From 6f533d8f20de6eb25ed3243d45b11972a17fa202 Mon Sep 17 00:00:00 2001 From: oblonski <4sschroeder@gmail.com> Date: Sun, 23 Feb 2014 22:02:29 +0100 Subject: [PATCH] refined StateManager to deal with generic states --- .../core/algorithm/state/StateManager.java | 220 ++++++++++++------ .../state/RouteAndActivityStateGetter.java | 5 + .../core/algorithm/state/GenericsTest.java | 26 ++- .../algorithm/state/StateManagerTest.java | 126 +++++++++- 4 files changed, 294 insertions(+), 83 deletions(-) diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java index 12dad6d9..03d11612 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java @@ -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.State; 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 { - private Map vehicleRouteStates = new HashMap(); + static class States_ { + + private Map states = new HashMap(); + + public void putState(StateId id, Class type, T state){ + states.put(id, type.cast(state)); + } + + public T getState(StateId id, Class type){ + if(states.containsKey(id)){ + T s = type.cast(states.get(id)); + return s; + } + return null; + } + + } + + private Map vehicleRouteStates_ = new HashMap(); - private Map activityStates = new HashMap(); + private Map activityStates_ = new HashMap(); private RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor(); @@ -66,9 +83,9 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart private Collection updaters = new ArrayList(); - private Map defaultRouteStates = new HashMap(); + private Map defaultRouteStates_ = new HashMap(); - private Map defaultActivityStates = new HashMap(); + private Map defaultActivityStates_ = new HashMap(); private VehicleRoutingTransportCosts routingCosts; @@ -79,76 +96,169 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart public StateManager(VehicleRoutingProblem vrp) { super(); 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){ this.routingCosts = routingCosts; + addDefaultStates(); } - + @Deprecated public void addDefaultRouteState(StateId stateId, State defaultState){ - if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString()); - defaultRouteStates.put(stateId, defaultState); + addDefaultRouteState(stateId, State.class, defaultState); } - public void addDefaultActivityState(StateId stateId, State defaultState){ + public void addDefaultRouteState(StateId stateId, Class type, T defaultState){ 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 void addDefaultActivityState(StateId stateId, Class type, T defaultState){ + if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString()); + defaultActivityStates_.put(stateId, type.cast(defaultState)); } public void clear(){ - vehicleRouteStates.clear(); - activityStates.clear(); + vehicleRouteStates_.clear(); + activityStates_.clear(); } + @Deprecated @Override public State getActivityState(TourActivity act, StateId stateId) { - if(!activityStates.containsKey(act)){ - return getDefaultActState(stateId,act); + if(!activityStates_.containsKey(act)){ + return getDefaultActivityState_(act,stateId,State.class); } - States actStates = activityStates.get(act); - State state = actStates.getState(stateId); + States_ actStates = activityStates_.get(act); + State state = actStates.getState(stateId, State.class); if(state == null){ - return getDefaultActState(stateId,act); + return getDefaultActivityState_(act,stateId,State.class); } return state; } - void putInternalActivityState(TourActivity act, StateId stateId, State state){ - if(!activityStates.containsKey(act)){ - activityStates.put(act, StateFactory.createStates()); + @Override + public T getActivityState(TourActivity act, StateId stateId, Class type) { + if(!activityStates_.containsKey(act)){ + return getDefaultActivityState_(act, stateId, type); } - States actStates = activityStates.get(act); - actStates.putState(stateId, state); + States_ states = activityStates_.get(act); + 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){ - if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString()); - putInternalActivityState(act, stateId, state); - } - - void putInternalRouteState(VehicleRoute route, StateId stateId, State state){ - if(!vehicleRouteStates.containsKey(route)){ - vehicleRouteStates.put(route, StateFactory.createStates()); + private T getDefaultActivityState_(TourActivity act, StateId stateId,Class type) { + if(defaultActivityStates_.containsKey(stateId)){ + return type.cast(defaultActivityStates_.get(stateId)); } - States routeStates = (States) vehicleRouteStates.get(route); - routeStates.putState(stateId, state); - } - - public void putRouteState(VehicleRoute route, StateId stateId, State state){ - if(StateFactory.isReservedId(stateId)) StateFactory.throwReservedIdException(stateId.toString()); - putInternalRouteState(route, stateId, state); + if(stateId.equals(StateFactory.EARLIEST_OPERATION_START_TIME)){ + return type.cast(StateFactory.createState(act.getTheoreticalEarliestOperationStartTime())); + } + if(stateId.equals(StateFactory.LATEST_OPERATION_START_TIME)){ + return type.cast(StateFactory.createState(act.getTheoreticalLatestOperationStartTime())); + } + return null; } @Override - public State getRouteState(VehicleRoute route, StateId stateId) { - if(!vehicleRouteStates.containsKey(route)){ - return getDefaultRouteState(stateId,route); + public T getRouteState(VehicleRoute route, StateId stateId, Class type) { + if(!vehicleRouteStates_.containsKey(route)){ + return getDefaultRouteState_(stateId, type); } - States routeStates = vehicleRouteStates.get(route); - State state = routeStates.getState(stateId); + States_ states = vehicleRouteStates_.get(route); + T state = states.getState(stateId, type); + if(state == null) return getDefaultRouteState_(stateId, type); + return state; + } + + private T getDefaultRouteState_(StateId stateId, Class 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 void putActivityState_(TourActivity act, StateId stateId, Class 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); + } + + void putInternalActivityState_(TourActivity act, StateId stateId, Class 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); + } + + void putInternalRouteState_(VehicleRoute route, StateId stateId, Class 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 void putRouteState_(VehicleRoute route, StateId stateId, Class 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){ - return getDefaultRouteState(stateId, route); + return getDefaultRouteState_(stateId, State.class); } return state; } @@ -220,29 +330,7 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart 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 public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { // log.debug("insert " + job2insert + " in " + inRoute); @@ -306,4 +394,6 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart addActivityVisitor(new UpdateTimeWindow(this, routingCosts)); } } + + } diff --git a/jsprit-core/src/main/java/jsprit/core/problem/solution/route/state/RouteAndActivityStateGetter.java b/jsprit-core/src/main/java/jsprit/core/problem/solution/route/state/RouteAndActivityStateGetter.java index 7de0f4f5..8487eadf 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/solution/route/state/RouteAndActivityStateGetter.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/solution/route/state/RouteAndActivityStateGetter.java @@ -23,9 +23,14 @@ import jsprit.core.problem.solution.route.state.StateFactory.StateId; public interface RouteAndActivityStateGetter { + @Deprecated public State getActivityState(TourActivity act, StateId stateId); + @Deprecated public State getRouteState(VehicleRoute route, StateId stateId); + public T getActivityState(TourActivity act, StateId stateId, Class type); + + public T getRouteState(VehicleRoute route, StateId stateId, Class type); } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/GenericsTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/GenericsTest.java index 4708d8a5..57e417a6 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/state/GenericsTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/state/GenericsTest.java @@ -6,21 +6,23 @@ import java.util.Map; import jsprit.core.problem.Capacity; import jsprit.core.problem.job.Job; 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 { - static class State { - Class type; - T state; - public State(Class type, T state) { - super(); - this.type = type; - this.state = state; - } - - } +// static class State { +// Class type; +// T state; +// public State(Class type, T state) { +// super(); +// this.type = type; +// this.state = state; +// } +// +// } static class States { @@ -48,10 +50,14 @@ public class GenericsTest { String state = states.getState("state", String.class); Job service = states.getState("job", Job.class); Capacity capacity = states.getState("cap", Capacity.class); + + states.putState("st", State.class, StateFactory.createState(10.)); + System.out.println(load); System.out.println(state); System.out.println(service); System.out.println(capacity); + System.out.println(states.getState("st", State.class).toDouble()); } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/StateManagerTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/StateManagerTest.java index c0282c08..e5624b14 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/state/StateManagerTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/state/StateManagerTest.java @@ -1,36 +1,146 @@ 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; public class StateManagerTest { + @SuppressWarnings("deprecation") @Test 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 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 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 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 - 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 - 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)); } }