Uses of Class
com.google.ortools.constraintsolver.Constraint

Packages that use Constraint

Package	Description
com.google.ortools.constraintsolver

Uses of Constraint in com.google.ortools.constraintsolver

Subclasses of Constraint in com.google.ortools.constraintsolver

Modifier and Type	Class	Description
class	CastConstraint	Cast constraints are special channeling constraints designed to keep a variable in sync with an expression.
class	DisjunctiveConstraint
class	GlobalVehicleBreaksConstraint	GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on all vehicles in the dimension passed to its constructor. It is intended to be used for dimensions representing time. A break constraint ensures break intervals fit on the route of a vehicle. For a given vehicle, it forces break intervals to be disjoint from visit intervals, where visit intervals start at CumulVar(node) and last for node_visit_transit[node].
class	Pack
class	TypeRegulationsConstraint	The following constraint ensures that incompatibilities and requirements between types are respected. It verifies both "hard" and "temporal" incompatibilities. Two nodes with hard incompatible types cannot be served by the same vehicle at all, while with a temporal incompatibility they can't be on the same route at the same time. The VisitTypePolicy of a node determines how visiting it impacts the type count on the route. For example, for - three temporally incompatible types T1 T2 and T3 - 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with - a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE - r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE - 3 nodes A, UV and AR of type T3, respectively with type policies TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED the configurations UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or a1 --> r1 --> UV --> ... are not feasible. It also verifies same-vehicle and temporal type requirements. A node of type T_d with a same-vehicle requirement for type T_r needs to be served by the same vehicle as a node of type T_r. Temporal requirements, on the other hand, can take effect either when the dependent type is being added to the route or when it's removed from it, which is determined by the dependent node's VisitTypePolicy. In the above example: - If T3 is required on the same vehicle as T1, A, AR or UV must be on the same vehicle as a1. - If T2 is required when adding T1, a2 must be visited *before* a1, and if r2 is also visited on the route, it must be *after* a1, i.e.

Methods in com.google.ortools.constraintsolver that return Constraint

Modifier and Type	Method	Description
Constraint	ModelCache.findExprExprConstraint(IntExpr expr1, IntExpr expr2, int type)	Expr Expr Constraints.
Constraint	ModelCache.findVarConstantConstantConstraint(IntVar var, long value1, long value2, int type)	Var Constant Constant Constraints.
Constraint	ModelCache.findVarConstantConstraint(IntVar var, long value, int type)	Var Constant Constraints.
Constraint	ModelCache.findVoidConstraint(int type)	Void constraints.
Constraint	Solver.IntegerCastInfo.getMaintainer()
Constraint	Solver.makeAbsEquality(IntVar var, IntVar abs_var)	Creates the constraint abs(var) == abs_var.
Constraint	Solver.makeAllDifferent(IntVar[] vars)	All variables are pairwise different.
Constraint	Solver.makeAllDifferent(IntVar[] vars, boolean stronger_propagation)	All variables are pairwise different.
Constraint	Solver.makeAllDifferentExcept(IntVar[] vars, long escape_value)	All variables are pairwise different, unless they are assigned to the escape value.
Constraint	Solver.makeAllowedAssignment(IntVar[] vars, IntTupleSet tuples)	This method creates a constraint where the graph of the relation between the variables is given in extension.
Constraint	Solver.makeBetweenCt(IntExpr expr, long l, long u)	(l <= expr <= u)
Constraint	Solver.makeCircuit(IntVar[] nexts)	Force the "nexts" variable to create a complete Hamiltonian path.
Constraint	Solver.makeCount(IntVar[] vars, long value, long max_count)	|{i | vars[i] == value}| == max_count
Constraint	Solver.makeCount(IntVar[] vars, long value, IntVar max_count)	|{i | vars[i] == value}| == max_count
Constraint	Solver.makeCover(IntervalVar[] vars, IntervalVar target_var)	This constraint states that the target_var is the convex hull of the intervals.
Constraint	Solver.makeCumulative(IntervalVar[] intervals, int[] demands, long capacity, String name)	This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values.
Constraint	Solver.makeCumulative(IntervalVar[] intervals, int[] demands, IntVar capacity, 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 capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values.
Constraint	Solver.makeCumulative(IntervalVar[] intervals, long[] demands, long capacity, String name)	This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values.
Constraint	Solver.makeCumulative(IntervalVar[] intervals, long[] demands, IntVar capacity, String name)	This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values.
Constraint	Solver.makeCumulative(IntervalVar[] intervals, IntVar[] demands, long capacity, 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 capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
Constraint	Solver.makeCumulative(IntervalVar[] intervals, IntVar[] demands, IntVar capacity, 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 capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
Constraint	Solver.makeDelayedPathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, IntVar[] transits)	Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated.
Constraint	Solver.makeDeviation(IntVar[] vars, IntVar deviation_var, long total_sum)	Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars
Constraint	Solver.makeDistribute(IntVar[] vars, int[] card_min, int[] card_max)	Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
Constraint	Solver.makeDistribute(IntVar[] vars, int[] values, int[] card_min, int[] card_max)	Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
Constraint	Solver.makeDistribute(IntVar[] vars, int[] values, IntVar[] cards)	Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
Constraint	Solver.makeDistribute(IntVar[] vars, long[] card_min, long[] card_max)	Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
Constraint	Solver.makeDistribute(IntVar[] vars, long[] values, long[] card_min, long[] card_max)	Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
Constraint	Solver.makeDistribute(IntVar[] vars, long[] values, IntVar[] cards)	Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
Constraint	Solver.makeDistribute(IntVar[] vars, long card_min, long card_max, long card_size)	Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
Constraint	Solver.makeDistribute(IntVar[] vars, IntVar[] cards)	Aggregated version of count: |{i | v[i] == j}| == cards[j]
Constraint	Solver.makeElementEquality(int[] vals, IntVar index, IntVar target)
Constraint	Solver.makeElementEquality(long[] vals, IntVar index, IntVar target)
Constraint	Solver.makeElementEquality(IntVar[] vars, IntVar index, long target)
Constraint	Solver.makeElementEquality(IntVar[] vars, IntVar index, IntVar target)
Constraint	Solver.makeEquality(IntervalVar var1, IntervalVar var2)	This constraints states that the two interval variables are equal.
Constraint	Solver.makeEquality(IntExpr expr, int value)	expr == value
Constraint	Solver.makeEquality(IntExpr expr, long value)	expr == value
Constraint	Solver.makeEquality(IntExpr left, IntExpr right)	left == right
Constraint	Solver.makeFalseConstraint()	This constraint always fails.
Constraint	Solver.makeFalseConstraint(String explanation)
Constraint	Solver.makeGreater(IntExpr expr, int value)	expr > value
Constraint	Solver.makeGreater(IntExpr expr, long value)	expr > value
Constraint	Solver.makeGreater(IntExpr left, IntExpr right)	left > right
Constraint	Solver.makeGreaterOrEqual(IntExpr expr, int value)	expr >= value
Constraint	Solver.makeGreaterOrEqual(IntExpr expr, long value)	expr >= value
Constraint	Solver.makeGreaterOrEqual(IntExpr left, IntExpr right)	left >= right
Constraint	Solver.makeIfThenElseCt(IntVar condition, IntExpr then_expr, IntExpr else_expr, IntVar target_var)	Special cases with arrays of size two.
Constraint	Solver.makeIndexOfConstraint(IntVar[] vars, IntVar index, long target)	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	Solver.makeIndexOfFirstMaxValueConstraint(IntVar index, IntVar[] vars)	Creates a constraint that binds the index variable to the index of the first variable with the maximum value.
Constraint	Solver.makeIndexOfFirstMinValueConstraint(IntVar index, IntVar[] vars)	Creates a constraint that binds the index variable to the index of the first variable with the minimum value.
Constraint	Solver.makeIntervalVarRelation(IntervalVar t, int r, long d)	This method creates a relation between an interval var and a date.
Constraint	Solver.makeIntervalVarRelation(IntervalVar t1, int r, IntervalVar t2)	This method creates a relation between two interval vars.
Constraint	Solver.makeIntervalVarRelationWithDelay(IntervalVar t1, int r, IntervalVar t2, long delay)	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	Solver.makeInversePermutationConstraint(IntVar[] left, IntVar[] right)	Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e. for all i in [0..left.size()-1], right[left[i]] = i.
Constraint	Solver.makeIsBetweenCt(IntExpr expr, long l, long u, IntVar b)	b == (l <= expr <= u)
Constraint	Solver.makeIsDifferentCstCt(IntExpr var, long value, IntVar boolvar)	boolvar == (var !
Constraint	Solver.makeIsDifferentCstCt(IntExpr v1, IntExpr v2, IntVar b)	b == (v1 !
Constraint	Solver.makeIsEqualCstCt(IntExpr var, long value, IntVar boolvar)	boolvar == (var == value)
Constraint	Solver.makeIsEqualVar(IntExpr v1, IntExpr v2, IntVar b)	b == (v1 == v2)
Constraint	Solver.makeIsGreaterCstCt(IntExpr v, long c, IntVar b)	b == (v > c)
Constraint	Solver.makeIsGreaterCt(IntExpr left, IntExpr right, IntVar b)	b == (left > right)
Constraint	Solver.makeIsGreaterOrEqualCstCt(IntExpr var, long value, IntVar boolvar)	boolvar == (var >= value)
Constraint	Solver.makeIsGreaterOrEqualCt(IntExpr left, IntExpr right, IntVar b)	b == (left >= right)
Constraint	Solver.makeIsLessCstCt(IntExpr v, long c, IntVar b)	b == (v < c)
Constraint	Solver.makeIsLessCt(IntExpr left, IntExpr right, IntVar b)	b == (left < right)
Constraint	Solver.makeIsLessOrEqualCstCt(IntExpr var, long value, IntVar boolvar)	boolvar == (var <= value)
Constraint	Solver.makeIsLessOrEqualCt(IntExpr left, IntExpr right, IntVar b)	b == (left <= right)
Constraint	Solver.MakeIsLexicalLessOrEqualWithOffsetsCt(IntVar[] left, IntVar[] right, long[] offsets, IntVar boolvar)
Constraint	Solver.makeIsMemberCt(IntExpr expr, int[] values, IntVar boolvar)
Constraint	Solver.makeIsMemberCt(IntExpr expr, long[] values, IntVar boolvar)	boolvar == (expr in set)
Constraint	Solver.makeLess(IntExpr expr, int value)	expr < value
Constraint	Solver.makeLess(IntExpr expr, long value)	expr < value
Constraint	Solver.makeLess(IntExpr left, IntExpr right)	left < right
Constraint	Solver.makeLessOrEqual(IntExpr expr, int value)	expr <= value
Constraint	Solver.makeLessOrEqual(IntExpr expr, long value)	expr <= value
Constraint	Solver.makeLessOrEqual(IntExpr left, IntExpr right)	left <= right
Constraint	Solver.makeLexicalLess(IntVar[] left, IntVar[] right)	Creates a constraint that enforces that left is lexicographically less than right.
Constraint	Solver.makeLexicalLessOrEqual(IntVar[] left, IntVar[] right)	Creates a constraint that enforces that left is lexicographically less than or equal to right.
Constraint	Solver.MakeLexicalLessOrEqualWithOffsets(IntVar[] left, IntVar[] right, long[] offsets)	Creates a constraint that enforces that left is lexicographically less than or equal to right with an offset.
Constraint	Solver.makeMapDomain(IntVar var, IntVar[] actives)	This constraint maps the domain of 'var' onto the array of variables 'actives'.
Constraint	Solver.makeMaxEquality(IntVar[] vars, IntVar max_var)
Constraint	Solver.makeMemberCt(IntExpr expr, int[] values)
Constraint	Solver.makeMemberCt(IntExpr expr, long[] values)	expr in set.
Constraint	Solver.makeMinEquality(IntVar[] vars, IntVar min_var)
Constraint	Solver.makeNoCycle(IntVar[] nexts, IntVar[] active)	Prevent cycles.
Constraint	Solver.makeNoCycle(IntVar[] nexts, IntVar[] active, LongPredicate sink_handler)	Prevent cycles.
Constraint	Solver.makeNoCycle(IntVar[] nexts, IntVar[] active, LongPredicate sink_handler, boolean assume_paths)
Constraint	Solver.makeNonEquality(IntExpr expr, int value)	expr !
Constraint	Solver.makeNonEquality(IntExpr expr, long value)	expr !
Constraint	Solver.makeNonEquality(IntExpr left, IntExpr right)	left !
Constraint	Solver.makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, IntVar[] x_size, IntVar[] y_size)	This constraint states that all the boxes must not overlap. The coordinates of box i are: (x_vars[i], y_vars[i]), (x_vars[i], y_vars[i] + y_size[i]), (x_vars[i] + x_size[i], y_vars[i]), (x_vars[i] + x_size[i], y_vars[i] + y_size[i]). The sizes must be non-negative.
Constraint	Solver.makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size)
Constraint	Solver.makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t y_size)
Constraint	Solver.makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, IntVar[] x_size, IntVar[] y_size)	This constraint states that all the boxes must not overlap. The coordinates of box i are: (x_vars[i], y_vars[i]), (x_vars[i], y_vars[i] + y_size[i]), (x_vars[i] + x_size[i], y_vars[i]), (x_vars[i] + x_size[i], y_vars[i] + y_size[i]). The sizes must be positive. Boxes with a zero dimension can be placed anywhere.
Constraint	Solver.makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size)
Constraint	Solver.makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t y_size)
Constraint	Solver.makeNotBetweenCt(IntExpr expr, long l, long u)	(expr < l || expr > u) This constraint is lazy as it will not make holes in the domain of variables.
Constraint	Solver.makeNotMemberCt(IntExpr expr, int[] values)
Constraint	Solver.makeNotMemberCt(IntExpr expr, int[] starts, int[] ends)	expr should not be in the list of forbidden intervals [start[i]..end[i]].
Constraint	Solver.makeNotMemberCt(IntExpr expr, long[] values)	expr not in set.
Constraint	Solver.makeNotMemberCt(IntExpr expr, long[] starts, long[] ends)	expr should not be in the list of forbidden intervals [start[i]..end[i]].
Constraint	Solver.makeNullIntersect(IntVar[] first_vars, IntVar[] second_vars)	Creates a constraint that states that all variables in the first vector are different from all variables in the second group.
Constraint	Solver.makeNullIntersectExcept(IntVar[] first_vars, IntVar[] second_vars, long escape_value)	Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value.
Constraint	Solver.makePathConnected(IntVar[] nexts, long[] sources, long[] sinks, IntVar[] status)	Constraint enforcing that status[i] is true iff there's a path defined on next variables from sources[i] to sinks[i]. Check whether more propagation is needed.
Constraint	Solver.makePathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, IntVar[] transits)	Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.
Constraint	Solver.makePathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, IntVar[] slacks, LongBinaryOperator transit_evaluator)	Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
Constraint	Solver.makePathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, LongBinaryOperator transit_evaluator)	Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
Constraint	Solver.makeScalProdEquality(IntVar[] vars, int[] coefficients, long cst)
Constraint	Solver.makeScalProdEquality(IntVar[] vars, int[] coefficients, IntVar target)
Constraint	Solver.makeScalProdEquality(IntVar[] vars, long[] coefficients, long cst)
Constraint	Solver.makeScalProdEquality(IntVar[] vars, long[] coefficients, IntVar target)
Constraint	Solver.makeScalProdGreaterOrEqual(IntVar[] vars, int[] coeffs, long cst)
Constraint	Solver.makeScalProdGreaterOrEqual(IntVar[] vars, long[] coeffs, long cst)
Constraint	Solver.makeScalProdLessOrEqual(IntVar[] vars, int[] coefficients, long cst)
Constraint	Solver.makeScalProdLessOrEqual(IntVar[] vars, long[] coefficients, long cst)
Constraint	Solver.makeSortingConstraint(IntVar[] vars, IntVar[] sorted)	Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars. This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa. Behind the scenes, this constraint maintains that: - sorted is always increasing. - whatever the values of vars, there exists a permutation that injects its values into the sorted variables. For more info, please have a look at: https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf
Constraint	Solver.makeSubCircuit(IntVar[] nexts)	Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves.
Constraint	Solver.makeSumEquality(IntVar[] vars, long cst)
Constraint	Solver.makeSumEquality(IntVar[] vars, IntVar var)
Constraint	Solver.makeSumGreaterOrEqual(IntVar[] vars, long cst)
Constraint	Solver.makeSumLessOrEqual(IntVar[] vars, long cst)	Variation on arrays.
Constraint	Solver.makeTemporalDisjunction(IntervalVar t1, IntervalVar t2)	This constraint implements a temporal disjunction between two interval vars.
Constraint	Solver.makeTemporalDisjunction(IntervalVar t1, IntervalVar t2, IntVar alt)	This constraint implements a temporal disjunction between two interval vars t1 and t2.
Constraint	Solver.makeTransitionConstraint(IntVar[] vars, IntTupleSet transition_table, long initial_state, int[] final_states)	This constraint create a finite automaton that will check the sequence of variables vars.
Constraint	Solver.makeTransitionConstraint(IntVar[] vars, IntTupleSet transition_table, long initial_state, long[] final_states)	This constraint create a finite automaton that will check the sequence of variables vars.
Constraint	Solver.makeTrueConstraint()	This constraint always succeeds.

Methods in com.google.ortools.constraintsolver with parameters of type Constraint

Modifier and Type	Method	Description
void	Solver.addConstraint(Constraint c)	Adds the constraint 'c' to the model. After calling this method, and until there is a backtrack that undoes the addition, any assignment of variables to values must satisfy the given constraint in order to be considered feasible.
void	PropagationMonitor.beginConstraintInitialPropagation(Constraint constraint)	Propagation events.
void	PropagationMonitor.beginNestedConstraintInitialPropagation(Constraint parent, Constraint nested)
void	ModelVisitor.beginVisitConstraint(String type_name, Constraint constraint)
boolean	Solver.checkConstraint(Constraint ct)	Checks whether adding this constraint will lead to an immediate failure.
static final void	mainJNI.Constraint_accept(long jarg1, Constraint jarg1_, long jarg2, ModelVisitor jarg2_)
static final void	mainJNI.Constraint_initialPropagate(long jarg1, Constraint jarg1_)
static final boolean	mainJNI.Constraint_isCastConstraint(long jarg1, Constraint jarg1_)
static final void	mainJNI.Constraint_post(long jarg1, Constraint jarg1_)
static final void	mainJNI.Constraint_postAndPropagate(long jarg1, Constraint jarg1_)
static final String	mainJNI.Constraint_toString(long jarg1, Constraint jarg1_)
static final long	mainJNI.Constraint_var(long jarg1, Constraint jarg1_)
void	PropagationMonitor.endConstraintInitialPropagation(Constraint constraint)
void	PropagationMonitor.endNestedConstraintInitialPropagation(Constraint parent, Constraint nested)
void	ModelVisitor.endVisitConstraint(String type_name, Constraint constraint)
static long	Constraint.getCPtr(Constraint obj)
void	ModelCache.insertExprExprConstraint(Constraint ct, IntExpr expr1, IntExpr expr2, int type)
void	ModelCache.insertVarConstantConstantConstraint(Constraint ct, IntVar var, long value1, long value2, int type)
void	ModelCache.insertVarConstantConstraint(Constraint ct, IntVar var, long value, int type)
void	ModelCache.insertVoidConstraint(Constraint ct, int type)
DecisionBuilder	Solver.makeConstraintAdder(Constraint ct)	Returns a decision builder that will add the given constraint to the model.
Demon	Solver.makeConstraintInitialPropagateCallback(Constraint ct)	This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'.
Demon	Solver.makeDelayedConstraintInitialPropagateCallback(Constraint ct)	This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority.
static final void	mainJNI.ModelCache_insertExprExprConstraint(long jarg1, ModelCache jarg1_, long jarg2, Constraint jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntExpr jarg4_, int jarg5)
static final void	mainJNI.ModelCache_insertVarConstantConstantConstraint(long jarg1, ModelCache jarg1_, long jarg2, Constraint jarg2_, long jarg3, IntVar jarg3_, long jarg4, long jarg5, int jarg6)
static final void	mainJNI.ModelCache_insertVarConstantConstraint(long jarg1, ModelCache jarg1_, long jarg2, Constraint jarg2_, long jarg3, IntVar jarg3_, long jarg4, int jarg5)
static final void	mainJNI.ModelCache_insertVoidConstraint(long jarg1, ModelCache jarg1_, long jarg2, Constraint jarg2_, int jarg3)
static final void	mainJNI.ModelVisitor_beginVisitConstraint(long jarg1, ModelVisitor jarg1_, String jarg2, long jarg3, Constraint jarg3_)
static final void	mainJNI.ModelVisitor_endVisitConstraint(long jarg1, ModelVisitor jarg1_, String jarg2, long jarg3, Constraint jarg3_)
static final long	mainJNI.new_Solver_IntegerCastInfo__SWIG_1(long jarg1, IntVar jarg1_, long jarg2, IntExpr jarg2_, long jarg3, Constraint jarg3_)
static final void	mainJNI.PropagationMonitor_beginConstraintInitialPropagation(long jarg1, PropagationMonitor jarg1_, long jarg2, Constraint jarg2_)
static final void	mainJNI.PropagationMonitor_beginNestedConstraintInitialPropagation(long jarg1, PropagationMonitor jarg1_, long jarg2, Constraint jarg2_, long jarg3, Constraint jarg3_)
static final void	mainJNI.PropagationMonitor_endConstraintInitialPropagation(long jarg1, PropagationMonitor jarg1_, long jarg2, Constraint jarg2_)
static final void	mainJNI.PropagationMonitor_endNestedConstraintInitialPropagation(long jarg1, PropagationMonitor jarg1_, long jarg2, Constraint jarg2_, long jarg3, Constraint jarg3_)
void	Solver.IntegerCastInfo.setMaintainer(Constraint value)
static final void	mainJNI.Solver_addConstraint(long jarg1, Solver jarg1_, long jarg2, Constraint jarg2_)
static final boolean	mainJNI.Solver_checkConstraint(long jarg1, Solver jarg1_, long jarg2, Constraint jarg2_)
static final void	mainJNI.Solver_IntegerCastInfo_maintainer_set(long jarg1, Solver.IntegerCastInfo jarg1_, long jarg2, Constraint jarg2_)
static final long	mainJNI.Solver_makeConstraintAdder(long jarg1, Solver jarg1_, long jarg2, Constraint jarg2_)
static final long	mainJNI.Solver_makeConstraintInitialPropagateCallback(long jarg1, Solver jarg1_, long jarg2, Constraint jarg2_)
static final long	mainJNI.Solver_makeDelayedConstraintInitialPropagateCallback(long jarg1, Solver jarg1_, long jarg2, Constraint jarg2_)
static long	Constraint.swigRelease(Constraint obj)

Constructors in com.google.ortools.constraintsolver with parameters of type Constraint

Modifier	Constructor	Description
	IntegerCastInfo(IntVar v, IntExpr e, Constraint c)