parser.hh

Go to the documentation of this file.

// Copyright (c) 2014, LAAS-CNRS
// Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
//
// This file is part of hpp-manipulation-urdf.
// hpp-manipulation-urdf is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation, either version
// 3 of the License, or (at your option) any later version.
//
// hpp-manipulation-urdf is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Lesser Public License for more details.  You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-manipulation-urdf. If not, see <http://www.gnu.org/licenses/>.

#ifndef HPP_MANIPULATION_PARSER_HH
# define HPP_MANIPULATION_PARSER_HH

# include <map>
# include <list>
# include <string>
# include <iostream>
# include <tinyxml.h>

# include <boost/function.hpp>

namespace hpp {
  namespace util {
    namespace parser {
      typedef TiXmlElement XMLElement;
      typedef TiXmlDocument XMLDocument;
      typedef TiXmlDeclaration XMLDeclaration;
      typedef TiXmlAttribute XMLAttribute;
      typedef TiXmlNode XMLNode;
      typedef TiXmlText XMLText;
      typedef TiXmlComment XMLComment;

      typedef TiXmlPrinter XMLPrinter;

      class RootFactory;



      class ObjectFactory {
        public:
          typedef std::list <ObjectFactory*> ObjectFactoryList;

          ObjectFactory (ObjectFactory* parent = NULL, const XMLElement* element = NULL);

      virtual ~ObjectFactory() {}

          virtual bool init ();

          void setAttribute (const XMLAttribute* attr);

          virtual void addTextChild (const XMLText* text);

          virtual bool finishAttributes ();

          virtual void finishTags ();

          virtual void finishFile ();



          ObjectFactory (const std::string& tagName, ObjectFactory* parent = NULL);

          void addAttribute (const std::string& name, const std::string& value);

          XMLNode* write (XMLNode* node) const;



          std::string tagName () const;

          std::string name () const;

          bool hasAttribute (const std::string& attr) const;

          std::string getAttribute (const std::string& attr) const;

          ObjectFactoryList getChildrenOfType (std::string type);

          bool getChildOfType (std::string type, ObjectFactory*& o);


          void name (const std::string& n);

          void name (const char* n);

          template <typename T> T* as ()
          {
            return static_cast <T*> (this);
          }

        protected:
          ObjectFactory (ObjectFactory* root);

          ObjectFactory* parent ();

          virtual ObjectFactory* root ();

          bool hasParent () const;

          const XMLElement* XMLelement ();

          virtual void impl_setAttribute (const XMLAttribute* attr);

          virtual void impl_write (XMLElement* element) const;

          void addChild (ObjectFactory* child);

          virtual std::ostream& print (std::ostream& os) const;

        private:
          ObjectFactory* parent_;
          ObjectFactory* root_;
          typedef std::map <std::string, ObjectFactoryList > ChildrenMap;
          ChildrenMap children_;

          const XMLElement* element_;

          typedef std::map <std::string, std::string> AttributeMap;
          AttributeMap attrMap_;
          std::string name_, tagName_;
          int id_;

          friend std::ostream& operator<< (std::ostream&, const ObjectFactory&);
      };

      template <typename T>
      ObjectFactory* create (ObjectFactory* parent = NULL, const XMLElement* element = NULL)
      {
        return new T (parent, element);
      }

      class Parser {
        public:
          typedef boost::function <ObjectFactory* (ObjectFactory*, const XMLElement*)>
                    FactoryType;

          Parser (FactoryType defaultFactory = create <ObjectFactory>);

          virtual ~Parser ();

          void addObjectFactory (const std::string& tagname, FactoryType factory);

          virtual void parse (const char* xmlString);

          virtual void parseFile (const std::string& filename);

          ObjectFactory* root () const;

        private:
          XMLDocument doc_;
          ObjectFactory* root_;

          bool checkError () const;

          void loadString (const char* xmlstring);

          void parse ();

          void parseElement (const XMLElement* element, ObjectFactory* parent);

          typedef std::map <std::string, FactoryType> ObjectFactoryMap;
          typedef std::pair <std::string, FactoryType> ObjectFactoryPair;
          typedef std::pair <ObjectFactoryMap::iterator, bool> ObjectFactoryInsertRet;
          ObjectFactoryMap objFactoryMap_;
          FactoryType defaultFactory_;

          typedef std::list <ObjectFactory*> ObjectFactoryList;
          ObjectFactoryList objectFactories_;

          std::ostream& print (std::ostream&) const;
          friend std::ostream& operator<< (std::ostream&, const Parser&);
      };

      std::ostream& operator<< (std::ostream&, const ObjectFactory&);
      std::ostream& operator<< (std::ostream&, const Parser&);
    } // namespace parser
  } // namespace manipulation
} // namespace hpp

#endif //  HPP_MANIPULATION_PARSER_HH