rename StatusVar() to Var()

2012-03-20 13:11:01 +00:00
parent f53b68cb87
commit db3f43b18a
7 changed files with 90 additions and 114 deletions
--- a/com/google/ortools/constraintsolver/ValCstPair.cs
+++ b/com/google/ortools/constraintsolver/ValCstPair.cs
@@ -132,17 +132,12 @@ public class WrappedConstraint : BaseEquality

  public static implicit operator IntVar(WrappedConstraint eq)
  {
-    return eq.StatusVar();
+    return eq.Var();
  }

  public static implicit operator IntExpr(WrappedConstraint eq)
  {
-    return eq.StatusVar();
-  }
-
-  public IntVar StatusVar()
-  {
-    return Cst.StatusVar();
+    return eq.Var();
  }

  public override Solver solver()
@@ -152,7 +147,7 @@ public class WrappedConstraint : BaseEquality

  public override IntVar Var()
  {
-    return StatusVar();
+    return Cst.Var();
  }
 }

@@ -192,7 +187,7 @@ public class IntExprEquality : BaseEquality
    return eq.ToConstraint();
  }

-  public IntVar StatusVar()
+  public override IntVar Var()
  {
    return equality_ ?
        left_.solver().MakeIsEqualVar(left_, right_) :
@@ -201,12 +196,12 @@ public class IntExprEquality : BaseEquality

  public static implicit operator IntVar(IntExprEquality eq)
  {
-    return eq.StatusVar();
+    return eq.Var();
  }

  public static implicit operator IntExpr(IntExprEquality eq)
  {
-    return eq.StatusVar();
+    return eq.Var();
  }

  public override Solver solver()
@@ -214,11 +209,6 @@ public class IntExprEquality : BaseEquality
    return left_.solver();
  }

-  public override IntVar Var()
-  {
-    return StatusVar();
-  }
-
  private IntExpr left_;
  private IntExpr right_;
  private bool equality_;
@@ -262,7 +252,7 @@ public class ConstraintEquality : BaseEquality
    return eq.ToConstraint();
  }

-  public IntVar StatusVar()
+  public override IntVar Var()
  {
    return equality_ ?
        left_.solver().MakeIsEqualVar(left_.Var(), right_.Var()) :
@@ -271,12 +261,12 @@ public class ConstraintEquality : BaseEquality

  public static implicit operator IntVar(ConstraintEquality eq)
  {
-    return eq.StatusVar();
+    return eq.Var();
  }

  public static implicit operator IntExpr(ConstraintEquality eq)
  {
-    return eq.StatusVar();
+    return eq.Var();
  }

  public override Solver solver()
@@ -284,11 +274,6 @@ public class ConstraintEquality : BaseEquality
    return left_.solver();
  }

-  public override IntVar Var()
-  {
-    return StatusVar();
-  }
-
  private IConstraintWithStatus left_;
  private IConstraintWithStatus right_;
  private bool equality_;
--- a/constraint_solver/constraint_solver.cc
+++ b/constraint_solver/constraint_solver.cc
@@ -3242,7 +3242,7 @@ bool Constraint::IsCastConstraint() const {
  return ContainsKey(solver()->cast_constraints_, this);
 }

-IntVar* Constraint::StatusVar() {
+IntVar* Constraint::Var() {
  return NULL;
 }

--- a/constraint_solver/constraint_solver.h
+++ b/constraint_solver/constraint_solver.h
@@ -3460,7 +3460,7 @@ class Constraint : public PropagationBaseObject {
  // Creates an boolean variable representing the status of the
  // variable (false = constraint is violated, true constraint is
  // satisfied). It returns NULL if the constraint does not support his API.
-  virtual IntVar* StatusVar();
+  virtual IntVar* Var();

 private:
  DISALLOW_COPY_AND_ASSIGN(Constraint);
--- a/constraint_solver/constraint_solver.swig
+++ b/constraint_solver/constraint_solver.swig
@@ -294,7 +294,7 @@ namespace operations_research {
                        (void**)&c,
                        SWIGTYPE_p_operations_research__Constraint,
                        SWIG_POINTER_EXCEPTION | 0 ) != -1) {
-      operations_research::IntVar* const v = c->StatusVar();
+      operations_research::IntVar* const v = c->Var();
      if (v == NULL) {
        SWIG_fail;
      } else {
@@ -339,7 +339,7 @@ namespace operations_research {
        PyErr_SetString(PyExc_TypeError, "Invalid LanguageCode");
        SWIG_fail;
      }
-      operations_research::IntVar* const v = c->StatusVar();
+      operations_research::IntVar* const v = c->Var();
      if (v == NULL) {
        SWIG_fail;
      } else {
@@ -418,7 +418,7 @@ namespace operations_research {
          PyErr_SetString(PyExc_TypeError, "Invalid LanguageCode");
          SWIG_fail;
        }
-        operations_research::IntVar* const v = c->StatusVar();
+        operations_research::IntVar* const v = c->Var();
        if (v == NULL) {
          SWIG_fail;
        } else {
@@ -947,7 +947,7 @@ static void SetPythonFlags(bool trace_propagation,
    return self->solver()->MakeSum(self, other);
  }
  IntExpr* __add__(Constraint* other) {
-    return self->solver()->MakeSum(self, other->StatusVar());
+    return self->solver()->MakeSum(self, other->Var());
  }
  IntExpr* __add__(int64 v) {
    return self->solver()->MakeSum(self, v);
@@ -959,7 +959,7 @@ static void SetPythonFlags(bool trace_propagation,
    return self->solver()->MakeDifference(self, other);
  }
  IntExpr* __sub__(Constraint* other) {
-    return self->solver()->MakeDifference(self, other->StatusVar());
+    return self->solver()->MakeDifference(self, other->Var());
  }
  IntExpr* __sub__(int64 v) {
    return self->solver()->MakeSum(self, -v);
@@ -971,7 +971,7 @@ static void SetPythonFlags(bool trace_propagation,
    return self->solver()->MakeProd(self, other);
  }
  IntExpr* __mul__(Constraint* other) {
-    return self->solver()->MakeProd(self, other->StatusVar());
+    return self->solver()->MakeProd(self, other->Var());
  }
  IntExpr* __mul__(int64 v) {
    return self->solver()->MakeProd(self, v);
@@ -1030,22 +1030,22 @@ static void SetPythonFlags(bool trace_propagation,
    return self->solver()->MakeLess(self->Var(), other->Var());
  }
  Constraint* __eq__(Constraint* other) {
-    return self->solver()->MakeEquality(self->Var(), other->StatusVar());
+    return self->solver()->MakeEquality(self->Var(), other->Var());
  }
  Constraint* __ne__(Constraint* other) {
-    return self->solver()->MakeNonEquality(self->Var(), other->StatusVar());
+    return self->solver()->MakeNonEquality(self->Var(), other->Var());
  }
  Constraint* __ge__(Constraint* other) {
-    return self->solver()->MakeGreaterOrEqual(self->Var(), other->StatusVar());
+    return self->solver()->MakeGreaterOrEqual(self->Var(), other->Var());
  }
  Constraint* __gt__(Constraint* other) {
-    return self->solver()->MakeGreater(self->Var(), other->StatusVar());
+    return self->solver()->MakeGreater(self->Var(), other->Var());
  }
  Constraint* __le__(Constraint* other) {
-    return self->solver()->MakeLessOrEqual(self->Var(), other->StatusVar());
+    return self->solver()->MakeLessOrEqual(self->Var(), other->Var());
  }
  Constraint* __lt__(Constraint* other) {
-    return self->solver()->MakeLess(self->Var(), other->StatusVar());
+    return self->solver()->MakeLess(self->Var(), other->Var());
  }
  Constraint* MapTo(const std::vector<IntVar*>& vars) {
    return self->solver()->MakeMapDomain(self->Var(), vars);
@@ -1061,121 +1061,117 @@ static void SetPythonFlags(bool trace_propagation,
 // Add arithmetic operators to integer expressions.
 %extend Constraint {
  IntExpr* __add__(IntExpr* other) {
-    return self->solver()->MakeSum(self->StatusVar(), other);
+    return self->solver()->MakeSum(self->Var(), other);
  }
  IntExpr* __add__(Constraint* other) {
-    return self->solver()->MakeSum(self->StatusVar(), other->StatusVar());
+    return self->solver()->MakeSum(self->Var(), other->Var());
  }
  IntExpr* __add__(int64 v) {
-    return self->solver()->MakeSum(self->StatusVar(), v);
+    return self->solver()->MakeSum(self->Var(), v);
  }
  IntExpr* __radd__(int64 v) {
-    return self->solver()->MakeSum(self->StatusVar(), v);
+    return self->solver()->MakeSum(self->Var(), v);
  }
  IntExpr* __sub__(IntExpr* other) {
-    return self->solver()->MakeDifference(self->StatusVar(), other);
+    return self->solver()->MakeDifference(self->Var(), other);
  }
  IntExpr* __sub__(Constraint* other) {
-    return self->solver()->MakeDifference(self->StatusVar(),
-                                          other->StatusVar());
+    return self->solver()->MakeDifference(self->Var(), other->Var());
  }
  IntExpr* __sub__(int64 v) {
-    return self->solver()->MakeSum(self->StatusVar(), -v);
+    return self->solver()->MakeSum(self->Var(), -v);
  }
  IntExpr* __rsub__(int64 v) {
-    return self->solver()->MakeDifference(v, self->StatusVar());
+    return self->solver()->MakeDifference(v, self->Var());
  }
  IntExpr* __mul__(IntExpr* other) {
-    return self->solver()->MakeProd(self->StatusVar(), other);
+    return self->solver()->MakeProd(self->Var(), other);
  }
  IntExpr* __mul__(Constraint* other) {
-    return self->solver()->MakeProd(self->StatusVar(), other->StatusVar());
+    return self->solver()->MakeProd(self->Var(), other->Var());
  }
  IntExpr* __mul__(int64 v) {
-    return self->solver()->MakeProd(self->StatusVar(), v);
+    return self->solver()->MakeProd(self->Var(), v);
  }
  IntExpr* __rmul__(int64 v) {
-    return self->solver()->MakeProd(self->StatusVar(), v);
+    return self->solver()->MakeProd(self->Var(), v);
  }
  IntExpr* __floordiv__(int64 v) {
-    return self->solver()->MakeDiv(self->StatusVar(), v);
+    return self->solver()->MakeDiv(self->Var(), v);
  }

  IntExpr* __neg__() {
-    return self->solver()->MakeOpposite(self->StatusVar());
+    return self->solver()->MakeOpposite(self->Var());
  }
  IntExpr* __abs__() {
-    return self->solver()->MakeAbs(self->StatusVar());
+    return self->solver()->MakeAbs(self->Var());
  }
  IntExpr* Square() {
-    return self->solver()->MakeSquare(self->StatusVar());
+    return self->solver()->MakeSquare(self->Var());
  }

  Constraint* __eq__(int64 v) {
-    return self->solver()->MakeEquality(self->StatusVar(), v);
+    return self->solver()->MakeEquality(self->Var(), v);
  }
  Constraint* __ne__(int64 v) {
-    return self->solver()->MakeNonEquality(self->StatusVar(), v);
+    return self->solver()->MakeNonEquality(self->Var(), v);
  }
  Constraint* __ge__(int64 v) {
-    return self->solver()->MakeGreaterOrEqual(self->StatusVar(), v);
+    return self->solver()->MakeGreaterOrEqual(self->Var(), v);
  }
  Constraint* __gt__(int64 v) {
-    return self->solver()->MakeGreater(self->StatusVar(), v);
+    return self->solver()->MakeGreater(self->Var(), v);
  }
  Constraint* __le__(int64 v) {
-    return self->solver()->MakeLessOrEqual(self->StatusVar(), v);
+    return self->solver()->MakeLessOrEqual(self->Var(), v);
  }
  Constraint* __lt__(int64 v) {
-    return self->solver()->MakeLess(self->StatusVar(), v);
+    return self->solver()->MakeLess(self->Var(), v);
  }
  Constraint* __eq__(IntExpr* other) {
-    return self->solver()->MakeEquality(self->StatusVar(), other->Var());
+    return self->solver()->MakeEquality(self->Var(), other->Var());
  }
  Constraint* __ne__(IntExpr* other) {
-    return self->solver()->MakeNonEquality(self->StatusVar(), other->Var());
+    return self->solver()->MakeNonEquality(self->Var(), other->Var());
  }
  Constraint* __ge__(IntExpr* other) {
-    return self->solver()->MakeGreaterOrEqual(self->StatusVar(), other->Var());
+    return self->solver()->MakeGreaterOrEqual(self->Var(), other->Var());
  }
  Constraint* __gt__(IntExpr* other) {
-    return self->solver()->MakeGreater(self->StatusVar(), other->Var());
+    return self->solver()->MakeGreater(self->Var(), other->Var());
  }
  Constraint* __le__(IntExpr* other) {
-    return self->solver()->MakeLessOrEqual(self->StatusVar(), other->Var());
+    return self->solver()->MakeLessOrEqual(self->Var(), other->Var());
  }
  Constraint* __lt__(IntExpr* other) {
-    return self->solver()->MakeLess(self->StatusVar(), other->Var());
+    return self->solver()->MakeLess(self->Var(), other->Var());
  }
  Constraint* __eq__(Constraint* other) {
-    return self->solver()->MakeEquality(self->StatusVar(), other->StatusVar());
+    return self->solver()->MakeEquality(self->Var(), other->Var());
  }
  Constraint* __ne__(Constraint* other) {
-    return self->solver()->MakeNonEquality(self->StatusVar(),
-                                           other->StatusVar());
+    return self->solver()->MakeNonEquality(self->Var(), other->Var());
  }
  Constraint* __ge__(Constraint* other) {
-    return self->solver()->MakeGreaterOrEqual(self->StatusVar(),
-                                              other->StatusVar());
+    return self->solver()->MakeGreaterOrEqual(self->Var(), other->Var());
  }
  Constraint* __gt__(Constraint* other) {
-    return self->solver()->MakeGreater(self->StatusVar(), other->StatusVar());
+    return self->solver()->MakeGreater(self->Var(), other->Var());
  }
  Constraint* __le__(Constraint* other) {
-    return self->solver()->MakeLessOrEqual(self->StatusVar(),
-                                           other->StatusVar());
+    return self->solver()->MakeLessOrEqual(self->Var(), other->Var());
  }
  Constraint* __lt__(Constraint* other) {
-    return self->solver()->MakeLess(self->StatusVar(), other->StatusVar());
+    return self->solver()->MakeLess(self->Var(), other->Var());
  }
  Constraint* MapTo(const std::vector<IntVar*>& vars) {
-    return self->solver()->MakeMapDomain(self->StatusVar(), vars);
+    return self->solver()->MakeMapDomain(self->Var(), vars);
  }
  IntExpr* IndexOf(const std::vector<int64>& vars) {
-    return self->solver()->MakeElement(vars, self->StatusVar());
+    return self->solver()->MakeElement(vars, self->Var());
  }
  IntExpr* IndexOf(const std::vector<IntVar*>& vars) {
-    return self->solver()->MakeElement(vars, self->StatusVar());
+    return self->solver()->MakeElement(vars, self->Var());
  }
 }

@@ -1317,7 +1313,6 @@ struct FailureProtect {
 %rename (toString) *::DebugString;
 %rename (tryDecisions) operations_research::Solver::Try;

-
 %rename("%(lowercamelcase)s", %$isfunction) "";

 namespace operations_research {
@@ -1592,16 +1587,12 @@ struct FailureProtect {
 %typemap(cscode) operations_research::Constraint %{
  public static implicit operator IntVar(Constraint eq)
  {
-    return eq.StatusVar();
+    return eq.Var();
  }

  public static implicit operator IntExpr(Constraint eq)
  {
-    return eq.StatusVar();
-  }
-  public IntVar Var()
-  {
-    return StatusVar();
+    return eq.Var();
  }
  public static IntExpr operator+(Constraint a, Constraint b) {
    return a.solver().MakeSum(a.Var(), b.Var());
--- a/constraint_solver/count_cst.cc
+++ b/constraint_solver/count_cst.cc
@@ -217,7 +217,7 @@ class CountValueEq : public Constraint {
  virtual void InitialPropagate();
  void OneBound(int index);
  void OneDomain(int index);
-  void Var();
+  void CountVar();
  void CardMin();
  void CardMax();
  virtual string DebugString() const;
@@ -282,7 +282,7 @@ void CountValueEq::Post() {
  if (!count_->Bound()) {
    Demon* d = MakeConstraintDemon0(solver(),
                                        this,
-                                        &CountValueEq::Var,
+                                        &CountValueEq::CountVar,
                                        "Var");
    count_->WhenRange(d);
  }
@@ -350,7 +350,7 @@ void CountValueEq::OneDomain(int index) {
  }
 }

-void CountValueEq::Var() {
+void CountValueEq::CountVar() {
  if (count_->Min() > max_.Value()) {
    solver()->Fail();
  }
@@ -415,7 +415,7 @@ class Distribute : public Constraint {
  virtual void InitialPropagate();
  void OneBound(int vindex);
  void OneDomain(int vindex);
-  void Var(int cindex);
+  void CountVar(int cindex);
  void CardMin(int cindex);
  void CardMax(int cindex);
  virtual string DebugString() const;
@@ -517,7 +517,7 @@ void Distribute::Post() {
    if (!cards_[i]->Bound()) {
      Demon* d = MakeConstraintDemon1(solver(),
                                      this,
-                                      &Distribute::Var,
+                                      &Distribute::CountVar,
                                      "Var",
                                      i);
      cards_[i]->WhenRange(d);
@@ -595,7 +595,7 @@ void Distribute::OneDomain(int index) {
  }
 }

-void Distribute::Var(int cindex) {
+void Distribute::CountVar(int cindex) {
  if (cards_[cindex]->Min() > max_[cindex] ||
      cards_[cindex]->Max() < min_[cindex]) {
    solver()->Fail();
@@ -639,7 +639,7 @@ class FastDistribute : public Constraint {
  virtual void InitialPropagate();
  void OneBound(int vindex);
  void OneDomain(int vindex);
-  void Var(int card_index);
+  void CountVar(int card_index);
  void CardMin(int card_index);
  void CardMax(int card_index);
  virtual string DebugString() const;
@@ -734,7 +734,7 @@ void FastDistribute::Post() {
    if (!cards_[card_index]->Bound()) {
      Demon* d = MakeConstraintDemon1(solver(),
                                      this,
-                                      &FastDistribute::Var,
+                                      &FastDistribute::CountVar,
                                      "Var",
                                      card_index);
      cards_[card_index]->WhenRange(d);
@@ -759,7 +759,7 @@ void FastDistribute::InitialPropagate() {
    }
    min_.SetValue(s, card_index, min);
    max_.SetValue(s, card_index, max);
-    Var(card_index);
+    CountVar(card_index);
  }
 }

@@ -807,7 +807,7 @@ void FastDistribute::OneDomain(int index) {
  }
 }

-void FastDistribute::Var(int card_index) {
+void FastDistribute::CountVar(int card_index) {
  const int64 stored_min = min_[card_index];
  const int64 stored_max = max_[card_index];
  cards_[card_index]->SetRange(min_[card_index], max_[card_index]);
@@ -851,7 +851,7 @@ class BoundedDistribute : public Constraint {
  virtual void InitialPropagate();
  void OneBound(int vindex);
  void OneDomain(int vindex);
-  void Var(int card_index);
+  void CountVar(int card_index);
  void CardMin(int card_index);
  void CardMax(int card_index);
  virtual string DebugString() const;
@@ -985,7 +985,7 @@ void BoundedDistribute::InitialPropagate() {
    }
    min_.SetValue(s, card_index, min);
    max_.SetValue(s, card_index, max);
-    Var(card_index);
+    CountVar(card_index);
  }
 }

@@ -1034,7 +1034,7 @@ void BoundedDistribute::OneDomain(int index) {
  }
 }

-void BoundedDistribute::Var(int card_index) {
+void BoundedDistribute::CountVar(int card_index) {
  const int64 stored_min = min_[card_index];
  const int64 stored_max = max_[card_index];
  if (card_min_ > stored_max || card_max_ < stored_min) {
--- a/constraint_solver/expr_cst.cc
+++ b/constraint_solver/expr_cst.cc
@@ -27,7 +27,7 @@
 #include "util/const_int_array.h"

 DEFINE_int32(cache_initial_size, 1024, "Initial size of the array of the hash "
-             "table of caches for objects of type StatusVar(x == 3)");
+             "table of caches for objects of type Var(x == 3)");

 namespace operations_research {

@@ -41,7 +41,7 @@ class EqualityExprCst : public Constraint {
  virtual ~EqualityExprCst() {}
  virtual void Post();
  virtual void InitialPropagate();
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsEqualCstVar(expr_->Var(), value_);
  }
  virtual string DebugString() const;
@@ -100,7 +100,7 @@ class GreaterEqExprCst : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsGreaterOrEqualCstVar(expr_->Var(), value_);
  }

@@ -168,7 +168,7 @@ class LessEqExprCst : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsLessOrEqualCstVar(expr_->Var(), value_);
  }
  virtual void Accept(ModelVisitor* const visitor) const {
@@ -235,7 +235,7 @@ class DiffCst : public Constraint {
  virtual void InitialPropagate();
  void BoundPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsDifferentCstVar(var_, value_);
  }
  virtual void Accept(ModelVisitor* const visitor) const {
@@ -374,7 +374,7 @@ IntVar* Solver::MakeIsEqualCstVar(IntVar* const var, int64 value) {
      name = var->DebugString();
    }
    IntVar* const boolvar = MakeBoolVar(
-        StringPrintf("StatusVar<%s == %" GG_LL_FORMAT "d>",
+        StringPrintf("Var<%s == %" GG_LL_FORMAT "d>",
                     name.c_str(), value));
    CastConstraint* const maintain =
        RevAlloc(new IsEqualCstCt(this, var, value, boolvar));
@@ -490,7 +490,7 @@ IntVar* Solver::MakeIsDifferentCstVar(IntVar* const var, int64 value) {
      name = var->DebugString();
    }
    IntVar* const boolvar = MakeBoolVar(
-        StringPrintf("StatusVar<%s != %" GG_LL_FORMAT "d>",
+        StringPrintf("Var<%s != %" GG_LL_FORMAT "d>",
                     name.c_str(), value));
    CastConstraint* const maintain =
        RevAlloc(new IsDiffCstCt(this, var, value, boolvar));
@@ -596,7 +596,7 @@ IntVar* Solver::MakeIsGreaterOrEqualCstVar(IntVar* const var, int64 value) {
      name = var->DebugString();
    }
    IntVar* const boolvar = MakeBoolVar(
-        StringPrintf("StatusVar<%s >= %" GG_LL_FORMAT "d>",
+        StringPrintf("Var<%s >= %" GG_LL_FORMAT "d>",
                     name.c_str(), value));
    CastConstraint* const maintain =
        RevAlloc(new IsGreaterEqualCstCt(this, var, value, boolvar));
@@ -708,7 +708,7 @@ IntVar* Solver::MakeIsLessOrEqualCstVar(IntVar* const var, int64 value) {
      name = var->DebugString();
    }
    IntVar* const boolvar = MakeBoolVar(
-        StringPrintf("StatusVar<%s <= %" GG_LL_FORMAT "d>",
+        StringPrintf("Var<%s <= %" GG_LL_FORMAT "d>",
                     name.c_str(), value));
    CastConstraint* const maintain =
        RevAlloc(new IsLessEqualCstCt(this, var, value, boolvar));
--- a/constraint_solver/range_cst.cc
+++ b/constraint_solver/range_cst.cc
@@ -32,7 +32,7 @@ class RangeEquality : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsEqualVar(left_, right_);
  }
  virtual void Accept(ModelVisitor* const visitor) const {
@@ -86,7 +86,7 @@ class RangeLessOrEqual : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsLessOrEqualVar(left_, right_);
  }
  virtual void Accept(ModelVisitor* const visitor) const {
@@ -141,7 +141,7 @@ class RangeGreaterOrEqual : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsGreaterOrEqualVar(left_, right_);
  }
  virtual void Accept(ModelVisitor* const visitor) const {
@@ -196,7 +196,7 @@ class RangeLess : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsLessVar(left_, right_);
  }
  virtual void Accept(ModelVisitor* const visitor) const {
@@ -250,7 +250,7 @@ class RangeGreater : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsGreaterVar(left_, right_);
  }
  virtual void Accept(ModelVisitor* const visitor) const {
@@ -304,7 +304,7 @@ class DiffVar : public Constraint {
  virtual void Post();
  virtual void InitialPropagate();
  virtual string DebugString() const;
-  virtual IntVar* StatusVar() {
+  virtual IntVar* Var() {
    return solver()->MakeIsDifferentVar(left_, right_);
  }