Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

XObject.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(XOBJECT_HEADER_GUARD_1357924680)
#define XOBJECT_HEADER_GUARD_1357924680



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



#include <xalanc/XalanDOM/XalanDOMString.hpp>



#include <xalanc/PlatformSupport/DoubleSupport.hpp>
#include <xalanc/PlatformSupport/FormatterListener.hpp>
#include <xalanc/PlatformSupport/XalanReferenceCountedObject.hpp>



#include <xalanc/DOMSupport/DOMServices.hpp>



#include <xalanc/XPath/NodeRefListBase.hpp>
#include <xalanc/XPath/XalanXPathException.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class MutableNodeRefList;
class NodeRefListBase;
class XalanDocumentFragment;
class XObjectFactory;
class XObjectTypeCallback;
class XPathExecutionContext;



class XALAN_XPATH_EXPORT XObject : protected XalanReferenceCountedObject
{
public:

    friend class XObjectPtr;

    enum    eObjectType { eTypeNull = 0,
                          eTypeUnknown = 1,
                          eTypeBoolean = 2,
                          eTypeNumber = 3,
                          eTypeString = 4,
                          eTypeNodeSet = 5,
                          eTypeResultTreeFrag = 6,
                          eTypeUserDefined = 7,
                          // These next types are implementation-specific, and
                          // are never returned by getType().
                          eTypeStringReference = 8,
                          eTypeStringAdapter = 9,
                          eTypeStringCached = 10,
                          eTypeXTokenNumberAdapter = 11,
                          eTypeXTokenStringAdapter = 12,
                          eTypeNodeSetNodeProxy = 13,
                          eUnknown
                        };

    static void
    initialize(MemoryManagerType& theManager);

    static void
    terminate();

    XObject(eObjectType     theObjectType);

    XObject(const XObject&  source);


    virtual const XalanDOMString&
    getTypeString() const = 0;

    virtual double
    num() const;

    virtual bool
    boolean() const;

    virtual const XalanDOMString&
    str() const;

    typedef void (FormatterListener::*MemberFunctionPtr)(const XMLCh* const, const unsigned int);

    virtual void
    str(
            FormatterListener&  formatterListener,
            MemberFunctionPtr   function) const = 0;

    virtual double
    stringLength() const = 0;

    virtual void
    str(XalanDOMString& theBuffer) const;

    virtual const XalanDocumentFragment&
    rtree() const;

    virtual const NodeRefListBase&
    nodeset() const;

    virtual void
    ProcessXObjectTypeCallback(XObjectTypeCallback&     theCallbackObject) = 0;

    virtual void
    ProcessXObjectTypeCallback(XObjectTypeCallback&     theCallbackObject) const = 0;

    bool
    equals(
            const XObject&          theRHS,
            XPathExecutionContext&  executionContext) const;

    bool
    notEquals(
            const XObject&          theRHS,
            XPathExecutionContext&  executionContext) const;

    bool
    lessThan(
            const XObject&          theRHS,
            XPathExecutionContext&  executionContext) const;

    bool
    lessThanOrEquals(
            const XObject&          theRHS,
            XPathExecutionContext&  executionContext) const;

    bool
    greaterThan(
            const XObject&          theRHS,
            XPathExecutionContext&  executionContext) const;

    bool
    greaterThanOrEquals(
            const XObject&          theRHS,
            XPathExecutionContext&  executionContext) const;

    eObjectType
    getType() const
    {
        return m_objectType;
    }

    static bool
    boolean(double  theNumber)
    {
        return !DoubleSupport::isNaN(theNumber) && !DoubleSupport::equal(theNumber, 0.0);
    }

    static bool
    boolean(const XalanDOMString&   theString)
    {
        return theString.length() == 0 ? false : true;
    }

    static bool
    boolean(const NodeRefListBase&  theNodeList)
    {
        return theNodeList.getLength() == 0 ? false : true;
    }

    static const XalanDOMString&
    string(bool     theBool)
    {
        return theBool == true ? s_trueString : s_falseString;
    }

    static void
    string(
            bool                theBool,
            FormatterListener&  formatterListener,
            MemberFunctionPtr   function)
    {
        if(theBool == true)
        {
            (formatterListener.*function)(s_trueString.c_str(), s_trueString.length());
        }
        else
        {
            (formatterListener.*function)(s_falseString.c_str(), s_falseString.length());
        }
    }

    static void
    string(
            double              theNumber,
            XalanDOMString&     theString)
    {
        DoubleToDOMString(theNumber, theString);
    }

    static void
    string(
            double              theNumber,
            FormatterListener&  formatterListener,
            MemberFunctionPtr   function)
    {
        DOMStringHelper::DoubleToCharacters(theNumber, formatterListener, function);
    }

    static void
    string(
            const XalanNode&    theNode,
            XalanDOMString&     theString)
    {
        DOMServices::getNodeData(theNode, theString);
    }

    static void
    string(
            const XalanNode&    theNode,
            FormatterListener&  formatterListener,
            MemberFunctionPtr   function)
    {
        DOMServices::getNodeData(theNode, formatterListener, function);
    }

    static void
    string(
            const NodeRefListBase&  theNodeList,
            XalanDOMString&         theString)
    {
        if (theNodeList.getLength() > 0)
        {
            assert(theNodeList.item(0) != 0);

            string(*theNodeList.item(0), theString);
        }
    }

    static void
    string(
            const NodeRefListBase&  theNodeList,
            FormatterListener&      formatterListener,
            MemberFunctionPtr       function)
    {
        if (theNodeList.getLength() > 0)
        {
            assert(theNodeList.item(0) != 0);

            DOMServices::getNodeData(*theNodeList.item(0), formatterListener, function);
        }
    }

    static double
    number(bool     theBoolean)
    {
        return theBoolean == true ? 1.0 : 0.0;
    }

    static double
    number(const XalanDOMString&    theString,
            MemoryManagerType&      theManager)
    {
        return DoubleSupport::toDouble(theString, theManager);
    }

    static double
    number(
            XPathExecutionContext&  executionContext,
            const NodeRefListBase&  theNodeList);

    static double
    number(
            XPathExecutionContext&  executionContext,
            const XalanNode&        theNode);


    // All XObject instances are controlled by an instance of an XObjectFactory.
    friend class XObjectFactory;

    void
    setFactory(XObjectFactory*  theFactory)
    {
        m_factory = theFactory;
    }

    // Base class for all XObject exceptions...
    class XObjectException : public XalanXPathException
    {
    public:

        explicit
        XObjectException(
                const XalanDOMString&   message = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
                MemoryManagerType& theManager = XalanMemMgrs::getDummyMemMgr());

        XObjectException( const XObjectException& other) ;

        virtual
        ~XObjectException();

        virtual const XalanDOMChar*
        getType() const
        {
            return m_type;
        }
    private:

        static const XalanDOMChar   m_type[];
    };

    class XObjectInvalidConversionException : public XObjectException
    {
    public:

        XObjectInvalidConversionException(
                                eObjectType fromType,
                                eObjectType toType);


        XObjectInvalidConversionException( const XObjectInvalidConversionException& other);

        virtual
        ~XObjectInvalidConversionException();

        virtual const XalanDOMChar*
        getType() const
        {
            return m_type;
        }


    private:

        static const XalanDOMChar   m_type[];

        static const XalanDOMString&
        formatErrorString(
                const XalanDOMString&   fromType,
                const XalanDOMString&   toType,
                XalanDOMString&         theResult);


        const eObjectType       m_from;

        const eObjectType       m_to;
    };

protected:

    virtual eObjectType
    getRealType() const;

    virtual void 
    referenced();

    virtual void 
    dereferenced();

    virtual
    ~XObject();

    static const XalanDOMString     s_emptyString;

    static const XalanDOMString&    s_booleanString;

    static const XalanDOMString&    s_falseString;

    static const XalanDOMString&    s_nodesetString;

    static const XalanDOMString&    s_numberString;

    static const XalanDOMString&    s_resultTreeFragmentString;

    static const XalanDOMString&    s_stringString;

    static const XalanDOMString&    s_trueString;

private:

    // Not implemented...
    XObject&
    operator=(const XObject&);

    const eObjectType   m_objectType;

    XObjectFactory*     m_factory;
};



class XALAN_XPATH_EXPORT XObjectPtr
{
public:

    friend bool operator==(const XObjectPtr&, const XObjectPtr&);
    friend bool operator<(const XObjectPtr&, const XObjectPtr&);

    explicit
    XObjectPtr(XObject*     theXObject = 0) :
        m_xobjectPtr(theXObject)
    {
        XalanReferenceCountedObject::addReference(theXObject);
    }
    
    XObjectPtr(const XObjectPtr&    theSource) :
        m_xobjectPtr(theSource.m_xobjectPtr)
    { 
        XalanReferenceCountedObject::addReference(m_xobjectPtr);
    };

    XObjectPtr&
    operator=(const XObjectPtr&     theRHS)
    { 
        if (m_xobjectPtr != theRHS.m_xobjectPtr)
        {
            XalanReferenceCountedObject::removeReference(m_xobjectPtr);

            m_xobjectPtr = theRHS.m_xobjectPtr;

            XalanReferenceCountedObject::addReference(m_xobjectPtr);
        }

        return *this;
    }

    ~XObjectPtr()
    {
        XalanReferenceCountedObject::removeReference(m_xobjectPtr);
    };  

    void
    release()
    {
        XObject* const  xobjectPtr = m_xobjectPtr;

        m_xobjectPtr = 0;

        XalanReferenceCountedObject::removeReference(xobjectPtr);
    }

    bool
    null() const
    {
        return m_xobjectPtr == 0 ? true : false;
    }

    const XObject&
    operator*() const
    {
        return *m_xobjectPtr;
    };

    XObject&
    operator*() 
    {
        return *m_xobjectPtr;
    };

    const XObject*
    operator->() const
    {
        return m_xobjectPtr;
    };

    XObject*
    operator->()
    {
        return m_xobjectPtr;
    };

    const XObject*
    get() const
    {
        return m_xobjectPtr;
    };

    XObject*
    get()
    {
        return m_xobjectPtr;
    };

private:

    XObject*    m_xobjectPtr;
};



inline bool
operator==(
            const XObjectPtr&   theLHS,
            const XObjectPtr&   theRHS)
{
    return theLHS.m_xobjectPtr == theRHS.m_xobjectPtr;
}



inline bool
operator!=(
            const XObjectPtr&   theLHS,
            const XObjectPtr&   theRHS)
{
    return !(theLHS == theRHS);
}



inline bool
operator<(
            const XObjectPtr&   theLHS,
            const XObjectPtr&   theRHS)
{
    return theLHS.m_xobjectPtr < theRHS.m_xobjectPtr;
}



XALAN_CPP_NAMESPACE_END



#endif  // XOBJECT_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.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.