Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package rinde.sim.pdptw.fabrirecht;
  
  import static com.google.common.collect.Lists.newArrayList;
  import static com.google.common.collect.Sets.newLinkedHashSet;
  
 import java.io.Reader;
 import java.io.Writer;
 import java.util.List;
 import java.util.Set;
 
 

Author(s):
Rinde van Lon <rinde.vanlon@cs.kuleuven.be>
 
 public class FabriRechtParser {
 
   private final static Gson gson = initialize();
 
   public static FabriRechtScenario parse(String coordinateFile,
       String ordersFilethrows IOException {
         .);
 
     final BufferedReader coordinateFileReader = new BufferedReader(
         new FileReader(coordinateFile));
     final BufferedReader ordersFileReader = new BufferedReader(new FileReader(
         ordersFile));
 
     final List<Pointcoordinates = newArrayList();
     String line;
     int coordinateCounter = 0;
     int minX = .;
     int minY = .;
     int maxX = .;
     int maxY = .;
     while ((line = coordinateFileReader.readLine()) != null) {
       final String[] parts = line.split(";");
       if (Integer.parseInt(parts[0]) != coordinateCounter) {
         throw new IllegalArgumentException(
             "The coordinate file seems to be in an unrecognized format.");
       }
       final int x = Integer.parseInt(parts[1]);
       final int y = Integer.parseInt(parts[2]);
 
       minX = Math.min(xminX);
       minY = Math.min(yminY);
       maxX = Math.max(xmaxX);
       maxY = Math.max(ymaxY);
 
       coordinates.add(new Point(xy));
       if (Integer.parseInt(parts[0]) == 0) {
         sb.addEvent(new AddDepotEvent(0, new Point(xy)));
       }
       coordinateCounter++;
     }
     coordinateFileReader.close();
 
     final Point min = new Point(minXminY);
     final Point max = new Point(maxXmaxY);
 
     //
     // sb.addMultipleEvents(0, 10, PDPScenarioEvent.ADD_DEPOT);
 
     // Anzahl der Fahrzeuge; Kapazität; untere Zeitfenstergrenze; obere
     // Zeitfenstergrenze
    final String[] firstLine = ordersFileReader.readLine().split(";");
    final int numVehicles = Integer.parseInt(firstLine[0]);
    final int capacity = Integer.parseInt(firstLine[1]);
    final long startTime = Long.parseLong(firstLine[2]);
    final long endTime = Long.parseLong(firstLine[3]);
    final TimeWindow timeWindow = new TimeWindow(startTimeendTime);
    sb.addEvent(new TimedEvent(.endTime));
    // for (int i = 0; i < numVehicles; i++) {
    // sb.addEvent(new AddVehicleEvent(0, new VehicleDTO(coordinates.get(0),
    // 1.0, capacity, timeWindow)));
    // }
    final VehicleDTO defaultVehicle = new VehicleDTO(coordinates.get(0), 1.0,
        capacitytimeWindow);
    // Nr. des Pickup-Orts; Nr. des Delivery-Orts; untere Zeitfenstergrenze
    // Pickup; obere Zeitfenstergrenze Pickup; untere Zeitfenstergrenze
    // Delivery; obere Zeitfenstergrenze Delivery; benötigte Kapazität;
    // Anrufzeit; Servicezeit Pickup; Servicezeit Delivery
    while ((line = ordersFileReader.readLine()) != null) {
      final String[] parts = line.split(";");
      final int neededCapacity = 1; // Integer.parseInt(parts[6]);
      final ParcelDTO o = new ParcelDTO(coordinates.get(Integer
          .parseInt(parts[0])), coordinates.get(Integer.parseInt(parts[1])),
          new TimeWindow(Long.parseLong(parts[2]), Long.parseLong(parts[3])),
          new TimeWindow(Long.parseLong(parts[4]), Long.parseLong(parts[5])),
          neededCapacity, Long.parseLong(parts[7]), Long.parseLong(parts[8]),
          Long.parseLong(parts[9]));
      sb.addEvent(new AddParcelEvent(o));
    }
    ordersFileReader.close();
    return sb.build(new ScenarioCreator<FabriRechtScenario>() {
      @Override
      public FabriRechtScenario create(List<TimedEventeventList,
          Set<Enum<?>> eventTypes) {
        return new FabriRechtScenario(eventListeventTypesminmax,
            timeWindowdefaultVehicle);
      }
    });
  }
  public static String toJson(FabriRechtScenario scenario) {
    return .toJson(scenario);
  }
  public static void toJson(FabriRechtScenario scenarioWriter writer)
      throws IOException {
    .toJson(scenarioFabriRechtScenario.classwriter);
    writer.close();
  }
  public static FabriRechtScenario fromJson(String json) {
    return .fromJson(jsonFabriRechtScenario.class);
  }
  public static FabriRechtScenario fromJson(String jsonint numVehicles,
      int vehicleCapacity) {
    final FabriRechtScenario scen = fromJson(json);
    final List<TimedEventevents = newArrayList();
    for (int i = 0; i < numVehiclesi++) {
      events.add(new AddVehicleEvent(0, new VehicleDTO(
          scen.defaultVehicle.startPositionscen.defaultVehicle.speed,
          vehicleCapacityscen.defaultVehicle.availabilityTimeWindow)));
    }
    events.addAll(scen.asList());
    return new FabriRechtScenario(eventsscen.getPossibleEventTypes(),
        scen.minscen.maxscen.timeWindowscen.defaultVehicle);
  }
  public static FabriRechtScenario fromJson(Reader reader) {
    return .fromJson(readerFabriRechtScenario.class);
  }
  public static FabriRechtScenario fromJson(Reader readerint numVehicles,
      int vehicleCapacity) {
    final FabriRechtScenario scen = fromJson(reader);
    final List<TimedEventevents = newArrayList();
    for (int i = 0; i < numVehiclesi++) {
      events.add(new AddVehicleEvent(0, new VehicleDTO(
          scen.defaultVehicle.startPositionscen.defaultVehicle.speed,
          vehicleCapacityscen.defaultVehicle.availabilityTimeWindow)));
    }
    events.addAll(scen.asList());
    return new FabriRechtScenario(eventsscen.getPossibleEventTypes(),
        scen.minscen.maxscen.timeWindowscen.defaultVehicle);
  }
  static class EnumDeserializer implements JsonDeserializer<Set<Enum<?>>>,
      JsonSerializer<Set<Enum<?>>> {
    @Override
    public Set<Enum<?>> deserialize(JsonElement jsonType typeOfT,
        JsonDeserializationContext contextthrows JsonParseException {
      final Set<Enum<?>> eventTypes = newLinkedHashSet();
      final List<Stringlist = context
          .deserialize(jsonnew TypeToken<List<String>>() {}.getType());
      for (final String s : list) {
        eventTypes.add(PDPScenarioEvent.valueOf(s));
      }
      return eventTypes;
    }
    @Override
    public JsonElement serialize(Set<Enum<?>> srcType typeOfSrc,
        JsonSerializationContext context) {
      final List<Stringlist = newArrayList();
      for (final Enum<?> e : src) {
        list.add(e.name());
      }
      return context.serialize(srcnew TypeToken<List<String>>() {}.getType());
    }
  }
  static class PointAdapter extends TypeAdapter<Point> {
    @Override
    public Point read(JsonReader readerthrows IOException {
      if (reader.peek() == .) {
        reader.nextNull();
        return null;
      }
      final String xy = reader.nextString();
      final String[] parts = xy.split(",");
      final double x = Double.parseDouble(parts[0]);
      final double y = Double.parseDouble(parts[1]);
      return new Point(xy);
    }
    @Override
    public void write(JsonWriter writerPoint valuethrows IOException {
      if (value == null) {
        writer.nullValue();
        return;
      }
      final String xy = value.x + "," + value.y;
      writer.value(xy);
    }
  }
  static class TimeWindowAdapter extends TypeAdapter<TimeWindow> {
    @Override
    public TimeWindow read(JsonReader readerthrows IOException {
      if (reader.peek() == .) {
        reader.nextNull();
        return null;
      }
      final String xy = reader.nextString();
      final String[] parts = xy.split(",");
      final long x = Long.parseLong(parts[0]);
      final long y = Long.parseLong(parts[1]);
      return new TimeWindow(xy);
    }
    @Override
    public void write(JsonWriter writerTimeWindow valuethrows IOException {
      if (value == null) {
        writer.nullValue();
        return;
      }
      final String xy = value.begin + "," + value.end;
      writer.value(xy);
    }
  }
  static class TimedEventDeserializer implements JsonDeserializer<TimedEvent> {
    @Override
    public TimedEvent deserialize(JsonElement jsonType typeOfT,
        JsonDeserializationContext contextthrows JsonParseException {
      final long time = json.getAsJsonObject().get("time").getAsLong();
      final PDPScenarioEvent type = PDPScenarioEvent.valueOf(json
          .getAsJsonObject().get("eventType").getAsJsonObject().get("name")
          .getAsString());
      switch (type) {
      case :
        return new AddDepotEvent(time, (Pointcontext.deserialize(json
            .getAsJsonObject().get("position"), Point.class));
      case :
        return new AddVehicleEvent(time, (VehicleDTOcontext.deserialize(json
            .getAsJsonObject().get("vehicleDTO"), VehicleDTO.class));
      case :
        return new AddParcelEvent((ParcelDTOcontext.deserialize(json
            .getAsJsonObject().get("parcelDTO"), ParcelDTO.class));
      case :
        return new TimedEvent(typetime);
      }
      throw new IllegalStateException();
    }
  }
  private final static Gson initialize() {
    final Type collectionType = new TypeToken<Set<Enum<?>>>() {}.getType();
    final GsonBuilder builder = new GsonBuilder();
    // builder.setPrettyPrinting();
    builder
        .registerTypeAdapter(Point.classnew PointAdapter())
        .registerTypeAdapter(TimeWindow.classnew TimeWindowAdapter())
        .registerTypeAdapter(collectionTypenew EnumDeserializer());
    return builder.create();
  }
New to GrepCode? Check out our FAQ X