Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package rinde.sim.pdptw.central;
  import static;
  import static;
 import java.util.List;
 import java.util.Set;
Provides methods for validating input to and output from Solvers. Also provides wrap(rinde.sim.pdptw.central.Solver) method which decorates any solver such that both inputs and outputs are validated every time it is is called.

Rinde van Lon <>
 public final class SolverValidator {
   private SolverValidator() {}

Decorates the original Solver such that both the inputs to the solver and the outputs from the solver are validated. When an invalid input or output is detected a is thrown.

delegate The Solver that will be used for the actual solving.
The wrapped solver.
   public static Solver wrap(Solver delegate) {
     return new SolverValidator.Validator(delegate);
   public static SupplierRng<Solverwrap(SupplierRng<? extends Solversup) {
     return new SolverValidatorSupplier(sup);
   private static final class SolverValidatorSupplier extends
       DefaultSupplierRng<Solver> {
     private final SupplierRng<? extends Solversupplier;
     SolverValidatorSupplier(SupplierRng<? extends Solversup) {
        = sup;
     public Solver get(long seed) {
       return SolverValidator.wrap(.get(seed));

Validates the inputs for Solver.solve(rinde.sim.pdptw.central.GlobalStateObject) method. If the input is not correct an java.lang.IllegalArgumentException is thrown.

state The state to validate.
The state.
   public static GlobalStateObject validateInputs(GlobalStateObject state) {
     checkArgument(state.time >= 0, "Time must be >= 0, is %s."state.time);
     final Set<ParcelDTOinventoryParcels = newHashSet();
     final boolean routeIsPresent = state.vehicles.get(0)..isPresent();
     final Set<ParcelDTOallParcels = newHashSet();
     for (final VehicleStateObject vs : state.vehicles) {
           vs.route.isPresent() == routeIsPresent,
           "Either a route should be present for all vehicles, or no route should be present for all vehicles.");
       if (vs.route.isPresent()) {
         for (final ParcelDTO p : vs.route.get()) {
               "Found parcel which is already present in the route of another vehicle. Parcel %s.",
     for (int i = 0; i < state.vehicles.size(); i++) {
       final VehicleStateObject vs = state.vehicles.get(i);
       checkArgument(vs.remainingServiceTime >= 0,
           "Remaining service time must be >= 0, is %s.",
       checkArgument(vs.speed > 0, "Speed must be positive, is %s."vs.speed);
       final Set<ParcelDTOintersection = Sets.intersection(
          "Parcels can not be available AND in the inventory of a vehicle, found: %s.",
      final Set<ParcelDTOinventoryIntersection = Sets.intersection(
          "Parcels can not be in the inventory of two vehicles at the same time, found: %s.",
      // if the destination parcel is not available, it must be in the
      // cargo of the vehicle
      if (vs.destination != null) {
        final boolean isAvailable = state.availableParcels
        final boolean isInCargo = vs.contents.contains(vs.destination);
            isAvailable != isInCargo,
            "Destination must be either available (%s) or in the current vehicle's cargo (%s), but not both (i.e. XOR). Destination: %s, vehicle: %s (out of %s), remaining service time: %s.",
      if (vs.route.isPresent()) {
    return state;

Validate the route of a vehicle.

vs The vehicle to check.
i The index of the vehicle, only used to generate nice error messages.
java.lang.IllegalArgumentException if the route is not correct.
  public static void checkRoute(VehicleStateObject vsint i) {
        "Vehicle %s's route doesn't contain all locations it has in cargo. Route: %s, cargo: %s.",
        ivs.route.get(), vs.contents);
    if (vs.destination != null) {
          && vs.route.get().get(0) == vs.destination,
          "First location in route must equal destination (%s), route is: %s.",
    for (final ParcelDTO dp : vs.route.get()) {
      final int freq = Collections.frequency(vs.route.get(), dp);
      if (vs.contents.contains(dp)) {
            freq == 1,
            "A parcel already in cargo should occur once in the route, found %s instance(s). Parcel: %s, route: %s.",
      } else {
            freq == 2,
            "A parcel that is still available should occur twice in the route, found %s instance(s). Parcel: %s, route: %s.",
            freqdpvs.route.get(), vs.remainingServiceTime);

Validates the routes that are produced by a Solver. If one of the routes is infeasible an java.lang.IllegalArgumentException is thrown.

routes The routes that are validated.
state Parameter as specified by Solver.solve(rinde.sim.pdptw.central.GlobalStateObject).
The routes.
      ImmutableList<ImmutableList<ParcelDTO>> routesGlobalStateObject state) {
        routes.size() == state.vehicles.size(),
        "There must be exactly one route for every vehicle, found %s routes with %s vehicles.",
        routes.size(), state.vehicles.size());
    final Set<ParcelDTOinputParcels = newHashSet(state.availableParcels);
    final Set<ParcelDTOoutputParcels = newHashSet();
    for (int i = 0; i < routes.size(); i++) {
      final List<ParcelDTOroute = routes.get(i);
      final Set<ParcelDTOrouteSet = ImmutableSet.copyOf(route);
          "The route of vehicle %s doesn't visit all parcels in its cargo."i);
      if (state.vehicles.get(i). != null) {
            route.get(0) == state.vehicles.get(i).,
            "The route of vehicle %s should start with its current destination: %s.",
      for (final ParcelDTO p : route) {
            "Found a parcel which is already in another route: %s."p);
        final int frequency = Collections.frequency(routep);
        if (state.availableParcels.contains(p)) {
          // if the parcel is available, it needs to occur twice in
          // the route (once for pickup, once for delivery).
              frequency == 2,
              "Route %s: a parcel that is picked up needs to be delivered as well, so it should occur twice in the route, found %s occurence(s) of parcel %s.",
        } else {
              "The parcel in this route is not available, which means it should be in the contents of this vehicle. Parcel: %s.",
              frequency == 1,
              "A parcel that is already in cargo should occur once in the route, found %s occurences of parcel %s.",
        "The number of distinct parcels in the routes should equal the number of parcels in the input, parcels that should be added in routes: %s, parcels that should be removed from routes: %s.",
    return routes;
  private static class Validator implements Solver {
    private final Solver delegateSolver;
    Validator(Solver delegate) {
       = delegate;
      return validateOutputs(.solve(validateInputs(state)), state);
New to GrepCode? Check out our FAQ X