xpathfunctions.h

简单的xml解析类

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

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

			Array<DomNode*> nodes = parms[0].getValueNodeSet(context);

			double total = 0;
			for( int i = 0; i < nodes.getSize(); ++i ) {
				String value = nodes[i]->getValue();
				if( !XPathToken(value).isCompatibleWith(XPathToken::NUMBER_DBL) ) {
					throw XPathException(String("Node does not contain a valid numeric data for use with function 'sum'", String::STATIC));
				}
				total += value.getAsDouble();
			}

			return XPathToken(total);
		}
	};




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

		virtual XPathToken execute( Array<DomNode*> search, DomNode* context, Array<XPathToken> parms )
		{
			if( parms[0].isCompatibleWith(XPathToken::BOOLEAN) ) {
				return XPathToken( parms[0].getValueBool() );
			}

			return XPathToken(false);
		}
	};




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

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




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

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

			if( parms[0].getType() == XPathToken::NODESET ) {
				Array<DomNode*> results = parms[0].getValueNodeSet(context);
				return XPathToken( results.getSize() == 0 );
			}

			return XPathToken( !parms[0].getValueBool() );
		}
	};




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

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




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

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

			return XPathToken( parms[0].getValueBool() || parms[1].getValueBool() );
		}
	};




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

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

			return XPathToken( parms[0].getValueBool() && parms[1].getValueBool() );
		}
	};




	/****
	 * \class XPathOperatorNotEqual
	 */
	class  XPathOperatorNotEqual :public XPathFunction
	{
	public:
		XPathOperatorNotEqual() :XPathFunction(String("!=", String::STATIC), 2)
		{}

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() != parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() != parms[1].getValueNumberInt());
			}

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




	/****
	 * \class XPathOperatorLessEqual
	 */
	class  XPathOperatorLessEqual :public XPathFunction
	{
	public:
		XPathOperatorLessEqual() :XPathFunction(String("<=", String::STATIC), 2)
		{}

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() <= parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() <= parms[1].getValueNumberInt());
			}

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




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

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() < parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() < parms[1].getValueNumberInt());
			}

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




	/****
	 * \class XPathOperatorGreatEqual
	 */
	class  XPathOperatorGreatEqual :public XPathFunction
	{
	public:
		XPathOperatorGreatEqual() :XPathFunction(String(">=", String::STATIC), 2)
		{}

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() >= parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() >= parms[1].getValueNumberInt());
			}

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




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

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() > parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() > parms[1].getValueNumberInt());
			}

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




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

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() + parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() + parms[1].getValueNumberInt());
			}
			if( parms[0].getType() == XPathToken::STRING || parms[1].getType() == XPathToken::STRING ) {
				return XPathToken(parms[0].getValue(context) + parms[1].getValue(context));
			}

			throw XPathException(String("Incompatible types for XPath operator '+'", String::STATIC));
		}
	};




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

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() - parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() - parms[1].getValueNumberInt());
			}

			throw XPathException(String("Incompatible types for XPath operator '-'", String::STATIC));
		}
	};




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

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() * parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() * parms[1].getValueNumberInt());
			}

			throw XPathException(String("Incompatible types for XPath operator '*'", String::STATIC));
		}
	};




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

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				if( parms[1].getValueNumberDouble() == 0.0 ) {
					throw XPathException(String("Divide by zero encountered in XPath expression", String::STATIC));
				}
				return XPathToken(parms[0].getValueNumberDouble() / parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				if( parms[1].getValueNumberInt() == 0 ) {
					throw XPathException(String("Divide by zero encountered in XPath expression", String::STATIC));
				}
				int parm0 = parms[0].getValueNumberInt();
				int parm1 = parms[1].getValueNumberInt();
				if( parm0 % parm1 == 0 ) {
					return XPathToken( parm0 / parm1 );
				}
				else {
					return XPathToken(parms[0].getValueNumberDouble() / parms[1].getValueNumberDouble());
				}
			}

			throw XPathException(String("Incompatible types for XPath operator 'div'", String::STATIC));
		}
	};




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

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

			return XPathToken( parms[0].getValueNumberInt() % parms[1].getValueNumberInt() );
		}
	};




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

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

			if( parms[0].getType() == XPathToken::NUMBER_DBL || parms[1].getType() == XPathToken::NUMBER_DBL ) {
				return XPathToken(parms[0].getValueNumberDouble() == parms[1].getValueNumberDouble());
			}
			if( parms[0].getType() == XPathToken::NUMBER_INT || parms[1].getType() == XPathToken::NUMBER_INT ) {
				return XPathToken(parms[0].getValueNumberInt() == parms[1].getValueNumberInt());
			}
			if( parms[0].getType() == XPathToken::BOOLEAN || parms[1].getType() == XPathToken::BOOLEAN ) {
				return XPathToken(parms[0].getValueBool() == parms[1].getValueBool());
			}

			if( parms[0].getType() == XPathToken::NODESET ) {
				Array<DomNode*> nodeset1 = parms[0].getValueNodeSet(context);

				if( parms[1].getType() == XPathToken::NODESET ) {
					Array<DomNode*> nodeset2 = parms[1].getValueNodeSet(context);

					if( nodeset1.getSize() != nodeset2.getSize() ) {
						return XPathToken(false);
					}
					for( int i = 0; i < nodeset1.getSize(); ++i ) {
						if( nodeset1[0] != nodeset2[1] ) {
							return XPathToken(false);
						}
					}
					return XPathToken(true);
				}
				if( nodeset1.getSize() > 0 ) {
					return XPathToken( parms[1].getValue(context) == nodeset1[0]->getValue() );
				}
				return XPathToken(false);
			}

			if( parms[1].getType() == XPathToken::NODESET ) {
				Array<DomNode*> nodeset1 = parms[1].getValueNodeSet(context);

				if( parms[0].getType() == XPathToken::NODESET ) {
					Array<DomNode*> nodeset2 = parms[0].getValueNodeSet(context);

					if( nodeset1.getSize() != nodeset2.getSize() ) {
						return XPathToken(false);
					}
					for( int i = 0; i < nodeset1.getSize(); ++i ) {
						if( nodeset1[0] != nodeset2[1] ) {
							return XPathToken(false);
						}
					}
					return XPathToken(true);
				}
				if( nodeset1.getSize() > 0 ) {
					return XPathToken( parms[0].getValue(context) == nodeset1[0]->getValue() );
				}
				return XPathToken(false);
			}

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



}}}	// namespaces


// Public External Variables ===============================================================================================

// Public Function Prototypes ==============================================================================================

// Public Inline Functions =================================================================================================

#endif // include guard