XalanEXSLTStringImpl.hpp

Go to the documentation of this file.

/*
 * 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(EXSLT_STRINGIMPL_HEADER_GUARD_1357924680)
#define EXSLT_STRINGIMPL_HEADER_GUARD_1357924680
 
 
 
#include "XalanEXSLTDefinitions.hpp"
 
 
 
#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>
 
 
 
#include <xalanc/XPath/Function.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAlign : public Function
{
public:
 
    typedef Function    ParentType;
 
    XalanEXSLTFunctionAlign()
    {
    }
 
 
    virtual
    ~XalanEXSLTFunctionAlign()
    {
    }
 
    // These methods are inherited from Function ...
 
    virtual XObjectPtr
    execute(
            XPathExecutionContext&          executionContext,
            XalanNode*                      context,
            const XObjectArgVectorType&     args,
            const Locator*                  locator) const;
 
    using ParentType::execute;
 
    virtual XalanEXSLTFunctionAlign*
    clone(MemoryManager&    theManager) const
    {
        return XalanCopyConstruct(theManager, *this);
    }
 
protected:
 
    const XalanDOMString&
    getError(XalanDOMString&    theBuffer) const
    {
        return XalanMessageLoader::getMessage(
                    theBuffer,
                    XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
                    "align()");
    }
 
private:
 
    // Not implemented...
    XalanEXSLTFunctionAlign&
    operator=(const XalanEXSLTFunctionAlign&);
 
    bool
    operator==(const XalanEXSLTFunctionAlign&) const;
 
 
    // Data members...
    static const XalanDOMChar   s_centerString[];
    static const XalanDOMChar   s_rightString[];
};
 
 
 
class XALAN_EXSLT_EXPORT XalanEXSLTFunctionConcat : public Function
{
public:
 
    typedef Function    ParentType;
 
    XalanEXSLTFunctionConcat() :
        Function()
    {
    }
 
    virtual
    ~XalanEXSLTFunctionConcat()
    {
    }
 
    // These methods are inherited from Function ...
 
    virtual XObjectPtr
    execute(
            XPathExecutionContext&          executionContext,
            XalanNode*                      context,
            const XObjectArgVectorType&     args,
            const Locator*                  locator) const;
 
    using ParentType::execute;
 
    virtual XalanEXSLTFunctionConcat*
    clone(MemoryManager&    theManager) const
    {
        return XalanCopyConstruct(theManager, *this);
    }
 
protected:
 
    const XalanDOMString&
    getError(XalanDOMString&    theBuffer) const
    {
        return XalanMessageLoader::getMessage(
                    theBuffer,
                    XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
                    "concat()");
    }
 
private:
 
    // Not implemented...
    XalanEXSLTFunctionConcat&
    operator=(const XalanEXSLTFunctionConcat&);
 
    bool
    operator==(const XalanEXSLTFunctionConcat&) const;
};
 
 
 
class XALAN_EXSLT_EXPORT XalanEXSLTFunctionPadding : public Function
{
public:
 
    typedef Function    ParentType;
 
    XalanEXSLTFunctionPadding(MemoryManager&  theManager) :
        Function(),
        m_space(s_spaceString, theManager)
    {
    }
 
    // A dummy constructor for use internally.  Do not use this one!!!!
    XalanEXSLTFunctionPadding(
                MemoryManager&  theManager,
                int                 /* theDummy */) :
        Function(),
        m_space(theManager)
    {
    }
 
    XalanEXSLTFunctionPadding(
                const XalanEXSLTFunctionPadding&    other,
                MemoryManager&                  theManager) :
        Function(other),
        m_space(s_spaceString, theManager)
    {
    }
 
    virtual
    ~XalanEXSLTFunctionPadding()
    {
    }
 
    // These methods are inherited from Function ...
 
    virtual XObjectPtr
    execute(
            XPathExecutionContext&          executionContext,
            XalanNode*                      context,
            const XObjectArgVectorType&     args,
            const Locator*                  locator) const;
 
    using ParentType::execute;
 
    virtual XalanEXSLTFunctionPadding*
    clone(MemoryManager&    theManager) const
    {
        return XalanCopyConstruct(theManager, *this, theManager);
    }
 
protected:
 
    const XalanDOMString&
    getError(XalanDOMString&    theBuffer) const
    {
        return XalanMessageLoader::getMessage(
                    theBuffer,
                    XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
                    "padding()");
    }
 
private:
 
    // Not implemented...
    XalanEXSLTFunctionPadding(const XalanEXSLTFunctionPadding&);
 
    XalanEXSLTFunctionPadding&
    operator=(const XalanEXSLTFunctionPadding&);
 
    bool
    operator==(const XalanEXSLTFunctionPadding&) const;
 
 
    // Data members...
    const XalanDOMString        m_space;
 
    static const XalanDOMChar   s_spaceString[];
};
 
 
class XALAN_EXSLT_EXPORT XalanEXSLTFunctionEncodeURI : public Function
{
public:
 
    typedef Function    ParentType;
 
    XalanEXSLTFunctionEncodeURI() :
        Function()
    {
    }
 
    virtual
    ~XalanEXSLTFunctionEncodeURI()
    {
    }
 
    // These methods are inherited from Function ...
 
    virtual XObjectPtr
    execute(
            XPathExecutionContext&          executionContext,
            XalanNode*                      context,
            const XObjectArgVectorType&     args,
            const Locator*                  locator) const;
 
    using ParentType::execute;
 
    virtual XalanEXSLTFunctionEncodeURI*
    clone(MemoryManager&    theManager) const
    {
        return XalanCopyConstruct(theManager, *this);
    }
 
protected:
 
    const XalanDOMString&
    getError(XalanDOMString&    theBuffer) const
    {
        return XalanMessageLoader::getMessage(
                    theBuffer,
                    XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
                    "encode-uri()");
    }
 
    const XalanDOMString&
    escapedOctet(
                XalanDOMChar        theChar,
                XalanDOMString&     theBuffer) const;
 
    static const XalanDOMChar               s_reservedChars[];
    static const XalanDOMString::size_type  s_reservedCharsSize;
 
    static const XalanDOMChar               s_excludedChars[];
    static const XalanDOMString::size_type  s_excludedCharsSize;
 
private:
 
    // Not implemented...
    XalanEXSLTFunctionEncodeURI&
    operator=(const XalanEXSLTFunctionEncodeURI&);
 
    bool
    operator==(const XalanEXSLTFunctionEncodeURI&) const;
};
 
 
 
class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDecodeURI : public Function
{
public:
 
    typedef Function    ParentType;
 
    XalanEXSLTFunctionDecodeURI() :
        Function()
    {
    }
 
    virtual
    ~XalanEXSLTFunctionDecodeURI()
    {
    }
 
    // These methods are inherited from Function ...
 
    virtual XObjectPtr
    execute(
            XPathExecutionContext&          executionContext,
            XalanNode*                      context,
            const XObjectArgVectorType&     args,
            const Locator*                  locator) const;
 
    using ParentType::execute;
 
    virtual XalanEXSLTFunctionDecodeURI*
    clone(MemoryManager&    theManager) const
    {
        return XalanCopyConstruct(theManager, *this);
    }
 
protected:
 
    const XalanDOMString&
    getError(XalanDOMString&    theBuffer) const
    {
        return XalanMessageLoader::getMessage(
                    theBuffer,
                    XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
                    "decode-uri()");
 
    }
 
    XalanDOMChar
    hexCharsToByte( 
            XPathExecutionContext&      executionContext,
            XalanNode*                  context,
            const Locator*              locator,
            const XalanDOMChar          highHexChar,
            const XalanDOMChar          lowHexChar) const;
 
    static const XalanDOMString::size_type s_octetSize;
 
private:
 
    // Not implemented...
    XalanEXSLTFunctionDecodeURI&
    operator=(const XalanEXSLTFunctionDecodeURI&);
 
    bool
    operator==(const XalanEXSLTFunctionDecodeURI&) const;
};
 
}
 
 
 
#endif  // EXSLT_STRINGIMPL_HEADER_GUARD_1357924680