---

cppdom.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil c-basic-offset: 3 -*- */
// vim:cindent:ts=3:sw=3:et:tw=80:sta:
/*************************************************************** cppdom-cpr beg
 * 
 * cppdom was forked from the original xmlpp version 0.6 under the LGPL. This
 * new, branched xmlpp is under the same LGPL (of course) and is being
 * maintained by:
 *      Kevin Meinert   <subatomic@users.sourceforge.net>
 *      Allen Bierbaum  <allenb@users.sourceforge.net>
 *      Ben Scott       <nonchocoboy@users.sourceforge.net>
 *
 * -----------------------------------------------------------------
 *
 * xmlpp - an xml parser and validator written in C++
 * copyright (c) 2000-2001 Michael Fink
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: cppdom.h,v $
 * Date modified: $Date: 2003/01/03 03:06:47 $
 * Version:       $Revision: 1.52 $
 * -----------------------------------------------------------------
 *
 ************************************************************ cppdom-cpr-end */
// prevent multiple includes
#ifndef CPPDOM_CPPDOM_H
#define CPPDOM_CPPDOM_H

#ifdef _MSC_VER
   // disable 'identifier was truncated to 255 characters in debug information' warning
#  pragma warning(disable: 4786)

   // Visual Studio 7 has support for member templates.
#  if _MSC_VER < 1300
#     define CPPDOM_NO_MEMBER_TEMPLATES
#  endif
#endif

// needed includes
#include <string>
#include <sstream>
#include <list>
#include <map>
#include <iosfwd>
#include <fstream>
#include <iostream>
#include "config.h"
#include "shared_ptr.h"   // the boost::shared_ptr class

namespace cppdom
{
   enum XMLErrorCode
   {
      xml_unknown = 0,              
      xml_instream_error,           
      xml_opentag_expected,         
      xml_opentag_cdata_expected,   
      xml_closetag_expected,        
      xml_pi_doctype_expected,      
      xml_tagname_expected,         
      xml_closetag_slash_expected,  
      xml_tagname_close_mismatch,   
      xml_attr_equal_expected,      
      xml_attr_value_expected,      
      xml_save_invalid_nodetype,    
   // added by kevin for 0.7 compatibility...
      xml_filename_invalid,
      xml_file_access,

      xml_dummy                     
   };


   // classes

   class CPPDOM_API XMLError
   {
   public:
      XMLError(XMLErrorCode code);

      XMLErrorCode getError() const;

      void getStrError(std::string& error) const;

      std::string getString() const;

      std::string getInfo() const;

   protected:
      XMLErrorCode mErrorCode;
   };


   class CPPDOM_API XMLLocation
   {
   public:
      XMLLocation();

      int getLine() const;

      int getPos() const;

      void step(int chars = 1);

      void newline();

      void reset();

   protected:
      int mLine;
      int mPos;
   };


   // typedefs

   typedef int XMLTagNameHandle;
   typedef std::map<XMLTagNameHandle,std::string> XMLTagNameMap;
   typedef std::map<std::string,std::string> XMLEntityMap;
   typedef cppdom_boost::shared_ptr<class XMLContext> XMLContextPtr;
   typedef cppdom_boost::shared_ptr<class XMLEventHandler> XMLEventHandlerPtr;

   class CPPDOM_API XMLContext
   {
   public:
      XMLContext();
      virtual ~XMLContext();

      std::string getEntity(const std::string& entname);

      std::string getTagname(XMLTagNameHandle handle);

      XMLTagNameHandle insertTagname(const std::string& tagname);

      XMLLocation& getLocation();

      virtual void initContext();

      void setEventHandler(XMLEventHandlerPtr ehptr);

      XMLEventHandler& getEventHandler();

      bool handleEvents() const;

   protected:
      bool           mInit;               
      int            mNextHandle;         
      XMLTagNameMap  mTagNames;           
      XMLEntityMap   mEntities;           
      XMLLocation    mLocation;           
      bool           mHandleEvents;       
      XMLEventHandlerPtr mEventHandler;   
   };

   enum XMLNodeType
   {
      xml_nt_node,      
      xml_nt_leaf,      
      xml_nt_document,  
      xml_nt_cdata      
   };


   // typedefs
   typedef cppdom_boost::shared_ptr<class XMLNode> XMLNodePtr;

   typedef std::list<XMLNodePtr> XMLNodeList;
   typedef XMLNodeList::iterator XMLNodeListIterator;



   class CPPDOM_API XMLAttribute
   {
   public:
      XMLAttribute();
      XMLAttribute(const XMLAttribute& attr);
      XMLAttribute(const std::string& val);

#ifndef CPPDOM_NO_MEMBER_TEMPLATES
      template<class T>
      XMLAttribute(const T& val)
      {
         setValue<T>(val);
      }
#endif // ! CPPDOM_NO_MEMBER_TEMPLATES

      const std::string& getString() const;

#ifndef CPPDOM_NO_MEMBER_TEMPLATES

      template<class T>
      void setValue(const T& val)
      {
         std::ostringstream oss;
         oss << val;
         mData = oss.str();
      }

      template<class T>
      T getValue() const
      {
         T t;
         std::istringstream iss(mData);
         iss >> t;
         return t;
      }

      // Specializations of getValue<T> placed inline for Visual Studio 7.
      // MIPSpro and GCC do not handle this. They get out-of-line
      // specializations, found below.
#ifdef _MSC_VER

      template<>
      std::string getValue<std::string>() const
      {
         std::string value(mData);
         return value;
      }
#endif // ! _MSC_VER
#endif // ! CPPDOM_NO_MEMBER_TEMPLATES

      operator std::string() const;

   protected:
      std::string mData;
   };

#ifndef CPPDOM_NO_MEMBER_TEMPLATES
#ifndef _MSC_VER
   template<>
   inline std::string XMLAttribute::getValue<std::string>() const
   {
      std::string value(mData);
      return value;
   }
#endif // ! _MSC_VER
#endif // ! CPPDOM_NO_MEMBER_TEMPLATES


   class CPPDOM_API XMLAttributes: public std::map<std::string, std::string>
   {
      friend class XMLParser;
   public:
      XMLAttributes();

      std::string get(const std::string& key) const;

      void set(const std::string& key, const std::string& value);

      bool has(const std::string& key) const;
   };




   class CPPDOM_API XMLNode
   {
      friend class XMLParser;
   protected:
      XMLNode();

   public:
      explicit XMLNode(XMLContextPtr pctx);

      XMLNode(const XMLNode& node);
      ~XMLNode();

      XMLNode& operator=(const XMLNode& node);

      XMLNodeType getType() const;

      std::string getName();

      XMLAttributes& getAttrMap();

      XMLAttribute getAttribute(const std::string& name) const;

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

      const std::string& getCdata();

      void setType(XMLNodeType type);

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

      void setCdata(const std::string& cdata);

      void setAttribute(const std::string& attr, const XMLAttribute& value);

      void addChild(XMLNodePtr& node);
      bool removeChild(XMLNodePtr& node);
      bool removeChild(std::string& childName);
      bool removeChildren(std::string& childName);


      XMLNodeList& getChildren();

      XMLNodePtr getChild(const std::string& name);

      XMLNodeList getChildren(const std::string& name);

      XMLNodeList getChildren(const char* name);

      template<class Predicate>
      XMLNodeList getChildrenPred(Predicate pred)
      {
         XMLNodeList result(0);
         XMLNodeList::const_iterator iter;

         // search for all occurances of nodename and insert them into the new list
         for(iter = mNodeList.begin(); iter != mNodeList.end(); ++iter)
         {
            if (pred(*iter))
            {
               result.push_back(*iter);
            }
         }
         return result;
      }

      XMLNode* getParent() const;

      void load(std::istream& in, XMLContextPtr& context);

      void save(std::ostream& out, int indent=0);

      XMLContextPtr getContext();

   protected:
      XMLTagNameHandle  mNodeNameHandle;  
      XMLContextPtr     mContext;         
      XMLNodeType       mNodeType;        
      XMLAttributes     mAttributes;      
      std::string       mCdata;           
      XMLNodeList       mNodeList;        
      XMLNode*          mParent;          
   };


   class CPPDOM_API XMLDocument: public XMLNode
   {
      friend class XMLParser;
   public:
      XMLDocument();

      explicit XMLDocument(XMLContextPtr context);

      XMLNodeList& getPiList();

      XMLNodeList& getDtdList();

      void load(std::istream& in, XMLContextPtr& context);

      void save(std::ostream& out);

      void loadFile(const std::string& filename) throw(XMLError);

      void saveFile(const std::string& filename);


   protected:
      XMLNodeList mProcInstructions;

      XMLNodeList mDtdRules;
   };

   typedef cppdom_boost::shared_ptr<class XMLDocument> XMLDocumentPtr;


   class CPPDOM_API XMLEventHandler
   {
   public:
      XMLEventHandler() {}

      virtual ~XMLEventHandler() {}

      virtual void startDocument() {}

      virtual void endDocument() {}

      virtual void processingInstruction(XMLNode& pinode) {}

      virtual void startNode(const std::string& nodename) {}
      virtual void parsedAttributes(XMLAttributes& attr) {}
      virtual void endNode(XMLNode& node) {}

      virtual void gotCdata(const std::string& cdata) {}
   };
}

#endif

---