envi-code/SourceCode/Code2026/tg_shs/shs_utility/XMLDOMNode.cpp

#include "stdafx.h"
#include "XMLDOMNode.h"
#include <assert.h>

CXMLDOMNode::CXMLDOMNode(void)
{
	m_pXMLDOMNode = NULL;
}

CXMLDOMNode::CXMLDOMNode( const CXMLDOMNode& srcXMLDOMNode )
{
	//assert( NULL != srcXMLDOMNode.m_pXMLDOMNode );
	m_pXMLDOMNode = srcXMLDOMNode.m_pXMLDOMNode;
}

CXMLDOMNode::CXMLDOMNode( MSXML2::IXMLDOMNodePtr pXMLDOMNode )
{
	
	m_pXMLDOMNode = pXMLDOMNode;
}

CXMLDOMNode& CXMLDOMNode::operator= ( const CXMLDOMNode& srcXMLDOMNode )
{
	if( this == &srcXMLDOMNode ) { return *this; }
	m_pXMLDOMNode = srcXMLDOMNode.m_pXMLDOMNode;
	return *this;
}
CXMLDOMNodePtr CXMLDOMNode::operator= (  CXMLDOMNodePtr psrcXMLDOMNode )
{
	m_pXMLDOMNode = psrcXMLDOMNode->m_pXMLDOMNode;
	return psrcXMLDOMNode;
}
bool CXMLDOMNode::operator== ( const CXMLDOMNode& srcXMLDOMNode )
{
	return ( m_pXMLDOMNode == srcXMLDOMNode.m_pXMLDOMNode );
}
bool CXMLDOMNode::operator!= ( const CXMLDOMNode& srcXMLDOMNode )
{
	return ( m_pXMLDOMNode != srcXMLDOMNode.m_pXMLDOMNode );
}
//CXMLDOMNodePtr 等号重载:
bool operator==  ( const CXMLDOMNodePtr& pXMLDOMNode1, const CXMLDOMNodePtr& pXMLDOMNode2 )
{
	return ( *pXMLDOMNode1.get() == *pXMLDOMNode2.get() ); 
}
//CXMLDOMNodePtr 不等号重载:
bool operator!=  ( const CXMLDOMNodePtr& pXMLDOMNode1, const CXMLDOMNodePtr& pXMLDOMNode2 )
{
	return ( *pXMLDOMNode1.get() != *pXMLDOMNode2.get() ); 
}

// 判断是否为空.
bool operator!= (  const CXMLDOMNodePtr& pXMLDOMNode2, const TCHAR* pNULL )
{
	//assert( NULL == pNULL);
	return( NULL != pXMLDOMNode2.get()->GetNodePtr() );
}
//  判断是否为空.
bool operator!= ( const TCHAR* pNULL, const CXMLDOMNodePtr& pXMLDOMNode2 )
{
	//assert( NULL == pNULL); 
	return(  NULL != pXMLDOMNode2.get()->GetNodePtr() );
}
// 判断是否为空
bool operator== (  const CXMLDOMNodePtr& pXMLDOMNode2, const TCHAR* pNULL )
{
	//assert( NULL == pNULL);
	return( NULL == pXMLDOMNode2.get()->GetNodePtr());
}
// 判断是否为空.
bool operator== ( const TCHAR* pNULL, const CXMLDOMNodePtr& pXMLDOMNode2 )
{
	//assert( NULL == pNULL);
	return( NULL == pXMLDOMNode2.get()->GetNodePtr() );
}
CXMLDOMNode::~CXMLDOMNode()
{
	if( NULL != m_pXMLDOMNode )
	{
		m_pXMLDOMNode.Release();
	}
	m_pXMLDOMNode = NULL;
}

bool CXMLDOMNode::HasChildNodes()
{
	//assert( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::DOMNodeType			NodeType;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	bool bHasChildNodes = false;
	HRESULT hr; 
	try
	{
		hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		//assert( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return false;
		}
		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i];
			hr = pXMLDOMNode->get_nodeType( &NodeType );
			//assert( SUCCEEDED( hr ) );
			if( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
			if( NodeType == MSXML2::NODE_ELEMENT )
			{
				bHasChildNodes = true;
				break;
			}
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}
		//assert( false );
		return false;
	}
	if( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}
	return bHasChildNodes;
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName )
{
	//assert( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	if( ! HasChildNodes() )
	{
		return false;
	}
	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	bool bIsExist = false;
	HRESULT hr ;
	try
	{
		hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		//assert( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return false;
		}
		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i];
			TCHAR szCurrentChildNodeName[MAX_PATH];
			memset( szCurrentChildNodeName, 0, sizeof( szCurrentChildNodeName ) );
			_tcscpy( szCurrentChildNodeName, ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName() );
			//assert( NULL != szCurrentChildNodeName );
			if( NULL == szCurrentChildNodeName )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}
#ifdef _DEBUG
			TCHAR szDebugString[MAX_PATH];
			memset( szDebugString, 0, sizeof( szDebugString ) );
			_stprintf( szDebugString, TEXT("\ncurrent node is: %s( =? %s )\n "), ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName(), szChildNodeName );
			OutputDebugString( szDebugString );
#endif	
			if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) // Exist
			{
				bIsExist = true;
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				break;
			}
			if( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}
		//assert( false );
		return false;
	}
	if( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}
	return bIsExist;
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, CXMLDOMNodePtr& pGetXMLDOMNode)
{
	//assert( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	if( ! HasChildNodes() )
	{
		return false;
	}


	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	bool bIsExist = false;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		//assert( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return false;
		}

		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i];
			TCHAR szCurrentChildNodeName[MAX_PATH];
			memset( szCurrentChildNodeName, 0, sizeof( szCurrentChildNodeName ) );
			_tcscpy( szCurrentChildNodeName, ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName() );
			//assert( NULL != szCurrentChildNodeName );
			if( NULL == szCurrentChildNodeName )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}

#ifdef _DEBUG
			TCHAR szDebugString[MAX_PATH];
			memset( szDebugString, 0, sizeof( szDebugString ) );
			_stprintf( szDebugString, TEXT("\ncurrent node is: %s( =? %s )\n "), ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName(), szChildNodeName );
			OutputDebugString( szDebugString );
#endif	
			if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) 
			{
				CXMLDOMNodePtr pTempXMLDOMNode= new CXMLDOMNode();
				ASSERT( NULL != pTempXMLDOMNode.get() );
				if( NULL != pTempXMLDOMNode.get() )
				{
					pTempXMLDOMNode->m_pXMLDOMNode = pXMLDOMNode;
				}
				pGetXMLDOMNode = pTempXMLDOMNode;
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				bIsExist = true;
				break;
			}
			if( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}
		ASSERT( false );
		return false;	
	}

	if( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}
	return bIsExist;
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szChildNodeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	if( ! HasChildNodes() )
	{
		return false;
	}
	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	bool bIsExist = false;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return false;
		}
		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i] ;
			TCHAR szCurrentChildNodeName[MAX_PATH];
			memset( szCurrentChildNodeName, 0, sizeof( szCurrentChildNodeName ) );
			_tcscpy( szCurrentChildNodeName, ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName() );
			ASSERT( NULL != szCurrentChildNodeName );
			if( NULL == szCurrentChildNodeName )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}
			TCHAR szCurrentChildNodeValue[MAX_PATH];
			memset( szCurrentChildNodeValue, 0, sizeof( szCurrentChildNodeValue ) );
			BSTR bstr = NULL;
			HRESULT hr = pXMLDOMNode->get_text( &bstr );
			ASSERT( SUCCEEDED(hr) );
			if( FAILED ( hr ) )
			{
				continue;
			}
			_tcscpy( szCurrentChildNodeValue, ( TCHAR* )( _bstr_t) bstr);
			if( NULL != bstr )
			{
				SysFreeString(bstr);
				bstr = NULL;
			}
			if( NULL == szCurrentChildNodeValue )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}

#ifdef _DEBUG
			TCHAR szDebugString[MAX_PATH];
			memset( szDebugString, 0, sizeof( szDebugString ) );
			_stprintf( szDebugString, TEXT("\ncurrent node is: %s( =? %s ) --node value is: %s( =? %s) \n " ), szCurrentChildNodeName, szChildNodeName, szCurrentChildNodeValue, szChildNodeValue );
			OutputDebugString( szDebugString );
#endif	
			if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) 
			{
				if( 0 == _tcscmp( szCurrentChildNodeValue, szChildNodeValue ) )
				{
#ifdef _DEBUG
					OutputDebugString( TEXT("\n<Exist>\n") );
#endif
					bIsExist = true;
					break;
				}

			}
			if ( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if ( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if ( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}
		ASSERT( false );
		return false;	
	}
	if ( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if ( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}
	return bIsExist;	
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName,
								   const TCHAR* szChildNodeValue,
								   CXMLDOMNodePtr& pGetXMLDOMNode)
{

	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	if( ! HasChildNodes() )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	bool bIsExist = false;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return false;
		}
		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i] ;
			TCHAR szCurrentChildNodeName[MAX_PATH];
			memset( szCurrentChildNodeName, 0, sizeof( szCurrentChildNodeName ) );
			_tcscpy( szCurrentChildNodeName, ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName() );
			ASSERT( NULL != szCurrentChildNodeName );
			if( NULL == szCurrentChildNodeName )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}
			TCHAR szCurrentChildNodeValue[MAX_PATH];
			memset( szCurrentChildNodeValue, 0, sizeof( szCurrentChildNodeValue ) );
			BSTR bstr = NULL;
			HRESULT hr = pXMLDOMNode->get_text( &bstr );
			ASSERT( SUCCEEDED(hr) );
			if( FAILED ( hr ) )
			{
				continue;
			}
			_tcscpy( szCurrentChildNodeValue, ( TCHAR* )( _bstr_t) bstr);
			if( NULL != bstr )
			{
				SysFreeString(bstr);
				bstr = NULL;
			}
			if( NULL == szCurrentChildNodeValue )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}

#ifdef _DEBUG
			TCHAR szDebugString[MAX_PATH];
			memset( szDebugString, 0, sizeof( szDebugString ) );
			_stprintf( szDebugString, TEXT( "\ncurrent node is: %s( =? %s ) --node value is: %s( =? %s) \n " ), szCurrentChildNodeName, szChildNodeName, szCurrentChildNodeValue, szChildNodeValue );
			OutputDebugString( szDebugString );
#endif	
			if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) 
			{
				if( 0 == _tcscmp( szCurrentChildNodeValue, szChildNodeValue ) )
				{
#ifdef _DEBUG
					OutputDebugString( TEXT("\n<Exist>\n") );
#endif
					if( NULL != pGetXMLDOMNode.get() )
					{
						pGetXMLDOMNode.release();
					}

					CXMLDOMNodePtr pTempXMLDOMNode( new CXMLDOMNode() );
					ASSERT( NULL != pTempXMLDOMNode.get() );
					if( NULL != pTempXMLDOMNode.get() )
					{
						pTempXMLDOMNode->m_pXMLDOMNode = pXMLDOMNode;
					}
					pGetXMLDOMNode = pTempXMLDOMNode;

					bIsExist = true;
					break;
				}

			}
			if ( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if ( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if ( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}

		ASSERT( false );
		return false;	

	}
	if ( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if ( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}
	return bIsExist;	
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const int& nChildNodeValue,
								   CXMLDOMNodePtr& pGetXMLDOMNode  )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	const int nBase = 10; 
	TCHAR szChildNodeValue[ MAX_PATH ];
	memset( szChildNodeValue, 0, sizeof( szChildNodeValue ) );
	_itot( nChildNodeValue, szChildNodeValue, nBase );
	ASSERT( NULL != szChildNodeValue );
	if( NULL == szChildNodeValue )
	{
		return NULL;
	}

	return IsChildNodeExist(  szChildNodeName, szChildNodeValue, pGetXMLDOMNode  );

}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
								   const TCHAR* szAttributeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	if( ! HasChildNodes() )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	bool bIsExist = false;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return false;
		}

		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i];

			TCHAR szCurrentChildNodeName[MAX_PATH];
			memset( szCurrentChildNodeName, 0, sizeof( szCurrentChildNodeName ) );
			_tcscpy( szCurrentChildNodeName, ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName() );
			ASSERT( NULL != szCurrentChildNodeName );
			if( NULL == szCurrentChildNodeName )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}
#ifdef _DEBUG
			TCHAR szDebugString[MAX_PATH];
			memset( szDebugString, 0, sizeof( szDebugString ) );
			_stprintf( szDebugString, TEXT( "\ncurrent node is: %s( =? %s )\n " ), ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName(), szChildNodeName );
			OutputDebugString( szDebugString );
#endif	
			
			if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) 
			{
				//////////////////////////////////////////////////////////////////////////
				MSXML2::IXMLDOMElementPtr pXMLDOMElement = NULL;
				pXMLDOMElement = static_cast< MSXML2::IXMLDOMElementPtr >( pXMLDOMNode );
				TCHAR szCurrentChildAttributeValue[MAX_PATH];
				memset( szCurrentChildAttributeValue, 0, sizeof( szCurrentChildAttributeValue ) );
				_variant_t vt = pXMLDOMElement->getAttribute( _bstr_t( szAttributeName ) );
				_tcscpy( szCurrentChildAttributeValue, _VariantToString( vt ) );
				ASSERT( NULL != szCurrentChildAttributeValue );
				if( NULL == szCurrentChildAttributeValue )
				{
					if( NULL != pXMLDOMNode )
					{
						pXMLDOMNode.Release();
						pXMLDOMNode = NULL;
					}
					continue;
				}
				
				if( _tcslen( szCurrentChildAttributeValue ) > 0 )
				{
#ifdef _DEBUG
					TCHAR szDebugString[MAX_PATH];
					memset( szDebugString, 0, sizeof( szDebugString ) );
					_stprintf( szDebugString, TEXT( "\ncurrent attibute is: %s( =? %s )\n " ), szCurrentChildAttributeValue, szAttributeValue );
					OutputDebugString( szDebugString );
#endif			
					if( 0 == _tcscmp( szCurrentChildAttributeValue, szAttributeValue ) )
					{
						bIsExist = true;
						if( NULL != pXMLDOMElement )
						{
							pXMLDOMElement.Release();
							pXMLDOMElement = NULL;
						}
#ifdef _DEBUG
						OutputDebugString( TEXT( "\n<Exist>\n") );
#endif
						break;
					}
				}

				if( NULL != pXMLDOMElement )
				{
					pXMLDOMElement.Release();
					pXMLDOMElement = NULL;
				}
				//////////////////////////////////////////////////////////////////////////


			} // End if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) 

			if ( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
		} // End for( int i = 0; i < pXMLDOMNodeList->length; i++ )

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if ( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if ( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}

		ASSERT( false );
		return false;	
	}

	if ( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if ( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}

	return bIsExist;
}



bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
								   const TCHAR* szAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	// Have no child return.
	if( ! HasChildNodes() )
	{
		return false;
	}

	// Get child node list.
	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	bool bIsExist = false;
	HRESULT hr;
	try
	{
		/*HRESULT*/ hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return false;
		}

		// Travel the child node list and search for specific attribute value.
		//bool bIsExist = false;
		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i];

			// Get node name.
			TCHAR szCurrentChildNodeName[MAX_PATH];
			memset( szCurrentChildNodeName, 0, sizeof( szCurrentChildNodeName ) );
			_tcscpy( szCurrentChildNodeName, ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName() );
			ASSERT( NULL != szCurrentChildNodeName );
			if( NULL == szCurrentChildNodeName )
			{
				if( NULL != pXMLDOMNode )
				{
					pXMLDOMNode.Release();
					pXMLDOMNode = NULL;
				}
				continue;
			}
#ifdef _DEBUG
			TCHAR szDebugString[MAX_PATH];
			memset( szDebugString, 0, sizeof( szDebugString ) );
			_stprintf( szDebugString, TEXT( "\ncurrent node is: %s( =? %s )\n " ), ( TCHAR* )( _bstr_t )pXMLDOMNode->GetnodeName(), szChildNodeName );
			OutputDebugString( szDebugString );
#endif	
			// Specific node name Exist.
			if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) 
			{
				// Judge whether attribute value equal to the specific attribute value.
				//////////////////////////////////////////////////////////////////////////
				MSXML2::IXMLDOMElementPtr pXMLDOMElement = NULL;
				pXMLDOMElement = static_cast< MSXML2::IXMLDOMElementPtr >( pXMLDOMNode );
				TCHAR szCurrentChildAttributeValue[MAX_PATH];
				memset( szCurrentChildAttributeValue, 0, sizeof( szCurrentChildAttributeValue ) );
				_variant_t vt = pXMLDOMElement->getAttribute( _bstr_t( szAttributeName ) );
				_tcscpy( szCurrentChildAttributeValue, _VariantToString( vt ) );
				ASSERT( NULL != szCurrentChildAttributeValue );
				if( NULL == szCurrentChildAttributeValue )
				{
					if( NULL != pXMLDOMNode )
					{
						pXMLDOMNode.Release();
						pXMLDOMNode = NULL;
					}
					continue;
				}
				// Attribute Exist.
				if( _tcslen( szCurrentChildAttributeValue ) > 0 )
				{
#ifdef _DEBUG
					TCHAR szDebugString[MAX_PATH];
					memset( szDebugString, 0, sizeof( szDebugString ) );
					_stprintf( szDebugString, TEXT( "\ncurrent attibute is: %s( =? %s )\n " ), szCurrentChildAttributeValue, szAttributeValue );
					OutputDebugString( szDebugString );
#endif			
					// Exist and equal.
					if( 0 == _tcscmp( szCurrentChildAttributeValue, szAttributeValue ) )
					{
#ifdef _DEBUG
						OutputDebugString( TEXT( "\n<Exist>\n" ) );
#endif	
						CXMLDOMNodePtr pTempXMLDOMNode( new CXMLDOMNode() );
						assert( NULL != pTempXMLDOMNode.get() );
						if( NULL != pTempXMLDOMNode.get() )
						{
							pTempXMLDOMNode->m_pXMLDOMNode = pXMLDOMNode;
						}
						pGetXMLDOMNode = pTempXMLDOMNode;

						if( NULL != pXMLDOMElement )
						{
							pXMLDOMElement.Release();
							pXMLDOMElement = NULL;
						}

						bIsExist = true;

						break;
					}
				}

				if( NULL != pXMLDOMElement )
				{
					pXMLDOMElement.Release();
					pXMLDOMElement = NULL;
				}
				//////////////////////////////////////////////////////////////////////////


			} // End if( 0 == _tcscmp( szCurrentChildNodeName, szChildNodeName ) ) 

			if ( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
		} // End for( int i = 0; i < pXMLDOMNodeList->length; i++ )

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if ( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if ( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}

		ASSERT( false );
		return false;	
	}


	if ( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if ( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}

	return bIsExist;
}


bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
								   const double& dAttributeValue )
{

	ASSERT( NULL != szChildNodeName );
	if( NULL == szChildNodeName )
	{
		return false;	
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_tcscpy( szAttributeValue, _DoubleToString( dAttributeValue ) );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}
	return IsChildNodeExist( szChildNodeName, szAttributeName, szAttributeValue );
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName,
								   const double& dAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode  )
{
	ASSERT( NULL != szChildNodeName );
	if( NULL == szChildNodeName )
	{
		return false;	
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_tcscpy( szAttributeValue, _DoubleToString( dAttributeValue ) );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}
	return IsChildNodeExist( szChildNodeName, szAttributeName, szAttributeValue, pGetXMLDOMNode );
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
								   const int& nAttributeValue )
{
	ASSERT( NULL != szChildNodeName );
	if( NULL == szChildNodeName )
	{
		return false;	
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	const int nBase = 10; // Converting base value. 
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_itot( nAttributeValue, szAttributeValue, nBase );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}
	return IsChildNodeExist( szChildNodeName, szAttributeName, szAttributeValue );
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
								   const int& nAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode)
{
	ASSERT( NULL != szChildNodeName );
	if( NULL == szChildNodeName )
	{
		return false;	
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	const int nBase = 10; // Converting base value. 
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_itot( nAttributeValue, szAttributeValue, nBase );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}
	return IsChildNodeExist( szChildNodeName, szAttributeName, szAttributeValue, pGetXMLDOMNode );
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
								   const bool& bAttributeValue )
{
	ASSERT( NULL != szChildNodeName );
	if( NULL == szChildNodeName )
	{
		return false;	
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	return IsChildNodeExist( szChildNodeName, szAttributeName, ( int )bAttributeValue );
}

bool CXMLDOMNode::IsChildNodeExist( const TCHAR* szChildNodeName, const TCHAR* szAttributeName, 
								   const bool& bAttributeValue, CXMLDOMNodePtr& pGetXMLDOMNode)
{
	ASSERT( NULL != szChildNodeName );
	if( NULL == szChildNodeName )
	{
		return false;	
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	return IsChildNodeExist( szChildNodeName, szAttributeName, ( int )bAttributeValue, pGetXMLDOMNode );
}

CXMLDOMNodePtr CXMLDOMNode::GetChildNode( const TCHAR* pszNodeName )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMNodePtr pIChildNode = NULL;
	try
	{
		pIChildNode = m_pXMLDOMNode->selectSingleNode( _bstr_t( (TCHAR*) pszNodeName ) );
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIChildNode )
		{
			pIChildNode.Release();
			pIChildNode = NULL;
		}
		ASSERT( false );
		RETURN_NULL;
	}


	CXMLDOMNodePtr pCRetChild( new CXMLDOMNode( pIChildNode ) );

	ASSERT( NULL != pCRetChild.get() );

	if( NULL != pIChildNode )
	{
		pIChildNode.Release();
		pIChildNode = NULL;
	}
	return pCRetChild;
}

CXMLDOMNodePtr CXMLDOMNode::GetChildNodeByPath( const TCHAR* pszXPath )
{	
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	// Get rid off the '/' at first:
	TCHAR pszNodeName[MAX_PATH], *p ;
	memset( pszNodeName, 0, sizeof( pszNodeName ) );
	_tcscpy( pszNodeName, pszXPath );
	if( pszNodeName[0] == TEXT( '/' ) )
	{
		p = &pszNodeName[1];
		_tcscpy( pszNodeName, p );
		p = NULL;
	}

	MSXML2::IXMLDOMNodePtr pIChildNode = NULL;
	try
	{
		pIChildNode = m_pXMLDOMNode->selectSingleNode( _bstr_t( (TCHAR*) pszNodeName ) );
		assert( NULL != pIChildNode );
		if( NULL == pIChildNode )
		{
			RETURN_NULL;
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pIChildNode )
		{
			pIChildNode.Release();
			pIChildNode = NULL;
		}
		ASSERT( false );
		RETURN_NULL;
	}

	CXMLDOMNodePtr pCRetChild( new CXMLDOMNode( pIChildNode ) );
	ASSERT( NULL != pCRetChild.get() );

	if( NULL != pIChildNode )
	{
		pIChildNode.Release();
		pIChildNode = NULL;
	}
	return pCRetChild;
}

CXMLDOMNodesPtr CXMLDOMNode::GetChildrenNodes( const TCHAR* pszNodeName )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURNLIST_NULL;	
	}

	MSXML2::IXMLDOMNodeListPtr pXMLDOMNodeList = NULL;
	HRESULT hr;
	try
	{
		/*HRESULT */hr = m_pXMLDOMNode->get_childNodes( &pXMLDOMNodeList );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURNLIST_NULL;	
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}
		ASSERT( false );
		RETURNLIST_NULL;
	}

	CXMLDOMNodesPtr pRetXMLDOMNodes( new CXMLDOMNodes( pXMLDOMNodeList ) );
	if( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}

	return pRetXMLDOMNodes;
}


CXMLDOMNodePtr CXMLDOMNode::GetParentNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL  == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
	try
	{
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		//assert( NULL != pIXMLDOMParent );
		if( NULL == pIXMLDOMParent )
		{
			RETURN_NULL;	
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}
		ASSERT( false );
		RETURN_NULL;
	}

	CXMLDOMNodePtr pRetParent( new CXMLDOMNode( pIXMLDOMParent ) );
	ASSERT( NULL != pRetParent.get() );
	if( NULL == pRetParent.get() )
	{
		RETURN_NULL;	
	}

	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}

	return pRetParent;
}

CXMLDOMNodePtr CXMLDOMNode::GetFirstChildNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMFirstChild = NULL;
	MSXML2::DOMNodeType NodeType;
	HRESULT hr;
	try
	{
		pIXMLDOMFirstChild = m_pXMLDOMNode->GetfirstChild();
		ASSERT( NULL != pIXMLDOMFirstChild );
		if( NULL == pIXMLDOMFirstChild )
		{
			RETURN_NULL;	
		}

		// filter the node.
		//MSXML2::DOMNodeType NodeType;
		hr = pIXMLDOMFirstChild->get_nodeType( &NodeType );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		while( NodeType != MSXML2::NODE_ELEMENT )
		{
			pIXMLDOMFirstChild = pIXMLDOMFirstChild->GetnextSibling(); // m_pXMLDOMNode
			hr = pIXMLDOMFirstChild->get_nodeType( &NodeType );
			ASSERT( SUCCEEDED( hr ) );
			if( FAILED( hr ) )
			{
				RETURN_NULL;	
			}
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pIXMLDOMFirstChild )
		{
			pIXMLDOMFirstChild.Release();
			pIXMLDOMFirstChild = NULL;
		}	

		ASSERT( false );
		RETURN_NULL;	
	}


	CXMLDOMNodePtr pRetFirstChild( new CXMLDOMNode( pIXMLDOMFirstChild ) );
	ASSERT( NULL != pRetFirstChild.get() );
	if( NULL == pRetFirstChild.get() )
	{
		RETURN_NULL;	
	}

	if( NULL != pIXMLDOMFirstChild )
	{
		pIXMLDOMFirstChild.Release();
		pIXMLDOMFirstChild = NULL;
	}

	return pRetFirstChild;
}

CXMLDOMNodePtr CXMLDOMNode::GetFirstSiblingNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
	CXMLDOMNodePtr pFirstSibling;
	try
	{
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		ASSERT( NULL != pIXMLDOMParent );
		if( NULL == pIXMLDOMParent )
		{
			RETURN_NULL;	
		}

		CXMLDOMNodePtr pParent( new CXMLDOMNode( pIXMLDOMParent ) );
		ASSERT( NULL != pParent.get() );
		if( NULL == pParent.get() )
		{
			RETURN_NULL;	
		}

		/*CXMLDOMNodePtr*/ pFirstSibling = pParent->GetFirstChildNode();
		ASSERT( NULL != pFirstSibling.get() );
		if( NULL == pFirstSibling.get() )
		{
			RETURN_NULL;	
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}

		ASSERT( false );
		RETURN_NULL;	
	}

	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}

	return pFirstSibling;

}

CXMLDOMNodePtr CXMLDOMNode::GetNextSiblingNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMNextSibling = NULL;
	MSXML2::DOMNodeType NodeType;
	HRESULT hr;
	try
	{
		pIXMLDOMNextSibling = m_pXMLDOMNode->GetnextSibling();
		ASSERT( NULL != pIXMLDOMNextSibling );
		if( NULL == pIXMLDOMNextSibling )
		{
			RETURN_NULL;	
		}

		// filter the node.
		//MSXML2::DOMNodeType NodeType;
		hr = pIXMLDOMNextSibling->get_nodeType( &NodeType );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		while( NodeType != MSXML2::NODE_ELEMENT )
		{
			pIXMLDOMNextSibling = pIXMLDOMNextSibling->GetnextSibling(); // m_pXMLDOMNode
			hr = pIXMLDOMNextSibling->get_nodeType( &NodeType );
			ASSERT( SUCCEEDED( hr ) );
			if( FAILED( hr ) )
			{
				RETURN_NULL;	
			}
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMNextSibling )
		{
			pIXMLDOMNextSibling.Release();
			pIXMLDOMNextSibling = NULL;
		}
		ASSERT( false );
		RETURN_NULL;	
	}


	CXMLDOMNodePtr pRetNextSibling( new CXMLDOMNode( pIXMLDOMNextSibling ) );
	ASSERT( NULL != pRetNextSibling.get() );
	if( NULL == pRetNextSibling.get() )
	{
		RETURN_NULL;	
	}

	if( NULL != pIXMLDOMNextSibling )
	{
		pIXMLDOMNextSibling.Release();
		pIXMLDOMNextSibling = NULL;
	}

	return pRetNextSibling;
}
CXMLDOMNodePtr CXMLDOMNode::GetPrevSiblingNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}


	MSXML2::IXMLDOMNodePtr pIXMLDOMPrevSibling = NULL;
	MSXML2::DOMNodeType NodeType;
	HRESULT hr;
	try
	{
		pIXMLDOMPrevSibling = m_pXMLDOMNode->GetpreviousSibling();
		ASSERT( NULL != pIXMLDOMPrevSibling );
		if( NULL == pIXMLDOMPrevSibling )
		{
			RETURN_NULL;	
		}

		// filter the node.
		//MSXML2::DOMNodeType NodeType;
		/*HRESULT*/ hr = pIXMLDOMPrevSibling->get_nodeType( &NodeType );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		while( NodeType != MSXML2::NODE_ELEMENT )
		{
			pIXMLDOMPrevSibling = pIXMLDOMPrevSibling->GetpreviousSibling(); // m_pXMLDOMNode
			hr = pIXMLDOMPrevSibling->get_nodeType( &NodeType );
			ASSERT( SUCCEEDED( hr ) );
			if( FAILED( hr ) )
			{
				RETURN_NULL;	
			}
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMPrevSibling )
		{
			pIXMLDOMPrevSibling.Release();
			pIXMLDOMPrevSibling = NULL;
		}
		ASSERT( false );
		RETURN_NULL;	
	}


	CXMLDOMNodePtr pRetPrevSibling( new CXMLDOMNode( pIXMLDOMPrevSibling ) );
	ASSERT( NULL != pRetPrevSibling.get() );
	if( NULL == pRetPrevSibling.get() )
	{
		RETURN_NULL;	
	}

	if( NULL != pIXMLDOMPrevSibling )
	{
		pIXMLDOMPrevSibling.Release();
		pIXMLDOMPrevSibling = NULL;
	}

	return pRetPrevSibling;
}

CXMLDOMNodePtr CXMLDOMNode::GetLastSiblingNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
	CXMLDOMNodePtr pLastSibling;
	try
	{
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		ASSERT( NULL != pIXMLDOMParent );
		if( NULL == pIXMLDOMParent )
		{
			RETURN_NULL;	
		}

		CXMLDOMNodePtr pParent( new CXMLDOMNode( pIXMLDOMParent ) );
		ASSERT( NULL != pParent.get() );
		if( NULL == pParent.get() )
		{
			RETURN_NULL;	
		}

		/*CXMLDOMNodePtr*/ pLastSibling = pParent->GetLastChildNode();
		ASSERT( NULL != pLastSibling.get() );
		if( NULL == pLastSibling.get() )
		{
			RETURN_NULL;	
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}
		ASSERT( false );
		RETURN_NULL;	
	}


	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}


	return pLastSibling;
}

CXMLDOMNodePtr CXMLDOMNode::GetLastChildNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}


	MSXML2::IXMLDOMNodePtr pIXMLDOMLastChild = NULL;
	MSXML2::DOMNodeType NodeType;
	HRESULT hr;
	try
	{
		pIXMLDOMLastChild  = m_pXMLDOMNode->GetlastChild();
		ASSERT( NULL != pIXMLDOMLastChild  );
		if( NULL == pIXMLDOMLastChild  )
		{
			RETURN_NULL;	
		}

		// filter the node.
		//MSXML2::DOMNodeType NodeType;
		hr = pIXMLDOMLastChild ->get_nodeType( &NodeType );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		while( NodeType != MSXML2::NODE_ELEMENT )
		{
			pIXMLDOMLastChild = pIXMLDOMLastChild->GetpreviousSibling(); 
			//cout << " cout:" << pIXMLDOMLastChild->GetnodeName() << endl;
			hr = pIXMLDOMLastChild->get_nodeType( &NodeType );
			ASSERT( SUCCEEDED( hr ) );
			if( FAILED( hr ) )
			{
				RETURN_NULL;	
			}
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pIXMLDOMLastChild )
		{
			pIXMLDOMLastChild.Release();
			pIXMLDOMLastChild = NULL;
		}

		ASSERT( false );
		RETURN_NULL;
	}

	CXMLDOMNodePtr pRetLastChild( new CXMLDOMNode( pIXMLDOMLastChild ) );
	ASSERT( NULL != pRetLastChild.get() );
	if( NULL == pRetLastChild.get() )
	{
		RETURN_NULL;	
	}

	if( NULL != pIXMLDOMLastChild )
	{
		pIXMLDOMLastChild.Release();
		pIXMLDOMLastChild = NULL;
	}

	return pRetLastChild;

}

TCHAR* CXMLDOMNode::GetNodeName()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return NULL;
	}


	BSTR bstr = NULL;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_nodeName( &bstr );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			return NULL;
		}
	}
	catch( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != bstr )
		{
			SysFreeString(bstr);
			bstr = NULL;
		}

		ASSERT( false );
		return NULL;
	}
	static TCHAR szGetName[MAX_PATH];
	memset( szGetName, 0, sizeof( szGetName ) );
	_tcscpy( szGetName, (TCHAR*)(_bstr_t)( bstr ) );
	static TCHAR* szRetName = NULL;
	szRetName = szGetName;

	if( NULL != bstr )
	{
		SysFreeString(bstr);
		bstr = NULL;
	}

	return szRetName;
}

bool CXMLDOMNode::GetNodeName( TCHAR* szGetName)
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	BSTR bstr = NULL;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_nodeName( &bstr );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			return false;
		}
	}
	catch(...)
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != bstr )
		{
			SysFreeString(bstr);
			bstr = NULL;
		}

		ASSERT( false );
		return false;
	}
	_tcscpy( szGetName, (TCHAR*)(_bstr_t)(bstr) );

	if( NULL != bstr )
	{
		SysFreeString(bstr);
		bstr = NULL;
	}

	return true;
}

bool CXMLDOMNode::CloneNode( CXMLDOMNodePtr& pGetClonedNodeRoot , bool bIsDeepClone)
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	VARIANT_BOOL vb;
	if( bIsDeepClone )
	{
		vb = VARIANT_TRUE;	
	}
	else
	{
		vb = VARIANT_FALSE;
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMCloneNode = NULL;
	try
	{
		pIXMLDOMCloneNode = m_pXMLDOMNode->cloneNode( ( VARIANT_BOOL)vb );
		ASSERT( NULL != pIXMLDOMCloneNode  );
		if( NULL == pIXMLDOMCloneNode  )
		{
			return false;
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMCloneNode )
		{
			pIXMLDOMCloneNode.Release();
			pIXMLDOMCloneNode = NULL;
		}

		ASSERT( false );
		return false;
	}

	CXMLDOMNodePtr pTempNode( new CXMLDOMNode( pIXMLDOMCloneNode ) );
	ASSERT( NULL != pTempNode.get() );
	if( NULL == pTempNode.get() )
	{
		return false;
	}
	pGetClonedNodeRoot = pTempNode;

	if( NULL != pIXMLDOMCloneNode )
	{
		pIXMLDOMCloneNode.Release();
		pIXMLDOMCloneNode = NULL;
	}

	return true;
}

bool CXMLDOMNode::InsertBefore( const CXMLDOMNodePtr& pInNode )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != pInNode.get() );
	if( NULL == pInNode.get() )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
	try
	{
		// Get the parent of current node's.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		ASSERT( NULL != pIXMLDOMParent );
		if( NULL == pIXMLDOMParent )
		{
			return false;
		}

		// _variant_t vtNull;
		// vtNull.vt = VT_NULL;

		// Insert pInNode before current node.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
		pIXMLDOMNewNode =  pIXMLDOMParent->insertBefore( pInNode.get()->m_pXMLDOMNode , ( _variant_t)( IDispatch*) m_pXMLDOMNode ); 
		ASSERT( NULL != pIXMLDOMNewNode );
		if( NULL == pIXMLDOMNewNode )
		{
			return false;
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}

		if( NULL != pIXMLDOMNewNode )
		{
			pIXMLDOMNewNode.Release();
			pIXMLDOMNewNode = NULL;
		}

		ASSERT( false );
		return false;
	}


	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}

	if( NULL != pIXMLDOMNewNode )
	{
		pIXMLDOMNewNode.Release();
		pIXMLDOMNewNode = NULL;
	}

	return true;

}
bool CXMLDOMNode::InsertBefore( const CXMLDOMNodePtr& pInNode, CXMLDOMNodePtr& pGetInsertedNode )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != pInNode.get() );
	if( NULL == pInNode.get() )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
	try
	{
		// Get the parent of current node's.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		ASSERT( NULL != pIXMLDOMParent );
		if( NULL == pIXMLDOMParent )
		{
			return false;
		}

		// Insert pInNode before current node.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
		pIXMLDOMNewNode =  pIXMLDOMParent->insertBefore( pInNode.get()->m_pXMLDOMNode , ( _variant_t)( IDispatch*) m_pXMLDOMNode ); 
		ASSERT( NULL != pIXMLDOMNewNode );
		if( NULL == pIXMLDOMNewNode )
		{
			return false;
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}

		if( NULL != pIXMLDOMNewNode )
		{
			pIXMLDOMNewNode.Release();
			pIXMLDOMNewNode = NULL;
		}
		ASSERT( false );
		return false;
	}

	// Create new node.
	CXMLDOMNodePtr pTempNode( new CXMLDOMNode( pIXMLDOMNewNode ) );
	ASSERT( NULL != pTempNode.get() );
	if( NULL == pTempNode.get() )
	{
		return false;
	}

	// Return the pointer to new node.
	pGetInsertedNode = pTempNode;

	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}

	if( NULL != pIXMLDOMNewNode )
	{
		pIXMLDOMNewNode.Release();
		pIXMLDOMNewNode = NULL;
	}

	return true;

}

bool CXMLDOMNode::InsertAfter( const CXMLDOMNodePtr& pInNode )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != pInNode.get() );
	if( NULL == pInNode.get() )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
	try
	{
		// Get the parent of current node's.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		ASSERT( NULL != pIXMLDOMParent );
		if( NULL == pIXMLDOMParent )
		{
			return false;
		}

		// Insert pInNode After current node.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
		pIXMLDOMNewNode =  pIXMLDOMParent->insertBefore( pInNode.get()->m_pXMLDOMNode , ( _variant_t)( IDispatch*) m_pXMLDOMNode->GetnextSibling() ); 
		ASSERT( NULL != pIXMLDOMNewNode );
		if( NULL == pIXMLDOMNewNode )
		{
			return false;
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}

		if( NULL != pIXMLDOMNewNode )
		{
			pIXMLDOMNewNode.Release();
			pIXMLDOMNewNode = NULL;
		}
		ASSERT( false );
		return false;
	}


	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}

	if( NULL != pIXMLDOMNewNode )
	{
		pIXMLDOMNewNode.Release();
		pIXMLDOMNewNode = NULL;
	}

	return true;

}

bool CXMLDOMNode::InsertAfter( const CXMLDOMNodePtr& pInNode, CXMLDOMNodePtr& pGetInsertedNode  )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != pInNode.get() );
	if( NULL == pInNode.get() )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
	try
	{
		// Get the parent of current node's.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMParent = NULL;
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		ASSERT( NULL != pIXMLDOMParent );
		if( NULL == pIXMLDOMParent )
		{
			return false;
		}

		// Insert pInNode after current node.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMNewNode = NULL;
		pIXMLDOMNewNode =  pIXMLDOMParent->insertBefore( pInNode.get()->m_pXMLDOMNode , ( _variant_t)( IDispatch*) m_pXMLDOMNode->GetnextSibling() ); 
		ASSERT( NULL != pIXMLDOMNewNode );
		if( NULL == pIXMLDOMNewNode )
		{
			return false;
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}

		if( NULL != pIXMLDOMNewNode )
		{
			pIXMLDOMNewNode.Release();
			pIXMLDOMNewNode = NULL;
		}
		ASSERT( false );
		return false;
	}

	// Create new node.
	CXMLDOMNodePtr pTempNode( new CXMLDOMNode( pIXMLDOMNewNode ) );
	ASSERT( NULL != pTempNode.get() );
	if( NULL == pTempNode.get() )
	{
		return false;
	}

	// Return the pointer to new node.
	pGetInsertedNode = pTempNode;

	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}

	if( NULL != pIXMLDOMNewNode )
	{
		pIXMLDOMNewNode.Release();
		pIXMLDOMNewNode = NULL;
	}

	return true;
}
bool CXMLDOMNode::AppendNode( const CXMLDOMNodePtr& pInNode )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != pInNode.get() );
	if( NULL == pInNode.get() )
	{
		return false;
	}

	try
	{
		// Append pInNode to last.
		HRESULT hr = m_pXMLDOMNode->appendChild( pInNode.get()->m_pXMLDOMNode);
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			return false;
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		ASSERT( false );
		return false;
	}


	return true;
}

bool CXMLDOMNode::AppendNode( const CXMLDOMNodePtr& pInNode, CXMLDOMNodePtr& pGetAppendedNode )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != pInNode.get() );
	if( NULL == pInNode.get() )
	{
		return false;
	}
	MSXML2::IXMLDOMNodePtr pIXMLDOMInNode = NULL;
	pIXMLDOMInNode = pInNode.get()->m_pXMLDOMNode;
	ASSERT( NULL != pIXMLDOMInNode );
	if( NULL == pIXMLDOMInNode )
	{
		return false;
	}
	
	MSXML2::IXMLDOMNodePtr pIXMLDOMAppendNode = NULL;
	try
	{
		// Append pInNode to last.
		//MSXML2::IXMLDOMNodePtr pIXMLDOMAppendNode = NULL;
		pIXMLDOMAppendNode = m_pXMLDOMNode->appendChild( pIXMLDOMInNode );// pInNode.get()->m_pXMLDOMNode
		ASSERT( NULL != pIXMLDOMAppendNode );
		if( NULL == pIXMLDOMAppendNode )
		{
			return false;
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMAppendNode )
		{
			pIXMLDOMAppendNode.Release();
			pIXMLDOMAppendNode = NULL;
		}
		if( NULL != pIXMLDOMInNode )
		{
			pIXMLDOMInNode.Release();
			pIXMLDOMInNode = NULL;
		}
		ASSERT( false );
		return false;
	}

	// Return current node pointer.
	CXMLDOMNodePtr pTemp( new CXMLDOMNode( pIXMLDOMAppendNode ) );
	ASSERT( NULL != pTemp.get() );
	if( NULL != pTemp.get() )
	{
		pGetAppendedNode = pTemp;
	}

	if( NULL != pIXMLDOMAppendNode )
	{
		pIXMLDOMAppendNode.Release();
		pIXMLDOMAppendNode = NULL;
	}
	if( NULL != pIXMLDOMInNode )
	{
		pIXMLDOMInNode.Release();
		pIXMLDOMInNode = NULL;
	}

	return true;
}
int CXMLDOMNode::GetCurNodeLevel()
{
	CXMLDOMNodePtr TemPtr = GetRoot();
	CXMLDOMNodePtr pXMLDOMNode( new CXMLDOMNode(m_pXMLDOMNode));
	CString str = TemPtr->GetAttributeName();
	int nCount =0;
	while(*TemPtr.get()!=*pXMLDOMNode.get())
	{
		pXMLDOMNode = pXMLDOMNode->GetParentNode();
		nCount++;
	}
	return nCount+1;
}
bool CXMLDOMNode::IsRootNode(const CXMLDOMNodePtr &pXMLDOMNodePtr)
{
	CXMLDOMNodePtr TemPtr = GetRoot();
	if (*pXMLDOMNodePtr.get() == *TemPtr.get())
	{
		return true;
	}
	else
	{
		return false;
	}
}
CXMLDOMNodePtr CXMLDOMNode::GetRoot( void )
{
	MSXML2::IXMLDOMDocumentPtr pCurrentDoc = NULL;
	MSXML2::IXMLDOMElementPtr pXMLDOMElement = NULL;
//	HRESULT hr;
	try
	{
		HRESULT hr = m_pXMLDOMNode->get_ownerDocument( &pCurrentDoc );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		hr = pCurrentDoc->get_documentElement( &pXMLDOMElement );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;
		}
	}
	catch ( ... )
	{
		if( NULL != pCurrentDoc )
		{
			pCurrentDoc.Release();
			pCurrentDoc = NULL;
		}
		ASSERT( false );
		//RETURN_NULL;
		if( NULL != pXMLDOMElement )
		{
			pXMLDOMElement.Release();
			pXMLDOMElement = NULL;
		}
		ASSERT( false );
		RETURN_NULL;
	}
	CXMLDOMNodePtr pXMLDOMNode( new CXMLDOMNode( pXMLDOMElement ) );
	if( NULL != pCurrentDoc )
	{
		pCurrentDoc.Release();
		pCurrentDoc = NULL;
	}
	if( NULL != pXMLDOMElement )
	{
		pXMLDOMElement.Release();
		pXMLDOMElement = NULL;
	}	
	return pXMLDOMNode;
}
CXMLDOMNodePtr CXMLDOMNode::AppendNodeEx( const TCHAR* szNodeName, const TCHAR* szNodeValue,
						  const TCHAR* szAttributeName,
						  const TCHAR* szAttributeValue)
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMDocumentPtr pCurrentDoc = NULL;
	MSXML2::IXMLDOMNodePtr pCurrentNode = NULL;
	try
	{
		// Get document  of current node's own.
		HRESULT hr = m_pXMLDOMNode->get_ownerDocument( &pCurrentDoc );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		// Create it at first.
		pCurrentNode = pCurrentDoc->createElement( _bstr_t( szNodeName ) );
		ASSERT( NULL != pCurrentNode );
		if( NULL == pCurrentNode )
		{
			RETURN_NULL;	
		}
		m_pXMLDOMNode->appendChild( pCurrentNode );
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pCurrentNode )
		{
			pCurrentNode.Release();
			pCurrentNode = NULL;
		}
		if( NULL != pCurrentDoc )
		{
			pCurrentDoc.Release();
			pCurrentDoc = NULL;
		}
		ASSERT( false );
		RETURN_NULL;
	}

	CXMLDOMNodePtr pRetCurrentNode( new CXMLDOMNode( pCurrentNode ) );

	// Have szNodeValue then create node value.
	if( *szNodeValue != NULLSTRING ) // szNodeValue != TEXT("")
	{
		pRetCurrentNode->SetNodeValue( szNodeValue );
	}
	// Have szAttributeName then create attribute node and set value to it.
	if( *szAttributeName != NULLSTRING )
	{
		pRetCurrentNode->SetAttributeValue( szAttributeName, szAttributeValue );
	}

	// Clear to avoid memory leak.
	if( NULL != pCurrentNode )
	{
		pCurrentNode.Release();
		pCurrentNode = NULL;
	}
	if( NULL != pCurrentDoc )
	{
		pCurrentDoc.Release();
		pCurrentDoc = NULL;
	}
	int nLevel = GetCurNodeLevel();
	if (nLevel>=0)
	{
		int nChildLevel = nLevel+1;
		CString strTab = _T("\n");
		int i=0;
		for (i=0;i<nLevel;i++)
		{
			strTab += _T("\t");
		}
		//SetNodeTabValue(strTab);
		strTab += _T("\t");
		//pRetCurrentNode->SetNodeTabValue(strTab);
	}
	return pRetCurrentNode;
}
CXMLDOMNodePtr CXMLDOMNode::AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue/* = ""*/, const TCHAR* szAttributeName/* = ""*/, const TCHAR* szAttributeValue/* = ""*/ )
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		//return NULL;
		RETURN_NULL;
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMDocumentPtr pCurrentDoc = NULL;
	MSXML2::IXMLDOMNodePtr pCurrentNode = NULL;
	try
	{
		// Get document  of current node's own.
		//MSXML2::IXMLDOMDocumentPtr pCurrentDoc = NULL;
		HRESULT hr = m_pXMLDOMNode->get_ownerDocument( &pCurrentDoc );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		// Create it at first.
		//MSXML2::IXMLDOMNodePtr pCurrentNode = NULL;
		pCurrentNode = pCurrentDoc->createElement( _bstr_t( szNodeName ) );
		ASSERT( NULL != pCurrentNode );
		if( NULL == pCurrentNode )
		{
			RETURN_NULL;	
		}
		// Then append it to last.
		/*hr = */m_pXMLDOMNode->appendChild( pCurrentNode );
		/*ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}*/
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pCurrentNode )
		{
			pCurrentNode.Release();
			pCurrentNode = NULL;
		}
		if( NULL != pCurrentDoc )
		{
			pCurrentDoc.Release();
			pCurrentDoc = NULL;
		}
		ASSERT( false );
		RETURN_NULL;
	}

	CXMLDOMNodePtr pRetCurrentNode( new CXMLDOMNode( pCurrentNode ) );

	// Have szNodeValue then create node value.
	if( *szNodeValue != NULLSTRING ) // szNodeValue != TEXT("")
	{
		pRetCurrentNode->SetNodeValue( szNodeValue );
	}
	// Have szAttributeName then create attribute node and set value to it.
	if( *szAttributeName != NULLSTRING )
	{
		pRetCurrentNode->SetAttributeValue( szAttributeName, szAttributeValue );
	}

	// Clear to avoid memory leak.
	if( NULL != pCurrentNode )
	{
		pCurrentNode.Release();
		pCurrentNode = NULL;
	}
	if( NULL != pCurrentDoc )
	{
		pCurrentDoc.Release();
		pCurrentDoc = NULL;
	}
	return pRetCurrentNode;
}

CXMLDOMNodePtr CXMLDOMNode::AppendNode( const TCHAR* szNodeName,const CStringArray &arystrAttributeName,
						  const CStringArray &arystrAttributeValue, 
						  const TCHAR* szNodeValue)
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	MSXML2::IXMLDOMDocumentPtr pCurrentDoc = NULL;
	MSXML2::IXMLDOMNodePtr pCurrentNode = NULL;
	try
	{
		HRESULT hr = m_pXMLDOMNode->get_ownerDocument( &pCurrentDoc );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			RETURN_NULL;	
		}
		pCurrentNode = pCurrentDoc->createElement( _bstr_t( szNodeName ) );
		ASSERT( NULL != pCurrentNode );
		if( NULL == pCurrentNode )
		{
			RETURN_NULL;	
		}
		// Then append it to last.
		m_pXMLDOMNode->appendChild( pCurrentNode );
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pCurrentNode )
		{
			pCurrentNode.Release();
			pCurrentNode = NULL;
		}
		if( NULL != pCurrentDoc )
		{
			pCurrentDoc.Release();
			pCurrentDoc = NULL;
		}
		ASSERT( false );
		RETURN_NULL;
	}

	CXMLDOMNodePtr pRetCurrentNode( new CXMLDOMNode( pCurrentNode ) );

	// Have szNodeValue then create node value.
	if( *szNodeValue != NULLSTRING ) // szNodeValue != TEXT("")
	{
		pRetCurrentNode->SetNodeValue( szNodeValue );
	}
	// Have szAttributeName then create attribute node and set value to it.
	if( arystrAttributeName.GetSize()!=0)
	{
		// Zyu modify on 100722，支持64位
		//int nLen = arystrAttributeName.GetSize();
		INT_PTR nLen = arystrAttributeName.GetSize();
		int i =0;
		for (;i<nLen;i++)
		{
			CString szAttributeName,szAttributeValue;
			szAttributeName = arystrAttributeName.GetAt(i);
			szAttributeValue = arystrAttributeValue.GetAt(i);
			pRetCurrentNode->SetAttributeValue( szAttributeName, szAttributeValue );
		}
		
	}
	// Clear to avoid memory leak.
	if( NULL != pCurrentNode )
	{
		pCurrentNode.Release();
		pCurrentNode = NULL;
	}
	if( NULL != pCurrentDoc )
	{
		pCurrentDoc.Release();
		pCurrentDoc = NULL;
	}
	return pRetCurrentNode;
}
CXMLDOMNodePtr CXMLDOMNode::AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue/* = TEXT("")*/, const TCHAR* szAttributeName/* = TEXT("")*/, const double&  dAttributeValue/* = 0.0*/ )
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;		
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_tcscpy( szAttributeValue, _DoubleToString( dAttributeValue ) );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		RETURN_NULL;	
	}

	return AppendNode(  szNodeName, szNodeValue , szAttributeName , szAttributeValue );
}

CXMLDOMNodePtr CXMLDOMNode::AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue/* = TEXT("")*/, const TCHAR* szAttributeName/* = TEXT("")*/, const int& nAttributeValue/* = 0*/ )
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	const int nBase = 10; // Converting base value. 
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_itot( nAttributeValue, szAttributeValue, nBase );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		RETURN_NULL;	
	}

	return AppendNode(  szNodeName, szNodeValue , szAttributeName , szAttributeValue );	
}

CXMLDOMNodePtr CXMLDOMNode::AppendNode( const TCHAR* szNodeName, const TCHAR* szNodeValue/* = TEXT("")*/, const TCHAR* szAttributeName/* = TEXT("")*/, const bool&  bAttributeValue/* = false*/ )
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	return AppendNode(  szNodeName, szNodeValue , szAttributeName ,( int ) bAttributeValue );
}

CXMLDOMNodePtr  CXMLDOMNode::AppendNode( const TCHAR* szNodeName, const double& dNodeValue/* = 0.0 */, const TCHAR* szAttributeName/* = ""*/, const TCHAR* szAttributeValue/* = TEXT("") */ )
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;		
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}
	TCHAR szNewNodeValue[ MAX_PATH ];
	memset( szNewNodeValue, 0, sizeof( szNewNodeValue ) );
	_tcscpy( szNewNodeValue, _DoubleToString( dNodeValue ) );
	ASSERT( NULL != szNewNodeValue );
	if( NULL == szNewNodeValue )
	{
		RETURN_NULL;	
	}

	return AppendNode(  szNodeName, szNewNodeValue , szAttributeName ,szAttributeValue );
}

CXMLDOMNodePtr CXMLDOMNode::AppendNode( const TCHAR* szNodeName, const int& nNodeValue/* = 0 */, const TCHAR* szAttributeName/* = TEXT("")*/, const TCHAR* szAttributeValue /*= TEXT("") */ )
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;	
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;	
	}

	const int nBase = 10; // Converting base value. 
	TCHAR szNewNodeValue[ MAX_PATH ];
	memset( szNewNodeValue, 0, sizeof( szNewNodeValue ) );
	_itot( nNodeValue, szNewNodeValue, nBase );
	ASSERT( NULL != szNewNodeValue );
	if( NULL == szNewNodeValue )
	{
		RETURN_NULL;	
	}

	return AppendNode(  szNodeName, szNewNodeValue , szAttributeName ,szAttributeValue );
}

CXMLDOMNodePtr CXMLDOMNode::AppendNode( const TCHAR* szNodeName, const bool& bNodeValue/* = false */, const TCHAR* szAttributeName/* = TEXT("")*/, const TCHAR* szAttributeValue/* = TEXT("") */ )
{
	ASSERT( NULL != szNodeName );
	if( NULL == szNodeName )
	{
		RETURN_NULL;
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		RETURN_NULL;
	}

	return AppendNode(  szNodeName,( int )bNodeValue , szAttributeName ,szAttributeValue );
}

bool  CXMLDOMNode::DeleteNode()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMNode = NULL;
	HRESULT hr ;
	try
	{
		/*HRESULT*/ hr = m_pXMLDOMNode->get_parentNode( &pIXMLDOMNode );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			return false;
		}

		/*hr = */
		MSXML2::IXMLDOMNodePtr pTem = pIXMLDOMNode->removeChild( m_pXMLDOMNode );
		if (pTem !=NULL)
		{
			pTem.Release();
			pTem = NULL;
		}
		else
		{
			return false;
		}
		/*ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			return false;
		}*/
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		ASSERT( false );
		return false;
	}

	return true;
}

bool CXMLDOMNode:: DeleteChildrenNodes()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}


	if( !HasChildNodes() )
	{
		return false;
	}

	MSXML2::IXMLDOMNodePtr pIXMLDOMNode = NULL;
	//MSXML2::DOMNodeType NodeType;
	MSXML2::IXMLDOMNodeListPtr pNodeList = NULL;
	HRESULT hr;
	try
	{
		/*HRESULT*/ hr = m_pXMLDOMNode->get_childNodes( &pNodeList );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			return false;
		}
		int nCountChildrenNodes = pNodeList->length;

		for( int i = 0; i < nCountChildrenNodes ; i++ )
		{
			pIXMLDOMNode = pNodeList->item[ 0 ];

			//hr = pIXMLDOMNode->get_nodeType( &NodeType );
			//ASSERT( SUCCEEDED(hr) );

			// filter delete item
			//if( NodeType == MSXML2::NODE_ELEMENT )
			{
				hr = m_pXMLDOMNode->removeChild( pIXMLDOMNode );

				ASSERT( SUCCEEDED( hr ) );
				if( FAILED( hr ) )
				{
					if( NULL != pIXMLDOMNode )
					{
						pIXMLDOMNode.Release();
						pIXMLDOMNode = NULL;
					}
					return false;
				}
			}

			if( NULL != pIXMLDOMNode )
			{
				pIXMLDOMNode.Release();
				pIXMLDOMNode = NULL;
			}
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pIXMLDOMNode )
		{
			pIXMLDOMNode.Release();
			pIXMLDOMNode = NULL;
		}
		if( NULL != pNodeList )
		{
			pNodeList.Release();
			pNodeList = NULL;
		}
		ASSERT( false );
		return false;
	}

	if( NULL != pIXMLDOMNode )
	{
		pIXMLDOMNode.Release();
		pIXMLDOMNode = NULL;
	}
	if( NULL != pNodeList )
	{
		pNodeList.Release();
		pNodeList = NULL;
	}
	return true;

}

bool CXMLDOMNode::GetAttributeName( TCHAR* szGetAttrName , int nIndex /*= 0*/ )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	memset( szGetAttrName, 0, sizeof( szGetAttrName ) );

	MSXML2::IXMLDOMNamedNodeMapPtr	pXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMAttributePtr		pXMLDOMAttribute = NULL;
	try
	{
		pXMLDOMNamedNodeMap = m_pXMLDOMNode->Getattributes();
		ASSERT( NULL != pXMLDOMNamedNodeMap );
		if( NULL == pXMLDOMNamedNodeMap ){ return false; }
		// nIndex value must be within length.
		ASSERT( nIndex < pXMLDOMNamedNodeMap->length );
		if( nIndex >= pXMLDOMNamedNodeMap->length ){ return false; }
		pXMLDOMAttribute = pXMLDOMNamedNodeMap->item[ nIndex ];
		ASSERT( NULL != pXMLDOMAttribute );
	}
	catch( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pXMLDOMNamedNodeMap )
		{
			pXMLDOMNamedNodeMap.Release();
			pXMLDOMNamedNodeMap = NULL;
		}
		if( NULL != pXMLDOMAttribute )
		{
			pXMLDOMAttribute.Release();
			pXMLDOMAttribute = NULL;
		}

		ASSERT( false );
		return false;
	}

	//_bstr_t bstrAttributeName;
	//memset( szGetAttrName, 0, sizeof( szGetAttrName ) );
	_tcscpy( szGetAttrName, ( TCHAR * )( _bstr_t )pXMLDOMAttribute->Getname() );

	if( NULL != pXMLDOMNamedNodeMap )
	{
		pXMLDOMNamedNodeMap.Release();
		pXMLDOMNamedNodeMap = NULL;
	}
	if( NULL != pXMLDOMAttribute )
	{
		pXMLDOMAttribute.Release();
		pXMLDOMAttribute = NULL;
	}

	return true;
}
long CXMLDOMNode::GetAttributeNum()
{
	long nNum = 0;
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return 0;
	}
	MSXML2::IXMLDOMNamedNodeMapPtr	pXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMAttributePtr		pXMLDOMAttribute = NULL;
	try
	{
		pXMLDOMNamedNodeMap = m_pXMLDOMNode->Getattributes();
		ASSERT( NULL != pXMLDOMNamedNodeMap );
		if( NULL == pXMLDOMNamedNodeMap ){ return 0; }
		nNum = pXMLDOMNamedNodeMap->length;
	}
	catch ( ... )
	{
		if( NULL != pXMLDOMNamedNodeMap )
		{
			pXMLDOMNamedNodeMap.Release();
			pXMLDOMNamedNodeMap = NULL;
		}
		if( NULL != pXMLDOMAttribute )
		{
			pXMLDOMAttribute.Release();
			pXMLDOMAttribute = NULL;
		}
		return 0;
	}
	if( NULL != pXMLDOMNamedNodeMap )
	{
		pXMLDOMNamedNodeMap.Release();
		pXMLDOMNamedNodeMap = NULL;
	}
	if( NULL != pXMLDOMAttribute )
	{
		pXMLDOMAttribute.Release();
		pXMLDOMAttribute = NULL;
	}
	return nNum;
}
TCHAR* CXMLDOMNode::GetAttributeName( int nIndex /*= 0*/ )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return NULL;
	}

	static TCHAR szGetAttrName[MAX_PATH];
	memset( szGetAttrName, 0, sizeof( szGetAttrName ) );

	MSXML2::IXMLDOMNamedNodeMapPtr	pXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMAttributePtr		pXMLDOMAttribute = NULL;
	try
	{
		pXMLDOMNamedNodeMap = m_pXMLDOMNode->Getattributes();
		ASSERT( NULL != pXMLDOMNamedNodeMap );
		if( NULL == pXMLDOMNamedNodeMap ){ return NULL; }
		int n = nIndex;
		int nl = pXMLDOMNamedNodeMap->length;
		//ASSERT( nIndex < pXMLDOMNamedNodeMap->length );
		if( nIndex >= pXMLDOMNamedNodeMap->length ){ return NULL; }

		pXMLDOMAttribute = pXMLDOMNamedNodeMap->item[ nIndex ];
		ASSERT( NULL != pXMLDOMAttribute );
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pXMLDOMNamedNodeMap )
		{
			pXMLDOMNamedNodeMap.Release();
			pXMLDOMNamedNodeMap = NULL;
		}
		if( NULL != pXMLDOMAttribute )
		{
			pXMLDOMAttribute.Release();
			pXMLDOMAttribute = NULL;
		}

		ASSERT( false );
		return NULL;
	}


	//_bstr_t bstrAttributeName;
	//TCHAR szGetAttrName[MAX_PATH];
	//memset( szGetAttrName, 0, sizeof( szGetAttrName ) );
	_tcscpy( szGetAttrName, ( TCHAR * )( _bstr_t )pXMLDOMAttribute->Getname() );

	if( NULL != pXMLDOMNamedNodeMap )
	{
		pXMLDOMNamedNodeMap.Release();
		pXMLDOMNamedNodeMap = NULL;
	}
	if( NULL != pXMLDOMAttribute )
	{
		pXMLDOMAttribute.Release();
		pXMLDOMAttribute = NULL;
	}
	static TCHAR* pRetAttrName = szGetAttrName;
	return pRetAttrName;
}


bool CXMLDOMNode::IsAttributeExist( const TCHAR* szAttributeName, const TCHAR* szAttributeValue/* = NULL */)
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	bool bIsExist = false;
	MSXML2::IXMLDOMElementPtr pXMLDOMElement = NULL;
	pXMLDOMElement = static_cast< MSXML2::IXMLDOMElementPtr >( m_pXMLDOMNode );
	TCHAR szCurrentAttributeValue[MAX_PATH];
	memset( szCurrentAttributeValue, 0, sizeof( szCurrentAttributeValue ) );
	_variant_t vt = pXMLDOMElement->getAttribute( _bstr_t( szAttributeName ) );
	_tcscpy( szCurrentAttributeValue, _VariantToString( vt ) );
	if( NULL == szCurrentAttributeValue ||  0 == _tcslen( szCurrentAttributeValue ) ) // Have no attribute name.
	{
		bIsExist = false;
	}
	else // Have attribute name.
	{
		if( NULL == szAttributeValue) // Only judge Attribute Name Exist?
		{
			bIsExist = true;
		}
		else // Judge Attribute name and attribute value.
		{
			// Attribute value Exist?
			if( _tcslen( szCurrentAttributeValue ) > 0 )
			{
#ifdef _DEBUG
				TCHAR szDebugString[MAX_PATH];
				memset( szDebugString, 0, sizeof( szDebugString ) );
				_stprintf( szDebugString, TEXT("\ncurrent attibute is: %s( =? %s )\n " ), szCurrentAttributeValue, szAttributeValue );
				OutputDebugString( szDebugString );
#endif			

				// Exist and equal.
				if( 0 == _tcscmp( szCurrentAttributeValue, szAttributeValue ) )
				{
					bIsExist = true;

#ifdef _DEBUG
					OutputDebugString( TEXT( "\n<Exist>\n" ) );
#endif

				}
				else
				{
#ifdef _DEBUG
					OutputDebugString( TEXT( "\n<Not Exist>\n" ) );
#endif
					bIsExist = false;
				}

			}
			else
			{
				bIsExist = false;
			}
		} // End if( NULL == szAttributeValue) 		
	}

	if( NULL != pXMLDOMElement )
	{
		pXMLDOMElement.Release();
		pXMLDOMElement = NULL;
	}

	return bIsExist;

}  

bool CXMLDOMNode::IsAttributeExist( const TCHAR* szAttributeName,  const double& dAttributeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_tcscpy( szAttributeValue, _DoubleToString( dAttributeValue ) );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}

	return IsAttributeExist( szAttributeName, szAttributeValue );

}


bool CXMLDOMNode::IsAttributeExist( const TCHAR* szAttributeName, const int& nAttributeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	const int nBase = 10; // Converting base value. 
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_itot( nAttributeValue, szAttributeValue, nBase );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}

	return IsAttributeExist( szAttributeName, szAttributeValue );
}

bool CXMLDOMNode::IsAttributeExist( const TCHAR* szAttributeName,  const bool& bAttributeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	return IsAttributeExist( szAttributeName, ( int )bAttributeValue );
}

TCHAR* CXMLDOMNode::GetAttributeValue( const TCHAR* szAttributeName )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return NULL;
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return NULL;
	}

	MSXML2::IXMLDOMNamedNodeMapPtr pIXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNode = NULL;
	VARIANT varTextValue;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_attributes( &pIXMLDOMNamedNodeMap );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED( hr ) )
		{
			return NULL;
		}

		pIXMLDOMNode = pIXMLDOMNamedNodeMap->getNamedItem( _bstr_t( szAttributeName ) );

		hr = pIXMLDOMNode->get_nodeValue( &varTextValue );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			return NULL;
		}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMNode )
		{
			pIXMLDOMNode.Release();
			pIXMLDOMNode = NULL;
		}
		if( NULL != pIXMLDOMNamedNodeMap )
		{
			pIXMLDOMNamedNodeMap.Release();
			pIXMLDOMNamedNodeMap = NULL;
		}
		ASSERT( false );
		return NULL;
	}

	static TCHAR szGetAttributeValue[1024];
	memset( szGetAttributeValue, 0, sizeof( szGetAttributeValue ) );
	_tcscpy( szGetAttributeValue, ( TCHAR* )(_bstr_t)varTextValue );
	static TCHAR* szRetAttributeValue = NULL;
	szRetAttributeValue = szGetAttributeValue;

	if( NULL != pIXMLDOMNode )
	{
		pIXMLDOMNode.Release();
		pIXMLDOMNode = NULL;
	}
	if( NULL != pIXMLDOMNamedNodeMap )
	{
		pIXMLDOMNamedNodeMap.Release();
		pIXMLDOMNamedNodeMap = NULL;
	}

	return szRetAttributeValue;
}

bool CXMLDOMNode::GetAttributeValue( const TCHAR* szAttributeName, TCHAR* szGetAttributeValue )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}
	memset( szGetAttributeValue, 0, sizeof( szGetAttributeValue ) );
	MSXML2::IXMLDOMNamedNodeMapPtr pIXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNode = NULL;
	VARIANT varTextValue;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_attributes( &pIXMLDOMNamedNodeMap );
		ASSERT( SUCCEEDED( hr) );
		if( FAILED( hr ) )
		{
			return false;
		}

		pIXMLDOMNode = pIXMLDOMNamedNodeMap->getNamedItem( _bstr_t( szAttributeName ) );

		hr = pIXMLDOMNode->get_nodeValue( &varTextValue );
		ASSERT( SUCCEEDED( hr ) );
		if( FAILED( hr ) )
		{
			return false;
		}

	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMNode )
		{
			pIXMLDOMNode.Release();
			pIXMLDOMNode = NULL;
		}
		if( NULL != pIXMLDOMNamedNodeMap )
		{
			pIXMLDOMNamedNodeMap.Release();
			pIXMLDOMNamedNodeMap = NULL;
		}
		ASSERT( false );
		return false;
	}

	_tcscpy( szGetAttributeValue, ( TCHAR* )(_bstr_t)varTextValue );

	if( NULL != pIXMLDOMNode )
	{
		pIXMLDOMNode.Release();
		pIXMLDOMNode = NULL;
	}
	if( NULL != pIXMLDOMNamedNodeMap )
	{
		pIXMLDOMNamedNodeMap.Release();
		pIXMLDOMNamedNodeMap = NULL;
	}

	return true;
}

double CXMLDOMNode::GetAttributeValueToDouble( const TCHAR* szAttributeName )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return 0.0;
	}

	// Get String attribute value:
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_tcscpy( szAttributeValue, GetAttributeValue(  szAttributeName ) );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue ) 
	{
		return 0.0;
	}

	// Change it to double:
	double dRetValue = 0.0;
	dRetValue = _tstof/*_ttof*/( szAttributeValue );
	ASSERT( dRetValue > 0.0 ||  dRetValue < -0.0);
	return dRetValue;	
}

int CXMLDOMNode::GetAttributeValueToInt( const TCHAR* szAttributeName )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return 0;
	}

	// Get String attribute value:
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_tcscpy( szAttributeValue, GetAttributeValue(  szAttributeName ) );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue ) 
	{
		return 0;
	}

	// Change it to integer:
	int dRetValue = 0;
	dRetValue = _ttoi( szAttributeValue );
	//ASSERT( dRetValue != 0);

	return dRetValue;	
}

bool CXMLDOMNode::GetAttributeValueToBool( const TCHAR* szAttributeName )
{
	ASSERT( NULL != szAttributeName );
	int nRetValue = GetAttributeValueToInt( szAttributeName );
	bool bRetValue = ( nRetValue == 1 )? true: false ;

	return bRetValue;
}

bool CXMLDOMNode::SetAttributeValue( const TCHAR* szAttributeName, const TCHAR* szAttributeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	MSXML2::IXMLDOMElementPtr pXMLDOMElement = NULL;
	HRESULT hr;
	try
	{
		pXMLDOMElement = static_cast< MSXML2::IXMLDOMElementPtr >( m_pXMLDOMNode );
		/*HRESULT*/ hr = pXMLDOMElement->setAttribute( _bstr_t( szAttributeName ), _variant_t( ( TCHAR* ) szAttributeValue ) );
		ASSERT( SUCCEEDED( hr ) );
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pXMLDOMElement )
		{
			pXMLDOMElement.Release();
			pXMLDOMElement = NULL;
		}

		ASSERT( false );
		return false;
	}

	if( NULL != pXMLDOMElement )
	{
		pXMLDOMElement.Release();
		pXMLDOMElement = NULL;
	}

	return SUCCEEDED( hr );
}

bool CXMLDOMNode::SetAttributeValue( const TCHAR* szAttributeName, const double& dAttributeValue )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_tcscpy( szAttributeValue, _DoubleToString( dAttributeValue ) );
	ASSERT( NULL != szAttributeValue );

	bool bSetSuccess = false;
	bSetSuccess = SetAttributeValue( szAttributeName, szAttributeValue );
	ASSERT( bSetSuccess );

	return bSetSuccess;
}

bool CXMLDOMNode::SetAttributeValue( const TCHAR* szAttributeName, const int& nAttributeValue )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	const int nBase = 10; // Converting base value. 
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_itot( nAttributeValue, szAttributeValue, nBase );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}

#ifdef _DEBUG
	TCHAR szDebugString[ MAX_PATH ];
	memset( szDebugString, 0, sizeof( szDebugString ) );
	_stprintf( szDebugString, TEXT( "\nbase %d: %s (%d chars)\n" ), nBase, szAttributeValue, _tcslen( szAttributeValue ) );
	OutputDebugString( szDebugString );
#endif

	bool bSetSuccess = false;
	bSetSuccess = SetAttributeValue( szAttributeName, szAttributeValue );
	ASSERT( bSetSuccess );

	return bSetSuccess;

}

bool CXMLDOMNode::SetAttributeValue( const TCHAR* szAttributeName, const long& lAttributeValue )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	const int nBase = 10;
	TCHAR szAttributeValue[ MAX_PATH ];
	memset( szAttributeValue, 0, sizeof( szAttributeValue ) );
	_itot( lAttributeValue, szAttributeValue, nBase );
	ASSERT( NULL != szAttributeValue );
	if( NULL == szAttributeValue )
	{
		return false;
	}

#ifdef _DEBUG
	TCHAR szDebugString[ MAX_PATH ];
	memset( szDebugString, 0, sizeof( szDebugString ) );
	_stprintf( szDebugString, TEXT( "\nbase %d: %s (%d chars)\n" ), nBase, szAttributeValue, _tcslen( szAttributeValue ) );
	OutputDebugString( szDebugString );
#endif

	bool bSetSuccess = false;
	bSetSuccess = SetAttributeValue( szAttributeName, szAttributeValue );
	ASSERT( bSetSuccess );

	return bSetSuccess;
}

bool CXMLDOMNode::SetAttributeValue( const TCHAR* szAttributeName, const bool& bAttributeValue )
{
	ASSERT( NULL != szAttributeName );
	if( NULL == szAttributeName )
	{
		return false;
	}

	bool bSetSuccess = false;
	bSetSuccess = SetAttributeValue( szAttributeName, ( int )bAttributeValue );
	ASSERT( bSetSuccess );

	return bSetSuccess;
}
bool CXMLDOMNode::DelAttributeNode( const TCHAR* pszAttributeTagName )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}	

	MSXML2::IXMLDOMNamedNodeMapPtr pIXMLDOMNamedNodeMap = NULL;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_attributes( &pIXMLDOMNamedNodeMap );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED ( hr ) )
		{
			return false;
		}
		hr =  pIXMLDOMNamedNodeMap->removeNamedItem( _bstr_t( pszAttributeTagName ) );
		ASSERT( SUCCEEDED( hr ) );
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != pIXMLDOMNamedNodeMap )
		{
			pIXMLDOMNamedNodeMap.Release();
			pIXMLDOMNamedNodeMap = NULL;
		}

		ASSERT( false );
		return false;
	}


	if( NULL != pIXMLDOMNamedNodeMap )
	{
		pIXMLDOMNamedNodeMap.Release();
		pIXMLDOMNamedNodeMap = NULL;
	}
	return SUCCEEDED( hr );
}

TCHAR* CXMLDOMNode::GetNodeValue()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return NULL;
	}
	TCHAR* pGetString = NULL;
	pGetString = _GetValue();
	ASSERT( NULL != pGetString );
	if( NULL == pGetString )
	{
		return NULL;
	}

	static TCHAR szGetString[1024];
	memset( szGetString, 0, sizeof( szGetString ) );
	_tcscpy( szGetString, _GetValue() );

	static TCHAR* pszRetString = NULL;
	pszRetString = szGetString;

	return pszRetString;
}

double CXMLDOMNode::GetNodeValueToDouble()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return 0.0; 
	}
	TCHAR szGetString[ MAX_PATH ];
	memset( szGetString, 0, sizeof( szGetString ) ); 
	_tcscpy( szGetString, _GetValue() );
	ASSERT( NULL != szGetString );
	if( NULL == szGetString )
	{
		return 0.0;
	}
	double dRetValue = 0.0;
	dRetValue = _tstof( szGetString );
	ASSERT( dRetValue > 0.0 || dRetValue < -0.0 );

	return dRetValue;	
}

int CXMLDOMNode::GetNodeValueToInt()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return 0; 
	}

	TCHAR szGetString[ MAX_PATH ];
	memset( szGetString, 0, sizeof( szGetString ) ); 
	_tcscpy( szGetString, _GetValue() );
	ASSERT( NULL != szGetString );
	if( NULL == szGetString )
	{
		return 0;
	}

	int dRetValue = 0;
	dRetValue = _ttoi( szGetString );
	return dRetValue;	
}

bool CXMLDOMNode::GetNodeValueToBool()
{
	ASSERT( NULL != m_pXMLDOMNode );

	int nRetValue = GetNodeValueToInt();
	bool bRetValue = ( nRetValue == 1 )? true: false ;

	return bRetValue;
}

bool CXMLDOMNode::SetNodeValue( const TCHAR* szNewNodeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	bool bSetSuccess = _SetValue( szNewNodeValue );
	ASSERT( bSetSuccess );
	if( !bSetSuccess )
	{
		return false;
	}

	return bSetSuccess;
}

bool CXMLDOMNode::SetNodeValue( const double& dNewNodeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false; 
	}


	TCHAR szNewNodeValue[ MAX_PATH ];
	memset( szNewNodeValue, 0, sizeof( szNewNodeValue ) );
	_tcscpy( szNewNodeValue, _DoubleToString( dNewNodeValue ) );
	ASSERT( NULL != szNewNodeValue );

	bool bSetSuccess = false;
	bSetSuccess = _SetValue( szNewNodeValue );
	ASSERT( bSetSuccess );

	return bSetSuccess;
}
bool CXMLDOMNode::SetNodeValue( const int& nNewNodeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false; 
	}

	const int nBase = 10; 
	TCHAR szNewNodeValue[ MAX_PATH ];
	memset( szNewNodeValue, 0, sizeof( szNewNodeValue ) );
	_itot( nNewNodeValue, szNewNodeValue, nBase );
	ASSERT( NULL != szNewNodeValue );
	if( NULL == szNewNodeValue )
	{
		return false;
	}

#ifdef _DEBUG
	TCHAR szDebugString[ MAX_PATH ];
	memset( szDebugString, 0, sizeof( szDebugString ) );
	_stprintf( szDebugString, TEXT( "\nbase %d: %s (%d chars)\n" ), nBase, szNewNodeValue, _tcslen( szNewNodeValue ) );
	OutputDebugString( szDebugString );
#endif

	bool bSetSuccess = false;
	bSetSuccess = _SetValue( szNewNodeValue );
	ASSERT( bSetSuccess );

	return bSetSuccess;
}

bool CXMLDOMNode::SetNodeValue( const bool& bNewNodeValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false; 
	}

	bool bSetSuccess = false;
	bSetSuccess = SetNodeValue(  ( int )bNewNodeValue );
	ASSERT( bSetSuccess );

	return bSetSuccess;
}

bool CXMLDOMNode::SetNodeTabValue(const TCHAR* pTabValue)
{
	ASSERT(pTabValue!=NULL);
	//MSXML2::IXMLDOMDocument2Ptr pXMLDOMDocument2Ptr = NULL;
	MSXML2::IXMLDOMDocumentPtr pCurrentDoc = NULL;
	pCurrentDoc = m_pXMLDOMNode->GetownerDocument();
	MSXML2::IXMLDOMTextPtr pXMLDOMTextPtr = NULL;
	if (pCurrentDoc!=NULL)
	{
		pXMLDOMTextPtr = pCurrentDoc->createTextNode(_bstr_t(pTabValue));
		MSXML2::IXMLDOMNodePtr pTem = NULL;
		if (pXMLDOMTextPtr!=NULL)
		{
			pTem = m_pXMLDOMNode->appendChild(pXMLDOMTextPtr);
			if (pTem !=NULL)
			{
				pXMLDOMTextPtr.Release();
				pXMLDOMTextPtr = NULL;
				pTem.Release();
				pTem = NULL;
				return true;
			}
			pXMLDOMTextPtr->Release();
			pXMLDOMTextPtr = NULL;
		}
	}
	return false;
}
bool CXMLDOMNode::DeleteNodeValue()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	bool bSetSuccess = SetNodeValue( TEXT("") );
	ASSERT( bSetSuccess );
	if( !bSetSuccess )
	{
		return false;
	}

	return bSetSuccess;
}

int CXMLDOMNode::GetSiblingCount()
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return 0;
	}

	MSXML2::IXMLDOMNodePtr	pIXMLDOMLastChild = NULL;
	MSXML2::IXMLDOMNodePtr	pIXMLDOMParent = NULL;
	MSXML2::IXMLDOMNodePtr	pICurNode = NULL;
	MSXML2::DOMNodeType		NodeType;
	HRESULT					hr = S_OK;
	int						nCount = 0;
	bool					bOpSuccess = true;

	try
	{
		pIXMLDOMParent = m_pXMLDOMNode->GetparentNode();
		ASSERT( NULL != pIXMLDOMParent );
		if( NULL != pIXMLDOMParent )
		{
			
			pICurNode = pIXMLDOMParent->GetfirstChild();
			if( NULL != pICurNode )
			{
			
				HRESULT hr = pICurNode->get_nodeType( &NodeType );
				ASSERT( SUCCEEDED( hr ) );
				if( SUCCEEDED( hr ) )
				{
					while( NodeType != MSXML2::NODE_ELEMENT )
					{
						pICurNode = pICurNode->GetnextSibling(); 
						hr = pICurNode->get_nodeType( &NodeType );
						ASSERT( SUCCEEDED( hr ) );
						if( FAILED( hr ) )
						{
							bOpSuccess = false;
							break;
						}
					}
				}
			}
			nCount += 1;

			if( bOpSuccess )
			{
				pIXMLDOMLastChild = pIXMLDOMParent->GetlastChild();
				if( NULL != pIXMLDOMLastChild )
				{
					
					hr = pIXMLDOMLastChild ->get_nodeType( &NodeType );
					ASSERT( SUCCEEDED( hr ) );
					if( SUCCEEDED( hr ) )
					{
						while( NodeType != MSXML2::NODE_ELEMENT )
						{
							pIXMLDOMLastChild = pIXMLDOMLastChild->GetpreviousSibling(); 
							hr = pIXMLDOMLastChild->get_nodeType( &NodeType );
							ASSERT( SUCCEEDED( hr ) );
							if( FAILED( hr ) )
							{
								bOpSuccess = false;
								break;
							}
						} 
					} 
				} 
			} 
			if( bOpSuccess )
			{
				while( pICurNode != pIXMLDOMLastChild )
				{
					pICurNode = pICurNode->GetnextSibling();
					if( NULL != pICurNode )
					{
						hr = pICurNode->get_nodeType( &NodeType );
						ASSERT( SUCCEEDED( hr ) );
						if( SUCCEEDED( hr ) )
						{
							while( NodeType != MSXML2::NODE_ELEMENT )
							{
								pICurNode = pICurNode->GetnextSibling(); 
								hr = pICurNode->get_nodeType( &NodeType );
								ASSERT( SUCCEEDED( hr ) );
								if( FAILED( hr ) )
								{
									nCount = 0;
									break;
								}
							}
						}
					} 

					nCount ++;

				}
			}
		}

		if( !bOpSuccess ){ nCount = 0;}
	}
	catch ( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif

		if( NULL != pIXMLDOMParent )
		{
			pIXMLDOMParent.Release();
			pIXMLDOMParent = NULL;
		}
		if( NULL != pIXMLDOMLastChild )
		{
			pIXMLDOMLastChild.Release();
			pIXMLDOMLastChild = NULL;
		}
		if( NULL != pICurNode )
		{
			pICurNode.Release();
			pICurNode = NULL;
		}

		ASSERT( false );
		return 0;	

	}


	if( NULL != pIXMLDOMParent )
	{
		pIXMLDOMParent.Release();
		pIXMLDOMParent = NULL;
	}
	if( NULL != pIXMLDOMLastChild )
	{
		pIXMLDOMLastChild.Release();
		pIXMLDOMLastChild = NULL;
	}
	if( NULL != pICurNode )
	{
		pICurNode.Release();
		pICurNode = NULL;
	}

	return nCount;
}

bool CXMLDOMNode::_GetValue( TCHAR* szGetValue)
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}

	if( HasChildNodes() )
	{
		ASSERT( false );
		return false;
	}

	BSTR bstr = NULL;
	HRESULT hr;
	try
	{
		hr = m_pXMLDOMNode->get_text( &bstr );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED ( hr ) )
		{
			return false;
		}
	}
	catch( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != bstr )
		{
			SysFreeString( bstr );
			bstr = NULL;
		}

		ASSERT( false );
		return false;
	}

	_tcscpy( szGetValue, ( TCHAR* )_bstr_t( bstr, true) );

	if( NULL != bstr )
	{
		SysFreeString(bstr);
		bstr = NULL;
	}
	return SUCCEEDED( hr );

}

TCHAR* CXMLDOMNode::_GetValue() 
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return NULL;
	}

	if( HasChildNodes() )
	{
		ASSERT( false );
		return NULL;
	}

	BSTR bstr = NULL;
	HRESULT hr ;
	try
	{
		hr = m_pXMLDOMNode->get_text( &bstr );
		ASSERT( SUCCEEDED(hr) );
		if( FAILED ( hr ) )
		{
			return NULL;
		}	
	}
	catch( ... )
	{
#ifdef _DEBUG
		MessageBox( NULL, TEXT("UnKnown error occured!"), TEXT("Error"), MB_OK|MB_ICONSTOP );
#endif
		if( NULL != bstr )
		{
			SysFreeString( bstr );
			bstr = NULL;
		}

		ASSERT( false );
		return NULL;
	}

	TCHAR szGetValue[1024];
	memset( szGetValue, 0, sizeof( szGetValue ) );
	_tcscpy( szGetValue, ( TCHAR* )_bstr_t( bstr, true ) );
	static TCHAR* szRetValue = NULL;
	szRetValue = szGetValue;
	if( NULL != bstr )
	{
		SysFreeString( bstr );
		bstr = NULL;
	}
	return szRetValue;
}

bool CXMLDOMNode::_SetValue( const TCHAR* szSetValue )
{
	ASSERT( NULL != m_pXMLDOMNode );
	if( NULL == m_pXMLDOMNode )
	{
		return false;
	}


	if( HasChildNodes() )
	{
		ASSERT( false );
		return false;
	}
	CString strText = szSetValue;
	int nLen = strText.GetLength();
	int nNum = 0;
	int i=0;
	for (i=0;i<nLen;i++)
	{
		TCHAR ch = strText.GetAt(i);
		if (ch == 32)
		{
			strText.Delete(i);
			i--;
			nNum ++;
		}
		else
		{
			break;
		}
	}
	if (nNum>0)
	{
		int i = 0;
		for (;i<nNum;i++)
		{
			TCHAR cNew = 31;
			strText.Insert(0,cNew);
		}
	}
	HRESULT hr = m_pXMLDOMNode->put_text( _bstr_t( strText ) );
	ASSERT( SUCCEEDED( hr ) );
	if( FAILED( hr ) )
	{
		return false;
	}

	return SUCCEEDED(hr);
}

TCHAR* CXMLDOMNode::_DoubleToString( const double& dToBeConvert )
{
#ifndef _CVTBUFSIZE
	const int _CVTBUFSIZE = MAX_PATH;
#endif
	static TCHAR* pRetString = NULL;
	const int nNumDigits = 16;
	static TCHAR szBuffer[_CVTBUFSIZE];
	char  szTarget[_CVTBUFSIZE];
	memset( szBuffer, 0, sizeof( szBuffer ) );
	memset( szTarget, 0, sizeof( szTarget ) );
#ifdef _UNICODE
	OutputDebugString( TEXT( "\n_UNICODE have been defined!\n" ) );
	_gcvt( dToBeConvert, nNumDigits, szTarget );
	int nLen = 0;
	nLen = MultiByteToWideChar( CP_ACP, 0, szTarget, -1, NULL, NULL );
	TCHAR* szWideTarget = new TCHAR[ nLen + 1 ];
	ASSERT( NULL != szWideTarget );
	if( NULL == szWideTarget )
	{
		return NULL;
	}
	memset( szWideTarget, 0, sizeof( szWideTarget ) );
	MultiByteToWideChar( CP_ACP, 0, szTarget, -1, szWideTarget, nLen );

	_tcscpy( szBuffer, szWideTarget );

	if( NULL != szWideTarget )
	{
		delete[] szWideTarget;
	}	

#else 
	_gcvt( dToBeConvert, nNumDigits, szBuffer );
#endif

	ASSERT( NULL != szBuffer );
	if( NULL == szBuffer )
	{
		return NULL;
	}

#ifdef _DEBUG
	// For test:
	TCHAR szDebugString[ MAX_PATH ];
	memset( szDebugString, 0, sizeof( szDebugString ) );
	_stprintf( szDebugString,TEXT( "\nBuffer: '%s' (total: %d chars)\n" ), szBuffer, _tcslen( szBuffer ) );
	OutputDebugString( szDebugString );
	//_tprintf(szDebugString);
	// End for test
#endif

	pRetString = szBuffer;
	return pRetString;

}
TCHAR* CXMLDOMNode::_VariantToString( const _variant_t& var )
{
	TCHAR szBuffer[MAX_PATH];   
	memset( szBuffer, 0, sizeof( szBuffer ) );
	switch( var.vt )   
	{   
	case   VT_EMPTY:   
	case   VT_NULL:   
	case   VT_DISPATCH:   
	case   VT_VARIANT:   
	case   VT_UI4:   
	case   VT_I1:   
	case   VT_UI2:   
	case   VT_SAFEARRAY:   
	case   VT_UNKNOWN:   
	case   VT_UINT:   
	case   VT_VOID:   
	case   VT_I8:   
	case   VT_HRESULT:   
	case   VT_ERROR:   
	case   VT_INT:   
	case   VT_PTR:   
	case   VT_UI8:   
	case   VT_CARRAY:   
	case   VT_USERDEFINED:   
	case   VT_LPWSTR:   
	case   VT_FILETIME:   
	case   VT_BLOB:   
	case   VT_LPSTR:   
	case   VT_STREAM:   
	case   VT_STORAGE:   
	case   VT_STREAMED_OBJECT:   
	case   VT_STORED_OBJECT:   
	case   VT_BLOB_OBJECT:   
	case   VT_CF:   
	case   VT_CLSID: 
		_tcscpy( szBuffer, TEXT("") );
		break;   
	case   VT_I2:   
		_stprintf( szBuffer, TEXT("%hd"), V_I2( &var ) );   
		break;   
	case   VT_I4:   
		_stprintf( szBuffer, TEXT("%d"), V_I4( &var ) );   
		break;   
	case   VT_R4:   
		_stprintf( szBuffer, TEXT("%e"), ( double )V_R4( &var ) );   
		break;   
	case   VT_R8:   
		_stprintf( szBuffer, TEXT("%e"), V_R8( &var ) );   
		break;  
	case   VT_BSTR:   
		_tcscpy( szBuffer,( TCHAR* )(_bstr_t)V_BSTR( &var ) );//
		break;   
	case   VT_BOOL:   
		_stprintf( szBuffer, TEXT("%s"), ( V_BOOL(&var) ? TEXT("true") : TEXT("false") ) ); 
		break;
	case   VT_UI1:   
		_stprintf( szBuffer, TEXT("0x%02hX"), ( unsigned short )V_UI1( &var ) );   
		break;   
	default:   
		_tcscpy( szBuffer, TEXT("") );   
		break;
	}

	TCHAR* pszRetString=NULL;
	pszRetString = szBuffer;

	return   pszRetString; 

}

bool CXMLDOMNode::_ParseXPath( const TCHAR* szXPath,  STRING_VECTOR& szVectNodeName)
{
	ASSERT( NULL != szXPath );
	if( NULL == szXPath )
	{
		return false;
	}
	int nLen = ( int )_tcslen( szXPath );
	if( nLen <=0 )
	{
		return false;
	}
	TCHAR* szPureXPath = new TCHAR[ nLen + 1 ];
	ASSERT( NULL != szPureXPath );
	if( NULL == szPureXPath )
	{
		return false;
	}
	_tcsncpy( szPureXPath, szXPath, nLen+1 );
	szVectNodeName.clear();
	TCHAR* pString = NULL;
	TCHAR szSeparator[] = TEXT(" /" );
	pString = _tcstok( szPureXPath, szSeparator ); 
	while( NULL != pString )
	{
#ifdef _DEBUG
		OutputDebugString( pString );
		OutputDebugString( TEXT("-") );
#endif
		szVectNodeName.push_back( pString );
		pString = _tcstok( NULL, szSeparator ); 
	}
	return true;
}