sxml.cpp

来自「天之炼狱1服务器端源文件游戏服务端不完整」· C++ 代码 · 共 972 行 · 第 1/2 页

//////////////////////////////////////////////////////////////////////////////
/// \file XML.cpp
/// \author excel96
/// \date 2003.7.25
///
/// \todo
/// \bug
/// \warning
//////////////////////////////////////////////////////////////////////////////

//#include "SFCPCH.h"
#include "SXml.h"
#include <iostream>
#include <iosfwd>
#include <assert.h>
#include <cstdio>
#include <cstdarg>
#include <ctime>

void itoa( int value, char* buf, int r )
{
	if ( r == 10 )
	{
		sprintf(buf, "%d", value);
	}
	else
	{
		sprintf(buf, "%x", value);
	}
}

//using namespace std;

//#pragma warning (push, 1)
	#include "xercesc/sax/SAXParseException.hpp"
	#include "xercesc/sax/SAXException.hpp"
	#include "xercesc/framework/MemBufInputSource.hpp"
	#include "xercesc/util/PlatformUtils.hpp"
	#include "xercesc/util/XMLString.hpp"
	#include "xercesc/sax2/XMLReaderFactory.hpp"
	#include "xercesc/sax2/SAX2XMLReader.hpp"
	#include "xercesc/sax2/Attributes.hpp"
	#include "xercesc/sax2/DefaultHandler.hpp"
//#pragma warning (pop)

//#pragma warning(disable:4100)

XERCES_CPP_NAMESPACE_USE

//////////////////////////////////////////////////////////////////////////////
/// \class XMLUtil
/// \brief
//////////////////////////////////////////////////////////////////////////////

class XMLUtil
{
public:
	static string trim(const string& str);
	static void filelog(char* fmt, ...);
	static string WideCharToString(const XMLCh * wstr, int wstrlen = -1);
};


//////////////////////////////////////////////////////////////////////////////
/// \class StrX
/// \brief 
//////////////////////////////////////////////////////////////////////////////

class StrX
{
private:
	char* m_pCSTR; ///< 郴何 巩磊凯 滚欺

public:
	StrX(const XMLCh* const toTranscode) { m_pCSTR = XMLString::transcode(toTranscode); }
	~StrX() { XMLString::release(&m_pCSTR); }

	const char* c_str() const { return m_pCSTR; }
	string	toString() const { return m_pCSTR; }
};

//////////////////////////////////////////////////////////////////////////////
/// \class XMLTreeGenerator
/// \brief 
//////////////////////////////////////////////////////////////////////////////

class XMLTreeGenerator : public DefaultHandler
{
private:
	XMLTree* m_pRoot;   ///< 弥惑困 畴靛
	XMLTree* m_pBuffer; ///< XML 颇教侩 烙矫 畴靛


public:
	XMLTreeGenerator( XMLTree* pTree );
	virtual ~XMLTreeGenerator();


public:
	// Handlers for the SAX ContentHandler interface
	void startElement( const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname, const Attributes& attrs );
	void endElement( const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname );
	void characters( const XMLCh* const chars, const unsigned int length );
	void ignorableWhitespace( const XMLCh* const, const unsigned int ) {}
	void resetDocument();

	// Handlers for the SAX ErrorHandler interface
	void warning( const SAXParseException& e );
	void error( const SAXParseException& e );
	void fatalError( const SAXParseException& e );


private:
	XMLTreeGenerator( const XMLTreeGenerator& ) {}
	XMLTreeGenerator& operator = ( const XMLTreeGenerator& ) { return *this; }
};

//////////////////////////////////////////////////////////////////////////////
/// \class XMLParser
/// \brief 
//////////////////////////////////////////////////////////////////////////////

class XMLParser
{
private:
	DefaultHandler* m_pHandler;


public:
	XMLParser(XMLTree* pTree);
	virtual ~XMLParser();


public:
	/// \brief 瘤沥等 困摹俊 乐绰 颇老 肚绰 昆 巩辑甫 颇教茄促.
	void parseURL(const char* pURL);

	/// \brief 牢荐肺 逞败瘤绰 巩磊凯阑 XML 巩辑肺 啊沥窍绊 颇教茄促.
	void parse(const char* buffer);
};


static const char* XML_ERROR_FILENAME = "__XMLError.log";

//////////////////////////////////////////////////////////////////////////////
/// \brief 
/// \param str 
/// \return string 
//////////////////////////////////////////////////////////////////////////////
string XMLUtil::WideCharToString(const XMLCh * wstr, int wstrlen)
{
//	return StrX( wstr ).c_str();

/*	if ( wstrlen == -1 )
	{
		wstrlen = (int)wcslen(wstr);
	}*/

	// test korean with WideCharToMultiByte
	//	int WideCharToMultiByte(
	//		UINT CodePage,            // code page
	//		DWORD dwFlags,            // performance and mapping flags
	//		LPCWSTR lpWideCharStr,    // wide-character string
	//		int cchWideChar,          // number of chars in string
	//		LPSTR lpMultiByteStr,     // buffer for new string
	//		int cbMultiByte,          // size of buffer
	//		LPCSTR lpDefaultChar,     // default for unmappable chars
	//		LPBOOL lpUsedDefaultChar  // set when default char used
	//	);
	//
	//lpDefaultChar 
	//	[in] Points to the character used if a wide character cannot be represented in the specified code page. 
	//  If this parameter is NULL, a system default value is used. 
	//  The function is faster when both lpDefaultChar and lpUsedDefaultChar are NULL. 
	//	For the code pages mentioned in dwFlags, lpDefaultChar must be NULL, 
	//  otherwise the function fails with ERROR_INVALID_PARAMETER. 

	//	lpUsedDefaultChar 
	//	[in] Points to a flag that indicates whether a default character was used. 
	//  The flag is set to TRUE if one or more wide characters in the source string 
	//  cannot be represented in the specified code page. Otherwise, the flag is set to FALSE. 
	//  This parameter may be NULL. The function is faster when both lpDefaultChar and lpUsedDefaultChar are NULL. 
	//	For the code pages mentioned in dwFlags, lpUsedDefaultChar must be NULL, 
	//  otherwise the function fails with ERROR_INVALID_PARAMETER. 

	// 弥家茄狼 汗荤甫 临捞扁 困秦辑 胶飘傅阑 霖厚. 	
/*	string strBuffer;
	strBuffer.reserve( wstrlen * 2 + 1 );		// capacity 甫 面盒窍霸.. 
	int nCopied = WideCharToMultiByte(
		CP_OEMCP,
		WC_COMPOSITECHECK,
		wstr,									// wide string
		wstrlen,								// length of wide string
		const_cast<LPSTR>(strBuffer.data()),	// mbcs string (unicode)
		(int)strBuffer.capacity(),					// length of mbcs string
		NULL,									// NULL 捞 狐福促绰单?
		NULL );
	strBuffer[nCopied] = 0;
	strBuffer._Mysize = nCopied;				// 荐悼栏肺 瘤沥秦具 茄促.

	return strBuffer;*/
	return StrX(wstr).toString();
}

string XMLUtil::trim(const string& str)
{
	if (str.size() == 0) return "";

	static const char * WhiteSpaces = " \t\n\r";
	size_t begin = str.find_first_not_of(WhiteSpaces);
	size_t end = str.find_last_not_of(WhiteSpaces);

	if (begin == string::npos)
	{
		if (end == string::npos) return "";
		else begin = 0;
	}
	else if (end == string::npos)
	{
		end = str.size();
	}

	return str.substr(begin , end - begin + 1);
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 
/// \param fmt 
/// \param ... 
//////////////////////////////////////////////////////////////////////////////
void XMLUtil::filelog(char* fmt, ...)
{
	ofstream file(XML_ERROR_FILENAME, ios::out | ios::app);
	if (file.is_open())
	{
		va_list valist;
		va_start(valist, fmt);
		char message_buffer[30000] = {0, };
		int nchars = vsnprintf(message_buffer, 30000, fmt, valist);
		if (nchars == -1 || nchars > 30000)
		{
			filelog(NULL, "filelog buffer overflow!");
			throw ("filelog() : more buffer size needed for log");
		}
		va_end(valist);

		time_t now = time(0);
		char time_buffer[256] = {0, };
		sprintf(time_buffer, "%s : ", ctime(&now));

		file.write(time_buffer, (streamsize)strlen(time_buffer));
		file.write(message_buffer, (streamsize)strlen(message_buffer));
		file.write("\n", (streamsize)strlen("\n"));
	}
}

//////////////////////////////////////////////////////////////////////////////
//
//	XMLAttribute
//
//////////////////////////////////////////////////////////////////////////////

XMLAttribute::XMLAttribute( const string &name, const string &value )
: m_Name( name ), m_Value( value )
{
}

XMLAttribute::~XMLAttribute()
{
}

void
XMLAttribute::SetValue( string value )
{
	m_Value = value;
}

const char*
XMLAttribute::GetName() const
{
	return m_Name.c_str();
}

const char*
XMLAttribute::ToString() const
{
	return m_Value.c_str();
}

const int
XMLAttribute::ToInt() const
{
	return atoi( m_Value.c_str() );
}

const DWORD
XMLAttribute::ToHex() const
{
	return strtoul( m_Value.c_str(), NULL, 16 );
}

const bool
XMLAttribute::ToBool() const
{
	return ( m_Value == "true" || m_Value == "TRUE" ) ? true : false;
}

const double	
XMLAttribute::ToDouble() const
{
	return atof( m_Value.c_str() );
}

const float
XMLAttribute::ToFloat() const
{
	return (float)atof( m_Value.c_str() );
}


//////////////////////////////////////////////////////////////////////////////
//
//	XMLTree
//
//////////////////////////////////////////////////////////////////////////////

XMLTree::XMLTree()
: m_pParent( NULL )
{
}

XMLTree::XMLTree( const string& name )
: m_Name( name ), m_pParent( NULL )
{
}

XMLTree::~XMLTree()
{
	Release();
}

const string&
XMLTree::GetName() const
{
	return m_Name;
}

void
XMLTree::SetName( const string& name )
{
	m_Name = name;
}

const string&
XMLTree::GetText() const
{
	return m_Text;
}

void
XMLTree::SetText( const string& text )
{
	m_Text = text;
}

const XMLTree*
XMLTree::GetParent() const
{
	return m_pParent;
}

void
XMLTree::SetParent( XMLTree* pParent )
{
	m_pParent = pParent;
}

void XMLTree::AddAttribute( const string& name, const string& value )
{
	ATTRIBUTES_MAP::iterator itr = m_AttributesMap.find( name );
	
	if ( itr == m_AttributesMap.end() )
	{
		XMLAttribute *pAttr = new XMLAttribute( name, value );
		
		m_AttributesVector.push_back( pAttr );
		m_AttributesMap.insert( ATTRIBUTES_MAP::value_type( name, pAttr ) );
	}
	else
	{
		XMLAttribute *pAttr = itr->second;
		pAttr->SetValue( value );
	}
}

void XMLTree::AddAttribute( const string& name, const char *value )
{
	AddAttribute( name, string(value) );
}

void XMLTree::AddAttribute( const string& name, const int& value )
{
	char szTemp[20];
	itoa( value, szTemp, 10 );
	AddAttribute( name, string(szTemp) );
}

void XMLTree::AddAttribute( const string& name, const unsigned int& value, const bool bHex )
{
	char szTemp[20];
	if( bHex == true )
		itoa( value, szTemp, 16 );
	else
		itoa( value, szTemp, 10 );

	AddAttribute( name, string(szTemp) );
}

void XMLTree::AddAttribute( const string& name, const DWORD& value, const bool bHex )
{
	char szTemp[20];
	if( bHex == true )
		itoa( value, szTemp, 16 );
	else
		itoa( value, szTemp, 10 );

	AddAttribute( name, string(szTemp) );
}

void XMLTree::AddAttribute( const string& name, const float& value )
{
	char szTemp[512];
	sprintf( szTemp, "%f", value );
	AddAttribute( name, string(szTemp) );
}

void XMLTree::AddAttribute( const string& name, const double& value )
{
	char szTemp[512];
	sprintf( szTemp, "%f", value );
	AddAttribute( name, string(szTemp) );
}

void XMLTree::AddAttribute( const string& name, const bool& value )
{
	if( value == true )
		AddAttribute( name, string("true") );
	else
		AddAttribute( name, string("false") );
}

XMLAttribute *
XMLTree::GetAttribute( const string& name ) const
{
	if(m_AttributesMap.empty() == true)
		return NULL;

	ATTRIBUTES_MAP::const_iterator itr = m_AttributesMap.find( name );

	if( itr == m_AttributesMap.end() )
		return NULL;

	return itr->second;
}

const bool
XMLTree::GetAttribute( const string& name, string &value )
{
	const XMLAttribute *pAttr = GetAttribute( name );

	if( pAttr == NULL )
		return false;

	value = pAttr->ToString();

	return true;
}

const bool
XMLTree::GetAttribute( const string& name, int &value )
{
	const XMLAttribute *pAttr = GetAttribute( name );

	if( pAttr == NULL )
		return false;