mi32/xml.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * \file xml.h <mi32/xml.h>
 * \brief Class wrappers around the libxml library
 *
 * \if NODOC
 * $Log: xml.h_v $
 * Revision 1.44  2011/11/18 15:45:18  mju
 * Add newChild and setProperty using double value with formatting.
 *
 * Revision 1.43  2011/07/21 20:51:48  mju
 * Add 64-bit getProperty also.
 *
 * Revision 1.42  2011/07/21 20:48:28  mju
 * Add getValue for 64-bit int.
 *
 * Revision 1.41  2007/03/12 16:22:22  dwilliss
 * Added GetElementsByTagName
 *
 * Revision 1.40  2007/03/05 16:38:48  dwilliss
 * Gave GetText an optional bool parameter to control whether or not it should
 * strip leading and trailing whitespace
 *
 * Revision 1.39  2007/01/11 15:11:15  mju
 * Add getValue methods.
 *
 * Revision 1.38  2007/01/10 22:30:19  mju
 * Add getProperty variants using reference for result so can test if have.
 *
 * Revision 1.37  2006/10/19 15:07:24  mju
 * Fwd declare filepath.
 *
 * Revision 1.36  2006/09/22 21:35:25  dwilliss
 * added GetContentXML methods to node
 *
 * Revision 1.35  2006/06/14 13:46:35  mju
 * Remove redundant hdr.
 *
 * Revision 1.34  2006/02/16 16:37:48  dwilliss
 * changed an ifdef to use a new define instead of a deprecated one
 *
 * Revision 1.33  2005/10/27 22:08:11  dwilliss
 * Added IsCDATA method
 *
 * Revision 1.32  2005/03/31 16:57:22  fileserver!dwilliss
 * Rename one of our types to MIUNICODE because it conflicted with a Microsoft #define
 *
 * Revision 1.31  2004/04/01 22:41:02  dwilliss
 * Almost got it working without needing to include contrib/libxml stuff, but
 * it's going to take more work.  Some stuff in libmi needs to be updated and
 * this isn't high enough priority to worry about it now.
 *
 * Revision 1.30  2004/03/29 21:28:04  dwilliss
 * *** empty log message ***
 *
 * Revision 1.29  2004/03/29 21:21:55  dwilliss
 * Added some methods to XMLSAX
 *
 * Revision 1.28  2004/03/11 23:02:11  dwilliss
 * *** empty log message ***
 *
 * Revision 1.27  2004/02/26 23:14:51  dwilliss
 * Added XMLSAX class
 *
 * Revision 1.26  2004/01/09 18:24:14  dwilliss
 * Unparse methods should be const
 *
 * Revision 1.25  2004/01/09 17:13:46  dwilliss
 * Added some STRUTF8 versions of methods
 *
 * Revision 1.24  2004/01/07 15:39:59  dwilliss
 * Added SetName and DeleteAllChildren methods to XMLNODE
 *
 * Revision 1.23  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.22  2003/09/03 16:39:53  mju
 * Have GetText return bool.
 *
 * Revision 1.21  2003/08/20 19:25:48  mju
 * Add FindNext and STRUTF8 versions of GetProperty/GetText.
 * Make both GetProperty methods return true if property found.
 * Remove pointer-returning versions of GetProperty/GetText.
 *
 * Revision 1.20  2003/06/27 21:06:26  dwilliss
 * Added AddEntity methods
 *
 * Revision 1.19  2003/06/27 20:46:01  dwilliss
 * Moved to misystem.dll and exported.  Can't have inlines anymore as a
 * result
 *
 * Revision 1.15  2002/09/19 15:39:54  dwilliss
 * Changed XMLDOC's copy constructor and assignment operator to be public
 * instead of private.  They are now implemented.
 *
 * Revision 1.13  2002/08/30 16:40:03  dwilliss
 * Added private, unimplemented copy constructors and assignment operators
 * XMLDOC could theoretically be copied, but until implemented it's better to
 * not allow it than to use default assignment/copy constructor.
 *
 * Revision 1.12  2002/08/30 16:27:36  dwilliss
 * Added Unparse methods
 *
 * Revision 1.11  2002/08/23 16:09:31  dwilliss
 * Added GetElementByAttribute method
 *
 * Revision 1.10  2002/08/19 15:43:37  dwilliss
 * Added some methods to node to get property values as bool and number with
 * defaults if they aren't defined
 *
 * Revision 1.9  2002/05/07 16:23:53  dwilliss
 * Added a NewChild method that copies a node
 *
 * Revision 1.8  2002/03/22 20:23:59  dwilliss
 * Added Read/Write HTML
 *
 * Revision 1.6  2002/02/15 20:45:14  dwilliss
 * Added WriteHTML methods
 *
 * Revision 1.5  2002/02/13 23:15:58  dwilliss
 * Added Attach/Detach/Delete/Replace methods
 *
 * Revision 1.4  2001/12/20 23:47:09  dwilliss
 * Added a Parse method
 *
 * Revision 1.3  2001/12/12 20:25:16  dwilliss
 * Read/Write methods take FILEPATH now
 *
 * Revision 1.1  2001/12/07 18:51:46  dwilliss
 * Initial revision
 * \endif
 ****************************************************************************/

#ifndef INC_MI32_XML_H
#define INC_MI32_XML_H

#if 1 || defined(MISYSTEMDLL)
// contrib headers only needed while compiling misystem -- eventually.
// For now, we still need them
#ifndef __XML_TREE_H__     // libxml's include guards, not ours
#include <libxml/tree.h>
#endif
#ifndef __XML_PARSER_H__
#include <libxml/parser.h>
#endif

#else

struct xmlSAXHandler;
struct _xmlNs;
struct _xmlNode;
struct _xmlDoc;
struct _xmlEntity;
typedef unsigned char xmlChar;
typedef _xmlDoc* xmlDocPtr;
typedef _xmlEntity* xmlEntityPtr;

#endif

#ifndef INC_MI32_MISTRING_H
#include <mi32/mistring.h>
#endif

#ifndef INC_MI32_SIMPLEAR_H
#include <mi32/simplear.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class STRUTF8;
#endif // GENERATING_DOXYGEN_OUTPUT

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef XML_CASE_SENSITIVE
#define XML_CASE_SENSITIVE true
#endif

class XMLDOC;
class FILE_RAW;
class FILEPATH;


class XMLNAMESPACE 
#if 1 || defined(MISYSTEMDLL)
 : public _xmlNs 
#endif
{
   public:
      const char* GetHREF() const { return (reinterpret_cast<const char*>(this->href)); }

      const char* GetPrefix() const { return (reinterpret_cast<const char*>(this->prefix)); }
      
      XMLNAMESPACE* Copy() { return (static_cast<XMLNAMESPACE*>(xmlCopyNamespace(this))); }

      void Free() { xmlFreeNs(this); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      XMLNAMESPACE();
      XMLNAMESPACE(const XMLNAMESPACE&);
      ~XMLNAMESPACE();

      friend struct _xmlNs;   
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class CLASSLIBEXPORT XMLNODE 
#if 1 || defined(MISYSTEMDLL)
: public _xmlNode 
#endif
{
   public:

      void AddComment (
         const MIUNICODE*
         );
      
      void AppendText (
         const MIUNICODE* text
         );

      void Attach (
         XMLNODE* parent
         );

      XMLNODE* Copy (
         bool recursive = true,
         XMLDOC* NewDoc = NULL
         ) const;

      void Delete ();

      void DeleteAllChildren();

      void Detach();
      
      XMLNODE* FindChild (
         const char *TagName           
         ) const;

      XMLNODE* FindChild (
         const char *TagName,          
         const char *PropertyName,     
         const MIUNICODE* PropertyValue
         ) const;

      XMLNODE* FindChild (
         const char *TagName,          
         const char *PropertyName,     
         const char *PropertyValue     
         ) const;

      XMLNODE* FindNext (
         const char *TagName = 0,      
         const char *PropName = 0,     
         const char *PropValue = 0     
         ) const;


      // Get the children of this node as an XML string
      bool GetContentXML (
         MISTRING& retstr,    
         bool bIncludeSelf,   
         bool bFormat = true, 
         int indent = 0       
         );

      // Get the children of this node as an XML string
      bool GetContentXML (
         STRUTF8& retstr,     
         bool bIncludeSelf,   
         bool bFormat = true, 
         int indent = 0       
         );

      XMLNODE* GetElementByAttribute (
         const char *AttributeName,
         const MIUNICODE* AttributeValue
         ) const;

      XMLNODE* GetElementByAttribute (
         const char *AttributeName,
         const char *AttributeValue
         ) const;

      bool GetElementsByTagName (
         SIMPLE_ARRAY<XMLNODE*>& Nodes,
         const char *TagName,
         bool bCaseSensitive = true
         ) const;

      XMLNODE* GetFirstChild (
         ) const;

      XMLNODE* GetLastChild ()  const;

      XMLNODE* GetParent ()  const;

      XMLNODE* GetPrevious () const;
      
      const char* GetName () const;

      XMLNODE* GetNext() const;

      bool GetProperty (
         const char *PropName,         
         MISTRING& str,
         bool bCaseSensitive = true
         ) const;

      bool GetProperty (
         const char *PropName,         
         STRUTF8& retstr,              
         bool bCaseSensitive = true
         ) const;

      bool GetProperty (
         const char *PropName,         
         bool& retvalue,               
         bool bCaseSensitive = true
         ) const;

      bool GetProperty (
         const char *PropName,         
         double& retvalue,             
         bool bCaseSensitive = true
         ) const;

      bool GetProperty (
         const char *PropName,         
         INT32& retvalue,              
         bool bCaseSensitive = true
         ) const;

      bool GetProperty (
         const char *PropName,         
         UINT32& retvalue,             
         bool bCaseSensitive = true
         ) const;

      bool GetProperty (
         const char *PropName,         
         INT64& retvalue,              
         bool bCaseSensitive = true
         ) const;

      bool GetProperty (
         const char *PropName,         
         UINT64& retvalue,             
         bool bCaseSensitive = true
         ) const;

      bool GetPropertyBool (
         const char *PropName,         
         bool dft = false,
         bool bCaseSensitive = true
         ) const;

      double GetPropertyNum (
         const char *PropName,         
         double dft = 0.0,
         bool bCaseSensitive = true
         ) const;

#if defined(MISYSTEMDLL)
      #ifndef GENERATING_DOXYGEN_OUTPUT
      // Note, these versions can go away once everything has been compiled
      // to expect the 2nd parameter with a default (any time after 12 Mar 07)
      
      bool GetText (
         MISTRING& str
         ) const;

      bool GetText (
         STRUTF8& str
         ) const;

      bool GetText (
         MISTRING& str,
         bool bPreserveLeadingAndTrailingWhitespace
         ) const;

      bool GetText (
         STRUTF8& str,
         bool bPreserveLeadingAndTrailingWhitespace
         ) const;
      #endif
#else
      bool GetText (
         MISTRING& str,
         bool bStripLeadingAndTrailingWhitespace = true
         ) const;

      bool GetText (
         STRUTF8& str,
         bool bStripLeadingAndTrailingWhitespace = true
         ) const;
#endif

      bool GetValue (
         bool& retvalue                
         ) const;

      bool GetValue (
         double& retvalue              
         ) const;

      bool GetValue (
         INT32& retvalue               
         ) const;

      bool GetValue (
         UINT32& retvalue              
         ) const;

      bool GetValue (
         INT64& retvalue               
         ) const;

      bool GetValue (
         UINT64& retvalue              
         ) const;

      bool HasProperty (
         const char* name, 
         bool bCaseSensitive=true
         ) const;

      bool IsCDATA() const;

      bool IsEmpty() const;

      bool IsText() const;

      XMLNODE* NewChild (
         const char *TagName,             
         XMLNAMESPACE *pNameSpace = 0
         );
         
      XMLNODE* NewChild (
         const char *TagName,             
         const MIUNICODE *value,
         XMLNAMESPACE *pNameSpace = 0
         );
         
      XMLNODE* NewChild (
         const char *TagName,             
         double value,
         MISTRING::FLOATFMT floatfmt = MISTRING::FLOATFMT_MaxPrecision,
         XMLNAMESPACE *pNameSpace = 0
         );
         
      XMLNODE* NewChild (
         const XMLNODE *NodeToCopy
         );

      XMLNODE* NewCDATAChild (
         const char *TagName,             
         const MIUNICODE *value,
         XMLNAMESPACE *pNameSpace = 0
         );

      XMLNODE* NewCDATAChild (
         const char *TagName,             
         const UINT8  *value,          
         int len = -1,                 
         XMLNAMESPACE *pNameSpace = 0
         );

      XMLNODE* NewTextChild (
         const char *TagName,             
         const MIUNICODE *value,
         XMLNAMESPACE *pNameSpace = 0
         );

      XMLNODE* NewTextChild (
         const char *TagName,             
         const char *value,            
         XMLNAMESPACE *pNameSpace = 0
         );

      void Replace (
         XMLNODE* NodeToReplace
         );

      void SetName(
         const char* name
         );

      void SetNamespace ( 
         XMLNAMESPACE *pNameSpace
         );

      void SetProperty (
         const char *PropName,         
         const MIUNICODE *value
         );

      void SetProperty (
         const char *PropName,         
         const char *value             
         );

      void SetProperty (
         const char *PropName,         
         double value,
         MISTRING::FLOATFMT floatfmt = MISTRING::FLOATFMT_MaxPrecision
         );

      void SetText (
         const MIUNICODE* text
         );

      void SetText (
         const char* text
         );

      void UnsetProperty (
         const char *PropName          
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      XMLNODE();
      XMLNODE(const XMLNODE&);
      ~XMLNODE();

      XMLNODE& operator= (
         const XMLNODE&
         );

      friend struct _xmlNode; // avoids warning about destructor being private

      bool GetElementsByTagNameSub (
         SIMPLE_ARRAY<XMLNODE*>& Nodes,
         const char *TagName,
         bool bCaseSensitive = true
         ) const;

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class CLASSLIBEXPORT XMLDOC {
   public:

      
      XMLDOC();

      XMLDOC (
         const MIUNICODE* xmlbuffer
         );

      XMLDOC (
         const UINT8* xmlbuffer
         );

      XMLDOC (
         const XMLDOC&
         );

      virtual ~XMLDOC();
      
      XMLDOC& operator= (
         const XMLDOC&
         );

      void AddEntity (
         const char* name, 
         const MIUNICODE* content
         );

      void AddEntity (
         const char* name, 
         MIUNICODE content
         );

      void Clear();

      const MISTRING& GetErrorMessage (
         ) const;

      ERRVALUE ReadHTML (
         const FILEPATH& filepath
         );

      ERRVALUE ReadHTML (
         const MIUNICODE* filename
         );

      ERRVALUE Read (
         const FILEPATH& filepath
         );

      ERRVALUE Read (
         const MIUNICODE* filename
         );

      ERRVALUE Parse (
         const UINT8* xmlbuffer
         );

      ERRVALUE ParseHTML (
         const UINT8* xmlbuffer
         );

      void SetCompression(
         int compression
         );

      void Unparse (
         MISTRING& string,
         bool bIndentTreeOutput = true
         ) const;

      void Unparse (
         STRUTF8& string,
         bool bIndentTreeOutput = true
         ) const;

      void UnparseHTML (
         MISTRING& string,
         bool bIndentTreeOutput = true
         ) const;

      void UnparseHTML (
         STRUTF8& string,
         bool bIndentTreeOutput = true
         ) const;

      ERRVALUE Write (
         const FILEPATH& filepath
         ) const;

      ERRVALUE Write (
         const MIUNICODE* filename
         ) const;

      ERRVALUE Write (
         FILE_RAW& file
         ) const;

      ERRVALUE WriteHTML (
         const FILEPATH& filepath
         ) const;

      ERRVALUE WriteHTML (
         const MIUNICODE* filename
         ) const;

      ERRVALUE WriteHTML (
         FILE_RAW& file
         ) const;

      xmlDocPtr* GetDocPtr() const;

      XMLNODE* GetRootNode (
         ) const;

      protected:
         virtual void OnDocReplaced();

      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         
         class ERRORTRAP {
            public:
               ERRORTRAP(XMLDOC*);
               ~ERRORTRAP();
            private:
               MISTRING& m_string;

               static void MyErrorFunc(void*, const char*, ...);
            };

         xmlDocPtr m_doc;
         MISTRING m_ErrorMessage;

         friend class XMLNODE;
         friend class ERRORTRAP;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };




class CLASSLIBEXPORT XMLSAX {
   public:

      struct ATTRIBUTE {
         const xmlChar* name;
         const xmlChar *value;
         };


      XMLSAX();
      virtual ~XMLSAX();

      ERRVALUE Parse (
         const FILEPATH& filepath
         );

      ERRVALUE Parse (
         const char* buffer,
         int size
         );

   private:

      virtual void v_StartDocument (); 

      virtual void v_EndDocument ();   

      virtual void v_CDATABlock (
         const xmlChar* data,
         int len
         );

      virtual void v_Characters (
         const xmlChar* ch,
         int len
         );

      virtual void v_Comment (
         const xmlChar* ch
         );

      virtual void v_IgnorableWhitespace (
         const xmlChar* ch,
         int len
         );

      virtual void v_StartElement (
         const xmlChar* name,
         const SIMPLE_ARRAY<ATTRIBUTE>& attributes
         );

      virtual void v_EndElement (
         const xmlChar* name
         );


#ifndef GENERATING_DOXYGEN_OUTPUT

      xmlSAXHandler* m_sax;
      SIMPLE_ARRAY<ATTRIBUTE>* m_attribs;
      MISTRING m_errormsg;

      // The following function names follow the naming convention of the
      // xmlSAXHandler members, not MicroImages convention.

      static void startDocument(void*);
      static void endDocument(void*);
      static void characters(void*, const xmlChar*, int);
      static void startElement(void*, const xmlChar*, const xmlChar**);
      static void endElement(void*, const xmlChar*);
      static xmlEntityPtr getEntity(void*, const xmlChar*);
      static void MyErrorFunc(void*, const char*, ...);
      static void cdataBlock(void*, const xmlChar*, int);
      static void comment(void*, const xmlChar*);
      static void ignorableWhitespace(void*, const xmlChar*, int);

#endif
   };



#undef CLASSLIBEXPORT

#endif
 

---