src/xmlpatterns/expr/qoperandsiterator_p.h
changeset 0 1918ee327afb
child 4 3b1da2848fc7
equal deleted inserted replaced
-1:000000000000 0:1918ee327afb
       
     1 /****************************************************************************
       
     2 **
       
     3 ** Copyright (C) 2009 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 //  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 "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