improve updates/updaters at act- and routeLevel

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

@@ -49,4 +49,8 @@ class BackwardInTimeListeners {
 		for(BackwardInTimeListener l : listeners){ l.end(start, latestDepartureTime); }
 	}
 
+	public boolean isEmpty() {
+		return listeners.isEmpty();
+	}
+
 }

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

@@ -38,4 +38,8 @@ class ForwardInTimeListeners {
 		for(ForwardInTimeListener l : listeners){ l.end(end, arrivalTime); }
 	}
 
+	public boolean isEmpty() {
+		return listeners.isEmpty();
+	}
+
 }

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

@@ -28,7 +28,7 @@ class HardConstraints {
 
 	}
 	
-	static class HardRouteLevelConstraintAccumulator implements HardRouteLevelConstraint {
+	static class HardRouteLevelConstraintManager implements HardRouteLevelConstraint {
 
 		private Collection<HardRouteLevelConstraint> hardConstraints = new ArrayList<HardRouteLevelConstraint>();
 		
@@ -50,7 +50,7 @@ class HardConstraints {
 	
 	
 	
-	static class HardActivityLevelConstraintAccumulator implements HardActivityLevelConstraint {
+	static class HardActivityLevelConstraintManager implements HardActivityLevelConstraint {
 
 		private Collection<HardActivityLevelConstraint> hardConstraints = new ArrayList<HardActivityLevelConstraint>();
 		

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

@@ -25,11 +25,10 @@ import java.util.List;
 import java.util.concurrent.ExecutorService;
 
 import org.apache.commons.configuration.HierarchicalConfiguration;
-import org.apache.commons.configuration.XMLConfiguration;
 import org.apache.log4j.Logger;
 
+import algorithms.StateUpdates.UpdateStates;
 import basics.VehicleRoutingProblem;
-import basics.VehicleRoutingProblem.FleetComposition;
 import basics.algo.InsertionListener;
 import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
 

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

@@ -46,6 +46,7 @@ class IterateRouteBackwardInTime implements VehicleRouteUpdater{
 	 * 
 	 */
 	public void iterate(VehicleRoute vehicleRoute) {
+		if(listeners.isEmpty()) return;
 		listeners.start(vehicleRoute, vehicleRoute.getEnd(), vehicleRoute.getEnd().getTheoreticalLatestOperationStartTime());
 		
 		Iterator<TourActivity> reverseActIter = vehicleRoute.getTourActivities().reverseActivityIterator();

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

@@ -48,6 +48,7 @@ class IterateRouteForwardInTime implements VehicleRouteUpdater{
 	 * 
 	 */
 	public void iterate(VehicleRoute vehicleRoute) {
+		if(listeners.isEmpty()) return;
 		listeners.start(vehicleRoute, vehicleRoute.getStart(), vehicleRoute.getStart().getEndTime());
 		
 		Vehicle vehicle = vehicleRoute.getVehicle();

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

@@ -0,0 +1,576 @@
+package algorithms;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+
+import algorithms.BackwardInTimeListeners.BackwardInTimeListener;
+import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
+import algorithms.RuinStrategy.RuinListener;
+import algorithms.StateManager.StateImpl;
+import basics.Job;
+import basics.Service;
+import basics.VehicleRoutingProblem;
+import basics.VehicleRoutingProblemSolution;
+import basics.algo.InsertionEndsListener;
+import basics.algo.InsertionStartsListener;
+import basics.algo.IterationEndsListener;
+import basics.algo.IterationStartsListener;
+import basics.algo.JobInsertedListener;
+import basics.algo.VehicleRoutingAlgorithmListener;
+import basics.costs.ForwardTransportCost;
+import basics.costs.VehicleRoutingActivityCosts;
+import basics.costs.VehicleRoutingTransportCosts;
+import basics.route.DeliveryActivity;
+import basics.route.End;
+import basics.route.PickupActivity;
+import basics.route.Start;
+import basics.route.TourActivity;
+import basics.route.VehicleRoute;
+
+class StateUpdates {
+	
+	static class VRAListenersManager implements IterationStartsListener, IterationEndsListener, InsertionStartsListener, InsertionEndsListener, JobInsertedListener, RuinListener{
+
+		private Map<Class<? extends VehicleRoutingAlgorithmListener>,Collection<VehicleRoutingAlgorithmListener>> listeners = new HashMap<Class<? extends VehicleRoutingAlgorithmListener>,Collection<VehicleRoutingAlgorithmListener>>();
+		
+		public void addListener(VehicleRoutingAlgorithmListener vraListener){
+			if(!listeners.containsKey(vraListener.getClass())){
+				listeners.put(vraListener.getClass(), new ArrayList<VehicleRoutingAlgorithmListener>());
+			}
+			listeners.get(vraListener.getClass()).add(vraListener);
+		}
+		
+		@Override
+		public void ruinStarts(Collection<VehicleRoute> routes) {
+			if(listeners.containsKey(RuinListener.class)){
+				for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){
+					((RuinListener)l).ruinStarts(routes);
+				}
+			}
+		}
+
+		@Override
+		public void ruinEnds(Collection<VehicleRoute> routes,Collection<Job> unassignedJobs) {
+			if(listeners.containsKey(RuinListener.class)){
+				for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){
+					((RuinListener)l).ruinEnds(routes,unassignedJobs);
+				}
+			}
+		}
+
+		@Override
+		public void removed(Job job, VehicleRoute fromRoute) {
+			if(listeners.containsKey(RuinListener.class)){
+				for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){
+					((RuinListener)l).removed(job, fromRoute);
+				}
+			}
+		}
+
+		@Override
+		public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
+			if(listeners.containsKey(JobInsertedListener.class)){
+				for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){
+					((JobInsertedListener)l).informJobInserted(job2insert, inRoute, additionalCosts, additionalTime);
+				}
+			}
+			
+		}
+
+		@Override
+		public void informInsertionEnds(Collection<VehicleRoute> vehicleRoutes) {
+//			if(listeners.containsKey(JobInsertedListener.class)){
+//				for(VehicleRoutingAlgorithmListener l : listeners.get(RuinListener.class)){
+//					((JobInsertedListener)l).informJobInserted(job2insert, inRoute, additionalCosts, additionalTime);
+//				}
+//			}
+		}
+
+		@Override
+		public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes,Collection<Job> unassignedJobs) {
+			// TODO Auto-generated method stub
+			
+		}
+
+		@Override
+		public void informIterationEnds(int i, VehicleRoutingProblem problem,Collection<VehicleRoutingProblemSolution> solutions) {
+			// TODO Auto-generated method stub
+			
+		}
+
+		@Override
+		public void informIterationStarts(int i, VehicleRoutingProblem problem,Collection<VehicleRoutingProblemSolution> solutions) {
+			// TODO Auto-generated method stub
+			
+		}
+		
+	}
+	
+	static class UpdateCostsAtRouteLevel implements JobInsertedListener, InsertionStartsListener, InsertionEndsListener{
+		
+		private StateManagerImpl states;
+		
+		private VehicleRoutingTransportCosts tpCosts;
+		
+		private VehicleRoutingActivityCosts actCosts;
+		
+		public UpdateCostsAtRouteLevel(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts, VehicleRoutingActivityCosts actCosts) {
+			super();
+			this.states = states;
+			this.tpCosts = tpCosts;
+			this.actCosts = actCosts;
+		}
+
+		@Override
+		public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
+//			inRoute.getVehicleRouteCostCalculator().addTransportCost(additionalCosts);
+			double oldCosts = states.getRouteState(inRoute, StateTypes.COSTS).toDouble();
+			oldCosts += additionalCosts;
+			states.putRouteState(inRoute, StateTypes.COSTS, new StateImpl(oldCosts));
+		}
+
+		@Override
+		public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
+			IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts);
+			forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states));
+			for(VehicleRoute route : vehicleRoutes){
+				forwardInTime.iterate(route);
+			}
+			
+		}
+
+		@Override
+		public void informInsertionEnds(Collection<VehicleRoute> vehicleRoutes) {
+			
+//			IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts);
+//			forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states));
+			for(VehicleRoute route : vehicleRoutes){
+				if(route.isEmpty()) continue;
+				route.getVehicleRouteCostCalculator().reset();
+				route.getVehicleRouteCostCalculator().addOtherCost(states.getRouteState(route, StateTypes.COSTS).toDouble());
+				route.getVehicleRouteCostCalculator().price(route.getVehicle());
+//				forwardInTime.iterate(route);
+			}
+			
+		}
+
+	}
+
+	static class UpdateActivityTimes implements ForwardInTimeListener{
+
+		private Logger log = Logger.getLogger(UpdateActivityTimes.class);
+		
+		@Override
+		public void start(VehicleRoute route, Start start, double departureTime) {
+			start.setEndTime(departureTime);
+		}
+
+		@Override
+		public void nextActivity(TourActivity act, double arrTime, double endTime) {
+			act.setArrTime(arrTime);
+			act.setEndTime(endTime);
+		}
+
+		@Override
+		public void end(End end, double arrivalTime) {
+			end.setArrTime(arrivalTime);
+		}
+
+	}
+
+	static class UpdateCostsAtAllLevels implements ForwardInTimeListener{
+
+		private static Logger log = Logger.getLogger(UpdateCostsAtAllLevels.class);
+		
+		private VehicleRoutingActivityCosts activityCost;
+
+		private ForwardTransportCost transportCost;
+		
+		private StateManagerImpl states;
+		
+		private double totalOperationCost = 0.0;
+		
+		private VehicleRoute vehicleRoute = null;
+		
+		private TourActivity prevAct = null;
+		
+		private double startTimeAtPrevAct = 0.0;
+		
+		public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, ForwardTransportCost transportCost, StateManagerImpl states) {
+			super();
+			this.activityCost = activityCost;
+			this.transportCost = transportCost;
+			this.states = states;
+		}
+
+		@Override
+		public void start(VehicleRoute route, Start start, double departureTime) {
+			vehicleRoute = route;
+			vehicleRoute.getVehicleRouteCostCalculator().reset();
+			prevAct = start;
+			startTimeAtPrevAct = departureTime;
+//			log.info(start + " depTime=" + departureTime);
+		}
+
+		@Override
+		public void nextActivity(TourActivity act, double arrTime, double endTime) {
+//			log.info(act + " job " + ((JobActivity)act).getJob().getId() + " arrTime=" + arrTime + " endTime=" +  endTime);
+			double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), act.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
+			double actCost = activityCost.getActivityCost(act, arrTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
+
+			vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
+			vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
+
+			if(transportCost > 10000 || actCost > 100000){
+				throw new IllegalStateException("aaaääähh");
+			}
+			
+			totalOperationCost += transportCost;
+			totalOperationCost += actCost;
+
+			states.putActivityState(act, StateTypes.COSTS, new StateImpl(totalOperationCost));
+
+			prevAct = act;
+			startTimeAtPrevAct = endTime;	
+		}
+
+		@Override
+		public void end(End end, double arrivalTime) {
+//			log.info(end + " arrTime=" + arrivalTime);
+			double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), end.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
+			double actCost = activityCost.getActivityCost(end, arrivalTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
+			
+			vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
+			vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
+			
+			if(transportCost > 10000 || actCost > 100000){
+				throw new IllegalStateException("aaaääähh");
+			}
+			
+			totalOperationCost += transportCost;
+			totalOperationCost += actCost;
+			
+			states.putRouteState(vehicleRoute, StateTypes.COSTS, new StateImpl(totalOperationCost));
+			
+			//this is rather strange and likely to change
+			vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getDriver());
+			vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getVehicle());
+			vehicleRoute.getVehicleRouteCostCalculator().finish();
+			
+			startTimeAtPrevAct = 0.0;
+			prevAct = null;
+			vehicleRoute = null;
+			totalOperationCost = 0.0;
+		}
+
+	}
+
+	static class UpdateEarliestStartTimeWindowAtActLocations implements ForwardInTimeListener{
+
+		private StateManagerImpl states;
+		
+		public UpdateEarliestStartTimeWindowAtActLocations(StateManagerImpl states) {
+			super();
+			this.states = states;
+		}
+
+		@Override
+		public void start(VehicleRoute route, Start start, double departureTime) {}
+
+		@Override
+		public void nextActivity(TourActivity act, double arrTime, double endTime) {
+			states.putActivityState(act, StateTypes.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(arrTime, act.getTheoreticalEarliestOperationStartTime())));
+		}
+
+		@Override
+		public void end(End end, double arrivalTime) {}
+
+	}
+
+	static class UpdateLatestOperationStartTimeAtActLocations implements BackwardInTimeListener{
+
+		private static Logger log = Logger.getLogger(UpdateLatestOperationStartTimeAtActLocations.class);
+		
+		private StateManagerImpl states;
+		
+		public UpdateLatestOperationStartTimeAtActLocations(StateManagerImpl states) {
+			super();
+			this.states = states;
+		}
+
+		@Override
+		public void start(VehicleRoute route, End end, double latestArrivalTime) {}
+
+		@Override
+		public void prevActivity(TourActivity act,double latestDepartureTime, double latestOperationStartTime) {
+//			log.info(act + " jobId=" + ((JobActivity)act).getJob().getId() + " " + latestOperationStartTime);
+			states.putActivityState(act, StateTypes.LATEST_OPERATION_START_TIME, new StateImpl(latestOperationStartTime));
+		}
+
+		@Override
+		public void end(Start start, double latestDepartureTime) {}
+
+		
+
+	}
+
+	static class UpdateLoadAtAllLevels implements ForwardInTimeListener{
+
+		private double load = 0.0;
+		
+		private StateManagerImpl states;
+		
+		private VehicleRoute vehicleRoute;
+		
+		public UpdateLoadAtAllLevels(StateManagerImpl states) {
+			super();
+			this.states = states;
+		}
+
+		@Override
+		public void start(VehicleRoute route, Start start, double departureTime) { vehicleRoute = route; }
+
+		@Override
+		public void nextActivity(TourActivity act, double arrTime, double endTime) {
+			load += (double)act.getCapacityDemand();
+			states.putActivityState(act, StateTypes.LOAD, new StateImpl(load));
+		}
+
+		@Override
+		public void end(End end, double arrivalTime) {
+			states.putRouteState(vehicleRoute, StateTypes.LOAD, new StateImpl(load));
+			load=0;
+			vehicleRoute = null;
+		}
+
+	}
+
+	static class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener{
+
+		private StateManagerImpl states;
+		
+		public UpdateLoadAtRouteLevel(StateManagerImpl states) {
+			super();
+			this.states = states;
+		}
+
+		@Override
+		public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
+			if(!(job2insert instanceof Service)){
+				return;
+			}
+			double oldLoad = states.getRouteState(inRoute, StateTypes.LOAD).toDouble();
+			states.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(oldLoad + job2insert.getCapacityDemand()));
+		}
+
+		@Override
+		public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
+			for(VehicleRoute route : vehicleRoutes){
+				int load = 0;
+				for(Job j : route.getTourActivities().getJobs()){
+					load += j.getCapacityDemand();
+				}
+				states.putRouteState(route, StateTypes.LOAD, new StateImpl(load));
+			}
+			
+		}
+
+	}
+
+	static class UpdateStates implements JobInsertedListener, RuinListener{
+
+		private IterateRouteForwardInTime iterateForward;
+		
+		private IterateRouteBackwardInTime iterateBackward;
+		
+		public UpdateStates(StateManagerImpl states, VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts activityCosts) {
+			
+			iterateForward = new IterateRouteForwardInTime(routingCosts);
+			iterateForward.addListener(new UpdateActivityTimes());
+			iterateForward.addListener(new UpdateCostsAtAllLevels(activityCosts, routingCosts, states));
+			iterateForward.addListener(new UpdateLoadAtAllLevels(states));
+//			iterateForward.addListener(new UpdateEarliestStartTimeWindowAtActLocations(states));
+			
+			iterateBackward = new IterateRouteBackwardInTime(routingCosts);
+			iterateBackward.addListener(new UpdateLatestOperationStartTimeAtActLocations(states));
+		}
+		
+		public void update(VehicleRoute route){
+			iterateForward.iterate(route);
+			iterateBackward.iterate(route);
+		}
+
+		@Override
+		public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
+			iterateForward.iterate(inRoute);
+			iterateBackward.iterate(inRoute);
+		}
+
+		@Override
+		public void ruinStarts(Collection<VehicleRoute> routes) {}
+
+		@Override
+		public void ruinEnds(Collection<VehicleRoute> routes,Collection<Job> unassignedJobs) {
+			for(VehicleRoute route : routes) {
+				iterateForward.iterate(route);
+				iterateBackward.iterate(route);
+			}
+		}
+
+		@Override
+		public void removed(Job job, VehicleRoute fromRoute) {}
+
+	}
+
+	static class UpdateFuturePickupsAtActivityLevel implements BackwardInTimeListener {
+		private StateManagerImpl stateManager;
+		private int futurePicks = 0;
+		private VehicleRoute route;
+		
+		public UpdateFuturePickupsAtActivityLevel(StateManagerImpl stateManager) {
+			super();
+			this.stateManager = stateManager;
+		}
+
+		@Override
+		public void start(VehicleRoute route, End end, double latestArrivalTime) {
+			this.route = route;
+		}
+		
+		@Override
+		public void prevActivity(TourActivity act, double latestDepartureTime, double latestOperationStartTime) {
+			stateManager.putActivityState(act, StateTypes.FUTURE_PICKS, new StateImpl(futurePicks));
+			if(act instanceof PickupActivity){
+				futurePicks += act.getCapacityDemand();
+			}
+			assert futurePicks <= route.getVehicle().getCapacity() : "sum of pickups must not be > vehicleCap";
+			assert futurePicks >= 0 : "sum of pickups must not < 0";
+		}
+		
+		@Override
+		public void end(Start start, double latestDepartureTime) {
+			futurePicks = 0;
+			route = null;
+		}
+	}
+
+	static class UpdateOccuredDeliveriesAtActivityLevel implements ForwardInTimeListener {
+		private StateManagerImpl stateManager;
+		private int deliveries = 0; 
+		private VehicleRoute route;
+		
+		public UpdateOccuredDeliveriesAtActivityLevel(StateManagerImpl stateManager) {
+			super();
+			this.stateManager = stateManager;
+		}
+
+		@Override
+		public void start(VehicleRoute route, Start start, double departureTime) {
+			this.route = route; 
+		}
+		
+		@Override
+		public void nextActivity(TourActivity act, double arrTime, double endTime) {
+			if(act instanceof DeliveryActivity){
+				deliveries += Math.abs(act.getCapacityDemand());
+			}
+			stateManager.putActivityState(act, StateTypes.PAST_DELIVERIES, new StateImpl(deliveries));
+			assert deliveries >= 0 : "deliveries < 0";
+			assert deliveries <= route.getVehicle().getCapacity() : "deliveries > vehicleCap";
+		}
+		
+		@Override
+		public void end(End end, double arrivalTime) {
+			deliveries = 0;
+			route = null;
+		}
+	}
+	
+	/**
+	 * Updates load at activity level. Note that this assumed that StateTypes.LOAD_AT_DEPOT is already updated, i.e. it starts by setting loadAtDepot to StateTypes.LOAD_AT_DEPOT.
+	 * If StateTypes.LOAD_AT_DEPOT is not set, it starts with 0 load at depot.
+	 *  
+	 * @author stefan
+	 *
+	 */
+	static class UpdateLoadAtActivityLevel implements ForwardInTimeListener {
+		private StateManagerImpl stateManager;
+		private int currentLoad = 0;
+		private VehicleRoute route;
+		
+		public UpdateLoadAtActivityLevel(StateManagerImpl stateManager) {
+			super();
+			this.stateManager = stateManager;
+		}
+
+		@Override
+		public void start(VehicleRoute route, Start start, double departureTime) {
+			currentLoad = (int) stateManager.getRouteState(route, StateTypes.LOAD_AT_DEPOT).toDouble();
+			this.route = route;
+		}
+		
+		@Override
+		public void nextActivity(TourActivity act, double arrTime, double endTime) {
+			currentLoad += act.getCapacityDemand();
+			stateManager.putActivityState(act, StateTypes.LOAD, new StateImpl(currentLoad));
+			assert currentLoad <= route.getVehicle().getCapacity() : "currentLoad at activity must not be > vehicleCapacity";
+			assert currentLoad >= 0 : "currentLoad at act must not be < 0";
+		}
+		
+		@Override
+		public void end(End end, double arrivalTime) {
+			currentLoad = 0;
+		}
+	}
+	
+	static class ResetStateManager implements IterationStartsListener {
+
+		private StateManagerImpl stateManager;
+		
+		public ResetStateManager(StateManagerImpl stateManager) {
+			super();
+			this.stateManager = stateManager;
+		}
+
+		@Override
+		public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
+			stateManager.clear();
+		}
+	}
+	
+	static class WalkThroughAndUpdateRoutesOnceTheyChanged implements InsertionStartsListener, JobInsertedListener {
+
+		private IterateRouteForwardInTime forwardInTimeIterator;
+		
+		private IterateRouteBackwardInTime backwardInTimeIterator;
+		
+		public WalkThroughAndUpdateRoutesOnceTheyChanged(VehicleRoutingTransportCosts routingCosts) {
+			forwardInTimeIterator = new IterateRouteForwardInTime(routingCosts);
+			backwardInTimeIterator = new IterateRouteBackwardInTime(routingCosts);
+		}
+		
+		void addListener(ForwardInTimeListener l){
+			forwardInTimeIterator.addListener(l);
+		}
+		
+		void addListener(BackwardInTimeListener l){
+			backwardInTimeIterator.addListener(l);
+		}
+
+		@Override
+		public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
+			
+		}
+
+		@Override
+		public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
+			// TODO Auto-generated method stub
+			
+		}
+		
+	}
+}

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

@@ -1,62 +0,0 @@
-package algorithms;
-
-import java.util.Collection;
-
-import algorithms.StateManager.StateImpl;
-import basics.Job;
-import basics.algo.InsertionEndsListener;
-import basics.algo.InsertionStartsListener;
-import basics.algo.JobInsertedListener;
-import basics.costs.VehicleRoutingActivityCosts;
-import basics.costs.VehicleRoutingTransportCosts;
-import basics.route.VehicleRoute;
-
-class UdateCostsAtRouteLevel implements JobInsertedListener, InsertionStartsListener, InsertionEndsListener{
-	
-	private StateManagerImpl states;
-	
-	private VehicleRoutingTransportCosts tpCosts;
-	
-	private VehicleRoutingActivityCosts actCosts;
-	
-	public UdateCostsAtRouteLevel(StateManagerImpl states, VehicleRoutingTransportCosts tpCosts, VehicleRoutingActivityCosts actCosts) {
-		super();
-		this.states = states;
-		this.tpCosts = tpCosts;
-		this.actCosts = actCosts;
-	}
-
-	@Override
-	public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
-//		inRoute.getVehicleRouteCostCalculator().addTransportCost(additionalCosts);
-		double oldCosts = states.getRouteState(inRoute, StateTypes.COSTS).toDouble();
-		oldCosts += additionalCosts;
-		states.putRouteState(inRoute, StateTypes.COSTS, new StateImpl(oldCosts));
-	}
-
-	@Override
-	public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
-		IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts);
-		forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states));
-		for(VehicleRoute route : vehicleRoutes){
-			forwardInTime.iterate(route);
-		}
-		
-	}
-
-	@Override
-	public void informInsertionEnds(Collection<VehicleRoute> vehicleRoutes) {
-		
-//		IterateRouteForwardInTime forwardInTime = new IterateRouteForwardInTime(tpCosts);
-//		forwardInTime.addListener(new UpdateCostsAtAllLevels(actCosts, tpCosts, states));
-		for(VehicleRoute route : vehicleRoutes){
-			if(route.isEmpty()) continue;
-			route.getVehicleRouteCostCalculator().reset();
-			route.getVehicleRouteCostCalculator().addOtherCost(states.getRouteState(route, StateTypes.COSTS).toDouble());
-			route.getVehicleRouteCostCalculator().price(route.getVehicle());
-//			forwardInTime.iterate(route);
-		}
-		
-	}
-
-}

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

@@ -1,31 +0,0 @@
-package algorithms;
-
-import org.apache.log4j.Logger;
-
-import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
-import basics.route.End;
-import basics.route.Start;
-import basics.route.TourActivity;
-import basics.route.VehicleRoute;
-
-class UpdateActivityTimes implements ForwardInTimeListener{
-
-	private Logger log = Logger.getLogger(UpdateActivityTimes.class);
-	
-	@Override
-	public void start(VehicleRoute route, Start start, double departureTime) {
-		start.setEndTime(departureTime);
-	}
-
-	@Override
-	public void nextActivity(TourActivity act, double arrTime, double endTime) {
-		act.setArrTime(arrTime);
-		act.setEndTime(endTime);
-	}
-
-	@Override
-	public void end(End end, double arrivalTime) {
-		end.setArrTime(arrivalTime);
-	}
-
-}

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

@@ -1,100 +0,0 @@
-package algorithms;
-
-import org.apache.log4j.Logger;
-
-import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
-import algorithms.StateManager.StateImpl;
-import basics.costs.ForwardTransportCost;
-import basics.costs.VehicleRoutingActivityCosts;
-import basics.route.End;
-import basics.route.Start;
-import basics.route.TourActivity;
-import basics.route.TourActivity.JobActivity;
-import basics.route.VehicleRoute;
-
-class UpdateCostsAtAllLevels implements ForwardInTimeListener{
-
-	private static Logger log = Logger.getLogger(UpdateCostsAtAllLevels.class);
-	
-	private VehicleRoutingActivityCosts activityCost;
-
-	private ForwardTransportCost transportCost;
-	
-	private StateManagerImpl states;
-	
-	private double totalOperationCost = 0.0;
-	
-	private VehicleRoute vehicleRoute = null;
-	
-	private TourActivity prevAct = null;
-	
-	private double startTimeAtPrevAct = 0.0;
-	
-	public UpdateCostsAtAllLevels(VehicleRoutingActivityCosts activityCost, ForwardTransportCost transportCost, StateManagerImpl states) {
-		super();
-		this.activityCost = activityCost;
-		this.transportCost = transportCost;
-		this.states = states;
-	}
-
-	@Override
-	public void start(VehicleRoute route, Start start, double departureTime) {
-		vehicleRoute = route;
-		vehicleRoute.getVehicleRouteCostCalculator().reset();
-		prevAct = start;
-		startTimeAtPrevAct = departureTime;
-//		log.info(start + " depTime=" + departureTime);
-	}
-
-	@Override
-	public void nextActivity(TourActivity act, double arrTime, double endTime) {
-//		log.info(act + " job " + ((JobActivity)act).getJob().getId() + " arrTime=" + arrTime + " endTime=" +  endTime);
-		double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), act.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
-		double actCost = activityCost.getActivityCost(act, arrTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
-
-		vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
-		vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
-
-		if(transportCost > 10000 || actCost > 100000){
-			throw new IllegalStateException("aaaääähh");
-		}
-		
-		totalOperationCost += transportCost;
-		totalOperationCost += actCost;
-
-		states.putActivityState(act, StateTypes.COSTS, new StateImpl(totalOperationCost));
-
-		prevAct = act;
-		startTimeAtPrevAct = endTime;	
-	}
-
-	@Override
-	public void end(End end, double arrivalTime) {
-//		log.info(end + " arrTime=" + arrivalTime);
-		double transportCost = this.transportCost.getTransportCost(prevAct.getLocationId(), end.getLocationId(), startTimeAtPrevAct, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
-		double actCost = activityCost.getActivityCost(end, arrivalTime, vehicleRoute.getDriver(), vehicleRoute.getVehicle());
-		
-		vehicleRoute.getVehicleRouteCostCalculator().addTransportCost(transportCost);
-		vehicleRoute.getVehicleRouteCostCalculator().addActivityCost(actCost);
-		
-		if(transportCost > 10000 || actCost > 100000){
-			throw new IllegalStateException("aaaääähh");
-		}
-		
-		totalOperationCost += transportCost;
-		totalOperationCost += actCost;
-		
-		states.putRouteState(vehicleRoute, StateTypes.COSTS, new StateImpl(totalOperationCost));
-		
-		//this is rather strange and likely to change
-		vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getDriver());
-		vehicleRoute.getVehicleRouteCostCalculator().price(vehicleRoute.getVehicle());
-		vehicleRoute.getVehicleRouteCostCalculator().finish();
-		
-		startTimeAtPrevAct = 0.0;
-		prevAct = null;
-		vehicleRoute = null;
-		totalOperationCost = 0.0;
-	}
-
-}

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

@@ -1,30 +0,0 @@
-package algorithms;
-
-import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
-import algorithms.StateManager.StateImpl;
-import basics.route.End;
-import basics.route.Start;
-import basics.route.TourActivity;
-import basics.route.VehicleRoute;
-
-class UpdateEarliestStartTimeWindowAtActLocations implements ForwardInTimeListener{
-
-	private StateManagerImpl states;
-	
-	public UpdateEarliestStartTimeWindowAtActLocations(StateManagerImpl states) {
-		super();
-		this.states = states;
-	}
-
-	@Override
-	public void start(VehicleRoute route, Start start, double departureTime) {}
-
-	@Override
-	public void nextActivity(TourActivity act, double arrTime, double endTime) {
-		states.putActivityState(act, StateTypes.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(arrTime, act.getTheoreticalEarliestOperationStartTime())));
-	}
-
-	@Override
-	public void end(End end, double arrivalTime) {}
-
-}

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

@@ -1,38 +0,0 @@
-package algorithms;
-
-import org.apache.log4j.Logger;
-
-import algorithms.BackwardInTimeListeners.BackwardInTimeListener;
-import algorithms.StateManager.StateImpl;
-import basics.route.End;
-import basics.route.Start;
-import basics.route.TourActivity;
-import basics.route.TourActivity.JobActivity;
-import basics.route.VehicleRoute;
-
-class UpdateLatestOperationStartTimeAtActLocations implements BackwardInTimeListener{
-
-	private static Logger log = Logger.getLogger(UpdateLatestOperationStartTimeAtActLocations.class);
-	
-	private StateManagerImpl states;
-	
-	public UpdateLatestOperationStartTimeAtActLocations(StateManagerImpl states) {
-		super();
-		this.states = states;
-	}
-
-	@Override
-	public void start(VehicleRoute route, End end, double latestArrivalTime) {}
-
-	@Override
-	public void prevActivity(TourActivity act,double latestDepartureTime, double latestOperationStartTime) {
-//		log.info(act + " jobId=" + ((JobActivity)act).getJob().getId() + " " + latestOperationStartTime);
-		states.putActivityState(act, StateTypes.LATEST_OPERATION_START_TIME, new StateImpl(latestOperationStartTime));
-	}
-
-	@Override
-	public void end(Start start, double latestDepartureTime) {}
-
-	
-
-}

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

@@ -1,45 +0,0 @@
-package algorithms;
-
-import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
-import algorithms.StateManager.StateImpl;
-import basics.route.End;
-import basics.route.Start;
-import basics.route.TourActivity;
-import basics.route.VehicleRoute;
-
-/**
- * It does not update start and end activities.
- * 
- * @author stefan
- *
- */
-class UpdateLoadAtAllLevels implements ForwardInTimeListener{
-
-	private double load = 0.0;
-	
-	private StateManagerImpl states;
-	
-	private VehicleRoute vehicleRoute;
-	
-	public UpdateLoadAtAllLevels(StateManagerImpl states) {
-		super();
-		this.states = states;
-	}
-
-	@Override
-	public void start(VehicleRoute route, Start start, double departureTime) { vehicleRoute = route; }
-
-	@Override
-	public void nextActivity(TourActivity act, double arrTime, double endTime) {
-		load += (double)act.getCapacityDemand();
-		states.putActivityState(act, StateTypes.LOAD, new StateImpl(load));
-	}
-
-	@Override
-	public void end(End end, double arrivalTime) {
-		states.putRouteState(vehicleRoute, StateTypes.LOAD, new StateImpl(load));
-		load=0;
-		vehicleRoute = null;
-	}
-
-}

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

@@ -1,42 +0,0 @@
-package algorithms;
-
-import java.util.Collection;
-
-import algorithms.StateManager.StateImpl;
-import basics.Job;
-import basics.Service;
-import basics.algo.InsertionStartsListener;
-import basics.algo.JobInsertedListener;
-import basics.route.VehicleRoute;
-
-class UpdateLoadAtRouteLevel implements JobInsertedListener, InsertionStartsListener{
-
-	private StateManagerImpl states;
-	
-	public UpdateLoadAtRouteLevel(StateManagerImpl states) {
-		super();
-		this.states = states;
-	}
-
-	@Override
-	public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
-		if(!(job2insert instanceof Service)){
-			return;
-		}
-		double oldLoad = states.getRouteState(inRoute, StateTypes.LOAD).toDouble();
-		states.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(oldLoad + job2insert.getCapacityDemand()));
-	}
-
-	@Override
-	public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
-		for(VehicleRoute route : vehicleRoutes){
-			int load = 0;
-			for(Job j : route.getTourActivities().getJobs()){
-				load += j.getCapacityDemand();
-			}
-			states.putRouteState(route, StateTypes.LOAD, new StateImpl(load));
-		}
-		
-	}
-
-}

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

@@ -1,55 +0,0 @@
-package algorithms;
-
-import java.util.Collection;
-
-import algorithms.RuinStrategy.RuinListener;
-import basics.Job;
-import basics.algo.JobInsertedListener;
-import basics.costs.VehicleRoutingActivityCosts;
-import basics.costs.VehicleRoutingTransportCosts;
-import basics.route.VehicleRoute;
-
-class UpdateStates implements JobInsertedListener, RuinListener{
-
-	private IterateRouteForwardInTime iterateForward;
-	
-	private IterateRouteBackwardInTime iterateBackward;
-	
-	public UpdateStates(StateManagerImpl states, VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts activityCosts) {
-		
-		iterateForward = new IterateRouteForwardInTime(routingCosts);
-		iterateForward.addListener(new UpdateActivityTimes());
-		iterateForward.addListener(new UpdateCostsAtAllLevels(activityCosts, routingCosts, states));
-		iterateForward.addListener(new UpdateLoadAtAllLevels(states));
-//		iterateForward.addListener(new UpdateEarliestStartTimeWindowAtActLocations(states));
-		
-		iterateBackward = new IterateRouteBackwardInTime(routingCosts);
-		iterateBackward.addListener(new UpdateLatestOperationStartTimeAtActLocations(states));
-	}
-	
-	public void update(VehicleRoute route){
-		iterateForward.iterate(route);
-		iterateBackward.iterate(route);
-	}
-
-	@Override
-	public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
-		iterateForward.iterate(inRoute);
-		iterateBackward.iterate(inRoute);
-	}
-
-	@Override
-	public void ruinStarts(Collection<VehicleRoute> routes) {}
-
-	@Override
-	public void ruinEnds(Collection<VehicleRoute> routes,Collection<Job> unassignedJobs) {
-		for(VehicleRoute route : routes) {
-			iterateForward.iterate(route);
-			iterateBackward.iterate(route);
-		}
-	}
-
-	@Override
-	public void removed(Job job, VehicleRoute fromRoute) {}
-
-}

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

@@ -36,10 +36,10 @@ import org.apache.commons.configuration.XMLConfiguration;
 import org.apache.log4j.Logger;
 
 import util.RouteUtils;
-import algorithms.RuinStrategy.RuinListener;
+import algorithms.StateUpdates.UpdateStates;
-import algorithms.VehicleRoutingAlgorithms.TypedMap.InsertionStrategyKey;
 import algorithms.VehicleRoutingAlgorithms.TypedMap.AbstractKey;
 import algorithms.VehicleRoutingAlgorithms.TypedMap.AcceptorKey;
+import algorithms.VehicleRoutingAlgorithms.TypedMap.InsertionStrategyKey;
 import algorithms.VehicleRoutingAlgorithms.TypedMap.RuinStrategyKey;
 import algorithms.VehicleRoutingAlgorithms.TypedMap.SelectorKey;
 import algorithms.VehicleRoutingAlgorithms.TypedMap.StrategyModuleKey;
@@ -71,7 +71,6 @@ import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
 import basics.algo.VehicleRoutingAlgorithmListeners.Priority;
 import basics.io.AlgorithmConfig;
 import basics.io.AlgorithmConfigXmlReader;
-import basics.route.VehicleRoute;
 
 
 

jsprit-core/src/main/java/basics/algo/SearchStrategyListener.java

@@ -20,6 +20,6 @@
  ******************************************************************************/
 package basics.algo;
 
-public class SearchStrategyListener {
+public interface SearchStrategyListener extends VehicleRoutingAlgorithmListener{
 
 }

jsprit-core/src/main/java/basics/algo/SearchStrategyModuleListener.java

@@ -20,6 +20,6 @@
  ******************************************************************************/
 package basics.algo;
 
-public interface SearchStrategyModuleListener {
+public interface SearchStrategyModuleListener extends VehicleRoutingAlgorithmListener{
 
 }

jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java

@@ -1,6 +1,6 @@
 package algorithms;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.Collection;
 
@@ -9,6 +9,8 @@ import org.junit.Test;
 
 import util.Solutions;
 import algorithms.HardConstraints.HardActivityLevelConstraint;
+import algorithms.StateUpdates.UpdateCostsAtRouteLevel;
+import algorithms.StateUpdates.UpdateLoadAtRouteLevel;
 import algorithms.acceptors.AcceptNewIfBetterThanWorst;
 import algorithms.selectors.SelectBest;
 import basics.VehicleRoutingAlgorithm;
@@ -76,7 +78,7 @@ public class BuildCVRPAlgoFromScratchTest {
 		vra.getAlgorithmListeners().addListener(clearStateManager);
 		vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager));
 		
-		vra.getSearchStrategyManager().addSearchStrategyModuleListener(new UdateCostsAtRouteLevel(stateManager, vrp.getTransportCosts(), vrp.getActivityCosts()));
+		vra.getSearchStrategyManager().addSearchStrategyModuleListener(new UpdateCostsAtRouteLevel(stateManager, vrp.getTransportCosts(), vrp.getActivityCosts()));
 		vra.getSearchStrategyManager().addSearchStrategyModuleListener(new UpdateLoadAtRouteLevel(stateManager));
 		
 		VehicleRoutingProblemSolution iniSolution = new CreateInitialSolution(bestInsertion).createInitialSolution(vrp);

jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java

@@ -9,8 +9,12 @@ import org.junit.Test;
 import util.Solutions;
 import algorithms.BackwardInTimeListeners.BackwardInTimeListener;
 import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
-import algorithms.HardConstraints.HardActivityLevelConstraintAccumulator;
+import algorithms.HardConstraints.HardActivityLevelConstraintManager;
 import algorithms.StateManager.StateImpl;
+import algorithms.StateUpdates.UpdateActivityTimes;
+import algorithms.StateUpdates.UpdateCostsAtAllLevels;
+import algorithms.StateUpdates.UpdateEarliestStartTimeWindowAtActLocations;
+import algorithms.StateUpdates.UpdateLatestOperationStartTimeAtActLocations;
 import algorithms.acceptors.AcceptNewIfBetterThanWorst;
 import algorithms.selectors.SelectBest;
 import basics.Delivery;
@@ -28,6 +32,7 @@ import basics.io.VrpXMLReader;
 import basics.io.VrpXMLWriter;
 import basics.route.DeliveryActivity;
 import basics.route.End;
+import basics.route.PickupActivity;
 import basics.route.Start;
 import basics.route.TourActivity;
 import basics.route.VehicleRoute;
@@ -49,7 +54,7 @@ public class BuildPDVRPAlgoFromScratchTest {
 			
 			final StateManagerImpl stateManager = new StateManagerImpl();
 			
-			HardActivityLevelConstraintAccumulator actLevelConstraintAccumulator = new HardActivityLevelConstraintAccumulator();
+			HardActivityLevelConstraintManager actLevelConstraintAccumulator = new HardActivityLevelConstraintManager();
 			actLevelConstraintAccumulator.addConstraint(new HardConstraints.HardPickupAndDeliveryConstraint(stateManager));
 			actLevelConstraintAccumulator.addConstraint(new HardConstraints.HardTimeWindowConstraint(stateManager, vrp.getTransportCosts()));
 			
@@ -80,16 +85,8 @@ public class BuildPDVRPAlgoFromScratchTest {
 			
 			vra = new VehicleRoutingAlgorithm(vrp, strategyManager);
 			
-			//listeners
-			IterationStartsListener clearStateManager = new IterationStartsListener() {
 			
-				@Override
+			vra.getAlgorithmListeners().addListener(new StateUpdates.ResetStateManager(stateManager));
-				public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
-					stateManager.clear();
-				}
-				
-			};
-			vra.getAlgorithmListeners().addListener(clearStateManager);
 			
 			final IterateRouteForwardInTime iterateForward = new IterateRouteForwardInTime(vrp.getTransportCosts());
 			
@@ -97,74 +94,12 @@ public class BuildPDVRPAlgoFromScratchTest {
 			iterateForward.addListener(new UpdateEarliestStartTimeWindowAtActLocations(stateManager));
 			iterateForward.addListener(new UpdateCostsAtAllLevels(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
 			
-//			iterateForward.addListener(new UpdateLoadAtAllLevels(stateManager));
+			iterateForward.addListener(new StateUpdates.UpdateOccuredDeliveriesAtActivityLevel(stateManager));
+			iterateForward.addListener(new StateUpdates.UpdateLoadAtActivityLevel(stateManager));
 			
-			iterateForward.addListener(new ForwardInTimeListener() {
-				
-				private int currentLoad = 0;
-				private int deliveries = 0; 
-				private VehicleRoute route;
-				
-				@Override
-				public void start(VehicleRoute route, Start start, double departureTime) {
-//					log.info("iterate forward");
-					currentLoad = (int) stateManager.getRouteState(route, StateTypes.LOAD_AT_DEPOT).toDouble();
-					this.route = route; 
-//					log.info("currentLoad="+currentLoad);
-				}
-				
-				@Override
-				public void nextActivity(TourActivity act, double arrTime, double endTime) {
-//					log.info("nextAct="+act.getClass().toString()+ " capDemand=" + act.getCapacityDemand() + " currentLoad="+currentLoad);
-					currentLoad += act.getCapacityDemand();
-					if(act instanceof DeliveryActivity){
-						deliveries += Math.abs(act.getCapacityDemand());
-					}
-					stateManager.putActivityState(act, StateTypes.LOAD, new StateImpl(currentLoad));
-					stateManager.putActivityState(act, StateTypes.PAST_DELIVERIES, new StateImpl(deliveries));
-					if(currentLoad < 0) throw new IllegalStateException("currentload < 0");
-					if(currentLoad > route.getVehicle().getCapacity()){
-						throw new IllegalStateException("currentload="+currentLoad+" wich is > " + route.getVehicle().getCapacity());
-					}
-					
-				}
-				
-				@Override
-				public void end(End end, double arrivalTime) {
-//					log.info("currentLoad="+currentLoad);
-//					stateManager.putRouteState(route, StateTypes.LOAD, new StateImpl(currentLoad));
-					currentLoad = 0;
-					deliveries = 0;
-					route = null;
-				}
-			});
-//			
 			final IterateRouteBackwardInTime iterateBackward = new IterateRouteBackwardInTime(vrp.getTransportCosts());
 			iterateBackward.addListener(new UpdateLatestOperationStartTimeAtActLocations(stateManager));
-			iterateBackward.addListener(new BackwardInTimeListener() {
+			iterateBackward.addListener(new StateUpdates.UpdateFuturePickupsAtActivityLevel(stateManager));
-				
-				int futurePicks = 0;
-				@Override
-				public void start(VehicleRoute route, End end, double latestArrivalTime) {
-					
-					
-				}
-				
-				@Override
-				public void prevActivity(TourActivity act, double latestDepartureTime, double latestOperationStartTime) {
-					stateManager.putActivityState(act, StateTypes.FUTURE_PICKS, new StateImpl(futurePicks));
-					if(act.getCapacityDemand() > 0){
-						futurePicks += act.getCapacityDemand();
-					}
-					
-				}
-				
-				@Override
-				public void end(Start start, double latestDepartureTime) {
-					futurePicks = 0;
-					
-				}
-			});
 			
 			
 			InsertionStartsListener loadVehicleInDepot = new InsertionStartsListener() {
@@ -193,9 +128,6 @@ public class BuildPDVRPAlgoFromScratchTest {
 			
 			vra.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager));
 			
-//			vra.getSearchStrategyManager().addSearchStrategyModuleListener(loadVehicleInDepot);
-			
-			
 			JobInsertedListener updateLoadAfterJobHasBeenInserted = new JobInsertedListener() {
 				
 				@Override
@@ -212,14 +144,11 @@ public class BuildPDVRPAlgoFromScratchTest {
 //						log.info("loadAtEnd="+loadAtEnd);
 						stateManager.putRouteState(inRoute, StateTypes.LOAD, new StateImpl(loadAtEnd + job2insert.getCapacityDemand()));
 					}
-					
 					iterateForward.iterate(inRoute);
 					iterateBackward.iterate(inRoute);
 				}
 			};
 						
-//			vra.getSearchStrategyManager().addSearchStrategyModuleListener(updateLoadAfterJobHasBeenInserted);
-			
 			bestInsertion.addListener(loadVehicleInDepot);
 			bestInsertion.addListener(updateLoadAfterJobHasBeenInserted);
 			

jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java

@@ -33,6 +33,7 @@ import org.junit.Test;
 import util.Coordinate;
 import util.ManhattanDistanceCalculator;
 import util.RouteUtils;
+import algorithms.StateUpdates.UpdateStates;
 import basics.Job;
 import basics.Service;
 import basics.VehicleRoutingProblem;

jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java

@@ -32,17 +32,18 @@ import org.apache.log4j.Logger;
 import org.junit.Before;
 import org.junit.Test;
 
+import algorithms.StateUpdates.UpdateStates;
 import basics.Job;
 import basics.Service;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.DriverImpl;
+import basics.route.DriverImpl.NoDriver;
 import basics.route.ServiceActivity;
 import basics.route.TimeWindow;
 import basics.route.TourActivities;
 import basics.route.TourActivity;
 import basics.route.Vehicle;
 import basics.route.VehicleRoute;
-import basics.route.DriverImpl.NoDriver;
 
 
 

jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java

@@ -34,18 +34,19 @@ import org.junit.Test;
 
 import util.Coordinate;
 import util.ManhattanDistanceCalculator;
+import algorithms.StateUpdates.UpdateStates;
 import basics.Job;
 import basics.Service;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.Driver;
 import basics.route.DriverImpl;
+import basics.route.DriverImpl.NoDriver;
 import basics.route.ServiceActivity;
 import basics.route.TimeWindow;
 import basics.route.TourActivities;
 import basics.route.TourActivity;
 import basics.route.Vehicle;
 import basics.route.VehicleRoute;
-import basics.route.DriverImpl.NoDriver;
 
 
 

jsprit-core/src/test/java/algorithms/TestIterateRouteForwardInTime.java

@@ -10,6 +10,10 @@ import org.junit.Test;
 
 import util.Coordinate;
 import util.ManhattanDistanceCalculator;
+import algorithms.StateUpdates.UpdateActivityTimes;
+import algorithms.StateUpdates.UpdateCostsAtAllLevels;
+import algorithms.StateUpdates.UpdateEarliestStartTimeWindowAtActLocations;
+import algorithms.StateUpdates.UpdateLoadAtAllLevels;
 import basics.Job;
 import basics.Service;
 import basics.costs.DefaultVehicleRoutingActivityCosts;

jsprit-core/src/test/java/algorithms/TestTourStateUpdaterWithService.java

@@ -27,6 +27,7 @@ import org.junit.Test;
 
 import util.Coordinate;
 import util.ManhattanDistanceCalculator;
+import algorithms.StateUpdates.UpdateStates;
 import basics.Job;
 import basics.Service;
 import basics.costs.VehicleRoutingTransportCosts;
@@ -38,7 +39,6 @@ import basics.route.TourActivities;
 import basics.route.Vehicle;
 import basics.route.VehicleImpl;
 import basics.route.VehicleRoute;
-import basics.route.VehicleType;
 import basics.route.VehicleTypeImpl;