#ifndef XMLDOMNODE_ZZG_2008_12_08
#define XMLDOMNODE_ZZG_2008_12_08

#include <afx.h>
#include "msxml6.tlh"

#include <memory>
#include <vector>

#if ADS > 22
#define _THROW0()		throw ()
#endif

using namespace MSXML2;
template<class _Ty>
class _auto_ptr;
template<class _Ty>
struct _auto_ptr_ref
{	// proxy reference for auto_ptr copying
	_auto_ptr_ref(void *_Right)	: _Ref(_Right)
	{	// construct from generic pointer to auto_ptr ptr
	}
	void *_Ref;	// generic pointer to auto_ptr ptr
};
template<class _Ty>
class _auto_ptr
{	// wrap an object pointer to ensure destruction
public:
	typedef _Ty element_type;

	explicit _auto_ptr(_Ty *_Ptr = 0) _THROW0()
		: _Myptr(_Ptr)
	{	// construct from object pointer
	}
	_auto_ptr(_auto_ptr<_Ty>& _Right) _THROW0()
		: _Myptr(_Right.release())
	{	// construct by assuming pointer from _Right auto_ptr
	}

	_auto_ptr(_auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// construct by assuming pointer from _Right auto_ptr_ref
		_Ty **_Pptr = (_Ty **)_Right._Ref;
		_Ty *_Ptr = *_Pptr;
		*_Pptr = 0;	// release old
		_Myptr = _Ptr;	// reset this
	}

	template<class _Other>
	operator _auto_ptr<_Other>() _THROW0()
	{	// convert to compatible auto_ptr
		return (_auto_ptr<_Other>(*this));
	}

	template<class _Other>
	operator _auto_ptr_ref<_Other>() _THROW0()
	{	// convert to compatible auto_ptr_ref
		_Other *_Testptr = (_Ty *)_Myptr;	// test implicit conversion
		_auto_ptr_ref<_Other> _Ans(&_Myptr);
		return (_Testptr != 0 ? _Ans : _Ans);
	}

	template<class _Other>
	_auto_ptr<_Ty>& operator=(_auto_ptr<_Other>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	_auto_ptr<_Ty>& operator=(_auto_ptr<_Ty>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	_auto_ptr<_Ty>& operator=(_auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// assign compatible _Right._Ref (assume pointer)
		_Ty **_Pptr = (_Ty **)_Right._Ref;
		_Ty *_Ptr = *_Pptr;
		*_Pptr = 0;	// release old
		reset(_Ptr);	// set new
		return (*this);
	}

	~_auto_ptr()
	{	// destroy the object
		delete (_Ty *)_Myptr;
	}

	_Ty& operator*() const _THROW0()
	{	// return designated value

#if _HAS_ITERATOR_DEBUGGING
		if (_Myptr == 0)
			_DEBUG_ERROR("auto_ptr not dereferencable");
#endif /* _HAS_ITERATOR_DEBUGGING */
		return (*(_Ty *)_Myptr);
	}
	_Ty *operator->() const _THROW0()
	{	// return pointer to class object
		return (&**this);
	}
	_Ty *get() const _THROW0()
	{	// return wrapped pointer
		return ((_Ty *)_Myptr);
	}
	_Ty *release() _THROW0()
	{	// return wrapped pointer and give up ownership
		_Ty *_Tmp = (_Ty *)_Myptr;
		_Myptr = 0;
		return (_Tmp);
	}
	void reset(_Ty* _Ptr = 0)
	{	// destroy designated object and store new pointer
		if (_Ptr != _Myptr)
			delete (_Ty *)_Myptr;
		_Myptr = _Ptr;
	}
	bool isvalid() const
	{
		return get() ? true : false;
	}
private:
	const _Ty *_Myptr;	// the wrapped object pointer
};
class CXMLDOMNode;
class CXMLDOMNodes;
// 智能指针 指向:CXMLDOMNodePtr，CXMLDOMNodesPtr
//typedef std::auto_ptr<CXMLDOMNode> CXMLDOMNodePtr; // 
//typedef std::auto_ptr<CXMLDOMNodes> CXMLDOMNodesPtr;
typedef _auto_ptr<CXMLDOMNode> CXMLDOMNodePtr;
typedef _auto_ptr<CXMLDOMNodes> CXMLDOMNodesPtr;
#define RETURN_NULL CXMLDOMNodePtr pRetNode( new CXMLDOMNode( NULL ) );return pRetNode; 
#define NULLSTRING TEXT('\0')

#ifndef _tstof 
#ifdef UNICODE
#pragma message( "Unicode have been defined!")
inline double _wtof( const TCHAR *szBuffer )
{
	int nLenWC = _tcslen( szBuffer );
	int nLenMB =  WideCharToMultiByte( CP_ACP, 0, szBuffer, -1, NULL, 0, NULL, NULL );
	char* pMBString = new char[ nLenMB + 1 ];
	WideCharToMultiByte( CP_ACP, 0, szBuffer, nLenWC, pMBString, nLenMB, NULL, NULL );
	double dRet = atof( pMBString  );
	if( NULL != pMBString)
	{
		delete [] pMBString;
	}
	return dRet;
}
#define _tstof _wtof
#else
#pragma message( "Unicode have not been defined, yet!")
#define _tstof	atof
#endif // #ifdef UNICODE
#endif
//节点名数组:
typedef std::vector<TCHAR*> STRING_VECTOR;

#include "XMLDOMNodes.h"

//#pragma once
//#ifdef COMMON_EXPORT
//#define COMMON_EXP __declspec( dllexport )
//#else
//#define COMMON_EXP __declspec( dllimport )
//#endif
//xml节点 类
class TARCH_EXP CXMLDOMNode
{
	friend class CXMLDOMNodes;
public:
	CXMLDOMNode( void );
	CXMLDOMNode( const CXMLDOMNode& srcXMLDOMNode );
	CXMLDOMNode( MSXML2::IXMLDOMNodePtr pXMLDOMNode );
	~CXMLDOMNode();
	//操作符重载
	CXMLDOMNode& operator= ( const CXMLDOMNode& srcXMLDOMNode );
	CXMLDOMNodePtr operator= (  CXMLDOMNodePtr psrcXMLDOMNode );
	bool operator== ( const CXMLDOMNode& srcXMLDOMNode );
	bool operator!= ( const CXMLDOMNode& srcXMLDOMNode );
	friend bool operator== ( const CXMLDOMNodePtr& pXMLDOMNode1, const CXMLDOMNodePtr& pXMLDOMNode2 );
	friend bool operator!= ( const CXMLDOMNodePtr& pXMLDOMNode1, const CXMLDOMNodePtr& pXMLDOMNode2 );
	friend bool operator!= (  const CXMLDOMNodePtr& pXMLDOMNode2, const TCHAR* pNULL );
	friend bool operator!= ( const TCHAR* pNULL, const CXMLDOMNodePtr& pXMLDOMNode2 );
	friend bool operator== (  const CXMLDOMNodePtr& pXMLDOMNode2, const TCHAR* pNULL );
	friend bool operator== ( const TCHAR* pNULL, const CXMLDOMNodePtr& pXMLDOMNode2 );
public:
	int GetCurNodeLevel();
	//得到当前节点所在文档的根节点
	CXMLDOMNodePtr GetRoot( void );
	bool IsRootNode(const CXMLDOMNodePtr &pXMLDOMNodePtr);
	//判断当前节点是否有子节点.
	bool HasChildNodes(); 
	//判断当前节点指定的子节点是否存在
	bool IsChildNodeExist( const TCHAR* szChildNodeName );
	//判断当前节点指定的子节点是否存在如果找到则返回该节点指针.
	bool IsChildNodeExist( const TCHAR* szChildNodeName, CXMLDOMNodePtr& pGetXMLDOMNode);
	//判断当前节点的有指定值的指定子节点是否存在.
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szChildNodeValue );
	//判断当前节点的有指定值的指定子节点是否存在并返回该节点指针
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szChildNodeValue,
								CXMLDOMNodePtr& pGetXMLDOMNode);
	//判断当前节点的有指定整型值的指定子节点是否存在并返回该节点指针
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const int& nChildNodeValue,
							CXMLDOMNodePtr& pGetXMLDOMNode);
	//判断当前节点的有字符串属性值的指定子节点是否存在
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
								const TCHAR* szAttributeValue );
	//判断当前节点的有字符串属性值的指定子节点是否存在并返回该节点指针
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
							const TCHAR* szAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode);
	//判断当前节点的有双精度属性值的指定子节点是否存在
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
								const double& dAttributeValue );
	//判断当前节点的有双精度属性值的指定子节点是否存在并返回该节点指针
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
							const double& dAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode);
	//判断当前节点的有整型属性值的指定子节点是否存在
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
							const int& nAttributeValue );
	//判断当前节点的有整形属性值的指定子节点是否存在并返回该节点指针
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
							const int& nAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode);
	//判断当前节点的有布尔型属性值的指定子节点是否存在
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
							const bool& bAttributeValue );
	//判断当前节点的有布尔型属性值的指定子节点是否存在并返回该节点指针
	bool IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
						const bool& bAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode);

	//根据节点名字得到当前节点的子节点
	CXMLDOMNodePtr GetChildNode( const TCHAR* pszNodeName );
	//根据设定的条件得到当前节点的子节点
	CXMLDOMNodePtr GetChildNodeByPath( const TCHAR* pszXPath );
	//根据节点名子得到当前节点的子节点
	CXMLDOMNodesPtr GetChildrenNodes( const TCHAR* pszNodeName );
	//得到当前节点的父节点
	CXMLDOMNodePtr GetParentNode();
	//得到当前节点的第一个子节点
	CXMLDOMNodePtr GetFirstChildNode(); 
	//得到当前节点的最后一个子节点
	CXMLDOMNodePtr GetLastChildNode();
	//得到当前节点的第一个兄弟节点
	CXMLDOMNodePtr GetFirstSiblingNode();
	//得到当前节点的下一个兄弟节点
	CXMLDOMNodePtr GetNextSiblingNode();
	//得到当前节点的前一个兄弟节点
	CXMLDOMNodePtr GetPrevSiblingNode();
	//得到当前节点的最后一个兄弟节点
	CXMLDOMNodePtr GetLastSiblingNode();

	//得到当前节点的标记名字; 
	TCHAR* GetNodeName( void );
	//得到当前节点的标记名字.
	bool GetNodeName( TCHAR* szGetName);
	//克隆当前节点（bIsDeepClone指定是否也递归的克隆该节点下的所有子节点 true 是 false 否）
	bool CloneNode( CXMLDOMNodePtr& pGetClonedNodeRoot, bool bIsDeepClone = true );
	//在当前节点前插入节点
	bool InsertBefore( const CXMLDOMNodePtr& pInNode );
	//在当前节点前插入节点并返回该插入节点的指针
	bool InsertBefore( const CXMLDOMNodePtr& pInNode, CXMLDOMNodePtr& pGetInsertedNode );
	//在当前节点之后插入节点.
	bool InsertAfter( const CXMLDOMNodePtr& pInNode );
	//在当前节点值后插入节点并返回该插入节点的指针
	bool InsertAfter( const CXMLDOMNodePtr& pInNode, CXMLDOMNodePtr& pGetInsertedNode);
	//把当前节点的子节点添加到当前位置
	bool AppendNode( const CXMLDOMNodePtr& pInNode );
	//把当前节点的子节点添加到当前位置并返回该添加节点的指针
	bool AppendNode( const CXMLDOMNodePtr& pInNode, CXMLDOMNodePtr& pGetAppendedNode);
	//添加当前节点的子节点并设置该节点的值或属性（属性值为字符串）是否设置默认缩进
	CXMLDOMNodePtr AppendNodeEx( const TCHAR* szNodeName,const TCHAR* szNodeValue = TEXT(""),
		const TCHAR* szAttributeName = TEXT(""),
		const TCHAR* szAttributeValue = TEXT(""));
	//添加当前节点的子节点并设置该节点的值或属性（属性值为字符串）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue = TEXT(""),
								const TCHAR* szAttributeName = TEXT(""),
								const TCHAR* szAttributeValue = TEXT(""));
	//添加当前节点的子节点并设置该节点的值或属性（多个属性）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName,const CStringArray &arystrAttributeName,
								const CStringArray &arystrAttributeValue, 
								const TCHAR* szNodeValue = TEXT(""));
	//添加当前节点的子节点并设置该节点的值或属性（属性值为双精度）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue = TEXT(""),
								const TCHAR* szAttributeName = TEXT(""),
								const double&  dAttributeValue = 0.0 );
	//添加当前节点的子节点并设置该节点的值或属性（属性值为整形）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue = TEXT(""), 
							const TCHAR* szAttributeName = TEXT(""), 
							const int&  nAttributeValue = 0 );
	//添加当前节点的子节点并设置该节点的值或属性（属性值为布尔）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue = TEXT(""),
								const TCHAR* szAttributeName = TEXT(""), 
								const bool&  bAttributeValue = false );

	//添加当前节点的子节点并设置该节点的值或属性（节点值为双精度）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName, const double& dNodeValue = 0.0 , 
							const TCHAR* szAttributeName = TEXT(""), 
							const TCHAR* szAttributeValue = TEXT("")  );
	//添加当前节点的子节点并设置该节点的值或属性（节点值为整形）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName, const int& nNodeValue = 0 , 
							const TCHAR* szAttributeName = TEXT(""),
							const TCHAR* szAttributeValue = TEXT("")  );
	//添加当前节点的子节点并设置该节点的值或属性（节点值为布尔）
	CXMLDOMNodePtr AppendNode( const TCHAR* szNodeName, const bool& bNodeValue = false , 
							const TCHAR* szAttributeName = TEXT(""),
							const TCHAR* szAttributeValue = TEXT("")  );

	//删除当前节点及其子节点.
	bool DeleteNode();
	//删除当前节点的所有子节点但保留当前节点
	bool DeleteChildrenNodes();
	//根据索引值返回当前节点的属性名
	TCHAR* GetAttributeName( int nIndex = 0 );
	//根据索引值返回当前节点的属性名
	bool GetAttributeName( TCHAR* szGetAttrName, int nIndex = 0 );
	//指定的属性名或字符串值在当前节点中是否存在 当szAttributeValue为空时只判断属性名
	bool IsAttributeExist( const TCHAR* szAttributeName, const TCHAR* szAttributeValue = NULL );
	//指定的属性名或双精度值在当前节点中是否存在
	bool IsAttributeExist( const TCHAR* szAttributeName,  const double& dAttributeValue );
	//指定的属性名或整形值在当前节点中是否存在
	bool IsAttributeExist( const TCHAR* szAttributeName,  const int& nAttributeValue );
	//指定的属性名或布尔值在当前节点中是否存在
	bool IsAttributeExist( const TCHAR* szAttributeName,  const bool& bAttributeValue ); 

	//得到当前节点属性数量
	long GetAttributeNum();
	//根据当前节点属性名得到字符串属性值
	TCHAR* GetAttributeValue( const TCHAR* szAttributeName );
	//根据当前节点属性名得到字符串属性值
	bool GetAttributeValue( const TCHAR* szAttributeName, TCHAR* szGetAttributeValue);
	//将属性值转化为双精度.
	double GetAttributeValueToDouble( const TCHAR* szAttributeName );
	//将属性值转化为整形.
	int GetAttributeValueToInt( const TCHAR* szAttributeName );
	//将属性值转化为布尔.
	bool GetAttributeValueToBool( const TCHAR* szAttributeName );

	//根据当前节点属性名设置节点字符串属性值
	bool SetAttributeValue( const TCHAR* szAttributeName, const TCHAR* szAttributeValue );
	//根据当前节点属性名设置节点双精度属性值
	bool SetAttributeValue( const TCHAR* szAttributeName, const double& dAttributeValue );
	//根据当前节点属性名设置节点整形属性值
	bool SetAttributeValue( const TCHAR* szAttributeName, const int& nAttributeValue );
	//根据当前节点属性名设置节点长整形属性值	
	bool SetAttributeValue( const TCHAR* szAttributeName, const long& lAttributeValue );
	//根据当前节点属性名设置节点布尔属性值 
	bool SetAttributeValue( const TCHAR* szAttributeName, const bool& bAttributeValue );
	//根据属性名删除属性
	bool DelAttributeNode( const TCHAR* pszAttributeTagName );


	//从当前的叶子节点中取出字符串值
	TCHAR* GetNodeValue();
	//把该值转化为双精度
	double GetNodeValueToDouble();
	//把该值转化为整形
	int GetNodeValueToInt();
	//把该值转化为布尔
	bool GetNodeValueToBool();
	//设置当前叶子节点的字符串值
	bool SetNodeValue( const TCHAR* szNewNodeValue );
	//设置当前叶子节点的双精度值
	bool SetNodeValue( const double& dNewNodeValue );
	//设置当前叶子节点的整形值
	bool SetNodeValue( const int& nNewNodeValue );
	//设置当前叶子节点的布尔值
	bool SetNodeValue( const bool& bNewNodeValue );
	//给当前节点添加回车和空格符
	bool SetNodeTabValue(const TCHAR* pTabValue);
	//从当前叶子节点删除值
	bool DeleteNodeValue();
	//得到当前节点的兄弟节点个数
	int GetSiblingCount();
	// 解析设置调件为节点名字:
	bool _ParseXPath( const TCHAR* szXPath, STRING_VECTOR& szVectNodeName);
	MSXML2::IXMLDOMNodePtr GetNodePtr() {return m_pXMLDOMNode;} 
private:
	//得到当前节点的值（当前节点必须为叶子节点）
	TCHAR* _GetValue();
	//得到当前节点的值（当前节点必须为叶子节点）
	bool _GetValue( TCHAR* szGetValue);
	//设置当前节点的值（当前节点必须为叶子节点）
	bool _SetValue( const TCHAR* szSetValue );
	//把双精度转换为字符串:
	TCHAR* _DoubleToString( const double& dToBeConvert );
	// 把 _variant_t 转换为字符串:
	TCHAR* _VariantToString( const _variant_t& var );
protected:	
	MSXML2::IXMLDOMNodePtr   m_pXMLDOMNode;
};
#endif