xpathfunctions.h

简单的xml解析类

//************************************************************************************************************************** 
//* Blue Xml Extension
//* Copyright (c) 2002-2004 Josh Harler
//* 
//* Blue - General Purpose C++ Library
//* Copyright (c) 2002-2004 Josh Harler
//* 
//* This software is provided 'as-is', without any express or implied warranty. In no event
//* will the authors be held liable for any damages arising from the use of this software.
//* 
//* Permission is granted to anyone to use this software for any purpose, including commercial
//* applications, and to alter it and redistribute it freely, subject to the following restrictions:
//* 
//* 	1. The origin of this software must not be misrepresented; you must not claim that you
//* 	wrote the original software. If you use this software in a product, an acknowledgment in the
//* 	product documentation would be appreciated but is not required.
//* 
//* 	2. Altered source versions must be plainly marked as such, and must not be misrepresented as
//* 	being the original software.
//* 
//* 	3. This notice may not be removed or altered from any source distribution.
//*
//*
//* file   Blue/Extension/Xml/XPathFunctions.h
//**

#ifndef __blue_ext_xml_XPathFunctions_h_included__
#define __blue_ext_xml_XPathFunctions_h_included__

// Public Headers ==========================================================================================================

#include "../XPathExpression.h"


// Public Defines/Enums/Typedefs/Etc. ======================================================================================

// Public Classes/Structs ==================================================================================================

namespace blue {
namespace ext {
namespace xml {

	/****
	 * Functions
	 */
	class XPathFunctionCount;
//	class XPathFunctionId;
	class XPathFunctionLast;
	class XPathFunctionLocalName;
	class XPathFunctionName;
//	class XPathFunctionNamespaceUri;
	class XPathFunctionPosition;
	class XPathFunctionConcat;
	class XPathFunctionContains;
	class XPathFunctionNormalizeSpace;
	class XPathFunctionStartsWith;
	class XPathFunctionString;
	class XPathFunctionStringLength;
	class XPathFunctionSubstring;
	class XPathFunctionSubstringAfter;
	class XPathFunctionSubstringBefore;
	class XPathFunctionTranslate;
	class XPathFunctionCeiling;
	class XPathFunctionFloor;
	class XPathFunctionRound;
	class XPathFunctionSum;
	class XPathFunctionBoolean;
	class XPathFunctionFalse;
//	class XPathFunctionLang;
	class XPathFunctionNot;
	class XPathFunctionTrue;

	/****
	 * Operators
	 */
	class XPathOperatorOr;
	class XPathOperatorAnd;
	class XPathOperatorNotEqual;
	class XPathOperatorLessEqual;
	class XPathOperatorLess;
	class XPathOperatorGreatEqual;
	class XPathOperatorGreat;
	class XPathOperatorAdd;
	class XPathOperatorSub;
	class XPathOperatorMult;
	class XPathOperatorDiv;
	class XPathOperatorMod;
	class XPathOperatorEqual;




	/****
	 * \class XPathFunctionCount
	 */
	class  XPathFunctionCount :public XPathFunction
	{
	public:
		XPathFunctionCount() :XPathFunction(String("count", String::STATIC), 1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::NODESET);

			return XPathToken(parms[0].getValueNodeSet(context).getSize());
		}
	};




	/****
	 * \class XPathFunctionLast
	 */
	class  XPathFunctionLast :public XPathFunction
	{
	public:
		XPathFunctionLast() :XPathFunction(String("last", String::STATIC), 0)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			return XPathToken(search.getSize());
		}
	};




	/****
	 * \class XPathFunctionLocalName
	 */
	class  XPathFunctionLocalName :public XPathFunction
	{
	public:
		XPathFunctionLocalName() :XPathFunction(String("local-name", String::STATIC), 0)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			String name = context->getName();
			int posColon = name.findPos(":");
			if( posColon != String::npos ) {
				name = name.stripFromLeft(posColon + 1);
			}
			return XPathToken(name);
		}
	};




	/****
	 * \class XPathFunctionName
	 */
	class  XPathFunctionName :public XPathFunction
	{
	public:
		XPathFunctionName() :XPathFunction(String("name", String::STATIC), 0)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			return XPathToken( context->getName() );
		}
	};




	/****
	 * \class XPathFunctionPosition
	 */
	class  XPathFunctionPosition :public XPathFunction
	{
	public:
		XPathFunctionPosition() :XPathFunction(String("position", String::STATIC), 0)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			for( int i = 0; i < search.getSize(); ++i ) {
				if( search[i] == context ) {
					return XPathToken(i + 1);
				}
			}

			return XPathToken(1);
		}
	};




	/****
	 * \class XPathFunctionConcat
	 */
	class  XPathFunctionConcat :public XPathFunction
	{
	public:
		XPathFunctionConcat() :XPathFunction(String("concat", String::STATIC), -1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			String result;
			for( int i = 0; i < parms.getSize(); ++i ) {
				validateParm(parms[0], XPathToken::STRING);
				result += parms[0].getValue(context);
			}

			return XPathToken(result);
		}
	};




	/****
	 * \class XPathFunctionContains
	 */
	class  XPathFunctionContains :public XPathFunction
	{
	public:
		XPathFunctionContains() :XPathFunction(String("contains", String::STATIC), 2)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);
			validateParm(parms[1], XPathToken::STRING);

			return XPathToken( parms[0].getValue(context).findPos(parms[1].getValue(context)) != String::npos );
		}
	};




	/****
	 * \class XPathFunctionNormalizeSpace
	 */
	class  XPathFunctionNormalizeSpace :public XPathFunction
	{
	public:
		XPathFunctionNormalizeSpace() :XPathFunction(String("normalize-space", String::STATIC), 1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);

			return XPathToken( parms[0].getValue(context).trim() );
		}
	};




	/****
	 * \class XPathFunctionStartsWith
	 */
	class  XPathFunctionStartsWith :public XPathFunction
	{
	public:
		XPathFunctionStartsWith() :XPathFunction(String("starts-with", String::STATIC), 2)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);
			validateParm(parms[1], XPathToken::STRING);

			return XPathToken( parms[0].getValue(context).beginsWith(parms[1].getValue(context)) );
		}
	};




	/****
	 * \class XPathFunctionString
	 */
	class  XPathFunctionString :public XPathFunction
	{
	public:
		XPathFunctionString() :XPathFunction(String("string", String::STATIC), 1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			return XPathToken( (parms[0].isCompatibleWith(XPathToken::STRING) ? parms[0].getValue(context) : String::null) );
		}
	};




	/****
	 * \class XPathFunctionStringLength
	 */
	class  XPathFunctionStringLength :public XPathFunction
	{
	public:
		XPathFunctionStringLength() :XPathFunction(String("string-length", String::STATIC), 1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);

			return XPathToken( parms[0].getValue(context).getLength() );
		}
	};




	/****
	 * \class XPathFunctionSubstring
	 */
	class  XPathFunctionSubstring :public XPathFunction
	{
	public:
		XPathFunctionSubstring() :XPathFunction(String("substring", String::STATIC), 3)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);
			validateParm(parms[1], XPathToken::NUMBER_INT);
			validateParm(parms[2], XPathToken::NUMBER_INT);

			return XPathToken( parms[0].getValue(context).subString(parms[1].getValueNumberInt(), parms[2].getValueNumberInt()) );
		}
	};




	/****
	 * \class XPathFunctionSubstringAfter
	 */
	class  XPathFunctionSubstringAfter :public XPathFunction
	{
	public:
		XPathFunctionSubstringAfter() :XPathFunction(String("substring-after", String::STATIC), 2)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);
			validateParm(parms[1], XPathToken::STRING);

			String value1 = parms[0].getValue(context);
			String value2 = parms[1].getValue(context);

			return XPathToken( value1.subString(value1.findPos(value2)) );
		}
	};




	/****
	 * \class XPathFunctionSubstringBefore
	 */
	class  XPathFunctionSubstringBefore :public XPathFunction
	{
	public:
		XPathFunctionSubstringBefore() :XPathFunction(String("substring-before", String::STATIC), 2)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);
			validateParm(parms[1], XPathToken::STRING);

			String value1 = parms[0].getValue(context);
			String value2 = parms[1].getValue(context);

			int pos = value1.findPos(value2);
			if( pos == String::npos ) {
				pos = value1.getLength();
			}

			return XPathToken( value1.left(pos) );
		}
	};




	/****
	 * \class XPathFunctionTranslate
	 */
	class  XPathFunctionTranslate :public XPathFunction
	{
	public:
		XPathFunctionTranslate() :XPathFunction(String("translate", String::STATIC), 3)
		{}

		virtual XPathToken execute( Array<DomNode*> , DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::STRING);
			validateParm(parms[1], XPathToken::STRING);
			validateParm(parms[2], XPathToken::STRING);

			String source = parms[0].getValue(context);
			String search = parms[1].getValue(context);
			String transl = parms[2].getValue(context);
			String result;

			if( search.getLength() != transl.getLength() ) {
				throw XPathException(String("The second and third parameters to XPath function 'translate' must be the same length", String::STATIC));
			}

			for( int i = 0; i < source.getLength(); ++i ) {
				char ch = source[i];
				for( int iS = 0; iS < search.getLength(); ++iS ) {
					if( ch == search[iS] ) {
						ch = transl[iS];
					}
				}

				result += ch;
			}
			
			return XPathToken(result);
		}
	};




	/****
	 * \class XPathFunctionCeiling
	 */
	class  XPathFunctionCeiling :public XPathFunction
	{
	public:
		XPathFunctionCeiling() :XPathFunction(String("ceiling", String::STATIC), 1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::NUMBER_DBL);

			double dblValue = parms[0].getValueNumberDouble();
			int    intValue = (int)dblValue;

			if( (double)intValue < dblValue ) {
				return XPathToken(intValue + 1);
			}
			else {
				return XPathToken(intValue);
			}
		}
	};




	/****
	 * \class XPathFunctionFloor
	 */
	class  XPathFunctionFloor :public XPathFunction
	{
	public:
		XPathFunctionFloor() :XPathFunction(String("floor", String::STATIC), 1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::NUMBER_DBL);

			if( parms[0].getValue(context).isValidInt() ) {
				return XPathToken( parms[0].getValueNumberInt() );
			}

			double dblValue = parms[0].getValueNumberDouble();
			int    intValue = (int)dblValue;

			if( (double)(intValue + 1) > dblValue ) {
				return XPathToken(intValue);
			}
			else {
				return XPathToken(intValue + 1);
			}
		}
	};




	/****
	 * \class XPathFunctionRound
	 */
	class  XPathFunctionRound :public XPathFunction
	{
	public:
		XPathFunctionRound() :XPathFunction(String("round", String::STATIC), 1)
		{}

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			validateParm(parms[0], XPathToken::NUMBER_DBL);

			if( parms[0].getValue(context).isValidInt() ) {
				return XPathToken( parms[0].getValueNumberInt() );
			}

			double dblValue = parms[0].getValueNumberDouble();
			
			if( dblValue >= 0 ) {
				return XPathToken( (int)(dblValue + .5) );
			}
			else {
				return XPathToken( (int)(dblValue - .5) );
			}
		}
	};