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


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

BEGIN_NAMESPACE( classad )

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

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

#ifdef CLASSAD_DEPRECATED
#include "stream.h"
#endif

typedef classad_hash_map<std::string, ExprTree*, StringCaseIgnHash, CaseIgnEqStr> AttrList;
typedef std::set<std::string, CaseIgnLTStr> DirtyAttrList;

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

class ClassAd : public ExprTree
{
        public:

                ClassAd ();

                ClassAd (const ClassAd &ad);

                ~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;

                void 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);

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

#if defined( CLASSAD_DEPRECATED )

        int             Insert(const char *str);
                int                     InsertOrUpdate(const char *expr) { return Insert(expr); }

                // for iteration through expressions
//              void            ResetExpr();
//              ExprTree*       NextExpr();

                // for iteration through names (i.e., lhs of the expressions)
//              void            ResetName() { this->ptrName = exprList; }
//              const char* NextNameOriginal();

                // lookup values in classads  (for simple assignments)
//              ExprTree*   Lookup(char *) const;               // for convenience
//      ExprTree*       Lookup(const char*) const;      // look up an expression

                int         LookupString(const char *name, char *value) const; 
                int         LookupString(const char *name, char *value, int max_len) const;
                int         LookupString (const char *name, char **value) const;
        int         LookupInteger(const char *name, int &value) const;
        int         LookupFloat(const char *name, float &value) const;
        int         LookupBool(const char *name, int &value) const;
        int         LookupBool(const char *name, bool &value) const;

                int         EvalString (const char *name, class ClassAd *target, char *value);
                int         EvalInteger (const char *name, class ClassAd *target, int &value);
                int         EvalFloat (const char *name, class ClassAd *target, float &value);
                int         EvalBool  (const char *name, class ClassAd *target, int &value);

        ClassAd(FILE*,char*,int&,int&,int&);    // Constructor, read from file.

        void            SetMyTypeName(const char *);
        const char*     GetMyTypeName();
        void            SetTargetTypeName(const char *);
        const char*     GetTargetTypeName();

        int put(Stream& s);

                int initFromStream(Stream& s);

        virtual int     fPrint(FILE *file);

                void            dPrint( int level);

                bool AddExplicitConditionals( ExprTree *expr, ExprTree *&newExpr );
                ClassAd *AddExplicitTargetRefs( );
#endif

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

                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(); }

        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& );
#if defined( EXPERIMENTAL )
                bool _MakeRectangles(const ExprTree*,const std::string&,Rectangles&, bool);
                bool _CheckRef( ExprTree *, const std::string & );
#endif

#if defined( CLASSAD_DEPRECATED )
                void evalFromEnvironment( const char *name, Value val );
                ExprTree *AddExplicitConditionals( ExprTree * );
                ExprTree *AddExplicitTargetRefs( ExprTree *,
                        std::set < std::string, CaseIgnLTStr > & );
#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 "classadItor.h"

#endif//__CLASSAD_H__