exprList.h

/***************************************************************
 *
 * Copyright (C) 1990-2007, Condor Team, Computer Sciences Department,
 * University of Wisconsin-Madison, WI.
 * 
 * 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.
 *
 ***************************************************************/


#ifndef __CLASSAD_EXPR_LIST_H__
#define __CLASSAD_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);

        virtual ~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() const             { 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 std::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//__CLASSAD_EXPR_LIST_H__