diff --git a/ortools/constraint_solver/constraint_solver.cc b/ortools/constraint_solver/constraint_solver.cc index 94cee18913..1e3b2f511f 100644 --- a/ortools/constraint_solver/constraint_solver.cc +++ b/ortools/constraint_solver/constraint_solver.cc @@ -171,9 +171,9 @@ ConstraintSolverParameters Solver::DefaultSolverParameters() { } // ----- Forward Declarations and Profiling Support ----- -extern DemonProfiler* BuildDemonProfiler(Solver* const solver); -extern void DeleteDemonProfiler(DemonProfiler* const monitor); -extern void InstallDemonProfiler(DemonProfiler* const monitor); +extern DemonProfiler* BuildDemonProfiler(Solver* solver); +extern void DeleteDemonProfiler(DemonProfiler* monitor); +extern void InstallDemonProfiler(DemonProfiler* monitor); extern LocalSearchProfiler* BuildLocalSearchProfiler(Solver* solver); extern void DeleteLocalSearchProfiler(LocalSearchProfiler* monitor); extern void InstallLocalSearchProfiler(LocalSearchProfiler* monitor); @@ -225,7 +225,7 @@ void Demon::desinhibit(Solver* const s) { // ------------------ Queue class ------------------ -extern void CleanVariableOnFail(IntVar* const var); +extern void CleanVariableOnFail(IntVar* var); class Queue { public: @@ -733,7 +733,7 @@ class CompressedTrail { // passing and storing a pointer. As objects are small, copying is // much faster than allocating (around 35% on a complete solve). -extern void RestoreBoolValue(IntVar* const var); +extern void RestoreBoolValue(IntVar* var); struct Trail { CompressedTrail rev_ints_; @@ -1009,11 +1009,11 @@ class Search { void EnterSearch(); void RestartSearch(); void ExitSearch(); - void BeginNextDecision(DecisionBuilder* const db); - void EndNextDecision(DecisionBuilder* const db, Decision* const d); - void ApplyDecision(Decision* const d); - void AfterDecision(Decision* const d, bool apply); - void RefuteDecision(Decision* const d); + void BeginNextDecision(DecisionBuilder* db); + void EndNextDecision(DecisionBuilder* db, Decision* d); + void ApplyDecision(Decision* d); + void AfterDecision(Decision* d, bool apply); + void RefuteDecision(Decision* d); void BeginFail(); void EndFail(); void BeginInitialPropagation(); @@ -1028,7 +1028,7 @@ class Search { bool IsUncheckedSolutionLimitReached(); void PeriodicCheck(); int ProgressPercent(); - void Accept(ModelVisitor* const visitor) const; + void Accept(ModelVisitor* visitor) const; void AddEventListener(Solver::MonitorEvent event, SearchMonitor* monitor) { if (monitor != nullptr) { monitor_event_listeners_[to_underlying(event)].push_back(monitor); @@ -1421,9 +1421,9 @@ enum SentinelMarker { }; } // namespace -extern PropagationMonitor* BuildTrace(Solver* const s); -extern LocalSearchMonitor* BuildLocalSearchMonitorPrimary(Solver* const s); -extern ModelCache* BuildModelCache(Solver* const solver); +extern PropagationMonitor* BuildTrace(Solver* s); +extern LocalSearchMonitor* BuildLocalSearchMonitorPrimary(Solver* s); +extern ModelCache* BuildModelCache(Solver* solver); std::string Solver::model_name() const { return name_; } @@ -1870,7 +1870,7 @@ void Solver::NewSearch(DecisionBuilder* const db, SearchMonitor* const m1, return NewSearch(db, monitors); } -extern PropagationMonitor* BuildPrintTrace(Solver* const s); +extern PropagationMonitor* BuildPrintTrace(Solver* s); // Opens a new top level search. void Solver::NewSearch(DecisionBuilder* const db, diff --git a/ortools/constraint_solver/constraint_solver.h b/ortools/constraint_solver/constraint_solver.h index fcad662752..583226a42a 100644 --- a/ortools/constraint_solver/constraint_solver.h +++ b/ortools/constraint_solver/constraint_solver.h @@ -876,12 +876,12 @@ class Solver { /// automatically be deleted. However, power users who implement their own /// constraints should do: solver.AddConstraint(solver.RevAlloc(new /// MyConstraint(...)); - void AddConstraint(Constraint* const c); + void AddConstraint(Constraint* c); /// Adds 'constraint' to the solver and marks it as a cast constraint, that /// is, a constraint created calling Var() on an expression. This is used /// internally. - void AddCastConstraint(CastConstraint* const constraint, - IntVar* const target_var, IntExpr* const expr); + void AddCastConstraint(CastConstraint* constraint, IntVar* target_var, + IntExpr* expr); /// @{ /// Solves the problem using the given DecisionBuilder and returns true if a @@ -924,17 +924,14 @@ class Solver { /// @param monitors A vector of search monitors that will be notified of /// various events during the search. In their reaction to these events, such /// monitors may influence the search. - bool Solve(DecisionBuilder* const db, - const std::vector& monitors); - bool Solve(DecisionBuilder* const db); - bool Solve(DecisionBuilder* const db, SearchMonitor* const m1); - bool Solve(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2); - bool Solve(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2, SearchMonitor* const m3); - bool Solve(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2, SearchMonitor* const m3, - SearchMonitor* const m4); + bool Solve(DecisionBuilder* db, const std::vector& monitors); + bool Solve(DecisionBuilder* db); + bool Solve(DecisionBuilder* db, SearchMonitor* m1); + bool Solve(DecisionBuilder* db, SearchMonitor* m1, SearchMonitor* m2); + bool Solve(DecisionBuilder* db, SearchMonitor* m1, SearchMonitor* m2, + SearchMonitor* m3); + bool Solve(DecisionBuilder* db, SearchMonitor* m1, SearchMonitor* m2, + SearchMonitor* m3, SearchMonitor* m4); /// @} /// @{ @@ -946,17 +943,15 @@ class Solver { /// } /// solver()->EndSearch(); - void NewSearch(DecisionBuilder* const db, + void NewSearch(DecisionBuilder* db, const std::vector& monitors); - void NewSearch(DecisionBuilder* const db); - void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1); - void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2); - void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2, SearchMonitor* const m3); - void NewSearch(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2, SearchMonitor* const m3, - SearchMonitor* const m4); + void NewSearch(DecisionBuilder* db); + void NewSearch(DecisionBuilder* db, SearchMonitor* m1); + void NewSearch(DecisionBuilder* db, SearchMonitor* m1, SearchMonitor* m2); + void NewSearch(DecisionBuilder* db, SearchMonitor* m1, SearchMonitor* m2, + SearchMonitor* m3); + void NewSearch(DecisionBuilder* db, SearchMonitor* m1, SearchMonitor* m2, + SearchMonitor* m3, SearchMonitor* m4); bool NextSolution(); void RestartSearch(); @@ -971,22 +966,22 @@ class Solver { /// call is the fact that SolveAndCommit will not backtrack all /// modifications at the end of the search. This method is only /// usable during the Next() method of a decision builder. - bool SolveAndCommit(DecisionBuilder* const db, + bool SolveAndCommit(DecisionBuilder* db, const std::vector& monitors); - bool SolveAndCommit(DecisionBuilder* const db); - bool SolveAndCommit(DecisionBuilder* const db, SearchMonitor* const m1); - bool SolveAndCommit(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2); - bool SolveAndCommit(DecisionBuilder* const db, SearchMonitor* const m1, - SearchMonitor* const m2, SearchMonitor* const m3); + bool SolveAndCommit(DecisionBuilder* db); + bool SolveAndCommit(DecisionBuilder* db, SearchMonitor* m1); + bool SolveAndCommit(DecisionBuilder* db, SearchMonitor* m1, + SearchMonitor* m2); + bool SolveAndCommit(DecisionBuilder* db, SearchMonitor* m1, SearchMonitor* m2, + SearchMonitor* m3); /// Checks whether the given assignment satisfies all relevant constraints. - bool CheckAssignment(Assignment* const solution); + bool CheckAssignment(Assignment* solution); /// Checks whether adding this constraint will lead to an immediate /// failure. It will return false if the model is already inconsistent, or if /// adding the constraint makes it inconsistent. - bool CheckConstraint(Constraint* const ct); + bool CheckConstraint(Constraint* ct); /// State of the solver. SolverState state() const { return state_; } @@ -1134,9 +1129,9 @@ class Solver { // ----- Integer Expressions ----- /// left + right. - IntExpr* MakeSum(IntExpr* const left, IntExpr* const right); + IntExpr* MakeSum(IntExpr* left, IntExpr* right); /// expr + value. - IntExpr* MakeSum(IntExpr* const expr, int64_t value); + IntExpr* MakeSum(IntExpr* expr, int64_t value); /// sum of all vars. IntExpr* MakeSum(const std::vector& vars); @@ -1148,38 +1143,38 @@ class Solver { const std::vector& coefs); /// left - right - IntExpr* MakeDifference(IntExpr* const left, IntExpr* const right); + IntExpr* MakeDifference(IntExpr* left, IntExpr* right); /// value - expr - IntExpr* MakeDifference(int64_t value, IntExpr* const expr); + IntExpr* MakeDifference(int64_t value, IntExpr* expr); /// -expr - IntExpr* MakeOpposite(IntExpr* const expr); + IntExpr* MakeOpposite(IntExpr* expr); /// left * right - IntExpr* MakeProd(IntExpr* const left, IntExpr* const right); + IntExpr* MakeProd(IntExpr* left, IntExpr* right); /// expr * value - IntExpr* MakeProd(IntExpr* const expr, int64_t value); + IntExpr* MakeProd(IntExpr* expr, int64_t value); /// expr / value (integer division) - IntExpr* MakeDiv(IntExpr* const expr, int64_t value); + IntExpr* MakeDiv(IntExpr* expr, int64_t value); /// numerator / denominator (integer division). Terms need to be positive. - IntExpr* MakeDiv(IntExpr* const numerator, IntExpr* const denominator); + IntExpr* MakeDiv(IntExpr* numerator, IntExpr* denominator); /// |expr| - IntExpr* MakeAbs(IntExpr* const expr); + IntExpr* MakeAbs(IntExpr* expr); /// expr * expr - IntExpr* MakeSquare(IntExpr* const expr); + IntExpr* MakeSquare(IntExpr* expr); /// expr ^ n (n > 0) - IntExpr* MakePower(IntExpr* const expr, int64_t n); + IntExpr* MakePower(IntExpr* expr, int64_t n); /// values[index] - IntExpr* MakeElement(const std::vector& values, IntVar* const index); + IntExpr* MakeElement(const std::vector& values, IntVar* index); /// values[index] - IntExpr* MakeElement(const std::vector& values, IntVar* const index); + IntExpr* MakeElement(const std::vector& values, IntVar* index); /// Function-based element. The constraint takes ownership of the /// callback. The callback must be able to cope with any possible /// value in the domain of 'index' (potentially negative ones too). - IntExpr* MakeElement(IndexEvaluator1 values, IntVar* const index); + IntExpr* MakeElement(IndexEvaluator1 values, IntVar* index); /// Function based element. The constraint takes ownership of the /// callback. The callback must be monotonic. It must be able to /// cope with any possible value in the domain of 'index' @@ -1187,13 +1182,12 @@ class Solver { /// checked. Thus giving a non-monotonic function, or specifying an /// incorrect increasing parameter will result in undefined behavior. IntExpr* MakeMonotonicElement(IndexEvaluator1 values, bool increasing, - IntVar* const index); + IntVar* index); /// 2D version of function-based element expression, values(expr1, expr2). - IntExpr* MakeElement(IndexEvaluator2 values, IntVar* const index1, - IntVar* const index2); + IntExpr* MakeElement(IndexEvaluator2 values, IntVar* index1, IntVar* index2); /// vars[expr] - IntExpr* MakeElement(const std::vector& vars, IntVar* const index); + IntExpr* MakeElement(const std::vector& vars, IntVar* index); #if !defined(SWIG) /// vars(argument) @@ -1239,28 +1233,26 @@ class Solver { IntExpr* MakeIndexExpression(const std::vector& vars, int64_t value); /// Special cases with arrays of size two. - Constraint* MakeIfThenElseCt(IntVar* const condition, - IntExpr* const then_expr, - IntExpr* const else_expr, - IntVar* const target_var); + Constraint* MakeIfThenElseCt(IntVar* condition, IntExpr* then_expr, + IntExpr* else_expr, IntVar* target_var); /// std::min(vars) IntExpr* MakeMin(const std::vector& vars); /// std::min (left, right) - IntExpr* MakeMin(IntExpr* const left, IntExpr* const right); + IntExpr* MakeMin(IntExpr* left, IntExpr* right); /// std::min(expr, value) - IntExpr* MakeMin(IntExpr* const expr, int64_t value); + IntExpr* MakeMin(IntExpr* expr, int64_t value); /// std::min(expr, value) - IntExpr* MakeMin(IntExpr* const expr, int value); + IntExpr* MakeMin(IntExpr* expr, int value); /// std::max(vars) IntExpr* MakeMax(const std::vector& vars); /// std::max(left, right) - IntExpr* MakeMax(IntExpr* const left, IntExpr* const right); + IntExpr* MakeMax(IntExpr* left, IntExpr* right); /// std::max(expr, value) - IntExpr* MakeMax(IntExpr* const expr, int64_t value); + IntExpr* MakeMax(IntExpr* expr, int64_t value); /// std::max(expr, value) - IntExpr* MakeMax(IntExpr* const expr, int value); + IntExpr* MakeMax(IntExpr* expr, int value); /// Convex piecewise function. IntExpr* MakeConvexPiecewiseExpr(IntExpr* expr, int64_t early_cost, @@ -1269,7 +1261,7 @@ class Solver { /// Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) /// a >= 0 and b >= 0 - IntExpr* MakeSemiContinuousExpr(IntExpr* const expr, int64_t fixed_charge, + IntExpr* MakeSemiContinuousExpr(IntExpr* expr, int64_t fixed_charge, int64_t step); /// General piecewise-linear function expression, built from f(x) where f is @@ -1282,14 +1274,13 @@ class Solver { #endif /// Modulo expression x % mod (with the python convention for modulo). - IntExpr* MakeModulo(IntExpr* const x, int64_t mod); + IntExpr* MakeModulo(IntExpr* x, int64_t mod); /// Modulo expression x % mod (with the python convention for modulo). - IntExpr* MakeModulo(IntExpr* const x, IntExpr* const mod); + IntExpr* MakeModulo(IntExpr* x, IntExpr* mod); /// Conditional Expr condition ? expr : unperformed_value - IntExpr* MakeConditionalExpression(IntVar* const condition, - IntExpr* const expr, + IntExpr* MakeConditionalExpression(IntVar* condition, IntExpr* expr, int64_t unperformed_value); /// This constraint always succeeds. @@ -1299,111 +1290,104 @@ class Solver { Constraint* MakeFalseConstraint(const std::string& explanation); /// boolvar == (var == value) - Constraint* MakeIsEqualCstCt(IntExpr* const var, int64_t value, - IntVar* const boolvar); + Constraint* MakeIsEqualCstCt(IntExpr* var, int64_t value, IntVar* boolvar); /// status var of (var == value) - IntVar* MakeIsEqualCstVar(IntExpr* const var, int64_t value); + IntVar* MakeIsEqualCstVar(IntExpr* var, int64_t value); /// b == (v1 == v2) - Constraint* MakeIsEqualCt(IntExpr* const v1, IntExpr* v2, IntVar* const b); + Constraint* MakeIsEqualCt(IntExpr* v1, IntExpr* v2, IntVar* b); /// status var of (v1 == v2) - IntVar* MakeIsEqualVar(IntExpr* const v1, IntExpr* v2); + IntVar* MakeIsEqualVar(IntExpr* v1, IntExpr* v2); /// left == right - Constraint* MakeEquality(IntExpr* const left, IntExpr* const right); + Constraint* MakeEquality(IntExpr* left, IntExpr* right); /// expr == value - Constraint* MakeEquality(IntExpr* const expr, int64_t value); + Constraint* MakeEquality(IntExpr* expr, int64_t value); /// expr == value - Constraint* MakeEquality(IntExpr* const expr, int value); + Constraint* MakeEquality(IntExpr* expr, int value); /// boolvar == (var != value) - Constraint* MakeIsDifferentCstCt(IntExpr* const var, int64_t value, - IntVar* const boolvar); + Constraint* MakeIsDifferentCstCt(IntExpr* var, int64_t value, + IntVar* boolvar); /// status var of (var != value) - IntVar* MakeIsDifferentCstVar(IntExpr* const var, int64_t value); + IntVar* MakeIsDifferentCstVar(IntExpr* var, int64_t value); /// status var of (v1 != v2) - IntVar* MakeIsDifferentVar(IntExpr* const v1, IntExpr* const v2); + IntVar* MakeIsDifferentVar(IntExpr* v1, IntExpr* v2); /// b == (v1 != v2) - Constraint* MakeIsDifferentCt(IntExpr* const v1, IntExpr* const v2, - IntVar* const b); + Constraint* MakeIsDifferentCt(IntExpr* v1, IntExpr* v2, IntVar* b); /// left != right - Constraint* MakeNonEquality(IntExpr* const left, IntExpr* const right); + Constraint* MakeNonEquality(IntExpr* left, IntExpr* right); /// expr != value - Constraint* MakeNonEquality(IntExpr* const expr, int64_t value); + Constraint* MakeNonEquality(IntExpr* expr, int64_t value); /// expr != value - Constraint* MakeNonEquality(IntExpr* const expr, int value); + Constraint* MakeNonEquality(IntExpr* expr, int value); /// boolvar == (var <= value) - Constraint* MakeIsLessOrEqualCstCt(IntExpr* const var, int64_t value, - IntVar* const boolvar); + Constraint* MakeIsLessOrEqualCstCt(IntExpr* var, int64_t value, + IntVar* boolvar); /// status var of (var <= value) - IntVar* MakeIsLessOrEqualCstVar(IntExpr* const var, int64_t value); + IntVar* MakeIsLessOrEqualCstVar(IntExpr* var, int64_t value); /// status var of (left <= right) - IntVar* MakeIsLessOrEqualVar(IntExpr* const left, IntExpr* const right); + IntVar* MakeIsLessOrEqualVar(IntExpr* left, IntExpr* right); /// b == (left <= right) - Constraint* MakeIsLessOrEqualCt(IntExpr* const left, IntExpr* const right, - IntVar* const b); + Constraint* MakeIsLessOrEqualCt(IntExpr* left, IntExpr* right, IntVar* b); /// left <= right - Constraint* MakeLessOrEqual(IntExpr* const left, IntExpr* const right); + Constraint* MakeLessOrEqual(IntExpr* left, IntExpr* right); /// expr <= value - Constraint* MakeLessOrEqual(IntExpr* const expr, int64_t value); + Constraint* MakeLessOrEqual(IntExpr* expr, int64_t value); /// expr <= value - Constraint* MakeLessOrEqual(IntExpr* const expr, int value); + Constraint* MakeLessOrEqual(IntExpr* expr, int value); /// boolvar == (var >= value) - Constraint* MakeIsGreaterOrEqualCstCt(IntExpr* const var, int64_t value, - IntVar* const boolvar); + Constraint* MakeIsGreaterOrEqualCstCt(IntExpr* var, int64_t value, + IntVar* boolvar); /// status var of (var >= value) - IntVar* MakeIsGreaterOrEqualCstVar(IntExpr* const var, int64_t value); + IntVar* MakeIsGreaterOrEqualCstVar(IntExpr* var, int64_t value); /// status var of (left >= right) - IntVar* MakeIsGreaterOrEqualVar(IntExpr* const left, IntExpr* const right); + IntVar* MakeIsGreaterOrEqualVar(IntExpr* left, IntExpr* right); /// b == (left >= right) - Constraint* MakeIsGreaterOrEqualCt(IntExpr* const left, IntExpr* const right, - IntVar* const b); + Constraint* MakeIsGreaterOrEqualCt(IntExpr* left, IntExpr* right, IntVar* b); /// left >= right - Constraint* MakeGreaterOrEqual(IntExpr* const left, IntExpr* const right); + Constraint* MakeGreaterOrEqual(IntExpr* left, IntExpr* right); /// expr >= value - Constraint* MakeGreaterOrEqual(IntExpr* const expr, int64_t value); + Constraint* MakeGreaterOrEqual(IntExpr* expr, int64_t value); /// expr >= value - Constraint* MakeGreaterOrEqual(IntExpr* const expr, int value); + Constraint* MakeGreaterOrEqual(IntExpr* expr, int value); /// b == (v > c) - Constraint* MakeIsGreaterCstCt(IntExpr* const v, int64_t c, IntVar* const b); + Constraint* MakeIsGreaterCstCt(IntExpr* v, int64_t c, IntVar* b); /// status var of (var > value) - IntVar* MakeIsGreaterCstVar(IntExpr* const var, int64_t value); + IntVar* MakeIsGreaterCstVar(IntExpr* var, int64_t value); /// status var of (left > right) - IntVar* MakeIsGreaterVar(IntExpr* const left, IntExpr* const right); + IntVar* MakeIsGreaterVar(IntExpr* left, IntExpr* right); /// b == (left > right) - Constraint* MakeIsGreaterCt(IntExpr* const left, IntExpr* const right, - IntVar* const b); + Constraint* MakeIsGreaterCt(IntExpr* left, IntExpr* right, IntVar* b); /// left > right - Constraint* MakeGreater(IntExpr* const left, IntExpr* const right); + Constraint* MakeGreater(IntExpr* left, IntExpr* right); /// expr > value - Constraint* MakeGreater(IntExpr* const expr, int64_t value); + Constraint* MakeGreater(IntExpr* expr, int64_t value); /// expr > value - Constraint* MakeGreater(IntExpr* const expr, int value); + Constraint* MakeGreater(IntExpr* expr, int value); /// b == (v < c) - Constraint* MakeIsLessCstCt(IntExpr* const v, int64_t c, IntVar* const b); + Constraint* MakeIsLessCstCt(IntExpr* v, int64_t c, IntVar* b); /// status var of (var < value) - IntVar* MakeIsLessCstVar(IntExpr* const var, int64_t value); + IntVar* MakeIsLessCstVar(IntExpr* var, int64_t value); /// status var of (left < right) - IntVar* MakeIsLessVar(IntExpr* const left, IntExpr* const right); + IntVar* MakeIsLessVar(IntExpr* left, IntExpr* right); /// b == (left < right) - Constraint* MakeIsLessCt(IntExpr* const left, IntExpr* const right, - IntVar* const b); + Constraint* MakeIsLessCt(IntExpr* left, IntExpr* right, IntVar* b); /// left < right - Constraint* MakeLess(IntExpr* const left, IntExpr* const right); + Constraint* MakeLess(IntExpr* left, IntExpr* right); /// expr < value - Constraint* MakeLess(IntExpr* const expr, int64_t value); + Constraint* MakeLess(IntExpr* expr, int64_t value); /// expr < value - Constraint* MakeLess(IntExpr* const expr, int value); + Constraint* MakeLess(IntExpr* expr, int value); /// Variation on arrays. Constraint* MakeSumLessOrEqual(const std::vector& vars, int64_t cst); Constraint* MakeSumGreaterOrEqual(const std::vector& vars, int64_t cst); Constraint* MakeSumEquality(const std::vector& vars, int64_t cst); - Constraint* MakeSumEquality(const std::vector& vars, - IntVar* const var); + Constraint* MakeSumEquality(const std::vector& vars, IntVar* var); Constraint* MakeScalProdEquality(const std::vector& vars, const std::vector& coefficients, int64_t cst); @@ -1412,10 +1396,10 @@ class Solver { int64_t cst); Constraint* MakeScalProdEquality(const std::vector& vars, const std::vector& coefficients, - IntVar* const target); + IntVar* target); Constraint* MakeScalProdEquality(const std::vector& vars, const std::vector& coefficients, - IntVar* const target); + IntVar* target); Constraint* MakeScalProdGreaterOrEqual(const std::vector& vars, const std::vector& coeffs, int64_t cst); @@ -1430,34 +1414,34 @@ class Solver { int64_t cst); Constraint* MakeMinEquality(const std::vector& vars, - IntVar* const min_var); + IntVar* min_var); Constraint* MakeMaxEquality(const std::vector& vars, - IntVar* const max_var); + IntVar* max_var); Constraint* MakeElementEquality(const std::vector& vals, - IntVar* const index, IntVar* const target); - Constraint* MakeElementEquality(const std::vector& vals, - IntVar* const index, IntVar* const target); + IntVar* index, IntVar* target); + Constraint* MakeElementEquality(const std::vector& vals, IntVar* index, + IntVar* target); Constraint* MakeElementEquality(const std::vector& vars, - IntVar* const index, IntVar* const target); + IntVar* index, IntVar* target); Constraint* MakeElementEquality(const std::vector& vars, - IntVar* const index, int64_t target); + IntVar* index, int64_t target); /// Creates the constraint abs(var) == abs_var. - Constraint* MakeAbsEquality(IntVar* const var, IntVar* const abs_var); + Constraint* MakeAbsEquality(IntVar* var, IntVar* abs_var); /// This constraint is a special case of the element constraint with /// an array of integer variables, where the variables are all /// different and the index variable is constrained such that /// vars[index] == target. Constraint* MakeIndexOfConstraint(const std::vector& vars, - IntVar* const index, int64_t target); + IntVar* index, int64_t target); /// This method is a specialized case of the MakeConstraintDemon /// method to call the InitiatePropagate of the constraint 'ct'. - Demon* MakeConstraintInitialPropagateCallback(Constraint* const ct); + Demon* MakeConstraintInitialPropagateCallback(Constraint* ct); /// This method is a specialized case of the MakeConstraintDemon /// method to call the InitiatePropagate of the constraint 'ct' with /// low priority. - Demon* MakeDelayedConstraintInitialPropagateCallback(Constraint* const ct); + Demon* MakeDelayedConstraintInitialPropagateCallback(Constraint* ct); #if !defined(SWIG) /// Creates a demon from a callback. Demon* MakeActionDemon(Action action); @@ -1468,38 +1452,35 @@ class Solver { // ----- Between and related constraints ----- /// (l <= expr <= u) - Constraint* MakeBetweenCt(IntExpr* const expr, int64_t l, int64_t u); + Constraint* MakeBetweenCt(IntExpr* expr, int64_t l, int64_t u); /// (expr < l || expr > u) /// This constraint is lazy as it will not make holes in the domain of /// variables. It will propagate only when expr->Min() >= l /// or expr->Max() <= u. - Constraint* MakeNotBetweenCt(IntExpr* const expr, int64_t l, int64_t u); + Constraint* MakeNotBetweenCt(IntExpr* expr, int64_t l, int64_t u); /// b == (l <= expr <= u) - Constraint* MakeIsBetweenCt(IntExpr* const expr, int64_t l, int64_t u, - IntVar* const b); - IntVar* MakeIsBetweenVar(IntExpr* const v, int64_t l, int64_t u); + Constraint* MakeIsBetweenCt(IntExpr* expr, int64_t l, int64_t u, IntVar* b); + IntVar* MakeIsBetweenVar(IntExpr* v, int64_t l, int64_t u); // ----- Member and related constraints ----- /// expr in set. Propagation is lazy, i.e. this constraint does not /// creates holes in the domain of the variable. - Constraint* MakeMemberCt(IntExpr* const expr, - const std::vector& values); - Constraint* MakeMemberCt(IntExpr* const expr, const std::vector& values); + Constraint* MakeMemberCt(IntExpr* expr, const std::vector& values); + Constraint* MakeMemberCt(IntExpr* expr, const std::vector& values); /// expr not in set. - Constraint* MakeNotMemberCt(IntExpr* const expr, + Constraint* MakeNotMemberCt(IntExpr* expr, const std::vector& values); - Constraint* MakeNotMemberCt(IntExpr* const expr, - const std::vector& values); + Constraint* MakeNotMemberCt(IntExpr* expr, const std::vector& values); /// expr should not be in the list of forbidden intervals [start[i]..end[i]]. - Constraint* MakeNotMemberCt(IntExpr* const expr, std::vector starts, + Constraint* MakeNotMemberCt(IntExpr* expr, std::vector starts, std::vector ends); /// expr should not be in the list of forbidden intervals [start[i]..end[i]]. - Constraint* MakeNotMemberCt(IntExpr* const expr, std::vector starts, + Constraint* MakeNotMemberCt(IntExpr* expr, std::vector starts, std::vector ends); #if !defined(SWIG) /// expr should not be in the list of forbidden intervals. @@ -1508,15 +1489,12 @@ class Solver { #endif // !defined(SWIG) /// boolvar == (expr in set) - Constraint* MakeIsMemberCt(IntExpr* const expr, - const std::vector& values, - IntVar* const boolvar); - Constraint* MakeIsMemberCt(IntExpr* const expr, - const std::vector& values, - IntVar* const boolvar); - IntVar* MakeIsMemberVar(IntExpr* const expr, - const std::vector& values); - IntVar* MakeIsMemberVar(IntExpr* const expr, const std::vector& values); + Constraint* MakeIsMemberCt(IntExpr* expr, const std::vector& values, + IntVar* boolvar); + Constraint* MakeIsMemberCt(IntExpr* expr, const std::vector& values, + IntVar* boolvar); + IntVar* MakeIsMemberVar(IntExpr* expr, const std::vector& values); + IntVar* MakeIsMemberVar(IntExpr* expr, const std::vector& values); /// |{i | vars[i] == value}| <= max_count Constraint* MakeAtMost(std::vector vars, int64_t value, @@ -1526,7 +1504,7 @@ class Solver { int64_t max_count); /// |{i | vars[i] == value}| == max_count Constraint* MakeCount(const std::vector& vars, int64_t value, - IntVar* const max_count); + IntVar* max_count); /// Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] Constraint* MakeDistribute(const std::vector& vars, @@ -1575,7 +1553,7 @@ class Solver { /// sum_i vars[i] == total_sum /// n = #vars Constraint* MakeDeviation(const std::vector& vars, - IntVar* const deviation_var, int64_t total_sum); + IntVar* deviation_var, int64_t total_sum); /// All variables are pairwise different. This corresponds to the /// stronger version of the propagation algorithm. @@ -1800,8 +1778,7 @@ class Solver { /// This constraint maps the domain of 'var' onto the array of /// variables 'actives'. That is /// for all i in [0 .. size - 1]: actives[i] == 1 <=> var->Contains(i); - Constraint* MakeMapDomain(IntVar* const var, - const std::vector& actives); + Constraint* MakeMapDomain(IntVar* var, const std::vector& actives); /// This method creates a constraint where the graph of the relation /// between the variables is given in extension. There are 'arity' @@ -1909,42 +1886,42 @@ class Solver { /// This method fills the vector with 'count' interval variables built with /// the corresponding parameters. - void MakeFixedDurationIntervalVarArray( - int count, int64_t start_min, int64_t start_max, int64_t duration, - bool optional, const std::string& name, - std::vector* const array); + void MakeFixedDurationIntervalVarArray(int count, int64_t start_min, + int64_t start_max, int64_t duration, + bool optional, const std::string& name, + std::vector* array); /// Creates a performed interval var with a fixed duration. The duration must /// be greater than 0. - IntervalVar* MakeFixedDurationIntervalVar(IntVar* const start_variable, + IntervalVar* MakeFixedDurationIntervalVar(IntVar* start_variable, int64_t duration, const std::string& name); /// Creates an interval var with a fixed duration, and performed_variable. /// The duration must be greater than 0. - IntervalVar* MakeFixedDurationIntervalVar(IntVar* const start_variable, + IntervalVar* MakeFixedDurationIntervalVar(IntVar* start_variable, int64_t duration, - IntVar* const performed_variable, + IntVar* performed_variable, const std::string& name); /// This method fills the vector with 'count' interval var built with /// the corresponding start variables. void MakeFixedDurationIntervalVarArray( const std::vector& start_variables, int64_t duration, - const std::string& name, std::vector* const array); + const std::string& name, std::vector* array); /// This method fills the vector with interval variables built with /// the corresponding start variables. void MakeFixedDurationIntervalVarArray( const std::vector& start_variables, const std::vector& durations, const std::string& name, - std::vector* const array); + std::vector* array); /// This method fills the vector with interval variables built with /// the corresponding start variables. void MakeFixedDurationIntervalVarArray( const std::vector& start_variables, const std::vector& durations, const std::string& name, - std::vector* const array); + std::vector* array); /// This method fills the vector with interval variables built with /// the corresponding start and performed variables. @@ -1952,7 +1929,7 @@ class Solver { const std::vector& start_variables, const std::vector& durations, const std::vector& performed_variables, const std::string& name, - std::vector* const array); + std::vector* array); /// This method fills the vector with interval variables built with /// the corresponding start and performed variables. @@ -1960,7 +1937,7 @@ class Solver { const std::vector& start_variables, const std::vector& durations, const std::vector& performed_variables, const std::string& name, - std::vector* const array); + std::vector* array); /// Creates a fixed and performed interval. IntervalVar* MakeFixedInterval(int64_t start, int64_t duration, @@ -1979,39 +1956,39 @@ class Solver { int64_t duration_min, int64_t duration_max, int64_t end_min, int64_t end_max, bool optional, const std::string& name, - std::vector* const array); + std::vector* array); /// Creates an interval var that is the mirror image of the given one, that /// is, the interval var obtained by reversing the axis. - IntervalVar* MakeMirrorInterval(IntervalVar* const interval_var); + IntervalVar* MakeMirrorInterval(IntervalVar* interval_var); /// Creates an interval var with a fixed duration whose start is /// synchronized with the start of another interval, with a given /// offset. The performed status is also in sync with the performed /// status of the given interval variable. IntervalVar* MakeFixedDurationStartSyncedOnStartIntervalVar( - IntervalVar* const interval_var, int64_t duration, int64_t offset); + IntervalVar* interval_var, int64_t duration, int64_t offset); /// Creates an interval var with a fixed duration whose start is /// synchronized with the end of another interval, with a given /// offset. The performed status is also in sync with the performed /// status of the given interval variable. IntervalVar* MakeFixedDurationStartSyncedOnEndIntervalVar( - IntervalVar* const interval_var, int64_t duration, int64_t offset); + IntervalVar* interval_var, int64_t duration, int64_t offset); /// Creates an interval var with a fixed duration whose end is /// synchronized with the start of another interval, with a given /// offset. The performed status is also in sync with the performed /// status of the given interval variable. IntervalVar* MakeFixedDurationEndSyncedOnStartIntervalVar( - IntervalVar* const interval_var, int64_t duration, int64_t offset); + IntervalVar* interval_var, int64_t duration, int64_t offset); /// Creates an interval var with a fixed duration whose end is /// synchronized with the end of another interval, with a given /// offset. The performed status is also in sync with the performed /// status of the given interval variable. IntervalVar* MakeFixedDurationEndSyncedOnEndIntervalVar( - IntervalVar* const interval_var, int64_t duration, int64_t offset); + IntervalVar* interval_var, int64_t duration, int64_t offset); /// Creates and returns an interval variable that wraps around the given one, /// relaxing the min start and end. Relaxing means making unbounded when @@ -2030,7 +2007,7 @@ class Solver { /// /// This is very useful to implement propagators that may only modify /// the start max or end max. - IntervalVar* MakeIntervalRelaxedMin(IntervalVar* const interval_var); + IntervalVar* MakeIntervalRelaxedMin(IntervalVar* interval_var); /// Creates and returns an interval variable that wraps around the given one, /// relaxing the max start and end. Relaxing means making unbounded when @@ -2049,37 +2026,34 @@ class Solver { /// /// This is very useful for implementing propagators that may only modify /// the start min or end min. - IntervalVar* MakeIntervalRelaxedMax(IntervalVar* const interval_var); + IntervalVar* MakeIntervalRelaxedMax(IntervalVar* interval_var); /// This method creates a relation between an interval var and a /// date. - Constraint* MakeIntervalVarRelation(IntervalVar* const t, - UnaryIntervalRelation r, int64_t d); + Constraint* MakeIntervalVarRelation(IntervalVar* t, UnaryIntervalRelation r, + int64_t d); /// This method creates a relation between two interval vars. - Constraint* MakeIntervalVarRelation(IntervalVar* const t1, - BinaryIntervalRelation r, - IntervalVar* const t2); + Constraint* MakeIntervalVarRelation(IntervalVar* t1, BinaryIntervalRelation r, + IntervalVar* t2); /// This method creates a relation between two interval vars. /// The given delay is added to the second interval. /// i.e.: t1 STARTS_AFTER_END of t2 with a delay of 2 /// means t1 will start at least two units of time after the end of t2. - Constraint* MakeIntervalVarRelationWithDelay(IntervalVar* const t1, + Constraint* MakeIntervalVarRelationWithDelay(IntervalVar* t1, BinaryIntervalRelation r, - IntervalVar* const t2, - int64_t delay); + IntervalVar* t2, int64_t delay); /// This constraint implements a temporal disjunction between two /// interval vars t1 and t2. 'alt' indicates which alternative was /// chosen (alt == 0 is equivalent to t1 before t2). - Constraint* MakeTemporalDisjunction(IntervalVar* const t1, - IntervalVar* const t2, IntVar* const alt); + Constraint* MakeTemporalDisjunction(IntervalVar* t1, IntervalVar* t2, + IntVar* alt); /// This constraint implements a temporal disjunction between two /// interval vars. - Constraint* MakeTemporalDisjunction(IntervalVar* const t1, - IntervalVar* const t2); + Constraint* MakeTemporalDisjunction(IntervalVar* t1, IntervalVar* t2); /// This constraint forces all interval vars into an non-overlapping /// sequence. Intervals with zero duration can be scheduled anywhere. @@ -2129,7 +2103,7 @@ class Solver { /// neither impact nor are impacted by this constraint. Constraint* MakeCumulative(const std::vector& intervals, const std::vector& demands, - IntVar* const capacity, const std::string& name); + IntVar* capacity, const std::string& name); /// This constraint enforces that, for any integer t, the sum of the demands /// corresponding to an interval containing t does not exceed the given @@ -2141,8 +2115,8 @@ class Solver { /// supported, and the corresponding intervals are filtered out, as they /// neither impact nor are impacted by this constraint. Constraint* MakeCumulative(const std::vector& intervals, - const std::vector& demands, - IntVar* const capacity, const std::string& name); + const std::vector& demands, IntVar* capacity, + const std::string& name); /// This constraint enforces that, for any integer t, the sum of demands /// corresponding to an interval containing t does not exceed the given @@ -2164,7 +2138,7 @@ class Solver { /// Demands should be positive. Constraint* MakeCumulative(const std::vector& intervals, const std::vector& demands, - IntVar* const capacity, const std::string& name); + IntVar* capacity, const std::string& name); /// This constraint states that the target_var is the convex hull of /// the intervals. If none of the interval variables is performed, @@ -2172,27 +2146,25 @@ class Solver { /// variable is unperformed, then all the intervals variables are /// unperformed too. Constraint* MakeCover(const std::vector& vars, - IntervalVar* const target_var); + IntervalVar* target_var); /// This constraints states that the two interval variables are equal. - Constraint* MakeEquality(IntervalVar* const var1, IntervalVar* const var2); + Constraint* MakeEquality(IntervalVar* var1, IntervalVar* var2); /// This method creates an empty assignment. Assignment* MakeAssignment(); /// This method creates an assignment which is a copy of 'a'. - Assignment* MakeAssignment(const Assignment* const a); + Assignment* MakeAssignment(const Assignment* a); /// Collect the first solution of the search. - SolutionCollector* MakeFirstSolutionCollector( - const Assignment* const assignment); + SolutionCollector* MakeFirstSolutionCollector(const Assignment* assignment); /// Collect the first solution of the search. The variables will need to /// be added later. SolutionCollector* MakeFirstSolutionCollector(); /// Collect the last solution of the search. - SolutionCollector* MakeLastSolutionCollector( - const Assignment* const assignment); + SolutionCollector* MakeLastSolutionCollector(const Assignment* assignment); /// Collect the last solution of the search. The variables will need to /// be added later. SolutionCollector* MakeLastSolutionCollector(); @@ -2234,20 +2206,19 @@ class Solver { int solution_count, std::vector maximize); /// Collect all solutions of the search. - SolutionCollector* MakeAllSolutionCollector( - const Assignment* const assignment); + SolutionCollector* MakeAllSolutionCollector(const Assignment* assignment); /// Collect all solutions of the search. The variables will need to /// be added later. SolutionCollector* MakeAllSolutionCollector(); /// Creates a minimization objective. - OptimizeVar* MakeMinimize(IntVar* const v, int64_t step); + OptimizeVar* MakeMinimize(IntVar* v, int64_t step); /// Creates a maximization objective. - OptimizeVar* MakeMaximize(IntVar* const v, int64_t step); + OptimizeVar* MakeMaximize(IntVar* v, int64_t step); /// Creates a objective with a given sense (true = maximization). - OptimizeVar* MakeOptimize(bool maximize, IntVar* const v, int64_t step); + OptimizeVar* MakeOptimize(bool maximize, IntVar* v, int64_t step); /// Creates a minimization weighted objective. The actual objective is /// scalar_prod(sub_objectives, weights). @@ -2407,8 +2378,8 @@ class Solver { /// Creates a search limit that is reached when either of the underlying limit /// is reached. That is, the returned limit is more stringent than both /// argument limits. - ABSL_MUST_USE_RESULT SearchLimit* MakeLimit(SearchLimit* const limit_1, - SearchLimit* const limit_2); + ABSL_MUST_USE_RESULT SearchLimit* MakeLimit(SearchLimit* limit_1, + SearchLimit* limit_2); /// Limits the search based on the improvements of 'objective_var'. Stops the /// search when the improvement rate gets lower than a threshold value. This @@ -2440,7 +2411,7 @@ class Solver { SearchMonitor* MakeSearchLog(int branch_period); /// At each solution, this monitor also display the var value. - SearchMonitor* MakeSearchLog(int branch_period, IntVar* const var); + SearchMonitor* MakeSearchLog(int branch_period, IntVar* var); /// At each solution, this monitor will also display result of @p /// display_callback. @@ -2454,11 +2425,11 @@ class Solver { /// OptimizeVar Search Logs /// At each solution, this monitor will also display the 'opt_var' value. - SearchMonitor* MakeSearchLog(int branch_period, OptimizeVar* const opt_var); + SearchMonitor* MakeSearchLog(int branch_period, OptimizeVar* opt_var); /// Creates a search monitor that will also print the result of the /// display callback. - SearchMonitor* MakeSearchLog(int branch_period, OptimizeVar* const opt_var, + SearchMonitor* MakeSearchLog(int branch_period, OptimizeVar* opt_var, std::function display_callback); /// Creates a search monitor from logging parameters. @@ -2501,32 +2472,27 @@ class Solver { #if !defined(SWIG) /// Compute the number of constraints a variable is attached to. ModelVisitor* MakeVariableDegreeVisitor( - absl::flat_hash_map* const map); + absl::flat_hash_map* map); #endif // !defined(SWIG) /// Symmetry Breaking. SearchMonitor* MakeSymmetryManager( const std::vector& visitors); - SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1); - SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1, - SymmetryBreaker* const v2); - SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1, - SymmetryBreaker* const v2, - SymmetryBreaker* const v3); - SearchMonitor* MakeSymmetryManager(SymmetryBreaker* const v1, - SymmetryBreaker* const v2, - SymmetryBreaker* const v3, - SymmetryBreaker* const v4); + SearchMonitor* MakeSymmetryManager(SymmetryBreaker* v1); + SearchMonitor* MakeSymmetryManager(SymmetryBreaker* v1, SymmetryBreaker* v2); + SearchMonitor* MakeSymmetryManager(SymmetryBreaker* v1, SymmetryBreaker* v2, + SymmetryBreaker* v3); + SearchMonitor* MakeSymmetryManager(SymmetryBreaker* v1, SymmetryBreaker* v2, + SymmetryBreaker* v3, SymmetryBreaker* v4); /// Decisions. - Decision* MakeAssignVariableValue(IntVar* const var, int64_t val); - Decision* MakeVariableLessOrEqualValue(IntVar* const var, int64_t value); - Decision* MakeVariableGreaterOrEqualValue(IntVar* const var, int64_t value); - Decision* MakeSplitVariableDomain(IntVar* const var, int64_t val, + Decision* MakeAssignVariableValue(IntVar* var, int64_t val); + Decision* MakeVariableLessOrEqualValue(IntVar* var, int64_t value); + Decision* MakeVariableGreaterOrEqualValue(IntVar* var, int64_t value); + Decision* MakeSplitVariableDomain(IntVar* var, int64_t val, bool start_with_lower_half); - Decision* MakeAssignVariableValueOrFail(IntVar* const var, int64_t value); - Decision* MakeAssignVariableValueOrDoNothing(IntVar* const var, - int64_t value); + Decision* MakeAssignVariableValueOrFail(IntVar* var, int64_t value); + Decision* MakeAssignVariableValueOrDoNothing(IntVar* var, int64_t value); Decision* MakeAssignVariablesValues(const std::vector& vars, const std::vector& values); Decision* MakeAssignVariablesValuesOrDoNothing( @@ -2544,15 +2510,11 @@ class Solver { /// db1 leaves | /// / | \ | /// db2 tree db2 tree db2 tree | - DecisionBuilder* Compose(DecisionBuilder* const db1, - DecisionBuilder* const db2); - DecisionBuilder* Compose(DecisionBuilder* const db1, - DecisionBuilder* const db2, - DecisionBuilder* const db3); - DecisionBuilder* Compose(DecisionBuilder* const db1, - DecisionBuilder* const db2, - DecisionBuilder* const db3, - DecisionBuilder* const db4); + DecisionBuilder* Compose(DecisionBuilder* db1, DecisionBuilder* db2); + DecisionBuilder* Compose(DecisionBuilder* db1, DecisionBuilder* db2, + DecisionBuilder* db3); + DecisionBuilder* Compose(DecisionBuilder* db1, DecisionBuilder* db2, + DecisionBuilder* db3, DecisionBuilder* db4); DecisionBuilder* Compose(const std::vector& dbs); /// Creates a decision builder which will create a search tree where each @@ -2571,11 +2533,11 @@ class Solver { /// unbalanced to the right, whereas Try(Try(a,b), Try(b,c)) will give a /// balanced tree. Investigate if we should only provide the binary version /// and/or if we should balance automatically. - DecisionBuilder* Try(DecisionBuilder* const db1, DecisionBuilder* const db2); - DecisionBuilder* Try(DecisionBuilder* const db1, DecisionBuilder* const db2, - DecisionBuilder* const db3); - DecisionBuilder* Try(DecisionBuilder* const db1, DecisionBuilder* const db2, - DecisionBuilder* const db3, DecisionBuilder* const db4); + DecisionBuilder* Try(DecisionBuilder* db1, DecisionBuilder* db2); + DecisionBuilder* Try(DecisionBuilder* db1, DecisionBuilder* db2, + DecisionBuilder* db3); + DecisionBuilder* Try(DecisionBuilder* db1, DecisionBuilder* db2, + DecisionBuilder* db3, DecisionBuilder* db4); DecisionBuilder* Try(const std::vector& dbs); /// Phases on IntVar arrays. @@ -2616,15 +2578,13 @@ class Solver { const DefaultPhaseParameters& parameters); /// Shortcuts for small arrays. - DecisionBuilder* MakePhase(IntVar* const v0, IntVarStrategy var_str, + DecisionBuilder* MakePhase(IntVar* v0, IntVarStrategy var_str, IntValueStrategy val_str); - DecisionBuilder* MakePhase(IntVar* const v0, IntVar* const v1, + DecisionBuilder* MakePhase(IntVar* v0, IntVar* v1, IntVarStrategy var_str, + IntValueStrategy val_str); + DecisionBuilder* MakePhase(IntVar* v0, IntVar* v1, IntVar* v2, IntVarStrategy var_str, IntValueStrategy val_str); - DecisionBuilder* MakePhase(IntVar* const v0, IntVar* const v1, - IntVar* const v2, IntVarStrategy var_str, - IntValueStrategy val_str); - DecisionBuilder* MakePhase(IntVar* const v0, IntVar* const v1, - IntVar* const v2, IntVar* const v3, + DecisionBuilder* MakePhase(IntVar* v0, IntVar* v1, IntVar* v2, IntVar* v3, IntVarStrategy var_str, IntValueStrategy val_str); /// Returns a decision that tries to schedule a task at a given time. @@ -2632,24 +2592,24 @@ class Solver { /// its start to 'est'. On the Refute branch, it will just update the /// 'marker' to 'est' + 1. This decision is used in the /// INTERVAL_SET_TIMES_FORWARD strategy. - Decision* MakeScheduleOrPostpone(IntervalVar* const var, int64_t est, - int64_t* const marker); + Decision* MakeScheduleOrPostpone(IntervalVar* var, int64_t est, + int64_t* marker); /// Returns a decision that tries to schedule a task at a given time. /// On the Apply branch, it will set that interval var as performed and set /// its end to 'est'. On the Refute branch, it will just update the /// 'marker' to 'est' - 1. This decision is used in the /// INTERVAL_SET_TIMES_BACKWARD strategy. - Decision* MakeScheduleOrExpedite(IntervalVar* const var, int64_t est, - int64_t* const marker); + Decision* MakeScheduleOrExpedite(IntervalVar* var, int64_t est, + int64_t* marker); /// Returns a decision that tries to rank first the ith interval var /// in the sequence variable. - Decision* MakeRankFirstInterval(SequenceVar* const sequence, int index); + Decision* MakeRankFirstInterval(SequenceVar* sequence, int index); /// Returns a decision that tries to rank last the ith interval var /// in the sequence variable. - Decision* MakeRankLastInterval(SequenceVar* const sequence, int index); + Decision* MakeRankLastInterval(SequenceVar* sequence, int index); /// Returns a decision builder which assigns values to variables which /// minimize the values returned by the evaluator. The arguments passed to the @@ -2680,33 +2640,29 @@ class Solver { /// Returns a decision builder for which the left-most leaf corresponds /// to assignment, the rest of the tree being explored using 'db'. DecisionBuilder* MakeDecisionBuilderFromAssignment( - Assignment* const assignment, DecisionBuilder* const db, + Assignment* assignment, DecisionBuilder* db, const std::vector& vars); /// Returns a decision builder that will add the given constraint to /// the model. - DecisionBuilder* MakeConstraintAdder(Constraint* const ct); + DecisionBuilder* MakeConstraintAdder(Constraint* ct); /// SolveOnce will collapse a search tree described by a decision /// builder 'db' and a set of monitors and wrap it into a single point. /// If there are no solutions to this nested tree, then SolveOnce will /// fail. If there is a solution, it will find it and returns nullptr. - DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db); - DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db, - SearchMonitor* const monitor1); - DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db, - SearchMonitor* const monitor1, - SearchMonitor* const monitor2); - DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db, - SearchMonitor* const monitor1, - SearchMonitor* const monitor2, - SearchMonitor* const monitor3); - DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db, - SearchMonitor* const monitor1, - SearchMonitor* const monitor2, - SearchMonitor* const monitor3, - SearchMonitor* const monitor4); - DecisionBuilder* MakeSolveOnce(DecisionBuilder* const db, + DecisionBuilder* MakeSolveOnce(DecisionBuilder* db); + DecisionBuilder* MakeSolveOnce(DecisionBuilder* db, SearchMonitor* monitor1); + DecisionBuilder* MakeSolveOnce(DecisionBuilder* db, SearchMonitor* monitor1, + SearchMonitor* monitor2); + DecisionBuilder* MakeSolveOnce(DecisionBuilder* db, SearchMonitor* monitor1, + SearchMonitor* monitor2, + SearchMonitor* monitor3); + DecisionBuilder* MakeSolveOnce(DecisionBuilder* db, SearchMonitor* monitor1, + SearchMonitor* monitor2, + SearchMonitor* monitor3, + SearchMonitor* monitor4); + DecisionBuilder* MakeSolveOnce(DecisionBuilder* db, const std::vector& monitors); /// NestedOptimize will collapse a search tree described by a @@ -2716,34 +2672,29 @@ class Solver { /// the best as described by the mandatory objective in the solution /// as well as the optimization direction, instantiate all variables /// to this solution, and return nullptr. - DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db, - Assignment* const solution, bool maximize, - int64_t step); - DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db, - Assignment* const solution, bool maximize, - int64_t step, - SearchMonitor* const monitor1); - DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db, - Assignment* const solution, bool maximize, - int64_t step, - SearchMonitor* const monitor1, - SearchMonitor* const monitor2); - DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db, - Assignment* const solution, bool maximize, - int64_t step, - SearchMonitor* const monitor1, - SearchMonitor* const monitor2, - SearchMonitor* const monitor3); - DecisionBuilder* MakeNestedOptimize(DecisionBuilder* const db, - Assignment* const solution, bool maximize, - int64_t step, - SearchMonitor* const monitor1, - SearchMonitor* const monitor2, - SearchMonitor* const monitor3, - SearchMonitor* const monitor4); + DecisionBuilder* MakeNestedOptimize(DecisionBuilder* db, Assignment* solution, + bool maximize, int64_t step); + DecisionBuilder* MakeNestedOptimize(DecisionBuilder* db, Assignment* solution, + bool maximize, int64_t step, + SearchMonitor* monitor1); + DecisionBuilder* MakeNestedOptimize(DecisionBuilder* db, Assignment* solution, + bool maximize, int64_t step, + SearchMonitor* monitor1, + SearchMonitor* monitor2); + DecisionBuilder* MakeNestedOptimize(DecisionBuilder* db, Assignment* solution, + bool maximize, int64_t step, + SearchMonitor* monitor1, + SearchMonitor* monitor2, + SearchMonitor* monitor3); + DecisionBuilder* MakeNestedOptimize(DecisionBuilder* db, Assignment* solution, + bool maximize, int64_t step, + SearchMonitor* monitor1, + SearchMonitor* monitor2, + SearchMonitor* monitor3, + SearchMonitor* monitor4); DecisionBuilder* MakeNestedOptimize( - DecisionBuilder* const db, Assignment* const solution, bool maximize, - int64_t step, const std::vector& monitors); + DecisionBuilder* db, Assignment* solution, bool maximize, int64_t step, + const std::vector& monitors); /// Returns a DecisionBuilder which restores an Assignment /// (calls void Assignment::Restore()) @@ -2865,7 +2816,7 @@ class Solver { /// to MakeNextNeighbor from the current solution (between two calls /// to Start()). When this limit is reached, MakeNextNeighbor() /// returns false. The counter is cleared when Start() is called. - LocalSearchOperator* MakeNeighborhoodLimit(LocalSearchOperator* const op, + LocalSearchOperator* MakeNeighborhoodLimit(LocalSearchOperator* op, int64_t limit); /// Local Search decision builders factories. @@ -2895,49 +2846,44 @@ class Solver { // TODO(user): Make a variant which runs a local search after each // solution found in a DFS. - DecisionBuilder* MakeLocalSearchPhase( - Assignment* const assignment, - LocalSearchPhaseParameters* const parameters); - DecisionBuilder* MakeLocalSearchPhase( - const std::vector& vars, DecisionBuilder* const first_solution, - LocalSearchPhaseParameters* const parameters); + DecisionBuilder* MakeLocalSearchPhase(Assignment* assignment, + LocalSearchPhaseParameters* parameters); + DecisionBuilder* MakeLocalSearchPhase(const std::vector& vars, + DecisionBuilder* first_solution, + LocalSearchPhaseParameters* parameters); /// Variant with a sub_decison_builder specific to the first solution. DecisionBuilder* MakeLocalSearchPhase( - const std::vector& vars, DecisionBuilder* const first_solution, - DecisionBuilder* const first_solution_sub_decision_builder, - LocalSearchPhaseParameters* const parameters); - DecisionBuilder* MakeLocalSearchPhase( - const std::vector& vars, - DecisionBuilder* const first_solution, - LocalSearchPhaseParameters* const parameters); + const std::vector& vars, DecisionBuilder* first_solution, + DecisionBuilder* first_solution_sub_decision_builder, + LocalSearchPhaseParameters* parameters); + DecisionBuilder* MakeLocalSearchPhase(const std::vector& vars, + DecisionBuilder* first_solution, + LocalSearchPhaseParameters* parameters); /// Solution Pool. SolutionPool* MakeDefaultSolutionPool(); /// Local Search Phase Parameters LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters( - IntVar* objective, LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder); + IntVar* objective, LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder); LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters( - IntVar* objective, LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, RegularLimit* const limit); + IntVar* objective, LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit); LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters( - IntVar* objective, LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, RegularLimit* const limit, + IntVar* objective, LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit, LocalSearchFilterManager* filter_manager); LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters( - IntVar* objective, SolutionPool* const pool, - LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder); + IntVar* objective, SolutionPool* pool, LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder); LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters( - IntVar* objective, SolutionPool* const pool, - LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, RegularLimit* const limit); + IntVar* objective, SolutionPool* pool, LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit); LocalSearchPhaseParameters* MakeLocalSearchPhaseParameters( - IntVar* objective, SolutionPool* const pool, - LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, RegularLimit* const limit, + IntVar* objective, SolutionPool* pool, LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit, LocalSearchFilterManager* filter_manager); /// Local Search Filters @@ -3043,7 +2989,7 @@ class Solver { int constraints() const { return constraints_list_.size(); } /// Accepts the given model visitor. - void Accept(ModelVisitor* const visitor) const; + void Accept(ModelVisitor* visitor) const; Decision* balancing_decision() const { return balancing_decision_.get(); } @@ -3067,14 +3013,14 @@ class Solver { /// Returns whether the object has been named or not. bool HasName(const PropagationBaseObject* object) const; /// Adds a new demon and wraps it inside a DemonProfiler if necessary. - Demon* RegisterDemon(Demon* const demon); + Demon* RegisterDemon(Demon* demon); /// Registers a new IntExpr and wraps it inside a TraceIntExpr if necessary. - IntExpr* RegisterIntExpr(IntExpr* const expr); + IntExpr* RegisterIntExpr(IntExpr* expr); /// Registers a new IntVar and wraps it inside a TraceIntVar if necessary. - IntVar* RegisterIntVar(IntVar* const var); + IntVar* RegisterIntVar(IntVar* var); /// Registers a new IntervalVar and wraps it inside a TraceIntervalVar /// if necessary. - IntervalVar* RegisterIntervalVar(IntervalVar* const var); + IntervalVar* RegisterIntervalVar(IntervalVar* var); /// Returns the active search, nullptr outside search. Search* ActiveSearch() const; @@ -3096,7 +3042,7 @@ class Solver { PropagationMonitor* GetPropagationMonitor() const; /// Adds the propagation monitor to the solver. This is called internally when /// a propagation monitor is passed to the Solve() or NewSearch() method. - void AddPropagationMonitor(PropagationMonitor* const monitor); + void AddPropagationMonitor(PropagationMonitor* monitor); /// Returns the local search monitor. LocalSearchMonitor* GetLocalSearchMonitor() const; /// Adds the local search monitor to the solver. This is called internally @@ -3130,7 +3076,7 @@ class Solver { friend class LocalSearchProfiler; #if !defined(SWIG) - friend void InternalSaveBooleanVarValue(Solver* const, IntVar* const); + friend void InternalSaveBooleanVarValue(Solver*, IntVar*); template friend class SimpleRevFIFO; template @@ -3140,20 +3086,18 @@ class Solver { /// boolean_var. In that case, it fills inner_var and is_negated to be /// true if the expression is 1 - boolean_var -- equivalent to /// not(boolean_var). - bool IsBooleanVar(IntExpr* const expr, IntVar** inner_var, - bool* is_negated) const; + bool IsBooleanVar(IntExpr* expr, IntVar** inner_var, bool* is_negated) const; /// Returns true if expr represents a product of a expr and a /// constant. In that case, it fills inner_expr and coefficient with /// these, and returns true. In the other case, it fills inner_expr /// with expr, coefficient with 1, and returns false. - bool IsProduct(IntExpr* const expr, IntExpr** inner_expr, - int64_t* coefficient); + bool IsProduct(IntExpr* expr, IntExpr** inner_expr, int64_t* coefficient); #endif /// !defined(SWIG) /// Internal. If the variables is the result of expr->Var(), this /// method returns expr, nullptr otherwise. - IntExpr* CastExpression(const IntVar* const var) const; + IntExpr* CastExpression(const IntVar* var) const; /// Tells the solver to kill or restart the current search. void FinishCurrentSearch(); @@ -3183,8 +3127,8 @@ class Solver { void JumpToSentinel(); void check_alloc_state(); void FreezeQueue(); - void EnqueueVar(Demon* const d); - void EnqueueDelayedDemon(Demon* const d); + void EnqueueVar(Demon* d); + void EnqueueDelayedDemon(Demon* d); void ExecuteAll(const SimpleRevFIFO& demons); void EnqueueAll(const SimpleRevFIFO& demons); void UnfreezeQueue(); @@ -3254,8 +3198,7 @@ class Solver { int GetNewIntVarIndex() { return num_int_vars_++; } /// Internal. - bool IsADifference(IntExpr* expr, IntExpr** const left, - IntExpr** const right); + bool IsADifference(IntExpr* expr, IntExpr** left, IntExpr** right); const std::string name_; const ConstraintSolverParameters parameters_; @@ -3350,7 +3293,7 @@ std::ostream& operator<<(std::ostream& out, const BaseObject* o); /// NOLINT class PropagationBaseObject : public BaseObject { public: explicit PropagationBaseObject(Solver* const s) : solver_(s) {} - ~PropagationBaseObject() override {} + ~PropagationBaseObject() override{}; std::string DebugString() const override { if (name().empty()) { @@ -3414,14 +3357,14 @@ class Decision : public BaseObject { ~Decision() override {} /// Apply will be called first when the decision is executed. - virtual void Apply(Solver* const s) = 0; + virtual void Apply(Solver* s) = 0; /// Refute will be called after a backtrack. - virtual void Refute(Solver* const s) = 0; + virtual void Refute(Solver* s) = 0; std::string DebugString() const override { return "Decision"; } /// Accepts the given visitor. - virtual void Accept(DecisionVisitor* const visitor) const; + virtual void Accept(DecisionVisitor* visitor) const; private: DISALLOW_COPY_AND_ASSIGN(Decision); @@ -3433,13 +3376,13 @@ class DecisionVisitor : public BaseObject { public: DecisionVisitor() {} ~DecisionVisitor() override {} - virtual void VisitSetVariableValue(IntVar* const var, int64_t value); - virtual void VisitSplitVariableDomain(IntVar* const var, int64_t value, + virtual void VisitSetVariableValue(IntVar* var, int64_t value); + virtual void VisitSplitVariableDomain(IntVar* var, int64_t value, bool start_with_lower_half); - virtual void VisitScheduleOrPostpone(IntervalVar* const var, int64_t est); - virtual void VisitScheduleOrExpedite(IntervalVar* const var, int64_t est); - virtual void VisitRankFirstInterval(SequenceVar* const sequence, int index); - virtual void VisitRankLastInterval(SequenceVar* const sequence, int index); + virtual void VisitScheduleOrPostpone(IntervalVar* var, int64_t est); + virtual void VisitScheduleOrExpedite(IntervalVar* var, int64_t est); + virtual void VisitRankFirstInterval(SequenceVar* sequence, int index); + virtual void VisitRankLastInterval(SequenceVar* sequence, int index); virtual void VisitUnknownDecision(); private: @@ -3456,16 +3399,16 @@ class DecisionBuilder : public BaseObject { /// return a decision (an instance of the class Decision). If it /// returns nullptr, this means that the decision builder has finished /// its work. - virtual Decision* Next(Solver* const s) = 0; + virtual Decision* Next(Solver* s) = 0; std::string DebugString() const override; #if !defined(SWIG) /// This method will be called at the start of the search. It asks /// the decision builder if it wants to append search monitors to the /// list of active monitors for this search. Please note there are no /// checks at this point for duplication. - virtual void AppendMonitors(Solver* const solver, - std::vector* const extras); - virtual void Accept(ModelVisitor* const visitor) const; + virtual void AppendMonitors(Solver* solver, + std::vector* extras); + virtual void Accept(ModelVisitor* visitor) const; #endif void set_name(const std::string& name) { name_ = name; } std::string GetName() const; @@ -3482,11 +3425,11 @@ class ProfiledDecisionBuilder : public DecisionBuilder { ~ProfiledDecisionBuilder() override {} const std::string& name() const { return name_; } double seconds() const { return seconds_; } - Decision* Next(Solver* const solver) override; + Decision* Next(Solver* solver) override; std::string DebugString() const override; - void AppendMonitors(Solver* const solver, - std::vector* const extras) override; - void Accept(ModelVisitor* const visitor) const override; + void AppendMonitors(Solver* solver, + std::vector* extras) override; + void Accept(ModelVisitor* visitor) const override; private: DecisionBuilder* const db_; @@ -3513,7 +3456,7 @@ class Demon : public BaseObject { ~Demon() override {} /// This is the main callback of the demon. - virtual void Run(Solver* const s) = 0; + virtual void Run(Solver* s) = 0; /// This method returns the priority of the demon. Usually a demon is /// fast, slow or normal. Immediate demons are reserved for internal @@ -3524,10 +3467,10 @@ class Demon : public BaseObject { /// This method inhibits the demon in the search tree below the /// current position. - void inhibit(Solver* const s); + void inhibit(Solver* s); /// This method un-inhibits the demon that was previously inhibited. - void desinhibit(Solver* const s); + void desinhibit(Solver* s); private: friend class Queue; @@ -3721,25 +3664,23 @@ class ModelVisitor : public BaseObject { virtual void BeginVisitModel(const std::string& type_name); virtual void EndVisitModel(const std::string& type_name); virtual void BeginVisitConstraint(const std::string& type_name, - const Constraint* const constraint); + const Constraint* constraint); virtual void EndVisitConstraint(const std::string& type_name, - const Constraint* const constraint); + const Constraint* constraint); virtual void BeginVisitExtension(const std::string& type); virtual void EndVisitExtension(const std::string& type); virtual void BeginVisitIntegerExpression(const std::string& type_name, - const IntExpr* const expr); + const IntExpr* expr); virtual void EndVisitIntegerExpression(const std::string& type_name, - const IntExpr* const expr); - virtual void VisitIntegerVariable(const IntVar* const variable, - IntExpr* const delegate); - virtual void VisitIntegerVariable(const IntVar* const variable, + const IntExpr* expr); + virtual void VisitIntegerVariable(const IntVar* variable, IntExpr* delegate); + virtual void VisitIntegerVariable(const IntVar* variable, const std::string& operation, int64_t value, - IntVar* const delegate); - virtual void VisitIntervalVariable(const IntervalVar* const variable, + IntVar* delegate); + virtual void VisitIntervalVariable(const IntervalVar* variable, const std::string& operation, - int64_t value, - IntervalVar* const delegate); - virtual void VisitSequenceVariable(const SequenceVar* const variable); + int64_t value, IntervalVar* delegate); + virtual void VisitSequenceVariable(const SequenceVar* variable); /// Visit integer arguments. virtual void VisitIntegerArgument(const std::string& arg_name, int64_t value); @@ -3750,20 +3691,20 @@ class ModelVisitor : public BaseObject { /// Visit integer expression argument. virtual void VisitIntegerExpressionArgument(const std::string& arg_name, - IntExpr* const argument); + IntExpr* argument); virtual void VisitIntegerVariableArrayArgument( const std::string& arg_name, const std::vector& arguments); /// Visit interval argument. virtual void VisitIntervalArgument(const std::string& arg_name, - IntervalVar* const argument); + IntervalVar* argument); virtual void VisitIntervalArrayArgument( const std::string& arg_name, const std::vector& arguments); /// Visit sequence argument. virtual void VisitSequenceArgument(const std::string& arg_name, - SequenceVar* const argument); + SequenceVar* argument); virtual void VisitSequenceArrayArgument( const std::string& arg_name, const std::vector& arguments); @@ -3809,7 +3750,7 @@ class Constraint : public PropagationBaseObject { void PostAndPropagate(); /// Accepts the given visitor. - virtual void Accept(ModelVisitor* const visitor) const; + virtual void Accept(ModelVisitor* visitor) const; /// Is the constraint created by a cast from expression to integer variable? bool IsCastConstraint() const; @@ -3857,20 +3798,20 @@ class SearchMonitor : public BaseObject { virtual void ExitSearch(); /// Before calling DecisionBuilder::Next. - virtual void BeginNextDecision(DecisionBuilder* const b); + virtual void BeginNextDecision(DecisionBuilder* b); /// After calling DecisionBuilder::Next, along with the returned decision. - virtual void EndNextDecision(DecisionBuilder* const b, Decision* const d); + virtual void EndNextDecision(DecisionBuilder* b, Decision* d); /// Before applying the decision. - virtual void ApplyDecision(Decision* const d); + virtual void ApplyDecision(Decision* d); /// Before refuting the decision. - virtual void RefuteDecision(Decision* const d); + virtual void RefuteDecision(Decision* d); /// Just after refuting or applying the decision, apply is true after Apply. /// This is called only if the Apply() or Refute() methods have not failed. - virtual void AfterDecision(Decision* const d, bool apply); + virtual void AfterDecision(Decision* d, bool apply); /// Just when the failure occurs. virtual void BeginFail(); @@ -3922,7 +3863,7 @@ class SearchMonitor : public BaseObject { virtual int ProgressPercent() { return kNoProgress; } /// Accepts the given model visitor. - virtual void Accept(ModelVisitor* const visitor) const; + virtual void Accept(ModelVisitor* visitor) const; /// Registers itself on the solver such that it gets notified of the search /// and propagation events. Override to incrementally install listeners for @@ -4101,7 +4042,7 @@ class IntExpr : public PropagationBaseObject { #endif // SWIG /// Accepts the given visitor. - virtual void Accept(ModelVisitor* const visitor) const; + virtual void Accept(ModelVisitor* visitor) const; private: DISALLOW_COPY_AND_ASSIGN(IntExpr); @@ -4210,9 +4151,9 @@ class InitAndGetValues { /// and a finer model for events. class IntVar : public IntExpr { public: - explicit IntVar(Solver* const s); - IntVar(Solver* const s, const std::string& name); - ~IntVar() override {} + explicit IntVar(Solver* s); + IntVar(Solver* s, const std::string& name); + ~IntVar() override{}; bool IsVar() const override { return true; } IntVar* Var() override { return this; } @@ -4293,7 +4234,7 @@ class IntVar : public IntExpr { virtual int VarType() const; /// Accepts the given visitor. - void Accept(ModelVisitor* const visitor) const override; + void Accept(ModelVisitor* visitor) const override; /// IsEqual virtual IntVar* IsEqual(int64_t constant) = 0; @@ -4418,8 +4359,8 @@ class ObjectiveMonitor : public SearchMonitor { public: ObjectiveMonitor(Solver* solver, const std::vector& maximize, std::vector vars, std::vector steps); + ~ObjectiveMonitor() override {} #ifndef SWIG - ~ObjectiveMonitor() override = default; ObjectiveMonitor(const ObjectiveMonitor&) = delete; ObjectiveMonitor& operator=(const ObjectiveMonitor&) = delete; #endif // SWIG @@ -4504,7 +4445,7 @@ class OptimizeVar : public ObjectiveMonitor { OptimizeVar(Solver* solver, const std::vector& maximize, std::vector vars, std::vector steps); #ifndef SWIG - ~OptimizeVar() override = default; + ~OptimizeVar() override {} #endif // SIWG /// Returns the best value found during search. @@ -4548,16 +4489,16 @@ class SearchLimit : public SearchMonitor { /// Copy a limit. Warning: leads to a direct (no check) downcasting of 'limit' /// so one needs to be sure both SearchLimits are of the same type. - virtual void Copy(const SearchLimit* const limit) = 0; + virtual void Copy(const SearchLimit* limit) = 0; /// Allocates a clone of the limit. virtual SearchLimit* MakeClone() const = 0; /// Internal methods. void EnterSearch() override; - void BeginNextDecision(DecisionBuilder* const b) override; + void BeginNextDecision(DecisionBuilder* b) override; void PeriodicCheck() override; - void RefuteDecision(Decision* const d) override; + void RefuteDecision(Decision* d) override; std::string DebugString() const override { return absl::StrFormat("SearchLimit(crossed = %i)", crossed_); } @@ -4574,11 +4515,11 @@ class SearchLimit : public SearchMonitor { /// number of failures in the search tree class RegularLimit : public SearchLimit { public: - RegularLimit(Solver* const s, absl::Duration time, int64_t branches, + RegularLimit(Solver* s, absl::Duration time, int64_t branches, int64_t failures, int64_t solutions, bool smart_time_check, bool cumulative); ~RegularLimit() override; - void Copy(const SearchLimit* const limit) override; + void Copy(const SearchLimit* limit) override; SearchLimit* MakeClone() const override; RegularLimit* MakeIdenticalClone() const; bool CheckWithOffset(absl::Duration offset) override; @@ -4604,7 +4545,7 @@ class RegularLimit : public SearchLimit { return solver_time_at_limit_start_ + duration_limit_; } - void Accept(ModelVisitor* const visitor) const override; + void Accept(ModelVisitor* visitor) const override; private: bool CheckTime(absl::Duration offset); @@ -4715,7 +4656,7 @@ class IntervalVar : public PropagationBaseObject { virtual void SetStartRange(int64_t mi, int64_t ma) = 0; virtual int64_t OldStartMin() const = 0; virtual int64_t OldStartMax() const = 0; - virtual void WhenStartRange(Demon* const d) = 0; + virtual void WhenStartRange(Demon* d) = 0; void WhenStartRange(Solver::Closure closure) { WhenStartRange(solver()->MakeClosureDemon(std::move(closure))); } @@ -4724,7 +4665,7 @@ class IntervalVar : public PropagationBaseObject { WhenStartRange(solver()->MakeActionDemon(std::move(action))); } #endif // SWIG - virtual void WhenStartBound(Demon* const d) = 0; + virtual void WhenStartBound(Demon* d) = 0; void WhenStartBound(Solver::Closure closure) { WhenStartBound(solver()->MakeClosureDemon(std::move(closure))); } @@ -4742,7 +4683,7 @@ class IntervalVar : public PropagationBaseObject { virtual void SetDurationRange(int64_t mi, int64_t ma) = 0; virtual int64_t OldDurationMin() const = 0; virtual int64_t OldDurationMax() const = 0; - virtual void WhenDurationRange(Demon* const d) = 0; + virtual void WhenDurationRange(Demon* d) = 0; void WhenDurationRange(Solver::Closure closure) { WhenDurationRange(solver()->MakeClosureDemon(std::move(closure))); } @@ -4751,7 +4692,7 @@ class IntervalVar : public PropagationBaseObject { WhenDurationRange(solver()->MakeActionDemon(std::move(action))); } #endif // SWIG - virtual void WhenDurationBound(Demon* const d) = 0; + virtual void WhenDurationBound(Demon* d) = 0; void WhenDurationBound(Solver::Closure closure) { WhenDurationBound(solver()->MakeClosureDemon(std::move(closure))); } @@ -4769,7 +4710,7 @@ class IntervalVar : public PropagationBaseObject { virtual void SetEndRange(int64_t mi, int64_t ma) = 0; virtual int64_t OldEndMin() const = 0; virtual int64_t OldEndMax() const = 0; - virtual void WhenEndRange(Demon* const d) = 0; + virtual void WhenEndRange(Demon* d) = 0; void WhenEndRange(Solver::Closure closure) { WhenEndRange(solver()->MakeClosureDemon(std::move(closure))); } @@ -4778,7 +4719,7 @@ class IntervalVar : public PropagationBaseObject { WhenEndRange(solver()->MakeActionDemon(std::move(action))); } #endif // SWIG - virtual void WhenEndBound(Demon* const d) = 0; + virtual void WhenEndBound(Demon* d) = 0; void WhenEndBound(Solver::Closure closure) { WhenEndBound(solver()->MakeClosureDemon(std::move(closure))); } @@ -4798,7 +4739,7 @@ class IntervalVar : public PropagationBaseObject { } virtual void SetPerformed(bool val) = 0; virtual bool WasPerformedBound() const = 0; - virtual void WhenPerformedBound(Demon* const d) = 0; + virtual void WhenPerformedBound(Demon* d) = 0; void WhenPerformedBound(Solver::Closure closure) { WhenPerformedBound(solver()->MakeClosureDemon(std::move(closure))); } @@ -4809,7 +4750,7 @@ class IntervalVar : public PropagationBaseObject { #endif // SWIG /// Attaches a demon awakened when anything about this interval changes. - void WhenAnything(Demon* const d); + void WhenAnything(Demon* d); /// Attaches a closure awakened when anything about this interval changes. void WhenAnything(Solver::Closure closure) { WhenAnything(solver()->MakeClosureDemon(std::move(closure))); @@ -4836,7 +4777,7 @@ class IntervalVar : public PropagationBaseObject { virtual IntExpr* SafeEndExpr(int64_t unperformed_value) = 0; /// Accepts the given visitor. - virtual void Accept(ModelVisitor* const visitor) const = 0; + virtual void Accept(ModelVisitor* visitor) const = 0; private: DISALLOW_COPY_AND_ASSIGN(IntervalVar); @@ -4850,7 +4791,7 @@ class IntervalVar : public PropagationBaseObject { /// used to create the search decision. class SequenceVar : public PropagationBaseObject { public: - SequenceVar(Solver* const s, const std::vector& intervals, + SequenceVar(Solver* s, const std::vector& intervals, const std::vector& nexts, const std::string& name); ~SequenceVar() override; @@ -4860,19 +4801,18 @@ class SequenceVar : public PropagationBaseObject { #if !defined(SWIG) /// Returns the minimum and maximum duration of combined interval /// vars in the sequence. - void DurationRange(int64_t* const dmin, int64_t* const dmax) const; + void DurationRange(int64_t* dmin, int64_t* dmax) const; /// Returns the minimum start min and the maximum end max of all /// interval vars in the sequence. - void HorizonRange(int64_t* const hmin, int64_t* const hmax) const; + void HorizonRange(int64_t* hmin, int64_t* hmax) const; /// Returns the minimum start min and the maximum end max of all /// unranked interval vars in the sequence. - void ActiveHorizonRange(int64_t* const hmin, int64_t* const hmax) const; + void ActiveHorizonRange(int64_t* hmin, int64_t* hmax) const; /// Compute statistics on the sequence. - void ComputeStatistics(int* const ranked, int* const not_ranked, - int* const unperformed) const; + void ComputeStatistics(int* ranked, int* not_ranked, int* unperformed) const; #endif // !defined(SWIG) /// Ranks the index_th interval var first of all unranked interval @@ -4893,8 +4833,8 @@ class SequenceVar : public PropagationBaseObject { /// Computes the set of indices of interval variables that can be /// ranked first in the set of unranked activities. - void ComputePossibleFirstsAndLasts(std::vector* const possible_firsts, - std::vector* const possible_lasts); + void ComputePossibleFirstsAndLasts(std::vector* possible_firsts, + std::vector* possible_lasts); /// Applies the following sequence of ranks, ranks first, then rank /// last. rank_first and rank_last represents different directions. @@ -4913,9 +4853,8 @@ class SequenceVar : public PropagationBaseObject { /// rank_first and rank_last represents different directions. /// rank_first[0] corresponds to the first interval of the sequence. /// rank_last[0] corresponds to the last interval of the sequence. - void FillSequence(std::vector* const rank_first, - std::vector* const rank_last, - std::vector* const unperformed) const; + void FillSequence(std::vector* rank_first, std::vector* rank_last, + std::vector* unperformed) const; /// Returns the index_th interval of the sequence. IntervalVar* Interval(int index) const; @@ -4927,7 +4866,7 @@ class SequenceVar : public PropagationBaseObject { int64_t size() const { return intervals_.size(); } /// Accepts the given visitor. - virtual void Accept(ModelVisitor* const visitor) const; + virtual void Accept(ModelVisitor* visitor) const; private: int ComputeForwardFrontier(); @@ -4954,8 +4893,8 @@ class AssignmentElement { class IntVarElement : public AssignmentElement { public: IntVarElement(); - explicit IntVarElement(IntVar* const var); - void Reset(IntVar* const var); + explicit IntVarElement(IntVar* var); + void Reset(IntVar* var); IntVarElement* Clone(); void Copy(const IntVarElement& element); IntVar* Var() const { return var_; } @@ -5005,8 +4944,8 @@ class IntVarElement : public AssignmentElement { class IntervalVarElement : public AssignmentElement { public: IntervalVarElement(); - explicit IntervalVarElement(IntervalVar* const var); - void Reset(IntervalVar* const var); + explicit IntervalVarElement(IntervalVar* var); + void Reset(IntervalVar* var); IntervalVarElement* Clone(); void Copy(const IntervalVarElement& element); IntervalVar* Var() const { return var_; } @@ -5118,8 +5057,8 @@ class IntervalVarElement : public AssignmentElement { class SequenceVarElement : public AssignmentElement { public: SequenceVarElement(); - explicit SequenceVarElement(SequenceVar* const var); - void Reset(SequenceVar* const var); + explicit SequenceVarElement(SequenceVar* var); + void Reset(SequenceVar* var); SequenceVarElement* Clone(); void Copy(const SequenceVarElement& element); SequenceVar* Var() const { return var_; } @@ -5347,7 +5286,7 @@ class Assignment : public PropagationBaseObject { SequenceContainer; explicit Assignment(Solver* solver); - explicit Assignment(const Assignment* const copy); + explicit Assignment(const Assignment* copy); ~Assignment() override; void Clear(); @@ -5376,7 +5315,7 @@ class Assignment : public PropagationBaseObject { #if !defined(SWIG) bool Save(File* file) const; #endif // #if !defined(SWIG) - void Save(AssignmentProto* const assignment_proto) const; + void Save(AssignmentProto* assignment_proto) const; void AddObjective(IntVar* const v) { AddObjectives({v}); } void AddObjectives(const std::vector& vars) { @@ -5447,81 +5386,81 @@ class Assignment : public PropagationBaseObject { } } - IntVarElement* Add(IntVar* const var); + IntVarElement* Add(IntVar* var); void Add(const std::vector& vars); /// Adds without checking if variable has been previously added. - IntVarElement* FastAdd(IntVar* const var); - int64_t Min(const IntVar* const var) const; - int64_t Max(const IntVar* const var) const; - int64_t Value(const IntVar* const var) const; - bool Bound(const IntVar* const var) const; - void SetMin(const IntVar* const var, int64_t m); - void SetMax(const IntVar* const var, int64_t m); - void SetRange(const IntVar* const var, int64_t l, int64_t u); - void SetValue(const IntVar* const var, int64_t value); + IntVarElement* FastAdd(IntVar* var); + int64_t Min(const IntVar* var) const; + int64_t Max(const IntVar* var) const; + int64_t Value(const IntVar* var) const; + bool Bound(const IntVar* var) const; + void SetMin(const IntVar* var, int64_t m); + void SetMax(const IntVar* var, int64_t m); + void SetRange(const IntVar* var, int64_t l, int64_t u); + void SetValue(const IntVar* var, int64_t value); - IntervalVarElement* Add(IntervalVar* const var); + IntervalVarElement* Add(IntervalVar* var); void Add(const std::vector& vars); /// Adds without checking if variable has been previously added. - IntervalVarElement* FastAdd(IntervalVar* const var); - int64_t StartMin(const IntervalVar* const var) const; - int64_t StartMax(const IntervalVar* const var) const; - int64_t StartValue(const IntervalVar* const var) const; - int64_t DurationMin(const IntervalVar* const var) const; - int64_t DurationMax(const IntervalVar* const var) const; - int64_t DurationValue(const IntervalVar* const var) const; - int64_t EndMin(const IntervalVar* const var) const; - int64_t EndMax(const IntervalVar* const var) const; - int64_t EndValue(const IntervalVar* const var) const; - int64_t PerformedMin(const IntervalVar* const var) const; - int64_t PerformedMax(const IntervalVar* const var) const; - int64_t PerformedValue(const IntervalVar* const var) const; - void SetStartMin(const IntervalVar* const var, int64_t m); - void SetStartMax(const IntervalVar* const var, int64_t m); - void SetStartRange(const IntervalVar* const var, int64_t mi, int64_t ma); - void SetStartValue(const IntervalVar* const var, int64_t value); - void SetDurationMin(const IntervalVar* const var, int64_t m); - void SetDurationMax(const IntervalVar* const var, int64_t m); - void SetDurationRange(const IntervalVar* const var, int64_t mi, int64_t ma); - void SetDurationValue(const IntervalVar* const var, int64_t value); - void SetEndMin(const IntervalVar* const var, int64_t m); - void SetEndMax(const IntervalVar* const var, int64_t m); - void SetEndRange(const IntervalVar* const var, int64_t mi, int64_t ma); - void SetEndValue(const IntervalVar* const var, int64_t value); - void SetPerformedMin(const IntervalVar* const var, int64_t m); - void SetPerformedMax(const IntervalVar* const var, int64_t m); - void SetPerformedRange(const IntervalVar* const var, int64_t mi, int64_t ma); - void SetPerformedValue(const IntervalVar* const var, int64_t value); + IntervalVarElement* FastAdd(IntervalVar* var); + int64_t StartMin(const IntervalVar* var) const; + int64_t StartMax(const IntervalVar* var) const; + int64_t StartValue(const IntervalVar* var) const; + int64_t DurationMin(const IntervalVar* var) const; + int64_t DurationMax(const IntervalVar* var) const; + int64_t DurationValue(const IntervalVar* var) const; + int64_t EndMin(const IntervalVar* var) const; + int64_t EndMax(const IntervalVar* var) const; + int64_t EndValue(const IntervalVar* var) const; + int64_t PerformedMin(const IntervalVar* var) const; + int64_t PerformedMax(const IntervalVar* var) const; + int64_t PerformedValue(const IntervalVar* var) const; + void SetStartMin(const IntervalVar* var, int64_t m); + void SetStartMax(const IntervalVar* var, int64_t m); + void SetStartRange(const IntervalVar* var, int64_t mi, int64_t ma); + void SetStartValue(const IntervalVar* var, int64_t value); + void SetDurationMin(const IntervalVar* var, int64_t m); + void SetDurationMax(const IntervalVar* var, int64_t m); + void SetDurationRange(const IntervalVar* var, int64_t mi, int64_t ma); + void SetDurationValue(const IntervalVar* var, int64_t value); + void SetEndMin(const IntervalVar* var, int64_t m); + void SetEndMax(const IntervalVar* var, int64_t m); + void SetEndRange(const IntervalVar* var, int64_t mi, int64_t ma); + void SetEndValue(const IntervalVar* var, int64_t value); + void SetPerformedMin(const IntervalVar* var, int64_t m); + void SetPerformedMax(const IntervalVar* var, int64_t m); + void SetPerformedRange(const IntervalVar* var, int64_t mi, int64_t ma); + void SetPerformedValue(const IntervalVar* var, int64_t value); - SequenceVarElement* Add(SequenceVar* const var); + SequenceVarElement* Add(SequenceVar* var); void Add(const std::vector& vars); /// Adds without checking if the variable had been previously added. - SequenceVarElement* FastAdd(SequenceVar* const var); - const std::vector& ForwardSequence(const SequenceVar* const var) const; - const std::vector& BackwardSequence(const SequenceVar* const var) const; - const std::vector& Unperformed(const SequenceVar* const var) const; - void SetSequence(const SequenceVar* const var, + SequenceVarElement* FastAdd(SequenceVar* var); + const std::vector& ForwardSequence(const SequenceVar* var) const; + const std::vector& BackwardSequence(const SequenceVar* var) const; + const std::vector& Unperformed(const SequenceVar* var) const; + void SetSequence(const SequenceVar* var, const std::vector& forward_sequence, const std::vector& backward_sequence, const std::vector& unperformed); - void SetForwardSequence(const SequenceVar* const var, + void SetForwardSequence(const SequenceVar* var, const std::vector& forward_sequence); - void SetBackwardSequence(const SequenceVar* const var, + void SetBackwardSequence(const SequenceVar* var, const std::vector& backward_sequence); - void SetUnperformed(const SequenceVar* const var, + void SetUnperformed(const SequenceVar* var, const std::vector& unperformed); - void Activate(const IntVar* const var); - void Deactivate(const IntVar* const var); - bool Activated(const IntVar* const var) const; + void Activate(const IntVar* var); + void Deactivate(const IntVar* var); + bool Activated(const IntVar* var) const; - void Activate(const IntervalVar* const var); - void Deactivate(const IntervalVar* const var); - bool Activated(const IntervalVar* const var) const; + void Activate(const IntervalVar* var); + void Deactivate(const IntervalVar* var); + bool Activated(const IntervalVar* var) const; - void Activate(const SequenceVar* const var); - void Deactivate(const SequenceVar* const var); - bool Activated(const SequenceVar* const var) const; + void Activate(const SequenceVar* var); + void Deactivate(const SequenceVar* var); + bool Activated(const SequenceVar* var) const; void ActivateObjective() { ActivateObjectiveFromIndex(0); } void DeactivateObjective() { DeactivateObjectiveFromIndex(0); } @@ -5549,9 +5488,9 @@ class Assignment : public PropagationBaseObject { sequence_var_container_.AreAllElementsBound(); } - bool Contains(const IntVar* const var) const; - bool Contains(const IntervalVar* const var) const; - bool Contains(const SequenceVar* const var) const; + bool Contains(const IntVar* var) const; + bool Contains(const IntervalVar* var) const; + bool Contains(const SequenceVar* var) const; /// Copies the intersection of the two assignments to the current /// assignment. void CopyIntersection(const Assignment* assignment); @@ -5607,7 +5546,7 @@ void SetAssignmentFromAssignment(Assignment* target_assignment, class Pack : public Constraint { public: - Pack(Solver* const s, const std::vector& vars, int number_of_bins); + Pack(Solver* s, const std::vector& vars, int number_of_bins); ~Pack() override; @@ -5662,15 +5601,15 @@ class Pack : public Constraint { /// This dimension enforces that cost_var == sum of weights[i] for /// all objects 'i' assigned to a bin. void AddWeightedSumOfAssignedDimension(const std::vector& weights, - IntVar* const cost_var); + IntVar* cost_var); /// This dimension links 'count_var' to the actual number of bins used in the /// pack. - void AddCountUsedBinDimension(IntVar* const count_var); + void AddCountUsedBinDimension(IntVar* count_var); /// This dimension links 'count_var' to the actual number of items /// assigned to a bin in the pack. - void AddCountAssignedItemsDimension(IntVar* const count_var); + void AddCountAssignedItemsDimension(IntVar* count_var); void Post() override; void ClearAll(); @@ -5692,7 +5631,7 @@ class Pack : public Constraint { void AssignFirstPossibleToBin(int bin_index); void AssignAllRemainingItems(); void UnassignAllRemainingItems(); - void Accept(ModelVisitor* const visitor) const override; + void Accept(ModelVisitor* visitor) const override; private: bool IsInProcess() const; @@ -5712,8 +5651,7 @@ class Pack : public Constraint { class DisjunctiveConstraint : public Constraint { public: - DisjunctiveConstraint(Solver* const s, - const std::vector& intervals, + DisjunctiveConstraint(Solver* s, const std::vector& intervals, const std::string& name); ~DisjunctiveConstraint() override; @@ -5755,19 +5693,19 @@ class SolutionPool : public BaseObject { /// This method is called to initialize the solution pool with the assignment /// from the local search. - virtual void Initialize(Assignment* const assignment) = 0; + virtual void Initialize(Assignment* assignment) = 0; /// This method is called when a new solution has been accepted by the local /// search. - virtual void RegisterNewSolution(Assignment* const assignment) = 0; + virtual void RegisterNewSolution(Assignment* assignment) = 0; /// This method is called when the local search starts a new neighborhood to /// initialize the default assignment. - virtual void GetNextSolution(Assignment* const assignment) = 0; + virtual void GetNextSolution(Assignment* assignment) = 0; /// This method checks if the local solution needs to be updated with /// an external one. - virtual bool SyncNeeded(Assignment* const local_assignment) = 0; + virtual bool SyncNeeded(Assignment* local_assignment) = 0; }; } // namespace operations_research diff --git a/ortools/constraint_solver/constraint_solveri.h b/ortools/constraint_solver/constraint_solveri.h index ebe7706db7..539a3cfe47 100644 --- a/ortools/constraint_solver/constraint_solveri.h +++ b/ortools/constraint_solver/constraint_solveri.h @@ -398,9 +398,9 @@ class SmallRevBitSet { public: explicit SmallRevBitSet(int64_t size); /// Sets the 'pos' bit. - void SetToOne(Solver* const solver, int64_t pos); + void SetToOne(Solver* solver, int64_t pos); /// Erases the 'pos' bit. - void SetToZero(Solver* const solver, int64_t pos); + void SetToZero(Solver* solver, int64_t pos); /// Returns the number of bits set to one. int64_t Cardinality() const; /// Is bitset null? @@ -425,9 +425,9 @@ class RevBitSet { ~RevBitSet(); /// Sets the 'index' bit. - void SetToOne(Solver* const solver, int64_t index); + void SetToOne(Solver* solver, int64_t index); /// Erases the 'index' bit. - void SetToZero(Solver* const solver, int64_t index); + void SetToZero(Solver* solver, int64_t index); /// Returns whether the 'index' bit is set. bool IsSet(int64_t index) const; /// Returns the number of bits set to one. @@ -440,13 +440,13 @@ class RevBitSet { /// It returns -1 if the bitset is empty after start. int64_t GetFirstBit(int start) const; /// Cleans all bits. - void ClearAll(Solver* const solver); + void ClearAll(Solver* solver); friend class RevBitMatrix; private: /// Save the offset's part of the bitset. - void Save(Solver* const solver, int offset); + void Save(Solver* solver, int offset); const int64_t size_; const int64_t length_; uint64_t* bits_; @@ -460,9 +460,9 @@ class RevBitMatrix : private RevBitSet { ~RevBitMatrix(); /// Sets the 'column' bit in the 'row' row. - void SetToOne(Solver* const solver, int64_t row, int64_t column); + void SetToOne(Solver* solver, int64_t row, int64_t column); /// Erases the 'column' bit in the 'row' row. - void SetToZero(Solver* const solver, int64_t row, int64_t column); + void SetToZero(Solver* solver, int64_t row, int64_t column); /// Returns whether the 'column' bit in the 'row' row is set. bool IsSet(int64_t row, int64_t column) const { DCHECK_GE(row, 0); @@ -481,7 +481,7 @@ class RevBitMatrix : private RevBitSet { /// It returns -1 if there are none. int64_t GetFirstBit(int row, int start) const; /// Cleans all bits. - void ClearAll(Solver* const solver); + void ClearAll(Solver* solver); private: const int64_t rows_; @@ -1815,7 +1815,7 @@ class LocalSearchFilterManager : public BaseObject { /// Returns true iff all filters return true, and the sum of their accepted /// objectives is between objective_min and objective_max. /// The monitor has its Begin/EndFiltering events triggered. - bool Accept(LocalSearchMonitor* const monitor, const Assignment* delta, + bool Accept(LocalSearchMonitor* monitor, const Assignment* delta, const Assignment* deltadelta, int64_t objective_min, int64_t objective_max); /// Synchronizes all filters to assignment. @@ -1881,64 +1881,58 @@ class IntVarLocalSearchFilter : public LocalSearchFilter { class PropagationMonitor : public SearchMonitor { public: - explicit PropagationMonitor(Solver* const solver); + explicit PropagationMonitor(Solver* solver); ~PropagationMonitor() override; std::string DebugString() const override { return "PropagationMonitor"; } /// Propagation events. - virtual void BeginConstraintInitialPropagation( - Constraint* const constraint) = 0; - virtual void EndConstraintInitialPropagation( - Constraint* const constraint) = 0; - virtual void BeginNestedConstraintInitialPropagation( - Constraint* const parent, Constraint* const nested) = 0; - virtual void EndNestedConstraintInitialPropagation( - Constraint* const parent, Constraint* const nested) = 0; - virtual void RegisterDemon(Demon* const demon) = 0; - virtual void BeginDemonRun(Demon* const demon) = 0; - virtual void EndDemonRun(Demon* const demon) = 0; - virtual void StartProcessingIntegerVariable(IntVar* const var) = 0; - virtual void EndProcessingIntegerVariable(IntVar* const var) = 0; + virtual void BeginConstraintInitialPropagation(Constraint* constraint) = 0; + virtual void EndConstraintInitialPropagation(Constraint* constraint) = 0; + virtual void BeginNestedConstraintInitialPropagation(Constraint* parent, + Constraint* nested) = 0; + virtual void EndNestedConstraintInitialPropagation(Constraint* parent, + Constraint* nested) = 0; + virtual void RegisterDemon(Demon* demon) = 0; + virtual void BeginDemonRun(Demon* demon) = 0; + virtual void EndDemonRun(Demon* demon) = 0; + virtual void StartProcessingIntegerVariable(IntVar* var) = 0; + virtual void EndProcessingIntegerVariable(IntVar* var) = 0; virtual void PushContext(const std::string& context) = 0; virtual void PopContext() = 0; /// IntExpr modifiers. - virtual void SetMin(IntExpr* const expr, int64_t new_min) = 0; - virtual void SetMax(IntExpr* const expr, int64_t new_max) = 0; - virtual void SetRange(IntExpr* const expr, int64_t new_min, - int64_t new_max) = 0; + virtual void SetMin(IntExpr* expr, int64_t new_min) = 0; + virtual void SetMax(IntExpr* expr, int64_t new_max) = 0; + virtual void SetRange(IntExpr* expr, int64_t new_min, int64_t new_max) = 0; /// IntVar modifiers. - virtual void SetMin(IntVar* const var, int64_t new_min) = 0; - virtual void SetMax(IntVar* const var, int64_t new_max) = 0; - virtual void SetRange(IntVar* const var, int64_t new_min, - int64_t new_max) = 0; - virtual void RemoveValue(IntVar* const var, int64_t value) = 0; - virtual void SetValue(IntVar* const var, int64_t value) = 0; - virtual void RemoveInterval(IntVar* const var, int64_t imin, - int64_t imax) = 0; - virtual void SetValues(IntVar* const var, - const std::vector& values) = 0; - virtual void RemoveValues(IntVar* const var, + virtual void SetMin(IntVar* var, int64_t new_min) = 0; + virtual void SetMax(IntVar* var, int64_t new_max) = 0; + virtual void SetRange(IntVar* var, int64_t new_min, int64_t new_max) = 0; + virtual void RemoveValue(IntVar* var, int64_t value) = 0; + virtual void SetValue(IntVar* var, int64_t value) = 0; + virtual void RemoveInterval(IntVar* var, int64_t imin, int64_t imax) = 0; + virtual void SetValues(IntVar* var, const std::vector& values) = 0; + virtual void RemoveValues(IntVar* var, const std::vector& values) = 0; /// IntervalVar modifiers. - virtual void SetStartMin(IntervalVar* const var, int64_t new_min) = 0; - virtual void SetStartMax(IntervalVar* const var, int64_t new_max) = 0; - virtual void SetStartRange(IntervalVar* const var, int64_t new_min, + virtual void SetStartMin(IntervalVar* var, int64_t new_min) = 0; + virtual void SetStartMax(IntervalVar* var, int64_t new_max) = 0; + virtual void SetStartRange(IntervalVar* var, int64_t new_min, int64_t new_max) = 0; - virtual void SetEndMin(IntervalVar* const var, int64_t new_min) = 0; - virtual void SetEndMax(IntervalVar* const var, int64_t new_max) = 0; - virtual void SetEndRange(IntervalVar* const var, int64_t new_min, + virtual void SetEndMin(IntervalVar* var, int64_t new_min) = 0; + virtual void SetEndMax(IntervalVar* var, int64_t new_max) = 0; + virtual void SetEndRange(IntervalVar* var, int64_t new_min, int64_t new_max) = 0; - virtual void SetDurationMin(IntervalVar* const var, int64_t new_min) = 0; - virtual void SetDurationMax(IntervalVar* const var, int64_t new_max) = 0; - virtual void SetDurationRange(IntervalVar* const var, int64_t new_min, + virtual void SetDurationMin(IntervalVar* var, int64_t new_min) = 0; + virtual void SetDurationMax(IntervalVar* var, int64_t new_max) = 0; + virtual void SetDurationRange(IntervalVar* var, int64_t new_min, int64_t new_max) = 0; - virtual void SetPerformed(IntervalVar* const var, bool value) = 0; + virtual void SetPerformed(IntervalVar* var, bool value) = 0; /// SequenceVar modifiers - virtual void RankFirst(SequenceVar* const var, int index) = 0; - virtual void RankNotFirst(SequenceVar* const var, int index) = 0; - virtual void RankLast(SequenceVar* const var, int index) = 0; - virtual void RankNotLast(SequenceVar* const var, int index) = 0; - virtual void RankSequence(SequenceVar* const var, + virtual void RankFirst(SequenceVar* var, int index) = 0; + virtual void RankNotFirst(SequenceVar* var, int index) = 0; + virtual void RankLast(SequenceVar* var, int index) = 0; + virtual void RankNotLast(SequenceVar* var, int index) = 0; + virtual void RankSequence(SequenceVar* var, const std::vector& rank_first, const std::vector& rank_last, const std::vector& unperformed) = 0; @@ -1949,7 +1943,7 @@ class PropagationMonitor : public SearchMonitor { class LocalSearchMonitor : public SearchMonitor { // TODO(user): Add monitoring of local search filters. public: - explicit LocalSearchMonitor(Solver* const solver); + explicit LocalSearchMonitor(Solver* solver); ~LocalSearchMonitor() override; std::string DebugString() const override { return "LocalSearchMonitor"; } @@ -2031,11 +2025,9 @@ class SymmetryBreaker : public DecisionVisitor { : symmetry_manager_(nullptr), index_in_symmetry_manager_(-1) {} ~SymmetryBreaker() override {} - void AddIntegerVariableEqualValueClause(IntVar* const var, int64_t value); - void AddIntegerVariableGreaterOrEqualValueClause(IntVar* const var, - int64_t value); - void AddIntegerVariableLessOrEqualValueClause(IntVar* const var, - int64_t value); + void AddIntegerVariableEqualValueClause(IntVar* var, int64_t value); + void AddIntegerVariableGreaterOrEqualValueClause(IntVar* var, int64_t value); + void AddIntegerVariableLessOrEqualValueClause(IntVar* var, int64_t value); private: friend class SymmetryManager; @@ -2057,9 +2049,8 @@ class SymmetryBreaker : public DecisionVisitor { /// the search is running. class SearchLog : public SearchMonitor { public: - SearchLog(Solver* const s, OptimizeVar* const obj, IntVar* const var, - double scaling_factor, double offset, - std::function display_callback, + SearchLog(Solver* s, OptimizeVar* obj, IntVar* var, double scaling_factor, + double offset, std::function display_callback, bool display_on_new_solutions_only, int period); ~SearchLog() override; void EnterSearch() override; @@ -2068,8 +2059,8 @@ class SearchLog : public SearchMonitor { void BeginFail() override; void NoMoreSolutions() override; void AcceptUncheckedNeighbor() override; - void ApplyDecision(Decision* const decision) override; - void RefuteDecision(Decision* const decision) override; + void ApplyDecision(Decision* decision) override; + void RefuteDecision(Decision* decision) override; void OutputDecision(); void Maintain(); void BeginInitialPropagation() override; @@ -2202,7 +2193,7 @@ class ModelCache { VAR_ARRAY_CONSTANT_EXPRESSION_MAX, }; - explicit ModelCache(Solver* const solver); + explicit ModelCache(Solver* solver); virtual ~ModelCache(); virtual void Clear() = 0; @@ -2211,98 +2202,90 @@ class ModelCache { virtual Constraint* FindVoidConstraint(VoidConstraintType type) const = 0; - virtual void InsertVoidConstraint(Constraint* const ct, + virtual void InsertVoidConstraint(Constraint* ct, VoidConstraintType type) = 0; /// Var Constant Constraints. virtual Constraint* FindVarConstantConstraint( - IntVar* const var, int64_t value, - VarConstantConstraintType type) const = 0; + IntVar* var, int64_t value, VarConstantConstraintType type) const = 0; - virtual void InsertVarConstantConstraint(Constraint* const ct, - IntVar* const var, int64_t value, + virtual void InsertVarConstantConstraint(Constraint* ct, IntVar* var, + int64_t value, VarConstantConstraintType type) = 0; /// Var Constant Constant Constraints. virtual Constraint* FindVarConstantConstantConstraint( - IntVar* const var, int64_t value1, int64_t value2, + IntVar* var, int64_t value1, int64_t value2, VarConstantConstantConstraintType type) const = 0; virtual void InsertVarConstantConstantConstraint( - Constraint* const ct, IntVar* const var, int64_t value1, int64_t value2, + Constraint* ct, IntVar* var, int64_t value1, int64_t value2, VarConstantConstantConstraintType type) = 0; /// Expr Expr Constraints. virtual Constraint* FindExprExprConstraint( - IntExpr* const expr1, IntExpr* const expr2, - ExprExprConstraintType type) const = 0; + IntExpr* expr1, IntExpr* expr2, ExprExprConstraintType type) const = 0; - virtual void InsertExprExprConstraint(Constraint* const ct, - IntExpr* const expr1, - IntExpr* const expr2, + virtual void InsertExprExprConstraint(Constraint* ct, IntExpr* expr1, + IntExpr* expr2, ExprExprConstraintType type) = 0; /// Expr Expressions. - virtual IntExpr* FindExprExpression(IntExpr* const expr, + virtual IntExpr* FindExprExpression(IntExpr* expr, ExprExpressionType type) const = 0; - virtual void InsertExprExpression(IntExpr* const expression, - IntExpr* const expr, + virtual void InsertExprExpression(IntExpr* expression, IntExpr* expr, ExprExpressionType type) = 0; /// Expr Constant Expressions. virtual IntExpr* FindExprConstantExpression( - IntExpr* const expr, int64_t value, - ExprConstantExpressionType type) const = 0; + IntExpr* expr, int64_t value, ExprConstantExpressionType type) const = 0; virtual void InsertExprConstantExpression( - IntExpr* const expression, IntExpr* const var, int64_t value, + IntExpr* expression, IntExpr* var, int64_t value, ExprConstantExpressionType type) = 0; /// Expr Expr Expressions. virtual IntExpr* FindExprExprExpression( - IntExpr* const var1, IntExpr* const var2, - ExprExprExpressionType type) const = 0; + IntExpr* var1, IntExpr* var2, ExprExprExpressionType type) const = 0; - virtual void InsertExprExprExpression(IntExpr* const expression, - IntExpr* const var1, - IntExpr* const var2, + virtual void InsertExprExprExpression(IntExpr* expression, IntExpr* var1, + IntExpr* var2, ExprExprExpressionType type) = 0; /// Expr Expr Constant Expressions. virtual IntExpr* FindExprExprConstantExpression( - IntExpr* const var1, IntExpr* const var2, int64_t constant, + IntExpr* var1, IntExpr* var2, int64_t constant, ExprExprConstantExpressionType type) const = 0; virtual void InsertExprExprConstantExpression( - IntExpr* const expression, IntExpr* const var1, IntExpr* const var2, - int64_t constant, ExprExprConstantExpressionType type) = 0; + IntExpr* expression, IntExpr* var1, IntExpr* var2, int64_t constant, + ExprExprConstantExpressionType type) = 0; /// Var Constant Constant Expressions. virtual IntExpr* FindVarConstantConstantExpression( - IntVar* const var, int64_t value1, int64_t value2, + IntVar* var, int64_t value1, int64_t value2, VarConstantConstantExpressionType type) const = 0; virtual void InsertVarConstantConstantExpression( - IntExpr* const expression, IntVar* const var, int64_t value1, - int64_t value2, VarConstantConstantExpressionType type) = 0; + IntExpr* expression, IntVar* var, int64_t value1, int64_t value2, + VarConstantConstantExpressionType type) = 0; /// Var Constant Array Expressions. virtual IntExpr* FindVarConstantArrayExpression( - IntVar* const var, const std::vector& values, + IntVar* var, const std::vector& values, VarConstantArrayExpressionType type) const = 0; virtual void InsertVarConstantArrayExpression( - IntExpr* const expression, IntVar* const var, - const std::vector& values, + IntExpr* expression, IntVar* var, const std::vector& values, VarConstantArrayExpressionType type) = 0; /// Var Array Expressions. @@ -2310,7 +2293,7 @@ class ModelCache { virtual IntExpr* FindVarArrayExpression( const std::vector& vars, VarArrayExpressionType type) const = 0; - virtual void InsertVarArrayExpression(IntExpr* const expression, + virtual void InsertVarArrayExpression(IntExpr* expression, const std::vector& vars, VarArrayExpressionType type) = 0; @@ -2321,7 +2304,7 @@ class ModelCache { VarArrayConstantArrayExpressionType type) const = 0; virtual void InsertVarArrayConstantArrayExpression( - IntExpr* const expression, const std::vector& var, + IntExpr* expression, const std::vector& var, const std::vector& values, VarArrayConstantArrayExpressionType type) = 0; @@ -2332,7 +2315,7 @@ class ModelCache { VarArrayConstantExpressionType type) const = 0; virtual void InsertVarArrayConstantExpression( - IntExpr* const expression, const std::vector& var, int64_t value, + IntExpr* expression, const std::vector& var, int64_t value, VarArrayConstantExpressionType type) = 0; Solver* solver() const; @@ -2355,14 +2338,13 @@ class ArgumentHolder { const std::vector& values); void SetIntegerMatrixArgument(const std::string& arg_name, const IntTupleSet& values); - void SetIntegerExpressionArgument(const std::string& arg_name, - IntExpr* const expr); + void SetIntegerExpressionArgument(const std::string& arg_name, IntExpr* expr); void SetIntegerVariableArrayArgument(const std::string& arg_name, const std::vector& vars); - void SetIntervalArgument(const std::string& arg_name, IntervalVar* const var); + void SetIntervalArgument(const std::string& arg_name, IntervalVar* var); void SetIntervalArrayArgument(const std::string& arg_name, const std::vector& vars); - void SetSequenceArgument(const std::string& arg_name, SequenceVar* const var); + void SetSequenceArgument(const std::string& arg_name, SequenceVar* var); void SetSequenceArrayArgument(const std::string& arg_name, const std::vector& vars); @@ -2412,22 +2394,21 @@ class ModelParser : public ModelVisitor { void BeginVisitModel(const std::string& solver_name) override; void EndVisitModel(const std::string& solver_name) override; void BeginVisitConstraint(const std::string& type_name, - const Constraint* const constraint) override; + const Constraint* constraint) override; void EndVisitConstraint(const std::string& type_name, - const Constraint* const constraint) override; + const Constraint* constraint) override; void BeginVisitIntegerExpression(const std::string& type_name, - const IntExpr* const expr) override; + const IntExpr* expr) override; void EndVisitIntegerExpression(const std::string& type_name, - const IntExpr* const expr) override; - void VisitIntegerVariable(const IntVar* const variable, - IntExpr* const delegate) override; - void VisitIntegerVariable(const IntVar* const variable, + const IntExpr* expr) override; + void VisitIntegerVariable(const IntVar* variable, IntExpr* delegate) override; + void VisitIntegerVariable(const IntVar* variable, const std::string& operation, int64_t value, - IntVar* const delegate) override; - void VisitIntervalVariable(const IntervalVar* const variable, + IntVar* delegate) override; + void VisitIntervalVariable(const IntervalVar* variable, const std::string& operation, int64_t value, - IntervalVar* const delegate) override; - void VisitSequenceVariable(const SequenceVar* const variable) override; + IntervalVar* delegate) override; + void VisitSequenceVariable(const SequenceVar* variable) override; /// Integer arguments void VisitIntegerArgument(const std::string& arg_name, int64_t value) override; @@ -2437,19 +2418,19 @@ class ModelParser : public ModelVisitor { const IntTupleSet& values) override; /// Variables. void VisitIntegerExpressionArgument(const std::string& arg_name, - IntExpr* const argument) override; + IntExpr* argument) override; void VisitIntegerVariableArrayArgument( const std::string& arg_name, const std::vector& arguments) override; /// Visit interval argument. void VisitIntervalArgument(const std::string& arg_name, - IntervalVar* const argument) override; + IntervalVar* argument) override; void VisitIntervalArrayArgument( const std::string& arg_name, const std::vector& arguments) override; /// Visit sequence argument. void VisitSequenceArgument(const std::string& arg_name, - SequenceVar* const argument) override; + SequenceVar* argument) override; void VisitSequenceArrayArgument( const std::string& arg_name, const std::vector& arguments) override; @@ -2819,15 +2800,15 @@ class UnsortedNullableRevBitset { /// This methods overwrites the active bitset with the mask. This method /// should be called only once. - void Init(Solver* const solver, const std::vector& mask); + void Init(Solver* solver, const std::vector& mask); /// This method subtracts the mask from the active bitset. It returns true if /// the active bitset was changed in the process. - bool RevSubtract(Solver* const solver, const std::vector& mask); + bool RevSubtract(Solver* solver, const std::vector& mask); /// This method ANDs the mask with the active bitset. It returns true if /// the active bitset was changed in the process. - bool RevAnd(Solver* const solver, const std::vector& mask); + bool RevAnd(Solver* solver, const std::vector& mask); /// This method returns the number of non null 64 bit words in the bitset /// representation. @@ -2853,7 +2834,7 @@ class UnsortedNullableRevBitset { const RevIntSet& active_words() const { return active_words_; } private: - void CleanUpActives(Solver* const solver); + void CleanUpActives(Solver* solver); const int64_t bit_size_; const int64_t word_size_; @@ -3093,7 +3074,7 @@ class PathState { class NodeRange; struct ChainBounds { - ChainBounds() = default; + ChainBounds() {} ChainBounds(int begin_index, int end_index) : begin_index(begin_index), end_index(end_index) {} int begin_index; diff --git a/ortools/constraint_solver/constraints.cc b/ortools/constraint_solver/constraints.cc index 6a2aeca8fc..3199d12630 100644 --- a/ortools/constraint_solver/constraints.cc +++ b/ortools/constraint_solver/constraints.cc @@ -241,7 +241,7 @@ class LexicalLessOrEqual : public Constraint { [](int step) { return step > 0; })); } - ~LexicalLessOrEqual() override = default; + ~LexicalLessOrEqual() override {} void Post() override { const int position = JumpEqualVariables(0); diff --git a/ortools/constraint_solver/count_cst.cc b/ortools/constraint_solver/count_cst.cc index 4fb4b0828e..a097ed8932 100644 --- a/ortools/constraint_solver/count_cst.cc +++ b/ortools/constraint_solver/count_cst.cc @@ -324,7 +324,7 @@ void Distribute::CardMax(int cindex) { class FastDistribute : public Constraint { public: - FastDistribute(Solver* const s, const std::vector& vars, + FastDistribute(Solver* s, const std::vector& vars, const std::vector& cards); ~FastDistribute() override {} @@ -510,7 +510,7 @@ void FastDistribute::CardMax(int card_index) { class BoundedDistribute : public Constraint { public: - BoundedDistribute(Solver* const s, const std::vector& vars, + BoundedDistribute(Solver* s, const std::vector& vars, const std::vector& values, const std::vector& card_min, const std::vector& card_max); @@ -713,7 +713,7 @@ void BoundedDistribute::CardMax(int card_index) { class BoundedFastDistribute : public Constraint { public: - BoundedFastDistribute(Solver* const s, const std::vector& vars, + BoundedFastDistribute(Solver* s, const std::vector& vars, const std::vector& card_min, const std::vector& card_max); ~BoundedFastDistribute() override {} diff --git a/ortools/constraint_solver/default_search.cc b/ortools/constraint_solver/default_search.cc index 6617d0dd88..dec7d29f07 100644 --- a/ortools/constraint_solver/default_search.cc +++ b/ortools/constraint_solver/default_search.cc @@ -96,13 +96,13 @@ class FindVar : public DecisionVisitor { ~FindVar() override {} - void VisitSetVariableValue(IntVar* const var, int64_t value) override { + void VisitSetVariableValue(IntVar* var, int64_t value) override { var_ = var; value_ = value; operation_ = ASSIGN; } - void VisitSplitVariableDomain(IntVar* const var, int64_t value, + void VisitSplitVariableDomain(IntVar* var, int64_t value, bool start_with_lower_half) override { var_ = var; value_ = value; @@ -124,7 +124,7 @@ class FindVar : public DecisionVisitor { void VisitUnknownDecision() override { operation_ = NONE; } // Returns the current variable. - IntVar* const var() const { + IntVar* var() const { CHECK_NE(operation_, NONE); return var_; } diff --git a/ortools/constraint_solver/element.cc b/ortools/constraint_solver/element.cc index 9275e13aa5..c7ba5ec152 100644 --- a/ortools/constraint_solver/element.cc +++ b/ortools/constraint_solver/element.cc @@ -36,7 +36,7 @@ ABSL_FLAG(bool, cp_disable_element_cache, true, namespace operations_research { // ----- IntExprElement ----- -void LinkVarExpr(Solver* const s, IntExpr* const expr, IntVar* const var); +void LinkVarExpr(Solver* s, IntExpr* expr, IntVar* var); namespace { @@ -68,7 +68,7 @@ class VectorGreater { class BaseIntExprElement : public BaseIntExpr { public: - BaseIntExprElement(Solver* const s, IntVar* const e); + BaseIntExprElement(Solver* s, IntVar* e); ~BaseIntExprElement() override {} int64_t Min() const override; int64_t Max() const override; @@ -285,7 +285,7 @@ class IntElementConstraint : public CastConstraint { // ----- IntExprElement -IntVar* BuildDomainIntVar(Solver* const solver, std::vector* values); +IntVar* BuildDomainIntVar(Solver* solver, std::vector* values); class IntExprElement : public BaseIntExprElement { public: @@ -461,8 +461,8 @@ void RangeMinimumQueryExprElement::SetRange(int64_t mi, int64_t ma) { class IncreasingIntExprElement : public BaseIntExpr { public: - IncreasingIntExprElement(Solver* const s, const std::vector& values, - IntVar* const index); + IncreasingIntExprElement(Solver* s, const std::vector& values, + IntVar* index); ~IncreasingIntExprElement() override {} int64_t Min() const override; @@ -680,8 +680,7 @@ IntExpr* Solver::MakeElement(const std::vector& values, namespace { class IntExprFunctionElement : public BaseIntExprElement { public: - IntExprFunctionElement(Solver* const s, Solver::IndexEvaluator1 values, - IntVar* const e); + IntExprFunctionElement(Solver* s, Solver::IndexEvaluator1 values, IntVar* e); ~IntExprFunctionElement() override; std::string name() const override { @@ -889,8 +888,8 @@ IntExpr* Solver::MakeMonotonicElement(Solver::IndexEvaluator1 values, namespace { class IntIntExprFunctionElement : public BaseIntExpr { public: - IntIntExprFunctionElement(Solver* const s, Solver::IndexEvaluator2 values, - IntVar* const expr1, IntVar* const expr2); + IntIntExprFunctionElement(Solver* s, Solver::IndexEvaluator2 values, + IntVar* expr1, IntVar* expr2); ~IntIntExprFunctionElement() override; std::string DebugString() const override { return absl::StrFormat("IntIntFunctionElement(%s,%s)", @@ -1201,9 +1200,9 @@ class IfThenElseCt : public CastConstraint { namespace { class IntExprEvaluatorElementCt : public CastConstraint { public: - IntExprEvaluatorElementCt(Solver* const s, Solver::Int64ToIntVar evaluator, + IntExprEvaluatorElementCt(Solver* s, Solver::Int64ToIntVar evaluator, int64_t range_start, int64_t range_end, - IntVar* const index, IntVar* const target_var); + IntVar* index, IntVar* target_var); ~IntExprEvaluatorElementCt() override {} void Post() override; @@ -1214,7 +1213,7 @@ class IntExprEvaluatorElementCt : public CastConstraint { void UpdateExpr(); std::string DebugString() const override; - void Accept(ModelVisitor* const visitor) const override; + void Accept(ModelVisitor* visitor) const override; protected: IntVar* const index_; @@ -1377,11 +1376,11 @@ void IntExprEvaluatorElementCt::Accept(ModelVisitor* const visitor) const { class IntExprArrayElementCt : public IntExprEvaluatorElementCt { public: - IntExprArrayElementCt(Solver* const s, std::vector vars, - IntVar* const index, IntVar* const target_var); + IntExprArrayElementCt(Solver* s, std::vector vars, IntVar* index, + IntVar* target_var); std::string DebugString() const override; - void Accept(ModelVisitor* const visitor) const override; + void Accept(ModelVisitor* visitor) const override; private: const std::vector vars_; diff --git a/ortools/constraint_solver/expr_array.cc b/ortools/constraint_solver/expr_array.cc index 56f1bda262..963c53b480 100644 --- a/ortools/constraint_solver/expr_array.cc +++ b/ortools/constraint_solver/expr_array.cc @@ -1555,8 +1555,7 @@ class SumBooleanLessOrEqualToOne : public BaseSumBooleanConstraint { class SumBooleanGreaterOrEqualToOne : public BaseSumBooleanConstraint { public: - SumBooleanGreaterOrEqualToOne(Solver* const s, - const std::vector& vars); + SumBooleanGreaterOrEqualToOne(Solver* s, const std::vector& vars); ~SumBooleanGreaterOrEqualToOne() override {} void Post() override; diff --git a/ortools/constraint_solver/expr_cst.cc b/ortools/constraint_solver/expr_cst.cc index f01c2b3e73..88bf5f0533 100644 --- a/ortools/constraint_solver/expr_cst.cc +++ b/ortools/constraint_solver/expr_cst.cc @@ -46,7 +46,7 @@ namespace operations_research { namespace { class EqualityExprCst : public Constraint { public: - EqualityExprCst(Solver* const s, IntExpr* const e, int64_t v); + EqualityExprCst(Solver* s, IntExpr* e, int64_t v); ~EqualityExprCst() override {} void Post() override; void InitialPropagate() override; @@ -121,7 +121,7 @@ Constraint* Solver::MakeEquality(IntExpr* const e, int v) { namespace { class GreaterEqExprCst : public Constraint { public: - GreaterEqExprCst(Solver* const s, IntExpr* const e, int64_t v); + GreaterEqExprCst(Solver* s, IntExpr* e, int64_t v); ~GreaterEqExprCst() override {} void Post() override; void InitialPropagate() override; @@ -219,7 +219,7 @@ Constraint* Solver::MakeGreater(IntExpr* const e, int v) { namespace { class LessEqExprCst : public Constraint { public: - LessEqExprCst(Solver* const s, IntExpr* const e, int64_t v); + LessEqExprCst(Solver* s, IntExpr* e, int64_t v); ~LessEqExprCst() override {} void Post() override; void InitialPropagate() override; @@ -316,7 +316,7 @@ Constraint* Solver::MakeLess(IntExpr* const e, int v) { namespace { class DiffCst : public Constraint { public: - DiffCst(Solver* const s, IntVar* const var, int64_t value); + DiffCst(Solver* s, IntVar* var, int64_t value); ~DiffCst() override {} void Post() override {} void InitialPropagate() override; diff --git a/ortools/constraint_solver/expressions.cc b/ortools/constraint_solver/expressions.cc index 8a4045683b..b0123ee1db 100644 --- a/ortools/constraint_solver/expressions.cc +++ b/ortools/constraint_solver/expressions.cc @@ -402,7 +402,7 @@ class DomainIntVar : public IntVar { virtual IntVar* GetOrMakeValueWatcher(int64_t value) = 0; - virtual void SetValueWatcher(IntVar* const boolvar, int64_t value) = 0; + virtual void SetValueWatcher(IntVar* boolvar, int64_t value) = 0; }; // This class monitors the domain of the variable and updates the @@ -886,7 +886,7 @@ class DomainIntVar : public IntVar { virtual IntVar* GetOrMakeUpperBoundWatcher(int64_t value) = 0; - virtual void SetUpperBoundWatcher(IntVar* const boolvar, int64_t value) = 0; + virtual void SetUpperBoundWatcher(IntVar* boolvar, int64_t value) = 0; }; // This class watches the bounds of the variable and updates the @@ -1330,9 +1330,8 @@ class DomainIntVar : public IntVar { }; // ----- Main Class ----- - DomainIntVar(Solver* const s, int64_t vmin, int64_t vmax, - const std::string& name); - DomainIntVar(Solver* const s, const std::vector& sorted_values, + DomainIntVar(Solver* s, int64_t vmin, int64_t vmax, const std::string& name); + DomainIntVar(Solver* s, const std::vector& sorted_values, const std::string& name); ~DomainIntVar() override; @@ -2899,7 +2898,7 @@ class SubCstIntVar : public IntVar { const int64_t cst_; }; - SubCstIntVar(Solver* const s, IntVar* v, int64_t c); + SubCstIntVar(Solver* s, IntVar* v, int64_t c); ~SubCstIntVar() override; int64_t Min() const override; @@ -3033,7 +3032,7 @@ class OppIntVar : public IntVar { int64_t Value() const override { return -iterator_->Value(); } }; - OppIntVar(Solver* const s, IntVar* v); + OppIntVar(Solver* s, IntVar* v); ~OppIntVar() override; int64_t Min() const override; @@ -3209,7 +3208,7 @@ class TimesPosCstIntVar : public TimesCstIntVar { const int64_t cst_; }; - TimesPosCstIntVar(Solver* const s, IntVar* v, int64_t c); + TimesPosCstIntVar(Solver* s, IntVar* v, int64_t c); ~TimesPosCstIntVar() override; int64_t Min() const override; @@ -3324,7 +3323,7 @@ class TimesPosCstBoolVar : public TimesCstIntVar { const int64_t cst_; }; - TimesPosCstBoolVar(Solver* const s, BooleanVar* v, int64_t c); + TimesPosCstBoolVar(Solver* s, BooleanVar* v, int64_t c); ~TimesPosCstBoolVar() override; int64_t Min() const override; @@ -3475,7 +3474,7 @@ class TimesNegCstIntVar : public TimesCstIntVar { const int64_t cst_; }; - TimesNegCstIntVar(Solver* const s, IntVar* v, int64_t c); + TimesNegCstIntVar(Solver* s, IntVar* v, int64_t c); ~TimesNegCstIntVar() override; int64_t Min() const override; diff --git a/ortools/constraint_solver/graph_constraints.cc b/ortools/constraint_solver/graph_constraints.cc index 51f86ebc71..8ec337b0a9 100644 --- a/ortools/constraint_solver/graph_constraints.cc +++ b/ortools/constraint_solver/graph_constraints.cc @@ -48,7 +48,7 @@ namespace operations_research { namespace { class NoCycle : public Constraint { public: - NoCycle(Solver* const s, const std::vector& nexts, + NoCycle(Solver* s, const std::vector& nexts, const std::vector& active, Solver::IndexFilter1 sink_handler, bool assume_paths); ~NoCycle() override {} @@ -649,7 +649,7 @@ Constraint* Solver::MakeSubCircuit(const std::vector& nexts) { namespace { class BasePathCumul : public Constraint { public: - BasePathCumul(Solver* const s, const std::vector& nexts, + BasePathCumul(Solver* s, const std::vector& nexts, const std::vector& active, const std::vector& cumuls); ~BasePathCumul() override {} @@ -1134,7 +1134,7 @@ class DelayedPathCumul : public Constraint { class IndexEvaluator2PathCumul : public BasePathCumul { public: - IndexEvaluator2PathCumul(Solver* const s, const std::vector& nexts, + IndexEvaluator2PathCumul(Solver* s, const std::vector& nexts, const std::vector& active, const std::vector& cumuls, Solver::IndexEvaluator2 transit_evaluator); @@ -1195,8 +1195,7 @@ bool IndexEvaluator2PathCumul::AcceptLink(int i, int j) const { class IndexEvaluator2SlackPathCumul : public BasePathCumul { public: - IndexEvaluator2SlackPathCumul(Solver* const s, - const std::vector& nexts, + IndexEvaluator2SlackPathCumul(Solver* s, const std::vector& nexts, const std::vector& active, const std::vector& cumuls, const std::vector& slacks, diff --git a/ortools/constraint_solver/interval.cc b/ortools/constraint_solver/interval.cc index 6e461bcd57..04e666d3dc 100644 --- a/ortools/constraint_solver/interval.cc +++ b/ortools/constraint_solver/interval.cc @@ -43,7 +43,7 @@ IntExpr* BuildEndExpr(IntervalVar* var); IntExpr* BuildSafeStartExpr(IntervalVar* var, int64_t unperformed_value); IntExpr* BuildSafeDurationExpr(IntervalVar* var, int64_t unperformed_value); IntExpr* BuildSafeEndExpr(IntervalVar* var, int64_t unperformed_value); -void LinkVarExpr(Solver* const s, IntExpr* const expr, IntVar* const var); +void LinkVarExpr(Solver* s, IntExpr* expr, IntVar* var); // It's good to have the two extreme values being symmetrical around zero: it // makes mirroring easier. @@ -275,7 +275,7 @@ class AlwaysPerformedIntervalVarWrapper : public IntervalVar { IntExpr* SafeEndExpr(int64_t unperformed_value) override { return EndExpr(); } protected: - IntervalVar* const underlying() const { return t_; } + IntervalVar* underlying() const { return t_; } bool MayUnderlyingBePerformed() const { return underlying()->MayBePerformed(); } @@ -747,11 +747,11 @@ class PerformedVar : public BooleanVar { class FixedDurationIntervalVar : public BaseIntervalVar { public: - FixedDurationIntervalVar(Solver* const s, int64_t start_min, - int64_t start_max, int64_t duration, bool optional, + FixedDurationIntervalVar(Solver* s, int64_t start_min, int64_t start_max, + int64_t duration, bool optional, const std::string& name); // Unperformed interval. - FixedDurationIntervalVar(Solver* const s, const std::string& name); + FixedDurationIntervalVar(Solver* s, const std::string& name); ~FixedDurationIntervalVar() override {} int64_t StartMin() const override; @@ -988,11 +988,11 @@ std::string FixedDurationIntervalVar::DebugString() const { class FixedDurationPerformedIntervalVar : public BaseIntervalVar { public: - FixedDurationPerformedIntervalVar(Solver* const s, int64_t start_min, + FixedDurationPerformedIntervalVar(Solver* s, int64_t start_min, int64_t start_max, int64_t duration, const std::string& name); // Unperformed interval. - FixedDurationPerformedIntervalVar(Solver* const s, const std::string& name); + FixedDurationPerformedIntervalVar(Solver* s, const std::string& name); ~FixedDurationPerformedIntervalVar() override {} int64_t StartMin() const override; @@ -1185,8 +1185,8 @@ std::string FixedDurationPerformedIntervalVar::DebugString() const { class StartVarPerformedIntervalVar : public IntervalVar { public: - StartVarPerformedIntervalVar(Solver* const s, IntVar* const var, - int64_t duration, const std::string& name); + StartVarPerformedIntervalVar(Solver* s, IntVar* var, int64_t duration, + const std::string& name); ~StartVarPerformedIntervalVar() override {} int64_t StartMin() const override; @@ -1351,8 +1351,8 @@ std::string StartVarPerformedIntervalVar::DebugString() const { class StartVarIntervalVar : public BaseIntervalVar { public: - StartVarIntervalVar(Solver* const s, IntVar* const start, int64_t duration, - IntVar* const performed, const std::string& name); + StartVarIntervalVar(Solver* s, IntVar* start, int64_t duration, + IntVar* performed, const std::string& name); ~StartVarIntervalVar() override {} int64_t StartMin() const override; @@ -1626,7 +1626,7 @@ class LinkStartVarIntervalVar : public Constraint { class FixedInterval : public IntervalVar { public: - FixedInterval(Solver* const s, int64_t start, int64_t duration, + FixedInterval(Solver* s, int64_t start, int64_t duration, const std::string& name); ~FixedInterval() override {} diff --git a/ortools/constraint_solver/local_search.cc b/ortools/constraint_solver/local_search.cc index 2dae6999e4..c748129a13 100644 --- a/ortools/constraint_solver/local_search.cc +++ b/ortools/constraint_solver/local_search.cc @@ -63,16 +63,15 @@ namespace operations_research { // search. // Returns true if a local optimum has been reached and cannot be improved. -bool LocalOptimumReached(Search* const search); +bool LocalOptimumReached(Search* search); // Returns true if the search accepts the delta (actually checking this by // calling AcceptDelta on the monitors of the search). -bool AcceptDelta(Search* const search, Assignment* delta, - Assignment* deltadelta); +bool AcceptDelta(Search* search, Assignment* delta, Assignment* deltadelta); // Notifies the search that a neighbor has been accepted by local search. -void AcceptNeighbor(Search* const search); -void AcceptUncheckedNeighbor(Search* const search); +void AcceptNeighbor(Search* search); +void AcceptUncheckedNeighbor(Search* search); // ----- Base operator class for operators manipulating IntVars ----- @@ -4376,14 +4375,13 @@ void LocalSearchFilterManager::Synchronize(const Assignment* assignment, class FindOneNeighbor : public DecisionBuilder { public: - FindOneNeighbor(Assignment* const assignment, IntVar* objective, - SolutionPool* const pool, - LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, - const RegularLimit* const limit, + FindOneNeighbor(Assignment* assignment, IntVar* objective, SolutionPool* pool, + LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, + const RegularLimit* limit, LocalSearchFilterManager* filter_manager); ~FindOneNeighbor() override {} - Decision* Next(Solver* const solver) override; + Decision* Next(Solver* solver) override; std::string DebugString() const override { return "FindOneNeighbor"; } private: @@ -4737,9 +4735,7 @@ class LocalSearchPhaseParameters : public BaseObject { return sub_decision_builder_; } RegularLimit* limit() const { return limit_; } - LocalSearchFilterManager* const filter_manager() const { - return filter_manager_; - } + LocalSearchFilterManager* filter_manager() const { return filter_manager_; } private: IntVar* const objective_; @@ -4816,12 +4812,12 @@ class NestedSolveDecision : public Decision { // This enum is used internally to tag states in the local search tree. enum StateType { DECISION_PENDING, DECISION_FAILED, DECISION_FOUND }; - NestedSolveDecision(DecisionBuilder* const db, bool restore, + NestedSolveDecision(DecisionBuilder* db, bool restore, const std::vector& monitors); - NestedSolveDecision(DecisionBuilder* const db, bool restore); + NestedSolveDecision(DecisionBuilder* db, bool restore); ~NestedSolveDecision() override {} - void Apply(Solver* const solver) override; - void Refute(Solver* const solver) override; + void Apply(Solver* solver) override; + void Refute(Solver* solver) override; std::string DebugString() const override { return "NestedSolveDecision"; } int state() const { return state_; } @@ -4878,36 +4874,32 @@ void NestedSolveDecision::Refute(Solver* const solver) {} class LocalSearch : public DecisionBuilder { public: - LocalSearch(Assignment* const assignment, IntVar* objective, - SolutionPool* const pool, LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, - RegularLimit* const limit, + LocalSearch(Assignment* assignment, IntVar* objective, SolutionPool* pool, + LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit, LocalSearchFilterManager* filter_manager); // TODO(user): find a way to not have to pass vars here: redundant with // variables in operators LocalSearch(const std::vector& vars, IntVar* objective, - SolutionPool* const pool, DecisionBuilder* const first_solution, - LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, - RegularLimit* const limit, + SolutionPool* pool, DecisionBuilder* first_solution, + LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit, LocalSearchFilterManager* filter_manager); LocalSearch(const std::vector& vars, IntVar* objective, - SolutionPool* const pool, DecisionBuilder* const first_solution, - DecisionBuilder* const first_solution_sub_decision_builder, - LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, - RegularLimit* const limit, + SolutionPool* pool, DecisionBuilder* first_solution, + DecisionBuilder* first_solution_sub_decision_builder, + LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit, LocalSearchFilterManager* filter_manager); LocalSearch(const std::vector& vars, IntVar* objective, - SolutionPool* const pool, DecisionBuilder* const first_solution, - LocalSearchOperator* const ls_operator, - DecisionBuilder* const sub_decision_builder, - RegularLimit* const limit, + SolutionPool* pool, DecisionBuilder* first_solution, + LocalSearchOperator* ls_operator, + DecisionBuilder* sub_decision_builder, RegularLimit* limit, LocalSearchFilterManager* filter_manager); ~LocalSearch() override; - Decision* Next(Solver* const solver) override; + Decision* Next(Solver* solver) override; std::string DebugString() const override { return "LocalSearch"; } - void Accept(ModelVisitor* const visitor) const override; + void Accept(ModelVisitor* visitor) const override; protected: void PushFirstSolutionDecision(DecisionBuilder* first_solution); diff --git a/ortools/constraint_solver/pack.cc b/ortools/constraint_solver/pack.cc index 0cbe1a6db4..0fb30f1424 100644 --- a/ortools/constraint_solver/pack.cc +++ b/ortools/constraint_solver/pack.cc @@ -50,7 +50,7 @@ class Dimension : public BaseObject { const std::vector& unassigned) = 0; virtual void EndPropagate() = 0; std::string DebugString() const override { return "Dimension"; } - virtual void Accept(ModelVisitor* const visitor) const = 0; + virtual void Accept(ModelVisitor* visitor) const = 0; Solver* solver() const { return solver_; } diff --git a/ortools/constraint_solver/python/constraint_solver.i b/ortools/constraint_solver/python/constraint_solver.i index f740e08963..1cf8fe1d3f 100644 --- a/ortools/constraint_solver/python/constraint_solver.i +++ b/ortools/constraint_solver/python/constraint_solver.i @@ -927,7 +927,7 @@ namespace operations_research { // See the occurrences of "DecisionBuilder*" in this file. %unignore Solver::Try(const std::vector&); %unignore Solver::Compose(const std::vector&); -%rename (SolveOnce) Solver::MakeSolveOnce(DecisionBuilder* const, +%rename (SolveOnce) Solver::MakeSolveOnce(DecisionBuilder*, const std::vector&); %rename (Phase) Solver::MakePhase(const std::vector&, IntVarStrategy, IntValueStrategy); diff --git a/ortools/constraint_solver/python/constraint_solver_helpers.i b/ortools/constraint_solver/python/constraint_solver_helpers.i index dc3941034e..f98f9a8c83 100644 --- a/ortools/constraint_solver/python/constraint_solver_helpers.i +++ b/ortools/constraint_solver/python/constraint_solver_helpers.i @@ -25,7 +25,9 @@ // solver and the routing library. %{ template<> -PyObject* PyObjFrom(const int64_t& c) { return PyLong_FromLongLong(c); } +PyObject* PyObjFrom(const int64_t& c) { + return PyLong_FromLongLong(c); +} %} // Conversion of IntExpr* and IntVar* are a bit special because of the two diff --git a/ortools/constraint_solver/range_cst.cc b/ortools/constraint_solver/range_cst.cc index 364ed4ad5a..2776ced8d7 100644 --- a/ortools/constraint_solver/range_cst.cc +++ b/ortools/constraint_solver/range_cst.cc @@ -71,7 +71,7 @@ class RangeEquality : public Constraint { class RangeLessOrEqual : public Constraint { public: - RangeLessOrEqual(Solver* const s, IntExpr* const l, IntExpr* const r); + RangeLessOrEqual(Solver* s, IntExpr* l, IntExpr* r); ~RangeLessOrEqual() override {} void Post() override; void InitialPropagate() override; @@ -120,7 +120,7 @@ std::string RangeLessOrEqual::DebugString() const { class RangeLess : public Constraint { public: - RangeLess(Solver* const s, IntExpr* const l, IntExpr* const r); + RangeLess(Solver* s, IntExpr* l, IntExpr* r); ~RangeLess() override {} void Post() override; void InitialPropagate() override; @@ -168,7 +168,7 @@ std::string RangeLess::DebugString() const { class DiffVar : public Constraint { public: - DiffVar(Solver* const s, IntVar* const l, IntVar* const r); + DiffVar(Solver* s, IntVar* l, IntVar* r); ~DiffVar() override {} void Post() override; void InitialPropagate() override; @@ -233,7 +233,7 @@ std::string DiffVar::DebugString() const { } // --------------------- Reified API ------------------- -// A reified API transforms an constraint into a status variables. +// A reified API transforms a constraint into a status variables. // For example x == y is transformed into IsEqual(x, y, b) where // b is a boolean variable which is true if and only if x is equal to b. diff --git a/ortools/constraint_solver/resource.cc b/ortools/constraint_solver/resource.cc index 02d0e87487..dc4607a844 100644 --- a/ortools/constraint_solver/resource.cc +++ b/ortools/constraint_solver/resource.cc @@ -449,7 +449,7 @@ class CumulativeLambdaThetaTree : public MonoidOperationTree { // resource constraint. class NotLast { public: - NotLast(Solver* const solver, const std::vector& intervals, + NotLast(Solver* solver, const std::vector& intervals, bool mirror, bool strict); ~NotLast() { gtl::STLDeleteElements(&by_start_min_); } @@ -551,7 +551,7 @@ bool NotLast::Propagate() { // which is why they are grouped together. class EdgeFinderAndDetectablePrecedences { public: - EdgeFinderAndDetectablePrecedences(Solver* const solver, + EdgeFinderAndDetectablePrecedences(Solver* solver, const std::vector& intervals, bool mirror, bool strict); ~EdgeFinderAndDetectablePrecedences() { @@ -1379,7 +1379,7 @@ class UpdatesForADemand { explicit UpdatesForADemand(int size) : updates_(size, 0), up_to_date_(false) {} - const int64_t Update(int index) { return updates_[index]; } + int64_t Update(int index) { return updates_[index]; } void Reset() { up_to_date_ = false; } void SetUpdate(int index, int64_t update) { DCHECK(!up_to_date_); diff --git a/ortools/constraint_solver/routing.cc b/ortools/constraint_solver/routing.cc index 2f03227a80..0d5411c4c4 100644 --- a/ortools/constraint_solver/routing.cc +++ b/ortools/constraint_solver/routing.cc @@ -3683,7 +3683,7 @@ void RoutingModel::SetAssignmentFromOtherModelAssignment( // A bipartite graph is created with left nodes representing the nodes of the // routing problem and right nodes representing possible node successors; an // arc between a left node l and a right node r is created if r can be the -// node folowing l in a route (Next(l) = r); the cost of the arc is the transit +// node following l in a route (Next(l) = r); the cost of the arc is the transit // cost between l and r in the routing problem. // This is a lower bound given the solution to assignment problem does not // necessarily produce a (set of) closed route(s) from a starting node to an @@ -6701,7 +6701,7 @@ namespace { // routing. class LightRangeLessOrEqual : public Constraint { public: - LightRangeLessOrEqual(Solver* const s, IntExpr* const l, IntExpr* const r); + LightRangeLessOrEqual(Solver* s, IntExpr* l, IntExpr* r); ~LightRangeLessOrEqual() override {} void Post() override; void InitialPropagate() override; diff --git a/ortools/constraint_solver/routing.h b/ortools/constraint_solver/routing.h index 1755c0ef66..79393b6b6b 100644 --- a/ortools/constraint_solver/routing.h +++ b/ortools/constraint_solver/routing.h @@ -1149,7 +1149,7 @@ class RoutingModel { /// vehicle routing problem. void AddLocalSearchOperator(LocalSearchOperator* ls_operator); /// Adds a search monitor to the search used to solve the routing model. - void AddSearchMonitor(SearchMonitor* const monitor); + void AddSearchMonitor(SearchMonitor* monitor); /// Adds a callback called each time a solution is found during the search. /// This is a shortcut to creating a monitor to call the callback on /// AtSolution() and adding it with AddSearchMonitor. @@ -1296,13 +1296,12 @@ class RoutingModel { /// it is advisible to call solver()->CheckSolution() afterwards. bool RoutesToAssignment(const std::vector>& routes, bool ignore_inactive_indices, bool close_routes, - Assignment* const assignment) const; + Assignment* assignment) const; /// Converts the solution in the given assignment to routes for all vehicles. /// Expects that assignment contains a valid solution (i.e. routes for all /// vehicles end with an end index for that vehicle). - void AssignmentToRoutes( - const Assignment& assignment, - std::vector>* const routes) const; + void AssignmentToRoutes(const Assignment& assignment, + std::vector>* routes) const; /// Converts the solution in the given assignment to routes for all vehicles. /// If the returned vector is route_indices, route_indices[i][j] is the index /// for jth location visited on route i. Note that contrary to @@ -1334,8 +1333,8 @@ class RoutingModel { /// (instead, the method returns nullptr). Assignment* CompactAndCheckAssignment(const Assignment& assignment) const; /// Adds an extra variable to the vehicle routing assignment. - void AddToAssignment(IntVar* const var); - void AddIntervalToAssignment(IntervalVar* const interval); + void AddToAssignment(IntVar* var); + void AddIntervalToAssignment(IntervalVar* interval); /// For every dimension in the model with an optimizer in /// local/global_dimension_optimizers_, this method tries to pack the cumul /// values of the dimension, such that: @@ -1416,7 +1415,7 @@ class RoutingModel { #endif class NodeNeighborsByCostClass { public: - NodeNeighborsByCostClass() = default; + NodeNeighborsByCostClass() {} /// Computes num_neighbors neighbors of all nodes for every cost class in /// routing_model. @@ -2584,7 +2583,7 @@ class GlobalVehicleBreaksConstraint : public Constraint { before_start_(before_start), after_start_(after_start) {} explicit TaskTranslator(IntervalVar* interval) : interval_(interval) {} - TaskTranslator() = default; + TaskTranslator() {} void SetStartMin(int64_t value) { if (start_ != nullptr) { @@ -2641,7 +2640,7 @@ class GlobalVehicleBreaksConstraint : public Constraint { class TypeRegulationsChecker { public: explicit TypeRegulationsChecker(const RoutingModel& model); - virtual ~TypeRegulationsChecker() = default; + virtual ~TypeRegulationsChecker() {} bool CheckVehicle(int vehicle, const std::function& next_accessor); @@ -2702,7 +2701,7 @@ class TypeIncompatibilityChecker : public TypeRegulationsChecker { public: TypeIncompatibilityChecker(const RoutingModel& model, bool check_hard_incompatibilities); - ~TypeIncompatibilityChecker() override = default; + ~TypeIncompatibilityChecker() override {} private: bool HasRegulationsToCheck() const override; @@ -2718,7 +2717,7 @@ class TypeRequirementChecker : public TypeRegulationsChecker { public: explicit TypeRequirementChecker(const RoutingModel& model) : TypeRegulationsChecker(model) {} - ~TypeRequirementChecker() override = default; + ~TypeRequirementChecker() override {} private: bool HasRegulationsToCheck() const override; diff --git a/ortools/constraint_solver/routing_index_manager.h b/ortools/constraint_solver/routing_index_manager.h index 7d2ca2f747..e92469898a 100644 --- a/ortools/constraint_solver/routing_index_manager.h +++ b/ortools/constraint_solver/routing_index_manager.h @@ -62,7 +62,6 @@ class RoutingIndexManager { RoutingIndexManager( int num_nodes, int num_vehicles, const std::vector >& starts_ends); - ~RoutingIndexManager() {} // Returns the number of nodes in the manager. int num_nodes() const { return num_nodes_; } diff --git a/ortools/constraint_solver/routing_lp_scheduling.h b/ortools/constraint_solver/routing_lp_scheduling.h index fc46625093..999ff22f8a 100644 --- a/ortools/constraint_solver/routing_lp_scheduling.h +++ b/ortools/constraint_solver/routing_lp_scheduling.h @@ -660,7 +660,7 @@ class DimensionCumulOptimizerCore { int64_t* transit_cost, int64_t* cost_offset = nullptr, bool reuse_previous_model_if_possible = true, bool clear_lp = false, bool clear_solution_constraints = true, - absl::Duration* const solve_duration = nullptr); + absl::Duration* solve_duration = nullptr); std::vector OptimizeSingleRouteWithResources( int vehicle, const std::function& next_accessor, @@ -712,7 +712,7 @@ class DimensionCumulOptimizerCore { RoutingLinearSolverWrapper* solver, std::vector* cumul_values, int64_t* cost, int64_t* transit_cost, int64_t* cumul_offset, - int64_t* const cost_offset); + int64_t* cost_offset); // Computes the minimum/maximum of cumuls for nodes on "route", and sets them // in current_route_[min|max]_cumuls_ respectively. diff --git a/ortools/constraint_solver/routing_neighborhoods.h b/ortools/constraint_solver/routing_neighborhoods.h index 4971836319..094a3af424 100644 --- a/ortools/constraint_solver/routing_neighborhoods.h +++ b/ortools/constraint_solver/routing_neighborhoods.h @@ -123,7 +123,7 @@ class SwapActiveToShortestPathOperator : public PathOperator { std::function start_empty_path_class, std::vector> alternative_sets, RoutingTransitCallback2 arc_evaluator); - ~SwapActiveToShortestPathOperator() override = default; + ~SwapActiveToShortestPathOperator() override {} bool MakeNeighbor() override; std::string DebugString() const override { return "SwapActiveToShortestPath"; diff --git a/ortools/constraint_solver/routing_search.h b/ortools/constraint_solver/routing_search.h index 36c8e477ff..962d5306b8 100644 --- a/ortools/constraint_solver/routing_search.h +++ b/ortools/constraint_solver/routing_search.h @@ -177,7 +177,7 @@ class IntVarFilteredHeuristic { const std::vector& secondary_vars, LocalSearchFilterManager* filter_manager); - virtual ~IntVarFilteredHeuristic() = default; + virtual ~IntVarFilteredHeuristic() {} /// Builds a solution. Returns the resulting assignment if a solution was /// found, and nullptr otherwise. @@ -274,7 +274,7 @@ class RoutingFilteredHeuristic : public IntVarFilteredHeuristic { std::function stop_search, LocalSearchFilterManager* filter_manager, bool omit_secondary_vars = true); - ~RoutingFilteredHeuristic() override = default; + ~RoutingFilteredHeuristic() override {} /// Builds a solution starting from the routes formed by the next accessor. const Assignment* BuildSolutionFromRoutes( const std::function& next_accessor); @@ -320,7 +320,7 @@ class CheapestInsertionFilteredHeuristic : public RoutingFilteredHeuristic { std::function evaluator, std::function penalty_evaluator, LocalSearchFilterManager* filter_manager); - ~CheapestInsertionFilteredHeuristic() override = default; + ~CheapestInsertionFilteredHeuristic() override {} protected: struct NodeInsertion { @@ -439,7 +439,7 @@ class GlobalCheapestInsertionFilteredHeuristic std::function penalty_evaluator, LocalSearchFilterManager* filter_manager, GlobalCheapestInsertionParameters parameters); - ~GlobalCheapestInsertionFilteredHeuristic() override = default; + ~GlobalCheapestInsertionFilteredHeuristic() override {} bool BuildSolutionInternal() override; std::string DebugString() const override { return "GlobalCheapestInsertionFilteredHeuristic"; @@ -571,7 +571,7 @@ class GlobalCheapestInsertionFilteredHeuristic /// NOTE: Assumes (DCHECKS) that /// UseEmptyVehicleTypeCuratorForVehicle(pair_entry.vehicle()) is true. bool InsertPairEntryUsingEmptyVehicleTypeCurator( - const absl::flat_hash_set& pair_indices, PairEntry* const pair_entry, + const absl::flat_hash_set& pair_indices, PairEntry* pair_entry, AdjustablePriorityQueue* priority_queue, std::vector* pickup_to_entries, std::vector* delivery_to_entries); @@ -723,7 +723,7 @@ class GlobalCheapestInsertionFilteredHeuristic /// Updates the pair entry's value and rearranges the priority queue /// accordingly. void UpdatePairEntry( - PairEntry* const pair_entry, + PairEntry* pair_entry, AdjustablePriorityQueue* priority_queue) const; /// Computes and returns the insertion value of inserting 'pickup' and /// 'delivery' respectively after 'pickup_insert_after' and @@ -975,7 +975,7 @@ class InsertionSequenceContainer { // Generates insertion positions respecting structural constraints. class InsertionSequenceGenerator { public: - InsertionSequenceGenerator() = default; + InsertionSequenceGenerator() {} /// Generates insertions for a pickup and delivery pair in a multitour path: /// - a series of pickups may only start if all the deliveries of previous @@ -1036,7 +1036,7 @@ class LocalCheapestInsertionFilteredHeuristic std::function evaluator, RoutingSearchParameters::PairInsertionStrategy pair_insertion_strategy, LocalSearchFilterManager* filter_manager); - ~LocalCheapestInsertionFilteredHeuristic() override = default; + ~LocalCheapestInsertionFilteredHeuristic() override {} bool BuildSolutionInternal() override; std::string DebugString() const override { return "LocalCheapestInsertionFilteredHeuristic"; @@ -1098,7 +1098,7 @@ class CheapestAdditionFilteredHeuristic : public RoutingFilteredHeuristic { CheapestAdditionFilteredHeuristic(RoutingModel* model, std::function stop_search, LocalSearchFilterManager* filter_manager); - ~CheapestAdditionFilteredHeuristic() override = default; + ~CheapestAdditionFilteredHeuristic() override {} bool BuildSolutionInternal() override; private: @@ -1144,7 +1144,7 @@ class EvaluatorCheapestAdditionFilteredHeuristic RoutingModel* model, std::function stop_search, std::function evaluator, LocalSearchFilterManager* filter_manager); - ~EvaluatorCheapestAdditionFilteredHeuristic() override = default; + ~EvaluatorCheapestAdditionFilteredHeuristic() override {} std::string DebugString() const override { return "EvaluatorCheapestAdditionFilteredHeuristic"; } @@ -1168,7 +1168,7 @@ class ComparatorCheapestAdditionFilteredHeuristic RoutingModel* model, std::function stop_search, Solver::VariableValueComparator comparator, LocalSearchFilterManager* filter_manager); - ~ComparatorCheapestAdditionFilteredHeuristic() override = default; + ~ComparatorCheapestAdditionFilteredHeuristic() override {} std::string DebugString() const override { return "ComparatorCheapestAdditionFilteredHeuristic"; } @@ -1301,7 +1301,7 @@ class SequentialSavingsFilteredHeuristic : public SavingsFilteredHeuristic { LocalSearchFilterManager* filter_manager) : SavingsFilteredHeuristic(model, std::move(stop_search), parameters, filter_manager) {} - ~SequentialSavingsFilteredHeuristic() override = default; + ~SequentialSavingsFilteredHeuristic() override {} std::string DebugString() const override { return "SequentialSavingsFilteredHeuristic"; } @@ -1323,7 +1323,7 @@ class ParallelSavingsFilteredHeuristic : public SavingsFilteredHeuristic { LocalSearchFilterManager* filter_manager) : SavingsFilteredHeuristic(model, std::move(stop_search), parameters, filter_manager) {} - ~ParallelSavingsFilteredHeuristic() override = default; + ~ParallelSavingsFilteredHeuristic() override {} std::string DebugString() const override { return "ParallelSavingsFilteredHeuristic"; } @@ -1369,7 +1369,7 @@ class ChristofidesFilteredHeuristic : public RoutingFilteredHeuristic { std::function stop_search, LocalSearchFilterManager* filter_manager, bool use_minimum_matching); - ~ChristofidesFilteredHeuristic() override = default; + ~ChristofidesFilteredHeuristic() override {} bool BuildSolutionInternal() override; std::string DebugString() const override { return "ChristofidesFilteredHeuristic"; diff --git a/ortools/constraint_solver/samples/vrp_pickup_delivery_fifo.cc b/ortools/constraint_solver/samples/vrp_pickup_delivery_fifo.cc index 41d36ded1f..74a7874868 100644 --- a/ortools/constraint_solver/samples/vrp_pickup_delivery_fifo.cc +++ b/ortools/constraint_solver/samples/vrp_pickup_delivery_fifo.cc @@ -100,7 +100,7 @@ void PrintSolution(const DataModel& data, const RoutingIndexManager& manager, for (int vehicle_id = 0; vehicle_id < data.num_vehicles; ++vehicle_id) { int64_t index = routing.Start(vehicle_id); LOG(INFO) << "Route for Vehicle " << vehicle_id << ":"; - int64_t route_distance =0; + int64_t route_distance = 0; std::stringstream route; while (!routing.IsEnd(index)) { route << manager.IndexToNode(index).value() << " -> "; diff --git a/ortools/constraint_solver/samples/vrp_solution_callback.cc b/ortools/constraint_solver/samples/vrp_solution_callback.cc index 054be6b91b..7895de30c6 100644 --- a/ortools/constraint_solver/samples/vrp_solution_callback.cc +++ b/ortools/constraint_solver/samples/vrp_solution_callback.cc @@ -13,7 +13,6 @@ // [START program] // [START import] -#include #include #include #include diff --git a/ortools/constraint_solver/search.cc b/ortools/constraint_solver/search.cc index 718ba27d6d..972b917b2f 100644 --- a/ortools/constraint_solver/search.cc +++ b/ortools/constraint_solver/search.cc @@ -488,10 +488,10 @@ class CompositeDecisionBuilder : public DecisionBuilder { CompositeDecisionBuilder(); explicit CompositeDecisionBuilder(const std::vector& dbs); ~CompositeDecisionBuilder() override; - void Add(DecisionBuilder* const db); - void AppendMonitors(Solver* const solver, - std::vector* const monitors) override; - void Accept(ModelVisitor* const visitor) const override; + void Add(DecisionBuilder* db); + void AppendMonitors(Solver* solver, + std::vector* monitors) override; + void Accept(ModelVisitor* visitor) const override; protected: std::vector builders_; @@ -536,7 +536,7 @@ class ComposeDecisionBuilder : public CompositeDecisionBuilder { ComposeDecisionBuilder(); explicit ComposeDecisionBuilder(const std::vector& dbs); ~ComposeDecisionBuilder() override; - Decision* Next(Solver* const s) override; + Decision* Next(Solver* s) override; std::string DebugString() const override; private: @@ -640,10 +640,10 @@ class TryDecisionBuilder; class TryDecision : public Decision { public: - explicit TryDecision(TryDecisionBuilder* const try_builder); + explicit TryDecision(TryDecisionBuilder* try_builder); ~TryDecision() override; - void Apply(Solver* const solver) override; - void Refute(Solver* const solver) override; + void Apply(Solver* solver) override; + void Refute(Solver* solver) override; std::string DebugString() const override { return "TryDecision"; } private: @@ -655,9 +655,9 @@ class TryDecisionBuilder : public CompositeDecisionBuilder { TryDecisionBuilder(); explicit TryDecisionBuilder(const std::vector& dbs); ~TryDecisionBuilder() override; - Decision* Next(Solver* const solver) override; + Decision* Next(Solver* solver) override; std::string DebugString() const override; - void AdvanceToNextBuilder(Solver* const solver); + void AdvanceToNextBuilder(Solver* solver); private: TryDecision try_decision_; @@ -989,8 +989,8 @@ class HighestRegretSelectorOnMin : public BaseObject { iterators_[i] = vars[i]->MakeDomainIterator(true); } } - ~HighestRegretSelectorOnMin() override {} - int64_t Choose(Solver* const s, const std::vector& vars, + ~HighestRegretSelectorOnMin() override{}; + int64_t Choose(Solver* s, const std::vector& vars, int64_t first_unbound, int64_t last_unbound); std::string DebugString() const override { return "MaxRegretSelector"; } @@ -1047,8 +1047,8 @@ class CheapestVarSelector : public BaseObject { public: explicit CheapestVarSelector(std::function var_evaluator) : var_evaluator_(std::move(var_evaluator)) {} - ~CheapestVarSelector() override {} - int64_t Choose(Solver* const s, const std::vector& vars, + ~CheapestVarSelector() override{}; + int64_t Choose(Solver* s, const std::vector& vars, int64_t first_unbound, int64_t last_unbound); std::string DebugString() const override { return "CheapestVarSelector"; } @@ -1080,8 +1080,8 @@ int64_t CheapestVarSelector::Choose(Solver* const s, class PathSelector : public BaseObject { public: PathSelector() : first_(std::numeric_limits::max()) {} - ~PathSelector() override {} - int64_t Choose(Solver* const s, const std::vector& vars, + ~PathSelector() override{}; + int64_t Choose(Solver* s, const std::vector& vars, int64_t first_unbound, int64_t last_unbound); std::string DebugString() const override { return "ChooseNextOnPath"; } @@ -1551,10 +1551,10 @@ std::string StaticEvaluatorSelector::DebugString() const { class AssignOneVariableValue : public Decision { public: - AssignOneVariableValue(IntVar* const v, int64_t val); + AssignOneVariableValue(IntVar* v, int64_t val); ~AssignOneVariableValue() override {} - void Apply(Solver* const s) override; - void Refute(Solver* const s) override; + void Apply(Solver* s) override; + void Refute(Solver* s) override; std::string DebugString() const override; void Accept(DecisionVisitor* const visitor) const override { visitor->VisitSetVariableValue(var_, value_); @@ -1589,10 +1589,10 @@ Decision* Solver::MakeAssignVariableValue(IntVar* const var, int64_t val) { namespace { class AssignOneVariableValueOrFail : public Decision { public: - AssignOneVariableValueOrFail(IntVar* const v, int64_t value); + AssignOneVariableValueOrFail(IntVar* v, int64_t value); ~AssignOneVariableValueOrFail() override {} - void Apply(Solver* const s) override; - void Refute(Solver* const s) override; + void Apply(Solver* s) override; + void Refute(Solver* s) override; std::string DebugString() const override; void Accept(DecisionVisitor* const visitor) const override { visitor->VisitSetVariableValue(var_, value_); @@ -1657,10 +1657,10 @@ Decision* Solver::MakeAssignVariableValueOrDoNothing(IntVar* const var, namespace { class SplitOneVariable : public Decision { public: - SplitOneVariable(IntVar* const v, int64_t val, bool start_with_lower_half); + SplitOneVariable(IntVar* v, int64_t val, bool start_with_lower_half); ~SplitOneVariable() override {} - void Apply(Solver* const s) override; - void Refute(Solver* const s) override; + void Apply(Solver* s) override; + void Refute(Solver* s) override; std::string DebugString() const override; void Accept(DecisionVisitor* const visitor) const override { visitor->VisitSplitVariableDomain(var_, value_, start_with_lower_half_); @@ -1730,8 +1730,8 @@ class AssignVariablesValues : public Decision { const std::vector& vars, const std::vector& values, RefutationBehavior refutation = RefutationBehavior::kForbidAssignment); ~AssignVariablesValues() override {} - void Apply(Solver* const s) override; - void Refute(Solver* const s) override; + void Apply(Solver* s) override; + void Refute(Solver* s) override; std::string DebugString() const override; void Accept(DecisionVisitor* const visitor) const override { for (int i = 0; i < vars_.size(); ++i) { @@ -1847,10 +1847,10 @@ class BaseAssignVariables : public DecisionBuilder { : selector_(selector), mode_(mode) {} ~BaseAssignVariables() override; - Decision* Next(Solver* const s) override; + Decision* Next(Solver* s) override; std::string DebugString() const override; static BaseAssignVariables* MakePhase( - Solver* const s, const std::vector& vars, + Solver* s, const std::vector& vars, Solver::VariableIndexSelector var_selector, Solver::VariableValueSelector value_selector, const std::string& value_selector_name, BaseAssignVariables::Mode mode); @@ -2288,7 +2288,7 @@ SolutionCollector::SolutionCollector(Solver* solver, SolutionCollector::SolutionCollector(Solver* solver) : SearchMonitor(solver), prototype_(new Assignment(solver)) {} -SolutionCollector::~SolutionCollector() = default; +SolutionCollector::~SolutionCollector() {} int64_t SolutionCollector::SolutionData::ObjectiveValue() const { return solution != nullptr ? solution->ObjectiveValue() : 0; @@ -2491,8 +2491,8 @@ namespace { // Collect first solution, useful when looking satisfaction problems class FirstSolutionCollector : public SolutionCollector { public: - FirstSolutionCollector(Solver* const s, const Assignment* const a); - explicit FirstSolutionCollector(Solver* const s); + FirstSolutionCollector(Solver* s, const Assignment* a); + explicit FirstSolutionCollector(Solver* s); ~FirstSolutionCollector() override; void EnterSearch() override; bool AtSolution() override; @@ -2554,8 +2554,8 @@ SolutionCollector* Solver::MakeFirstSolutionCollector() { namespace { class LastSolutionCollector : public SolutionCollector { public: - LastSolutionCollector(Solver* const s, const Assignment* const a); - explicit LastSolutionCollector(Solver* const s); + LastSolutionCollector(Solver* s, const Assignment* a); + explicit LastSolutionCollector(Solver* s); ~LastSolutionCollector() override; bool AtSolution() override; void Install() override; @@ -2608,7 +2608,7 @@ class BestValueSolutionCollector : public SolutionCollector { BestValueSolutionCollector(Solver* solver, const Assignment* assignment, std::vector maximize); BestValueSolutionCollector(Solver* solver, std::vector maximize); - ~BestValueSolutionCollector() override = default; + ~BestValueSolutionCollector() override {} void EnterSearch() override; bool AtSolution() override; void Install() override; @@ -2861,8 +2861,8 @@ SolutionCollector* Solver::MakeNBestLexicographicValueSolutionCollector( namespace { class AllSolutionCollector : public SolutionCollector { public: - AllSolutionCollector(Solver* const s, const Assignment* const a); - explicit AllSolutionCollector(Solver* const s); + AllSolutionCollector(Solver* s, const Assignment* a); + explicit AllSolutionCollector(Solver* s); ~AllSolutionCollector() override; bool AtSolution() override; void Install() override; @@ -3125,7 +3125,7 @@ class WeightedOptimizeVar : public OptimizeVar { CHECK_EQ(sub_objectives.size(), weights.size()); } - ~WeightedOptimizeVar() override = default; + ~WeightedOptimizeVar() override {} std::string Print() const override; private: @@ -3195,7 +3195,7 @@ class Metaheuristic : public ObjectiveMonitor { ~Metaheuristic() override {} void EnterSearch() override; - void RefuteDecision(Decision* const d) override; + void RefuteDecision(Decision* d) override; bool AcceptDelta(Assignment* delta, Assignment* deltadelta) override; }; @@ -3250,7 +3250,7 @@ class TabuSearch : public Metaheuristic { std::vector objectives, std::vector steps, const std::vector& vars, int64_t keep_tenure, int64_t forbid_tenure, double tabu_factor); - ~TabuSearch() override = default; + ~TabuSearch() override {} void EnterSearch() override; void ApplyDecision(Decision* d) override; bool AtSolution() override; @@ -3490,7 +3490,7 @@ class SimulatedAnnealing : public Metaheuristic { std::vector objectives, std::vector steps, std::vector initial_temperatures); - ~SimulatedAnnealing() override = default; + ~SimulatedAnnealing() override {} void ApplyDecision(Decision* d) override; bool LocalOptimum() override; void AcceptNeighbor() override; @@ -3691,7 +3691,7 @@ class GuidedLocalSearch : public Metaheuristic { int64_t step, const std::vector& vars, double penalty_factor, bool reset_penalties_on_new_best_solution); - ~GuidedLocalSearch() override = default; + ~GuidedLocalSearch() override {} bool AcceptDelta(Assignment* delta, Assignment* deltadelta) override; void ApplyDecision(Decision* d) override; bool AtSolution() override; @@ -3989,7 +3989,7 @@ template class BinaryGuidedLocalSearch : public GuidedLocalSearch

{ public: BinaryGuidedLocalSearch( - Solver* const solver, IntVar* const objective, + Solver* solver, IntVar* objective, std::function objective_function, bool maximize, int64_t step, const std::vector& vars, double penalty_factor, bool reset_penalties_on_new_best_solution); @@ -4074,7 +4074,7 @@ template class TernaryGuidedLocalSearch : public GuidedLocalSearch

{ public: TernaryGuidedLocalSearch( - Solver* const solver, IntVar* const objective, + Solver* solver, IntVar* objective, std::function objective_function, bool maximize, int64_t step, const std::vector& vars, const std::vector& secondary_vars, double penalty_factor, @@ -4733,10 +4733,10 @@ SearchLimit* Solver::MakeLimit(SearchLimit* const limit_1, namespace { class CustomLimit : public SearchLimit { public: - CustomLimit(Solver* const s, std::function limiter); + CustomLimit(Solver* s, std::function limiter); bool CheckWithOffset(absl::Duration offset) override; void Init() override; - void Copy(const SearchLimit* const limit) override; + void Copy(const SearchLimit* limit) override; SearchLimit* MakeClone() const override; private: diff --git a/ortools/constraint_solver/utilities.cc b/ortools/constraint_solver/utilities.cc index ea851c2c7d..913ee18fcc 100644 --- a/ortools/constraint_solver/utilities.cc +++ b/ortools/constraint_solver/utilities.cc @@ -283,7 +283,7 @@ bool UnsortedNullableRevBitset::RevAnd(Solver* const solver, } } } else { - // Zero the word as the mask is implicitely null. + // Zero the word as the mask is implicitly null. changed = true; bits_.SetValue(solver, index, 0); to_remove_.push_back(index);