classad.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_CLASSAD_H__
#define __CLASSAD_CLASSAD_H__


#include <set>
#include <map>
#include <vector>
#include "classad/classad_stl.h"
#include "classad/exprTree.h"

BEGIN_NAMESPACE( classad )

typedef std::set<std::string, CaseIgnLTStr> References;
typedef std::map<const ClassAd*, References> PortReferences;

#if defined( EXPERIMENTAL )
#include "classad/rectangle.h"
#endif

#ifdef WIN32
typedef classad_hash_map<std::string, ExprTree*, StringCaseIgnHash> AttrList;
#else
typedef classad_hash_map<std::string, ExprTree*, StringCaseIgnHash, CaseIgnEqStr> AttrList;
#endif
typedef std::set<std::string, CaseIgnLTStr> DirtyAttrList;

void ClassAdLibraryVersion(int &major, int &minor, int &patch);
void ClassAdLibraryVersion(std::string &version_string);

// This flag is only meant for use in Condor, which is transitioning
// from an older version of ClassAds with slightly different evaluation
// semantics. It will be removed without warning in a future release.
extern bool _useOldClassAdSemantics;

class ClassAd : public ExprTree
{
    public:

        ClassAd ();

        ClassAd (const ClassAd &ad);

        virtual ~ClassAd ();

        bool Insert( const std::string &attrName, ExprTree *expr );

        bool DeepInsert( ExprTree *scopeExpr, const std::string &attrName, 
                ExprTree *expr );

        bool InsertAttr( const std::string &attrName,int value, 
                Value::NumberFactor f=Value::NO_FACTOR );

        bool DeepInsertAttr( ExprTree *scopeExpr, const std::string &attrName,
                int value, Value::NumberFactor f=Value::NO_FACTOR );

        bool InsertAttr( const std::string &attrName,double value, 
                Value::NumberFactor f=Value::NO_FACTOR);

        bool DeepInsertAttr( ExprTree *scopeExpr, const std::string &attrName,
                double value, Value::NumberFactor f=Value::NO_FACTOR);

        bool InsertAttr( const std::string &attrName, bool value );

        bool DeepInsertAttr( ExprTree *scopeExpr, const std::string &attrName, 
                bool value );

        bool InsertAttr( const std::string &attrName, const char *value );

        bool DeepInsertAttr( ExprTree *scopeExpr, const std::string &attrName, 
                const char *value );

        bool InsertAttr( const std::string &attrName, const std::string &value );

        bool DeepInsertAttr( ExprTree *scopeExpr, const std::string &attrName, 
                const std::string &value );

        ExprTree *Lookup( const std::string &attrName ) const;

        ExprTree *LookupInScope(const std::string &attrName,const ClassAd *&ad)const;

        void Clear( );

        bool Delete( const std::string &attrName );

        bool DeepDelete( const std::string &scopeExpr, const std::string &attrName );

        bool DeepDelete( ExprTree *scopeExpr, const std::string &attrName );
    
        ExprTree *Remove( const std::string &attrName );

        ExprTree *DeepRemove( const std::string &scopeExpr, const std::string &attrName );

        ExprTree *DeepRemove( ExprTree *scopeExpr, const std::string &attrName );

        bool EvaluateAttr( const std::string& attrName, Value &result ) const;

        bool EvaluateExpr( const std::string& buf, Value &result ) const;

        bool EvaluateExpr( const ExprTree* expr, Value &result ) const; // eval'n

        bool EvaluateExpr( const ExprTree* expr, Value &result, ExprTree *&sig) const;

        bool EvaluateAttrInt( const std::string &attr, int& intValue ) const;

        bool EvaluateAttrReal( const std::string &attr, double& realValue )const;

        bool EvaluateAttrNumber( const std::string &attr, int& intValue ) const;

        bool EvaluateAttrNumber(const std::string &attr,double& realValue) const;

        bool EvaluateAttrString( const std::string &attr, char *buf, int len) 
                const;

        bool EvaluateAttrString( const std::string &attr, std::string &buf ) const;

        bool EvaluateAttrBool( const std::string &attr, bool& boolValue ) const;

        bool EvaluateAttrClassAd( const std::string &attr, ClassAd *&classad ) const;

        bool EvaluateAttrList( const std::string &attr, ExprList *&l ) const;


        typedef AttrList::iterator iterator;

        typedef AttrList::const_iterator const_iterator;

        iterator begin() { return attrList.begin(); }

        const_iterator begin() const { return attrList.begin(); }

        iterator end() { return attrList.end(); }

        const_iterator end() const { return attrList.end(); }

        iterator find(std::string const& attrName);

        const_iterator find(std::string const& attrName) const;

        int size(void) const { return attrList.size(); }

        static ClassAd *MakeClassAd( std::vector< std::pair< std::string, ExprTree* > > &vec );

        void GetComponents( std::vector< std::pair< std::string, ExprTree *> > &vec ) const;

        bool Update( const ClassAd& ad );   

        void Modify( ClassAd& ad );

        virtual ExprTree* Copy( ) const;

        ClassAd &operator=(const ClassAd &rhs);

        bool CopyFrom( const ClassAd &ad );

        virtual bool SameAs(const ExprTree *tree) const;

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

        bool Flatten( const ExprTree* expr, Value& val, ExprTree *&fexpr )const;

        bool FlattenAndInline( const ExprTree* expr, Value& val,    // NAC
                               ExprTree *&fexpr )const;             // NAC
        
        bool GetExternalReferences( const ExprTree *tree, References &refs, bool fullNames );

        bool GetExternalReferences(const ExprTree *tree, PortReferences &refs);


        bool GetInternalReferences( const ExprTree *tree, References &refs, bool fullNames);

#if defined( EXPERIMENTAL )
        bool AddRectangle( const ExprTree *tree, Rectangles &r, 
                    const std::string &allowed, const References &imported );
#endif

        void        ChainToAd(ClassAd *new_chain_parent_ad);
        void        Unchain(void);

        ClassAd *   GetChainedParentAd(void);

        bool CopyFromChain( const ClassAd &ad );

        bool UpdateFromChain( const ClassAd &ad );

        void        EnableDirtyTracking(void)  { do_dirty_tracking = true;  }
        void        DisableDirtyTracking(void) { do_dirty_tracking = false; }
        void        ClearAllDirtyFlags(void);
        void        MarkAttributeDirty(const std::string &name);
        void        MarkAttributeClean(const std::string &name);
        bool        IsAttributeDirty(const std::string &name);

        typedef DirtyAttrList::iterator dirtyIterator;
        dirtyIterator dirtyBegin() { return dirtyAttrList.begin(); }
        dirtyIterator dirtyEnd() { return dirtyAttrList.end(); }

        /* This data member is intended for transitioning Condor from
         * old to new ClassAds. It allows unscoped attribute references
         * in expressions that can't be found in the local scope to be
         * looked for in an alternate scope. In Condor, the alternate
         * scope is the Target ad in matchmaking.
         * Expect alternateScope to be removed from a future release.
         */
        ClassAd *alternateScope;

    private:
        friend  class AttributeReference;
        friend  class ExprTree;
        friend  class EvalState;
        friend  class ClassAdIterator;

        bool _GetExternalReferences( const ExprTree *, ClassAd *, 
                    EvalState &, References&, bool fullNames );

        bool _GetExternalReferences( const ExprTree *, ClassAd *, 
                    EvalState &, PortReferences& );

        bool _GetInternalReferences(const ExprTree *expr, ClassAd *ad,
            EvalState &state, References& refs, bool fullNames);
#if defined( EXPERIMENTAL )
        bool _MakeRectangles(const ExprTree*,const std::string&,Rectangles&, bool);
        bool _CheckRef( ExprTree *, const std::string & );
#endif

        ClassAd *_GetDeepScope( const std::string& ) const;
        ClassAd *_GetDeepScope( ExprTree * ) const;

        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;
    
        int LookupInScope( const std::string&, ExprTree*&, EvalState& ) const;
        AttrList      attrList;
        DirtyAttrList dirtyAttrList;
        bool          do_dirty_tracking;
        ClassAd       *chained_parent_ad;
};

END_NAMESPACE // classad

#include "classad/classadItor.h"

#endif//__CLASSAD_CLASSAD_H__