Line data    Source code

       1             : #ifndef RAPIDXML_UTILS_HPP_INCLUDED
       2             : #define RAPIDXML_UTILS_HPP_INCLUDED
       3             : 
       4             : // Copyright (C) 2006, 2009 Marcin Kalicinski
       5             : // Version 1.13
       6             : // Revision $DateTime: 2009/05/13 01:46:17 $
       7             : //! \file rapidxml_utils.hpp This file contains high-level rapidxml utilities that can be useful
       8             : //! in certain simple scenarios. They should probably not be used if maximizing performance is the main objective.
       9             : 
      10             : #include "rapidxml.hpp"
      11             : #include <vector>
      12             : #include <string>
      13             : #include <fstream>
      14             : #include <stdexcept>
      15             : 
      16             : namespace rapidxml
      17             : {
      18             : 
      19             :     //! Represents data loaded from a file
      20             :     template<class Ch = char>
      21           5 :     class file
      22             :     {
      23             :         
      24             :     public:
      25             :         
      26             :         //! Loads file into the memory. Data will be automatically destroyed by the destructor.
      27             :         //! \param filename Filename to load.
      28           5 :         file(const char *filename)
      29           5 :         {
      30             :             using namespace std;
      31             : 
      32             :             // Open stream
      33          10 :             basic_ifstream<Ch> stream(filename, ios::binary);
      34           5 :             if (!stream)
      35           0 :                 throw runtime_error(string("cannot open file ") + filename);
      36           5 :             stream.unsetf(ios::skipws);
      37             :             
      38             :             // Determine stream size
      39           5 :             stream.seekg(0, ios::end);
      40           5 :             size_t size = stream.tellg();
      41           5 :             stream.seekg(0);   
      42             :             
      43             :             // Load data and add terminating 0
      44           5 :             m_data.resize(size + 1);
      45           5 :             stream.read(&m_data.front(), static_cast<streamsize>(size));
      46           5 :             m_data[size] = 0;
      47           5 :         }
      48             : 
      49             :         //! Loads file into the memory. Data will be automatically destroyed by the destructor
      50             :         //! \param stream Stream to load from
      51             :         file(std::basic_istream<Ch> &stream)
      52             :         {
      53             :             using namespace std;
      54             : 
      55             :             // Load data and add terminating 0
      56             :             stream.unsetf(ios::skipws);
      57             :             m_data.assign(istreambuf_iterator<Ch>(stream), istreambuf_iterator<Ch>());
      58             :             if (stream.fail() || stream.bad())
      59             :                 throw runtime_error("error reading stream");
      60             :             m_data.push_back(0);
      61             :         }
      62             :         
      63             :         //! Gets file data.
      64             :         //! \return Pointer to data of file.
      65           5 :         Ch *data()
      66             :         {
      67           5 :             return &m_data.front();
      68             :         }
      69             : 
      70             :         //! Gets file data.
      71             :         //! \return Pointer to data of file.
      72             :         const Ch *data() const
      73             :         {
      74             :             return &m_data.front();
      75             :         }
      76             : 
      77             :         //! Gets file data size.
      78             :         //! \return Size of file data, in characters.
      79             :         std::size_t size() const
      80             :         {
      81             :             return m_data.size();
      82             :         }
      83             : 
      84             :     private:
      85             : 
      86             :         std::vector<Ch> m_data;   // File data
      87             : 
      88             :     };
      89             : 
      90             :     //! Counts children of node. Time complexity is O(n).
      91             :     //! \return Number of children of node
      92             :     template<class Ch>
      93             :     inline std::size_t count_children(xml_node<Ch> *node)
      94             :     {
      95             :         xml_node<Ch> *child = node->first_node();
      96             :         std::size_t count = 0;
      97             :         while (child)
      98             :         {
      99             :             ++count;
     100             :             child = child->next_sibling();
     101             :         }
     102             :         return count;
     103             :     }
     104             : 
     105             :     //! Counts attributes of node. Time complexity is O(n).
     106             :     //! \return Number of attributes of node
     107             :     template<class Ch>
     108             :     inline std::size_t count_attributes(xml_node<Ch> *node)
     109             :     {
     110             :         xml_attribute<Ch> *attr = node->first_attribute();
     111             :         std::size_t count = 0;
     112             :         while (attr)
     113             :         {
     114             :             ++count;
     115             :             attr = attr->next_attribute();
     116             :         }
     117             :         return count;
     118             :     }
     119             : 
     120             : }
     121             : 
     122             : #endif