xml.h

功能齐全的XML解析/生成类. 可以在Windows/WindowsCE下使用.亲自调试通过.

		XMLComment** GetComments();
		unsigned int GetCommentsNum();
		int AddComment(XMLComment*,int InsertBeforeElement);
		int AddComment(const char*,int);
		int RemoveComment(unsigned int i);
		int RemoveAllComments();

		// XMLCData
		XMLCData** GetCDatas();
		unsigned int GetCDatasNum();
		int AddCData(XMLCData*,int InsertBeforeElement);
		int AddCData(const char*,int);
		int RemoveCData(unsigned int i);
		int RemoveAllCDatas();


		int AddVariable(XMLVariable*);
		int AddVariable(const char*,const char*);
#ifdef XML_OPTIONAL_MIME
		int AddBinaryVariable(char*,char*,int);
#endif
		int FindVariable(XMLVariable*);
		int FindVariable(const char*  x);
		XMLVariable* FindVariableZ(XMLVariable*);
		XMLVariable* FindVariableZ(const char* x,bool ForceCreate = false,char* defnew = 0,bool Temp = false);
		int RemoveVariable(unsigned int i);
		int RemoveVariableAndKeep(unsigned int i,XMLVariable** vr);
		int RemoveAllVariables();
		int RemoveTemporalVariables(bool Deep = false);

		int AddContent(XMLContent* v,int InsertBeforeElement);
		int AddContent(const char*,int);
		int RemoveContent(unsigned int i);
		void RemoveAllContents();
		XMLContent** GetContents();
		unsigned int GetContentsNum();

		XMLElement* GetElementInSection(const char*);
		int XMLQuery(const char* expression,XMLElement** rv,unsigned int deep = 0xFFFFFFFF);

		XMLElement* GetParent();

		XMLElement** GetChildren();
		unsigned int GetChildrenNum();
		unsigned int GetAllChildren(XMLElement**,unsigned int deep = 0xFFFFFFFF);
		unsigned int GetAllChildrenNum(unsigned int deep = 0xFFFFFFFF);

		XMLVariable** GetVariables();
		unsigned int GetVariableNum();
		void Export(FILE* fp,int ShowAll,XML_SAVE_MODE SaveMode,XML_TARGET_MODE TargetMode = XML_TARGET_MODE_FILE,XMLHeader* hdr = 0,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0);
		void SetExportFormatting(XMLEXPORTFORMAT* xf);

		void SetElementName(const char*);
		size_t GetElementName(char*,int NoDecode = 0);
		size_t GetElementFullName(char*,int NoDecode = 0);
		size_t GetElementUniqueString(char*);

		void SetTemporal(bool);
		bool IsTemporal();

		int   GetType();
		static void Write16String(FILE* fp,const char* s);

	private:

		XMLElement(XMLElement&);
		unsigned __int64 param;
		char* el; // element name
		int type; // type, 0 element
		XMLElement* parent; // one
		XMLElement** children; // many
		XMLVariable** variables; // many
		XMLComment** comments; // many
		XMLContent** contents; // many;
		XMLCData** cdatas;
		unsigned int childrennum;
		unsigned int variablesnum;
		unsigned int commentsnum;
		unsigned int contentsnum;
		unsigned int cdatasnum;

		bool Temporal;

		Z<XMLBORROWELEMENT> BorrowedElements;
		unsigned int NumBorrowedElements;

		int SpaceForElement(unsigned int);
		int SpaceForVariable(unsigned int);
		int SpaceForComment(unsigned int);
		int SpaceForContent(unsigned int);
		int SpaceForCData(unsigned int);

		int TotalChildPointersAvailable;
		int TotalVariablePointersAvailable;
		int TotalCommentPointersAvailable;
		int TotalContentPointersAvailable;
		int TotalCDataPointersAvailable;
		XMLEXPORTFORMAT xfformat;

		static void printc(FILE* fp,XMLElement* root,int deep,int ShowAll,XML_SAVE_MODE SaveMode,XML_TARGET_MODE TargetMode);
		void SetParent(XMLElement*);


	};


class XMLVariable
	{
	public:

		XMLVariable(const char*,const char*,int NoDecode = 0,bool Temp = false);
		~XMLVariable();
		XMLVariable(XMLVariable&);
		XMLVariable& operator =(XMLVariable&);


		size_t MemoryUsage();
		void CompressMemory();
		bool IntegrityTest();
		int Compare(XMLVariable*);
		XMLElement* SetOwnerElement(XMLElement*);
		size_t GetName(char*,int NoDecode = 0);
		size_t GetValue(char*,int NoDecode = 0);
		int GetValueInt();
#ifdef _atoi64
		__int64 GetValueInt64();
#endif
		float GetValueFloat();
		void SetName(const char*,int NoDecode = 0);
		void SetValue(const char*,int NoDecode = 0);
		void SetValueInt(int);
		void SetValueInt64(__int64);
		void SetValueFloat(float);
		template <typename T> void SetValueX(T t,const char* fmt);
		template <typename T> T GetValueX(const char* fmt);
		XMLVariable* Duplicate();
		void Copy();
		XMLElement* GetOwnerElement();
		void SetTemporal(bool);
		bool IsTemporal();

#ifdef XML_OPTIONAL_MIME
		size_t GetBinaryValue(char*);
		size_t SetBinaryValue(char*,int);
#endif

	private:

		void Clear();
		char* vn;
		char* vv;
		XMLElement* owner;
		bool Temporal;


	};


class XMLHeader
	{
	public:

		// constructors/destructor
		XMLHeader(const char* ht);
		operator char*();
		size_t MemoryUsage();
		void CompressMemory();
		bool IntegrityTest();
		int Compare(XMLHeader*);
		void SetEncoding(const char*);
		XMLHeader* Duplicate();


		XMLHeader(XMLHeader&);
		XMLHeader& operator =(XMLHeader&);
		~XMLHeader();

		// XMLComment
		XMLComment** GetComments();
		unsigned int GetCommentsNum();
		int AddComment(XMLComment*,int pos);
		int RemoveComment(unsigned int i);
		int RemoveAllComments();
		int SpaceForComment(unsigned int);

		void Export(FILE* fp,int HeaderMode,XML_TARGET_MODE TargetMode = XML_TARGET_MODE_FILE,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0);

	private:

		void Clear();
		int TotalCommentPointersAvailable;
		char* hdr;
		unsigned int commentsnum;
		XMLComment** comments;
	};

class XMLComment
	{
	public:

		// constructors/destructor
		XMLComment(XMLElement* p,int ElementPosition,const char* ht);
		operator char*();
		void SetComment(const char* ht);
		size_t MemoryUsage();
		void CompressMemory();
		bool IntegrityTest();
		int Compare(XMLComment*);

		XMLComment(XMLComment&);
		XMLComment& operator =(XMLComment&);
		~XMLComment();

		XMLComment* Duplicate();
		void SetParent(XMLElement* p,int ep);
		int GetEP();

	private:

		XMLElement* parent;
		char* c;
		int ep; // Element Position (Before)
	};


class XMLContent
	{
	public:

		// constructors/destructor
		XMLContent(XMLElement* p,int ElementPosition,const char* ht,int NoDecode = 0);
		size_t GetValue(char*,int NoDecode = 0);
		void SetValue(const char*,int NoDecode = 0);
		size_t MemoryUsage();
		void CompressMemory();
		bool IntegrityTest();
		int Compare(XMLContent*);

		XMLContent(XMLContent&);
		XMLContent& operator =(XMLContent&);
		~XMLContent();

		XMLContent* Duplicate();
		void SetParent(XMLElement* p,int ep);
		int GetEP();

	private:

		XMLElement* parent;
		char* c;
		int ep; // Element Position (Before)
	};

class XMLCData
	{
	public:

		// constructors/destructor
		XMLCData(XMLElement* p,int ElementPosition,const char* ht);
		operator char*();
		void SetCData(const char* ht);
		size_t MemoryUsage();
		void CompressMemory();
		bool IntegrityTest();
		int Compare(XMLCData*);

		XMLCData(XMLCData&);
		XMLCData& operator =(XMLCData&);
		~XMLCData();

		XMLCData* Duplicate();
		void SetParent(XMLElement* p,int ep);
		int GetEP();

	private:

		XMLElement* parent;
		char* c;
		int ep; // Element Position (Before)
	};



// public functions
size_t XMLGetString(const char* section,const char* Tattr,const char* defv,char*out,const size_t maxlen,const char* xml,XML* af = 0);
int     XMLGetInt(const char* item,const char* attr,const int defv,const char* xml,XML* af = 0);
#ifdef _WIN32
__int64 XMLGetInt64(const char* item,const char* attr,const __int64 defv,const char* xml,XML* af = 0);
#endif
float   XMLGetFloat(const char* item,const char* attr,const float defv,const char* xml,XML* af = 0);
size_t     XMLGetBinaryData(const char* item,const char* attr,const char* defv,char*out,const size_t maxlen,const char* xml,XML* af = 0);

int    XMLSetString(const char* section,const char* Tattr,char*out,const char* xml,XML* af = 0);
int    XMLSetInt(const char* section,const char* attr,int v,const char* xml,XML* af = 0);
#ifdef _WIN32
int    XMLSetString(const char* section,const char* Tattr,wchar_t*out,const char* xml,XML* af = 0);
int    XMLSetInt64(const char* section,const char* attr,__int64 v,const char* xml,XML* af = 0);
#endif
int    XMLSetFloat(const char* section,const char* attr,float v,const char* xml,XML* af = 0);
int    XMLSetBinaryData(const char* section,const char* attr,char* data,int len,const char* xml,XML* af = 0);

int XMLRenameElement(const char* section,const char* newname,const char* xml,XML* af = 0);

#ifndef __SYMBIAN32__
#ifdef XML_USE_STL
int    XMLGetAllVariables(const char* section,vector<char*>* vnames,vector<char*>* vvalues,const char*xml);
int    XMLGetAllItems(const char* section,vector<char*>* vnames,const char*xml);
#else
int    XMLGetAllVariables(const char* section,char** vnames,char** vvalues,const char*xml);
int    XMLGetAllItems(const char* section,char** vnames,const char*xml);
#endif
#endif



// XMLTransform class

class XMLTransformData
	{
	public:
		XMLTransformData() {}
	};

class XMLTransform
	{
	public:

		XMLTransform(XMLTransformData*) { }
		virtual ~XMLTransform() {}
		virtual size_t Encrypt(const char*src,size_t srclen,int srctype,char* dst,size_t dstlen,XMLTransformData* data = 0) = 0;
		virtual size_t Decrypt(const char*src,size_t srclen,int srctype,char* dst,size_t dstlen,XMLTransformData* data = 0) = 0;

	};

class XMLHelper
	{
	public:

		// static functions
		static char* FindXMLClose(char* s);
		static XMLElement* ParseElementTree(XMLHeader* hdr,XMLElement* parent,char* tree,char** EndValue,XML_PARSE_STATUS& iParseStatus);
		static void AddBlankVariable(XMLElement* parent,char *a2,int Pos);
		static int pow(int P,int z);



	};

#ifdef XML_USE_NAMESPACE
};
#endif

inline wchar_t* UTF8ToWideChar(const char *pMBString)
{
	if (pMBString == NULL) 
	{
		return NULL;
	}

	int nSize = MultiByteToWideChar(CP_UTF8, 0, pMBString, -1, NULL, 0);
	if (nSize <= 0)
	{
		return NULL;
	}

	wchar_t *pRetString = new wchar_t[nSize + 1];
	if (pRetString == NULL)
	{
		return NULL;
	}

	ZeroMemory(pRetString, (nSize + 1)*sizeof(wchar_t));
	if (!(MultiByteToWideChar(CP_UTF8, 0, pMBString, -1, pRetString, nSize + 1) > 0))
	{
		delete [] pRetString;
		pRetString = NULL;
	}

	return pRetString;
}

inline wchar_t* CharToWideChar(const char* str)
{
	int nLength = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL,0);
	wchar_t *pw = new wchar_t[nLength];
	MultiByteToWideChar(CP_ACP, 0, str, -1, pw, nLength);
	return pw;
}

#endif // _XML_H