/home/mhx/git/github/libmoost/include/moost/xml/simple_parser.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_XML_PARSER_H
#define MOOST_XML_PARSER_H

#include <map>
#include <string>
#include <fstream>
#include <vector>
#include <cctype> // for tolower
#include <stdexcept>
#include <algorithm>

#include <boost/shared_ptr.hpp>
#include  <boost/algorithm/string/case_conv.hpp>
#include <boost/lexical_cast.hpp>

namespace moost { namespace xml {

class simple_parser
{
public:

   struct tree_node
   {
      typedef std::vector< boost::shared_ptr<tree_node> > tree_branch_t;

      std::string    header; //< the header tag of the node
      std::string    value;  //< the value between the header tags
      tree_branch_t  leaves; //< a list of subnodes (if any)

      inline void leaves2map(std::map<std::string, std::string>& destMap) const;
   };

   typedef boost::shared_ptr<tree_node> shared_node_t;
   typedef tree_node::tree_branch_t     tree_branch_t;

public:

   inline void
      load(const std::string& fileName, bool makeLowercaseTags = false);

   inline const tree_branch_t&
      get_root() const { return m_root; }

private:

   inline void recursive_parse_tag( const std::string& header,
                                    std::istream& xmlFile,
                                    boost::shared_ptr<tree_node>& pCurrNode,
                                    bool makeLowercaseTags = false);

   inline bool parse_token( std::istream& xmlFile,
                            std::string& token, bool& isComment);

private:

   tree_branch_t m_root; //< the stored xml tree
};

// -----------------------------------------------------------------------------

void simple_parser::load(const std::string& fileName, bool makeLowercaseTags)
{
   std::ifstream xmlFile(fileName.c_str());

   if ( !xmlFile.is_open() )
      throw std::runtime_error("Cannot open file <" + fileName + ">!" );

   xmlFile.exceptions(std::ios::badbit);

   std::string tokenName;
   bool isComment;
   bool isInTag;
   for (;;)
   {
      isInTag = parse_token(xmlFile, tokenName, isComment);
      if ( xmlFile.eof() )
         break;

      if ( isInTag )
      {
         if ( isComment )
            continue;

         boost::shared_ptr<tree_node> pTmpMap(new tree_node());
         m_root.push_back(pTmpMap);

         recursive_parse_tag(tokenName, xmlFile, pTmpMap, makeLowercaseTags);
      }
   }
}

// -----------------------------------------------------------------------------

bool simple_parser::parse_token( std::istream& xmlFile,
                                 std::string& token, bool& isComment)
{
   token.clear();
   bool isInTag = false;
   isComment = false;
   char c = 0;

   for(;;)
   {
      c = xmlFile.get();
      if ( xmlFile.eof() )
         break;

      if ( isspace(c) && token.empty() )
         continue;

      if ( c == '<' && !isComment )
      {
         if ( !token.empty() ) // end of a in-token
         {
            xmlFile.putback(c);
            break;
         }

         isInTag = true;
         continue;
      }
      else if ( c == '>' )
      {
         if ( isComment )
         {
            if ( token.substr(token.size()-2,2) == "--" )
               break;
         }
         else
            break;
      }

      token.append(1, c);
      if ( token.size() == 3 && token == "!--" )
         isComment = true;
   }

   return isInTag;
}

// -----------------------------------------------------------------------------

void simple_parser::recursive_parse_tag( const std::string& header,
                                         std::istream& xmlFile,
                                         boost::shared_ptr<tree_node>& pCurrNode,
                                         bool makeLowercaseTags)
{
   pCurrNode->header = header;

   if ( makeLowercaseTags )
   {
      std::transform( pCurrNode->header.begin(), pCurrNode->header.end(),
                      pCurrNode->header.begin(), (int(*)(int)) std::tolower);
   }

   bool isInTag = false;
   bool isComment = false;

   std::string tokenName;
   std::string closeToken = "/" + header;

   for (;;)
   {
      isInTag = parse_token(xmlFile, tokenName, isComment);
      if ( xmlFile.eof() )
         throw std::runtime_error("EOF Before finding the right token!" );

      if ( isInTag )
      {
         if ( tokenName.empty() )
            continue;

         if ( isComment )
            continue;

         if ( tokenName == closeToken )
            return;

         if ( tokenName[0] == '/' )
            throw std::runtime_error("Cannot find closing token for <" + header + ">! Found <" + tokenName + "> instead!" );

         boost::shared_ptr<tree_node> pTmpMap(new tree_node());
         pCurrNode->leaves.push_back( pTmpMap );
         recursive_parse_tag(tokenName, xmlFile, pTmpMap, makeLowercaseTags);
      }
      else
         pCurrNode->value = tokenName;
   }

   throw std::runtime_error("simple_parser::recursive_parse_tag. Should never end here!");
}

// -----------------------------------------------------------------------------

void simple_parser::tree_node::leaves2map( std::map<std::string, std::string>& currentLevel ) const
{
   tree_branch_t::const_iterator leafIt;
   for ( leafIt = leaves.begin(); leafIt != leaves.end(); ++leafIt )
      currentLevel[(*leafIt)->header] = (*leafIt)->value;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------

template <typename T>
struct get_opt_detail
{
   static T lexical_cast(const std::string& val)
   {
      return boost::lexical_cast<T>(val);
   }
};

template <>
struct get_opt_detail<bool>
{
   static bool lexical_cast(const std::string& val)
   {
      if (val == "true")
         return true;
      if (val == "false")
         return false;
      return boost::lexical_cast<bool>(val);
   }
};

template <typename T>
static void get_opt( T& value,
                     const std::string& key,
                     const std::map<std::string, std::string>& optMap,
                     bool throwIfNotFound = true )
{
   std::string localKey = boost::to_lower_copy(key);
   std::map<std::string, std::string>::const_iterator f = optMap.find(localKey);
   if ( f == optMap.end() )
   {
      if ( throwIfNotFound )
         throw std::runtime_error("mandatory key <" + key + "> not found!");
   }
   else
   {
      try
      {
         value = get_opt_detail<T>::lexical_cast(f->second);
      }
      catch (const boost::bad_lexical_cast&)
      {
         throw std::runtime_error("bad cast for key <" + key + ">");
      }
   }
}

}}

// -----------------------------------------------------------------------------

#endif // MOOST_XML_PARSER_H