relax api

jsprit-core/src/main/java/algorithms/BestInsertionBuilder.java

@@ -4,6 +4,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 import basics.VehicleRoutingProblem;
+import basics.VehicleRoutingProblem.Constraint;
 import basics.algo.InsertionListener;
 import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
 
@@ -25,11 +26,34 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
 
 	private ActivityInsertionCostsCalculator actInsertionCostsCalculator = null;
 	
-	public BestInsertionBuilder(VehicleRoutingProblem vrp, StateManager stateManager) {
+	public BestInsertionBuilder(VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, StateManager stateManager) {
 		super();
 		this.vrp = vrp;
 		this.stateManager = stateManager;
 		this.constraintManager = new ConstraintManager();
+		this.fleetManager = vehicleFleetManager;
+	}
+	
+	/**
+	 * Adds core constraints, i.e.
+	 * 
+	 * <p>HardPickupAndDeliveryLoadRouteLevelConstraint<br>
+	 * HardTimeWindowActivityLevelConstraint<br>
+	 * if(Constraint.DELIVERIES_FIRST) HardPickupAndDeliveryBackhaulActivityLevelConstraint<br>
+	 * else HardPickupAndDeliveryActivityLevelConstraint
+	 * @return
+	 */
+	public BestInsertionBuilder addCoreConstraints(){
+		constraintManager.addConstraint(new HardPickupAndDeliveryLoadRouteLevelConstraint(stateManager));
+		constraintManager.addConstraint(new HardTimeWindowActivityLevelConstraint(stateManager, vrp.getTransportCosts()));
+		if(vrp.getProblemConstraints().contains(Constraint.DELIVERIES_FIRST)){
+			constraintManager.addConstraint(new HardPickupAndDeliveryBackhaulActivityLevelConstraint(stateManager));
+		}
+		else{
+			constraintManager.addConstraint(new HardPickupAndDeliveryActivityLevelConstraint(stateManager));
+		}
+		StateUtils.addCoreStateUpdaters(vrp, stateManager);
+		return this;
 	}
 
 	public BestInsertionBuilder addConstraint(HardActivityLevelConstraint hardActvitiyLevelConstraint){
@@ -55,11 +79,6 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
 		return this;
 	}
 	
-	public BestInsertionBuilder setFleetManager(VehicleFleetManager fleetManager){
-		this.fleetManager = fleetManager;
-		return this;
-	}
-	
 	public void setActivityInsertionCostCalculator(ActivityInsertionCostsCalculator activityInsertionCostsCalculator){
 		this.actInsertionCostsCalculator = activityInsertionCostsCalculator;
 	};
@@ -69,19 +88,53 @@ public class BestInsertionBuilder implements InsertionStrategyBuilder{
 		List<InsertionListener> iListeners = new ArrayList<InsertionListener>();
 		List<PrioritizedVRAListener> algorithmListeners = new ArrayList<PrioritizedVRAListener>();
 		CalculatorBuilder calcBuilder = new CalculatorBuilder(iListeners, algorithmListeners);
+		addCoreUpdater();
+		
 		if(local){
 			calcBuilder.setLocalLevel();
 		}
+		else {
+			//add CostsUpdater
+			
+		}
+//			calcBuilder.setRouteLevel(forwardLooking, memory);
+//		}
 		calcBuilder.setConstraintManager(constraintManager);
 		calcBuilder.setStates(stateManager);
 		calcBuilder.setVehicleRoutingProblem(vrp);
 		calcBuilder.setVehicleFleetManager(fleetManager);
 		calcBuilder.setActivityInsertionCostsCalculator(actInsertionCostsCalculator);
-		if(considerFixedCosts) calcBuilder.considerFixedCosts(weightOfFixedCosts);
+		if(considerFixedCosts) {
+			calcBuilder.considerFixedCosts(weightOfFixedCosts);
+		}
 		JobInsertionCalculator jobInsertions = calcBuilder.build();
 		BestInsertion bestInsertion = new BestInsertion(jobInsertions);
 		for(InsertionListener l : iListeners) bestInsertion.addListener(l); 
 		return bestInsertion;
 	}
 
+	private void addCoreUpdater() {
+		if(!hasActivityTimeUpdater()){
+			stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
+		}
+//		if(!hasLoadUpdater()){
+//			stateManager.addActivityVisitor(new UpdateLoadAtActivityLevel(stateManager));
+//		}
+		
+	}
+
+	private boolean hasLoadUpdater() {
+		for(StateUpdater updater : stateManager.getStateUpdaters()){
+			if(updater instanceof UpdateLoadAtActivityLevel) return true;
+		}
+		return false;
+	}
+
+	private boolean hasActivityTimeUpdater() {
+		for(StateUpdater updater : stateManager.getStateUpdaters()){
+			if(updater instanceof UpdateActivityTimes) return true;
+		}
+		return false;
+	}
+
 }

jsprit-core/src/main/java/algorithms/CalculatesServiceInsertionConsideringFixCost.java

@@ -37,9 +37,9 @@ final class CalculatesServiceInsertionConsideringFixCost implements JobInsertion
 	
 	private double solution_completeness_ratio = 0.5;
 	
-	private StateManager states;
+	private StateGetter states;
 
-	public CalculatesServiceInsertionConsideringFixCost(final JobInsertionCalculator standardInsertionCalculator, StateManager activityStates2) {
+	public CalculatesServiceInsertionConsideringFixCost(final JobInsertionCalculator standardInsertionCalculator, StateGetter activityStates2) {
 		super();
 		this.standardServiceInsertion = standardInsertionCalculator;
 		this.states = activityStates2;

jsprit-core/src/main/java/algorithms/CalculationUtils.java

@@ -22,7 +22,7 @@ package algorithms;
 
 import basics.route.TourActivity;
 
-public class CalculationUtils {
+class CalculationUtils {
 	
 
 	/**

jsprit-core/src/main/java/algorithms/CalculatorBuilder.java

@@ -58,7 +58,7 @@ class CalculatorBuilder {
 
 	private VehicleRoutingProblem vrp;
 
-	private StateManager states;
+	private StateGetter states;
 
 	private boolean local = true;
 
@@ -103,7 +103,7 @@ class CalculatorBuilder {
 	 * 
 	 * @return
 	 */
-	public CalculatorBuilder setStates(StateManager states){
+	public CalculatorBuilder setStates(StateGetter states){
 		this.states = states;
 		return this;
 	}
@@ -217,7 +217,7 @@ class CalculatorBuilder {
 		}
 	}
 
-	private CalculatorPlusListeners createStandardLocal(VehicleRoutingProblem vrp, StateManager statesManager){
+	private CalculatorPlusListeners createStandardLocal(VehicleRoutingProblem vrp, StateGetter statesManager){
 		if(constraintManager == null) throw new IllegalStateException("constraint-manager is null");
  		
 		ActivityInsertionCostsCalculator actInsertionCalc;
@@ -235,7 +235,7 @@ class CalculatorBuilder {
 		return calcPlusListeners;
 	}
 
-	private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCalculator baseCalculator, StateManager activityStates2, double weightOfFixedCosts){
+	private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCalculator baseCalculator, StateGetter activityStates2, double weightOfFixedCosts){
 		final CalculatesServiceInsertionConsideringFixCost withFixCost = new CalculatesServiceInsertionConsideringFixCost(baseCalculator, activityStates2);
 		withFixCost.setWeightOfFixCost(weightOfFixedCosts);
 		CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(withFixCost);
@@ -243,7 +243,7 @@ class CalculatorBuilder {
 		return calcPlusListeners;
 	}
 
-	private CalculatorPlusListeners createStandardRoute(VehicleRoutingProblem vrp, StateManager activityStates2, int forwardLooking, int solutionMemory){
+	private CalculatorPlusListeners createStandardRoute(VehicleRoutingProblem vrp, StateGetter activityStates2, int forwardLooking, int solutionMemory){
 		int after = forwardLooking;
 		ActivityInsertionCostsCalculator routeLevelCostEstimator;
 		if(activityInsertionCostCalculator == null){
@@ -261,7 +261,7 @@ class CalculatorBuilder {
 		return calcPlusListener;
 	}
 
-	private JobInsertionCalculator createFinalInsertion(VehicleFleetManager fleetManager, JobInsertionCalculator baseCalc, StateManager activityStates2){
+	private JobInsertionCalculator createFinalInsertion(VehicleFleetManager fleetManager, JobInsertionCalculator baseCalc, StateGetter activityStates2){
 		return new CalculatesVehTypeDepServiceInsertion(fleetManager, baseCalc);
 	}
 

jsprit-core/src/main/java/algorithms/ConstraintManager.java

@@ -2,7 +2,7 @@ package algorithms;
 
 import basics.route.TourActivity;
 
-public class ConstraintManager implements HardActivityLevelConstraint, HardRouteLevelConstraint{
+class ConstraintManager implements HardActivityLevelConstraint, HardRouteLevelConstraint{
 
 	private HardActivityLevelConstraintManager actLevelConstraintManager = new HardActivityLevelConstraintManager();
 	

jsprit-core/src/main/java/algorithms/FindCheaperVehicleAlgo.java

@@ -41,13 +41,13 @@ final class FindCheaperVehicleAlgo {
 	
 	private double weightFixCosts = 1.0;
 	
-	private StateManager states;
+	private StateGetter states;
 	
 	public void setWeightFixCosts(double weightFixCosts) {
 		this.weightFixCosts = weightFixCosts;
 	}
 	
-	public void setStates(StateManager states) {
+	public void setStates(StateGetter states) {
 		this.states = states;
 	}
 

jsprit-core/src/main/java/algorithms/HardLoadConstraint.java

@@ -2,11 +2,11 @@ package algorithms;
 
 import basics.Service;
 
-public class HardLoadConstraint implements HardRouteLevelConstraint{
+class HardLoadConstraint implements HardRouteLevelConstraint{
 
-	private StateManager states;
+	private StateGetter states;
 	
-	public HardLoadConstraint(StateManager states) {
+	public HardLoadConstraint(StateGetter states) {
 		super();
 		this.states = states;
 	}

jsprit-core/src/main/java/algorithms/HardPickupAndDeliveryActivityLevelConstraint.java

@@ -6,11 +6,11 @@ import basics.route.ServiceActivity;
 import basics.route.Start;
 import basics.route.TourActivity;
 
-public class HardPickupAndDeliveryActivityLevelConstraint implements HardActivityLevelConstraint {
+class HardPickupAndDeliveryActivityLevelConstraint implements HardActivityLevelConstraint {
 	
-	private StateManager stateManager;
+	private StateGetter stateManager;
 	
-	public HardPickupAndDeliveryActivityLevelConstraint(StateManager stateManager) {
+	public HardPickupAndDeliveryActivityLevelConstraint(StateGetter stateManager) {
 		super();
 		this.stateManager = stateManager;
 	}

jsprit-core/src/main/java/algorithms/HardPickupAndDeliveryBackhaulActivityLevelConstraint.java

@@ -6,11 +6,11 @@ import basics.route.ServiceActivity;
 import basics.route.Start;
 import basics.route.TourActivity;
 
-public class HardPickupAndDeliveryBackhaulActivityLevelConstraint implements HardActivityLevelConstraint {
+class HardPickupAndDeliveryBackhaulActivityLevelConstraint implements HardActivityLevelConstraint {
 	
-	private StateManager stateManager;
+	private StateGetter stateManager;
 	
-	public HardPickupAndDeliveryBackhaulActivityLevelConstraint(StateManager stateManager) {
+	public HardPickupAndDeliveryBackhaulActivityLevelConstraint(StateGetter stateManager) {
 		super();
 		this.stateManager = stateManager;
 	}

jsprit-core/src/main/java/algorithms/HardPickupAndDeliveryLoadRouteLevelConstraint.java

@@ -10,11 +10,11 @@ import basics.Service;
  * @author stefan
  *
  */
-public class HardPickupAndDeliveryLoadConstraint implements HardRouteLevelConstraint {
+class HardPickupAndDeliveryLoadRouteLevelConstraint implements HardRouteLevelConstraint {
 
-	private StateManager stateManager;
+	private StateGetter stateManager;
 	
-	public HardPickupAndDeliveryLoadConstraint(StateManager stateManager) {
+	public HardPickupAndDeliveryLoadRouteLevelConstraint(StateGetter stateManager) {
 		super();
 		this.stateManager = stateManager;
 	}

jsprit-core/src/main/java/algorithms/HardTimeWindowActivityLevelConstraint.java

@@ -10,15 +10,15 @@ import basics.route.TourActivity;
 	 * @author stefan
 	 *
 	 */
-	public class HardTimeWindowActivityLevelConstraint implements HardActivityLevelConstraint {
+	class HardTimeWindowActivityLevelConstraint implements HardActivityLevelConstraint {
 
 		private static Logger log = Logger.getLogger(HardTimeWindowActivityLevelConstraint.class);
 		
-		private StateManager states;
+		private StateGetter states;
 		
 		private VehicleRoutingTransportCosts routingCosts;
 		
-		public HardTimeWindowActivityLevelConstraint(StateManager states, VehicleRoutingTransportCosts routingCosts) {
+		public HardTimeWindowActivityLevelConstraint(StateGetter states, VehicleRoutingTransportCosts routingCosts) {
 			super();
 			this.states = states;
 			this.routingCosts = routingCosts;

jsprit-core/src/main/java/algorithms/InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts.java

@@ -2,7 +2,7 @@ package algorithms;
 
 import java.util.Collection;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.Delivery;
 import basics.Job;
 import basics.Pickup;
@@ -20,9 +20,9 @@ import basics.route.VehicleRoute;
  * 
  * @param stateManager
  */
-public class InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts implements InsertionStartsListener {
+class InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts implements InsertionStartsListener {
 
-	private StateManagerImpl stateManager;
+	private StateManager stateManager;
 	
 	/**
 	 * Initializes the load of each route/vehicle at start- and end-location before insertion starts.
@@ -34,7 +34,7 @@ public class InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts implements I
 	 * 
 	 * @param stateManager
 	 */
-	public InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts(StateManagerImpl stateManager) {
+	public InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts(StateManager stateManager) {
 		super();
 		this.stateManager = stateManager;
 	}

jsprit-core/src/main/java/algorithms/InsertionFactory.java

@@ -32,7 +32,7 @@ class InsertionFactory {
 	private static Logger log = Logger.getLogger(InsertionFactory.class);
 	
 	public static InsertionStrategy createInsertion(VehicleRoutingProblem vrp, HierarchicalConfiguration config, 
-			VehicleFleetManager vehicleFleetManager, StateManagerImpl routeStates, List<PrioritizedVRAListener> algorithmListeners, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager){
+			VehicleFleetManager vehicleFleetManager, StateManager routeStates, List<PrioritizedVRAListener> algorithmListeners, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager){
 
 		if(config.containsKey("[@name]")){
 			String insertionName = config.getString("[@name]");

jsprit-core/src/main/java/algorithms/LocalActivityInsertionCostsCalculator.java

@@ -24,11 +24,22 @@ import basics.costs.VehicleRoutingActivityCosts;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.TourActivity;
 
+/**
+ * Calculates activity insertion costs locally, i.e. by comparing the additional costs of insertion the new activity k between
+ * activity i (prevAct) and j (nextAct).
+ * Additional costs are then basically calculated as delta c = c_ik + c_kj - c_ij.
+ * 
+ * <p>Note once time has an effect on costs this class requires activity endTimes.
+ * 
+ * @author stefan
+ *
+ */
 class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCalculator{
 
 	private VehicleRoutingTransportCosts routingCosts;
 	private VehicleRoutingActivityCosts activityCosts;
 	
+	
 	public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts) {
 		super();
 		this.routingCosts = routingCosts;

jsprit-core/src/main/java/algorithms/RouteLevelActivityInsertionCostsEstimator.java

@@ -36,11 +36,11 @@ class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCost
 	
 	private AuxilliaryCostCalculator auxilliaryPathCostCalculator;
 	
-	private StateManager stateManager;
+	private StateGetter stateManager;
 	
 	private int nuOfActivities2LookForward = 0;
 	
-	public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, StateManager stateManager) {
+	public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, StateGetter stateManager) {
 		super();
 		this.activityCosts = actCosts;
 		this.stateManager = stateManager;

jsprit-core/src/main/java/algorithms/ServiceInsertionOnRouteLevelCalculator.java

@@ -56,7 +56,7 @@ final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCalcul
 	
 	private TourActivityFactory tourActivityFactory = new DefaultTourActivityFactory();
 	
-	private StateManager stateManager;
+	private StateGetter stateManager;
 	
 	private HardRouteLevelConstraint hardRouteLevelConstraint;
 	
@@ -107,7 +107,7 @@ final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCalcul
 		}
 
 
-	public void setStates(StateManager stateManager){
+	public void setStates(StateGetter stateManager){
 		this.stateManager = stateManager;
 	}
 	

jsprit-core/src/main/java/algorithms/StateGetter.java

@@ -16,25 +16,23 @@
  ******************************************************************************/
 package algorithms;
 
+import basics.route.TourActivity;
+import basics.route.VehicleRoute;
 
-
-
-/**
- * collection of hard constrainters bot at activity and at route level.
- * 
- * <p>HardPickupAndDeliveryLoadConstraint requires LOAD_AT_DEPOT and LOAD (i.e. load at end) at route-level
- * 
- * <p>HardTimeWindowConstraint requires LATEST_OPERATION_START_TIME
- * 
- * <p>HardPickupAndDeliveryConstraint requires LOAD_AT_DEPOT and LOAD at route-level and FUTURE_PICKS and PAST_DELIVIERS on activity-level
- * 
- * <p>HardPickupAndDeliveryBackhaulConstraint requires LOAD_AT_DEPOT and LOAD at route-level and FUTURE_PICKS and PAST_DELIVIERS on activity-level
- * 
- * @author stefan
- *
- */
-class HardConstraints {
+public interface StateGetter {
 	
+	public interface StateId {
+		
+	}
 	
+	public interface State {
+		double toDouble();
+	}
+	
+
+	State getActivityState(TourActivity act, StateId stateId);
+
+	State getRouteState(VehicleRoute route, StateId stateId);
+
 
 }

jsprit-core/src/main/java/algorithms/StateIdFactory.java

@@ -23,7 +23,7 @@ package algorithms;
 import java.util.Arrays;
 import java.util.List;
 
-import algorithms.StateManager.StateId;
+import algorithms.StateGetter.StateId;
 
 public class StateIdFactory {
 	

jsprit-core/src/main/java/algorithms/StateManager.java

@@ -16,23 +16,256 @@
  ******************************************************************************/
 package algorithms;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import basics.Job;
+import basics.VehicleRoutingProblem;
+import basics.VehicleRoutingProblemSolution;
+import basics.algo.InsertionEndsListener;
+import basics.algo.InsertionListener;
+import basics.algo.InsertionListeners;
+import basics.algo.InsertionStartsListener;
+import basics.algo.IterationStartsListener;
+import basics.algo.JobInsertedListener;
+import basics.algo.RuinListener;
+import basics.algo.RuinListeners;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
-public interface StateManager {
+public class StateManager implements StateGetter, IterationStartsListener, RuinListener, InsertionStartsListener, JobInsertedListener, InsertionEndsListener {
+
 	
-	public interface StateId {
+	
+	private interface States {
+		
+		State getState(StateId key);
 		
 	}
 	
-	public interface State {
-		double toDouble();
+	public static class StateImpl implements State{
+		double state;
+
+		public StateImpl(double state) {
+			super();
+			this.state = state;
+		}
+
+		@Override
+		public double toDouble() {
+			return state;
+		}
+		
 	}
 	
+	private static class StatesImpl implements States{
 
-	State getActivityState(TourActivity act, StateId stateId);
+		private Map<StateId,State> states = new HashMap<StateId, State>();
+		
+		public void putState(StateId key, State state) {
+			states.put(key, state);
+		}
 
-	State getRouteState(VehicleRoute route, StateId stateId);
+		@Override
+		public State getState(StateId key) {
+			return states.get(key);
+		}
 
+	}
+	
+	private Map<VehicleRoute,States> vehicleRouteStates = new HashMap<VehicleRoute, States>();
+	
+	private Map<TourActivity,States> activityStates = new HashMap<TourActivity, States>();
+	
+	private RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
+	
+	private ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
+	
+	private Collection<RouteVisitor> routeVisitors = new ArrayList<RouteVisitor>();
+	
+	private RuinListeners ruinListeners = new RuinListeners();
+	
+	private InsertionListeners insertionListeners = new InsertionListeners();
+	
+	private Collection<StateUpdater> updaters = new ArrayList<StateUpdater>();
+	
+	public void clear(){
+		vehicleRouteStates.clear();
+		activityStates.clear();
+	}
 
+	@Override
+	public State getActivityState(TourActivity act, StateId stateId) {
+		if(!activityStates.containsKey(act)){
+			return getDefaultActState(stateId,act);
+		}
+		StatesImpl actStates = (StatesImpl) activityStates.get(act);
+		State state = actStates.getState(stateId);
+		if(state == null){
+			return getDefaultActState(stateId,act);
+		}
+		return state;
+	}
+	
+	public void putActivityState(TourActivity act, StateId stateId, State state){
+		if(!activityStates.containsKey(act)){
+			activityStates.put(act, new StatesImpl());
+		}
+		StatesImpl actStates = (StatesImpl) activityStates.get(act);
+		actStates.putState(stateId, state);
+	}
+	
+	
+	public void putRouteState(VehicleRoute route, StateId stateId, State state){
+		if(!vehicleRouteStates.containsKey(route)){
+			vehicleRouteStates.put(route, new StatesImpl());
+		}
+		StatesImpl routeStates = (StatesImpl) vehicleRouteStates.get(route);
+		routeStates.putState(stateId, state);
+	}
+
+	@Override
+	public State getRouteState(VehicleRoute route, StateId stateId) {
+		if(!vehicleRouteStates.containsKey(route)){
+			return getDefaultRouteState(stateId,route);
+		}
+		StatesImpl routeStates = (StatesImpl) vehicleRouteStates.get(route);
+		State state = routeStates.getState(stateId);
+		if(state == null){
+			return getDefaultRouteState(stateId, route);
+		}
+		return state;
+	}
+
+	/**
+	 * Adds state updater.
+	 * 
+	 * <p>Note that a state update occurs if route and/or activity states change, i.e. if jobs are removed
+	 * or inserted into a route. Thus here, it is assumed that a state updater is either of type InsertionListener, 
+	 * RuinListener, ActivityVisitor, ReverseActivityVisitor, RouteVisitor, ReverseRouteVisitor. 
+	 * 
+	 * <p>The following rule pertain for activity/route visitors:These visitors visits all activities/route in a route subsequently in two cases. First, if insertionStart (after ruinStrategies have removed activities from routes)
+	 * and, second, if a job has been inserted and thus if a route has changed.
+	 *  
+	 * @param updater
+	 */
+	public void addStateUpdater(StateUpdater updater){
+		if(updater instanceof ActivityVisitor) addActivityVisitor((ActivityVisitor) updater);
+		if(updater instanceof ReverseActivityVisitor) addActivityVisitor((ReverseActivityVisitor)updater);
+		if(updater instanceof RouteVisitor) addRouteVisitor((RouteVisitor) updater);
+		if(updater instanceof InsertionListener) addListener((InsertionListener) updater);
+		if(updater instanceof RuinListener) addListener((RuinListener) updater);
+		updaters.add(updater);
+	}
+	
+	Collection<StateUpdater> getStateUpdaters(){
+		return Collections.unmodifiableCollection(updaters);
+	}
+	
+	/**
+	 * Adds an activityVisitor.
+	 * <p>This visitor visits all activities in a route subsequently in two cases. First, if insertionStart (after ruinStrategies have removed activities from routes)
+	 * and, second, if a job has been inserted and thus if a route has changed. 
+	 * 
+	 * @param activityVistor
+	 */
+	 void addActivityVisitor(ActivityVisitor activityVistor){
+		routeActivityVisitor.addActivityVisitor(activityVistor);
+	}
+
+	/**
+	 * Adds an reverseActivityVisitor.
+	 * <p>This reverseVisitor visits all activities in a route subsequently (starting from the end of the route) in two cases. First, if insertionStart (after ruinStrategies have removed activities from routes)
+	 * and, second, if a job has been inserted and thus if a route has changed. 
+	 * 
+	 * @param reverseActivityVistor
+	 */
+	 void addActivityVisitor(ReverseActivityVisitor activityVistor){
+		revRouteActivityVisitor.addActivityVisitor(activityVistor);
+	}
+
+	 void addRouteVisitor(RouteVisitor routeVisitor){
+		routeVisitors.add(routeVisitor);
+	}
+
+	void addListener(RuinListener ruinListener){
+		ruinListeners.addListener(ruinListener);
+	}
+
+	void removeListener(RuinListener ruinListener){
+		ruinListeners.removeListener(ruinListener);
+	}
+
+	void addListener(InsertionListener insertionListener){
+		insertionListeners.addListener(insertionListener);
+	}
+
+	void removeListener(InsertionListener insertionListener){
+		insertionListeners.removeListener(insertionListener);
+	}
+
+	private State getDefaultActState(StateId stateId, TourActivity act){
+		if(stateId.equals(StateIdFactory.LOAD)) return new StateImpl(0);
+		if(stateId.equals(StateIdFactory.COSTS)) return new StateImpl(0);
+		if(stateId.equals(StateIdFactory.DURATION)) return new StateImpl(0);
+		if(stateId.equals(StateIdFactory.EARLIEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalEarliestOperationStartTime());
+		if(stateId.equals(StateIdFactory.LATEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalLatestOperationStartTime());
+		if(stateId.equals(StateIdFactory.FUTURE_PICKS)) return new StateImpl(0);
+		if(stateId.equals(StateIdFactory.PAST_DELIVERIES)) return new StateImpl(0);
+		return null;
+	}
+	
+	private State getDefaultRouteState(StateId stateId, VehicleRoute route){
+		if(stateId.equals(StateIdFactory.LOAD)) return new StateImpl(0);
+		if(stateId.equals(StateIdFactory.LOAD_AT_BEGINNING)) return new StateImpl(0);
+		if(stateId.equals(StateIdFactory.COSTS)) return new StateImpl(0);
+		if(stateId.equals(StateIdFactory.DURATION)) return new StateImpl(0);
+		return null;
+	}
+
+	@Override
+	public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
+		insertionListeners.jobInserted(job2insert, inRoute, additionalCosts, additionalTime);
+		for(RouteVisitor v : routeVisitors){ v.visit(inRoute); }
+		routeActivityVisitor.visit(inRoute);
+		revRouteActivityVisitor.visit(inRoute);
+	}
+
+	@Override
+	public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes,Collection<Job> unassignedJobs) {
+		insertionListeners.insertionStarts(vehicleRoutes, unassignedJobs);
+		for(VehicleRoute route : vehicleRoutes){ 
+			for(RouteVisitor v : routeVisitors){ v.visit(route); }
+			routeActivityVisitor.visit(route);
+			revRouteActivityVisitor.visit(route);
+		}
+	}
+	
+	@Override
+	public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
+		clear();
+	}
+
+	@Override
+	public void ruinStarts(Collection<VehicleRoute> routes) {
+		ruinListeners.ruinStarts(routes);
+	}
+
+	@Override
+	public void ruinEnds(Collection<VehicleRoute> routes, Collection<Job> unassignedJobs) {
+		ruinListeners.ruinEnds(routes, unassignedJobs);		
+	}
+
+	@Override
+	public void removed(Job job, VehicleRoute fromRoute) {
+		ruinListeners.removed(job, fromRoute);
+	}
+
+	@Override
+	public void informInsertionEnds(Collection<VehicleRoute> vehicleRoutes) {
+		insertionListeners.insertionEnds(vehicleRoutes);
+	}
 }

jsprit-core/src/main/java/algorithms/StateManagerImpl.java

@@ -1,242 +0,0 @@
-/*******************************************************************************
- * Copyright (C) 2013  Stefan Schroeder
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either 
- * version 3.0 of the License, or (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public 
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
- ******************************************************************************/
-package algorithms;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-import basics.Job;
-import basics.VehicleRoutingProblem;
-import basics.VehicleRoutingProblemSolution;
-import basics.algo.InsertionEndsListener;
-import basics.algo.InsertionListener;
-import basics.algo.InsertionListeners;
-import basics.algo.InsertionStartsListener;
-import basics.algo.IterationStartsListener;
-import basics.algo.JobInsertedListener;
-import basics.algo.RuinListener;
-import basics.algo.RuinListeners;
-import basics.route.TourActivity;
-import basics.route.VehicleRoute;
-
-public class StateManagerImpl implements StateManager, IterationStartsListener, RuinListener, InsertionStartsListener, JobInsertedListener, InsertionEndsListener {
-
-	private interface States {
-		
-		State getState(StateId key);
-		
-	}
-	
-	public static class StateImpl implements State{
-		double state;
-
-		public StateImpl(double state) {
-			super();
-			this.state = state;
-		}
-
-		@Override
-		public double toDouble() {
-			return state;
-		}
-		
-	}
-	
-	private static class StatesImpl implements States{
-
-		private Map<StateId,State> states = new HashMap<StateId, State>();
-		
-		public void putState(StateId key, State state) {
-			states.put(key, state);
-		}
-
-		@Override
-		public State getState(StateId key) {
-			return states.get(key);
-		}
-
-	}
-	
-	private Map<VehicleRoute,States> vehicleRouteStates = new HashMap<VehicleRoute, States>();
-	
-	private Map<TourActivity,States> activityStates = new HashMap<TourActivity, States>();
-	
-	private RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
-	
-	private ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
-	
-	private Collection<RouteVisitor> routeVisitors = new ArrayList<RouteVisitor>();
-	
-	private RuinListeners ruinListeners = new RuinListeners();
-	
-	private InsertionListeners insertionListeners = new InsertionListeners();
-	
-	public void addListener(RuinListener ruinListener){
-		ruinListeners.addListener(ruinListener);
-	}
-	
-	public void removeListener(RuinListener ruinListener){
-		ruinListeners.removeListener(ruinListener);
-	}
-	
-	public void addListener(InsertionListener insertionListener){
-		insertionListeners.addListener(insertionListener);
-	}
-	
-	public void removeListener(InsertionListener insertionListener){
-		insertionListeners.removeListener(insertionListener);
-	}
-	
-	
-	public void clear(){
-		vehicleRouteStates.clear();
-		activityStates.clear();
-	}
-
-	@Override
-	public State getActivityState(TourActivity act, StateId stateId) {
-		if(!activityStates.containsKey(act)){
-			return getDefaultActState(stateId,act);
-		}
-		StatesImpl actStates = (StatesImpl) activityStates.get(act);
-		State state = actStates.getState(stateId);
-		if(state == null){
-			return getDefaultActState(stateId,act);
-		}
-		return state;
-	}
-	
-	public void putActivityState(TourActivity act, StateId stateId, State state){
-		if(!activityStates.containsKey(act)){
-			activityStates.put(act, new StatesImpl());
-		}
-		StatesImpl actStates = (StatesImpl) activityStates.get(act);
-		actStates.putState(stateId, state);
-	}
-	
-	
-	private State getDefaultActState(StateId stateId, TourActivity act){
-		if(stateId.equals(StateIdFactory.LOAD)) return new StateImpl(0);
-		if(stateId.equals(StateIdFactory.COSTS)) return new StateImpl(0);
-		if(stateId.equals(StateIdFactory.DURATION)) return new StateImpl(0);
-		if(stateId.equals(StateIdFactory.EARLIEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalEarliestOperationStartTime());
-		if(stateId.equals(StateIdFactory.LATEST_OPERATION_START_TIME)) return new StateImpl(act.getTheoreticalLatestOperationStartTime());
-		if(stateId.equals(StateIdFactory.FUTURE_PICKS)) return new StateImpl(0);
-		if(stateId.equals(StateIdFactory.PAST_DELIVERIES)) return new StateImpl(0);
-		return null;
-	}
-	
-	private State getDefaultRouteState(StateId stateId, VehicleRoute route){
-		if(stateId.equals(StateIdFactory.LOAD)) return new StateImpl(0);
-		if(stateId.equals(StateIdFactory.LOAD_AT_BEGINNING)) return new StateImpl(0);
-		if(stateId.equals(StateIdFactory.COSTS)) return new StateImpl(0);
-		if(stateId.equals(StateIdFactory.DURATION)) return new StateImpl(0);
-		return null;
-	}
-
-	@Override
-	public State getRouteState(VehicleRoute route, StateId stateId) {
-		if(!vehicleRouteStates.containsKey(route)){
-			return getDefaultRouteState(stateId,route);
-		}
-		StatesImpl routeStates = (StatesImpl) vehicleRouteStates.get(route);
-		State state = routeStates.getState(stateId);
-		if(state == null){
-			return getDefaultRouteState(stateId, route);
-		}
-		return state;
-	}
-	
-	public void putRouteState(VehicleRoute route, StateId stateId, State state){
-		if(!vehicleRouteStates.containsKey(route)){
-			vehicleRouteStates.put(route, new StatesImpl());
-		}
-		StatesImpl routeStates = (StatesImpl) vehicleRouteStates.get(route);
-		routeStates.putState(stateId, state);
-	}
-
-	@Override
-	public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
-		insertionListeners.jobInserted(job2insert, inRoute, additionalCosts, additionalTime);
-		for(RouteVisitor v : routeVisitors){ v.visit(inRoute); }
-		routeActivityVisitor.visit(inRoute);
-		revRouteActivityVisitor.visit(inRoute);
-	}
-
-	@Override
-	public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes,Collection<Job> unassignedJobs) {
-		insertionListeners.insertionStarts(vehicleRoutes, unassignedJobs);
-		for(VehicleRoute route : vehicleRoutes){ 
-			for(RouteVisitor v : routeVisitors){ v.visit(route); }
-			routeActivityVisitor.visit(route);
-			revRouteActivityVisitor.visit(route);
-		}
-	}
-	
-	/**
-	 * Adds an activityVisitor.
-	 * <p>This visitor visits all activities in a route subsequently in two cases. First, if insertionStart (after ruinStrategies have removed activities from routes)
-	 * and, second, if a job has been inserted and thus if a route has changed. 
-	 * 
-	 * @param activityVistor
-	 */
-	public void addActivityVisitor(ActivityVisitor activityVistor){
-		routeActivityVisitor.addActivityVisitor(activityVistor);
-	}
-	
-	/**
-	 * Adds an reverseActivityVisitor.
-	 * <p>This reverseVisitor visits all activities in a route subsequently (starting from the end of the route) in two cases. First, if insertionStart (after ruinStrategies have removed activities from routes)
-	 * and, second, if a job has been inserted and thus if a route has changed. 
-	 * 
-	 * @param reverseActivityVistor
-	 */
-	public void addActivityVisitor(ReverseActivityVisitor activityVistor){
-		revRouteActivityVisitor.addActivityVisitor(activityVistor);
-	}
-
-	public void addRouteVisitor(RouteVisitor routeVisitor){
-		routeVisitors.add(routeVisitor);
-	}
-
-	@Override
-	public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
-		clear();
-	}
-
-	@Override
-	public void ruinStarts(Collection<VehicleRoute> routes) {
-		ruinListeners.ruinStarts(routes);
-	}
-
-	@Override
-	public void ruinEnds(Collection<VehicleRoute> routes, Collection<Job> unassignedJobs) {
-		ruinListeners.ruinEnds(routes, unassignedJobs);		
-	}
-
-	@Override
-	public void removed(Job job, VehicleRoute fromRoute) {
-		ruinListeners.removed(job, fromRoute);
-	}
-
-	@Override
-	public void informInsertionEnds(Collection<VehicleRoute> vehicleRoutes) {
-		insertionListeners.insertionEnds(vehicleRoutes);
-	}
-}

jsprit-core/src/main/java/algorithms/StateUpdater.java

@@ -0,0 +1,5 @@
+package algorithms;
+
+public interface StateUpdater {
+
+}

jsprit-core/src/main/java/algorithms/StateUpdates.java

@@ -618,7 +618,7 @@ class StateUpdates {
 		
 		private ReverseRouteActivityVisitor revRouteActivityVisitor;
 		
-		public UpdateStates(StateManagerImpl states, VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts activityCosts) {
+		public UpdateStates(StateManager states, VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts activityCosts) {
 			routeActivityVisitor = new RouteActivityVisitor();
 			routeActivityVisitor.addActivityVisitor(new UpdateActivityTimes(routingCosts));
 			routeActivityVisitor.addActivityVisitor(new UpdateCostsAtAllLevels(activityCosts, routingCosts, states));

jsprit-core/src/main/java/algorithms/StateUtils.java

@@ -0,0 +1,22 @@
+package algorithms;
+
+import basics.VehicleRoutingProblem;
+
+public class StateUtils {
+	
+	public static void addCoreStateUpdaters(VehicleRoutingProblem vrp, StateManager stateManager){
+		stateManager.addListener(new InitializeLoadsAtStartAndEndOfRouteWhenInsertionStarts(stateManager));
+		stateManager.addListener(new UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted(stateManager));
+	
+		stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
+		stateManager.addActivityVisitor(new UpdateLoadAtActivityLevel(stateManager));
+		
+		stateManager.addActivityVisitor(new UpdateCostsAtAllLevels(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
+		
+		stateManager.addActivityVisitor(new UpdateOccuredDeliveriesAtActivityLevel(stateManager));
+		stateManager.addActivityVisitor(new UpdateLatestOperationStartTimeAtActLocations(stateManager, vrp.getTransportCosts()));
+		stateManager.addActivityVisitor(new UpdateFuturePickupsAtActivityLevel(stateManager));
+		
+	}
+
+}

jsprit-core/src/main/java/algorithms/UpdateActivityTimes.java

@@ -14,7 +14,7 @@ import basics.route.VehicleRoute;
  * @author stefan
  *
  */
-public class UpdateActivityTimes implements ActivityVisitor{
+class UpdateActivityTimes implements ActivityVisitor, StateUpdater{
 
 	private Logger log = Logger.getLogger(UpdateActivityTimes.class);
 	

jsprit-core/src/main/java/algorithms/UpdateCostsAtAllLevels.java

@@ -2,7 +2,7 @@ package algorithms;
 
 import org.apache.log4j.Logger;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.costs.ForwardTransportCost;
 import basics.costs.VehicleRoutingActivityCosts;
 import basics.costs.VehicleRoutingTransportCosts;
@@ -21,7 +21,7 @@ import basics.route.VehicleRoute;
  * @param transportCost
  * @param states
  */
-public class UpdateCostsAtAllLevels implements ActivityVisitor{
+class UpdateCostsAtAllLevels implements ActivityVisitor,StateUpdater{
 
 	private static Logger log = Logger.getLogger(UpdateCostsAtAllLevels.class);
 	
@@ -29,7 +29,7 @@ public class UpdateCostsAtAllLevels implements ActivityVisitor{
 
 	private ForwardTransportCost transportCost;
 	
-	private StateManagerImpl states;
+	private StateManager states;
 	
 	private double totalOperationCost = 0.0;
 	
@@ -52,7 +52,7 @@ public class UpdateCostsAtAllLevels implements ActivityVisitor{
 	 * @param transportCost
 	 * @param states
 	 */
-	public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, VehicleRoutingTransportCosts transportCost, StateManagerImpl states) {
+	public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, VehicleRoutingTransportCosts transportCost, StateManager states) {
 		super();
 		this.activityCost = activityCost;
 		this.transportCost = transportCost;

jsprit-core/src/main/java/algorithms/UpdateCostsAtRouteLevel.java

@@ -2,7 +2,7 @@ package algorithms;
 
 import java.util.Collection;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.Job;
 import basics.algo.InsertionEndsListener;
 import basics.algo.InsertionStartsListener;
@@ -11,15 +11,15 @@ import basics.costs.VehicleRoutingActivityCosts;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.VehicleRoute;
 
-public class UpdateCostsAtRouteLevel implements JobInsertedListener, InsertionStartsListener, InsertionEndsListener{
+class UpdateCostsAtRouteLevel implements StateUpdater,JobInsertedListener, InsertionStartsListener, InsertionEndsListener{
 		
-		private StateManagerImpl states;
+		private StateManager states;
 		
 		private VehicleRoutingTransportCosts tpCosts;
 		
 		private VehicleRoutingActivityCosts actCosts;
 		
-		public UpdateCostsAtRouteLevel(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts, VehicleRoutingActivityCosts actCosts) {
+		public UpdateCostsAtRouteLevel(StateManager states, VehicleRoutingTransportCosts tpCosts, VehicleRoutingActivityCosts actCosts) {
 			super();
 			this.states = states;
 			this.tpCosts = tpCosts;

jsprit-core/src/main/java/algorithms/UpdateEarliestStartTimeWindowAtActLocations.java

@@ -1,17 +1,17 @@
 package algorithms;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
-public class UpdateEarliestStartTimeWindowAtActLocations implements ActivityVisitor{
+class UpdateEarliestStartTimeWindowAtActLocations implements ActivityVisitor,StateUpdater{
 
-	private StateManagerImpl states;
+	private StateManager states;
 	
 	private ActivityTimeTracker timeTracker;
 	
-	public UpdateEarliestStartTimeWindowAtActLocations(StateManagerImpl states, VehicleRoutingTransportCosts transportCosts) {
+	public UpdateEarliestStartTimeWindowAtActLocations(StateManager states, VehicleRoutingTransportCosts transportCosts) {
 		super();
 		this.states = states;
 		timeTracker = new ActivityTimeTracker(transportCosts);

jsprit-core/src/main/java/algorithms/UpdateFuturePickupsAtActivityLevel.java

@@ -1,17 +1,17 @@
 package algorithms;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.route.PickupActivity;
 import basics.route.ServiceActivity;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
-public class UpdateFuturePickupsAtActivityLevel implements ReverseActivityVisitor {
-	private StateManagerImpl stateManager;
+class UpdateFuturePickupsAtActivityLevel implements ReverseActivityVisitor, StateUpdater {
+	private StateManager stateManager;
 	private int futurePicks = 0;
 	private VehicleRoute route;
 	
-	public UpdateFuturePickupsAtActivityLevel(StateManagerImpl stateManager) {
+	public UpdateFuturePickupsAtActivityLevel(StateManager stateManager) {
 		super();
 		this.stateManager = stateManager;
 	}

jsprit-core/src/main/java/algorithms/UpdateLatestOperationStartTimeAtActLocations.java

@@ -2,16 +2,16 @@ package algorithms;
 
 import org.apache.log4j.Logger;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
-public class UpdateLatestOperationStartTimeAtActLocations implements ReverseActivityVisitor{
+class UpdateLatestOperationStartTimeAtActLocations implements ReverseActivityVisitor, StateUpdater{
 
 	private static Logger log = Logger.getLogger(UpdateLatestOperationStartTimeAtActLocations.class);
 	
-	private StateManagerImpl states;
+	private StateManager states;
 	
 	private VehicleRoute route;
 	
@@ -21,7 +21,7 @@ public class UpdateLatestOperationStartTimeAtActLocations implements ReverseActi
 	
 	private TourActivity prevAct;
 	
-	public UpdateLatestOperationStartTimeAtActLocations(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts) {
+	public UpdateLatestOperationStartTimeAtActLocations(StateManager states, VehicleRoutingTransportCosts tpCosts) {
 		super();
 		this.states = states;
 		this.transportCosts = tpCosts;

jsprit-core/src/main/java/algorithms/UpdateLoadAtActivityLevel.java

@@ -1,6 +1,6 @@
 package algorithms;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
@@ -15,8 +15,8 @@ import basics.route.VehicleRoute;
  * @author stefan
  *
  */
-public class UpdateLoadAtActivityLevel implements ActivityVisitor {
-	private StateManagerImpl stateManager;
+class UpdateLoadAtActivityLevel implements ActivityVisitor, StateUpdater {
+	private StateManager stateManager;
 	private int currentLoad = 0;
 	private VehicleRoute route;
 	
@@ -39,7 +39,7 @@ public class UpdateLoadAtActivityLevel implements ActivityVisitor {
 	 * @author stefan
 	 *
 	 */
-	public UpdateLoadAtActivityLevel(StateManagerImpl stateManager) {
+	public UpdateLoadAtActivityLevel(StateManager stateManager) {
 		super();
 		this.stateManager = stateManager;
 	}

jsprit-core/src/main/java/algorithms/UpdateLoadAtAllLevels.java

@@ -1,18 +1,18 @@
 package algorithms;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
-public class UpdateLoadAtAllLevels implements ActivityVisitor{
+class UpdateLoadAtAllLevels implements ActivityVisitor,StateUpdater{
 
 	private double load = 0.0;
 	
-	private StateManagerImpl states;
+	private StateManager states;
 	
 	private VehicleRoute vehicleRoute;
 	
-	public UpdateLoadAtAllLevels(StateManagerImpl states) {
+	public UpdateLoadAtAllLevels(StateManager states) {
 		super();
 		this.states = states;
 	}

jsprit-core/src/main/java/algorithms/UpdateLoadAtRouteLevel.java

@@ -2,7 +2,7 @@ package algorithms;
 
 import java.util.Collection;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.Job;
 import basics.Service;
 import basics.algo.InsertionStartsListener;
@@ -15,9 +15,9 @@ import basics.route.VehicleRoute;
  * @author stefan
  *
  */
-public class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener{
+class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener, StateUpdater{
 
-	private StateManagerImpl states;
+	private StateManager states;
 	
 	/**
 	 * Updates load at route level, i.e. modifies StateTypes.LOAD for each route.
@@ -25,7 +25,7 @@ public class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionSta
 	 * @author stefan
 	 *
 	 */
-	public UpdateLoadAtRouteLevel(StateManagerImpl states) {
+	public UpdateLoadAtRouteLevel(StateManager states) {
 		super();
 		this.states = states;
 	}

jsprit-core/src/main/java/algorithms/UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted.java

@@ -1,6 +1,6 @@
 package algorithms;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.Delivery;
 import basics.Job;
 import basics.Pickup;
@@ -17,9 +17,9 @@ import basics.route.VehicleRoute;
  * 
  * @param stateManager
  */
-public class UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted implements JobInsertedListener {
+class UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted implements JobInsertedListener, StateUpdater {
 
-		private StateManagerImpl stateManager;
+		private StateManager stateManager;
 		
 		/**
 		 * Updates loads at start and end of a route if a job has been inserted in that route.
@@ -30,7 +30,7 @@ public class UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted implements Jo
 		 * 
 		 * @param stateManager
 		 */
-		public UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted(StateManagerImpl stateManager) {
+		public UpdateLoadsAtStartAndEndOfRouteWhenJobHasBeenInserted(StateManager stateManager) {
 			super();
 			this.stateManager = stateManager;
 		}

jsprit-core/src/main/java/algorithms/UpdateOccuredDeliveriesAtActivityLevel.java

@@ -1,16 +1,16 @@
 package algorithms;
 
-import algorithms.StateManagerImpl.StateImpl;
+import algorithms.StateManager.StateImpl;
 import basics.route.DeliveryActivity;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
-public class UpdateOccuredDeliveriesAtActivityLevel implements ActivityVisitor {
-	private StateManagerImpl stateManager;
+class UpdateOccuredDeliveriesAtActivityLevel implements ActivityVisitor, StateUpdater {
+	private StateManager stateManager;
 	private int deliveries = 0; 
 	private VehicleRoute route;
 	
-	public UpdateOccuredDeliveriesAtActivityLevel(StateManagerImpl stateManager) {
+	public UpdateOccuredDeliveriesAtActivityLevel(StateManager stateManager) {
 		super();
 		this.stateManager = stateManager;
 	}

jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithms.java

@@ -438,7 +438,7 @@ public class VehicleRoutingAlgorithms {
 		final VehicleFleetManager vehicleFleetManager = createFleetManager(vrp);
 		
 		//create state-manager
-		final StateManagerImpl stateManager = new StateManagerImpl();
+		final StateManager stateManager = new StateManager();
 		
 		/*
 		 * define constraints
@@ -454,7 +454,7 @@ public class VehicleRoutingAlgorithms {
 			constraintManager.addConstraint(new HardPickupAndDeliveryActivityLevelConstraint(stateManager));
 		}
 		
-		constraintManager.addConstraint(new HardPickupAndDeliveryLoadConstraint(stateManager));
+		constraintManager.addConstraint(new HardPickupAndDeliveryLoadRouteLevelConstraint(stateManager));
 		
 		//construct initial solution creator 
 		AlgorithmStartsListener createInitialSolution = createInitialSolution(config,vrp,vehicleFleetManager,stateManager,algorithmListeners,definedClasses,executorService,nuOfThreads,constraintManager);
@@ -542,7 +542,7 @@ public class VehicleRoutingAlgorithms {
 		return metaAlgorithm;	
 	}
 
-	private static SolutionCostCalculator getCostCalculator(final StateManagerImpl stateManager) {
+	private static SolutionCostCalculator getCostCalculator(final StateManager stateManager) {
 		SolutionCostCalculator calc = new SolutionCostCalculator() {
 			
 			@Override
@@ -644,7 +644,7 @@ public class VehicleRoutingAlgorithms {
 		metaAlgorithm.getAlgorithmListeners().addAll(algorithmListeners);
 	}
 	
-	private static AlgorithmStartsListener createInitialSolution(XMLConfiguration config, final VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, final StateManagerImpl routeStates, Set<PrioritizedVRAListener> algorithmListeners, TypedMap definedClasses, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager) {
+	private static AlgorithmStartsListener createInitialSolution(XMLConfiguration config, final VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, final StateManager routeStates, Set<PrioritizedVRAListener> algorithmListeners, TypedMap definedClasses, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager) {
 		List<HierarchicalConfiguration> modConfigs = config.configurationsAt("construction.insertion");
 		if(modConfigs == null) return null;
 		if(modConfigs.isEmpty()) return null;
@@ -741,7 +741,7 @@ public class VehicleRoutingAlgorithms {
 	}
 	
 	private static SearchStrategyModule buildModule(HierarchicalConfiguration moduleConfig, final VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, 
-			final StateManagerImpl routeStates, Set<PrioritizedVRAListener> algorithmListeners, TypedMap definedClasses, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager) {
+			final StateManager routeStates, Set<PrioritizedVRAListener> algorithmListeners, TypedMap definedClasses, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager) {
 		String moduleName = moduleConfig.getString("[@name]");
 		if(moduleName == null) throw new IllegalStateException("module(-name) is missing.");
 		String moduleId = moduleConfig.getString("[@id]");
@@ -843,7 +843,7 @@ public class VehicleRoutingAlgorithms {
 				"\n\tgendreauPostOpt");
 	}
 
-	private static RuinStrategy getRadialRuin(final VehicleRoutingProblem vrp, final StateManagerImpl routeStates, TypedMap definedClasses, ModKey modKey, double shareToRuin, JobDistance jobDistance) {
+	private static RuinStrategy getRadialRuin(final VehicleRoutingProblem vrp, final StateManager routeStates, TypedMap definedClasses, ModKey modKey, double shareToRuin, JobDistance jobDistance) {
 		RuinStrategyKey stratKey = new RuinStrategyKey(modKey);
 		RuinStrategy ruin = definedClasses.get(stratKey);
 		if(ruin == null){
@@ -853,7 +853,7 @@ public class VehicleRoutingAlgorithms {
 		return ruin;
 	}
 
-	private static RuinStrategy getRandomRuin(final VehicleRoutingProblem vrp, final StateManagerImpl routeStates, TypedMap definedClasses, ModKey modKey, double shareToRuin) {
+	private static RuinStrategy getRandomRuin(final VehicleRoutingProblem vrp, final StateManager routeStates, TypedMap definedClasses, ModKey modKey, double shareToRuin) {
 		RuinStrategyKey stratKey = new RuinStrategyKey(modKey);
 		RuinStrategy ruin = definedClasses.get(stratKey);
 		if(ruin == null){
@@ -863,7 +863,7 @@ public class VehicleRoutingAlgorithms {
 		return ruin;
 	}
 	
-	private static InsertionStrategy createInsertionStrategy(HierarchicalConfiguration moduleConfig, VehicleRoutingProblem vrp,VehicleFleetManager vehicleFleetManager, StateManagerImpl routeStates, List<PrioritizedVRAListener> algorithmListeners, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager) {
+	private static InsertionStrategy createInsertionStrategy(HierarchicalConfiguration moduleConfig, VehicleRoutingProblem vrp,VehicleFleetManager vehicleFleetManager, StateManager routeStates, List<PrioritizedVRAListener> algorithmListeners, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager) {
 		InsertionStrategy insertion = InsertionFactory.createInsertion(vrp, moduleConfig, vehicleFleetManager, routeStates, algorithmListeners, executorService, nuOfThreads, constraintManager);
 		return insertion;
 	}