Changes in src/ResolvExpr/Cost.h [6b0b624:ddf8a29]

File:

• src/ResolvExpr/Cost.h (modified) (4 diffs)

src/ResolvExpr/Cost.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Cost.h -- 
+// Cost.h --
 //
 // Author           : Richard C. Bilson
@@ -20 +20 @@
 namespace ResolvExpr {
         class Cost {
+          private:
+                Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost );
+
           public:
-                Cost();
-                Cost( int unsafe, int poly, int safe );
-  
-                void incUnsafe( int inc = 1 );
-                void incPoly( int inc = 1 );
-                void incSafe( int inc = 1 );
-  
+                Cost & incUnsafe( int inc = 1 );
+                Cost & incPoly( int inc = 1 );
+                Cost & incSafe( int inc = 1 );
+                Cost & incReference( int inc = 1 );
+
+                int get_unsafeCost() const { return unsafeCost; }
+                int get_polyCost() const { return polyCost; }
+                int get_safeCost() const { return safeCost; }
+                int get_referenceCost() const { return referenceCost; }
+
                 Cost operator+( const Cost &other ) const;
                 Cost operator-( const Cost &other ) const;
@@ -35 +41 @@
                 bool operator!=( const Cost &other ) const;
                 friend std::ostream &operator<<( std::ostream &os, const Cost &cost );
-  
+
                 static const Cost zero;
                 static const Cost infinity;
+
+                static const Cost unsafe;
+                static const Cost poly;
+                static const Cost safe;
+                static const Cost reference;
           private:
                 int compare( const Cost &other ) const;
 
-                int unsafe;
-                int poly;
-                int safe;
+                int unsafeCost;
+                int polyCost;
+                int safeCost;
+                int referenceCost;
         };
 
-        inline Cost::Cost() : unsafe( 0 ), poly( 0 ), safe( 0 ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), referenceCost( referenceCost ) {}
 
-        inline Cost::Cost( int unsafe, int poly, int safe ) : unsafe( unsafe ), poly( poly ), safe( safe ) {}
-
-        inline void Cost::incUnsafe( int inc ) {
-                unsafe += inc;
+        inline Cost & Cost::incUnsafe( int inc ) {
+                if ( *this == infinity ) return *this;
+                unsafeCost += inc;
+                return *this;
         }
 
-        inline void Cost::incPoly( int inc ) {
-                poly += inc;
+        inline Cost & Cost::incPoly( int inc ) {
+                if ( *this == infinity ) return *this;
+                polyCost += inc;
+                return *this;
         }
 
-        inline void Cost::incSafe( int inc ) {
-                safe += inc;
+        inline Cost & Cost::incSafe( int inc ) {
+                if ( *this == infinity ) return *this;
+                safeCost += inc;
+                return *this;
+        }
+
+        inline Cost & Cost::incReference( int inc ) {
+                if ( *this == infinity ) return *this;
+                referenceCost += inc;
+                return *this;
         }
 
         inline Cost Cost::operator+( const Cost &other ) const {
-                return Cost( unsafe + other.unsafe, poly + other.poly, safe + other.safe );
+                if ( *this == infinity || other == infinity ) return infinity;
+                return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, referenceCost + other.referenceCost );
         }
 
         inline Cost Cost::operator-( const Cost &other ) const {
-                return Cost( unsafe - other.unsafe, poly - other.poly, safe - other.safe );
+                if ( *this == infinity || other == infinity ) return infinity;
+                return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, referenceCost - other.referenceCost );
         }
 
         inline Cost &Cost::operator+=( const Cost &other ) {
-                unsafe += other.unsafe;
-                poly += other.poly;
-                safe += other.safe;
+                if ( *this == infinity ) return *this;
+                if ( other == infinity ) {
+                        *this = infinity;
+                        return *this;
+                }
+                unsafeCost += other.unsafeCost;
+                polyCost += other.polyCost;
+                safeCost += other.safeCost;
+                referenceCost += other.referenceCost;
                 return *this;
         }
 
         inline bool Cost::operator<( const Cost &other ) const {
-            if ( *this == infinity ) return false;
-            if ( other == infinity ) return true;
-            if ( unsafe > other.unsafe ) {
+                if ( *this == infinity ) return false;
+                if ( other == infinity ) return true;
+
+                if ( unsafeCost > other.unsafeCost ) {
                         return false;
-            } else if ( unsafe < other.unsafe ) {
+                } else if ( unsafeCost < other.unsafeCost ) {
                         return true;
-            } else if ( poly > other.poly ) {
+                } else if ( polyCost > other.polyCost ) {
                         return false;
-            } else if ( poly < other.poly ) {
+                } else if ( polyCost < other.polyCost ) {
                         return true;
-            } else if ( safe > other.safe ) {
+                } else if ( safeCost > other.safeCost ) {
                         return false;
-            } else if ( safe < other.safe ) {
+                } else if ( safeCost < other.safeCost ) {
                         return true;
-            } else {
+                } else if ( referenceCost > other.referenceCost ) {
                         return false;
-            } // if
+                } else if ( referenceCost < other.referenceCost ) {
+                        return true;
+                } else {
+                        return false;
+                } // if
         }
 
         inline bool Cost::operator==( const Cost &other ) const {
-                return unsafe == other.unsafe
-                        && poly == other.poly
-                        && safe == other.safe;
+                return unsafeCost == other.unsafeCost
+                        && polyCost == other.polyCost
+                        && safeCost == other.safeCost
+                        && referenceCost == other.referenceCost;
         }
 
@@ -108 +144 @@
 
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
-                os << "( " << cost.unsafe << ", " << cost.poly << ", " << cost.safe << " )";
+                os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << ", " << cost.referenceCost << " )";
                 return os;
         }