src/xmlpatterns/expr/qoperandsiterator_p.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: http://www.qt-project.org/
   6 **
   7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 //
  43 //  W A R N I N G
  44 //  -------------
  45 //
  46 // This file is not part of the Qt API.  It exists purely as an
  47 // implementation detail.  This header file may change from version to
  48 // version without notice, or even be removed.
  49 //
  50 // We mean it.
  51
  52 #ifndef Patternist_OperandsIterator_H
  53 #define Patternist_OperandsIterator_H
  54
  55 #include <QPair>
  56 #include <QStack>
  57
  58 #include <private/qexpression_p.h>
  59
  60 QT_BEGIN_HEADER
  61
  62 QT_BEGIN_NAMESPACE
  63
  64 namespace QPatternist
  65 {
  66     /**
  67      * @short A helper class that iterates a tree of Expression instances. It
  68      * is not a sub-class of QAbstractXmlForwardIterator.
  69      *
  70      * The OperandsIterator delivers all Expression instances that are children at any
  71      * depth of the Expression passed in the constructor.
  72      * The order is delivered in a defined way, from left to right and depth
  73      * first.
  74      *
  75      * @author Frans Englich <frans.englich@nokia.com>
  76      */
  77     class OperandsIterator
  78     {
  79         /**
  80          * The second value, the int, is the current position in the first.
  81          */
  82         typedef QPair<Expression::List, int> Level;
  83
  84     public:
  85         enum TreatParent
  86         {
  87             ExcludeParent,
  88             IncludeParent
  89         };
  90
  91         /**
  92          * if @p treatParent is @c IncludeParent, @p start is excluded.
  93          *
  94          * @p start must be a valid Expression.
  95          */
  96         inline OperandsIterator(const Expression::Ptr &start,
  97                                 const TreatParent treatParent)
  98         {
  99             Q_ASSERT(start);
 100             if(treatParent == IncludeParent)
 101             {
 102                 Expression::List l;
 103                 l.append(start);
 104                 m_exprs.push(qMakePair(l, -1));
 105             }
 106
 107             m_exprs.push(qMakePair(start->operands(), -1));
 108         }
 109
 110         /**
 111          * @short Returns the current Expression and advances the iterator.
 112          *
 113          * If the end has been reached, a default constructed pointer is
 114          * returned.
 115          *
 116          * We intentionally return by reference.
 117          */
 118         inline Expression::Ptr next()
 119         {
 120             if(m_exprs.isEmpty())
 121                 return Expression::Ptr();
 122
 123             Level &lvl = m_exprs.top();
 124             ++lvl.second;
 125
 126             if(lvl.second == lvl.first.size())
 127             {
 128                 /* Resume iteration above us. */
 129                 m_exprs.pop();
 130
 131                 if(m_exprs.isEmpty())
 132                     return Expression::Ptr();
 133
 134                 while(true)
 135                 {
 136                     Level &previous = m_exprs.top();
 137                     ++previous.second;
 138
 139                     if(previous.second < previous.first.count())
 140                     {
 141                         const Expression::Ptr &op = previous.first.at(previous.second);
 142                         m_exprs.push(qMakePair(op->operands(), -1));
 143                         return op;
 144                     }
 145                     else
 146                     {
 147                         // We have already reached the end of this level.
 148                         m_exprs.pop();
 149                         if(m_exprs.isEmpty())
 150                             return Expression::Ptr();
 151                     }
 152                 }
 153             }
 154             else
 155             {
 156                 const Expression::Ptr &op = lvl.first.at(lvl.second);
 157                 m_exprs.push(qMakePair(op->operands(), -1));
 158                 return op;
 159             }
 160         }
 161
 162         /**
 163          * Advances this iterator by the current expression and its operands.
 164          */
 165         Expression::Ptr skipOperands()
 166         {
 167             if(m_exprs.isEmpty())
 168                 return Expression::Ptr();
 169
 170             Level &lvl = m_exprs.top();
 171             ++lvl.second;
 172
 173             if(lvl.second == lvl.first.size())
 174             {
 175                 /* We've reached the end of this level, at least. */
 176                 m_exprs.pop();
 177             }
 178
 179             return next();
 180         }
 181
 182     private:
 183         Q_DISABLE_COPY(OperandsIterator)
 184
 185         QStack<Level> m_exprs;
 186     };
 187 }
 188
 189
 190 QT_END_NAMESPACE
 191 QT_END_HEADER
 192
 193 #endif