Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

CountersTable.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_COUNTERSTABLE_HEADER_GUARD_1357924680)
#define XALAN_COUNTERSTABLE_HEADER_GUARD_1357924680


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



#include <xalanc/Include/XalanVector.hpp>




#include "xalanc/XPath/MutableNodeRefList.hpp"



XALAN_CPP_NAMESPACE_BEGIN



class ElemNumber;
class StylesheetExecutionContext;



struct Counter
{
    typedef unsigned long   CountType;

    typedef XalanVector<XalanNode*>         NodeVectorType;

    CountType           m_countNodesStartCount;

    NodeVectorType      m_countNodes;

    const XalanNode*    m_fromNode;

    const ElemNumber*   m_numberElem;

    Counter(
            MemoryManagerType&  theManager,
            const ElemNumber*   numberElem,
            NodeVectorType&     countNodes) :
        m_countNodesStartCount(0),
        m_countNodes(countNodes, theManager),
        m_fromNode(0),
        m_numberElem(numberElem)
    {
    }

    Counter(MemoryManagerType& theManager, const ElemNumber*    numberElem = 0) :
        m_countNodesStartCount(0),
        m_countNodes(theManager),
        m_fromNode(0),
        m_numberElem(numberElem)
    {
    }

    Counter(const Counter& other, MemoryManagerType& theManager) :
        m_countNodesStartCount(other.m_countNodesStartCount),
        m_countNodes(other.m_countNodes, theManager),
        m_fromNode(other.m_fromNode),
        m_numberElem(other.m_numberElem)
    {
    }

    CountType
    getPreviouslyCounted(
            StylesheetExecutionContext&     support,
            const XalanNode*                node) const;

    XalanNode*
    getLast() const
    {
        return m_countNodes.empty() == true ? 0 : m_countNodes.back();
    }

private:
    // Not implemented
    Counter();
    Counter(const Counter&);
};

XALAN_USES_MEMORY_MANAGER(Counter)

typedef XalanVector<Counter>                CounterVectorTypeDecl;
XALAN_USES_MEMORY_MANAGER(CounterVectorTypeDecl)

typedef XalanVector<CounterVectorTypeDecl>      ElemCounterVectorVectorTypeDecl;
XALAN_USES_MEMORY_MANAGER(ElemCounterVectorVectorTypeDecl)
class CountersTable
{
public:

    typedef Counter::CountType  CountType;

    typedef CounterVectorTypeDecl               CounterVectorType;
    typedef ElemCounterVectorVectorTypeDecl     ElemCounterVectorVectorType;

    typedef Counter::NodeVectorType             NodeVectorType;

    CountersTable(MemoryManagerType& theManager,
                    unsigned long       theSize = 0) :
        m_countersVector(theManager),
        m_newFound(theManager)
    {
        resize(theSize);
    };

    ~CountersTable()
    {
    }

    void
    resize(unsigned long    theSize)
    {
        m_countersVector.resize(theSize);
    }

    CountType
    countNode(
            StylesheetExecutionContext&     executionContext,
            const ElemNumber&               numberElem,
            XalanNode*                      node);

    void
    reset()
    {
        m_newFound.clear();

        m_countersVector.clear();
    }

private:
    // not implemented
    CountersTable();
    CountersTable(const CountersTable&);

    ElemCounterVectorVectorType     m_countersVector;


    NodeVectorType                  m_newFound;
};



XALAN_CPP_NAMESPACE_END



#endif  // !defined(XALAN_COUNTERSTABLE_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.