classad.h   classad.h 
skipping to change at line 643 skipping to change at line 643
typedef DirtyAttrList::iterator dirtyIterator; typedef DirtyAttrList::iterator dirtyIterator;
/** Return an interator to the first dirty attribute so all dirty a ttributes /** Return an interator to the first dirty attribute so all dirty a ttributes
* can be iterated through. * can be iterated through.
*/ */
dirtyIterator dirtyBegin() { return dirtyAttrList.begin(); } dirtyIterator dirtyBegin() { return dirtyAttrList.begin(); }
/** Return an iterator past the last dirty attribute /** Return an iterator past the last dirty attribute
*/ */
dirtyIterator dirtyEnd() { return dirtyAttrList.end(); } dirtyIterator dirtyEnd() { return dirtyAttrList.end(); }
//@} //@}
/* This data member is intended for transitioning Condor fro
m
* old to new ClassAds. It allows unscoped attribute referen
ces
* in expressions that can't be found in the local scope to
be
* looked for in an alternate scope. In Condor, the alternat
e
* scope is the Target ad in matchmaking.
* Expect alternateScope to be removed from a future release
.
*/
ClassAd *alternateScope;
private: private:
friend class AttributeReference; friend class AttributeReference;
friend class ExprTree; friend class ExprTree;
friend class EvalState; friend class EvalState;
friend class ClassAdIterator; friend class ClassAdIterator;
bool _GetExternalReferences( const ExprTree *, ClassAd *, bool _GetExternalReferences( const ExprTree *, ClassAd *,
EvalState &, References&, bool fullN ames ); EvalState &, References&, bool fullN ames );
bool _GetExternalReferences( const ExprTree *, ClassAd *, bool _GetExternalReferences( const ExprTree *, ClassAd *,
 End of changes. 1 change blocks. 
0 lines changed or deleted 14 lines changed or added


 matchClassad.h   matchClassad.h 
skipping to change at line 38 skipping to change at line 38
The top-level ClassAd equivalent to the following, with some The top-level ClassAd equivalent to the following, with some
minor implementation differences for efficiency. Because of minor implementation differences for efficiency. Because of
the use of global-scope references to .LEFT and .RIGHT, this the use of global-scope references to .LEFT and .RIGHT, this
ad is not suitable for nesting inside of other ads. The use ad is not suitable for nesting inside of other ads. The use
of global-scope references is done purely for efficiency, of global-scope references is done purely for efficiency,
since attribute lookups tends to be a big part of the time since attribute lookups tends to be a big part of the time
spent in matchmaking. spent in matchmaking.
<pre> <pre>
[ [
symmetricMatch = leftMatchesRight && rightMatchesLeft; symmetricMatch = leftMatchesRight && rightMatchesLeft;
leftMatchesRight = LEFT.requirements; leftMatchesRight = RIGHT.requirements;
rightMatchesLeft = RIGHT.requirements; rightMatchesLeft = LEFT.requirements;
leftRankValue = LEFT.rank; leftRankValue = LEFT.rank;
rightRankValue = RIGHT.rank; rightRankValue = RIGHT.rank;
RIGHT = rCtx.ad; RIGHT = rCtx.ad;
LEFT = lCtx.ad; LEFT = lCtx.ad;
lCtx = lCtx =
[ [
other = .RIGHT; other = .RIGHT;
target = .RIGHT; // for condor backwards compatibility target = .RIGHT; // for condor backwards compatibility
my = .LEFT; // for condor backwards compatibility my = .LEFT; // for condor backwards compatibility
ad = ad =
skipping to change at line 96 skipping to change at line 96
static MatchClassAd *MakeMatchClassAd( ClassAd* al, ClassAd* ar ); static MatchClassAd *MakeMatchClassAd( ClassAd* al, ClassAd* ar );
/** Method to initialize a MatchClassad given two ClassAds. The old /** Method to initialize a MatchClassad given two ClassAds. The old
expressions in the classad are deleted. expressions in the classad are deleted.
@param al The ad to be placed in the left context. @param al The ad to be placed in the left context.
@param ar The ad to be placed in the right context. @param ar The ad to be placed in the right context.
@return true if the operation succeeded, false other wise @return true if the operation succeeded, false other wise
*/ */
bool InitMatchClassAd( ClassAd* al, ClassAd *ar ); bool InitMatchClassAd( ClassAd* al, ClassAd *ar );
/** @return true if right and left ads match each other
*/
bool symmetricMatch();
/** @return true if the right ad matches the left ad's requi
rements
*/
bool rightMatchesLeft();
/** @return true if the left ad matches the right ad's requi
rements
*/
bool leftMatchesRight();
/** Replaces ad in the left context, or insert one if an ad did not /** Replaces ad in the left context, or insert one if an ad did not
previously exist previously exist
@param al The ad to be placed in the left context. @param al The ad to be placed in the left context.
@return true if the operation succeeded and false ot herwise. @return true if the operation succeeded and false ot herwise.
*/ */
bool ReplaceLeftAd( ClassAd *al ); bool ReplaceLeftAd( ClassAd *al );
/** Replaces ad in the right context, or insert one if an ad did not /** Replaces ad in the right context, or insert one if an ad did not
previously exist previously exist
@param ar The ad to be placed in the right context. @param ar The ad to be placed in the right context.
skipping to change at line 158 skipping to change at line 170
/** Modifies the requirements expression in the given ad to /** Modifies the requirements expression in the given ad to
make matchmaking more efficient. This will only imp rove make matchmaking more efficient. This will only imp rove
efficiency if it is called once and then the resulti ng efficiency if it is called once and then the resulti ng
requirements are used multiple times. Saves the old requirements are used multiple times. Saves the old
requirements expression so it can be restored via requirements expression so it can be restored via
UnoptimizeAdForMatchmaking. UnoptimizeAdForMatchmaking.
@param ad The ad to be optimized. @param ad The ad to be optimized.
@param error_msg non-NULL if an error description is desired. @param error_msg non-NULL if an error description is desired.
@return True on success. @return True on success.
*/ */
bool OptimizeRightAdForMatchmaking( ClassAd *ad, std::string *error_msg ); static bool OptimizeRightAdForMatchmaking( ClassAd *ad, std: :string *error_msg );
/** Modifies the requirements expression in the given ad to /** Modifies the requirements expression in the given ad to
make matchmaking more efficient. This will only imp rove make matchmaking more efficient. This will only imp rove
efficiency if it is called once and then the resulti ng efficiency if it is called once and then the resulti ng
requirements are used multiple times. Saves the old requirements are used multiple times. Saves the old
requirements expression so it can be restored via requirements expression so it can be restored via
UnoptimizeAdForMatchmaking. UnoptimizeAdForMatchmaking.
@param ad The ad to be optimized. @param ad The ad to be optimized.
@param error_msg non-NULL if an error description is desired. @param error_msg non-NULL if an error description is desired.
@return True on success. @return True on success.
*/ */
bool OptimizeLeftAdForMatchmaking( ClassAd *ad, std::string *error_msg ); static bool OptimizeLeftAdForMatchmaking( ClassAd *ad, std:: string *error_msg );
/** Restores ad previously optimized with OptimizeAdForMatch making. /** Restores ad previously optimized with OptimizeAdForMatch making.
@param ad The ad to be unoptimized. @param ad The ad to be unoptimized.
@return True on success. @return True on success.
*/ */
bool UnoptimizeAdForMatchmaking( ClassAd *ad ); static bool UnoptimizeAdForMatchmaking( ClassAd *ad );
protected: protected:
const ClassAd *ladParent, *radParent; const ClassAd *ladParent, *radParent;
ClassAd *lCtx, *rCtx, *lad, *rad; ClassAd *lCtx, *rCtx, *lad, *rad;
ExprTree *symmetric_match, *right_matches_left, *left_matche s_right;
private: private:
// The copy constructor and assignment operator are defined // The copy constructor and assignment operator are defined
// to be private so we don't have to write them, or worry about // to be private so we don't have to write them, or worry about
// them being inappropriately used. The day we want them, we can // them being inappropriately used. The day we want them, we can
// write them. // write them.
MatchClassAd(const MatchClassAd &) : ClassAd(){ return; } MatchClassAd(const MatchClassAd &) : ClassAd(){ return; }
MatchClassAd &operator=(const MatchClassAd &) { return *this; } MatchClassAd &operator=(const MatchClassAd &) { return *this; }
/** Modifies the requirements expression in the given ad to /** Modifies the requirements expression in the given ad to
make matchmaking more efficient. This will only imp rove make matchmaking more efficient. This will only imp rove
efficiency if it is called once and then the resulti ng efficiency if it is called once and then the resulti ng
requirements are used multiple times. Saves the old requirements are used multiple times. Saves the old
requirements expression so it can be restored via requirements expression so it can be restored via
UnoptimizeAdForMatchmaking. UnoptimizeAdForMatchmaking.
@param ad The ad to be optimized. @param ad The ad to be optimized.
@param is_right True if this ad will be the right ad . @param is_right True if this ad will be the right ad .
@param error_msg non-NULL if an error description is desired. @param error_msg non-NULL if an error description is desired.
@return True on success. @return True on success.
*/ */
bool OptimizeAdForMatchmaking( ClassAd *ad, bool is_right, s td::string *error_msg ); static bool OptimizeAdForMatchmaking( ClassAd *ad, bool is_r ight, std::string *error_msg );
/**
@return true if the given expression evaluates to true
*/
bool EvalMatchExpr(ExprTree *match_expr);
}; };
END_NAMESPACE // classad END_NAMESPACE // classad
#endif #endif
 End of changes. 8 change blocks. 
6 lines changed or deleted 25 lines changed or added


 operators.h   operators.h 
skipping to change at line 189 skipping to change at line 189
Operation (); Operation ();
private: private:
bool SameChild(const ExprTree *tree1, const ExprTree *tree2) const; bool SameChild(const ExprTree *tree1, const ExprTree *tree2) const;
virtual void _SetParentScope( const ClassAd* ); virtual void _SetParentScope( const ClassAd* );
virtual bool _Evaluate( EvalState &, Value &) const; virtual bool _Evaluate( EvalState &, Value &) const;
virtual bool _Evaluate( EvalState &, Value &, ExprTree*& ) c onst; virtual bool _Evaluate( EvalState &, Value &, ExprTree*& ) c onst;
virtual bool _Flatten( EvalState&, Value&, ExprTree*&, int* ) const; virtual bool _Flatten( EvalState&, Value&, ExprTree*&, int* ) const;
// returns true if result is determined for this ope
ration
// based on the evaluated arg1
bool shortCircuit( EvalState &state, Value const &arg1, Valu
e &result ) const;
// auxillary functionms // auxillary functionms
bool combine( OpKind&, Value&, ExprTree*&, bool combine( OpKind&, Value&, ExprTree*&,
int, Value&, ExprTree*, int, Value&, ExprTre e* ) const; int, Value&, ExprTree*, int, Value&, ExprTre e* ) const;
bool flattenSpecials( EvalState &, Value &, ExprTree *& ) co nst; bool flattenSpecials( EvalState &, Value &, ExprTree *& ) co nst;
static Operation* MakeOperation( OpKind, Value&, ExprTree* ) ; static Operation* MakeOperation( OpKind, Value&, ExprTree* ) ;
static Operation* MakeOperation( OpKind, ExprTree*, Value& ) ; static Operation* MakeOperation( OpKind, ExprTree*, Value& ) ;
static Value::ValueType coerceToNumber (Value&, Value &); static Value::ValueType coerceToNumber (Value&, Value &);
enum SigValues { SIG_NONE=0, SIG_CHLD1=1 , SIG_CHLD2=2 , SIG _CHLD3=4 }; enum SigValues { SIG_NONE=0, SIG_CHLD1=1 , SIG_CHLD2=2 , SIG _CHLD3=4 };
 End of changes. 1 change blocks. 
0 lines changed or deleted 6 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/