exprList.h

/*********************************************************************
 *
 * Condor ClassAd library
 * Copyright (C) 1990-2003, Condor Team, Computer Sciences Department,
 * University of Wisconsin-Madison, WI and Rajesh Raman.
 *
 * This source code is covered by the Condor Public License, which can
 * be found in the accompanying LICENSE file, or online at
 * www.condorproject.org.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * AND THE UNIVERSITY OF WISCONSIN-MADISON "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY, OF SATISFACTORY QUALITY, AND FITNESS
 * FOR A PARTICULAR PURPOSE OR USE ARE DISCLAIMED. THE COPYRIGHT
 * HOLDERS AND CONTRIBUTORS AND THE UNIVERSITY OF WISCONSIN-MADISON
 * MAKE NO MAKE NO REPRESENTATION THAT THE SOFTWARE, MODIFICATIONS,
 * ENHANCEMENTS OR DERIVATIVE WORKS THEREOF, WILL NOT INFRINGE ANY
 * PATENT, COPYRIGHT, TRADEMARK, TRADE SECRET OR OTHER PROPRIETARY
 * RIGHT.
 *
 *********************************************************************/

#ifndef __EXPR_LIST_H__
#define __EXPR_LIST_H__

#include <vector>

BEGIN_NAMESPACE( classad )

class ExprListIterator;

class ExprList : public ExprTree
{
        public:
                ExprList();
                ExprList(const std::vector<ExprTree*>& exprs);

        ExprList(const ExprList &other_list);

                ~ExprList();

        ExprList &operator=(const ExprList &other_list);

                static ExprList *MakeExprList( const std::vector< ExprTree* > &list );

                void GetComponents( std::vector<ExprTree*>& list) const;

                virtual ExprTree* Copy( ) const;

        bool CopyFrom(const ExprList &other_list);

        virtual bool SameAs(const ExprTree *tree) const;

        friend bool operator==(ExprList &list1, ExprList &list2);

                // STL-like iterators and functions
            typedef std::vector<ExprTree*>::iterator       iterator;
        typedef std::vector<ExprTree*>::const_iterator const_iterator;

        int size()                   { return exprList.size();  }
        iterator begin()             { return exprList.begin(); }
                iterator end()               { return exprList.end();   }
                const_iterator begin() const { return exprList.begin(); }
                const_iterator end() const   { return exprList.end();   }

                void insert(iterator it, ExprTree* t);
                void push_back(ExprTree* t);
                void erase(iterator it);
                void erase(iterator f, iterator l);
        
        private:
                friend class ExprListIterator;

                std::vector<ExprTree*> exprList;

                void Clear (void);
                virtual void _SetParentScope( const ClassAd* p );
                virtual bool _Evaluate (EvalState &, Value &) const;
                virtual bool _Evaluate (EvalState &, Value &, ExprTree *&) const;
                virtual bool _Flatten( EvalState&, Value&, ExprTree*&, int* ) const;
        void CopyList(const vector<ExprTree*> &exprs);
};


class ExprListIterator
{
        public:
                ExprListIterator( );

                ExprListIterator( const ExprList* l );

                ~ExprListIterator( );

            void Initialize( const ExprList* l );

        void ToFirst( );

        void ToAfterLast( );

                bool ToNth( int n );

        const ExprTree* NextExpr( );

        const ExprTree* CurrentExpr( ) const;

        const ExprTree* PrevExpr( );
    
        bool NextValue( Value& v, EvalState *es=NULL );

        bool CurrentValue( Value& v, EvalState *es=NULL );

        bool PrevValue( Value& v, EvalState *es=NULL  );

        bool NextValue( Value& v, ExprTree*& t, EvalState *es=NULL );

        bool CurrentValue( Value& v, ExprTree*& t, EvalState *es=NULL );

        bool PrevValue( Value& v, ExprTree*& t, EvalState *es=NULL  );

        bool IsAtFirst( ) const;

        bool IsAfterLast( ) const;

        private:
                const ExprList                          *l;
                EvalState                               state;
                std::vector<ExprTree*>::const_iterator  itr;

        bool GetValue( Value& v, const ExprTree *tree, EvalState *es=NULL );
                bool GetValue( Value& v, ExprTree*& t, const ExprTree *tree, EvalState *es=NULL );

};      


END_NAMESPACE // classad

#endif//__EXPR_LIST_H__