RoutingModel (com.google.ortools:ortools-java 9.12.9999 API)

java.lang.Object
- com.google.ortools.constraintsolver.RoutingModel

public class RoutingModel
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`RoutingModel.NodeNeighborsByCostClass`
`static class`	`RoutingModel.NodeNeighborsParameters`
`static class`	`RoutingModel.PickupDeliveryPosition` The position of a node in the set of pickup and delivery pairs.
`static class`	`RoutingModel.ResourceGroup` A ResourceGroup defines a set of available Resources with attributes on one or multiple dimensions.
`static class`	`RoutingModel.SecondaryOptimizer` Class used to solve a secondary model within a first solution strategy.
`static class`	`RoutingModel.VariableValuePair` Struct used to store a variable value.
`static class`	`RoutingModel.VehicleTypeContainer` Struct used to sort and store vehicles by their type.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ADDED_TYPE_REMOVED_FROM_VEHICLE` When visited, one instance of type 'T' previously added to the route (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle.
`static int`	`kTransitEvaluatorSignNegativeOrZero`
`static int`	`kTransitEvaluatorSignPositiveOrZero`
`static int`	`kTransitEvaluatorSignUnknown` Represents the sign of values returned by a transit evaluator.
`static int`	`PENALIZE_ONCE` The following enum is used to describe how the penalty cost is computed when using AddDisjunction.
`static int`	`PENALIZE_PER_INACTIVE`
`static int`	`PICKUP_AND_DELIVERY_FIFO` Deliveries must be performed in the same order as pickups.
`static int`	`PICKUP_AND_DELIVERY_LIFO` Deliveries must be performed in reverse order of pickups.
`static int`	`PICKUP_AND_DELIVERY_NO_ORDER` Any precedence is accepted.
`protected boolean`	`swigCMemOwn`
`static int`	`TYPE_ADDED_TO_VEHICLE` When visited, the number of types 'T' on the vehicle increases by one.
`static int`	`TYPE_ON_VEHICLE_UP_TO_VISIT` With the following policy, the visit enforces that type 'T' is considered on the route from its start until this node is visited.
`static int`	`TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED` The visit doesn't have an impact on the number of types 'T' on the route, as it's (virtually) added and removed directly.

Constructor Summary

Constructors
Constructor and Description
`RoutingModel(long cPtr, boolean cMemoryOwn)`
`RoutingModel(RoutingIndexManager index_manager)` Constructor taking an index manager.
`RoutingModel(RoutingIndexManager index_manager, RoutingModelParameters parameters)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`IntVar`	`activeVar(long index)` Returns the active variable of the node corresponding to index.
`IntVar`	`activeVehicleVar(int vehicle)` Returns the active variable of the vehicle.
`void`	`addAtSolutionCallback(java.lang.Runnable callback)` Adds a callback called each time a solution is found during the search.
`void`	`addAtSolutionCallback(java.lang.Runnable callback, boolean track_unchecked_neighbors)` Adds a callback called each time a solution is found during the search.
`IntBoolPair`	`addConstantDimension(long value, long capacity, boolean fix_start_cumul_to_zero, java.lang.String name)`
`IntBoolPair`	`addConstantDimensionWithSlack(long value, long capacity, long slack_max, boolean fix_start_cumul_to_zero, java.lang.String name)` Creates a dimension where the transit variable is constrained to be equal to 'value'; 'capacity' is the upper bound of the cumul variables.
`boolean`	`addDimension(int evaluator_index, long slack_max, long capacity, boolean fix_start_cumul_to_zero, java.lang.String name)` Model creation Methods to add dimensions to routes; dimensions represent quantities accumulated at nodes along the routes.
`boolean`	`AddDimensionWithCumulDependentVehicleTransitAndCapacity(int[] fixed_evaluator_indices, int[] cumul_dependent_evaluator_indices, long slack_max, long[] vehicle_capacities, boolean fix_start_cumul_to_zero, java.lang.String name)` Creates a dimension where the transit variable on arc i->j is the sum of: - A "fixed" transit value, obtained from the fixed_evaluator_index for this vehicle, referencing evaluators in transit_evaluators_, and - A FloatSlopePiecewiseLinearFunction of the cumul of node i, obtained from the cumul_dependent_evaluator_index of this vehicle, pointing to an evaluator in cumul_dependent_transit_evaluators_.
`boolean`	`addDimensionWithVehicleCapacity(int evaluator_index, long slack_max, long[] vehicle_capacities, boolean fix_start_cumul_to_zero, java.lang.String name)`
`boolean`	`addDimensionWithVehicleTransitAndCapacity(int[] evaluator_indices, long slack_max, long[] vehicle_capacities, boolean fix_start_cumul_to_zero, java.lang.String name)`
`boolean`	`addDimensionWithVehicleTransits(int[] evaluator_indices, long slack_max, long capacity, boolean fix_start_cumul_to_zero, java.lang.String name)`
`int`	`addDisjunction(long[] indices)` Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active.
`int`	`addDisjunction(long[] indices, long penalty)` Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active.
`int`	`addDisjunction(long[] indices, long penalty, long max_cardinality)` Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active.
`int`	`addDisjunction(long[] indices, long penalty, long max_cardinality, int penalty_cost_behavior)` Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active.
`void`	`AddEnterSearchCallback(java.lang.Runnable callback)`
`void`	`addHardTypeIncompatibility(int type1, int type2)` Incompatibilities: Two nodes with "hard" incompatible types cannot share the same route at all, while with a "temporal" incompatibility they can't be on the same route at the same time.
`void`	`addIntervalToAssignment(IntervalVar interval)`
`void`	`addLocalSearchFilter(LocalSearchFilter filter)` Adds a custom local search filter to the list of filters used to speed up local search by pruning unfeasible variable assignments.
`void`	`addLocalSearchOperator(LocalSearchOperator ls_operator)` Adds a local search operator to the set of operators used to solve the vehicle routing problem.
`IntBoolPair`	`addMatrixDimension(long[][] values, long capacity, boolean fix_start_cumul_to_zero, java.lang.String name)` Creates a dimension where the transit variable is constrained to be equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of the cumul variables.
`void`	`addPickupAndDelivery(long pickup, long delivery)` Notifies that index1 and index2 form a pair of nodes which should belong to the same route.
`void`	`addPickupAndDeliverySets(int pickup_disjunction, int delivery_disjunction)` Same as AddPickupAndDelivery but notifying that the performed node from the disjunction of index 'pickup_disjunction' is on the same route as the performed node from the disjunction of index 'delivery_disjunction'.
`void`	`addRequiredTypeAlternativesWhenAddingType(int dependent_type, SWIGTYPE_p_absl__flat_hash_setT_int_t required_type_alternatives)` If type_D depends on type_R when adding type_D, any node_D of type_D and VisitTypePolicy TYPE_ADDED_TO_VEHICLE or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its vehicle at the time node_D is visited.
`void`	`addRequiredTypeAlternativesWhenRemovingType(int dependent_type, SWIGTYPE_p_absl__flat_hash_setT_int_t required_type_alternatives)` The following requirements apply when visiting dependent nodes that remove their type from the route, i.e. type_R must be on the vehicle when type_D of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is visited.
`RoutingModel.ResourceGroup`	`AddResourceGroup()` Adds a resource group to the routing model and returns a pointer to it.
`void`	`AddRestoreDimensionValuesResetCallback(java.lang.Runnable callback)`
`void`	`AddRouteConstraint(SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_long_t_const_RF_t route_evaluator)`
`void`	`AddRouteConstraint(SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_long_t_const_RF_t route_evaluator, boolean costs_are_homogeneous_across_vehicles)`
`void`	`addSearchMonitor(SearchMonitor monitor)` Adds a search monitor to the search used to solve the routing model.
`void`	`addSoftSameVehicleConstraint(long[] indices, long cost)` Adds a soft constraint to force a set of variable indices to be on the same vehicle.
`void`	`addTemporalTypeIncompatibility(int type1, int type2)`
`void`	`addToAssignment(IntVar var)` Adds an extra variable to the vehicle routing assignment.
`void`	`addVariableMaximizedByFinalizer(IntVar var)` Adds a variable to maximize in the solution finalizer (see above for information on the solution finalizer).
`void`	`addVariableMinimizedByFinalizer(IntVar var)` Adds a variable to minimize in the solution finalizer.
`void`	`addVariableTargetToFinalizer(IntVar var, long target)` Add a variable to set the closest possible to the target value in the solution finalizer.
`IntBoolPair`	`addVectorDimension(long[] values, long capacity, boolean fix_start_cumul_to_zero, java.lang.String name)` Creates a dimension where the transit variable is constrained to be equal to 'values[i]' for node i; 'capacity' is the upper bound of the cumul variables.
`void`	`AddWeightedVariableMaximizedByFinalizer(IntVar var, long cost)` Adds a variable to maximize in the solution finalizer, with a weighted priority: the higher the more priority it has.
`void`	`AddWeightedVariableMinimizedByFinalizer(IntVar var, long cost)` Adds a variable to minimize in the solution finalizer, with a weighted priority: the higher the more priority it has.
`void`	`AddWeightedVariableTargetToFinalizer(IntVar var, long target, long cost)` Same as above with a weighted priority: the higher the cost, the more priority it has to be set close to the target value.
`IntVar`	`applyLocks(long[] locks)` Applies a lock chain to the next search.
`boolean`	`applyLocksToAllVehicles(long[][] locks, boolean close_routes)` Applies lock chains to all vehicles to the next search, such that locks[p] is the lock chain for route p.
`boolean`	`arcIsMoreConstrainedThanArc(long from, long to1, long to2)` Returns whether the arc from->to1 is more constrained than from->to2, taking into account, in order: - whether the destination node isn't an end node - whether the destination node is mandatory - whether the destination node is bound to the same vehicle as the source - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) It then breaks ties using, in order: - the arc cost (taking unperformed penalties into account) - the size of the vehicle vars of "to1" and "to2" (lowest size wins) - the value: the lowest value of the indices to1 and to2 wins.
`boolean`	`AreRoutesInterdependent(SWIGTYPE_p_operations_research__RoutingSearchParameters parameters)` Returns true if routes are interdependent.
`void`	`assignmentToRoutes(Assignment assignment, long[][] routes)` Converts the solution in the given assignment to routes for all vehicles.
`void`	`CancelSearch()` Cancels the current search.
`boolean`	`CheckIfAssignmentIsFeasible(Assignment assignment, boolean call_at_solution_monitors)` Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair containing the minimum and maximum of the CumulVar of the jth node on route i.
`boolean`	`checkLimit()` Returns true if the search limit has been crossed with the given time offset.
`boolean`	`checkLimit(SWIGTYPE_p_absl__Duration offset)` Returns true if the search limit has been crossed with the given time offset.
`void`	`closeModel()` Closes the current routing model; after this method is called, no modification to the model can be done, but RoutesToAssignment becomes available.
`void`	`closeModelWithParameters(RoutingSearchParameters search_parameters)` Same as above taking search parameters (as of 10/2015 some the parameters have to be set when closing the model).
`Assignment`	`compactAndCheckAssignment(Assignment assignment)` Same as CompactAssignment() but also checks the validity of the final compact solution; if it is not valid, no attempts to repair it are made (instead, the method returns nullptr).
`Assignment`	`compactAssignment(Assignment assignment)` Converts the solution in the given assignment to routes for all vehicles.
`long`	`computeLowerBound()` Computes a lower bound to the routing problem solving a linear assignment problem.
`boolean`	`costsAreHomogeneousAcrossVehicles()` Whether costs are homogeneous across all vehicles.
`IntVar`	`costVar()` Returns the global cost variable which is being minimized.
`SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t`	`CumulDependentTransitCallback(int callback_index)`
`java.lang.String`	`debugOutputAssignment(Assignment solution_assignment, java.lang.String dimension_to_print)` Print some debugging information about an assignment, including the feasible intervals of the CumulVar for dimension "dimension_to_print" at each step of the routes.
`void`	`delete()`
`boolean`	`enable_deep_serialization()` Returns the value of the internal enable_deep_serialization_ parameter.
`long`	`end(int vehicle)` Returns the variable index of the ending node of a vehicle route.
`Assignment`	`FastSolveFromAssignmentWithParameters(Assignment assignment, RoutingSearchParameters search_parameters, boolean check_solution_in_cp)` Improves a given assignment using unchecked local search.
`Assignment`	`FastSolveFromAssignmentWithParameters(Assignment assignment, RoutingSearchParameters search_parameters, boolean check_solution_in_cp, SWIGTYPE_p_absl__flat_hash_setT_operations_research__IntVar_p_t touched)` Improves a given assignment using unchecked local search.
`protected void`	`finalize()`
`long[]`	`getAmortizedLinearCostFactorOfVehicles()`
`long[]`	`getAmortizedQuadraticCostFactorOfVehicles()`
`long`	`getArcCostForClass(long from_index, long to_index, long cost_class_index)` Returns the cost of the segment between two nodes for a given cost class.
`long`	`getArcCostForFirstSolution(long from_index, long to_index)` Returns the cost of the arc in the context of the first solution strategy.
`long`	`getArcCostForVehicle(long from_index, long to_index, long vehicle)` Returns the cost of the transit arc between two nodes for a given vehicle.
`int`	`getCostClassesCount()` Returns the number of different cost classes in the model.
`int`	`getCostClassIndexOfVehicle(long vehicle)` Get the cost class index of the given vehicle.
`static long`	`getCPtr(RoutingModel obj)`
`SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t`	`GetDeliveryPosition(long node_index)` Returns the pickup and delivery positions where the node is a delivery.
`long`	`getDepot()` Returns the variable index of the first starting or ending node of all routes.
`RoutingDimension`	`getDimensionOrDie(java.lang.String dimension_name)` Returns a dimension from its name.
`int`	`GetDimensionResourceGroupIndex(RoutingDimension dimension)` Returns the index of the resource group attached to the dimension.
`int[]`	`GetDimensionResourceGroupIndices(RoutingDimension dimension)` Returns the indices of resource groups for this dimension.
`SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t`	`GetDimensionsWithGlobalCumulOptimizers()` Returns the dimensions which have [global\|local]_dimension_optimizers_.
`SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t`	`GetDimensionsWithLocalCumulOptimizers()`
`int[]`	`getDisjunctionIndices(long index)` Returns the indices of the disjunctions to which an index belongs.
`long`	`getDisjunctionMaxCardinality(int index)` Returns the maximum number of possible active nodes of the node disjunction of index 'index'.
`long[]`	`GetDisjunctionNodeIndices(int index)` Returns the variable indices of the nodes in the disjunction of index 'index'.
`long`	`getDisjunctionPenalty(int index)` Returns the penalty of the node disjunction of index 'index'.
`int`	`GetDisjunctionPenaltyCostBehavior(int index)` Returns the PenaltyCostBehavior used by the disjunction of index 'index'.
`SWIGTYPE_p_std__optionalT_long_t`	`GetFirstMatchingPickupDeliverySibling(long node, SWIGTYPE_p_std__functionT_bool_flongF_t is_match)`
`Assignment`	`GetFirstSolutionHint()` Returns the current hint assignment.
`long`	`getFixedCostOfVehicle(int vehicle)` Returns the route fixed cost taken into account if the route of the vehicle is not empty, aka there's at least one node on the route other than the first and last nodes.
`long`	`getHomogeneousCost(long from_index, long to_index)` Returns the cost of the segment between two nodes supposing all vehicle costs are the same (returns the cost for the first vehicle otherwise).
`static int`	`getKNoDimension()` Constant used to express the "no dimension" index, returned when a dimension name does not correspond to an actual dimension.
`static int`	`getKNoDisjunction()` Constant used to express the "no disjunction" index, returned when a node does not appear in any disjunction.
`static long`	`getKNoPenalty()` Constant used to express a hard constraint instead of a soft penalty.
`int`	`GetMaximumNumberOfActiveVehicles()` Returns the maximum number of active vehicles.
`SWIGTYPE_p_std__atomicT_bool_t`	`GetMutableCPInterrupt()` Returns the atomic<bool> to stop the CP solver.
`SWIGTYPE_p_std__atomicT_bool_t`	`GetMutableCPSatInterrupt()` Returns the atomic<bool> to stop the CP-SAT solver.
`RoutingDimension`	`getMutableDimension(java.lang.String dimension_name)` Returns a dimension from its name.
`SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer`	`GetMutableGlobalCumulLPOptimizer(RoutingDimension dimension)` Returns the global/local dimension cumul optimizer for a given dimension, or nullptr if there is none.
`SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer`	`GetMutableGlobalCumulMPOptimizer(RoutingDimension dimension)`
`SWIGTYPE_p_operations_research__LocalDimensionCumulOptimizer`	`GetMutableLocalCumulLPOptimizer(RoutingDimension dimension)`
`int`	`getNonZeroCostClassesCount()` Ditto, minus the 'always zero', built-in cost class.
`long`	`getNumberOfDecisionsInFirstSolution(RoutingSearchParameters search_parameters)` Returns statistics on first solution search, number of decisions sent to filters, number of decisions rejected by filters.
`int`	`getNumberOfDisjunctions()` Returns the number of node disjunctions in the model.
`long`	`getNumberOfRejectsInFirstSolution(RoutingSearchParameters search_parameters)`
`int`	`getNumberOfVisitTypes()`
`int`	`getNumOfSingletonNodes()` Returns the number of non-start/end nodes which do not appear in a pickup/delivery pair.
`RoutingModel.NodeNeighborsByCostClass`	`GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used)` Returns neighbors of all nodes for every cost class.
`RoutingModel.NodeNeighborsByCostClass`	`GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used, boolean add_vehicle_starts_to_neighbors)` Returns neighbors of all nodes for every cost class.
`RoutingModel.NodeNeighborsByCostClass`	`GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used, boolean add_vehicle_starts_to_neighbors, boolean add_vehicle_ends_to_neighbors)` Returns neighbors of all nodes for every cost class.
`RoutingModel.NodeNeighborsByCostClass`	`GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used, boolean add_vehicle_starts_to_neighbors, boolean add_vehicle_ends_to_neighbors, boolean only_sort_neighbors_for_partial_neighborhoods)` Returns neighbors of all nodes for every cost class.
`RoutingModel.NodeNeighborsByCostClass`	`GetOrCreateNodeNeighborsByCostClass(RoutingModel.NodeNeighborsParameters params)` Returns parameters.num_neighbors neighbors of all nodes for every cost class.
`int[]`	`GetPairIndicesOfType(int type)`
`PathsMetadata`	`GetPathsMetadata()`
`int`	`getPickupAndDeliveryPolicyOfVehicle(int vehicle)`
`SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t`	`GetPickupPosition(long node_index)` Returns the pickup and delivery positions where the node is a pickup.
`java.lang.String`	`getPrimaryConstrainedDimension()` Get the primary constrained dimension, or an empty string if it is unset.
`SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t`	`GetRequiredTypeAlternativesWhenAddingType(int type)` Returns the set of requirement alternatives when adding the given type.
`SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t`	`GetRequiredTypeAlternativesWhenRemovingType(int type)` Returns the set of requirement alternatives when removing the given type.
`RoutingModel.ResourceGroup`	`GetResourceGroup(int rg_index)`
`SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__RoutingModel__ResourceGroup_t_t`	`GetResourceGroups()`
`SWIGTYPE_p_std__optionalT_long_t`	`GetRouteCost(long[] route)`
`int`	`GetSameActivityGroupOfIndex(int node)` Returns the same activity group of the node.
`int`	`GetSameActivityGroupsCount()` Returns the number of same activity groups.
`int[]`	`GetSameActivityIndicesOfGroup(int group)` Returns variable indices of nodes in the same activity group.
`int[]`	`GetSameActivityIndicesOfIndex(int node)` Returns variable indices of nodes constrained to have the same activity.
`SWIGTYPE_p_std__vectorT_std__pairT_long_long_t_t`	`GetSameVehicleClassArcs(long from_index, long to_index)` Returns all arcs which are equivalent to the {from_index, to_index} arc wrt vehicle classes.
`int[]`	`getSameVehicleIndicesOfIndex(int node)` Returns variable indices of nodes constrained to be on the same route.
`int[]`	`GetSingleNodesOfType(int type)`
`SWIGTYPE_p_absl__flat_hash_setT_int_t`	`getTemporalTypeIncompatibilitiesOfType(int type)`
`SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_p_t`	`GetUnaryDimensions()` Returns dimensions for which all transit evaluators are unary.
`int`	`getVehicleClassesCount()` Returns the number of different vehicle classes in the model.
`int`	`getVehicleClassIndexOfVehicle(long vehicle)`
`int`	`GetVehicleOfClass(int vehicle_class)` Returns a vehicle of the given vehicle class, and -1 if there are no vehicles for this class.
`SWIGTYPE_p_std__dequeT_int_t`	`GetVehiclesOfSameClass(long start_end_index)` Returns indices of the vehicles which are in the same vehicle class as the vehicle starting or ending at start_end_index.
`RoutingModel.VehicleTypeContainer`	`GetVehicleTypeContainer()`
`int`	`getVisitType(long index)`
`int`	`GetVisitTypePolicy(long index)`
`boolean`	`hasDimension(java.lang.String dimension_name)` Returns true if a dimension exists for a given dimension name.
`boolean`	`HasGlobalCumulOptimizer(RoutingDimension dimension)` Returns whether the given dimension has global/local cumul optimizers.
`boolean`	`hasHardTypeIncompatibilities()` Returns true iff any hard (resp. temporal) type incompatibilities have been added to the model.
`boolean`	`HasLocalCumulOptimizer(RoutingDimension dimension)`
`boolean`	`HasMandatoryDisjunctions()` Returns true if the model contains mandatory disjunctions (ones with kNoPenalty as penalty).
`boolean`	`HasMaxCardinalityConstrainedDisjunctions()` Returns true if the model contains at least one disjunction which is constrained by its max_cardinality.
`boolean`	`hasSameVehicleTypeRequirements()` Returns true iff any same-route (resp. temporal) type requirements have been added to the model.
`boolean`	`hasTemporalTypeIncompatibilities()`
`boolean`	`hasTemporalTypeRequirements()`
`boolean`	`hasVehicleWithCostClassIndex(int cost_class_index)` Returns true iff the model contains a vehicle with the given cost_class_index.
`void`	`ignoreDisjunctionsAlreadyForcedToZero()` SPECIAL: Makes the solver ignore all the disjunctions whose active variables are all trivially zero (i.e.
`boolean`	`IsDelivery(long node_index)`
`boolean`	`isEnd(long index)` Returns true if 'index' represents the last node of a route.
`boolean`	`isMatchingModel()` Returns true if a vehicle/node matching problem is detected.
`boolean`	`IsPickup(long node_index)` Returns whether the node is a pickup (resp. delivery).
`boolean`	`isStart(long index)` Returns true if 'index' represents the first node of a route.
`boolean`	`isVehicleAllowedForIndex(int vehicle, long index)` Returns true if a vehicle is allowed to visit a given node.
`boolean`	`isVehicleUsed(Assignment assignment, int vehicle)` Returns true if the route of 'vehicle' is non empty in 'assignment'.
`boolean`	`IsVehicleUsedWhenEmpty(int vehicle)`
`DecisionBuilder`	`makeGuidedSlackFinalizer(RoutingDimension dimension, java.util.function.LongUnaryOperator initializer)` The next few members are in the public section only for testing purposes.
`DecisionBuilder`	`makeSelfDependentDimensionFinalizer(RoutingDimension dimension)` MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a self-dependent dimension.
`Assignment`	`mutablePreAssignment()`
`long`	`next(Assignment assignment, long index)` Assignment inspection Returns the variable index of the node directly after the node corresponding to 'index' in 'assignment'.
`IntVar[]`	`nexts()` Returns all next variables of the model, such that Nexts(i) is the next variable of the node corresponding to i.
`IntVar`	`nextVar(long index)` Returns the next variable of the node corresponding to index.
`int`	`nodes()` Sizes and indices Returns the number of nodes in the model.
`long`	`objective_lower_bound()` Returns the current lower bound found by internal solvers during the search.
`Assignment`	`preAssignment()` Returns an assignment used to fix some of the variables of the problem.
`Assignment`	`readAssignment(java.lang.String file_name)` Reads an assignment from a file and returns the current solution.
`Assignment`	`readAssignmentFromRoutes(long[][] routes, boolean ignore_inactive_indices)` Restores the routes as the current solution.
`int`	`RegisterCumulDependentTransitCallback(SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t callback)`
`int`	`registerTransitCallback(java.util.function.LongBinaryOperator callback)`
`int`	`registerTransitCallback(java.util.function.LongBinaryOperator callback, int sign)`
`int`	`registerTransitMatrix(long[][] values)`
`int`	`registerUnaryTransitCallback(java.util.function.LongUnaryOperator callback)`
`int`	`registerUnaryTransitCallback(java.util.function.LongUnaryOperator callback, int sign)`
`int`	`registerUnaryTransitVector(long[] values)` Registers 'callback' and returns its index.
`IntVar`	`ResourceVar(int vehicle, int resource_group)` Returns the resource variable for the given vehicle index in the given resource group.
`IntVar[]`	`ResourceVars(int resource_group)` Returns vehicle resource variables for a given resource group, such that ResourceVars(r_g)[v] is the resource variable for vehicle 'v' in resource group 'r_g'.
`Assignment`	`restoreAssignment(Assignment solution)` Restores an assignment as a solution in the routing model and returns the new solution.
`boolean`	`routesToAssignment(long[][] routes, boolean ignore_inactive_indices, boolean close_routes, Assignment assignment)` Fills an assignment from a specification of the routes of the vehicles.
`void`	`setAllowedVehiclesForIndex(int[] vehicles, long index)` Sets the vehicles which can visit a given node.
`void`	`setAmortizedCostFactorsOfAllVehicles(long linear_cost_factor, long quadratic_cost_factor)` The following methods set the linear and quadratic cost factors of vehicles (must be positive values).
`void`	`setAmortizedCostFactorsOfVehicle(long linear_cost_factor, long quadratic_cost_factor, int vehicle)` Sets the linear and quadratic cost factor of the given vehicle.
`void`	`setArcCostEvaluatorOfAllVehicles(int evaluator_index)` Sets the cost function of the model such that the cost of a segment of a route between node 'from' and 'to' is evaluator(from, to), whatever the route or vehicle performing the route.
`void`	`setArcCostEvaluatorOfVehicle(int evaluator_index, int vehicle)` Sets the cost function for a given vehicle route.
`void`	`setAssignmentFromOtherModelAssignment(Assignment target_assignment, RoutingModel source_model, Assignment source_assignment)` Given a "source_model" and its "source_assignment", resets "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ if costs aren't homogeneous across vehicles) of "this" model, with the values set according to those in "other_assignment".
`void`	`setFirstSolutionEvaluator(java.util.function.LongBinaryOperator evaluator)` Gets/sets the evaluator used during the search.
`void`	`SetFirstSolutionHint(Assignment hint)` Adds a hint to be used by first solution strategies.
`void`	`setFixedCostOfAllVehicles(long cost)` Sets the fixed cost of all vehicle routes.
`void`	`setFixedCostOfVehicle(long cost, int vehicle)` Sets the fixed cost of one vehicle route.
`void`	`SetMaximumNumberOfActiveVehicles(int max_active_vehicles)` Constrains the maximum number of active vehicles, aka the number of vehicles which do not have an empty route.
`void`	`SetPathEnergyCostOfVehicle(java.lang.String force, java.lang.String distance, long cost_per_unit, int vehicle)`
`void`	`SetPathEnergyCostsOfVehicle(java.lang.String force, java.lang.String distance, long threshold, long cost_per_unit_below_threshold, long cost_per_unit_above_threshold, int vehicle)`
`void`	`setPickupAndDeliveryPolicyOfAllVehicles(int policy)` Sets the Pickup and delivery policy of all vehicles.
`void`	`setPickupAndDeliveryPolicyOfVehicle(int policy, int vehicle)`
`void`	`setPrimaryConstrainedDimension(java.lang.String dimension_name)` Set the given dimension as "primary constrained".
`void`	`SetVehicleUsedWhenEmpty(boolean is_used, int vehicle)`
`void`	`setVisitType(long index, int type, int type_policy)`
`long`	`size()` Returns the number of next variables in the model.
`Assignment`	`solve()` Solves the current routing model; closes the current model.
`Assignment`	`solve(Assignment assignment)` Solves the current routing model; closes the current model.
`Assignment`	`SolveFromAssignmentsWithParameters(SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t assignments, RoutingSearchParameters search_parameters)` Same as above but will try all assignments in order as first solutions until one succeeds.
`Assignment`	`SolveFromAssignmentsWithParameters(SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t assignments, RoutingSearchParameters search_parameters, SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t solutions)` Same as above but will try all assignments in order as first solutions until one succeeds.
`Assignment`	`solveFromAssignmentWithParameters(Assignment assignment, RoutingSearchParameters search_parameters)` Same as above, except that if assignment is not null, it will be used as the initial solution.
`Solver`	`solver()` Returns the underlying constraint solver.
`Assignment`	`SolveWithIteratedLocalSearch(RoutingSearchParameters search_parameters)` Solves the current routing model by using an Iterated Local Search approach.
`Assignment`	`solveWithParameters(RoutingSearchParameters search_parameters)` Solves the current routing model with the given parameters.
`long`	`start(int vehicle)` Model inspection.
`RoutingSearchStatus.Value`	`status()` Returns the current status of the routing model.
`static long`	`swigRelease(RoutingModel obj)`
`SWIGTYPE_p_absl__Duration`	`TimeBuffer()` Returns the time buffer to safely return a solution.
`long`	`unperformedPenalty(long var_index)` Get the "unperformed" penalty of a node.
`long`	`unperformedPenaltyOrValue(long default_value, long var_index)` Same as above except that it returns default_value instead of 0 when penalty is not well defined (default value is passed as first argument to simplify the usage of the method in a callback).
`void`	`UpdateTimeLimit(SWIGTYPE_p_absl__Duration time_limit)` Updates the time limit of the search limit.
`int`	`VehicleIndex(long index)` Returns the vehicle of the given start/end index, and -1 if the given index is not a vehicle start/end.
`IntVar`	`VehicleRouteConsideredVar(int vehicle)` Returns the variable specifying whether or not the given vehicle route is considered for costs and constraints.
`int`	`vehicles()` Returns the number of vehicle routes in the model.
`IntVar`	`vehicleVar(long index)` Returns the vehicle variable of the node corresponding to index.
`IntVar[]`	`vehicleVars()` Returns all vehicle variables of the model, such that VehicleVars(i) is the vehicle variable of the node corresponding to i.
`boolean`	`writeAssignment(java.lang.String file_name)` Writes the current solution to a file containing an AssignmentProto.

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

- Field Detail
  - swigCMemOwn
```
protected transient boolean swigCMemOwn
```
  - PICKUP_AND_DELIVERY_NO_ORDER
```
public static final int PICKUP_AND_DELIVERY_NO_ORDER
```
    Any precedence is accepted.
  - PICKUP_AND_DELIVERY_LIFO
```
public static final int PICKUP_AND_DELIVERY_LIFO
```
    Deliveries must be performed in reverse order of pickups.
  - PICKUP_AND_DELIVERY_FIFO
```
public static final int PICKUP_AND_DELIVERY_FIFO
```
    Deliveries must be performed in the same order as pickups.
  - kTransitEvaluatorSignUnknown
```
public static final int kTransitEvaluatorSignUnknown
```
    Represents the sign of values returned by a transit evaluator.
  - kTransitEvaluatorSignPositiveOrZero
```
public static final int kTransitEvaluatorSignPositiveOrZero
```
  - kTransitEvaluatorSignNegativeOrZero
```
public static final int kTransitEvaluatorSignNegativeOrZero
```
  - PENALIZE_ONCE
```
public static final int PENALIZE_ONCE
```
    The following enum is used to describe how the penalty cost is computed
    when using AddDisjunction.
  - PENALIZE_PER_INACTIVE
```
public static final int PENALIZE_PER_INACTIVE
```
  - TYPE_ADDED_TO_VEHICLE
```
public static final int TYPE_ADDED_TO_VEHICLE
```
    When visited, the number of types 'T' on the vehicle increases by one.
  - ADDED_TYPE_REMOVED_FROM_VEHICLE
```
public static final int ADDED_TYPE_REMOVED_FROM_VEHICLE
```
    When visited, one instance of type 'T' previously added to the route
    (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle.
    If the type was not previously added to the route or all added instances
    have already been removed, this visit has no effect on the types.
  - TYPE_ON_VEHICLE_UP_TO_VISIT
```
public static final int TYPE_ON_VEHICLE_UP_TO_VISIT
```
    With the following policy, the visit enforces that type 'T' is
    considered on the route from its start until this node is visited.
  - TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED
```
public static final int TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED
```
    The visit doesn't have an impact on the number of types 'T' on the
    route, as it's (virtually) added and removed directly.
    This policy can be used for visits which are part of an incompatibility
    or requirement set without affecting the type count on the route.
- Constructor Detail
  - RoutingModel
```
public RoutingModel(long cPtr,
                    boolean cMemoryOwn)
```
  - RoutingModel
```
public RoutingModel(RoutingIndexManager index_manager)
```
    Constructor taking an index manager. The version which does not take
    RoutingModelParameters is equivalent to passing
    DefaultRoutingModelParameters().
  - RoutingModel
```
public RoutingModel(RoutingIndexManager index_manager,
                    RoutingModelParameters parameters)
```
- Method Detail
  - getCPtr
```
public static long getCPtr(RoutingModel obj)
```
  - swigRelease
```
public static long swigRelease(RoutingModel obj)
```
  - finalize
```
protected void finalize()
```
    Overrides:
    
    finalize in class java.lang.Object
  - delete
```
public void delete()
```
  - getKNoPenalty
```
public static long getKNoPenalty()
```
    Constant used to express a hard constraint instead of a soft penalty.
  - getKNoDisjunction
```
public static int getKNoDisjunction()
```
    Constant used to express the "no disjunction" index, returned when a node
    does not appear in any disjunction.
  - getKNoDimension
```
public static int getKNoDimension()
```
    Constant used to express the "no dimension" index, returned when a
    dimension name does not correspond to an actual dimension.
  - registerUnaryTransitVector
```
public int registerUnaryTransitVector(long[] values)
```
    Registers 'callback' and returns its index.
    The sign parameter allows to notify the solver that the callback only
    return values of the given sign. This can help the solver, but passing
    an incorrect sign may crash in non-opt compilation mode, and yield
    incorrect results in opt.
  - registerUnaryTransitCallback
```
public int registerUnaryTransitCallback(java.util.function.LongUnaryOperator callback,
                                        int sign)
```
  - registerUnaryTransitCallback
```
public int registerUnaryTransitCallback(java.util.function.LongUnaryOperator callback)
```
  - registerTransitMatrix
```
public int registerTransitMatrix(long[][] values)
```
  - registerTransitCallback
```
public int registerTransitCallback(java.util.function.LongBinaryOperator callback,
                                   int sign)
```
  - registerTransitCallback
```
public int registerTransitCallback(java.util.function.LongBinaryOperator callback)
```
  - RegisterCumulDependentTransitCallback
```
public int RegisterCumulDependentTransitCallback(SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t callback)
```
  - CumulDependentTransitCallback
```
public SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t CumulDependentTransitCallback(int callback_index)
```
  - addDimension
```
public boolean addDimension(int evaluator_index,
                            long slack_max,
                            long capacity,
                            boolean fix_start_cumul_to_zero,
                            java.lang.String name)
```
    Model creation
    Methods to add dimensions to routes; dimensions represent quantities
    accumulated at nodes along the routes. They represent quantities such as
    weights or volumes carried along the route, or distance or times.
    Quantities at a node are represented by "cumul" variables and the increase
    or decrease of quantities between nodes are represented by "transit"
    variables. These variables are linked as follows:
    if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i)
    where slack is a positive slack variable (can represent waiting times for
    a time dimension).
    Setting the value of fix_start_cumul_to_zero to true will force the
    "cumul" variable of the start node of all vehicles to be equal to 0.
    Creates a dimension where the transit variable is constrained to be
    equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the
    slack variable and 'capacity' is the upper bound of the cumul variables.
    'name' is the name used to reference the dimension; this name is used to
    get cumul and transit variables from the routing model.
    Returns false if a dimension with the same name has already been created
    (and doesn't create the new dimension).
    Takes ownership of the callback 'evaluator'.
  - addDimensionWithVehicleTransits
```
public boolean addDimensionWithVehicleTransits(int[] evaluator_indices,
                                               long slack_max,
                                               long capacity,
                                               boolean fix_start_cumul_to_zero,
                                               java.lang.String name)
```
  - addDimensionWithVehicleCapacity
```
public boolean addDimensionWithVehicleCapacity(int evaluator_index,
                                               long slack_max,
                                               long[] vehicle_capacities,
                                               boolean fix_start_cumul_to_zero,
                                               java.lang.String name)
```
  - addDimensionWithVehicleTransitAndCapacity
```
public boolean addDimensionWithVehicleTransitAndCapacity(int[] evaluator_indices,
                                                         long slack_max,
                                                         long[] vehicle_capacities,
                                                         boolean fix_start_cumul_to_zero,
                                                         java.lang.String name)
```
  - AddDimensionWithCumulDependentVehicleTransitAndCapacity
```
public boolean AddDimensionWithCumulDependentVehicleTransitAndCapacity(int[] fixed_evaluator_indices,
                                                                       int[] cumul_dependent_evaluator_indices,
                                                                       long slack_max,
                                                                       long[] vehicle_capacities,
                                                                       boolean fix_start_cumul_to_zero,
                                                                       java.lang.String name)
```
    Creates a dimension where the transit variable on arc i->j is the sum of:
    - A "fixed" transit value, obtained from the fixed_evaluator_index for
    this vehicle, referencing evaluators in transit_evaluators_, and
    - A FloatSlopePiecewiseLinearFunction of the cumul of node i, obtained
    from the cumul_dependent_evaluator_index of this vehicle, pointing to
    an evaluator in cumul_dependent_transit_evaluators_.
  - addConstantDimensionWithSlack
```
public IntBoolPair addConstantDimensionWithSlack(long value,
                                                 long capacity,
                                                 long slack_max,
                                                 boolean fix_start_cumul_to_zero,
                                                 java.lang.String name)
```
    Creates a dimension where the transit variable is constrained to be
    equal to 'value'; 'capacity' is the upper bound of the cumul variables.
    'name' is the name used to reference the dimension; this name is used to
    get cumul and transit variables from the routing model.
    Returns a pair consisting of an index to the registered unary transit
    callback and a bool denoting whether the dimension has been created.
    It is false if a dimension with the same name has already been created
    (and doesn't create the new dimension but still register a new callback).
  - addConstantDimension
```
public IntBoolPair addConstantDimension(long value,
                                        long capacity,
                                        boolean fix_start_cumul_to_zero,
                                        java.lang.String name)
```
  - addVectorDimension
```
public IntBoolPair addVectorDimension(long[] values,
                                      long capacity,
                                      boolean fix_start_cumul_to_zero,
                                      java.lang.String name)
```
    Creates a dimension where the transit variable is constrained to be
    equal to 'values[i]' for node i; 'capacity' is the upper bound of
    the cumul variables. 'name' is the name used to reference the dimension;
    this name is used to get cumul and transit variables from the routing
    model.
    Returns a pair consisting of an index to the registered unary transit
    callback and a bool denoting whether the dimension has been created.
    It is false if a dimension with the same name has already been created
    (and doesn't create the new dimension but still register a new callback).
  - addMatrixDimension
```
public IntBoolPair addMatrixDimension(long[][] values,
                                      long capacity,
                                      boolean fix_start_cumul_to_zero,
                                      java.lang.String name)
```
    Creates a dimension where the transit variable is constrained to be
    equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of
    the cumul variables. 'name' is the name used to reference the dimension;
    this name is used to get cumul and transit variables from the routing
    model.
    Returns a pair consisting of an index to the registered transit callback
    and a bool denoting whether the dimension has been created.
    It is false if a dimension with the same name has already been created
    (and doesn't create the new dimension but still register a new callback).
  - GetUnaryDimensions
```
public SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_p_t GetUnaryDimensions()
```
    Returns dimensions for which all transit evaluators are unary.
  - GetDimensionsWithGlobalCumulOptimizers
```
public SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t GetDimensionsWithGlobalCumulOptimizers()
```
    Returns the dimensions which have [global|local]_dimension_optimizers_.
  - GetDimensionsWithLocalCumulOptimizers
```
public SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t GetDimensionsWithLocalCumulOptimizers()
```
  - HasGlobalCumulOptimizer
```
public boolean HasGlobalCumulOptimizer(RoutingDimension dimension)
```
    Returns whether the given dimension has global/local cumul optimizers.
  - HasLocalCumulOptimizer
```
public boolean HasLocalCumulOptimizer(RoutingDimension dimension)
```
  - GetMutableGlobalCumulLPOptimizer
```
public SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer GetMutableGlobalCumulLPOptimizer(RoutingDimension dimension)
```
    Returns the global/local dimension cumul optimizer for a given dimension,
    or nullptr if there is none.
  - GetMutableGlobalCumulMPOptimizer
```
public SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer GetMutableGlobalCumulMPOptimizer(RoutingDimension dimension)
```
  - GetMutableLocalCumulLPOptimizer
```
public SWIGTYPE_p_operations_research__LocalDimensionCumulOptimizer GetMutableLocalCumulLPOptimizer(RoutingDimension dimension)
```
  - hasDimension
```
public boolean hasDimension(java.lang.String dimension_name)
```
    Returns true if a dimension exists for a given dimension name.
  - getDimensionOrDie
```
public RoutingDimension getDimensionOrDie(java.lang.String dimension_name)
```
    Returns a dimension from its name. Dies if the dimension does not exist.
  - getMutableDimension
```
public RoutingDimension getMutableDimension(java.lang.String dimension_name)
```
    Returns a dimension from its name. Returns nullptr if the dimension does
    not exist.
  - setPrimaryConstrainedDimension
```
public void setPrimaryConstrainedDimension(java.lang.String dimension_name)
```
    Set the given dimension as "primary constrained". As of August 2013, this
    is only used by ArcIsMoreConstrainedThanArc().
    "dimension" must be the name of an existing dimension, or be empty, in
    which case there will not be a primary dimension after this call.
  - getPrimaryConstrainedDimension
```
public java.lang.String getPrimaryConstrainedDimension()
```
    Get the primary constrained dimension, or an empty string if it is unset.
  - AddResourceGroup
```
public RoutingModel.ResourceGroup AddResourceGroup()
```
    Adds a resource group to the routing model and returns a pointer to it.
  - GetResourceGroups
```
public SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__RoutingModel__ResourceGroup_t_t GetResourceGroups()
```
  - GetResourceGroup
```
public RoutingModel.ResourceGroup GetResourceGroup(int rg_index)
```
  - GetDimensionResourceGroupIndices
```
public int[] GetDimensionResourceGroupIndices(RoutingDimension dimension)
```
    Returns the indices of resource groups for this dimension. This method can
    only be called after the model has been closed.
  - GetDimensionResourceGroupIndex
```
public int GetDimensionResourceGroupIndex(RoutingDimension dimension)
```
    Returns the index of the resource group attached to the dimension.
    DCHECKS that there's exactly one resource group for this dimension.
  - addDisjunction
```
public int addDisjunction(long[] indices,
                          long penalty,
                          long max_cardinality,
                          int penalty_cost_behavior)
```
    Adds a disjunction constraint on the indices: exactly 'max_cardinality' of
    the indices are active. Start and end indices of any vehicle cannot be
    part of a disjunction.
    
    If a penalty is given, at most 'max_cardinality' of the indices can be
    active, and if less are active, 'penalty' is payed per inactive index if
    the penalty cost is set to `PENALIZE_PER_INACTIVE`.
    This is equivalent to adding the constraint:
    p + Sum(i)active[i] == max_cardinality
    where p is an integer variable.
    If the penalty cost is set to `PENALIZE_ONCE`, then 'penalty' is payed
    once if there are less than `max_cardinality` of the indices active.
    This is equivalent to adding the constraint:
    p == (Sum(i)active[i] != max_cardinality)
    where p is a boolean variable.
    The following cost is added to the cost function: p * penalty.
    'penalty' must be positive to make the disjunction optional; a negative
    penalty will force 'max_cardinality' indices of the disjunction to be
    performed, and therefore p == 0.
    Note: passing a vector with a single index will model an optional index
    with a penalty cost if it is not visited.
  - addDisjunction
```
public int addDisjunction(long[] indices,
                          long penalty,
                          long max_cardinality)
```
    Adds a disjunction constraint on the indices: exactly 'max_cardinality' of
    the indices are active. Start and end indices of any vehicle cannot be
    part of a disjunction.
    
    If a penalty is given, at most 'max_cardinality' of the indices can be
    active, and if less are active, 'penalty' is payed per inactive index if
    the penalty cost is set to `PENALIZE_PER_INACTIVE`.
    This is equivalent to adding the constraint:
    p + Sum(i)active[i] == max_cardinality
    where p is an integer variable.
    If the penalty cost is set to `PENALIZE_ONCE`, then 'penalty' is payed
    once if there are less than `max_cardinality` of the indices active.
    This is equivalent to adding the constraint:
    p == (Sum(i)active[i] != max_cardinality)
    where p is a boolean variable.
    The following cost is added to the cost function: p * penalty.
    'penalty' must be positive to make the disjunction optional; a negative
    penalty will force 'max_cardinality' indices of the disjunction to be
    performed, and therefore p == 0.
    Note: passing a vector with a single index will model an optional index
    with a penalty cost if it is not visited.
  - addDisjunction
```
public int addDisjunction(long[] indices,
                          long penalty)
```
    Adds a disjunction constraint on the indices: exactly 'max_cardinality' of
    the indices are active. Start and end indices of any vehicle cannot be
    part of a disjunction.
    
    If a penalty is given, at most 'max_cardinality' of the indices can be
    active, and if less are active, 'penalty' is payed per inactive index if
    the penalty cost is set to `PENALIZE_PER_INACTIVE`.
    This is equivalent to adding the constraint:
    p + Sum(i)active[i] == max_cardinality
    where p is an integer variable.
    If the penalty cost is set to `PENALIZE_ONCE`, then 'penalty' is payed
    once if there are less than `max_cardinality` of the indices active.
    This is equivalent to adding the constraint:
    p == (Sum(i)active[i] != max_cardinality)
    where p is a boolean variable.
    The following cost is added to the cost function: p * penalty.
    'penalty' must be positive to make the disjunction optional; a negative
    penalty will force 'max_cardinality' indices of the disjunction to be
    performed, and therefore p == 0.
    Note: passing a vector with a single index will model an optional index
    with a penalty cost if it is not visited.
  - addDisjunction
```
public int addDisjunction(long[] indices)
```
    Adds a disjunction constraint on the indices: exactly 'max_cardinality' of
    the indices are active. Start and end indices of any vehicle cannot be
    part of a disjunction.
    
    If a penalty is given, at most 'max_cardinality' of the indices can be
    active, and if less are active, 'penalty' is payed per inactive index if
    the penalty cost is set to `PENALIZE_PER_INACTIVE`.
    This is equivalent to adding the constraint:
    p + Sum(i)active[i] == max_cardinality
    where p is an integer variable.
    If the penalty cost is set to `PENALIZE_ONCE`, then 'penalty' is payed
    once if there are less than `max_cardinality` of the indices active.
    This is equivalent to adding the constraint:
    p == (Sum(i)active[i] != max_cardinality)
    where p is a boolean variable.
    The following cost is added to the cost function: p * penalty.
    'penalty' must be positive to make the disjunction optional; a negative
    penalty will force 'max_cardinality' indices of the disjunction to be
    performed, and therefore p == 0.
    Note: passing a vector with a single index will model an optional index
    with a penalty cost if it is not visited.
  - getDisjunctionIndices
```
public int[] getDisjunctionIndices(long index)
```
    Returns the indices of the disjunctions to which an index belongs.
  - GetDisjunctionNodeIndices
```
public long[] GetDisjunctionNodeIndices(int index)
```
    Returns the variable indices of the nodes in the disjunction of index
    'index'.
  - getDisjunctionPenalty
```
public long getDisjunctionPenalty(int index)
```
    Returns the penalty of the node disjunction of index 'index'.
  - getDisjunctionMaxCardinality
```
public long getDisjunctionMaxCardinality(int index)
```
    Returns the maximum number of possible active nodes of the node
    disjunction of index 'index'.
  - GetDisjunctionPenaltyCostBehavior
```
public int GetDisjunctionPenaltyCostBehavior(int index)
```
    Returns the PenaltyCostBehavior used by the disjunction of index
    'index'.
  - getNumberOfDisjunctions
```
public int getNumberOfDisjunctions()
```
    Returns the number of node disjunctions in the model.
  - HasMandatoryDisjunctions
```
public boolean HasMandatoryDisjunctions()
```
    Returns true if the model contains mandatory disjunctions (ones with
    kNoPenalty as penalty).
  - HasMaxCardinalityConstrainedDisjunctions
```
public boolean HasMaxCardinalityConstrainedDisjunctions()
```
    Returns true if the model contains at least one disjunction which is
    constrained by its max_cardinality.
  - ignoreDisjunctionsAlreadyForcedToZero
```
public void ignoreDisjunctionsAlreadyForcedToZero()
```
    SPECIAL: Makes the solver ignore all the disjunctions whose active
    variables are all trivially zero (i.e. Max() == 0), by setting their
    max_cardinality to 0.
    This can be useful when using the BaseBinaryDisjunctionNeighborhood
    operators, in the context of arc-based routing.
  - addSoftSameVehicleConstraint
```
public void addSoftSameVehicleConstraint(long[] indices,
                                         long cost)
```
    Adds a soft constraint to force a set of variable indices to be on the
    same vehicle. If all nodes are not on the same vehicle, each extra vehicle
    used adds 'cost' to the cost function.
  - setAllowedVehiclesForIndex
```
public void setAllowedVehiclesForIndex(int[] vehicles,
                                       long index)
```
    Sets the vehicles which can visit a given node. If the node is in a
    disjunction, this will not prevent it from being unperformed.
    Specifying an empty vector of vehicles has no effect (all vehicles
    will be allowed to visit the node).
  - isVehicleAllowedForIndex
```
public boolean isVehicleAllowedForIndex(int vehicle,
                                        long index)
```
    Returns true if a vehicle is allowed to visit a given node.
  - addPickupAndDelivery
```
public void addPickupAndDelivery(long pickup,
                                 long delivery)
```
    Notifies that index1 and index2 form a pair of nodes which should belong
    to the same route. This methods helps the search find better solutions,
    especially in the local search phase.
    It should be called each time you have an equality constraint linking
    the vehicle variables of two node (including for instance pickup and
    delivery problems):
    Solver* const solver = routing.solver();
    int64_t index1 = manager.NodeToIndex(node1);
    int64_t index2 = manager.NodeToIndex(node2);
    solver->AddConstraint(solver->MakeEquality(
    routing.VehicleVar(index1),
    routing.VehicleVar(index2)));
    routing.AddPickupAndDelivery(index1, index2);
  - addPickupAndDeliverySets
```
public void addPickupAndDeliverySets(int pickup_disjunction,
                                     int delivery_disjunction)
```
    Same as AddPickupAndDelivery but notifying that the performed node from
    the disjunction of index 'pickup_disjunction' is on the same route as the
    performed node from the disjunction of index 'delivery_disjunction'.
  - GetPickupPosition
```
public SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t GetPickupPosition(long node_index)
```
    Returns the pickup and delivery positions where the node is a pickup.
  - GetDeliveryPosition
```
public SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t GetDeliveryPosition(long node_index)
```
    Returns the pickup and delivery positions where the node is a delivery.
  - IsPickup
```
public boolean IsPickup(long node_index)
```
    Returns whether the node is a pickup (resp. delivery).
  - IsDelivery
```
public boolean IsDelivery(long node_index)
```
  - setPickupAndDeliveryPolicyOfAllVehicles
```
public void setPickupAndDeliveryPolicyOfAllVehicles(int policy)
```
    Sets the Pickup and delivery policy of all vehicles. It is equivalent to
    calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.
  - setPickupAndDeliveryPolicyOfVehicle
```
public void setPickupAndDeliveryPolicyOfVehicle(int policy,
                                                int vehicle)
```
  - getPickupAndDeliveryPolicyOfVehicle
```
public int getPickupAndDeliveryPolicyOfVehicle(int vehicle)
```
  - getNumOfSingletonNodes
```
public int getNumOfSingletonNodes()
```
    Returns the number of non-start/end nodes which do not appear in a
    pickup/delivery pair.
  - GetFirstMatchingPickupDeliverySibling
```
public SWIGTYPE_p_std__optionalT_long_t GetFirstMatchingPickupDeliverySibling(long node,
                                                                              SWIGTYPE_p_std__functionT_bool_flongF_t is_match)
```
  - setVisitType
```
public void setVisitType(long index,
                         int type,
                         int type_policy)
```
  - getVisitType
```
public int getVisitType(long index)
```
  - GetSingleNodesOfType
```
public int[] GetSingleNodesOfType(int type)
```
  - GetPairIndicesOfType
```
public int[] GetPairIndicesOfType(int type)
```
  - GetVisitTypePolicy
```
public int GetVisitTypePolicy(long index)
```
  - getNumberOfVisitTypes
```
public int getNumberOfVisitTypes()
```
  - addHardTypeIncompatibility
```
public void addHardTypeIncompatibility(int type1,
                                       int type2)
```
    Incompatibilities:
    Two nodes with "hard" incompatible types cannot share the same route at
    all, while with a "temporal" incompatibility they can't be on the same
    route at the same time.
    NOTE: To avoid unnecessary memory reallocations, it is recommended to only
    add incompatibilities once all the existing types have been set with
    SetVisitType().
  - addTemporalTypeIncompatibility
```
public void addTemporalTypeIncompatibility(int type1,
                                           int type2)
```
  - getTemporalTypeIncompatibilitiesOfType
```
public SWIGTYPE_p_absl__flat_hash_setT_int_t getTemporalTypeIncompatibilitiesOfType(int type)
```
  - hasHardTypeIncompatibilities
```
public boolean hasHardTypeIncompatibilities()
```
    Returns true iff any hard (resp. temporal) type incompatibilities have
    been added to the model.
  - hasTemporalTypeIncompatibilities
```
public boolean hasTemporalTypeIncompatibilities()
```
  - addRequiredTypeAlternativesWhenAddingType
```
public void addRequiredTypeAlternativesWhenAddingType(int dependent_type,
                                                      SWIGTYPE_p_absl__flat_hash_setT_int_t required_type_alternatives)
```
    If type_D depends on type_R when adding type_D, any node_D of type_D and
    VisitTypePolicy TYPE_ADDED_TO_VEHICLE or
    TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its
    vehicle at the time node_D is visited.
  - addRequiredTypeAlternativesWhenRemovingType
```
public void addRequiredTypeAlternativesWhenRemovingType(int dependent_type,
                                                        SWIGTYPE_p_absl__flat_hash_setT_int_t required_type_alternatives)
```
    The following requirements apply when visiting dependent nodes that remove
    their type from the route, i.e. type_R must be on the vehicle when type_D
    of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE,
    TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is
    visited.
  - GetRequiredTypeAlternativesWhenAddingType
```
public SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t GetRequiredTypeAlternativesWhenAddingType(int type)
```
    Returns the set of requirement alternatives when adding the given type.
  - GetRequiredTypeAlternativesWhenRemovingType
```
public SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t GetRequiredTypeAlternativesWhenRemovingType(int type)
```
    Returns the set of requirement alternatives when removing the given type.
  - hasSameVehicleTypeRequirements
```
public boolean hasSameVehicleTypeRequirements()
```
    Returns true iff any same-route (resp. temporal) type requirements have
    been added to the model.
  - hasTemporalTypeRequirements
```
public boolean hasTemporalTypeRequirements()
```
  - unperformedPenalty
```
public long unperformedPenalty(long var_index)
```
    Get the "unperformed" penalty of a node. This is only well defined if the
    node is only part of a single Disjunction, and that disjunction has a
    penalty. For forced active nodes returns max int64_t. In all other cases,
    this returns 0.
  - unperformedPenaltyOrValue
```
public long unperformedPenaltyOrValue(long default_value,
                                      long var_index)
```
    Same as above except that it returns default_value instead of 0 when
    penalty is not well defined (default value is passed as first argument to
    simplify the usage of the method in a callback).
  - getDepot
```
public long getDepot()
```
    Returns the variable index of the first starting or ending node of all
    routes. If all routes start and end at the same node (single depot), this
    is the node returned.
  - SetMaximumNumberOfActiveVehicles
```
public void SetMaximumNumberOfActiveVehicles(int max_active_vehicles)
```
    Constrains the maximum number of active vehicles, aka the number of
    vehicles which do not have an empty route. For instance, this can be used
    to limit the number of routes in the case where there are fewer drivers
    than vehicles and that the fleet of vehicle is heterogeneous.
  - GetMaximumNumberOfActiveVehicles
```
public int GetMaximumNumberOfActiveVehicles()
```
    Returns the maximum number of active vehicles.
  - setArcCostEvaluatorOfAllVehicles
```
public void setArcCostEvaluatorOfAllVehicles(int evaluator_index)
```
    Sets the cost function of the model such that the cost of a segment of a
    route between node 'from' and 'to' is evaluator(from, to), whatever the
    route or vehicle performing the route.
  - setArcCostEvaluatorOfVehicle
```
public void setArcCostEvaluatorOfVehicle(int evaluator_index,
                                         int vehicle)
```
    Sets the cost function for a given vehicle route.
  - setFixedCostOfAllVehicles
```
public void setFixedCostOfAllVehicles(long cost)
```
    Sets the fixed cost of all vehicle routes. It is equivalent to calling
    SetFixedCostOfVehicle on all vehicle routes.
  - setFixedCostOfVehicle
```
public void setFixedCostOfVehicle(long cost,
                                  int vehicle)
```
    Sets the fixed cost of one vehicle route.
  - getFixedCostOfVehicle
```
public long getFixedCostOfVehicle(int vehicle)
```
    Returns the route fixed cost taken into account if the route of the
    vehicle is not empty, aka there's at least one node on the route other
    than the first and last nodes.
  - SetPathEnergyCostOfVehicle
```
public void SetPathEnergyCostOfVehicle(java.lang.String force,
                                       java.lang.String distance,
                                       long cost_per_unit,
                                       int vehicle)
```
  - SetPathEnergyCostsOfVehicle
```
public void SetPathEnergyCostsOfVehicle(java.lang.String force,
                                        java.lang.String distance,
                                        long threshold,
                                        long cost_per_unit_below_threshold,
                                        long cost_per_unit_above_threshold,
                                        int vehicle)
```
  - setAmortizedCostFactorsOfAllVehicles
```
public void setAmortizedCostFactorsOfAllVehicles(long linear_cost_factor,
                                                 long quadratic_cost_factor)
```
    The following methods set the linear and quadratic cost factors of
    vehicles (must be positive values). The default value of these parameters
    is zero for all vehicles.
    
    When set, the cost_ of the model will contain terms aiming at reducing the
    number of vehicles used in the model, by adding the following to the
    objective for every vehicle v:
    INDICATOR(v used in the model) *
    [linear_cost_factor_of_vehicle_[v]
    - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)]
    i.e. for every used vehicle, we add the linear factor as fixed cost, and
    subtract the square of the route length multiplied by the quadratic
    factor. This second term aims at making the routes as dense as possible.
    
    Sets the linear and quadratic cost factor of all vehicles.
  - setAmortizedCostFactorsOfVehicle
```
public void setAmortizedCostFactorsOfVehicle(long linear_cost_factor,
                                             long quadratic_cost_factor,
                                             int vehicle)
```
    Sets the linear and quadratic cost factor of the given vehicle.
  - getAmortizedLinearCostFactorOfVehicles
```
public long[] getAmortizedLinearCostFactorOfVehicles()
```
  - getAmortizedQuadraticCostFactorOfVehicles
```
public long[] getAmortizedQuadraticCostFactorOfVehicles()
```
  - AddRouteConstraint
```
public void AddRouteConstraint(SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_long_t_const_RF_t route_evaluator,
                               boolean costs_are_homogeneous_across_vehicles)
```
  - AddRouteConstraint
```
public void AddRouteConstraint(SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_long_t_const_RF_t route_evaluator)
```
  - GetRouteCost
```
public SWIGTYPE_p_std__optionalT_long_t GetRouteCost(long[] route)
```
  - SetVehicleUsedWhenEmpty
```
public void SetVehicleUsedWhenEmpty(boolean is_used,
                                    int vehicle)
```
  - IsVehicleUsedWhenEmpty
```
public boolean IsVehicleUsedWhenEmpty(int vehicle)
```
  - setFirstSolutionEvaluator
```
public void setFirstSolutionEvaluator(java.util.function.LongBinaryOperator evaluator)
```
    Gets/sets the evaluator used during the search. Only relevant when
    RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY.
    Takes ownership of evaluator.
  - SetFirstSolutionHint
```
public void SetFirstSolutionHint(Assignment hint)
```
    Adds a hint to be used by first solution strategies. The hint assignment
    must outlive the search.
    As of 2024-12, only used by LOCAL_CHEAPEST_INSERTION and
    LOCAL_CHEAPEST_COST_INSERTION.
  - GetFirstSolutionHint
```
public Assignment GetFirstSolutionHint()
```
    Returns the current hint assignment.
  - addLocalSearchOperator
```
public void addLocalSearchOperator(LocalSearchOperator ls_operator)
```
    Adds a local search operator to the set of operators used to solve the
    vehicle routing problem.
  - addSearchMonitor
```
public void addSearchMonitor(SearchMonitor monitor)
```
    Adds a search monitor to the search used to solve the routing model.
  - AddEnterSearchCallback
```
public void AddEnterSearchCallback(java.lang.Runnable callback)
```
  - addAtSolutionCallback
```
public void addAtSolutionCallback(java.lang.Runnable callback,
                                  boolean track_unchecked_neighbors)
```
    Adds a callback called each time a solution is found during the search.
    This is a shortcut to creating a monitor to call the callback on
    AtSolution() and adding it with AddSearchMonitor.
    If track_unchecked_neighbors is true, the callback will also be called on
    AcceptUncheckedNeighbor() events, which is useful to grab solutions
    obtained when solver_parameters.check_solution_period > 1 (aka fastLS).
  - addAtSolutionCallback
```
public void addAtSolutionCallback(java.lang.Runnable callback)
```
    Adds a callback called each time a solution is found during the search.
    This is a shortcut to creating a monitor to call the callback on
    AtSolution() and adding it with AddSearchMonitor.
    If track_unchecked_neighbors is true, the callback will also be called on
    AcceptUncheckedNeighbor() events, which is useful to grab solutions
    obtained when solver_parameters.check_solution_period > 1 (aka fastLS).
  - AddRestoreDimensionValuesResetCallback
```
public void AddRestoreDimensionValuesResetCallback(java.lang.Runnable callback)
```
  - addVariableMinimizedByFinalizer
```
public void addVariableMinimizedByFinalizer(IntVar var)
```
    Adds a variable to minimize in the solution finalizer. The solution
    finalizer is called each time a solution is found during the search and
    allows to instantiate secondary variables (such as dimension cumul
    variables).
  - addVariableMaximizedByFinalizer
```
public void addVariableMaximizedByFinalizer(IntVar var)
```
    Adds a variable to maximize in the solution finalizer (see above for
    information on the solution finalizer).
  - AddWeightedVariableMinimizedByFinalizer
```
public void AddWeightedVariableMinimizedByFinalizer(IntVar var,
                                                    long cost)
```
    Adds a variable to minimize in the solution finalizer, with a weighted
    priority: the higher the more priority it has.
  - AddWeightedVariableMaximizedByFinalizer
```
public void AddWeightedVariableMaximizedByFinalizer(IntVar var,
                                                    long cost)
```
    Adds a variable to maximize in the solution finalizer, with a weighted
    priority: the higher the more priority it has.
  - addVariableTargetToFinalizer
```
public void addVariableTargetToFinalizer(IntVar var,
                                         long target)
```
    Add a variable to set the closest possible to the target value in the
    solution finalizer.
  - AddWeightedVariableTargetToFinalizer
```
public void AddWeightedVariableTargetToFinalizer(IntVar var,
                                                 long target,
                                                 long cost)
```
    Same as above with a weighted priority: the higher the cost, the more
    priority it has to be set close to the target value.
  - closeModel
```
public void closeModel()
```
    Closes the current routing model; after this method is called, no
    modification to the model can be done, but RoutesToAssignment becomes
    available. Note that CloseModel() is automatically called by Solve() and
    other methods that produce solution.
    This is equivalent to calling
    CloseModelWithParameters(DefaultRoutingSearchParameters()).
  - closeModelWithParameters
```
public void closeModelWithParameters(RoutingSearchParameters search_parameters)
```
    Same as above taking search parameters (as of 10/2015 some the parameters
    have to be set when closing the model).
  - solve
```
public Assignment solve(Assignment assignment)
```
    Solves the current routing model; closes the current model.
    This is equivalent to calling
    SolveWithParameters(DefaultRoutingSearchParameters())
    or
    SolveFromAssignmentWithParameters(assignment,
    DefaultRoutingSearchParameters()).
  - solve
```
public Assignment solve()
```
    Solves the current routing model; closes the current model.
    This is equivalent to calling
    SolveWithParameters(DefaultRoutingSearchParameters())
    or
    SolveFromAssignmentWithParameters(assignment,
    DefaultRoutingSearchParameters()).
  - solveWithParameters
```
public Assignment solveWithParameters(RoutingSearchParameters search_parameters)
```
    Solves the current routing model with the given parameters. If 'solutions'
    is specified, it will contain the k best solutions found during the search
    (from worst to best, including the one returned by this method), where k
    corresponds to the 'number_of_solutions_to_collect' in
    'search_parameters'. Note that the Assignment returned by the method and
    the ones in solutions are owned by the underlying solver and should not be
    deleted.
  - solveFromAssignmentWithParameters
```
public Assignment solveFromAssignmentWithParameters(Assignment assignment,
                                                    RoutingSearchParameters search_parameters)
```
    Same as above, except that if assignment is not null, it will be used as
    the initial solution.
  - FastSolveFromAssignmentWithParameters
```
public Assignment FastSolveFromAssignmentWithParameters(Assignment assignment,
                                                        RoutingSearchParameters search_parameters,
                                                        boolean check_solution_in_cp,
                                                        SWIGTYPE_p_absl__flat_hash_setT_operations_research__IntVar_p_t touched)
```
    Improves a given assignment using unchecked local search.
    If check_solution_in_cp is true the final solution will be checked with
    the CP solver.
    As of 11/2023, only works with greedy descent.
  - FastSolveFromAssignmentWithParameters
```
public Assignment FastSolveFromAssignmentWithParameters(Assignment assignment,
                                                        RoutingSearchParameters search_parameters,
                                                        boolean check_solution_in_cp)
```
    Improves a given assignment using unchecked local search.
    If check_solution_in_cp is true the final solution will be checked with
    the CP solver.
    As of 11/2023, only works with greedy descent.
  - SolveFromAssignmentsWithParameters
```
public Assignment SolveFromAssignmentsWithParameters(SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t assignments,
                                                     RoutingSearchParameters search_parameters,
                                                     SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t solutions)
```
    Same as above but will try all assignments in order as first solutions
    until one succeeds.
  - SolveFromAssignmentsWithParameters
```
public Assignment SolveFromAssignmentsWithParameters(SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t assignments,
                                                     RoutingSearchParameters search_parameters)
```
    Same as above but will try all assignments in order as first solutions
    until one succeeds.
  - SolveWithIteratedLocalSearch
```
public Assignment SolveWithIteratedLocalSearch(RoutingSearchParameters search_parameters)
```
    Solves the current routing model by using an Iterated Local Search
    approach.
  - setAssignmentFromOtherModelAssignment
```
public void setAssignmentFromOtherModelAssignment(Assignment target_assignment,
                                                  RoutingModel source_model,
                                                  Assignment source_assignment)
```
    Given a "source_model" and its "source_assignment", resets
    "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_
    if costs aren't homogeneous across vehicles) of "this" model, with the
    values set according to those in "other_assignment".
    The objective_element of target_assignment is set to this->cost_.
  - computeLowerBound
```
public long computeLowerBound()
```
    Computes a lower bound to the routing problem solving a linear assignment
    problem. The routing model must be closed before calling this method.
    Note that problems with node disjunction constraints (including optional
    nodes) and non-homogenous costs are not supported (the method returns 0 in
    these cases).
  - objective_lower_bound
```
public long objective_lower_bound()
```
    Returns the current lower bound found by internal solvers during the
    search.
  - status
```
public RoutingSearchStatus.Value status()
```
    Returns the current status of the routing model.
  - enable_deep_serialization
```
public boolean enable_deep_serialization()
```
    Returns the value of the internal enable_deep_serialization_ parameter.
  - applyLocks
```
public IntVar applyLocks(long[] locks)
```
    Applies a lock chain to the next search. 'locks' represents an ordered
    vector of nodes representing a partial route which will be fixed during
    the next search; it will constrain next variables such that:
    next[locks[i]] == locks[i+1].
    
    Returns the next variable at the end of the locked chain; this variable is
    not locked. An assignment containing the locks can be obtained by calling
    PreAssignment().
  - applyLocksToAllVehicles
```
public boolean applyLocksToAllVehicles(long[][] locks,
                                       boolean close_routes)
```
    Applies lock chains to all vehicles to the next search, such that locks[p]
    is the lock chain for route p. Returns false if the locks do not contain
    valid routes; expects that the routes do not contain the depots,
    i.e. there are empty vectors in place of empty routes.
    If close_routes is set to true, adds the end nodes to the route of each
    vehicle and deactivates other nodes.
    An assignment containing the locks can be obtained by calling
    PreAssignment().
  - preAssignment
```
public Assignment preAssignment()
```
    Returns an assignment used to fix some of the variables of the problem.
    In practice, this assignment locks partial routes of the problem. This
    can be used in the context of locking the parts of the routes which have
    already been driven in online routing problems.
  - mutablePreAssignment
```
public Assignment mutablePreAssignment()
```
  - writeAssignment
```
public boolean writeAssignment(java.lang.String file_name)
```
    Writes the current solution to a file containing an AssignmentProto.
    Returns false if the file cannot be opened or if there is no current
    solution.
  - readAssignment
```
public Assignment readAssignment(java.lang.String file_name)
```
    Reads an assignment from a file and returns the current solution.
    Returns nullptr if the file cannot be opened or if the assignment is not
    valid.
  - restoreAssignment
```
public Assignment restoreAssignment(Assignment solution)
```
    Restores an assignment as a solution in the routing model and returns the
    new solution. Returns nullptr if the assignment is not valid.
  - readAssignmentFromRoutes
```
public Assignment readAssignmentFromRoutes(long[][] routes,
                                           boolean ignore_inactive_indices)
```
    Restores the routes as the current solution. Returns nullptr if the
    solution cannot be restored (routes do not contain a valid solution). Note
    that calling this method will run the solver to assign values to the
    dimension variables; this may take considerable amount of time, especially
    when using dimensions with slack.
  - routesToAssignment
```
public boolean routesToAssignment(long[][] routes,
                                  boolean ignore_inactive_indices,
                                  boolean close_routes,
                                  Assignment assignment)
```
    Fills an assignment from a specification of the routes of the
    vehicles. The routes are specified as lists of variable indices that
    appear on the routes of the vehicles. The indices of the outer vector in
    'routes' correspond to vehicles IDs, the inner vector contains the
    variable indices on the routes for the given vehicle. The inner vectors
    must not contain the start and end indices, as these are determined by the
    routing model. Sets the value of NextVars in the assignment, adding the
    variables to the assignment if necessary. The method does not touch other
    variables in the assignment. The method can only be called after the model
    is closed. With ignore_inactive_indices set to false, this method will
    fail (return nullptr) in case some of the route contain indices that are
    deactivated in the model; when set to true, these indices will be
    skipped. Returns true if routes were successfully
    loaded. However, such assignment still might not be a valid
    solution to the routing problem due to more complex constraints;
    it is advisible to call solver()->CheckSolution() afterwards.
  - assignmentToRoutes
```
public void assignmentToRoutes(Assignment assignment,
                               long[][] routes)
```
    Converts the solution in the given assignment to routes for all vehicles.
    Expects that assignment contains a valid solution (i.e. routes for all
    vehicles end with an end index for that vehicle).
  - compactAssignment
```
public Assignment compactAssignment(Assignment assignment)
```
    Converts the solution in the given assignment to routes for all vehicles.
    If the returned vector is route_indices, route_indices[i][j] is the index
    for jth location visited on route i. Note that contrary to
    AssignmentToRoutes, the vectors do include start and end locations.
    Returns a compacted version of the given assignment, in which all vehicles
    with id lower or equal to some N have non-empty routes, and all vehicles
    with id greater than N have empty routes. Does not take ownership of the
    returned object.
    If found, the cost of the compact assignment is the same as in the
    original assignment and it preserves the values of 'active' variables.
    Returns nullptr if a compact assignment was not found.
    This method only works in homogenous mode, and it only swaps equivalent
    vehicles (vehicles with the same start and end nodes). When creating the
    compact assignment, the empty plan is replaced by the route assigned to
    the compatible vehicle with the highest id. Note that with more complex
    constraints on vehicle variables, this method might fail even if a compact
    solution exists.
    This method changes the vehicle and dimension variables as necessary.
    While compacting the solution, only basic checks on vehicle variables are
    performed; if one of these checks fails no attempts to repair it are made
    (instead, the method returns nullptr).
  - compactAndCheckAssignment
```
public Assignment compactAndCheckAssignment(Assignment assignment)
```
    Same as CompactAssignment() but also checks the validity of the final
    compact solution; if it is not valid, no attempts to repair it are made
    (instead, the method returns nullptr).
  - addToAssignment
```
public void addToAssignment(IntVar var)
```
    Adds an extra variable to the vehicle routing assignment.
  - addIntervalToAssignment
```
public void addIntervalToAssignment(IntervalVar interval)
```
  - GetOrCreateNodeNeighborsByCostClass
```
public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio,
                                                                                 long min_neighbors,
                                                                                 SWIGTYPE_p_double neighbors_ratio_used,
                                                                                 boolean add_vehicle_starts_to_neighbors,
                                                                                 boolean add_vehicle_ends_to_neighbors,
                                                                                 boolean only_sort_neighbors_for_partial_neighborhoods)
```
    Returns neighbors of all nodes for every cost class. The result is cached
    and is computed once. The number of neighbors considered is based on a
    ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum
    of min-neighbors node considered.
  - GetOrCreateNodeNeighborsByCostClass
```
public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio,
                                                                                 long min_neighbors,
                                                                                 SWIGTYPE_p_double neighbors_ratio_used,
                                                                                 boolean add_vehicle_starts_to_neighbors,
                                                                                 boolean add_vehicle_ends_to_neighbors)
```
    Returns neighbors of all nodes for every cost class. The result is cached
    and is computed once. The number of neighbors considered is based on a
    ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum
    of min-neighbors node considered.
  - GetOrCreateNodeNeighborsByCostClass
```
public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio,
                                                                                 long min_neighbors,
                                                                                 SWIGTYPE_p_double neighbors_ratio_used,
                                                                                 boolean add_vehicle_starts_to_neighbors)
```
    Returns neighbors of all nodes for every cost class. The result is cached
    and is computed once. The number of neighbors considered is based on a
    ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum
    of min-neighbors node considered.
  - GetOrCreateNodeNeighborsByCostClass
```
public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio,
                                                                                 long min_neighbors,
                                                                                 SWIGTYPE_p_double neighbors_ratio_used)
```
    Returns neighbors of all nodes for every cost class. The result is cached
    and is computed once. The number of neighbors considered is based on a
    ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum
    of min-neighbors node considered.
  - GetOrCreateNodeNeighborsByCostClass
```
public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(RoutingModel.NodeNeighborsParameters params)
```
    Returns parameters.num_neighbors neighbors of all nodes for every cost
    class. The result is cached and is computed once.
  - addLocalSearchFilter
```
public void addLocalSearchFilter(LocalSearchFilter filter)
```
    Adds a custom local search filter to the list of filters used to speed up
    local search by pruning unfeasible variable assignments.
    Calling this method after the routing model has been closed (CloseModel()
    or Solve() has been called) has no effect.
    The routing model does not take ownership of the filter.
  - start
```
public long start(int vehicle)
```
    Model inspection.
    Returns the variable index of the starting node of a vehicle route.
  - end
```
public long end(int vehicle)
```
    Returns the variable index of the ending node of a vehicle route.
  - isStart
```
public boolean isStart(long index)
```
    Returns true if 'index' represents the first node of a route.
  - isEnd
```
public boolean isEnd(long index)
```
    Returns true if 'index' represents the last node of a route.
  - VehicleIndex
```
public int VehicleIndex(long index)
```
    Returns the vehicle of the given start/end index, and -1 if the given
    index is not a vehicle start/end.
  - next
```
public long next(Assignment assignment,
                 long index)
```
    Assignment inspection
    Returns the variable index of the node directly after the node
    corresponding to 'index' in 'assignment'.
  - isVehicleUsed
```
public boolean isVehicleUsed(Assignment assignment,
                             int vehicle)
```
    Returns true if the route of 'vehicle' is non empty in 'assignment'.
  - nexts
```
public IntVar[] nexts()
```
    Returns all next variables of the model, such that Nexts(i) is the next
    variable of the node corresponding to i.
  - vehicleVars
```
public IntVar[] vehicleVars()
```
    Returns all vehicle variables of the model, such that VehicleVars(i) is
    the vehicle variable of the node corresponding to i.
  - ResourceVars
```
public IntVar[] ResourceVars(int resource_group)
```
    Returns vehicle resource variables for a given resource group, such that
    ResourceVars(r_g)[v] is the resource variable for vehicle 'v' in resource
    group 'r_g'.
  - nextVar
```
public IntVar nextVar(long index)
```
    Returns the next variable of the node corresponding to index. Note that
    NextVar(index) == index is equivalent to ActiveVar(index) == 0.
  - activeVar
```
public IntVar activeVar(long index)
```
    Returns the active variable of the node corresponding to index.
  - activeVehicleVar
```
public IntVar activeVehicleVar(int vehicle)
```
    Returns the active variable of the vehicle. It will be equal to 1 iff the
    route of the vehicle is not empty, 0 otherwise.
  - VehicleRouteConsideredVar
```
public IntVar VehicleRouteConsideredVar(int vehicle)
```
    Returns the variable specifying whether or not the given vehicle route is
    considered for costs and constraints. It will be equal to 1 iff the route
    of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true.
  - vehicleVar
```
public IntVar vehicleVar(long index)
```
    Returns the vehicle variable of the node corresponding to index. Note that
    VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.
  - ResourceVar
```
public IntVar ResourceVar(int vehicle,
                          int resource_group)
```
    Returns the resource variable for the given vehicle index in the given
    resource group. If a vehicle doesn't require a resource from the
    corresponding resource group, then ResourceVar(v, r_g) == -1.
  - costVar
```
public IntVar costVar()
```
    Returns the global cost variable which is being minimized.
  - getArcCostForVehicle
```
public long getArcCostForVehicle(long from_index,
                                 long to_index,
                                 long vehicle)
```
    Returns the cost of the transit arc between two nodes for a given vehicle.
    Input are variable indices of node. This returns 0 if vehicle < 0.
  - costsAreHomogeneousAcrossVehicles
```
public boolean costsAreHomogeneousAcrossVehicles()
```
    Whether costs are homogeneous across all vehicles.
  - getHomogeneousCost
```
public long getHomogeneousCost(long from_index,
                               long to_index)
```
    Returns the cost of the segment between two nodes supposing all vehicle
    costs are the same (returns the cost for the first vehicle otherwise).
  - getArcCostForFirstSolution
```
public long getArcCostForFirstSolution(long from_index,
                                       long to_index)
```
    Returns the cost of the arc in the context of the first solution strategy.
    This is typically a simplification of the actual cost; see the .cc.
  - getArcCostForClass
```
public long getArcCostForClass(long from_index,
                               long to_index,
                               long cost_class_index)
```
    Returns the cost of the segment between two nodes for a given cost
    class. Input are variable indices of nodes and the cost class.
    Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the
    returned cost won't necessarily be zero: only some of the components
    of the cost that depend on the cost class will be omited. See the code
    for details.
  - getCostClassIndexOfVehicle
```
public int getCostClassIndexOfVehicle(long vehicle)
```
    Get the cost class index of the given vehicle.
  - hasVehicleWithCostClassIndex
```
public boolean hasVehicleWithCostClassIndex(int cost_class_index)
```
    Returns true iff the model contains a vehicle with the given
    cost_class_index.
  - getCostClassesCount
```
public int getCostClassesCount()
```
    Returns the number of different cost classes in the model.
  - getNonZeroCostClassesCount
```
public int getNonZeroCostClassesCount()
```
    Ditto, minus the 'always zero', built-in cost class.
  - getVehicleClassIndexOfVehicle
```
public int getVehicleClassIndexOfVehicle(long vehicle)
```
  - GetVehicleOfClass
```
public int GetVehicleOfClass(int vehicle_class)
```
    Returns a vehicle of the given vehicle class, and -1 if there are no
    vehicles for this class.
  - getVehicleClassesCount
```
public int getVehicleClassesCount()
```
    Returns the number of different vehicle classes in the model.
  - getSameVehicleIndicesOfIndex
```
public int[] getSameVehicleIndicesOfIndex(int node)
```
    Returns variable indices of nodes constrained to be on the same route.
  - GetSameActivityIndicesOfIndex
```
public int[] GetSameActivityIndicesOfIndex(int node)
```
    Returns variable indices of nodes constrained to have the same activity.
  - GetSameActivityGroupOfIndex
```
public int GetSameActivityGroupOfIndex(int node)
```
    Returns the same activity group of the node.
  - GetSameActivityGroupsCount
```
public int GetSameActivityGroupsCount()
```
    Returns the number of same activity groups.
  - GetSameActivityIndicesOfGroup
```
public int[] GetSameActivityIndicesOfGroup(int group)
```
    Returns variable indices of nodes in the same activity group.
  - GetVehicleTypeContainer
```
public RoutingModel.VehicleTypeContainer GetVehicleTypeContainer()
```
  - arcIsMoreConstrainedThanArc
```
public boolean arcIsMoreConstrainedThanArc(long from,
                                           long to1,
                                           long to2)
```
    Returns whether the arc from->to1 is more constrained than from->to2,
    taking into account, in order:
    - whether the destination node isn't an end node
    - whether the destination node is mandatory
    - whether the destination node is bound to the same vehicle as the source
    - the "primary constrained" dimension (see SetPrimaryConstrainedDimension)
    It then breaks ties using, in order:
    - the arc cost (taking unperformed penalties into account)
    - the size of the vehicle vars of "to1" and "to2" (lowest size wins)
    - the value: the lowest value of the indices to1 and to2 wins.
    See the .cc for details.
    The more constrained arc is typically preferable when building a
    first solution. This method is intended to be used as a callback for the
    BestValueByComparisonSelector value selector.
    Args:
    from: the variable index of the source node
    to1: the variable index of the first candidate destination node.
    to2: the variable index of the second candidate destination node.
  - debugOutputAssignment
```
public java.lang.String debugOutputAssignment(Assignment solution_assignment,
                                              java.lang.String dimension_to_print)
```
    Print some debugging information about an assignment, including the
    feasible intervals of the CumulVar for dimension "dimension_to_print"
    at each step of the routes.
    If "dimension_to_print" is omitted, all dimensions will be printed.
  - CheckIfAssignmentIsFeasible
```
public boolean CheckIfAssignmentIsFeasible(Assignment assignment,
                                           boolean call_at_solution_monitors)
```
    Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair
    containing the minimum and maximum of the CumulVar of the jth node on
    route i.
    - cumul_bounds[i][j].first is the minimum.
    - cumul_bounds[i][j].second is the maximum.
    Checks if an assignment is feasible.
  - solver
```
public Solver solver()
```
    Returns the underlying constraint solver. Can be used to add extra
    constraints and/or modify search algorithms.
  - checkLimit
```
public boolean checkLimit(SWIGTYPE_p_absl__Duration offset)
```
    Returns true if the search limit has been crossed with the given time
    offset.
  - checkLimit
```
public boolean checkLimit()
```
    Returns true if the search limit has been crossed with the given time
    offset.
  - UpdateTimeLimit
```
public void UpdateTimeLimit(SWIGTYPE_p_absl__Duration time_limit)
```
    Updates the time limit of the search limit.
  - TimeBuffer
```
public SWIGTYPE_p_absl__Duration TimeBuffer()
```
    Returns the time buffer to safely return a solution.
  - GetMutableCPSatInterrupt
```
public SWIGTYPE_p_std__atomicT_bool_t GetMutableCPSatInterrupt()
```
    Returns the atomic<bool> to stop the CP-SAT solver.
  - GetMutableCPInterrupt
```
public SWIGTYPE_p_std__atomicT_bool_t GetMutableCPInterrupt()
```
    Returns the atomic<bool> to stop the CP solver.
  - CancelSearch
```
public void CancelSearch()
```
    Cancels the current search.
  - nodes
```
public int nodes()
```
    Sizes and indices
    Returns the number of nodes in the model.
  - vehicles
```
public int vehicles()
```
    Returns the number of vehicle routes in the model.
  - size
```
public long size()
```
    Returns the number of next variables in the model.
  - getNumberOfDecisionsInFirstSolution
```
public long getNumberOfDecisionsInFirstSolution(RoutingSearchParameters search_parameters)
```
    Returns statistics on first solution search, number of decisions sent to
    filters, number of decisions rejected by filters.
  - getNumberOfRejectsInFirstSolution
```
public long getNumberOfRejectsInFirstSolution(RoutingSearchParameters search_parameters)
```
  - isMatchingModel
```
public boolean isMatchingModel()
```
    Returns true if a vehicle/node matching problem is detected.
  - AreRoutesInterdependent
```
public boolean AreRoutesInterdependent(SWIGTYPE_p_operations_research__RoutingSearchParameters parameters)
```
    Returns true if routes are interdependent. This means that any
    modification to a route might impact another.
  - makeGuidedSlackFinalizer
```
public DecisionBuilder makeGuidedSlackFinalizer(RoutingDimension dimension,
                                                java.util.function.LongUnaryOperator initializer)
```
    The next few members are in the public section only for testing purposes.
    
    MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a
    dimension using a callback to choose which values to start with.
    The finalizer works only when all next variables in the model have
    been fixed. It has the following two characteristics:
    1. It follows the routes defined by the nexts variables when choosing a
    variable to make a decision on.
    2. When it comes to choose a value for the slack of node i, the decision
    builder first calls the callback with argument i, and supposingly the
    returned value is x it creates decisions slack[i] = x, slack[i] = x +
    1, slack[i] = x - 1, slack[i] = x + 2, etc.
  - makeSelfDependentDimensionFinalizer
```
public DecisionBuilder makeSelfDependentDimensionFinalizer(RoutingDimension dimension)
```
    MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a
    self-dependent dimension. It makes an extensive use of the caches of the
    state dependent transits.
    In detail, MakeSelfDependentDimensionFinalizer returns a composition of a
    local search decision builder with a greedy descent operator for the cumul
    of the start of each route and a guided slack finalizer. Provided there
    are no time windows and the maximum slacks are large enough, once the
    cumul of the start of route is fixed, the guided finalizer can find
    optimal values of the slacks for the rest of the route in time
    proportional to the length of the route. Therefore the composed finalizer
    generally works in time O(log(t)*n*m), where t is the latest possible
    departute time, n is the number of nodes in the network and m is the
    number of vehicles.
  - GetPathsMetadata
```
public PathsMetadata GetPathsMetadata()
```
  - GetVehiclesOfSameClass
```
public SWIGTYPE_p_std__dequeT_int_t GetVehiclesOfSameClass(long start_end_index)
```
    Returns indices of the vehicles which are in the same vehicle class as the
    vehicle starting or ending at start_end_index.
  - GetSameVehicleClassArcs
```
public SWIGTYPE_p_std__vectorT_std__pairT_long_long_t_t GetSameVehicleClassArcs(long from_index,
                                                                                long to_index)
```
    Returns all arcs which are equivalent to the {from_index, to_index} arc
    wrt vehicle classes. Arcs will be returned only if from_index is the
    start of a vehicle or if to_index is the end of a vehicle. The returned
    arcs will then be starting or ending at start or end nodes of vehicles in
    the same vehicle class. The input arc is included in the returned vector.

Class RoutingModel

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

swigCMemOwn

PICKUP_AND_DELIVERY_NO_ORDER

PICKUP_AND_DELIVERY_LIFO

PICKUP_AND_DELIVERY_FIFO

kTransitEvaluatorSignUnknown

kTransitEvaluatorSignPositiveOrZero

kTransitEvaluatorSignNegativeOrZero

PENALIZE_ONCE

PENALIZE_PER_INACTIVE

TYPE_ADDED_TO_VEHICLE

ADDED_TYPE_REMOVED_FROM_VEHICLE

TYPE_ON_VEHICLE_UP_TO_VISIT

TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED

Constructor Detail

RoutingModel

RoutingModel

RoutingModel

Method Detail

getCPtr

swigRelease

finalize

delete

getKNoPenalty

getKNoDisjunction

getKNoDimension

registerUnaryTransitVector

registerUnaryTransitCallback

registerUnaryTransitCallback

registerTransitMatrix

registerTransitCallback

registerTransitCallback

RegisterCumulDependentTransitCallback

CumulDependentTransitCallback

addDimension

addDimensionWithVehicleTransits

addDimensionWithVehicleCapacity

addDimensionWithVehicleTransitAndCapacity

AddDimensionWithCumulDependentVehicleTransitAndCapacity

addConstantDimensionWithSlack

addConstantDimension

addVectorDimension

addMatrixDimension

GetUnaryDimensions

GetDimensionsWithGlobalCumulOptimizers

GetDimensionsWithLocalCumulOptimizers

HasGlobalCumulOptimizer

HasLocalCumulOptimizer

GetMutableGlobalCumulLPOptimizer

GetMutableGlobalCumulMPOptimizer

GetMutableLocalCumulLPOptimizer

hasDimension

getDimensionOrDie

getMutableDimension

setPrimaryConstrainedDimension

getPrimaryConstrainedDimension

AddResourceGroup

GetResourceGroups

GetResourceGroup

GetDimensionResourceGroupIndices

GetDimensionResourceGroupIndex

addDisjunction

addDisjunction

addDisjunction

addDisjunction

getDisjunctionIndices

GetDisjunctionNodeIndices

getDisjunctionPenalty

getDisjunctionMaxCardinality

GetDisjunctionPenaltyCostBehavior

getNumberOfDisjunctions

HasMandatoryDisjunctions

HasMaxCardinalityConstrainedDisjunctions

ignoreDisjunctionsAlreadyForcedToZero