Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

VariablesStack.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(XALAN_VARIABLESSTACK_HEADER_GUARD)
#define XALAN_VARIABLESSTACK_HEADER_GUARD



// Base include file.  Must be first.
#include <xalanc/XSLT/XSLTDefinitions.hpp>



#include <cassert>



#include <xalanc/Include/XalanVector.hpp>



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



#include <xalanc/XSLT/XSLTProcessorException.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class Arg;
class ElemTemplateElement;
class ElemVariable;
class StylesheetExecutionContext;
class XalanNode;



class XALAN_XSLT_EXPORT VariablesStack
{
public:

    typedef unsigned long   size_type;

    explicit
    VariablesStack(MemoryManagerType& theManager);

    ~VariablesStack();

    void
    reset();

    void
    pushElementFrame(const ElemTemplateElement*     elem);

    void
    popElementFrame();

    void
    pushContextMarker();

    void
    popContextMarker();

    struct ParamsVectorEntry
    {
        ParamsVectorEntry() :
            m_qname(0),
            m_value(),
            m_variable(0)
        {
        }

        ParamsVectorEntry(
                const XalanQName*   qname,
                const XObjectPtr    value) :
            m_qname(qname),
            m_value(value),
            m_variable(0)
        {
        }

        ParamsVectorEntry(
                const XalanQName*       qname,
                const ElemVariable*     variable) :
            m_qname(qname),
            m_value(),
            m_variable(variable)
        {
        }

        const XalanQName*       m_qname;

        XObjectPtr              m_value;

        const ElemVariable*     m_variable;
    };

    typedef XalanVector<ParamsVectorEntry>          ParamsVectorType;
    typedef XalanVector<const ElemVariable*>            RecursionGuardStackType;
    typedef XalanVector<const ElemTemplateElement*> ElemTemplateElementStackType;

    void
    pushParams(const ParamsVectorType&  theParams);

    const XObjectPtr
    getParamVariable(
            const XalanQName&               qname,
            StylesheetExecutionContext&     executionContext,
            bool&                           fNameFound)
    {
        return findXObject(qname, executionContext, true, false, fNameFound);
    }

    const XObjectPtr
    getVariable(
            const XalanQName&               qname,
            StylesheetExecutionContext&     executionContext,
            bool&                           fNameFound)
    {
        return findXObject(qname, executionContext, false, true, fNameFound);
    }

    void
    pushVariable(
            const XalanQName&           name,
            const ElemVariable*         var,
            const ElemTemplateElement*  e);

    void
    pushVariable(
            const XalanQName&           name,
            const XObjectPtr&           val,
            const ElemTemplateElement*  e);

    void
    start();

    void
    resetParams();

    void
    markGlobalStackFrame();

    void
    unmarkGlobalStackFrame();

    void
    setCurrentStackFrameIndex(size_type     currentStackFrameIndex = ~0u)
    {
        if (currentStackFrameIndex == ~0u)
        {
            assert(size_type(m_stack.size()) == m_stack.size());

            m_currentStackFrameIndex = size_type(m_stack.size());
        }
        else
        {
            m_currentStackFrameIndex = currentStackFrameIndex;
        }
    }

    size_type
    getCurrentStackFrameIndex() const
    {
        return m_currentStackFrameIndex;
    }

    size_type
    getGlobalStackFrameIndex() const
    {
        return m_globalStackFrameIndex;
    }

    class InvalidStackContextException : public XSLTProcessorException
    {
    public:

        InvalidStackContextException(XalanDOMString& theResult);

        virtual
        ~InvalidStackContextException();


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

    };

    class PushParamFunctor
    {
    public:

        PushParamFunctor(VariablesStack&    theVariablesStack) :
            m_variablesStack(theVariablesStack)
        {
        }

        void
        operator()(const ParamsVectorType::value_type&  theEntry) const;

    private:

        VariablesStack&     m_variablesStack;
    };

    class XALAN_XSLT_EXPORT StackEntry
    {
    public:

        enum eType { eContextMarker,
                    eVariable,
                    eParam,
                    eActiveParam,
                    eElementFrameMarker,
                    eNextValue };

        explicit
        StackEntry();

        StackEntry(
            const XalanQName*   name,
            const XObjectPtr&   val,
            bool                isParam = false);

        StackEntry(
            const XalanQName*       name,
            const ElemVariable*     var,
            bool                    isParam = false);

        StackEntry(const ElemTemplateElement*   elem);


        StackEntry(const StackEntry&    theSource);

        ~StackEntry();

        eType
        getType() const
        {
            return m_type;
        }

        const XalanQName*
        getName() const
        {
            return m_qname;
        }

        const XObjectPtr&
        getValue() const
        {
            return m_value;
        }

        void
        setValue(const XObjectPtr&  theValue)
        {
            m_value = theValue;
        }

        const ElemVariable*
        getVariable() const
        {
            return m_variable;
        }

        void
        activate();

        void
        deactivate();

        const ElemTemplateElement*
        getElement() const
        {
            return m_element;
        }

        StackEntry&
        operator=(const StackEntry&     theRHS);

        bool
        operator==(const StackEntry&    theRHS) const;

    private:

        // Data members...
        eType                       m_type;

        const XalanQName*           m_qname;

        XObjectPtr                  m_value;

        const ElemVariable*         m_variable;

        const ElemTemplateElement*  m_element;
    };

    typedef XalanVector<StackEntry>         VariableStackStackType;

    size_type
    getStackSize() const
    {
        return size_type(m_stack.size());
    }

    enum { eDefaultStackSize = 100 };

private:

    class CommitPushParams
    {
    public:

        CommitPushParams(VariablesStack&    theVariablesStack);

        ~CommitPushParams();

        void
        commit()
        {
            m_variablesStack = 0;
        }

    private:

        VariablesStack*     m_variablesStack;

        size_type           m_stackSize;
    };

    friend class CommitPushParams;

    bool
    elementFrameAlreadyPushed(const ElemTemplateElement*    elem) const;

    void
    push(const StackEntry&  theEntry);

    void
    pop();

    const StackEntry&
    back() const
    {
        assert(m_stack.empty() == false);

        return m_stack.back();
    }

    friend class CommitPushElementFrame;
    friend class EnsurePop;
    friend class PushParamFunctor;
    friend class SetAndRestoreForceGlobalSearch;

    const XObjectPtr
    findXObject(
            const XalanQName&               name,
            StylesheetExecutionContext&     executionContext,
            bool                            fIsParam,
            bool                            fSearchGlobalSpace,
            bool&                           fNameFound);

    size_type
    findEntry(
            const XalanQName&   name,
            bool                fIsParam,
            bool                fSearchGlobalSpace);


    VariableStackStackType      m_stack;

    size_type                   m_globalStackFrameIndex;

    bool                        m_globalStackFrameMarked;

    size_type                   m_currentStackFrameIndex;   

    RecursionGuardStackType         m_guardStack;

    ElemTemplateElementStackType    m_elementFrameStack;
};



XALAN_CPP_NAMESPACE_END



#endif  // #if !defined(XALAN_VARIABLESSTACK_HEADER_GUARD)

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.