Java: Use lambda in Constraint Solver

examples/tests/TestConstraintSolver.java

@@ -11,14 +11,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import java.util.logging.Logger;
-import com.google.ortools.constraintsolver.VoidToString;
 import com.google.ortools.constraintsolver.Solver;
 import com.google.ortools.constraintsolver.OptimizeVar;
 import com.google.ortools.constraintsolver.IntVar;
 import com.google.ortools.constraintsolver.SearchMonitor;
 import com.google.ortools.constraintsolver.SearchLog;
+import com.google.ortools.constraintsolver.Decision;
 import com.google.ortools.constraintsolver.main;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.logging.Logger;
 
 /** Tests the Constraint solver java interface. */
 public class TestConstraintSolver {
@@ -50,16 +53,16 @@ public class TestConstraintSolver {
     logger.info("testSearchLog...DONE");
   }
 
-  static class SearchCount extends VoidToString {
-    public SearchCount(Integer count_) {
+  static class SearchCount implements Supplier<String> {
+    public SearchCount(AtomicInteger count_) {
       count = count_;
     }
     @Override
-    public String run() {
-      count++;
-      return "display callback...";
+    public String get() {
+      count.addAndGet(1);
+      return "display callback called...";
     }
-    private Integer count;
+    private AtomicInteger count;
   }
 
   static void testSearchLogWithCallback(boolean enableGC) {
@@ -67,7 +70,7 @@ public class TestConstraintSolver {
     Solver solver = new Solver("TestSearchLog");
     IntVar var = solver.makeIntVar(1, 1, "Variable");
     OptimizeVar objective = solver.makeMinimize(var, 1);
-    Integer count = new Integer(0);
+    AtomicInteger count = new AtomicInteger(0);
     SearchMonitor searchlog = solver.makeSearchLog(
         0,  // branch period
         new SearchCount(count));
@@ -75,16 +78,36 @@ public class TestConstraintSolver {
       System.gc(); // verify SearchCount is kept alive
     }
     runSearchLog(searchlog);
-    assert 1 == count;
+    logger.info("count:" + count.intValue());
+
+    if (count.intValue() != 1) throw new AssertionError("count != 1"); ;
     logger.info("testSearchLogWithCallback (enable gc:" + enableGC + ")...DONE");
   }
 
-  static void testSearchLogWithObjectiveCallback(boolean enableGC) {
-    logger.info("testSearchLogWithCallback (enable gc:" + enableGC + ")...");
+  static void testSearchLogWithIntVarCallback(boolean enableGC) {
+    logger.info("testSearchLogWithIntVarCallback (enable gc:" + enableGC + ")...");
     Solver solver = new Solver("TestSearchLog");
     IntVar var = solver.makeIntVar(1, 1, "Variable");
     OptimizeVar objective = solver.makeMinimize(var, 1);
-    Integer count = new Integer(0);
+    AtomicInteger count = new AtomicInteger(0);
+    SearchMonitor searchlog = solver.makeSearchLog(
+        0,  // branch period
+        var, // IntVar to monitor
+        new SearchCount(count));
+    if (enableGC) {
+      System.gc(); // verify SearchCount is kept alive
+    }
+    runSearchLog(searchlog);
+    if (count.intValue() != 1) throw new AssertionError("count != 1"); ;
+    logger.info("testSearchLogWithIntVarCallback (enable gc:" + enableGC + ")...DONE");
+  }
+
+  static void testSearchLogWithObjectiveCallback(boolean enableGC) {
+    logger.info("testSearchLogWithObjectiveCallback (enable gc:" + enableGC + ")...");
+    Solver solver = new Solver("TestSearchLog");
+    IntVar var = solver.makeIntVar(1, 1, "Variable");
+    OptimizeVar objective = solver.makeMinimize(var, 1);
+    AtomicInteger count = new AtomicInteger(0);
     SearchMonitor searchlog = solver.makeSearchLog(
         0,  // branch period
         objective, // objective var to monitor
@@ -93,15 +116,74 @@ public class TestConstraintSolver {
       System.gc(); // verify SearchCount is kept alive
     }
     runSearchLog(searchlog);
-    assert 1 == count;
-    logger.info("testSearchLogWithCallback (enable gc:" + enableGC + ")...DONE");
+    if (count.intValue() != 1) throw new AssertionError("count != 1"); ;
+    logger.info("testSearchLogWithObjectiveCallback (enable gc:" + enableGC + ")...DONE");
+  }
+
+  static class StringProperty {
+    public StringProperty(String value) {
+      value_ = value;
+    }
+    public void setValue(String value) {
+      value_ = value;;
+    }
+    public String toString() {
+      return value_;
+    }
+    private String value_;
+  }
+
+  static void testClosureDecision(boolean enableGC) {
+    logger.info("testClosureDecision (enable gc:" + enableGC + ")...");
+    final StringProperty call = new StringProperty("");
+    Solver solver = new Solver("ClosureDecisionTest");
+    Decision decision = solver.makeDecision(
+        (Solver s) -> { call.setValue("Apply"); },
+        (Solver s) -> { call.setValue("Refute"); });
+    if (enableGC) {
+      System.gc(); // verify SearchCount is kept alive
+    }
+
+    decision.apply(solver);
+    if (!call.toString().equals("Apply")) {throw new AssertionError("Apply action not called");}
+
+    decision.refute(solver);
+    if (!call.toString().equals("Refute")) {throw new AssertionError("Refute action not called");}
+    logger.info("testClosureDecision (enable gc:" + enableGC + ")...DONE");
+  }
+
+
+  static void testSolverInClosureDecision(boolean enableGC) {
+    logger.info("testSolverInClosureDecision (enable gc:" + enableGC + ")...");
+    Solver solver = new Solver("SolverTestName");
+    String model_name = solver.model_name();
+    Decision decision = solver.makeDecision(
+        (Solver s) -> {
+          if (!s.model_name().equals(model_name)) {throw new AssertionError("Solver ill formed");}
+        },
+        (Solver s) -> {
+          if (!s.model_name().equals(model_name)) {throw new AssertionError("Solver ill formed");}
+        });
+    if (enableGC) {
+      System.gc(); // verify SearchCount is kept alive
+    }
+
+    decision.apply(solver);
+    decision.refute(solver);
+    logger.info("testSolverInClosureDecision (enable gc:" + enableGC + ")...DONE");
   }
 
   public static void main(String[] args) throws Exception {
     testSearchLog();
     testSearchLogWithCallback(/*enableGC=*/false);
-    //testSearchLogWithCallback(/*enableGC=*/true);
+    testSearchLogWithCallback(/*enableGC=*/true);
+    testSearchLogWithIntVarCallback(/*enableGC=*/false);
+    testSearchLogWithIntVarCallback(/*enableGC=*/true);
     testSearchLogWithObjectiveCallback(/*enableGC=*/false);
-    //testSearchLogWithObjectiveCallback(/*enableGC=*/true);
+    testSearchLogWithObjectiveCallback(/*enableGC=*/true);
+    testClosureDecision(/*enableGC=*/false);
+    testClosureDecision(/*enableGC=*/true);
+    testSolverInClosureDecision(/*enableGC=*/false);
+    testSolverInClosureDecision(/*enableGC=*/true);
   }
 }

examples/tests/TestRouting.java

@@ -28,8 +28,8 @@ public class TestRouting {
 
   private static final Logger logger = Logger.getLogger(TestRouting.class.getName());
 
-  static void testSimpleRouting(boolean enableGC) {
-    logger.info("testSimpleRouting (enable gc:" + enableGC + ")...");
+  static void testRoutingTransitCallback(boolean enableGC) {
+    logger.info("testRoutingTransitCallback (enable gc:" + enableGC + ")...");
     // Create Routing Index Manager
     RoutingIndexManager manager =
       new RoutingIndexManager(5/*location*/, 1/*vehicle*/, 0/*depot*/);
@@ -58,13 +58,49 @@ public class TestRouting {
             .build();
     // Solve the problem.
     Assignment solution = routing.solveWithParameters(searchParameters);
-    assert null != solution;
-    assert 5 == solution.objectiveValue();
-    logger.info("testSimpleRouting (enable gc:" + enableGC + ")...DONE");
+    if (null == solution) throw new AssertionError("null == solution");
+    if (8 != solution.objectiveValue()) throw new AssertionError("5 != objective");
+    logger.info("testRoutingTransitCallback (enable gc:" + enableGC + ")...DONE");
+  }
+
+  static void testRoutingUnaryTransitCallback(boolean enableGC) {
+    logger.info("testRoutingUnaryTransitCallback (enable gc:" + enableGC + ")...");
+    // Create Routing Index Manager
+    RoutingIndexManager manager =
+      new RoutingIndexManager(5/*location*/, 1/*vehicle*/, 0/*depot*/);
+    // Create Routing Model.
+    RoutingModel routing = new RoutingModel(manager);
+    // Define cost of each arc.
+    int transitCallbackIndex;
+    if (true) {
+      transitCallbackIndex = routing.registerUnaryTransitCallback(
+          (long fromIndex) -> {
+            // Convert from routing variable Index to user NodeIndex.
+            int fromNode = manager.indexToNode(fromIndex);
+            return abs(fromNode);
+          });
+    }
+    if (enableGC) {
+      System.gc();
+    }
+    routing.setArcCostEvaluatorOfAllVehicles(transitCallbackIndex);
+    // Setting first solution heuristic.
+    RoutingSearchParameters searchParameters =
+        main.defaultRoutingSearchParameters()
+            .toBuilder()
+            .setFirstSolutionStrategy(FirstSolutionStrategy.Value.PATH_CHEAPEST_ARC)
+            .build();
+    // Solve the problem.
+    Assignment solution = routing.solveWithParameters(searchParameters);
+    if (null == solution) throw new AssertionError("null == solution");
+    if (10 != solution.objectiveValue()) throw new AssertionError("5 != objective");
+    logger.info("testRoutingUnaryTransitCallback (enable gc:" + enableGC + ")...DONE");
   }
 
   public static void main(String[] args) throws Exception {
-    testSimpleRouting(/*enable_gc=*/false);
-    testSimpleRouting(/*enable_gc=*/true);
+    testRoutingTransitCallback(/*enable_gc=*/false);
+    testRoutingTransitCallback(/*enable_gc=*/true);
+    testRoutingUnaryTransitCallback(/*enable_gc=*/false);
+    testRoutingUnaryTransitCallback(/*enable_gc=*/true);
   }
 }

ortools/com/google/ortools/constraintsolver/IntIntToLongFunction.java

@@ -0,0 +1,36 @@
+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.ortools.constraintsolver;
+
+/**
+ * Represents a function that accepts two int-valued arguments and produces a
+ * long-valued result.  This is the {@code int}{@code int}-to-{@code long} primitive
+ * specialization for {@link Function}.
+ *
+ * <p>This is a functional interface
+ * whose functional method is {@link #applyAsLong(long, long)}.
+ * @see Function
+ * @see IntToLongFunction.
+ */
+@FunctionalInterface
+public interface IntIntToLongFunction {
+    /**
+     * Applies this function to the given arguments.
+     *
+     * @param left the first argument
+     * @param right the second argument
+     * @return the function result
+     */
+    long applyAsLong(int left, int right);
+}

ortools/com/google/ortools/constraintsolver/LongTernaryOperator.java

@@ -0,0 +1,37 @@
+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.ortools.constraintsolver;
+
+/**
+ * Represents an operation upon three {@code long}-valued operands and producing a
+ * {@code long}-valued result.  This is the primitive type specialization of
+ * TernaryOperator for {@code long}.
+ *
+ * <p>This is a functional interface
+ * whose functional method is {@link #applyAsLong(long, long, long)}.
+ * @see BinaryOperator
+ * @see LongUnaryOperator.
+ */
+@FunctionalInterface
+public interface LongTernaryOperator {
+    /**
+     * Applies this operator to the given operands.
+     *
+     * @param left the first operand
+     * @param center the second operand
+     * @param right the third operand
+     * @return the operator result
+     */
+    long applyAsLong(long left, long center, long right);
+}

ortools/com/google/ortools/constraintsolver/LongTernaryPredicate.java

@@ -0,0 +1,48 @@
+// Copyright 2010-2018 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.ortools.constraintsolver;
+
+/**
+ * Represents a predicate (boolean-valued function) uppon
+ * three {@code long}-valued operands. This is the {@code long}-consuming primitive type
+ * specialization of {@link Predicate}.
+ *
+ * <p>This is a functional interface
+ * whose functional method is {@link #test(long, long, long)}.
+ * @see Predicate
+ */
+@FunctionalInterface
+public interface LongTernaryPredicate {
+    /**
+     * Evaluates this predicate on the given arguments.
+     *
+     * @param left the first operand
+     * @param center the second operand
+     * @param right the third operand
+     * @return {@code true} if the input argument matches the predicate,
+     * otherwise {@code false}
+     */
+    boolean test(long left, long center, long right);
+
+    /**
+     * Returns a predicate that represents the logical negation of this
+     * predicate.
+     *
+     * @return a predicate that represents the logical negation of this
+     * predicate
+     */
+    default LongTernaryPredicate negate() {
+        return (left, center, right) -> !test(left, center, right);
+    }
+}

ortools/constraint_solver/constraint_solver.h

@@ -721,6 +721,7 @@ class Solver {
 
   typedef std::function<bool(int64)> IndexFilter1;
 
+#if !defined(SWIG)
   typedef std::function<IntVar*(int64)> Int64ToIntVar;
 
   typedef std::function<int64(Solver* solver, const std::vector<IntVar*>& vars,
@@ -728,6 +729,8 @@ class Solver {
       VariableIndexSelector;
 
   typedef std::function<int64(const IntVar* v, int64 id)> VariableValueSelector;
+#endif  // SWIG
+
   typedef std::function<bool(int64, int64, int64)> VariableValueComparator;
   typedef std::function<void(int64)> ObjectiveWatcher;
   typedef std::function<DecisionModification()> BranchSelector;

ortools/constraint_solver/csharp/constraint_solver.i

@@ -196,8 +196,7 @@ CS_TYPEMAP_STDVECTOR_OBJECT(operations_research::SymmetryBreaker, SymmetryBreake
 // Rename rule on SearchLimit
 %rename (IsCrossed) operations_research::SearchLimit::crossed;
 
-// Rename rule on DisjunctiveConstraint.
-%rename (SequenceVar) operations_research::DisjunctiveConstraint::MakeSequenceVar;
+// DisjunctiveConstraint.
 // Keep reference to delegate to avoid GC to collect them early
 %typemap(cscode) operations_research::DisjunctiveConstraint %{
   // Store list of delegates to avoid the GC to reclaim them.
@@ -210,6 +209,8 @@ CS_TYPEMAP_STDVECTOR_OBJECT(operations_research::SymmetryBreaker, SymmetryBreake
     return c;
   }
 %}
+// Rename rule on DisjunctiveConstraint.
+%rename (SequenceVar) operations_research::DisjunctiveConstraint::MakeSequenceVar;
 
 // Generic rename rules.
 %rename (ToString) *::DebugString;

ortools/constraint_solver/java/routing.i

@@ -49,26 +49,9 @@ DEFINE_INDEX_TYPE_TYPEDEF(
     operations_research::RoutingVehicleClassIndex,
     operations_research::RoutingModel::VehicleClassIndex);
 
-%ignore operations_research::RoutingModel::RegisterStateDependentTransitCallback;
-%ignore operations_research::RoutingModel::StateDependentTransitCallback;
-%ignore operations_research::RoutingModel::MakeStateDependentTransit;
-%ignore operations_research::RoutingModel::AddDimensionDependentDimensionWithVehicleCapacity;
-%ignore operations_research::RoutingModel::AddMatrixDimension(
-    std::vector<std::vector<int64> > values,
-    int64 capacity,
-    bool fix_start_cumul_to_zero,
-    const std::string& name);
 
-%extend operations_research::RoutingModel {
-  void addMatrixDimension(const std::vector<std::vector<int64> >& values,
-                          int64 capacity, bool fix_start_cumul_to_zero,
-                          const std::string& name) {
-    $self->AddMatrixDimension(values, capacity, fix_start_cumul_to_zero, name);
-  }
-}
-
-// RoutingModel Callback
 namespace operations_research {
+// RoutingModel
 // Map transit callback to Java @FunctionalInterface types.
 // This replaces the RoutingTransitCallback[1-2] in the Java proxy class
 %typemap(javaimports) RoutingModel %{
@@ -79,229 +62,203 @@ import java.util.function.LongBinaryOperator;
 // see https://docs.oracle.com/javase/8/docs/api/java/util/function/LongUnaryOperator.html
 import java.util.function.LongUnaryOperator;
 %}
-// Types in Proxy class (RoutingModel.java) e.g.:
-// Foo::f(jstype $javainput, ...) {Foo_f_SWIG(javain, ...);}
-#define VAR_ARGS(X...) X
-%define DEFINE_LONG_CALLBACK(
-  TYPE,
-  JAVA_TYPE, JAVA_METHOD, JAVA_SIGN,
-  LAMBDA_PARAM, LAMBDA_CALL)
-  %typemap(in) TYPE %{
-    jclass object_class = jenv->GetObjectClass($input);
-    if (nullptr == object_class) return $null;
-    jmethodID method_id = jenv->GetMethodID(
-      object_class, JAVA_METHOD, JAVA_SIGN);
-    assert(method_id != nullptr);
-    // $input is a local pointer which will be deleted once this function return.
-    // we need to create a global ref to keep the java object alive
-    jobject object_ref = jenv->NewGlobalRef($input);
+%ignore RoutingModel::RegisterStateDependentTransitCallback;
+%ignore RoutingModel::StateDependentTransitCallback;
+%ignore RoutingModel::MakeStateDependentTransit;
+%ignore RoutingModel::AddDimensionDependentDimensionWithVehicleCapacity;
+%ignore RoutingModel::AddMatrixDimension(
+    std::vector<std::vector<int64> > values,
+    int64 capacity,
+    bool fix_start_cumul_to_zero,
+    const std::string& name);
 
-    /* Global JNI reference deleter */
-    class GlobalRefGuard {
-      JNIEnv *jenv_;
-      jobject jref_;
-      // non-copyable
-      GlobalRefGuard(const GlobalRefGuard &) = delete;
-      GlobalRefGuard &operator=(const GlobalRefGuard &) = delete;
-      public:
-      GlobalRefGuard(JNIEnv *jenv, jobject jref): jenv_(jenv), jref_(jref) {}
-      ~GlobalRefGuard() {jenv_->DeleteGlobalRef(jref_);}
-    };
-    // instantiate an object responsible of deleting the global ref when no one
-    // own it (thus allowing the GC to collect the Java object).
-    auto guard = std::make_shared<GlobalRefGuard>(jenv, object_ref);
-    // lambda capture the guard thus capturing the Java object ownership.
-    $1 = [jenv, object_ref, method_id, guard](LAMBDA_PARAM) -> long {
-      return jenv->CallLongMethod(object_ref, method_id, LAMBDA_CALL);
-    };
-  %}
-  // These 3 typemaps tell SWIG which JNI and Java types to use.
-  %typemap(jni) TYPE "jobject" // Type used in the JNI C.
-  %typemap(jtype) TYPE "JAVA_TYPE" // Type used in the JNI.java.
-  %typemap(jstype) TYPE "JAVA_TYPE" // Type used in the Proxy class
-  %typemap(javain) TYPE "$javainput" // argument passed to JNI java class
-%enddef
-DEFINE_LONG_CALLBACK(
-  RoutingTransitCallback2,
-  LongBinaryOperator, "applyAsLong", "(JJ)J",
-  VAR_ARGS(long from, long to), VAR_ARGS(from, to))
-DEFINE_LONG_CALLBACK(
-  RoutingTransitCallback1,
-  LongUnaryOperator, "applyAsLong", "(J)J",
-  VAR_ARGS(long from), VAR_ARGS(from))
-}  // namespace operations_research
-
-%rename (activeVar) operations_research::RoutingModel::ActiveVar;
-%rename (addAllActive) operations_research::RoutingModel::AddAllActive;
-%rename (addAtSolutionCallback) operations_research::RoutingModel::AddAtSolutionCallback;
-%rename (addConstantDimension) operations_research::RoutingModel::AddConstantDimension;
-%rename (addConstantDimensionWithSlack) operations_research::RoutingModel::AddConstantDimensionWithSlack;
-%rename (addDimension) operations_research::RoutingModel::AddDimension;
-%rename (addDimensionWithVehicleCapacity) operations_research::RoutingModel::AddDimensionWithVehicleCapacity;
-%rename (addDimensionWithVehicleTransitAndCapacity) operations_research::RoutingModel::AddDimensionWithVehicleTransitAndCapacity;
-%rename (addDimensionWithVehicleTransits) operations_research::RoutingModel::AddDimensionWithVehicleTransits;
-%rename (addDisjunction) operations_research::RoutingModel::AddDisjunction;
-%rename (addIntervalToAssignment) operations_research::RoutingModel::AddIntervalToAssignment;
-%rename (addLocalSearchFilter) operations_research::RoutingModel::AddLocalSearchFilter;
-%rename (addLocalSearchOperator) operations_research::RoutingModel::AddLocalSearchOperator;
-%rename (addPickupAndDelivery) operations_research::RoutingModel::AddPickupAndDelivery;
-%rename (addPickupAndDeliverySets) operations_research::RoutingModel::AddPickupAndDeliverySets;
-%rename (addSearchMonitor) operations_research::RoutingModel::AddSearchMonitor;
-%rename (addSoftSameVehicleConstraint) operations_research::RoutingModel::AddSoftSameVehicleConstraint;
-%rename (addToAssignment) operations_research::RoutingModel::AddToAssignment;
-%rename (addTypeIncompatibility) operations_research::RoutingModel::AddTypeIncompatibility;
-%rename (addVariableMaximizedByFinalizer) operations_research::RoutingModel::AddVariableMaximizedByFinalizer;
-%rename (addVariableMinimizedByFinalizer) operations_research::RoutingModel::AddVariableMinimizedByFinalizer;
-%rename (addVectorDimension) operations_research::RoutingModel::AddVectorDimension;
-%rename (applyLocks) operations_research::RoutingModel::ApplyLocks;
-%rename (applyLocksToAllVehicles) operations_research::RoutingModel::ApplyLocksToAllVehicles;
-%rename (arcIsMoreConstrainedThanArc) operations_research::RoutingModel::ArcIsMoreConstrainedThanArc;
-%rename (assignmentToRoutes) operations_research::RoutingModel::AssignmentToRoutes;
-%rename (checkLimit) operations_research::RoutingModel::CheckLimit;
-%rename (closeModel) operations_research::RoutingModel::CloseModel;
-%rename (closeModelWithParameters) operations_research::RoutingModel::CloseModelWithParameters;
-%rename (compactAndCheckAssignment) operations_research::RoutingModel::CompactAndCheckAssignment;
-%rename (compactAssignment) operations_research::RoutingModel::CompactAssignment;
-%rename (computeLowerBound) operations_research::RoutingModel::ComputeLowerBound;
-%rename (costVar) operations_research::RoutingModel::CostVar;
-%rename (costsAreHomogeneousAcrossVehicles) operations_research::RoutingModel::CostsAreHomogeneousAcrossVehicles;
-%rename (debugOutputAssignment) operations_research::RoutingModel::DebugOutputAssignment;
-%rename (end) operations_research::RoutingModel::End;
-%rename (getAllDimensionNames) operations_research::RoutingModel::GetAllDimensionNames;
-%rename (getAmortizedLinearCostFactorOfVehicles) operations_research::RoutingModel::GetAmortizedLinearCostFactorOfVehicles;
-%rename (getAmortizedQuadraticCostFactorOfVehicles) operations_research::RoutingModel::GetAmortizedQuadraticCostFactorOfVehicles;
-%rename (getArcCostForClass) operations_research::RoutingModel::GetArcCostForClass;
-%rename (getArcCostForFirstSolution) operations_research::RoutingModel::GetArcCostForFirstSolution;
-%rename (getArcCostForVehicle) operations_research::RoutingModel::GetArcCostForVehicle;
-%rename (getCostClassIndexOfVehicle) operations_research::RoutingModel::GetCostClassIndexOfVehicle;
-%rename (getCostClassesCount) operations_research::RoutingModel::GetCostClassesCount;
-%rename (getDeliveryIndexPairs) operations_research::RoutingModel::GetDeliveryIndexPairs;
-%rename (getDepot) operations_research::RoutingModel::GetDepot;
-%rename (getDimensionOrDie) operations_research::RoutingModel::GetDimensionOrDie;
-%rename (getDimensions) operations_research::RoutingModel::GetDimensions;
-%rename (getDimensionsWithSoftAndSpanCosts) operations_research::RoutingModel::GetDimensionsWithSoftAndSpanCosts;
-%rename (getDimensionsWithSoftOrSpanCosts) operations_research::RoutingModel::GetDimensionsWithSoftOrSpanCosts;
-%rename (getDisjunctionIndices) operations_research::RoutingModel::GetDisjunctionIndices;
-%rename (getDisjunctionMaxCardinality) operations_research::RoutingModel::GetDisjunctionMaxCardinality;
-%rename (getDisjunctionPenalty) operations_research::RoutingModel::GetDisjunctionPenalty;
-%rename (getFixedCostOfVehicle) operations_research::RoutingModel::GetFixedCostOfVehicle;
-%rename (getHomogeneousCost) operations_research::RoutingModel::GetHomogeneousCost;
-%rename (getMutableDimension) operations_research::RoutingModel::GetMutableDimension;
-%rename (getNonZeroCostClassesCount) operations_research::RoutingModel::GetNonZeroCostClassesCount;
-%rename (getNumOfSingletonNodes) operations_research::RoutingModel::GetNumOfSingletonNodes;
-%rename (getNumberOfDecisionsInFirstSolution) operations_research::RoutingModel::GetNumberOfDecisionsInFirstSolution;
-%rename (getNumberOfDisjunctions) operations_research::RoutingModel::GetNumberOfDisjunctions;
-%rename (getNumberOfRejectsInFirstSolution) operations_research::RoutingModel::GetNumberOfRejectsInFirstSolution;
-%rename (getNumberOfVisitTypes) operations_research::RoutingModel::GetNumberOfVisitTypes;
-%rename (getPerfectBinaryDisjunctions) operations_research::RoutingModel::GetPerfectBinaryDisjunctions;
-%rename (getPickupAndDeliveryPolicyOfVehicle) operations_research::RoutingModel::GetPickupAndDeliveryPolicyOfVehicle;
-%rename (getPickupIndexPairs) operations_research::RoutingModel::GetPickupIndexPairs;
-%rename (getPrimaryConstrainedDimension) operations_research::RoutingModel::GetPrimaryConstrainedDimension;
-%rename (getSameVehicleIndicesOfIndex) operations_research::RoutingModel::GetSameVehicleIndicesOfIndex;
-%rename (getTypeIncompatibilities) operations_research::RoutingModel::GetTypeIncompatibilities;
-%rename (getVehicleClassIndexOfVehicle) operations_research::RoutingModel::GetVehicleClassIndexOfVehicle;
-%rename (getVehicleClassesCount) operations_research::RoutingModel::GetVehicleClassesCount;
-%rename (getVisitType) operations_research::RoutingModel::GetVisitType;
-%rename (hasDimension) operations_research::RoutingModel::HasDimension;
-%rename (hasVehicleWithCostClassIndex) operations_research::RoutingModel::HasVehicleWithCostClassIndex;
-%rename (ignoreDisjunctionsAlreadyForcedToZero) operations_research::RoutingModel::IgnoreDisjunctionsAlreadyForcedToZero;
-%rename (isEnd) operations_research::RoutingModel::IsEnd;
-%rename (isMatchingModel) operations_research::RoutingModel::IsMatchingModel;
-%rename (isStart) operations_research::RoutingModel::IsStart;
-%rename (isVehicleAllowedForIndex) operations_research::RoutingModel::IsVehicleAllowedForIndex;
-%rename (isVehicleUsed) operations_research::RoutingModel::IsVehicleUsed;
-%rename (makeGuidedSlackFinalizer) operations_research::RoutingModel::MakeGuidedSlackFinalizer;
-%rename (makeSelfDependentDimensionFinalizer) operations_research::RoutingModel::MakeSelfDependentDimensionFinalizer;
-%rename (mutablePreAssignment) operations_research::RoutingModel::MutablePreAssignment;
-%rename (next) operations_research::RoutingModel::Next;
-%rename (nextVar) operations_research::RoutingModel::NextVar;
-%rename (nexts) operations_research::RoutingModel::Nexts;
-%rename (preAssignment) operations_research::RoutingModel::PreAssignment;
-%rename (readAssignment) operations_research::RoutingModel::ReadAssignment;
-%rename (readAssignmentFromRoutes) operations_research::RoutingModel::ReadAssignmentFromRoutes;
-%rename (registerPositiveTransitCallback) operations_research::RoutingModel::RegisterPositiveTransitCallback;
-%rename (registerTransitCallback) operations_research::RoutingModel::RegisterTransitCallback;
-%rename (registerUnaryTransitCallback) operations_research::RoutingModel::RegisterUnaryTransitCallback;
-%rename (restoreAssignment) operations_research::RoutingModel::RestoreAssignment;
-%rename (routesToAssignment) operations_research::RoutingModel::RoutesToAssignment;
-%rename (setAllowedVehiclesForIndex) operations_research::RoutingModel::SetAllowedVehiclesForIndex;
-%rename (setAmortizedCostFactorsOfAllVehicles) operations_research::RoutingModel::SetAmortizedCostFactorsOfAllVehicles;
-%rename (setAmortizedCostFactorsOfVehicle) operations_research::RoutingModel::SetAmortizedCostFactorsOfVehicle;
-%rename (setArcCostEvaluatorOfAllVehicles) operations_research::RoutingModel::SetArcCostEvaluatorOfAllVehicles;
-%rename (setArcCostEvaluatorOfVehicle) operations_research::RoutingModel::SetArcCostEvaluatorOfVehicle;
-%rename (setAssignmentFromOtherModelAssignment) operations_research::RoutingModel::SetAssignmentFromOtherModelAssignment;
-%rename (setFirstSolutionEvaluator) operations_research::RoutingModel::SetFirstSolutionEvaluator;
-%rename (setFixedCostOfAllVehicles) operations_research::RoutingModel::SetFixedCostOfAllVehicles;
-%rename (setFixedCostOfVehicle) operations_research::RoutingModel::SetFixedCostOfVehicle;
-%rename (setPickupAndDeliveryPolicyOfAllVehicles) operations_research::RoutingModel::SetPickupAndDeliveryPolicyOfAllVehicles;
-%rename (setPickupAndDeliveryPolicyOfVehicle) operations_research::RoutingModel::SetPickupAndDeliveryPolicyOfVehicle;
-%rename (setPrimaryConstrainedDimension) operations_research::RoutingModel::SetPrimaryConstrainedDimension;
-%rename (setVisitType) operations_research::RoutingModel::SetVisitType;
-%rename (size) operations_research::RoutingModel::Size;
-%rename (solve) operations_research::RoutingModel::Solve;
-%rename (solveFromAssignmentWithParameters) operations_research::RoutingModel::SolveFromAssignmentWithParameters;
-%rename (solveWithParameters) operations_research::RoutingModel::SolveWithParameters;
-%rename (start) operations_research::RoutingModel::Start;
-%rename (transitCallback) operations_research::RoutingModel::TransitCallback;
-%rename (unaryTransitCallbackOrNull) operations_research::RoutingModel::UnaryTransitCallbackOrNull;
-%rename (unperformedPenalty) operations_research::RoutingModel::UnperformedPenalty;
-%rename (unperformedPenaltyOrValue) operations_research::RoutingModel::UnperformedPenaltyOrValue;
-%rename (vehicleVar) operations_research::RoutingModel::VehicleVar;
-%rename (vehicleVars) operations_research::RoutingModel::VehicleVars;
-%rename (writeAssignment) operations_research::RoutingModel::WriteAssignment;
+%extend RoutingModel {
+  void addMatrixDimension(const std::vector<std::vector<int64> >& values,
+                          int64 capacity, bool fix_start_cumul_to_zero,
+                          const std::string& name) {
+    $self->AddMatrixDimension(values, capacity, fix_start_cumul_to_zero, name);
+  }
+}
+%rename (activeVar) RoutingModel::ActiveVar;
+%rename (addAllActive) RoutingModel::AddAllActive;
+%rename (addAtSolutionCallback) RoutingModel::AddAtSolutionCallback;
+%rename (addConstantDimension) RoutingModel::AddConstantDimension;
+%rename (addConstantDimensionWithSlack) RoutingModel::AddConstantDimensionWithSlack;
+%rename (addDimension) RoutingModel::AddDimension;
+%rename (addDimensionWithVehicleCapacity) RoutingModel::AddDimensionWithVehicleCapacity;
+%rename (addDimensionWithVehicleTransitAndCapacity) RoutingModel::AddDimensionWithVehicleTransitAndCapacity;
+%rename (addDimensionWithVehicleTransits) RoutingModel::AddDimensionWithVehicleTransits;
+%rename (addDisjunction) RoutingModel::AddDisjunction;
+%rename (addIntervalToAssignment) RoutingModel::AddIntervalToAssignment;
+%rename (addLocalSearchFilter) RoutingModel::AddLocalSearchFilter;
+%rename (addLocalSearchOperator) RoutingModel::AddLocalSearchOperator;
+%rename (addPickupAndDelivery) RoutingModel::AddPickupAndDelivery;
+%rename (addPickupAndDeliverySets) RoutingModel::AddPickupAndDeliverySets;
+%rename (addSearchMonitor) RoutingModel::AddSearchMonitor;
+%rename (addSoftSameVehicleConstraint) RoutingModel::AddSoftSameVehicleConstraint;
+%rename (addToAssignment) RoutingModel::AddToAssignment;
+%rename (addTypeIncompatibility) RoutingModel::AddTypeIncompatibility;
+%rename (addVariableMaximizedByFinalizer) RoutingModel::AddVariableMaximizedByFinalizer;
+%rename (addVariableMinimizedByFinalizer) RoutingModel::AddVariableMinimizedByFinalizer;
+%rename (addVectorDimension) RoutingModel::AddVectorDimension;
+%rename (applyLocks) RoutingModel::ApplyLocks;
+%rename (applyLocksToAllVehicles) RoutingModel::ApplyLocksToAllVehicles;
+%rename (arcIsMoreConstrainedThanArc) RoutingModel::ArcIsMoreConstrainedThanArc;
+%rename (assignmentToRoutes) RoutingModel::AssignmentToRoutes;
+%rename (checkLimit) RoutingModel::CheckLimit;
+%rename (closeModel) RoutingModel::CloseModel;
+%rename (closeModelWithParameters) RoutingModel::CloseModelWithParameters;
+%rename (compactAndCheckAssignment) RoutingModel::CompactAndCheckAssignment;
+%rename (compactAssignment) RoutingModel::CompactAssignment;
+%rename (computeLowerBound) RoutingModel::ComputeLowerBound;
+%rename (costVar) RoutingModel::CostVar;
+%rename (costsAreHomogeneousAcrossVehicles) RoutingModel::CostsAreHomogeneousAcrossVehicles;
+%rename (debugOutputAssignment) RoutingModel::DebugOutputAssignment;
+%rename (end) RoutingModel::End;
+%rename (getAllDimensionNames) RoutingModel::GetAllDimensionNames;
+%rename (getAmortizedLinearCostFactorOfVehicles) RoutingModel::GetAmortizedLinearCostFactorOfVehicles;
+%rename (getAmortizedQuadraticCostFactorOfVehicles) RoutingModel::GetAmortizedQuadraticCostFactorOfVehicles;
+%rename (getArcCostForClass) RoutingModel::GetArcCostForClass;
+%rename (getArcCostForFirstSolution) RoutingModel::GetArcCostForFirstSolution;
+%rename (getArcCostForVehicle) RoutingModel::GetArcCostForVehicle;
+%rename (getCostClassIndexOfVehicle) RoutingModel::GetCostClassIndexOfVehicle;
+%rename (getCostClassesCount) RoutingModel::GetCostClassesCount;
+%rename (getDeliveryIndexPairs) RoutingModel::GetDeliveryIndexPairs;
+%rename (getDepot) RoutingModel::GetDepot;
+%rename (getDimensionOrDie) RoutingModel::GetDimensionOrDie;
+%rename (getDimensions) RoutingModel::GetDimensions;
+%rename (getDimensionsWithSoftAndSpanCosts) RoutingModel::GetDimensionsWithSoftAndSpanCosts;
+%rename (getDimensionsWithSoftOrSpanCosts) RoutingModel::GetDimensionsWithSoftOrSpanCosts;
+%rename (getDisjunctionIndices) RoutingModel::GetDisjunctionIndices;
+%rename (getDisjunctionMaxCardinality) RoutingModel::GetDisjunctionMaxCardinality;
+%rename (getDisjunctionPenalty) RoutingModel::GetDisjunctionPenalty;
+%rename (getFixedCostOfVehicle) RoutingModel::GetFixedCostOfVehicle;
+%rename (getHomogeneousCost) RoutingModel::GetHomogeneousCost;
+%rename (getMutableDimension) RoutingModel::GetMutableDimension;
+%rename (getNonZeroCostClassesCount) RoutingModel::GetNonZeroCostClassesCount;
+%rename (getNumOfSingletonNodes) RoutingModel::GetNumOfSingletonNodes;
+%rename (getNumberOfDecisionsInFirstSolution) RoutingModel::GetNumberOfDecisionsInFirstSolution;
+%rename (getNumberOfDisjunctions) RoutingModel::GetNumberOfDisjunctions;
+%rename (getNumberOfRejectsInFirstSolution) RoutingModel::GetNumberOfRejectsInFirstSolution;
+%rename (getNumberOfVisitTypes) RoutingModel::GetNumberOfVisitTypes;
+%rename (getPerfectBinaryDisjunctions) RoutingModel::GetPerfectBinaryDisjunctions;
+%rename (getPickupAndDeliveryPolicyOfVehicle) RoutingModel::GetPickupAndDeliveryPolicyOfVehicle;
+%rename (getPickupIndexPairs) RoutingModel::GetPickupIndexPairs;
+%rename (getPrimaryConstrainedDimension) RoutingModel::GetPrimaryConstrainedDimension;
+%rename (getSameVehicleIndicesOfIndex) RoutingModel::GetSameVehicleIndicesOfIndex;
+%rename (getTypeIncompatibilities) RoutingModel::GetTypeIncompatibilities;
+%rename (getVehicleClassIndexOfVehicle) RoutingModel::GetVehicleClassIndexOfVehicle;
+%rename (getVehicleClassesCount) RoutingModel::GetVehicleClassesCount;
+%rename (getVisitType) RoutingModel::GetVisitType;
+%rename (hasDimension) RoutingModel::HasDimension;
+%rename (hasVehicleWithCostClassIndex) RoutingModel::HasVehicleWithCostClassIndex;
+%rename (ignoreDisjunctionsAlreadyForcedToZero) RoutingModel::IgnoreDisjunctionsAlreadyForcedToZero;
+%rename (isEnd) RoutingModel::IsEnd;
+%rename (isMatchingModel) RoutingModel::IsMatchingModel;
+%rename (isStart) RoutingModel::IsStart;
+%rename (isVehicleAllowedForIndex) RoutingModel::IsVehicleAllowedForIndex;
+%rename (isVehicleUsed) RoutingModel::IsVehicleUsed;
+%rename (makeGuidedSlackFinalizer) RoutingModel::MakeGuidedSlackFinalizer;
+%rename (makeSelfDependentDimensionFinalizer) RoutingModel::MakeSelfDependentDimensionFinalizer;
+%rename (mutablePreAssignment) RoutingModel::MutablePreAssignment;
+%rename (next) RoutingModel::Next;
+%rename (nextVar) RoutingModel::NextVar;
+%rename (nexts) RoutingModel::Nexts;
+%rename (preAssignment) RoutingModel::PreAssignment;
+%rename (readAssignment) RoutingModel::ReadAssignment;
+%rename (readAssignmentFromRoutes) RoutingModel::ReadAssignmentFromRoutes;
+%rename (registerPositiveTransitCallback) RoutingModel::RegisterPositiveTransitCallback;
+%rename (registerTransitCallback) RoutingModel::RegisterTransitCallback;
+%rename (registerUnaryTransitCallback) RoutingModel::RegisterUnaryTransitCallback;
+%rename (restoreAssignment) RoutingModel::RestoreAssignment;
+%rename (routesToAssignment) RoutingModel::RoutesToAssignment;
+%rename (setAllowedVehiclesForIndex) RoutingModel::SetAllowedVehiclesForIndex;
+%rename (setAmortizedCostFactorsOfAllVehicles) RoutingModel::SetAmortizedCostFactorsOfAllVehicles;
+%rename (setAmortizedCostFactorsOfVehicle) RoutingModel::SetAmortizedCostFactorsOfVehicle;
+%rename (setArcCostEvaluatorOfAllVehicles) RoutingModel::SetArcCostEvaluatorOfAllVehicles;
+%rename (setArcCostEvaluatorOfVehicle) RoutingModel::SetArcCostEvaluatorOfVehicle;
+%rename (setAssignmentFromOtherModelAssignment) RoutingModel::SetAssignmentFromOtherModelAssignment;
+%rename (setFirstSolutionEvaluator) RoutingModel::SetFirstSolutionEvaluator;
+%rename (setFixedCostOfAllVehicles) RoutingModel::SetFixedCostOfAllVehicles;
+%rename (setFixedCostOfVehicle) RoutingModel::SetFixedCostOfVehicle;
+%rename (setPickupAndDeliveryPolicyOfAllVehicles) RoutingModel::SetPickupAndDeliveryPolicyOfAllVehicles;
+%rename (setPickupAndDeliveryPolicyOfVehicle) RoutingModel::SetPickupAndDeliveryPolicyOfVehicle;
+%rename (setPrimaryConstrainedDimension) RoutingModel::SetPrimaryConstrainedDimension;
+%rename (setVisitType) RoutingModel::SetVisitType;
+%rename (size) RoutingModel::Size;
+%rename (solve) RoutingModel::Solve;
+%rename (solveFromAssignmentWithParameters) RoutingModel::SolveFromAssignmentWithParameters;
+%rename (solveWithParameters) RoutingModel::SolveWithParameters;
+%rename (start) RoutingModel::Start;
+%rename (transitCallback) RoutingModel::TransitCallback;
+%rename (unaryTransitCallbackOrNull) RoutingModel::UnaryTransitCallbackOrNull;
+%rename (unperformedPenalty) RoutingModel::UnperformedPenalty;
+%rename (unperformedPenaltyOrValue) RoutingModel::UnperformedPenaltyOrValue;
+%rename (vehicleVar) RoutingModel::VehicleVar;
+%rename (vehicleVars) RoutingModel::VehicleVars;
+%rename (writeAssignment) RoutingModel::WriteAssignment;
 
 // Add PickupAndDeliveryPolicy enum value to RoutingModel (like RoutingModel::Status)
 // For C++11 strongly typed enum SWIG support see https://github.com/swig/swig/issues/316
-%extend operations_research::RoutingModel {
-  static const operations_research::RoutingModel::PickupAndDeliveryPolicy ANY =
+%extend RoutingModel {
+  static const RoutingModel::PickupAndDeliveryPolicy ANY =
   operations_research::RoutingModel::PickupAndDeliveryPolicy::ANY;
-  static const operations_research::RoutingModel::PickupAndDeliveryPolicy LIFO =
+  static const RoutingModel::PickupAndDeliveryPolicy LIFO =
   operations_research::RoutingModel::PickupAndDeliveryPolicy::LIFO;
-  static const operations_research::RoutingModel::PickupAndDeliveryPolicy FIFO =
+  static const RoutingModel::PickupAndDeliveryPolicy FIFO =
   operations_research::RoutingModel::PickupAndDeliveryPolicy::FIFO;
 }
 
 // RoutingDimension methods.
-%rename (cumulVar) operations_research::RoutingDimension::CumulVar;
-%rename (fixedTransitVar) operations_research::RoutingDimension::FixedTransitVar;
-%rename (getBreakIntervalsOfVehicle) operations_research::RoutingDimension::GetBreakIntervalsOfVehicle;
-%rename (getCumulVarSoftLowerBound) operations_research::RoutingDimension::GetCumulVarSoftLowerBound;
-%rename (getCumulVarSoftLowerBoundCoefficient) operations_research::RoutingDimension::GetCumulVarSoftLowerBoundCoefficient;
-%rename (getCumulVarSoftUpperBound) operations_research::RoutingDimension::GetCumulVarSoftUpperBound;
-%rename (getCumulVarSoftUpperBoundCoefficient) operations_research::RoutingDimension::GetCumulVarSoftUpperBoundCoefficient;
-%rename (getGlobalSpanCostCoefficient) operations_research::RoutingDimension::global_span_cost_coefficient;
-%rename (getGroupDelay) operations_research::RoutingDimension::GetGroupDelay;
-%rename (getNodeVisitTransitsOfVehicle) operations_research::RoutingDimension::GetNodeVisitTransitsOfVehicle;
-%rename (getSpanCostCoefficientForVehicle) operations_research::RoutingDimension::GetSpanCostCoefficientForVehicle;
-%rename (getSpanUpperBoundForVehicle) operations_research::RoutingDimension::GetSpanUpperBoundForVehicle;
-%rename (getTransitValue) operations_research::RoutingDimension::GetTransitValue;
-%rename (getTransitValueFromClass) operations_research::RoutingDimension::GetTransitValueFromClass;
-%rename (hasCumulVarSoftLowerBound) operations_research::RoutingDimension::HasCumulVarSoftLowerBound;
-%rename (hasCumulVarSoftUpperBound) operations_research::RoutingDimension::HasCumulVarSoftUpperBound;
-%rename (hasPickupToDeliveryLimits) operations_research::RoutingDimension::HasPickupToDeliveryLimits;
-%rename (setBreakIntervalsOfVehicle) operations_research::RoutingDimension::SetBreakIntervalsOfVehicle;
-%rename (setCumulVarSoftLowerBound) operations_research::RoutingDimension::SetCumulVarSoftLowerBound;
-%rename (setCumulVarSoftUpperBound) operations_research::RoutingDimension::SetCumulVarSoftUpperBound;
-%rename (setGlobalSpanCostCoefficient) operations_research::RoutingDimension::SetGlobalSpanCostCoefficient;
-%rename (setPickupToDeliveryLimitFunctionForPair) operations_research::RoutingDimension::SetPickupToDeliveryLimitFunctionForPair;
-%rename (setSpanCostCoefficientForAllVehicles) operations_research::RoutingDimension::SetSpanCostCoefficientForAllVehicles;
-%rename (setSpanCostCoefficientForVehicle) operations_research::RoutingDimension::SetSpanCostCoefficientForVehicle;
-%rename (setSpanUpperBoundForVehicle) operations_research::RoutingDimension::SetSpanUpperBoundForVehicle;
-%rename (shortestTransitionSlack) operations_research::RoutingDimension::ShortestTransitionSlack;
-%rename (slackVar) operations_research::RoutingDimension::SlackVar;
-%rename (transitVar) operations_research::RoutingDimension::TransitVar;
-%rename (vehicleHasBreakIntervals) operations_research::RoutingDimension::VehicleHasBreakIntervals;
+// Map transit callback to Java @FunctionalInterface types.
+// This replaces the RoutingTransitCallback[1-2] in the Java proxy class
+%typemap(javaimports) RoutingDimension %{
+// Used to wrap std::function<int64(int64 from_index, int64 to_index)> group_delay
+// see https://docs.oracle.com/javase/8/docs/api/java/util/function/LongBinaryOperator.html
+import java.util.function.LongBinaryOperator;
+%}
+%rename (cumulVar) RoutingDimension::CumulVar;
+%rename (fixedTransitVar) RoutingDimension::FixedTransitVar;
+%rename (getBreakIntervalsOfVehicle) RoutingDimension::GetBreakIntervalsOfVehicle;
+%rename (getCumulVarSoftLowerBound) RoutingDimension::GetCumulVarSoftLowerBound;
+%rename (getCumulVarSoftLowerBoundCoefficient) RoutingDimension::GetCumulVarSoftLowerBoundCoefficient;
+%rename (getCumulVarSoftUpperBound) RoutingDimension::GetCumulVarSoftUpperBound;
+%rename (getCumulVarSoftUpperBoundCoefficient) RoutingDimension::GetCumulVarSoftUpperBoundCoefficient;
+%rename (getGlobalSpanCostCoefficient) RoutingDimension::global_span_cost_coefficient;
+%rename (getGroupDelay) RoutingDimension::GetGroupDelay;
+%rename (getNodeVisitTransitsOfVehicle) RoutingDimension::GetNodeVisitTransitsOfVehicle;
+%rename (getSpanCostCoefficientForVehicle) RoutingDimension::GetSpanCostCoefficientForVehicle;
+%rename (getSpanUpperBoundForVehicle) RoutingDimension::GetSpanUpperBoundForVehicle;
+%rename (getTransitValue) RoutingDimension::GetTransitValue;
+%rename (getTransitValueFromClass) RoutingDimension::GetTransitValueFromClass;
+%rename (hasCumulVarSoftLowerBound) RoutingDimension::HasCumulVarSoftLowerBound;
+%rename (hasCumulVarSoftUpperBound) RoutingDimension::HasCumulVarSoftUpperBound;
+%rename (hasPickupToDeliveryLimits) RoutingDimension::HasPickupToDeliveryLimits;
+%rename (setBreakIntervalsOfVehicle) RoutingDimension::SetBreakIntervalsOfVehicle;
+%rename (setCumulVarSoftLowerBound) RoutingDimension::SetCumulVarSoftLowerBound;
+%rename (setCumulVarSoftUpperBound) RoutingDimension::SetCumulVarSoftUpperBound;
+%rename (setGlobalSpanCostCoefficient) RoutingDimension::SetGlobalSpanCostCoefficient;
+%rename (setPickupToDeliveryLimitFunctionForPair) RoutingDimension::SetPickupToDeliveryLimitFunctionForPair;
+%rename (setSpanCostCoefficientForAllVehicles) RoutingDimension::SetSpanCostCoefficientForAllVehicles;
+%rename (setSpanCostCoefficientForVehicle) RoutingDimension::SetSpanCostCoefficientForVehicle;
+%rename (setSpanUpperBoundForVehicle) RoutingDimension::SetSpanUpperBoundForVehicle;
+%rename (shortestTransitionSlack) RoutingDimension::ShortestTransitionSlack;
+%rename (slackVar) RoutingDimension::SlackVar;
+%rename (transitVar) RoutingDimension::TransitVar;
+%rename (vehicleHasBreakIntervals) RoutingDimension::VehicleHasBreakIntervals;
 
 // RoutingFilteredDecisionBuilder methods.
-%rename (getEndChainStart) operations_research::RoutingFilteredDecisionBuilder::GetEndChainStart;
-%rename (getStartChainEnd) operations_research::RoutingFilteredDecisionBuilder::GetStartChainEnd;
-%rename (initializeRoutes) operations_research::RoutingFilteredDecisionBuilder::InitializeRoutes;
-%rename (makeDisjunctionNodesUnperformed) operations_research::RoutingFilteredDecisionBuilder::MakeDisjunctionNodesUnperformed;
-%rename (makeUnassignedNodesUnperformed) operations_research::RoutingFilteredDecisionBuilder::MakeUnassignedNodesUnperformed;
+%rename (getEndChainStart) RoutingFilteredDecisionBuilder::GetEndChainStart;
+%rename (getStartChainEnd) RoutingFilteredDecisionBuilder::GetStartChainEnd;
+%rename (initializeRoutes) RoutingFilteredDecisionBuilder::InitializeRoutes;
+%rename (makeDisjunctionNodesUnperformed) RoutingFilteredDecisionBuilder::MakeDisjunctionNodesUnperformed;
+%rename (makeUnassignedNodesUnperformed) RoutingFilteredDecisionBuilder::MakeUnassignedNodesUnperformed;
 
 // Generic rename rules.
 %rename (buildSolution) *::BuildSolution;
 
+}  // namespace operations_research
+
 // Protobuf support
 PROTO_INPUT(operations_research::RoutingSearchParameters,
             com.google.ortools.constraintsolver.RoutingSearchParameters,
@@ -321,18 +278,14 @@ PROTO2_RETURN(operations_research::RoutingModelParameters,
 %unignore RoutingIndexPair;
 %unignore RoutingIndexPairs;
 
-// Add needed import to mainJNI.java
-%pragma(java) jniclassimports=%{
-import java.util.function.LongBinaryOperator;
-import java.util.function.LongUnaryOperator;
-%}
-
+namespace operations_research {
 // IMPORTANT(viger): These functions from routing_parameters.h are global, so in
 // java they are in the main.java (import com.[...].constraintsolver.main).
 %rename (defaultRoutingSearchParameters) DefaultRoutingSearchParameters;
 %rename (defaultRoutingModelParameters) DefaultRoutingModelParameters;
 %rename (findErrorInRoutingSearchParameters) FindErrorInRoutingSearchParameters;
-%rename (makeSetValuesFromTargets) operations_research::MakeSetValuesFromTargets;
+%rename (makeSetValuesFromTargets) MakeSetValuesFromTargets;
+}  // namespace operations_research
 
 %include "ortools/constraint_solver/routing_types.h"
 %include "ortools/constraint_solver/routing_parameters.h"