rename InsertionBuilder

jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/box/Jsprit.java

@@ -526,8 +526,8 @@ public class Jsprit {
         boolean fastRegret = Boolean.parseBoolean(getProperty(Parameter.FAST_REGRET.toString()));
         if (es != null) {
             if(fastRegret){
-                RegretInsertionConcurrentFast regretInsertion = (RegretInsertionConcurrentFast) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
+                RegretInsertionConcurrentFast regretInsertion = (RegretInsertionConcurrentFast) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
-                    .setInsertionStrategy(InsertionBuilder.Strategy.REGRET)
+                    .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET)
                     .setConcurrentMode(es, noThreads)
                     .setFastRegret(true)
                     .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString())))
@@ -540,8 +540,8 @@ public class Jsprit {
                 regret = regretInsertion;
             }
             else {
-                RegretInsertionConcurrent regretInsertion = (RegretInsertionConcurrent) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
+                RegretInsertionConcurrent regretInsertion = (RegretInsertionConcurrent) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
-                    .setInsertionStrategy(InsertionBuilder.Strategy.REGRET)
+                    .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET)
                     .setConcurrentMode(es, noThreads)
                     .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString())))
                     .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString())))
@@ -553,8 +553,8 @@ public class Jsprit {
             }
         } else {
             if(fastRegret) {
-                RegretInsertionFast regretInsertion = (RegretInsertionFast) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
+                RegretInsertionFast regretInsertion = (RegretInsertionFast) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
-                    .setInsertionStrategy(InsertionBuilder.Strategy.REGRET)
+                    .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET)
                     .setFastRegret(true)
                     .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString())))
                     .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString())))
@@ -566,8 +566,8 @@ public class Jsprit {
                 regret = regretInsertion;
             }
             else{
-                RegretInsertion regretInsertion = (RegretInsertion) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
+                RegretInsertion regretInsertion = (RegretInsertion) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
-                    .setInsertionStrategy(InsertionBuilder.Strategy.REGRET)
+                    .setInsertionStrategy(InsertionStrategyBuilder.Strategy.REGRET)
                     .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString())))
                     .considerFixedCosts(toDouble(getProperty(Parameter.FIXED_COST_PARAM.toString())))
                     .setActivityInsertionCostCalculator(activityInsertion)
@@ -581,16 +581,16 @@ public class Jsprit {
 
         AbstractInsertionStrategy best;
         if (vrp.getJobs().size() < 250 || es == null) {
-            BestInsertion bestInsertion = (BestInsertion) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
+            BestInsertion bestInsertion = (BestInsertion) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
-                .setInsertionStrategy(InsertionBuilder.Strategy.BEST)
+                .setInsertionStrategy(InsertionStrategyBuilder.Strategy.BEST)
                 .considerFixedCosts(Double.valueOf(properties.getProperty(Parameter.FIXED_COST_PARAM.toString())))
                 .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString())))
                 .setActivityInsertionCostCalculator(activityInsertion)
                 .build();
             best = bestInsertion;
         } else {
-            BestInsertionConcurrent bestInsertion = (BestInsertionConcurrent) new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
+            BestInsertionConcurrent bestInsertion = (BestInsertionConcurrent) new InsertionStrategyBuilder(vrp, vehicleFleetManager, stateManager, constraintManager)
-                .setInsertionStrategy(InsertionBuilder.Strategy.BEST)
+                .setInsertionStrategy(InsertionStrategyBuilder.Strategy.BEST)
                 .considerFixedCosts(Double.valueOf(properties.getProperty(Parameter.FIXED_COST_PARAM.toString())))
                 .setAllowVehicleSwitch(toBoolean(getProperty(Parameter.VEHICLE_SWITCH.toString())))
                 .setConcurrentMode(es, noThreads)

jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionBuilder.java

@@ -28,7 +28,10 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 
-
+/**
+ * use InsertionStrategyBuilder instead
+ */
+@Deprecated
 public class InsertionBuilder {
 
     private boolean fastRegret;

jsprit-core/src/main/java/com/graphhopper/jsprit/core/algorithm/recreate/InsertionStrategyBuilder.java

@@ -0,0 +1,212 @@
+/*
+ * Licensed to GraphHopper GmbH under one or more contributor
+ * license agreements. See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ *
+ * GraphHopper GmbH licenses this file to you 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.graphhopper.jsprit.core.algorithm.recreate;
+
+import com.graphhopper.jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners;
+import com.graphhopper.jsprit.core.algorithm.recreate.listener.InsertionListener;
+import com.graphhopper.jsprit.core.algorithm.state.StateManager;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.constraint.ConstraintManager;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleFleetManager;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+
+
+public class InsertionStrategyBuilder {
+
+    private boolean fastRegret;
+
+
+    public enum Strategy {
+        REGRET, BEST
+    }
+
+    private VehicleRoutingProblem vrp;
+
+    private StateManager stateManager;
+
+    private boolean local = true;
+
+    private ConstraintManager constraintManager;
+
+    private VehicleFleetManager fleetManager;
+
+    private double weightOfFixedCosts;
+
+    private boolean considerFixedCosts = false;
+
+    private ActivityInsertionCostsCalculator actInsertionCostsCalculator = null;
+
+    private int forwaredLooking;
+
+    private int memory;
+
+    private ExecutorService executor;
+
+    private int nuOfThreads;
+
+    private double timeSlice;
+
+    private int nNeighbors;
+
+    private boolean timeScheduling = false;
+
+    private boolean allowVehicleSwitch = true;
+
+    private boolean addDefaultCostCalc = true;
+
+    private Strategy strategy = Strategy.BEST;
+
+    private boolean isFastRegret = false;
+
+    public InsertionStrategyBuilder(VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, StateManager stateManager, ConstraintManager constraintManager) {
+        super();
+        this.vrp = vrp;
+        this.stateManager = stateManager;
+        this.constraintManager = constraintManager;
+        this.fleetManager = vehicleFleetManager;
+    }
+
+    public InsertionStrategyBuilder setInsertionStrategy(Strategy strategy) {
+        this.strategy = strategy;
+        return this;
+    }
+
+    public InsertionStrategyBuilder setRouteLevel(int forwardLooking, int memory) {
+        local = false;
+        this.forwaredLooking = forwardLooking;
+        this.memory = memory;
+        return this;
+    }
+
+    public InsertionStrategyBuilder setRouteLevel(int forwardLooking, int memory, boolean addDefaultMarginalCostCalculation) {
+        local = false;
+        this.forwaredLooking = forwardLooking;
+        this.memory = memory;
+        this.addDefaultCostCalc = addDefaultMarginalCostCalculation;
+        return this;
+    }
+
+    public InsertionStrategyBuilder setFastRegret(boolean fastRegret) {
+        this.isFastRegret = fastRegret;
+        return this;
+    }
+
+
+    public InsertionStrategyBuilder setLocalLevel() {
+        local = true;
+        return this;
+    }
+
+    /**
+     * If addDefaulMarginalCostCalculation is false, no calculator is set which implicitly assumes that marginal cost calculation
+     * is controlled by your custom soft constraints.
+     *
+     * @param addDefaultMarginalCostCalculation
+     * @return
+     */
+    public InsertionStrategyBuilder setLocalLevel(boolean addDefaultMarginalCostCalculation) {
+        local = true;
+        addDefaultCostCalc = addDefaultMarginalCostCalculation;
+        return this;
+    }
+
+    public InsertionStrategyBuilder considerFixedCosts(double weightOfFixedCosts) {
+        this.weightOfFixedCosts = weightOfFixedCosts;
+        this.considerFixedCosts = true;
+        return this;
+    }
+
+    public InsertionStrategyBuilder setActivityInsertionCostCalculator(ActivityInsertionCostsCalculator activityInsertionCostsCalculator) {
+        this.actInsertionCostsCalculator = activityInsertionCostsCalculator;
+        return this;
+    }
+
+    public InsertionStrategyBuilder setConcurrentMode(ExecutorService executor, int nuOfThreads) {
+        this.executor = executor;
+        this.nuOfThreads = nuOfThreads;
+        return this;
+    }
+
+
+    public InsertionStrategy build() {
+        List<InsertionListener> iListeners = new ArrayList<InsertionListener>();
+        List<VehicleRoutingAlgorithmListeners.PrioritizedVRAListener> algorithmListeners = new ArrayList<VehicleRoutingAlgorithmListeners.PrioritizedVRAListener>();
+        JobInsertionCostsCalculatorBuilder calcBuilder = new JobInsertionCostsCalculatorBuilder(iListeners, algorithmListeners);
+        if (local) {
+            calcBuilder.setLocalLevel(addDefaultCostCalc);
+        } else {
+            calcBuilder.setRouteLevel(forwaredLooking, memory, addDefaultCostCalc);
+        }
+        calcBuilder.setConstraintManager(constraintManager);
+        calcBuilder.setStateManager(stateManager);
+        calcBuilder.setVehicleRoutingProblem(vrp);
+        calcBuilder.setVehicleFleetManager(fleetManager);
+        calcBuilder.setActivityInsertionCostsCalculator(actInsertionCostsCalculator);
+        if (considerFixedCosts) {
+            calcBuilder.considerFixedCosts(weightOfFixedCosts);
+        }
+        if (timeScheduling) {
+            calcBuilder.experimentalTimeScheduler(timeSlice, nNeighbors);
+        }
+        calcBuilder.setAllowVehicleSwitch(allowVehicleSwitch);
+        JobInsertionCostsCalculator costCalculator = calcBuilder.build();
+
+        InsertionStrategy insertion;
+        if (strategy.equals(Strategy.BEST)) {
+            if (executor == null) {
+                insertion = new BestInsertion(costCalculator, vrp);
+            } else {
+                insertion = new BestInsertionConcurrent(costCalculator, executor, nuOfThreads, vrp);
+            }
+        } else if (strategy.equals(Strategy.REGRET)) {
+            if (executor == null) {
+                if (isFastRegret) {
+                    RegretInsertionFast regret = new RegretInsertionFast(costCalculator, vrp, fleetManager);
+                    regret.setSwitchAllowed(allowVehicleSwitch);
+                    insertion = regret;
+                } else {
+                    RegretInsertion regret = new RegretInsertion(costCalculator, vrp);
+                    insertion = regret;
+                }
+
+            } else {
+                if (isFastRegret) {
+                    RegretInsertionConcurrentFast regret = new RegretInsertionConcurrentFast(costCalculator, vrp, executor, fleetManager);
+                    regret.setSwitchAllowed(allowVehicleSwitch);
+                    insertion = regret;
+                } else {
+                    RegretInsertionConcurrent regret = new RegretInsertionConcurrent(costCalculator, vrp, executor);
+                    insertion = regret;
+                }
+
+            }
+        } else throw new IllegalStateException("you should never get here");
+        for (InsertionListener l : iListeners) insertion.addListener(l);
+        return insertion;
+    }
+
+    public InsertionStrategyBuilder setAllowVehicleSwitch(boolean allowVehicleSwitch) {
+        this.allowVehicleSwitch = allowVehicleSwitch;
+        return this;
+    }
+
+
+}