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 <hpp/manipulation/fwd.hh>

namespace hpp {
  namespace manipulation {
    namespace parser {
      typedef TiXmlElement XMLElement;
      typedef TiXmlDocument XMLDocument;
      typedef TiXmlAttribute XMLAttribute;
      typedef TiXmlNode XMLNode;
      typedef TiXmlText XMLText;

      class RootFactory;



      class ObjectFactory {
        public:
          typedef std::vector <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 ();



          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 ()
          {
            if (!dynamic_cast <T*> (this)) {
              std::ostringstream oss;
              oss << "Unexpected tag: " << this->tagName ();
              throw std::invalid_argument (oss.str ().c_str ());
            }
            return static_cast <T*> (this);
          }

        protected:
          ObjectFactory (RootFactory* root);

          ObjectFactory* parent ();

          RootFactory* root ();

          bool hasParent () const;

          const XMLElement* XMLelement ();

          virtual void impl_setAttribute (const XMLAttribute* attr);

          void addChild (ObjectFactory* child);

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

        private:
          ObjectFactory* parent_;
          RootFactory* 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_;
          int id_;

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

      class RootFactory : public ObjectFactory {
        public:
    virtual ~RootFactory () {}
          RootFactory (const DevicePtr_t dev = DevicePtr_t ());

          DevicePtr_t device () const;

          inline std::string prependPrefix (const std::string& in) const
          {
            if (prefix_.empty ()) return in;
            return prefix_ + in;
          }

          inline std::string removePrefix (const std::string& in) const
          {
            if (prefix_.empty ()) return in;
            assert (in.compare (0, prefix_.size (), prefix_) == 0);
            return in.substr (prefix_.size ());
          }

          void prefix (const std::string& prefix)
          {
            if (prefix.empty ()) return;
            prefix_ = prefix + "/";
          }

        private:
          DevicePtr_t device_;
          std::string prefix_;
      };


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

      class Parser {
        public:
          typedef ObjectFactory* (*FactoryType) (ObjectFactory*, const XMLElement*);
          typedef ObjectFactory::ObjectFactoryList ObjectFactoryList;

          Parser (bool fillWithDefaultFactories = true, FactoryType defaultFactory = create <ObjectFactory>);

          ~Parser ();

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

          void parseString (const std::string& xmlString, DevicePtr_t robot);

          void parseFile (const std::string& filename, DevicePtr_t robot);

          const ObjectFactoryList& objectFactories () const
          {
            return objectFactories_;
          }

          void prefix (const std::string& prefix)
          {
            prefix_ = prefix;
          }

        private:
          XMLDocument doc_;
          RootFactory* root_;
          DevicePtr_t device_;

          void loadFile (const char* filename);

          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_;

          ObjectFactoryList objectFactories_;

          std::string prefix_;

          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