| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #if !defined(XPATHFUNCTIONTABLE_HEADER_GUARD_1357924680) |
| #define XPATHFUNCTIONTABLE_HEADER_GUARD_1357924680 |
| |
| |
| |
| // Base include file. Must be first. |
| #include <xalanc/XPath/XPathDefinitions.hpp> |
| |
| |
| |
| #include <algorithm> |
| |
| |
| |
| #include <xalanc/XalanDOM/XalanDOMString.hpp> |
| |
| |
| |
| #include <xalanc/Include/STLHelper.hpp> |
| |
| |
| |
| #include <xalanc/XPath/Function.hpp> |
| #include <xalanc/XPath/XalanXPathException.hpp> |
| |
| |
| |
| XALAN_CPP_NAMESPACE_BEGIN |
| |
| |
| |
| /** |
| * Exception class thrown when an unknown function is encountered |
| */ |
| class XALAN_XPATH_EXPORT XPathExceptionFunctionNotAvailable : public XalanXPathException |
| { |
| public: |
| |
| typedef Function::LocatorType LocatorType; |
| |
| XPathExceptionFunctionNotAvailable(const XalanDOMString& theFunctionNumber, |
| XalanDOMString& theResult); |
| |
| XPathExceptionFunctionNotAvailable( |
| const XalanDOMString& theFunctionNumber, |
| const LocatorType& theLocator, |
| XalanDOMString& theResult); |
| |
| ~XPathExceptionFunctionNotAvailable(); |
| }; |
| |
| |
| |
| /** |
| * Exception class thrown when an installFunction() is called with a |
| * function name that is not supported. |
| */ |
| class XALAN_XPATH_EXPORT XPathExceptionFunctionNotSupported : public XalanXPathException |
| { |
| public: |
| |
| XPathExceptionFunctionNotSupported(const XalanDOMChar* theFunctionName, |
| XalanDOMString& theResult); |
| |
| ~XPathExceptionFunctionNotSupported(); |
| }; |
| |
| |
| |
| /** |
| * Class defines a table of functions that can be called in XPath expresions. |
| */ |
| class XALAN_XPATH_EXPORT XPathFunctionTable |
| { |
| public: |
| |
| enum { InvalidFunctionNumberID = -1, TableSize = 36 }; |
| |
| typedef size_t SizeType; |
| typedef XalanDOMString::size_type StringSizeType; |
| typedef DeleteFunctor<Function> DeleteFunctorType; |
| |
| /** |
| * Constructor. |
| * |
| * @param fCreateTable If true, the internal table will be created. Otherwise, CreateTable() must be called. |
| */ |
| XPathFunctionTable(bool fCreateTable = true); |
| |
| ~XPathFunctionTable(); |
| |
| void |
| setMemoryManager(MemoryManagerType& theManager) |
| { |
| m_memoryManager = &theManager; |
| } |
| /** |
| * Set up the internal table. |
| */ |
| void |
| CreateTable(); |
| |
| /** |
| * Destroy the internal table. |
| */ |
| void |
| DestroyTable(); |
| |
| /** |
| * Retrieve the function object for a specified function name. |
| * |
| * @param theFunctionName name of function |
| * @return function named |
| */ |
| const Function& |
| operator[](const XalanDOMString& theFunctionName) const |
| { |
| const int theFunctionID = |
| getFunctionIndex(theFunctionName); |
| |
| if (theFunctionID != InvalidFunctionNumberID) |
| { |
| return *m_functionTable[theFunctionID]; |
| } |
| else |
| { |
| MemoryManagerType* theManager = const_cast<MemoryManagerType*>(m_memoryManager); |
| |
| XalanDOMString theResult(*theManager); |
| |
| throw XPathExceptionFunctionNotAvailable(theFunctionName, theResult); |
| } |
| } |
| |
| /** |
| * Retrieve the function object for a specified function ID number. |
| * |
| * @param theFunctionID ID number of the function |
| * @return function named |
| */ |
| const Function& |
| operator[](int theFunctionID) const |
| { |
| assert(theFunctionID >= 0 && theFunctionID < TableSize); |
| assert(m_functionTable[theFunctionID] != 0); |
| |
| return *m_functionTable[theFunctionID]; |
| } |
| |
| /** |
| * Map a function ID to the corresponding name. |
| * |
| * @param theFunctionID The ID number of the function |
| * @return The name of the function, or an empty string if the function doesn't exist. |
| */ |
| const XalanDOMString& |
| idToName(int theFunctionID, |
| XalanDOMString& theResult) const |
| { |
| |
| if (theFunctionID >= 0 && theFunctionID < TableSize) |
| { |
| theResult.assign( |
| s_functionNames[theFunctionID].m_name, |
| s_functionNames[theFunctionID].m_size); |
| } |
| |
| return theResult; |
| } |
| |
| /** |
| * Map a function name to the corresponding ID number. |
| * |
| * @param theName name of function |
| * @return The ID number of function, or InvalidFunctionNumberID if the function doesn't exist. |
| */ |
| int |
| nameToID(const XalanDOMString& theName) const |
| { |
| return getFunctionIndex(theName); |
| } |
| |
| /** |
| * Insert a named function into the function table. |
| * |
| * @param theFunctionName name of function |
| * @param theFunction function object corresponding to name |
| */ |
| void |
| InstallFunction( |
| const XalanDOMString& theFunctionName, |
| const Function& theFunction) |
| { |
| InstallFunction(theFunctionName.c_str(), theFunction); |
| } |
| |
| /** |
| * Remove a named function from the function table. |
| * |
| * @param theFunctionName name of function |
| * @return true if the function was found and removed. |
| */ |
| bool |
| UninstallFunction(const XalanDOMString& theFunctionName) |
| { |
| return UninstallFunction(theFunctionName.c_str()); |
| } |
| |
| /** |
| * Insert a named function into the function table. |
| * |
| * @param theFunctionName name of function |
| * @param theFunction function object corresponding to name |
| */ |
| void |
| InstallFunction( |
| const XalanDOMChar* theFunctionName, |
| const Function& theFunction); |
| |
| /** |
| * Remove a named function from the function table. |
| * |
| * @param theFunctionName name of function |
| * @return true if the function was found and removed. |
| */ |
| bool |
| UninstallFunction(const XalanDOMChar* theFunctionName); |
| |
| /** |
| * Whether a named function is in the function table. |
| * |
| * @param theFunctionName name of function |
| * @return true if function is in table |
| */ |
| bool |
| isInstalledFunction(const XalanDOMString& theFunctionName) const |
| { |
| return getFunctionIndex(theFunctionName) != InvalidFunctionNumberID ? true : false; |
| } |
| |
| #if defined(XALAN_NO_MEMBER_TEMPLATES) |
| |
| typedef XalanVector<XalanDOMString> InstalledFunctionNameVectorType; |
| |
| /** |
| * Add a list of the names of installed functions to a vector of names. |
| * |
| * @param theVector vector of function name strings added to |
| */ |
| void |
| getInstalledFunctionNames(InstalledFunctionNameVectorType& theVector) const |
| { |
| XalanDOMString theString; |
| |
| for (int i = 0; i < TableSize; ++i) |
| { |
| if (m_functionTable[i] != 0) |
| { |
| theString.assign( |
| s_functionNames[i].m_name, |
| s_functionNames[i].m_size); |
| |
| theVector.push_back(theString); |
| } |
| } |
| } |
| #else |
| |
| /** |
| * Add a list of the names of installed functions to a vector of names. |
| * |
| * @param theIterator function table iterator to append names to |
| */ |
| template<class OutputIteratorType> |
| void |
| getInstalledFunctionNames(OutputIteratorType theIterator) const |
| { |
| XalanDOMString theString(XalanMemMgrs::getDefaultXercesMemMgr()); |
| |
| for (int i = 0; i < TableSize; ++i) |
| { |
| if (m_functionTable[i] != 0) |
| { |
| theString.assign( |
| s_functionNames[i].m_name, |
| s_functionNames[i].m_size); |
| |
| *theIterator = theString; |
| |
| ++theIterator; |
| } |
| } |
| } |
| #endif |
| |
| struct FunctionNameTableEntry |
| { |
| const XalanDOMChar* m_name; |
| |
| StringSizeType m_size; |
| }; |
| |
| // These are static strings for the functions supported. |
| // Note that the XSLT functions are also here, since it's |
| // just easier to do it this way. |
| |
| // The string "id" |
| static const XalanDOMChar s_id[]; |
| |
| // The string "key" |
| static const XalanDOMChar s_key[]; |
| |
| // The string "not" |
| static const XalanDOMChar s_not[]; |
| |
| // The string "sum" |
| static const XalanDOMChar s_sum[]; |
| |
| // The string "lang" |
| static const XalanDOMChar s_lang[]; |
| |
| // The string "last" |
| static const XalanDOMChar s_last[]; |
| |
| // The string "name" |
| static const XalanDOMChar s_name[]; |
| |
| // The string "true" |
| static const XalanDOMChar s_true[]; |
| |
| // The string "count" |
| static const XalanDOMChar s_count[]; |
| |
| // The string "false" |
| static const XalanDOMChar s_false[]; |
| |
| // The string "floor" |
| static const XalanDOMChar s_floor[]; |
| |
| // The string "round" |
| static const XalanDOMChar s_round[]; |
| |
| // The string "concat" |
| static const XalanDOMChar s_concat[]; |
| |
| // The string "number" |
| static const XalanDOMChar s_number[]; |
| |
| // The string "string" |
| static const XalanDOMChar s_string[]; |
| |
| // The string "boolean" |
| static const XalanDOMChar s_boolean[]; |
| |
| // The string "ceiling" |
| static const XalanDOMChar s_ceiling[]; |
| |
| // The string "current" |
| static const XalanDOMChar s_current[]; |
| |
| // The string "contains" |
| static const XalanDOMChar s_contains[]; |
| |
| // The string "document" |
| static const XalanDOMChar s_document[]; |
| |
| // The string "position" |
| static const XalanDOMChar s_position[]; |
| |
| // The string "substring" |
| static const XalanDOMChar s_substring[]; |
| |
| // The string "translate" |
| static const XalanDOMChar s_translate[]; |
| |
| // The string "local-name" |
| static const XalanDOMChar s_localName[]; |
| |
| // The string "generate-id" |
| static const XalanDOMChar s_generateId[]; |
| |
| // The string "starts-with" |
| static const XalanDOMChar s_startsWith[]; |
| |
| // The string "format-number" |
| static const XalanDOMChar s_formatNumber[]; |
| |
| // The string "namespace-uri" |
| static const XalanDOMChar s_namespaceUri[]; |
| |
| // The string "string-length" |
| static const XalanDOMChar s_stringLength[]; |
| |
| // The string "normalize-space" |
| static const XalanDOMChar s_normalizeSpace[]; |
| |
| // The string "substring-after" |
| static const XalanDOMChar s_substringAfter[]; |
| |
| // The string "system-property" |
| static const XalanDOMChar s_systemProperty[]; |
| |
| // The string "substring-before" |
| static const XalanDOMChar s_substringBefore[]; |
| |
| // The string "element-available" |
| static const XalanDOMChar s_elementAvailable[]; |
| |
| // The string "function-available" |
| static const XalanDOMChar s_functionAvailable[]; |
| |
| // The string "unparsed-entity-uri" |
| static const XalanDOMChar s_unparsedEntityUri[]; |
| |
| // A table of function names. |
| static const FunctionNameTableEntry s_functionNames[]; |
| |
| // The size of the table. |
| static const SizeType s_functionNamesSize; |
| |
| private: |
| |
| static int |
| getFunctionIndex(const XalanDOMString& theName) |
| { |
| return getFunctionIndex( |
| theName.c_str(), |
| theName.length()); |
| } |
| |
| static int |
| getFunctionIndex(const XalanDOMChar* theName) |
| { |
| return getFunctionIndex( |
| theName, |
| XalanDOMString::length(theName)); |
| } |
| |
| static int |
| getFunctionIndex( |
| const XalanDOMChar* theName, |
| StringSizeType theNameLength); |
| |
| MemoryManagerType* m_memoryManager; |
| |
| const Function* m_functionTable[TableSize]; |
| |
| const Function** const m_functionTableEnd; |
| |
| // The last one in the table of function names. |
| static const FunctionNameTableEntry* const s_lastFunctionName; |
| }; |
| |
| |
| |
| XALAN_CPP_NAMESPACE_END |
| |
| |
| |
| #endif // XPATHFUNCTIONTABLE_HEADER_GUARD_1357924680 |