src/xmlpatterns/environment/qstackcontextbase.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 /**
  43  * @file
  44  * @short This file is included by qstackcontextbase_p.h.
  45  * If you need includes in this file, put them in qstackcontextbase_p.h, outside of the namespace.
  46  */
  47
  48 template<typename TSuperClass>
  49 StackContextBase<TSuperClass>::StackContextBase() : m_rangeVariables(10),
  50                                                     m_expressionVariables(10),
  51                                                     m_positionIterators(5),
  52                                                     m_itemCacheCells(5),
  53                                                     m_itemSequenceCacheCells(5)
  54 {
  55     /* The m_* containers are initialized with default sizes. Estimated guesses on usage patterns. */
  56 }
  57
  58 template<typename TSuperClass>
  59 StackContextBase<TSuperClass>::StackContextBase(const DynamicContext::Ptr &prevContext)
  60                                                 : TSuperClass(prevContext),
  61                                                   m_rangeVariables(10),
  62                                                   m_expressionVariables(10),
  63                                                   m_positionIterators(5),
  64                                                   m_itemCacheCells(5),
  65                                                   m_itemSequenceCacheCells(5)
  66 {
  67     Q_ASSERT(prevContext);
  68 }
  69
  70 template<typename TSuperClass>
  71 ItemCacheCell &StackContextBase<TSuperClass>::itemCacheCell(const VariableSlotID slot)
  72 {
  73     if(slot >= m_itemCacheCells.size())
  74         m_itemCacheCells.resize(qMax(slot + 1, m_itemCacheCells.size()));
  75
  76     return m_itemCacheCells[slot];
  77 }
  78
  79 template<typename TSuperClass>
  80 ItemSequenceCacheCell::Vector &StackContextBase<TSuperClass>::itemSequenceCacheCells(const VariableSlotID slot)
  81 {
  82     if(slot >= m_itemSequenceCacheCells.size())
  83         m_itemSequenceCacheCells.resize(qMax(slot + 1, m_itemSequenceCacheCells.size()));
  84
  85     return m_itemSequenceCacheCells;
  86 }
  87
  88 template<typename TSuperClass>
  89 Item StackContextBase<TSuperClass>::rangeVariable(const VariableSlotID slot) const
  90 {
  91     Q_ASSERT(slot < m_rangeVariables.size());
  92     Q_ASSERT(m_rangeVariables.at(slot));
  93     return m_rangeVariables.at(slot);
  94 }
  95
  96 template<typename TSuperClass>
  97 Expression::Ptr StackContextBase<TSuperClass>::expressionVariable(const VariableSlotID slot) const
  98 {
  99     Q_ASSERT(slot < m_expressionVariables.size());
 100     Q_ASSERT(m_expressionVariables.at(slot));
 101     return m_expressionVariables.at(slot);
 102 }
 103
 104 template<typename TSuperClass>
 105 Item::Iterator::Ptr StackContextBase<TSuperClass>::positionIterator(const VariableSlotID slot) const
 106 {
 107     Q_ASSERT(slot < m_positionIterators.size());
 108     return m_positionIterators.at(slot);
 109 }
 110
 111 template<typename TSuperClass>
 112 template<typename VectorType, typename UnitType>
 113 inline
 114 void StackContextBase<TSuperClass>::setSlotVariable(const VariableSlotID slot,
 115                                                     const UnitType &newValue,
 116                                                     VectorType &container) const
 117 {
 118     if(slot < container.size())
 119         container.replace(slot, newValue);
 120     else
 121     {
 122         container.resize(slot + 1);
 123         container.replace(slot, newValue);
 124     }
 125 }
 126
 127 template<typename TSuperClass>
 128 void StackContextBase<TSuperClass>::setRangeVariable(const VariableSlotID slot,
 129                                                      const Item &newValue)
 130 {
 131     setSlotVariable(slot, newValue, m_rangeVariables);
 132 }
 133
 134 template<typename TSuperClass>
 135 void StackContextBase<TSuperClass>::setExpressionVariable(const VariableSlotID slot,
 136                                                           const Expression::Ptr &newValue)
 137 {
 138     setSlotVariable(slot, newValue, m_expressionVariables);
 139 }
 140
 141 template<typename TSuperClass>
 142 void StackContextBase<TSuperClass>::setPositionIterator(const VariableSlotID slot,
 143                                                         const Item::Iterator::Ptr &newValue)
 144 {
 145     setSlotVariable(slot, newValue, m_positionIterators);
 146 }
 147
 148 template<typename TSuperClass>
 149 DynamicContext::TemplateParameterHash &StackContextBase<TSuperClass>::templateParameterStore()
 150 {
 151     return m_templateParameterStore;
 152 }
 153