ConstraintProto.Builder (com.google.ortools:ortools-java 9.12.9999 API)

java.lang.Object
- com.google.protobuf.AbstractMessageLite.Builder
- - com.google.protobuf.AbstractMessage.Builder<BuilderT>
  - - com.google.protobuf.GeneratedMessage.Builder<ConstraintProto.Builder>
    - - com.google.ortools.sat.ConstraintProto.Builder

All Implemented Interfaces:

ConstraintProtoOrBuilder, com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, java.lang.Cloneable

Enclosing class:

ConstraintProto
```
public static final class ConstraintProto.Builder
extends com.google.protobuf.GeneratedMessage.Builder<ConstraintProto.Builder>
implements ConstraintProtoOrBuilder
```
```
 Next id: 31
 
```
Protobuf type operations_research.sat.ConstraintProto

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ConstraintProto.Builder`	`addAllEnforcementLiteral(java.lang.Iterable<? extends java.lang.Integer> values)` The constraint will be enforced iff all literals listed here are true.
`ConstraintProto.Builder`	`addEnforcementLiteral(int value)` The constraint will be enforced iff all literals listed here are true.
`ConstraintProto`	`build()`
`ConstraintProto`	`buildPartial()`
`ConstraintProto.Builder`	`clear()`
`ConstraintProto.Builder`	`clearAllDiff()` The all_diff constraint forces all variables to take different values.
`ConstraintProto.Builder`	`clearAtMostOne()` The at_most_one constraint enforces that no more than one literal is true at the same time.
`ConstraintProto.Builder`	`clearAutomaton()` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`ConstraintProto.Builder`	`clearBoolAnd()` The bool_and constraint forces all of the literals to be true.
`ConstraintProto.Builder`	`clearBoolOr()` The bool_or constraint forces at least one literal to be true.
`ConstraintProto.Builder`	`clearBoolXor()` The bool_xor constraint forces an odd number of the literals to be true.
`ConstraintProto.Builder`	`clearCircuit()` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`ConstraintProto.Builder`	`clearConstraint()`
`ConstraintProto.Builder`	`clearCumulative()` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`ConstraintProto.Builder`	`clearDummyConstraint()` This constraint is not meant to be used and will be rejected by the solver.
`ConstraintProto.Builder`	`clearElement()` The element constraint forces the variable with the given index to be equal to the target.
`ConstraintProto.Builder`	`clearEnforcementLiteral()` The constraint will be enforced iff all literals listed here are true.
`ConstraintProto.Builder`	`clearExactlyOne()` The exactly_one constraint force exactly one literal to true and no more.
`ConstraintProto.Builder`	`clearIntDiv()` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`ConstraintProto.Builder`	`clearInterval()` The interval constraint takes a start, end, and size, and forces start + size == end.
`ConstraintProto.Builder`	`clearIntMod()` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`ConstraintProto.Builder`	`clearIntProd()` The int_prod constraint forces the target to equal the product of all variables.
`ConstraintProto.Builder`	`clearInverse()` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`ConstraintProto.Builder`	`clearLinear()` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`ConstraintProto.Builder`	`clearLinMax()` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`ConstraintProto.Builder`	`clearName()` For debug/logging only.
`ConstraintProto.Builder`	`clearNoOverlap()` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`ConstraintProto.Builder`	`clearNoOverlap2D()` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`ConstraintProto.Builder`	`clearReservoir()` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`ConstraintProto.Builder`	`clearRoutes()` The routes constraint implements the vehicle routing problem.
`ConstraintProto.Builder`	`clearTable()` The table constraint enforces what values a tuple of variables may take.
`AllDifferentConstraintProto`	`getAllDiff()` The all_diff constraint forces all variables to take different values.
`AllDifferentConstraintProto.Builder`	`getAllDiffBuilder()` The all_diff constraint forces all variables to take different values.
`AllDifferentConstraintProtoOrBuilder`	`getAllDiffOrBuilder()` The all_diff constraint forces all variables to take different values.
`BoolArgumentProto`	`getAtMostOne()` The at_most_one constraint enforces that no more than one literal is true at the same time.
`BoolArgumentProto.Builder`	`getAtMostOneBuilder()` The at_most_one constraint enforces that no more than one literal is true at the same time.
`BoolArgumentProtoOrBuilder`	`getAtMostOneOrBuilder()` The at_most_one constraint enforces that no more than one literal is true at the same time.
`AutomatonConstraintProto`	`getAutomaton()` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`AutomatonConstraintProto.Builder`	`getAutomatonBuilder()` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`AutomatonConstraintProtoOrBuilder`	`getAutomatonOrBuilder()` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`BoolArgumentProto`	`getBoolAnd()` The bool_and constraint forces all of the literals to be true.
`BoolArgumentProto.Builder`	`getBoolAndBuilder()` The bool_and constraint forces all of the literals to be true.
`BoolArgumentProtoOrBuilder`	`getBoolAndOrBuilder()` The bool_and constraint forces all of the literals to be true.
`BoolArgumentProto`	`getBoolOr()` The bool_or constraint forces at least one literal to be true.
`BoolArgumentProto.Builder`	`getBoolOrBuilder()` The bool_or constraint forces at least one literal to be true.
`BoolArgumentProtoOrBuilder`	`getBoolOrOrBuilder()` The bool_or constraint forces at least one literal to be true.
`BoolArgumentProto`	`getBoolXor()` The bool_xor constraint forces an odd number of the literals to be true.
`BoolArgumentProto.Builder`	`getBoolXorBuilder()` The bool_xor constraint forces an odd number of the literals to be true.
`BoolArgumentProtoOrBuilder`	`getBoolXorOrBuilder()` The bool_xor constraint forces an odd number of the literals to be true.
`CircuitConstraintProto`	`getCircuit()` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`CircuitConstraintProto.Builder`	`getCircuitBuilder()` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`CircuitConstraintProtoOrBuilder`	`getCircuitOrBuilder()` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`ConstraintProto.ConstraintCase`	`getConstraintCase()`
`CumulativeConstraintProto`	`getCumulative()` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`CumulativeConstraintProto.Builder`	`getCumulativeBuilder()` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`CumulativeConstraintProtoOrBuilder`	`getCumulativeOrBuilder()` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`ConstraintProto`	`getDefaultInstanceForType()`
`static com.google.protobuf.Descriptors.Descriptor`	`getDescriptor()`
`com.google.protobuf.Descriptors.Descriptor`	`getDescriptorForType()`
`ListOfVariablesProto`	`getDummyConstraint()` This constraint is not meant to be used and will be rejected by the solver.
`ListOfVariablesProto.Builder`	`getDummyConstraintBuilder()` This constraint is not meant to be used and will be rejected by the solver.
`ListOfVariablesProtoOrBuilder`	`getDummyConstraintOrBuilder()` This constraint is not meant to be used and will be rejected by the solver.
`ElementConstraintProto`	`getElement()` The element constraint forces the variable with the given index to be equal to the target.
`ElementConstraintProto.Builder`	`getElementBuilder()` The element constraint forces the variable with the given index to be equal to the target.
`ElementConstraintProtoOrBuilder`	`getElementOrBuilder()` The element constraint forces the variable with the given index to be equal to the target.
`int`	`getEnforcementLiteral(int index)` The constraint will be enforced iff all literals listed here are true.
`int`	`getEnforcementLiteralCount()` The constraint will be enforced iff all literals listed here are true.
`java.util.List<java.lang.Integer>`	`getEnforcementLiteralList()` The constraint will be enforced iff all literals listed here are true.
`BoolArgumentProto`	`getExactlyOne()` The exactly_one constraint force exactly one literal to true and no more.
`BoolArgumentProto.Builder`	`getExactlyOneBuilder()` The exactly_one constraint force exactly one literal to true and no more.
`BoolArgumentProtoOrBuilder`	`getExactlyOneOrBuilder()` The exactly_one constraint force exactly one literal to true and no more.
`LinearArgumentProto`	`getIntDiv()` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`LinearArgumentProto.Builder`	`getIntDivBuilder()` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`LinearArgumentProtoOrBuilder`	`getIntDivOrBuilder()` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`IntervalConstraintProto`	`getInterval()` The interval constraint takes a start, end, and size, and forces start + size == end.
`IntervalConstraintProto.Builder`	`getIntervalBuilder()` The interval constraint takes a start, end, and size, and forces start + size == end.
`IntervalConstraintProtoOrBuilder`	`getIntervalOrBuilder()` The interval constraint takes a start, end, and size, and forces start + size == end.
`LinearArgumentProto`	`getIntMod()` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`LinearArgumentProto.Builder`	`getIntModBuilder()` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`LinearArgumentProtoOrBuilder`	`getIntModOrBuilder()` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`LinearArgumentProto`	`getIntProd()` The int_prod constraint forces the target to equal the product of all variables.
`LinearArgumentProto.Builder`	`getIntProdBuilder()` The int_prod constraint forces the target to equal the product of all variables.
`LinearArgumentProtoOrBuilder`	`getIntProdOrBuilder()` The int_prod constraint forces the target to equal the product of all variables.
`InverseConstraintProto`	`getInverse()` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`InverseConstraintProto.Builder`	`getInverseBuilder()` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`InverseConstraintProtoOrBuilder`	`getInverseOrBuilder()` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`LinearConstraintProto`	`getLinear()` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`LinearConstraintProto.Builder`	`getLinearBuilder()` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`LinearConstraintProtoOrBuilder`	`getLinearOrBuilder()` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`LinearArgumentProto`	`getLinMax()` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`LinearArgumentProto.Builder`	`getLinMaxBuilder()` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`LinearArgumentProtoOrBuilder`	`getLinMaxOrBuilder()` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`java.lang.String`	`getName()` For debug/logging only.
`com.google.protobuf.ByteString`	`getNameBytes()` For debug/logging only.
`NoOverlapConstraintProto`	`getNoOverlap()` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`NoOverlap2DConstraintProto`	`getNoOverlap2D()` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`NoOverlap2DConstraintProto.Builder`	`getNoOverlap2DBuilder()` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`NoOverlap2DConstraintProtoOrBuilder`	`getNoOverlap2DOrBuilder()` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`NoOverlapConstraintProto.Builder`	`getNoOverlapBuilder()` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`NoOverlapConstraintProtoOrBuilder`	`getNoOverlapOrBuilder()` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`ReservoirConstraintProto`	`getReservoir()` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`ReservoirConstraintProto.Builder`	`getReservoirBuilder()` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`ReservoirConstraintProtoOrBuilder`	`getReservoirOrBuilder()` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`RoutesConstraintProto`	`getRoutes()` The routes constraint implements the vehicle routing problem.
`RoutesConstraintProto.Builder`	`getRoutesBuilder()` The routes constraint implements the vehicle routing problem.
`RoutesConstraintProtoOrBuilder`	`getRoutesOrBuilder()` The routes constraint implements the vehicle routing problem.
`TableConstraintProto`	`getTable()` The table constraint enforces what values a tuple of variables may take.
`TableConstraintProto.Builder`	`getTableBuilder()` The table constraint enforces what values a tuple of variables may take.
`TableConstraintProtoOrBuilder`	`getTableOrBuilder()` The table constraint enforces what values a tuple of variables may take.
`boolean`	`hasAllDiff()` The all_diff constraint forces all variables to take different values.
`boolean`	`hasAtMostOne()` The at_most_one constraint enforces that no more than one literal is true at the same time.
`boolean`	`hasAutomaton()` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`boolean`	`hasBoolAnd()` The bool_and constraint forces all of the literals to be true.
`boolean`	`hasBoolOr()` The bool_or constraint forces at least one literal to be true.
`boolean`	`hasBoolXor()` The bool_xor constraint forces an odd number of the literals to be true.
`boolean`	`hasCircuit()` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`boolean`	`hasCumulative()` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`boolean`	`hasDummyConstraint()` This constraint is not meant to be used and will be rejected by the solver.
`boolean`	`hasElement()` The element constraint forces the variable with the given index to be equal to the target.
`boolean`	`hasExactlyOne()` The exactly_one constraint force exactly one literal to true and no more.
`boolean`	`hasIntDiv()` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`boolean`	`hasInterval()` The interval constraint takes a start, end, and size, and forces start + size == end.
`boolean`	`hasIntMod()` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`boolean`	`hasIntProd()` The int_prod constraint forces the target to equal the product of all variables.
`boolean`	`hasInverse()` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`boolean`	`hasLinear()` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`boolean`	`hasLinMax()` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`boolean`	`hasNoOverlap()` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`boolean`	`hasNoOverlap2D()` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`boolean`	`hasReservoir()` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`boolean`	`hasRoutes()` The routes constraint implements the vehicle routing problem.
`boolean`	`hasTable()` The table constraint enforces what values a tuple of variables may take.
`protected com.google.protobuf.GeneratedMessage.FieldAccessorTable`	`internalGetFieldAccessorTable()`
`boolean`	`isInitialized()`
`ConstraintProto.Builder`	`mergeAllDiff(AllDifferentConstraintProto value)` The all_diff constraint forces all variables to take different values.
`ConstraintProto.Builder`	`mergeAtMostOne(BoolArgumentProto value)` The at_most_one constraint enforces that no more than one literal is true at the same time.
`ConstraintProto.Builder`	`mergeAutomaton(AutomatonConstraintProto value)` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`ConstraintProto.Builder`	`mergeBoolAnd(BoolArgumentProto value)` The bool_and constraint forces all of the literals to be true.
`ConstraintProto.Builder`	`mergeBoolOr(BoolArgumentProto value)` The bool_or constraint forces at least one literal to be true.
`ConstraintProto.Builder`	`mergeBoolXor(BoolArgumentProto value)` The bool_xor constraint forces an odd number of the literals to be true.
`ConstraintProto.Builder`	`mergeCircuit(CircuitConstraintProto value)` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`ConstraintProto.Builder`	`mergeCumulative(CumulativeConstraintProto value)` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`ConstraintProto.Builder`	`mergeDummyConstraint(ListOfVariablesProto value)` This constraint is not meant to be used and will be rejected by the solver.
`ConstraintProto.Builder`	`mergeElement(ElementConstraintProto value)` The element constraint forces the variable with the given index to be equal to the target.
`ConstraintProto.Builder`	`mergeExactlyOne(BoolArgumentProto value)` The exactly_one constraint force exactly one literal to true and no more.
`ConstraintProto.Builder`	`mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`ConstraintProto.Builder`	`mergeFrom(ConstraintProto other)`
`ConstraintProto.Builder`	`mergeFrom(com.google.protobuf.Message other)`
`ConstraintProto.Builder`	`mergeIntDiv(LinearArgumentProto value)` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`ConstraintProto.Builder`	`mergeInterval(IntervalConstraintProto value)` The interval constraint takes a start, end, and size, and forces start + size == end.
`ConstraintProto.Builder`	`mergeIntMod(LinearArgumentProto value)` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`ConstraintProto.Builder`	`mergeIntProd(LinearArgumentProto value)` The int_prod constraint forces the target to equal the product of all variables.
`ConstraintProto.Builder`	`mergeInverse(InverseConstraintProto value)` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`ConstraintProto.Builder`	`mergeLinear(LinearConstraintProto value)` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`ConstraintProto.Builder`	`mergeLinMax(LinearArgumentProto value)` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`ConstraintProto.Builder`	`mergeNoOverlap(NoOverlapConstraintProto value)` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`ConstraintProto.Builder`	`mergeNoOverlap2D(NoOverlap2DConstraintProto value)` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`ConstraintProto.Builder`	`mergeReservoir(ReservoirConstraintProto value)` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`ConstraintProto.Builder`	`mergeRoutes(RoutesConstraintProto value)` The routes constraint implements the vehicle routing problem.
`ConstraintProto.Builder`	`mergeTable(TableConstraintProto value)` The table constraint enforces what values a tuple of variables may take.
`ConstraintProto.Builder`	`setAllDiff(AllDifferentConstraintProto.Builder builderForValue)` The all_diff constraint forces all variables to take different values.
`ConstraintProto.Builder`	`setAllDiff(AllDifferentConstraintProto value)` The all_diff constraint forces all variables to take different values.
`ConstraintProto.Builder`	`setAtMostOne(BoolArgumentProto.Builder builderForValue)` The at_most_one constraint enforces that no more than one literal is true at the same time.
`ConstraintProto.Builder`	`setAtMostOne(BoolArgumentProto value)` The at_most_one constraint enforces that no more than one literal is true at the same time.
`ConstraintProto.Builder`	`setAutomaton(AutomatonConstraintProto.Builder builderForValue)` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`ConstraintProto.Builder`	`setAutomaton(AutomatonConstraintProto value)` The automaton constraint forces a sequence of variables to be accepted by an automaton.
`ConstraintProto.Builder`	`setBoolAnd(BoolArgumentProto.Builder builderForValue)` The bool_and constraint forces all of the literals to be true.
`ConstraintProto.Builder`	`setBoolAnd(BoolArgumentProto value)` The bool_and constraint forces all of the literals to be true.
`ConstraintProto.Builder`	`setBoolOr(BoolArgumentProto.Builder builderForValue)` The bool_or constraint forces at least one literal to be true.
`ConstraintProto.Builder`	`setBoolOr(BoolArgumentProto value)` The bool_or constraint forces at least one literal to be true.
`ConstraintProto.Builder`	`setBoolXor(BoolArgumentProto.Builder builderForValue)` The bool_xor constraint forces an odd number of the literals to be true.
`ConstraintProto.Builder`	`setBoolXor(BoolArgumentProto value)` The bool_xor constraint forces an odd number of the literals to be true.
`ConstraintProto.Builder`	`setCircuit(CircuitConstraintProto.Builder builderForValue)` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`ConstraintProto.Builder`	`setCircuit(CircuitConstraintProto value)` The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a literal) to form a unique cycle.
`ConstraintProto.Builder`	`setCumulative(CumulativeConstraintProto.Builder builderForValue)` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`ConstraintProto.Builder`	`setCumulative(CumulativeConstraintProto value)` The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals containing that point does not exceed the capacity.
`ConstraintProto.Builder`	`setDummyConstraint(ListOfVariablesProto.Builder builderForValue)` This constraint is not meant to be used and will be rejected by the solver.
`ConstraintProto.Builder`	`setDummyConstraint(ListOfVariablesProto value)` This constraint is not meant to be used and will be rejected by the solver.
`ConstraintProto.Builder`	`setElement(ElementConstraintProto.Builder builderForValue)` The element constraint forces the variable with the given index to be equal to the target.
`ConstraintProto.Builder`	`setElement(ElementConstraintProto value)` The element constraint forces the variable with the given index to be equal to the target.
`ConstraintProto.Builder`	`setEnforcementLiteral(int index, int value)` The constraint will be enforced iff all literals listed here are true.
`ConstraintProto.Builder`	`setExactlyOne(BoolArgumentProto.Builder builderForValue)` The exactly_one constraint force exactly one literal to true and no more.
`ConstraintProto.Builder`	`setExactlyOne(BoolArgumentProto value)` The exactly_one constraint force exactly one literal to true and no more.
`ConstraintProto.Builder`	`setIntDiv(LinearArgumentProto.Builder builderForValue)` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`ConstraintProto.Builder`	`setIntDiv(LinearArgumentProto value)` The int_div constraint forces the target to equal exprs[0] / exprs[1].
`ConstraintProto.Builder`	`setInterval(IntervalConstraintProto.Builder builderForValue)` The interval constraint takes a start, end, and size, and forces start + size == end.
`ConstraintProto.Builder`	`setInterval(IntervalConstraintProto value)` The interval constraint takes a start, end, and size, and forces start + size == end.
`ConstraintProto.Builder`	`setIntMod(LinearArgumentProto.Builder builderForValue)` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`ConstraintProto.Builder`	`setIntMod(LinearArgumentProto value)` The int_mod constraint forces the target to equal exprs[0] % exprs[1].
`ConstraintProto.Builder`	`setIntProd(LinearArgumentProto.Builder builderForValue)` The int_prod constraint forces the target to equal the product of all variables.
`ConstraintProto.Builder`	`setIntProd(LinearArgumentProto value)` The int_prod constraint forces the target to equal the product of all variables.
`ConstraintProto.Builder`	`setInverse(InverseConstraintProto.Builder builderForValue)` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`ConstraintProto.Builder`	`setInverse(InverseConstraintProto value)` The inverse constraint forces two arrays to be inverses of each other: the values of one are the indices of the other, and vice versa.
`ConstraintProto.Builder`	`setLinear(LinearConstraintProto.Builder builderForValue)` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`ConstraintProto.Builder`	`setLinear(LinearConstraintProto value)` The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
`ConstraintProto.Builder`	`setLinMax(LinearArgumentProto.Builder builderForValue)` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`ConstraintProto.Builder`	`setLinMax(LinearArgumentProto value)` The lin_max constraint forces the target to equal the maximum of all linear expressions.
`ConstraintProto.Builder`	`setName(java.lang.String value)` For debug/logging only.
`ConstraintProto.Builder`	`setNameBytes(com.google.protobuf.ByteString value)` For debug/logging only.
`ConstraintProto.Builder`	`setNoOverlap(NoOverlapConstraintProto.Builder builderForValue)` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`ConstraintProto.Builder`	`setNoOverlap(NoOverlapConstraintProto value)` The no_overlap constraint prevents a set of intervals from overlapping; in scheduling, this is called a disjunctive constraint.
`ConstraintProto.Builder`	`setNoOverlap2D(NoOverlap2DConstraintProto.Builder builderForValue)` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`ConstraintProto.Builder`	`setNoOverlap2D(NoOverlap2DConstraintProto value)` The no_overlap_2d constraint prevents a set of boxes from overlapping.
`ConstraintProto.Builder`	`setReservoir(ReservoirConstraintProto.Builder builderForValue)` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`ConstraintProto.Builder`	`setReservoir(ReservoirConstraintProto value)` The reservoir constraint forces the sum of a set of active demands to always be between a specified minimum and maximum value during specific times.
`ConstraintProto.Builder`	`setRoutes(RoutesConstraintProto.Builder builderForValue)` The routes constraint implements the vehicle routing problem.
`ConstraintProto.Builder`	`setRoutes(RoutesConstraintProto value)` The routes constraint implements the vehicle routing problem.
`ConstraintProto.Builder`	`setTable(TableConstraintProto.Builder builderForValue)` The table constraint enforces what values a tuple of variables may take.
`ConstraintProto.Builder`	`setTable(TableConstraintProto value)` The table constraint enforces what values a tuple of variables may take.

Methods inherited from class com.google.protobuf.GeneratedMessage.Builder
addRepeatedField, clearField, clearOneof, clone, getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, getUnknownFieldSetBuilder, hasField, hasOneof, internalGetMapField, internalGetMapFieldReflection, internalGetMutableMapField, internalGetMutableMapFieldReflection, isClean, markClean, mergeUnknownFields, mergeUnknownLengthDelimitedField, mergeUnknownVarintField, newBuilderForField, onBuilt, onChanged, parseUnknownField, setField, setRepeatedField, setUnknownFields, setUnknownFieldSetBuilder, setUnknownFieldsProto3

Methods inherited from class com.google.protobuf.AbstractMessage.Builder
findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString

Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder
addAll, addAll, mergeDelimitedFrom, mergeDelimitedFrom, newUninitializedMessageException

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.google.protobuf.MessageOrBuilder
findInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

Methods inherited from interface com.google.protobuf.Message.Builder
mergeDelimitedFrom, mergeDelimitedFrom

Method Detail

getDescriptor

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

internalGetFieldAccessorTable
```
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
```
Specified by:

internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage.Builder<ConstraintProto.Builder>

clear
```
public ConstraintProto.Builder clear()
```
Specified by:

clear in interface com.google.protobuf.Message.Builder

Specified by:

clear in interface com.google.protobuf.MessageLite.Builder

Overrides:

clear in class com.google.protobuf.GeneratedMessage.Builder<ConstraintProto.Builder>

getDescriptorForType
```
public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
```
Specified by:

getDescriptorForType in interface com.google.protobuf.Message.Builder

Specified by:

getDescriptorForType in interface com.google.protobuf.MessageOrBuilder

Overrides:

getDescriptorForType in class com.google.protobuf.GeneratedMessage.Builder<ConstraintProto.Builder>

getDefaultInstanceForType
```
public ConstraintProto getDefaultInstanceForType()
```
Specified by:

getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder

Specified by:

getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

build
```
public ConstraintProto build()
```
Specified by:

build in interface com.google.protobuf.Message.Builder

Specified by:

build in interface com.google.protobuf.MessageLite.Builder

buildPartial
```
public ConstraintProto buildPartial()
```
Specified by:

buildPartial in interface com.google.protobuf.Message.Builder

Specified by:

buildPartial in interface com.google.protobuf.MessageLite.Builder

mergeFrom
```
public ConstraintProto.Builder mergeFrom(com.google.protobuf.Message other)
```
Specified by:

mergeFrom in interface com.google.protobuf.Message.Builder

Overrides:

mergeFrom in class com.google.protobuf.AbstractMessage.Builder<ConstraintProto.Builder>

mergeFrom

public ConstraintProto.Builder mergeFrom(ConstraintProto other)

isInitialized
```
public final boolean isInitialized()
```
Specified by:

isInitialized in interface com.google.protobuf.MessageLiteOrBuilder

Overrides:

isInitialized in class com.google.protobuf.GeneratedMessage.Builder<ConstraintProto.Builder>

mergeFrom
```
public ConstraintProto.Builder mergeFrom(com.google.protobuf.CodedInputStream input,
                                         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                  throws java.io.IOException
```
Specified by:

mergeFrom in interface com.google.protobuf.Message.Builder

Specified by:

mergeFrom in interface com.google.protobuf.MessageLite.Builder

Overrides:

mergeFrom in class com.google.protobuf.AbstractMessage.Builder<ConstraintProto.Builder>

Throws:

java.io.IOException

getConstraintCase
```
public ConstraintProto.ConstraintCase getConstraintCase()
```
Specified by:

getConstraintCase in interface ConstraintProtoOrBuilder

clearConstraint

public ConstraintProto.Builder clearConstraint()

getName
```
public java.lang.String getName()
```
```
 For debug/logging only. Can be empty.
 
```
string name = 1;
Specified by:

getName in interface ConstraintProtoOrBuilder

Returns:

The name.

getNameBytes
```
public com.google.protobuf.ByteString getNameBytes()
```
```
 For debug/logging only. Can be empty.
 
```
string name = 1;
Specified by:

getNameBytes in interface ConstraintProtoOrBuilder

Returns:

The bytes for name.

setName

public ConstraintProto.Builder setName(java.lang.String value)

 For debug/logging only. Can be empty.

string name = 1;

Parameters:: value - The name to set.
Returns:: This builder for chaining.

clearName

public ConstraintProto.Builder clearName()

 For debug/logging only. Can be empty.

string name = 1;

Returns:: This builder for chaining.

setNameBytes

public ConstraintProto.Builder setNameBytes(com.google.protobuf.ByteString value)

 For debug/logging only. Can be empty.

string name = 1;

Parameters:: value - The bytes for name to set.
Returns:: This builder for chaining.

getEnforcementLiteralList

public java.util.List<java.lang.Integer> getEnforcementLiteralList()

 The constraint will be enforced iff all literals listed here are true. If
 this is empty, then the constraint will always be enforced. An enforced
 constraint must be satisfied, and an un-enforced one will simply be
 ignored.

 This is also called half-reification. To have an equivalence between a
 literal and a constraint (full reification), one must add both a constraint
 (controlled by a literal l) and its negation (controlled by the negation of
 l).

 Important: as of September 2018, only a few constraint support enforcement:
 - bool_or, bool_and, linear: fully supported.
 - interval: only support a single enforcement literal.
 - other: no support (but can be added on a per-demand basis).

repeated int32 enforcement_literal = 2;

Specified by:: getEnforcementLiteralList in interface ConstraintProtoOrBuilder
Returns:: A list containing the enforcementLiteral.

getEnforcementLiteralCount

public int getEnforcementLiteralCount()

 The constraint will be enforced iff all literals listed here are true. If
 this is empty, then the constraint will always be enforced. An enforced
 constraint must be satisfied, and an un-enforced one will simply be
 ignored.

 This is also called half-reification. To have an equivalence between a
 literal and a constraint (full reification), one must add both a constraint
 (controlled by a literal l) and its negation (controlled by the negation of
 l).

 Important: as of September 2018, only a few constraint support enforcement:
 - bool_or, bool_and, linear: fully supported.
 - interval: only support a single enforcement literal.
 - other: no support (but can be added on a per-demand basis).

repeated int32 enforcement_literal = 2;

Specified by:: getEnforcementLiteralCount in interface ConstraintProtoOrBuilder
Returns:: The count of enforcementLiteral.

getEnforcementLiteral

public int getEnforcementLiteral(int index)

 The constraint will be enforced iff all literals listed here are true. If
 this is empty, then the constraint will always be enforced. An enforced
 constraint must be satisfied, and an un-enforced one will simply be
 ignored.

 This is also called half-reification. To have an equivalence between a
 literal and a constraint (full reification), one must add both a constraint
 (controlled by a literal l) and its negation (controlled by the negation of
 l).

 Important: as of September 2018, only a few constraint support enforcement:
 - bool_or, bool_and, linear: fully supported.
 - interval: only support a single enforcement literal.
 - other: no support (but can be added on a per-demand basis).

repeated int32 enforcement_literal = 2;

Specified by:: getEnforcementLiteral in interface ConstraintProtoOrBuilder
Parameters:: index - The index of the element to return.
Returns:: The enforcementLiteral at the given index.

setEnforcementLiteral

public ConstraintProto.Builder setEnforcementLiteral(int index,
                                                     int value)

 The constraint will be enforced iff all literals listed here are true. If
 this is empty, then the constraint will always be enforced. An enforced
 constraint must be satisfied, and an un-enforced one will simply be
 ignored.

 This is also called half-reification. To have an equivalence between a
 literal and a constraint (full reification), one must add both a constraint
 (controlled by a literal l) and its negation (controlled by the negation of
 l).

 Important: as of September 2018, only a few constraint support enforcement:
 - bool_or, bool_and, linear: fully supported.
 - interval: only support a single enforcement literal.
 - other: no support (but can be added on a per-demand basis).

repeated int32 enforcement_literal = 2;

Parameters:: index - The index to set the value at.; value - The enforcementLiteral to set.
Returns:: This builder for chaining.

addEnforcementLiteral

public ConstraintProto.Builder addEnforcementLiteral(int value)

 The constraint will be enforced iff all literals listed here are true. If
 this is empty, then the constraint will always be enforced. An enforced
 constraint must be satisfied, and an un-enforced one will simply be
 ignored.

 This is also called half-reification. To have an equivalence between a
 literal and a constraint (full reification), one must add both a constraint
 (controlled by a literal l) and its negation (controlled by the negation of
 l).

 Important: as of September 2018, only a few constraint support enforcement:
 - bool_or, bool_and, linear: fully supported.
 - interval: only support a single enforcement literal.
 - other: no support (but can be added on a per-demand basis).

repeated int32 enforcement_literal = 2;

Parameters:: value - The enforcementLiteral to add.
Returns:: This builder for chaining.

addAllEnforcementLiteral

public ConstraintProto.Builder addAllEnforcementLiteral(java.lang.Iterable<? extends java.lang.Integer> values)

 The constraint will be enforced iff all literals listed here are true. If
 this is empty, then the constraint will always be enforced. An enforced
 constraint must be satisfied, and an un-enforced one will simply be
 ignored.

 This is also called half-reification. To have an equivalence between a
 literal and a constraint (full reification), one must add both a constraint
 (controlled by a literal l) and its negation (controlled by the negation of
 l).

 Important: as of September 2018, only a few constraint support enforcement:
 - bool_or, bool_and, linear: fully supported.
 - interval: only support a single enforcement literal.
 - other: no support (but can be added on a per-demand basis).

repeated int32 enforcement_literal = 2;

Parameters:: values - The enforcementLiteral to add.
Returns:: This builder for chaining.

clearEnforcementLiteral

public ConstraintProto.Builder clearEnforcementLiteral()

 The constraint will be enforced iff all literals listed here are true. If
 this is empty, then the constraint will always be enforced. An enforced
 constraint must be satisfied, and an un-enforced one will simply be
 ignored.

 This is also called half-reification. To have an equivalence between a
 literal and a constraint (full reification), one must add both a constraint
 (controlled by a literal l) and its negation (controlled by the negation of
 l).

 Important: as of September 2018, only a few constraint support enforcement:
 - bool_or, bool_and, linear: fully supported.
 - interval: only support a single enforcement literal.
 - other: no support (but can be added on a per-demand basis).

repeated int32 enforcement_literal = 2;

Returns:: This builder for chaining.

hasBoolOr
```
public boolean hasBoolOr()
```
```
 The bool_or constraint forces at least one literal to be true.
 
```
.operations_research.sat.BoolArgumentProto bool_or = 3;
Specified by:

hasBoolOr in interface ConstraintProtoOrBuilder

Returns:

Whether the boolOr field is set.

getBoolOr
```
public BoolArgumentProto getBoolOr()
```
```
 The bool_or constraint forces at least one literal to be true.
 
```
.operations_research.sat.BoolArgumentProto bool_or = 3;
Specified by:

getBoolOr in interface ConstraintProtoOrBuilder

Returns:

The boolOr.

setBoolOr

public ConstraintProto.Builder setBoolOr(BoolArgumentProto value)

 The bool_or constraint forces at least one literal to be true.

.operations_research.sat.BoolArgumentProto bool_or = 3;

setBoolOr

public ConstraintProto.Builder setBoolOr(BoolArgumentProto.Builder builderForValue)

 The bool_or constraint forces at least one literal to be true.

.operations_research.sat.BoolArgumentProto bool_or = 3;

mergeBoolOr

public ConstraintProto.Builder mergeBoolOr(BoolArgumentProto value)

 The bool_or constraint forces at least one literal to be true.

.operations_research.sat.BoolArgumentProto bool_or = 3;

clearBoolOr

public ConstraintProto.Builder clearBoolOr()

 The bool_or constraint forces at least one literal to be true.

.operations_research.sat.BoolArgumentProto bool_or = 3;

getBoolOrBuilder

public BoolArgumentProto.Builder getBoolOrBuilder()

 The bool_or constraint forces at least one literal to be true.

.operations_research.sat.BoolArgumentProto bool_or = 3;

getBoolOrOrBuilder
```
public BoolArgumentProtoOrBuilder getBoolOrOrBuilder()
```
```
 The bool_or constraint forces at least one literal to be true.
 
```
.operations_research.sat.BoolArgumentProto bool_or = 3;
Specified by:

getBoolOrOrBuilder in interface ConstraintProtoOrBuilder

hasBoolAnd

public boolean hasBoolAnd()

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

Specified by:: hasBoolAnd in interface ConstraintProtoOrBuilder
Returns:: Whether the boolAnd field is set.

getBoolAnd

public BoolArgumentProto getBoolAnd()

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

Specified by:: getBoolAnd in interface ConstraintProtoOrBuilder
Returns:: The boolAnd.

setBoolAnd

public ConstraintProto.Builder setBoolAnd(BoolArgumentProto value)

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

setBoolAnd

public ConstraintProto.Builder setBoolAnd(BoolArgumentProto.Builder builderForValue)

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

mergeBoolAnd

public ConstraintProto.Builder mergeBoolAnd(BoolArgumentProto value)

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

clearBoolAnd

public ConstraintProto.Builder clearBoolAnd()

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

getBoolAndBuilder

public BoolArgumentProto.Builder getBoolAndBuilder()

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

getBoolAndOrBuilder

public BoolArgumentProtoOrBuilder getBoolAndOrBuilder()

 The bool_and constraint forces all of the literals to be true.

 This is a "redundant" constraint in the sense that this can easily be
 encoded with many bool_or or at_most_one. It is just more space efficient
 and handled slightly differently internally.

.operations_research.sat.BoolArgumentProto bool_and = 4;

Specified by:: getBoolAndOrBuilder in interface ConstraintProtoOrBuilder

hasAtMostOne

public boolean hasAtMostOne()

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

Specified by:: hasAtMostOne in interface ConstraintProtoOrBuilder
Returns:: Whether the atMostOne field is set.

getAtMostOne

public BoolArgumentProto getAtMostOne()

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

Specified by:: getAtMostOne in interface ConstraintProtoOrBuilder
Returns:: The atMostOne.

setAtMostOne

public ConstraintProto.Builder setAtMostOne(BoolArgumentProto value)

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

setAtMostOne

public ConstraintProto.Builder setAtMostOne(BoolArgumentProto.Builder builderForValue)

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

mergeAtMostOne

public ConstraintProto.Builder mergeAtMostOne(BoolArgumentProto value)

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

clearAtMostOne

public ConstraintProto.Builder clearAtMostOne()

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

getAtMostOneBuilder

public BoolArgumentProto.Builder getAtMostOneBuilder()

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

getAtMostOneOrBuilder

public BoolArgumentProtoOrBuilder getAtMostOneOrBuilder()

 The at_most_one constraint enforces that no more than one literal is
 true at the same time.

 Note that an at most one constraint of length n could be encoded with n
 bool_and constraint with n-1 term on the right hand side. So in a sense,
 this constraint contribute directly to the "implication-graph" or the
 2-SAT part of the model.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto at_most_one = 26;

Specified by:: getAtMostOneOrBuilder in interface ConstraintProtoOrBuilder

hasExactlyOne

public boolean hasExactlyOne()

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

Specified by:: hasExactlyOne in interface ConstraintProtoOrBuilder
Returns:: Whether the exactlyOne field is set.

getExactlyOne

public BoolArgumentProto getExactlyOne()

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

Specified by:: getExactlyOne in interface ConstraintProtoOrBuilder
Returns:: The exactlyOne.

setExactlyOne

public ConstraintProto.Builder setExactlyOne(BoolArgumentProto value)

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

setExactlyOne

public ConstraintProto.Builder setExactlyOne(BoolArgumentProto.Builder builderForValue)

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

mergeExactlyOne

public ConstraintProto.Builder mergeExactlyOne(BoolArgumentProto value)

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

clearExactlyOne

public ConstraintProto.Builder clearExactlyOne()

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

getExactlyOneBuilder

public BoolArgumentProto.Builder getExactlyOneBuilder()

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

getExactlyOneOrBuilder

public BoolArgumentProtoOrBuilder getExactlyOneOrBuilder()

 The exactly_one constraint force exactly one literal to true and no more.

 Anytime a bool_or (it could have been called at_least_one) is included
 into an at_most_one, then the bool_or is actually an exactly one
 constraint, and the extra literal in the at_most_one can be set to false.
 So in this sense, this constraint is not really needed. it is just here
 for a better description of the problem structure and to facilitate some
 algorithm.

 This constraint does not support enforcement_literal. Just use a linear
 constraint if you need to enforce it. You also do not need to use it
 directly, we will extract it from the model in most situations.

.operations_research.sat.BoolArgumentProto exactly_one = 29;

Specified by:: getExactlyOneOrBuilder in interface ConstraintProtoOrBuilder

hasBoolXor
```
public boolean hasBoolXor()
```
```
 The bool_xor constraint forces an odd number of the literals to be true.
 
```
.operations_research.sat.BoolArgumentProto bool_xor = 5;
Specified by:

hasBoolXor in interface ConstraintProtoOrBuilder

Returns:

Whether the boolXor field is set.

getBoolXor
```
public BoolArgumentProto getBoolXor()
```
```
 The bool_xor constraint forces an odd number of the literals to be true.
 
```
.operations_research.sat.BoolArgumentProto bool_xor = 5;
Specified by:

getBoolXor in interface ConstraintProtoOrBuilder

Returns:

The boolXor.

setBoolXor

public ConstraintProto.Builder setBoolXor(BoolArgumentProto value)

 The bool_xor constraint forces an odd number of the literals to be true.

.operations_research.sat.BoolArgumentProto bool_xor = 5;

setBoolXor

public ConstraintProto.Builder setBoolXor(BoolArgumentProto.Builder builderForValue)

 The bool_xor constraint forces an odd number of the literals to be true.

.operations_research.sat.BoolArgumentProto bool_xor = 5;

mergeBoolXor

public ConstraintProto.Builder mergeBoolXor(BoolArgumentProto value)

 The bool_xor constraint forces an odd number of the literals to be true.

.operations_research.sat.BoolArgumentProto bool_xor = 5;

clearBoolXor

public ConstraintProto.Builder clearBoolXor()

 The bool_xor constraint forces an odd number of the literals to be true.

.operations_research.sat.BoolArgumentProto bool_xor = 5;

getBoolXorBuilder

public BoolArgumentProto.Builder getBoolXorBuilder()

 The bool_xor constraint forces an odd number of the literals to be true.

.operations_research.sat.BoolArgumentProto bool_xor = 5;

getBoolXorOrBuilder
```
public BoolArgumentProtoOrBuilder getBoolXorOrBuilder()
```
```
 The bool_xor constraint forces an odd number of the literals to be true.
 
```
.operations_research.sat.BoolArgumentProto bool_xor = 5;
Specified by:

getBoolXorOrBuilder in interface ConstraintProtoOrBuilder

hasIntDiv

public boolean hasIntDiv()

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

Specified by:: hasIntDiv in interface ConstraintProtoOrBuilder
Returns:: Whether the intDiv field is set.

getIntDiv

public LinearArgumentProto getIntDiv()

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

Specified by:: getIntDiv in interface ConstraintProtoOrBuilder
Returns:: The intDiv.

setIntDiv

public ConstraintProto.Builder setIntDiv(LinearArgumentProto value)

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

setIntDiv

public ConstraintProto.Builder setIntDiv(LinearArgumentProto.Builder builderForValue)

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

mergeIntDiv

public ConstraintProto.Builder mergeIntDiv(LinearArgumentProto value)

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

clearIntDiv

public ConstraintProto.Builder clearIntDiv()

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

getIntDivBuilder

public LinearArgumentProto.Builder getIntDivBuilder()

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

getIntDivOrBuilder

public LinearArgumentProtoOrBuilder getIntDivOrBuilder()

 The int_div constraint forces the target to equal exprs[0] / exprs[1].
 The division is "rounded" towards zero, so we can have for instance
 (2 = 12 / 5) or (-3 = -10 / 3). If you only want exact integer division,
 then you should use instead of t = a / b, the int_prod constraint
 a = b * t.

 If 0 belongs to the domain of exprs[1], then the model is deemed invalid.

.operations_research.sat.LinearArgumentProto int_div = 7;

Specified by:: getIntDivOrBuilder in interface ConstraintProtoOrBuilder