Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.9

XObjectFactory.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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(XOBJECTFACTORY_HEADER_GUARD_1357924680)
#define XOBJECTFACTORY_HEADER_GUARD_1357924680



// Base include file.  Must be first.
#include <xalanc/XPath/XPathDefinitions.hpp>



#include <algorithm>
#include <cassert>


#include <xalanc/XPath/XObject.hpp>
#include <xalanc/XPath/XPathExecutionContext.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class XalanNode;
class MutableNodeRefList;
class NodeRefListBase;
class XObject;
class XObjectPtr;
class XToken;



class XALAN_XPATH_EXPORT XObjectFactory
{
public:

    typedef XPathExecutionContext::BorrowReturnMutableNodeRefList   BorrowReturnMutableNodeRefList;
    typedef XPathExecutionContext::GetAndReleaseCachedString        GetAndReleaseCachedString;


    XObjectFactory(MemoryManagerType& theManager);

    virtual
    ~XObjectFactory();


    MemoryManagerType&
    getMemoryManager()
    {
        return m_memoryManager;
    }

    bool
    returnObject(XObject*   theXObject)
    {
        return doReturnObject(theXObject);
    }

    virtual void
    reset() = 0;

    virtual const XObjectPtr
    createBoolean(bool  theValue) = 0;

    virtual const XObjectPtr
    createNodeSet(BorrowReturnMutableNodeRefList&   theValue) = 0;

    virtual const XObjectPtr
    createNodeSet(XalanNode*    theValue) = 0;

    virtual const XObjectPtr
    createNull() = 0;

    virtual const XObjectPtr
    createNumber(double     theValue) = 0;

    virtual const XObjectPtr
    createNumber(const XToken&  theValue) = 0;

    virtual const XObjectPtr
    createString(const XalanDOMString&  theValue) = 0;

    virtual const XObjectPtr
    createString(const XalanDOMChar*    theValue) = 0;

    virtual const XObjectPtr
    createString(
            const XalanDOMChar*     theValue,
            unsigned int            theLength) = 0;

    virtual const XObjectPtr
    createString(const XToken&  theValue) = 0;

    virtual const XObjectPtr
    createStringReference(const XalanDOMString&     theValue) = 0;

    virtual const XObjectPtr
    createStringAdapter(const XObjectPtr&   theValue) = 0;

    virtual const XObjectPtr
    createString(GetAndReleaseCachedString&     theValue) = 0;

    virtual const XObjectPtr
    createUnknown(const XalanDOMString&     theValue) = 0;

#if defined(XALAN_NO_STD_NAMESPACE)
    struct DeleteXObjectFunctor : public unary_function<XObject*, void>
#else
    struct DeleteXObjectFunctor : public std::unary_function<XObject*, void>
#endif
    {
    public:

        DeleteXObjectFunctor(
            XObjectFactory&     theFactoryInstance,
            bool                fInReset = false) :
            m_factoryInstance(theFactoryInstance),
            m_fInReset(fInReset)
        {
        }

        result_type
        operator()(argument_type    theXObject) const
        {
            if (m_fInReset == true)
            {
                m_factoryInstance.doReturnObject(
                    theXObject,
                    true);
            }
            else
            {
                m_factoryInstance.returnObject(theXObject);
            }
        }

    private:

        XObjectFactory&     m_factoryInstance;

        const bool          m_fInReset;
    };

    friend struct DeleteXObjectFunctor;

protected:

    XObject::eObjectType
    getRealType(const XObject&  theXObject) const
    {
        return theXObject.getRealType();
    }

    void
    deleteObject(const XObject*     theXObject) const
    {
        if( theXObject!= 0)
        {
            XObject*    theTmpXObject = const_cast<XObject*>(theXObject);
            MemoryManagerType& theManager = const_cast<MemoryManagerType&>(m_memoryManager);

            theTmpXObject->~XObject();

            theManager.deallocate((void*)theTmpXObject);
        }
    
    }

    virtual bool
    doReturnObject(
            XObject*    theXObject,
            bool        fInReset = false) = 0;

private:

    // Not implemented...
    XObjectFactory(const XObjectFactory&);

    XObjectFactory&
    operator=(const XObjectFactory&);

    bool
    operator==(const XObjectFactory&) const;

    MemoryManagerType& m_memoryManager;
};



XALAN_CPP_NAMESPACE_END



#endif  // XOBJECTFACTORY_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.