trans/graphhopper-jsprit
1
0
Fork 0
mirror of https://github.com/graphhopper/jsprit.git synced 2020-01-24 07:45:05 +01:00
Code Issues Releases Wiki Activity

refined StateManager to deal with generic states

Browse source
This commit is contained in:
oblonski 2014-02-23 22:02:29 +01:00
parent 3101ea253a
commit 6f533d8f20
4 changed files with 294 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

216
jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java
View file

@ -45,14 +45,31 @@ import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
import jsprit.core.problem.solution.route.state.StateFactory; import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.solution.route.state.StateFactory.State; import jsprit.core.problem.solution.route.state.StateFactory.State;
import jsprit.core.problem.solution.route.state.StateFactory.StateId; import jsprit.core.problem.solution.route.state.StateFactory.StateId;
import jsprit.core.problem.solution.route.state.StateFactory.States;
public class StateManager implements RouteAndActivityStateGetter, IterationStartsListener, RuinListener, InsertionStartsListener, JobInsertedListener, InsertionEndsListener { public class StateManager implements RouteAndActivityStateGetter, IterationStartsListener, RuinListener, InsertionStartsListener, JobInsertedListener, InsertionEndsListener {
private Map<VehicleRoute,States> vehicleRouteStates = new HashMap<VehicleRoute, States>(); static class States_ {
private Map<TourActivity,States> activityStates = new HashMap<TourActivity, States>(); private Map<StateId,Object> states = new HashMap<StateId,Object>();
public <T> void putState(StateId id, Class<T> type, T state){
states.put(id, type.cast(state));
}
public <T> T getState(StateId id, Class<T> type){
if(states.containsKey(id)){
T s = type.cast(states.get(id));
return s;
}
return null;
}
}
private Map<VehicleRoute,States_> vehicleRouteStates_ = new HashMap<VehicleRoute, States_>();
private Map<TourActivity,States_> activityStates_ = new HashMap<TourActivity, States_>();
private RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor(); private RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
@ -66,9 +83,9 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
private Collection<StateUpdater> updaters = new ArrayList<StateUpdater>(); private Collection<StateUpdater> updaters = new ArrayList<StateUpdater>();
private Map<StateId,State> defaultRouteStates = new HashMap<StateId, State>(); private Map<StateId,Object> defaultRouteStates_ = new HashMap<StateId,Object>();
private Map<StateId,State> defaultActivityStates = new HashMap<StateId, State>(); private Map<StateId,Object> defaultActivityStates_ = new HashMap<StateId,Object>();
private VehicleRoutingTransportCosts routingCosts; private VehicleRoutingTransportCosts routingCosts;
@ -79,76 +96,169 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
public StateManager(VehicleRoutingProblem vrp) { public StateManager(VehicleRoutingProblem vrp) {
super(); super();
this.routingCosts = vrp.getTransportCosts(); this.routingCosts = vrp.getTransportCosts();
addDefaultStates();
}
private void addDefaultStates() {
defaultActivityStates_.put(StateFactory.LOAD, StateFactory.createState(0));
defaultActivityStates_.put(StateFactory.COSTS, StateFactory.createState(0));
defaultActivityStates_.put(StateFactory.DURATION, StateFactory.createState(0));
defaultActivityStates_.put(StateFactory.FUTURE_MAXLOAD, StateFactory.createState(0));
defaultActivityStates_.put(StateFactory.PAST_MAXLOAD, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.LOAD, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.COSTS, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.DURATION, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.FUTURE_MAXLOAD, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.PAST_MAXLOAD, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.LOAD_AT_END, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.MAXLOAD, StateFactory.createState(0));
defaultRouteStates_.put(StateFactory.LOAD_AT_BEGINNING, StateFactory.createState(0));
} }
public StateManager(VehicleRoutingTransportCosts routingCosts){ public StateManager(VehicleRoutingTransportCosts routingCosts){
this.routingCosts = routingCosts; this.routingCosts = routingCosts;
addDefaultStates();
} }
@Deprecated
public void addDefaultRouteState(StateId stateId, State defaultState){ public void addDefaultRouteState(StateId stateId, State defaultState){
if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString()); addDefaultRouteState(stateId, State.class, defaultState);
defaultRouteStates.put(stateId, defaultState);
} }
public void addDefaultActivityState(StateId stateId, State defaultState){ public <T> void addDefaultRouteState(StateId stateId, Class<T> type, T defaultState){
if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString()); if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString());
defaultActivityStates.put(stateId, defaultState); defaultRouteStates_.put(stateId, type.cast(defaultState));
}
@Deprecated
public void addDefaultActivityState(StateId stateId, State defaultState){
addDefaultActivityState(stateId, State.class, defaultState);
}
public <T> void addDefaultActivityState(StateId stateId, Class<T> type, T defaultState){
if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString());
defaultActivityStates_.put(stateId, type.cast(defaultState));
} }
public void clear(){ public void clear(){
vehicleRouteStates.clear(); vehicleRouteStates_.clear();
activityStates.clear(); activityStates_.clear();
} }
@Deprecated
@Override @Override
public State getActivityState(TourActivity act, StateId stateId) { public State getActivityState(TourActivity act, StateId stateId) {
if(!activityStates.containsKey(act)){ if(!activityStates_.containsKey(act)){
return getDefaultActState(stateId,act); return getDefaultActivityState_(act,stateId,State.class);
} }
States actStates = activityStates.get(act); States_ actStates = activityStates_.get(act);
State state = actStates.getState(stateId); State state = actStates.getState(stateId, State.class);
if(state == null){ if(state == null){
return getDefaultActState(stateId,act); return getDefaultActivityState_(act,stateId,State.class);
} }
return state; return state;
} }
void putInternalActivityState(TourActivity act, StateId stateId, State state){ @Override
if(!activityStates.containsKey(act)){ public <T> T getActivityState(TourActivity act, StateId stateId, Class<T> type) {
activityStates.put(act, StateFactory.createStates()); if(!activityStates_.containsKey(act)){
return getDefaultActivityState_(act, stateId, type);
} }
States actStates = activityStates.get(act); States_ states = activityStates_.get(act);
actStates.putState(stateId, state); T state = states.getState(stateId, type);
if(state == null) return getDefaultActivityState_(act, stateId, type);
return state;
} }
public void putActivityState(TourActivity act, StateId stateId, State state){ private <T> T getDefaultActivityState_(TourActivity act, StateId stateId,Class<T> type) {
if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString()); if(defaultActivityStates_.containsKey(stateId)){
putInternalActivityState(act, stateId, state); return type.cast(defaultActivityStates_.get(stateId));
} }
if(stateId.equals(StateFactory.EARLIEST_OPERATION_START_TIME)){
void putInternalRouteState(VehicleRoute route, StateId stateId, State state){ return type.cast(StateFactory.createState(act.getTheoreticalEarliestOperationStartTime()));
if(!vehicleRouteStates.containsKey(route)){
vehicleRouteStates.put(route, StateFactory.createStates());
} }
States routeStates = (States) vehicleRouteStates.get(route); if(stateId.equals(StateFactory.LATEST_OPERATION_START_TIME)){
routeStates.putState(stateId, state); return type.cast(StateFactory.createState(act.getTheoreticalLatestOperationStartTime()));
} }
return null;
public void putRouteState(VehicleRoute route, StateId stateId, State state){
if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString());
putInternalRouteState(route, stateId, state);
} }
@Override @Override
public State getRouteState(VehicleRoute route, StateId stateId) { public <T> T getRouteState(VehicleRoute route, StateId stateId, Class<T> type) {
if(!vehicleRouteStates.containsKey(route)){ if(!vehicleRouteStates_.containsKey(route)){
return getDefaultRouteState(stateId,route); return getDefaultRouteState_(stateId, type);
} }
States routeStates = vehicleRouteStates.get(route); States_ states = vehicleRouteStates_.get(route);
State state = routeStates.getState(stateId); T state = states.getState(stateId, type);
if(state == null) return getDefaultRouteState_(stateId, type);
return state;
}
private <T> T getDefaultRouteState_(StateId stateId, Class<T> type) {
if(defaultRouteStates_.containsKey(stateId)){
return type.cast(defaultRouteStates_.get(stateId));
}
return null;
}
@Deprecated
public void putActivityState(TourActivity act, StateId stateId, State state){
putActivityState_(act, stateId, State.class, state);
}
public <T> void putActivityState_(TourActivity act, StateId stateId, Class<T> type, T state){
if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString());
putInternalActivityState_(act, stateId, type, state);
}
@Deprecated
void putInternalActivityState(TourActivity act, StateId stateId, State state){
putInternalActivityState_(act, stateId, State.class, state);
}
<T> void putInternalActivityState_(TourActivity act, StateId stateId, Class<T> type, T state){
if(!activityStates_.containsKey(act)){
activityStates_.put(act, new States_());
}
States_ actStates = activityStates_.get(act);
actStates.putState(stateId, type, state);
}
@Deprecated
void putInternalRouteState(VehicleRoute route, StateId stateId, State state){
putInternalRouteState_(route, stateId, State.class, state);
}
<T> void putInternalRouteState_(VehicleRoute route, StateId stateId, Class<T> type, T state){
if(!vehicleRouteStates_.containsKey(route)){
vehicleRouteStates_.put(route, new States_());
}
States_ routeStates = vehicleRouteStates_.get(route);
routeStates.putState(stateId, type, state);
}
@Deprecated
public void putRouteState(VehicleRoute route, StateId stateId, State state){
putRouteState_(route, stateId, State.class, state);
}
public <T> void putRouteState_(VehicleRoute route, StateId stateId, Class<T> type, T state){
if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString());
putInternalRouteState_(route, stateId, type, state);
}
@Deprecated
@Override
public State getRouteState(VehicleRoute route, StateId stateId) {
if(!vehicleRouteStates_.containsKey(route)){
return getDefaultRouteState_(stateId,State.class);
}
States_ routeStates = vehicleRouteStates_.get(route);
State state = routeStates.getState(stateId,State.class);
if(state == null){ if(state == null){
return getDefaultRouteState(stateId, route); return getDefaultRouteState_(stateId, State.class);
} }
return state; return state;
} }
@ -220,28 +330,6 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
insertionListeners.removeListener(insertionListener); insertionListeners.removeListener(insertionListener);
} }
private State getDefaultActState(StateId stateId, TourActivity act){
if(stateId.equals(StateFactory.LOAD)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.COSTS)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.DURATION)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.EARLIEST_OPERATION_START_TIME)) return StateFactory.createState(act.getTheoreticalEarliestOperationStartTime());
if(stateId.equals(StateFactory.LATEST_OPERATION_START_TIME)) return StateFactory.createState(act.getTheoreticalLatestOperationStartTime());
if(stateId.equals(StateFactory.FUTURE_MAXLOAD)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.PAST_MAXLOAD)) return StateFactory.createState(0);
if(defaultActivityStates.containsKey(stateId)) return defaultActivityStates.get(stateId);
return null;
}
private State getDefaultRouteState(StateId stateId, VehicleRoute route){
if(stateId.equals(StateFactory.MAXLOAD)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.LOAD)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.LOAD_AT_END)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.LOAD_AT_BEGINNING)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.COSTS)) return StateFactory.createState(0);
if(stateId.equals(StateFactory.DURATION)) return StateFactory.createState(0);
if(defaultRouteStates.containsKey(stateId)) return defaultRouteStates.get(stateId);
return null;
}
@Override @Override
public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) {
@ -306,4 +394,6 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
addActivityVisitor(new UpdateTimeWindow(this, routingCosts)); addActivityVisitor(new UpdateTimeWindow(this, routingCosts));
} }
} }
} }

5
jsprit-core/src/main/java/jsprit/core/problem/solution/route/state/RouteAndActivityStateGetter.java
View file

@ -23,9 +23,14 @@ import jsprit.core.problem.solution.route.state.StateFactory.StateId;
public interface RouteAndActivityStateGetter { public interface RouteAndActivityStateGetter {
@Deprecated
public State getActivityState(TourActivity act, StateId stateId); public State getActivityState(TourActivity act, StateId stateId);
@Deprecated
public State getRouteState(VehicleRoute route, StateId stateId); public State getRouteState(VehicleRoute route, StateId stateId);
public <T> T getActivityState(TourActivity act, StateId stateId, Class<T> type);
public <T> T getRouteState(VehicleRoute route, StateId stateId, Class<T> type);
} }

26
jsprit-core/src/test/java/jsprit/core/algorithm/state/GenericsTest.java
View file

@ -6,21 +6,23 @@ import java.util.Map;
import jsprit.core.problem.Capacity; import jsprit.core.problem.Capacity;
import jsprit.core.problem.job.Job; import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Service; import jsprit.core.problem.job.Service;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.solution.route.state.StateFactory.State;
public class GenericsTest { public class GenericsTest {
static class State<T> { // static class State<T> {
Class<T> type; // Class<T> type;
T state; // T state;
public State(Class<T> type, T state) { // public State(Class<T> type, T state) {
super(); // super();
this.type = type; // this.type = type;
this.state = state; // this.state = state;
} // }
//
} // }
static class States { static class States {
@ -48,10 +50,14 @@ public class GenericsTest {
String state = states.getState("state", String.class); String state = states.getState("state", String.class);
Job service = states.getState("job", Job.class); Job service = states.getState("job", Job.class);
Capacity capacity = states.getState("cap", Capacity.class); Capacity capacity = states.getState("cap", Capacity.class);
states.putState("st", State.class, StateFactory.createState(10.));
System.out.println(load); System.out.println(load);
System.out.println(state); System.out.println(state);
System.out.println(service); System.out.println(service);
System.out.println(capacity); System.out.println(capacity);
System.out.println(states.getState("st", State.class).toDouble());
} }

124
jsprit-core/src/test/java/jsprit/core/algorithm/state/StateManagerTest.java
View file

@ -1,36 +1,146 @@
package jsprit.core.algorithm.state; package jsprit.core.algorithm.state;
import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
import jsprit.core.problem.Capacity;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.solution.route.state.StateFactory.State;
import jsprit.core.problem.solution.route.state.StateFactory.StateId;
import org.junit.Test; import org.junit.Test;
public class StateManagerTest { public class StateManagerTest {
@SuppressWarnings("deprecation")
@Test @Test
public void whenInternalRouteStateIsSet_itMustBeSetCorrectly(){ public void whenInternalRouteStateIsSet_itMustBeSetCorrectly(){
VehicleRoute route = mock(VehicleRoute.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
State state = StateFactory.createState(1.);
stateManager.putInternalRouteState(route, id, state);
assertEquals(1.,stateManager.getRouteState(route, id).toDouble(),0.01);
} }
@SuppressWarnings("deprecation")
@Test @Test
public void whenRouteStateIsSet_itMustBeSetCorrectly(){ public void whenRouteStateIsSet_itMustBeSetCorrectly(){
VehicleRoute route = mock(VehicleRoute.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
State state = StateFactory.createState(1.);
stateManager.putRouteState(route, id, state);
assertEquals(1.,stateManager.getRouteState(route, id).toDouble(),0.01);
} }
@Test
public void whenRouteStateIsSetWithGenericMethod_itMustBeSetCorrectly(){
VehicleRoute route = mock(VehicleRoute.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
State state = StateFactory.createState(1.);
stateManager.putRouteState_(route, id, State.class, state);
assertEquals(1.,stateManager.getRouteState(route, id, State.class).toDouble(),0.01);
}
@Test
public void whenRouteStateIsSetWithGenericMethodAndBoolean_itMustBeSetCorrectly(){
VehicleRoute route = mock(VehicleRoute.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
boolean routeIsRed = true;
stateManager.putRouteState_(route, id, Boolean.class, routeIsRed);
assertTrue(stateManager.getRouteState(route, id, Boolean.class));
}
@Test
public void whenRouteStateIsSetWithGenericMethodAndInteger_itMustBeSetCorrectly(){
VehicleRoute route = mock(VehicleRoute.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
int load = 3;
stateManager.putRouteState_(route, id, Integer.class, load);
int getLoad = stateManager.getRouteState(route, id, Integer.class);
assertEquals(3, getLoad);
}
@Test
public void whenRouteStateIsSetWithGenericMethodAndCapacity_itMustBeSetCorrectly(){
VehicleRoute route = mock(VehicleRoute.class);
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);
Capacity getCap = stateManager.getRouteState(route, id, Capacity.class);
assertEquals(500, getCap.get(0));
}
@SuppressWarnings("deprecation")
@Test @Test
public void whenInternalActivityStateIsSet_itMustBeSetCorrectly(){ public void whenInternalActivityStateIsSet_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
State state = StateFactory.createState(1.);
stateManager.putInternalActivityState(activity, id, state);
assertEquals(1.,stateManager.getActivityState(activity, id).toDouble(),0.01);
} }
@SuppressWarnings("deprecation")
@Test @Test
public void whenActivityStateIsSet_itMustBeSetCorrectly(){ public void whenActivityStateIsSet_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
State state = StateFactory.createState(1.);
stateManager.putActivityState(activity, id, state);
assertEquals(1.,stateManager.getActivityState(activity, id).toDouble(),0.01);
} }
@Test @Test
public void whenDefaultActivityStateIsSet_itMustBeSetCorrectly(){ public void whenActivityStateIsSetWithGenericMethod_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
State state = StateFactory.createState(1.);
stateManager.putActivityState_(activity, id, State.class, state);
assertEquals(1.,stateManager.getActivityState(activity, id, State.class).toDouble(),0.01);
} }
@Test @Test
public void whenDefaultRouteStateIsSet_itMustBeSetCorrectly(){ public void whenActivityStateIsSetWithGenericMethodAndBoolean_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
boolean routeIsRed = true;
stateManager.putActivityState_(activity, id, Boolean.class, routeIsRed);
assertTrue(stateManager.getActivityState(activity, id, Boolean.class));
}
@Test
public void whenActivityStateIsSetWithGenericMethodAndInteger_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState");
int load = 3;
stateManager.putActivityState_(activity, id, Integer.class, load);
int getLoad = stateManager.getActivityState(activity, id, Integer.class);
assertEquals(3, getLoad);
}
@Test
public void whenActivityStateIsSetWithGenericMethodAndCapacity_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class);
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);
Capacity getCap = stateManager.getActivityState(activity, id, Capacity.class);
assertEquals(500, getCap.get(0));
} }
} }