renamed generic methods

jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java

@@ -178,6 +178,7 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
 	}
 	
 	/**
+	 * Generic method to add default activity state.
 	 * 
 	 * @param stateId
 	 * @param type
@@ -188,37 +189,55 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
 		defaultActivityStates_.put(stateId, type.cast(defaultState));
 	}
 	
+	/**
+	 * Clears all states.
+	 * 
+	 */
 	public void clear(){
 		vehicleRouteStates_.clear();
 		activityStates_.clear();
 	}
 
+	/**
+	 * @Deprecated use generic method instead <code>getActivityState(TourActivity act, StateId stateId, Class<T> type)</code>
+	 */
 	@Deprecated
 	@Override
 	public State getActivityState(TourActivity act, StateId stateId) {
 		if(!activityStates_.containsKey(act)){
-			return getDefaultActivityState_(act,stateId,State.class);
+			return getDefaultTypedActivityState(act,stateId,State.class);
 		}
 		States_ actStates = activityStates_.get(act);
 		State state = actStates.getState(stateId, State.class);
 		if(state == null){
-			return getDefaultActivityState_(act,stateId,State.class);
+			return getDefaultTypedActivityState(act,stateId,State.class);
 		}
 		return state;
 	}
 	
+	/**
+	 * Returns activity state of type 'type'.
+	 * 
+	 */
 	@Override
 	public <T> T getActivityState(TourActivity act, StateId stateId, Class<T> type) {
 		if(!activityStates_.containsKey(act)){
-			return getDefaultActivityState_(act, stateId, type);
+			return getDefaultTypedActivityState(act, stateId, type);
 		}
 		States_ states = activityStates_.get(act);
 		T state = states.getState(stateId, type);
-		if(state == null) return getDefaultActivityState_(act, stateId, type);
+		if(state == null) return getDefaultTypedActivityState(act, stateId, type);
 		return state;
 	}
 
-	private <T> T getDefaultActivityState_(TourActivity act, StateId stateId,Class<T> type) {
+	/**
+	 * 
+	 * @param act
+	 * @param stateId
+	 * @param type
+	 * @return
+	 */
+	private <T> T getDefaultTypedActivityState(TourActivity act, StateId stateId,Class<T> type) {
 		if(defaultActivityStates_.containsKey(stateId)){
 			return type.cast(defaultActivityStates_.get(stateId));
 		}
@@ -231,40 +250,67 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
 		return null;
 	}
 
+	/**
+	 * Return route state of type 'type'.
+	 * 
+	 * @return route-state
+	 * @throws ClassCastException if state of route and stateId is of another type
+	 */
 	@Override
 	public <T> T getRouteState(VehicleRoute route, StateId stateId, Class<T> type) {
 		if(!vehicleRouteStates_.containsKey(route)){
-			return getDefaultRouteState_(stateId, type);
+			return getDefaultTypedRouteState(stateId, type);
 		}
 		States_ states = vehicleRouteStates_.get(route);
 		T state = states.getState(stateId, type);
-		if(state == null) return getDefaultRouteState_(stateId, type);
+		if(state == null) return getDefaultTypedRouteState(stateId, type);
 		return state;
 	}
 
-	private <T> T getDefaultRouteState_(StateId stateId, Class<T> type) {
+	private <T> T getDefaultTypedRouteState(StateId stateId, Class<T> type) {
 		if(defaultRouteStates_.containsKey(stateId)){
 			return type.cast(defaultRouteStates_.get(stateId));
 		}
 		return null;
 	}
 	
+	/**
+	 * 
+	 * @param act
+	 * @param stateId
+	 * @param state
+	 * @deprecated use generic method <code>putTypedActivityState(TourActivity act, StateId stateId, Class<T> type, T state)</code> instead
+	 */
 	@Deprecated
 	public void putActivityState(TourActivity act, StateId stateId, State state){
-		putActivityState_(act, stateId, State.class, state);
+		putTypedActivityState(act, stateId, State.class, state);
 	}
 	
-	public <T> void putActivityState_(TourActivity act, StateId stateId, Class<T> type, T state){
+	/**
+	 * Generic method to memorize state 'state' of type 'type' of act and stateId.
+	 * 
+	 * <p><b>For example: </b><br>
+	 * <code>Capacity loadAtMyActivity = Capacity.Builder.newInstance().addCapacityDimension(0,10).build();<br>
+	 * stateManager.putTypedActivityState(myActivity, StateFactory.createStateId("act-load"), Capacity.class, loadAtMyActivity);</code>
+	 * <p>you can retrieve the load at myActivity by <br>
+	 * <code>Capacity load = stateManager.getActivityState(myActivity, StateFactory.createStateId("act-load"), Capacity.class);</code>
+	 * 
+	 * @param act
+	 * @param stateId
+	 * @param type
+	 * @param state
+	 */
+	public <T> void putTypedActivityState(TourActivity act, StateId stateId, Class<T> type, T state){
 		if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString());
-		putInternalActivityState_(act, stateId, type, state);
+		putInternalTypedActivityState(act, stateId, type, state);
 	}
 	
 	@Deprecated
 	void putInternalActivityState(TourActivity act, StateId stateId, State state){
-		putInternalActivityState_(act, stateId, State.class, state);
+		putInternalTypedActivityState(act, stateId, State.class, state);
 	}
 	
-	<T> void putInternalActivityState_(TourActivity act, StateId stateId, Class<T> type, T state){
+	<T> void putInternalTypedActivityState(TourActivity act, StateId stateId, Class<T> type, T state){
 		if(!activityStates_.containsKey(act)){
 			activityStates_.put(act, new States_());
 		}
@@ -274,10 +320,10 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
 
 	@Deprecated
 	void putInternalRouteState(VehicleRoute route, StateId stateId, State state){
-		putInternalRouteState_(route, stateId, State.class, state);
+		putTypedInternalRouteState(route, stateId, State.class, state);
 	}
 	
-	<T> void putInternalRouteState_(VehicleRoute route, StateId stateId, Class<T> type, T state){
+	<T> void putTypedInternalRouteState(VehicleRoute route, StateId stateId, Class<T> type, T state){
 		if(!vehicleRouteStates_.containsKey(route)){
 			vehicleRouteStates_.put(route, new States_());
 		}
@@ -287,24 +333,38 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
 
 	@Deprecated
 	public void putRouteState(VehicleRoute route, StateId stateId, State state){
-		 putRouteState_(route, stateId, State.class, state);
+		 putTypedRouteState(route, stateId, State.class, state);
 	}
 	
-	public <T> void putRouteState_(VehicleRoute route, StateId stateId, Class<T> type, T state){
+	/**
+	 * Generic method to memorize state 'state' of type 'type' of route and stateId.
+	 * 
+	 * <p><b>For example:</b> <br>
+	 * <code>double totalRouteDuration = 100.0;<br>
+	 * stateManager.putTypedActivityState(myRoute, StateFactory.createStateId("route-duration"), Double.class, totalRouteDuration);</code>
+	 * <p>you can retrieve the duration of myRoute then by <br>
+	 * <code>double totalRouteDuration = stateManager.getRouteState(myRoute, StateFactory.createStateId("route-duration"), Double.class);</code> 
+	 * 
+	 * @param act
+	 * @param stateId
+	 * @param type
+	 * @param state
+	 */
+	public <T> void putTypedRouteState(VehicleRoute route, StateId stateId, Class<T> type, T state){
 		if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString());
-        putInternalRouteState_(route, stateId, type, state);
+        putTypedInternalRouteState(route, stateId, type, state);
 	}
 
 	@Deprecated
 	@Override
 	public State getRouteState(VehicleRoute route, StateId stateId) {
 		if(!vehicleRouteStates_.containsKey(route)){
-			return getDefaultRouteState_(stateId,State.class);
+			return getDefaultTypedRouteState(stateId,State.class);
 		}
 		States_ routeStates = vehicleRouteStates_.get(route);
 		State state = routeStates.getState(stateId,State.class);
 		if(state == null){
-			return getDefaultRouteState_(stateId, State.class);
+			return getDefaultTypedRouteState(stateId, State.class);
 		}
 		return state;
 	}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateLoads.java

@@ -51,7 +51,7 @@ class UpdateLoads implements ActivityVisitor, StateUpdater, InsertionStartsListe
 	@Override
 	public void visit(TourActivity act) {
 		currentLoad = Capacity.addup(currentLoad, act.getSize());
-		stateManager.putInternalActivityState_(act, StateFactory.LOAD, Capacity.class, currentLoad);
+		stateManager.putInternalTypedActivityState(act, StateFactory.LOAD, Capacity.class, currentLoad);
 		assert currentLoad.isLessOrEqual(route.getVehicle().getType().getCapacityDimensions()) : "currentLoad at activity must not be > vehicleCapacity";
 		assert currentLoad.isGreaterOrEqual(Capacity.Builder.newInstance().build()) : "currentLoad at act must not be < 0 in one of the applied dimensions";
 	}
@@ -72,8 +72,8 @@ class UpdateLoads implements ActivityVisitor, StateUpdater, InsertionStartsListe
 				loadAtEnd = Capacity.addup(loadAtEnd, j.getSize());
 			}
 		}
-		stateManager.putInternalRouteState_(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class, loadAtDepot);
+		stateManager.putTypedInternalRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class, loadAtDepot);
-		stateManager.putInternalRouteState_(route, StateFactory.LOAD_AT_END, Capacity.class, loadAtEnd);
+		stateManager.putTypedInternalRouteState(route, StateFactory.LOAD_AT_END, Capacity.class, loadAtEnd);
 	}
 
 	@Override
@@ -85,11 +85,11 @@ class UpdateLoads implements ActivityVisitor, StateUpdater, InsertionStartsListe
 	public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
 		if(job2insert instanceof Delivery){
 			Capacity loadAtDepot = stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING, Capacity.class);
-			stateManager.putInternalRouteState_(inRoute, StateFactory.LOAD_AT_BEGINNING, Capacity.class, Capacity.addup(loadAtDepot, job2insert.getSize()));
+			stateManager.putTypedInternalRouteState(inRoute, StateFactory.LOAD_AT_BEGINNING, Capacity.class, Capacity.addup(loadAtDepot, job2insert.getSize()));
 		}
 		else if(job2insert instanceof Pickup || job2insert instanceof Service){
 			Capacity loadAtEnd = stateManager.getRouteState(inRoute, StateFactory.LOAD_AT_END, Capacity.class);
-			stateManager.putInternalRouteState_(inRoute, StateFactory.LOAD_AT_END, Capacity.class, Capacity.addup(loadAtEnd, job2insert.getSize()));
+			stateManager.putTypedInternalRouteState(inRoute, StateFactory.LOAD_AT_END, Capacity.class, Capacity.addup(loadAtEnd, job2insert.getSize()));
 		}
 	}
 

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute.java

@@ -34,7 +34,7 @@ class UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute implement
 	@Override
 	public void visit(TourActivity act) {
 		maxLoad = Capacity.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD, Capacity.class));
-		stateManager.putInternalActivityState_(act, StateFactory.PAST_MAXLOAD, Capacity.class, maxLoad);
+		stateManager.putInternalTypedActivityState(act, StateFactory.PAST_MAXLOAD, Capacity.class, maxLoad);
 		assert maxLoad.isGreaterOrEqual(Capacity.Builder.newInstance().build()) : "maxLoad can never be smaller than 0";
 		assert maxLoad.isLessOrEqual(route.getVehicle().getType().getCapacityDimensions()) : "maxLoad can never be bigger than vehicleCap";
 	}

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute.java

@@ -50,7 +50,7 @@ class UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute implements
 	public void visit(TourActivity act) {
 		maxLoad = Capacity.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD, Capacity.class));
 //		maxLoad = Math.max(maxLoad, stateManager.getActivityState(act, StateFactory.LOAD).toDouble());
-		stateManager.putInternalActivityState_(act, StateFactory.FUTURE_MAXLOAD, Capacity.class, maxLoad);
+		stateManager.putInternalTypedActivityState(act, StateFactory.FUTURE_MAXLOAD, Capacity.class, maxLoad);
 //		stateManager.putInternalActivityState(act, StateFactory.FUTURE_MAXLOAD, StateFactory.createState(maxLoad));
 		assert maxLoad.isLessOrEqual(route.getVehicle().getType().getCapacityDimensions()) : "maxLoad can in every capacity dimension never be bigger than vehicleCap";
 //		assert maxLoad <= route.getVehicle().getCapacity() : "maxLoad can never be bigger than vehicleCap";

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilisationAtRoute.java

@@ -47,6 +47,6 @@ class UpdateMaxCapacityUtilisationAtRoute implements ActivityVisitor, StateUpdat
 
 	@Override
 	public void finish() {
-		stateManager.putInternalRouteState_(route, StateFactory.MAXLOAD, Capacity.class, maxLoad);
+		stateManager.putTypedInternalRouteState(route, StateFactory.MAXLOAD, Capacity.class, maxLoad);
 	}
 }

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdatePracticalTimeWindows.java

@@ -42,7 +42,7 @@ class UpdatePracticalTimeWindows implements ReverseActivityVisitor, StateUpdater
 		double potentialLatestArrivalTimeAtCurrAct = latestArrTimeAtPrevAct - transportCosts.getBackwardTransportTime(activity.getLocationId(), prevAct.getLocationId(), latestArrTimeAtPrevAct, route.getDriver(),route.getVehicle()) - activity.getOperationTime();
 		double latestArrivalTime = Math.min(activity.getTheoreticalLatestOperationStartTime(), potentialLatestArrivalTimeAtCurrAct);
 		
-		states.putInternalActivityState_(activity, StateFactory.LATEST_OPERATION_START_TIME, Double.class, latestArrivalTime);
+		states.putInternalTypedActivityState(activity, StateFactory.LATEST_OPERATION_START_TIME, Double.class, latestArrivalTime);
 		
 		latestArrTimeAtPrevAct = latestArrivalTime;
 		prevAct = activity;

jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateVariableCosts.java

@@ -76,7 +76,7 @@ public class UpdateVariableCosts implements ActivityVisitor,StateUpdater{
 		totalOperationCost += transportCost;
 		totalOperationCost += actCost;
 
-		states.putInternalActivityState_(act, StateFactory.COSTS, Double.class, totalOperationCost);
+		states.putInternalTypedActivityState(act, StateFactory.COSTS, Double.class, totalOperationCost);
 
 		prevAct = act;
 		startTimeAtPrevAct = timeTracker.getActEndTime();
@@ -91,7 +91,7 @@ public class UpdateVariableCosts implements ActivityVisitor,StateUpdater{
 		totalOperationCost += transportCost;
 		totalOperationCost += actCost;
 		
-		states.putInternalRouteState_(vehicleRoute, StateFactory.COSTS, Double.class, totalOperationCost);
+		states.putTypedInternalRouteState(vehicleRoute, StateFactory.COSTS, Double.class, totalOperationCost);
 		
 		startTimeAtPrevAct = 0.0;
 		prevAct = null;

jsprit-core/src/test/java/jsprit/core/algorithm/state/HardPickupAndDeliveryShipmentActivityConstraintTest.java

@@ -65,7 +65,7 @@ public class HardPickupAndDeliveryShipmentActivityConstraintTest {
 		PickupService anotherService = new PickupService(mock(Service.class));
 		PickupShipment pickupShipment = new PickupShipment(shipment);
 		
-		stateManager.putInternalActivityState_(pickupService, StateFactory.LOAD, Capacity.class, Capacity.Builder.newInstance().addDimension(0, 2).build());
+		stateManager.putInternalTypedActivityState(pickupService, StateFactory.LOAD, Capacity.class, Capacity.Builder.newInstance().addDimension(0, 2).build());
 //		when(stateManager.getActivityState(pickupService, StateFactory.LOAD)).thenReturn(StateFactory.createState(2.0));
 		assertEquals(ConstraintsStatus.NOT_FULFILLED,constraint.fulfilled(iFacts, pickupService, pickupShipment, anotherService, 0.0));
 	}
@@ -76,7 +76,7 @@ public class HardPickupAndDeliveryShipmentActivityConstraintTest {
 		PickupService anotherService = new PickupService(mock(Service.class));
 		DeliverShipment pickupShipment = new DeliverShipment(shipment);
 		
-		stateManager.putInternalActivityState_(pickupService, StateFactory.LOAD, Capacity.class, Capacity.Builder.newInstance().addDimension(0, 2).build());
+		stateManager.putInternalTypedActivityState(pickupService, StateFactory.LOAD, Capacity.class, Capacity.Builder.newInstance().addDimension(0, 2).build());
 		assertEquals(ConstraintsStatus.NOT_FULFILLED_BREAK,constraint.fulfilled(iFacts, pickupService, pickupShipment, anotherService, 0.0));
 	}
 
@@ -86,7 +86,7 @@ public class HardPickupAndDeliveryShipmentActivityConstraintTest {
 		PickupService anotherService = new PickupService(mock(Service.class));
 		DeliverShipment pickupShipment = new DeliverShipment(shipment);
 		
-		stateManager.putInternalActivityState_(pickupService, StateFactory.LOAD, Capacity.class, Capacity.Builder.newInstance().addDimension(0, 1).build());
+		stateManager.putInternalTypedActivityState(pickupService, StateFactory.LOAD, Capacity.class, Capacity.Builder.newInstance().addDimension(0, 1).build());
 //		stateManager.putInternalActivityState(pickupService, StateFactory.LOAD, StateFactory.createState(1));
 		assertEquals(ConstraintsStatus.FULFILLED,constraint.fulfilled(iFacts, pickupService, pickupShipment, anotherService, 0.0));
 	}

jsprit-core/src/test/java/jsprit/core/algorithm/state/StateManagerTest.java

@@ -42,7 +42,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		State state = StateFactory.createState(1.);
-		stateManager.putRouteState_(route, id, State.class, state);
+		stateManager.putTypedRouteState(route, id, State.class, state);
 		assertEquals(1.,stateManager.getRouteState(route, id, State.class).toDouble(),0.01);
 	}
 	
@@ -52,7 +52,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		boolean routeIsRed = true;
-		stateManager.putRouteState_(route, id, Boolean.class, routeIsRed);
+		stateManager.putTypedRouteState(route, id, Boolean.class, routeIsRed);
 		assertTrue(stateManager.getRouteState(route, id, Boolean.class));
 	}
 	
@@ -62,7 +62,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		int load = 3;
-		stateManager.putRouteState_(route, id, Integer.class, load);
+		stateManager.putTypedRouteState(route, id, Integer.class, load);
 		int getLoad = stateManager.getRouteState(route, id, Integer.class);
 		assertEquals(3, getLoad);
 	}
@@ -73,7 +73,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		Capacity capacity = Capacity.Builder.newInstance().addDimension(0, 500).build();
-		stateManager.putRouteState_(route, id, Capacity.class, capacity);
+		stateManager.putTypedRouteState(route, id, Capacity.class, capacity);
 		Capacity getCap = stateManager.getRouteState(route, id, Capacity.class);
 		assertEquals(500, getCap.get(0));
 	}
@@ -108,7 +108,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		State state = StateFactory.createState(1.);
-		stateManager.putActivityState_(activity, id, State.class, state);
+		stateManager.putTypedActivityState(activity, id, State.class, state);
 		assertEquals(1.,stateManager.getActivityState(activity, id, State.class).toDouble(),0.01);
 	}
 	
@@ -118,7 +118,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		boolean routeIsRed = true;
-		stateManager.putActivityState_(activity, id, Boolean.class, routeIsRed);
+		stateManager.putTypedActivityState(activity, id, Boolean.class, routeIsRed);
 		assertTrue(stateManager.getActivityState(activity, id, Boolean.class));
 	}
 	
@@ -128,7 +128,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		int load = 3;
-		stateManager.putActivityState_(activity, id, Integer.class, load);
+		stateManager.putTypedActivityState(activity, id, Integer.class, load);
 		int getLoad = stateManager.getActivityState(activity, id, Integer.class);
 		assertEquals(3, getLoad);
 	}
@@ -139,7 +139,7 @@ public class StateManagerTest {
 		StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
 		StateId id = StateFactory.createId("myState");
 		Capacity capacity = Capacity.Builder.newInstance().addDimension(0, 500).build();
-		stateManager.putActivityState_(activity, id, Capacity.class, capacity);
+		stateManager.putTypedActivityState(activity, id, Capacity.class, capacity);
 		Capacity getCap = stateManager.getActivityState(activity, id, Capacity.class);
 		assertEquals(500, getCap.get(0));
 	}