Beispiel #1
1
  public static void main(String[] args) {

    int[] input = {2, 1, 4, 3, 6, 10, 8, 5, 9, 7};

    List list1 = new Q(input);
    List list2 = new I(input);
    List list3 = new B(input);

    list1.sort();
    list2.sort();
    list3.sort();
  }
Beispiel #2
1
  public void writeTasks(OutputStream output) {
    try {
      output.write("[\n".getBytes());
      boolean needComma = false;
      File[] files = tasksDirectory.listFiles((FileFilter) FileFilterUtils.directoryFileFilter());
      List<Integer> numbers = new ArrayList<>();
      for (File directory : files) {
        try {
          numbers.add(Integer.valueOf(directory.getName()));
        } catch (Throwable ignored) {

        }
      }
      numbers.sort(Comparator.<Integer>reverseOrder());
      numbers = numbers.subList(0, Math.min(100, numbers.size()));
      for (int taskId : numbers) {
        File infoFile = new File(new File(tasksDirectory, String.valueOf(taskId)), "info.json");
        if (!infoFile.exists()) {
          continue;
        }
        if (needComma) {
          output.write(",\n".getBytes());
        } else {
          needComma = true;
        }
        try (FileInputStream fis = new FileInputStream(infoFile)) {
          IOUtils.copy(fis, output);
        }
      }
      output.write("]\n".getBytes());
    } catch (IOException e) {
      throw Throwables.propagate(e);
    }
  }
Beispiel #3
1
 void sortTransactionByDate() {
   List<Transaction> tr = new ArrayList<Transaction>(transactions.values());
   tr.sort(Transaction.DateComparator);
   for (Transaction t : tr) {
     t.displayTransaction();
   }
 }
Beispiel #4
1
 void sortbyAccount() {
   List<Accounts> ac = new ArrayList<Accounts>(accounts.values());
   ac.sort(Accounts.AccountComparator);
   for (Accounts a : ac) {
     a.dispaly();
   }
 }
Beispiel #5
1
  static void lambdaTest() {
    Runnable r = () -> System.out.print("hello lambda");
    r.run();
    List<String> list = Arrays.asList("t1", "t2", "t334", "t4", "t567");
    list.parallelStream().filter(s -> s.length() == 2).forEach(System.out::println);

    list = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9", "15", "17");
    Map<String, Integer> integers =
        list.stream()
            .map(Integer::new)
            .filter(e -> e % 2 != 0)
            .distinct()
            .collect(Collectors.toMap(Object::toString, e -> e));
    System.out.println(integers);
    Stream.generate(Math::random).limit(10).forEach(System.out::println);

    new Thread(() -> System.out.println("hello lambda")).start();
    new Thread(
            () -> {
              System.out.println("hello lambda");
            })
        .start();

    List<String> words = Lists.newArrayList("ren", "wang", "li", "zhao", "ma");
    words.sort((w1, w2) -> Integer.compare((w1.length()), w2.length()));

    List<Integer> ints = Ints.asList(1, 2, 3, 4, 5);
    ints.sort(Integer::compare);

    //        words.forEach(e -> System.out.print(e));
    words.forEach(System.out::println);

    //        words.stream().map(w -> w.length());
    words.stream().map(String::length);

    //        words.stream().map(w -> new StringBuilder(w));
    words.stream().map(StringBuilder::new);

    Converter<String, Integer> converter; // (f) -> Integer.valueOf(f);
    converter = Integer::valueOf;
    Integer converted = converter.convert("123");
    System.out.println(converted);

    String[] arrayStr = new String[] {"a", "ab", "abc", "abcd"};

    Arrays.sort(arrayStr, (first, second) -> Integer.compare(first.length(), second.length()));
  }
 /** Fetches available package versions using JSON API of PyPI. */
 @NotNull
 private List<String> getPackageVersionsFromPyPI(@NotNull String packageName, boolean force)
     throws IOException {
   final PackageDetails details = refreshAndGetPackageDetailsFromPyPI(packageName, force);
   final List<String> result = details.getReleases();
   result.sort(PackageVersionComparator.VERSION_COMPARATOR.reversed());
   return Collections.unmodifiableList(result);
 }
Beispiel #7
1
  static void collectionTest() {
    // removeIf
    Collection<String> c = new HashSet<>();
    c.add("Content 1");
    c.add("Content 2");
    c.add("Content 3");
    c.add("Content 4");
    c.removeIf(s -> s.contains("2"));
    System.out.println("removeIf : " + c);

    /// 基本操作
    List<Integer> list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
    list.removeIf(a -> a % 3 == 0);
    System.out.println("a % 3 == 0 " + list);

    // OR 操作
    Predicate<Integer> predicate2 = a -> a % 3 == 0;
    Predicate<Integer> predicate3 = a -> a % 5 == 0;
    list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
    list.removeIf(predicate2.or(predicate3));
    System.out.println("a % 3 == 0 or a % 5 == 0 " + list);

    // AND 操作
    predicate2 = a -> a % 3 == 0;
    predicate3 = a -> a % 5 == 0;
    list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
    list.removeIf(predicate2.and(predicate3));
    System.out.println("a % 3 == 0 and a % 5 == 0 " + list);

    List<String> stringList = Arrays.asList("a", "b");
    stringList.forEach(System.out::println);

    stringList = Arrays.asList("a", "b", "c");
    stringList.replaceAll(String::toUpperCase);
    System.out.println(stringList); // [A, B, C]

    stringList = Arrays.asList("a", "b", "c");
    stringList.sort(String::compareTo);

    Map<String, Integer> map = new HashMap<>();
    map.put("A", 10);
    map.put("B", 20);
    map.put("C", 30);
    map.forEach((k, v) -> System.out.println("Item : " + k + " Count : " + v));
    System.out.println(map.getOrDefault("D", 40)); // => 40
  }
 public List<String> testSorted(List<String> list) {
   List<String> result = new ArrayList<>();
   for (String s : list) {
     result.add(s);
   }
   result.sort(null);
   return result.toArray(new String[0]);
 }
  @Override
  public PagerResult<GeneratorInstance> search(GeneratorInstanceSearchRequest request) {
    Long userId = request.getUserId();
    String name = StringUtils.hasText(request.getName()) ? request.getName() : null;
    List<GeneratorInstance> records =
        generatorInstanceRepository.filter(
            generatorInstance -> {
              if (generatorInstance.getIsDelete()) {
                return false;
              }
              if (name != null) {
                if (!generatorInstance.getName().contains(name)) {
                  return false;
                }
              }
              if (userId != null) {
                if (!userId.equals(generatorInstance.getUser().getId())) {
                  return false;
                }
              }
              return true;
            });
    Integer page = request.getPage();
    Integer pageSize = request.getPageSize();
    Integer fromIndex = (page - 1) * pageSize;
    Integer toIndex = fromIndex + pageSize > records.size() ? records.size() : fromIndex + pageSize;
    List<GeneratorInstance> limitRecords = records.subList(fromIndex, toIndex);
    List<GeneratorInstance> result = new ArrayList<>();
    for (GeneratorInstance g : limitRecords) {
      GeneratorInstance generatorInstance = new GeneratorInstance();
      generatorInstance.setId(g.getId());
      generatorInstance.setName(g.getName());
      generatorInstance.setCreateDate(g.getCreateDate());
      generatorInstance.setModifyDate(g.getModifyDate());
      generatorInstance.setIsDelete(g.getIsDelete());
      User userPersistence = userRepository.selectById(g.getUser().getId());
      generatorInstance.setUser(userPersistence);
      Generator generatorPersistence = generatorRepository.selectById(g.getGenerator().getId());
      if (generatorPersistence == null) {
        throw new AppException("生成器不存在");
      }
      generatorInstance.setGenerator(generatorPersistence);
      generatorInstance.setDataModel(g.getDataModel());
      generatorInstance.setVersion(g.getVersion());
      result.add(generatorInstance);
    }

    String sortField = request.getSortField();
    String sortDirection = request.getSortDirection();
    if ("modifyDate".equals(sortField)) {
      if ("DESC".equalsIgnoreCase(sortDirection)) {
        result.sort(
            (g1, g2) -> (int) (g2.getModifyDate().getTime() - g1.getModifyDate().getTime()));
      }
    }

    return new PagerResult<>(result, (long) records.size());
  }
  @NotNull
  public static List<SymfonyInstallerVersion> getVersions(@NotNull String jsonContent) {

    JsonObject jsonObject = new JsonParser().parse(jsonContent).getAsJsonObject();

    List<SymfonyInstallerVersion> symfonyInstallerVersions = new ArrayList<>();

    // prevent adding duplicate version on alias names
    Set<String> aliasBranches = new HashSet<>();

    // get alias version, in most common order
    for (String s : new String[] {"latest", "lts"}) {
      JsonElement asJsonObject = jsonObject.get(s);
      if (asJsonObject == null) {
        continue;
      }

      String asString = asJsonObject.getAsString();
      aliasBranches.add(asString);

      symfonyInstallerVersions.add(
          new SymfonyInstallerVersion(s, String.format("%s (%s)", asString, s)));
    }

    List<SymfonyInstallerVersion> branches = new ArrayList<>();
    Set<Map.Entry<String, JsonElement>> entries = jsonObject.entrySet();
    for (Map.Entry<String, JsonElement> entry : entries) {
      if (!entry.getKey().matches("^\\d+\\.\\d+$")) {
        continue;
      }

      // "2.8.0-dev", "2.8.0-DEV" is not supported
      String asString = entry.getValue().getAsString();
      if (asString.matches(".*[a-zA-Z].*") || aliasBranches.contains(asString)) {
        continue;
      }

      branches.add(
          new SymfonyInstallerVersion(
              asString, String.format("%s (%s)", entry.getKey(), asString)));
    }

    branches.sort(Comparator.comparing(SymfonyInstallerVersion::getVersion));

    Collections.reverse(branches);

    symfonyInstallerVersions.addAll(branches);

    // we need reverse order for sorting them on version string
    List<SymfonyInstallerVersion> installableVersions = new ArrayList<>();
    for (JsonElement installable : jsonObject.getAsJsonArray("installable")) {
      installableVersions.add(new SymfonyInstallerVersion(installable.getAsString()));
    }
    Collections.reverse(installableVersions);

    symfonyInstallerVersions.addAll(installableVersions);
    return symfonyInstallerVersions;
  }
Beispiel #11
0
 void sortAccountByType() {
   List<Accounts> ac = new ArrayList<Accounts>(accounts.values());
   ac.sort(Accounts.TypeComparator);
   ac.stream()
       .forEach(
           (a) -> {
             a.dispaly();
           });
 }
Beispiel #12
0
 void sortAccountByCustomer() {
   List<Customer> cl = new ArrayList<Customer>(customers.values());
   cl.sort(Customer.CustomerComparatorByName);
   for (Customer c : cl) {
     System.out.println("Customer Name: " + c.CustomerName);
     Accounts a = accounts.get(c.AccountId);
     a.dispaly();
   }
 }
  public static void main(String[] args) {
    // Methods in Comparator
    List<Person> people = new ArrayList<>();
    people.sort(
        Comparator.comparing(Person::getLastName)
            .thenComparing(Person::getFirstName)
            .thenComparing(
                Person::getEmailAddress, Comparator.nullsLast(String.CASE_INSENSITIVE_ORDER)));

    // Old way of initializing ThreadLocal:
    ThreadLocal<List<String>> oldThreadLocalString =
        new ThreadLocal<List<String>>() {
          @Override
          public List<String> initialValue() {
            return new ArrayList<>();
          }
        };
    System.out.println(oldThreadLocalString.get());

    // New way:
    ThreadLocal<List<String>> newThreadLocalString = ThreadLocal.withInitial(ArrayList::new);
    System.out.println(newThreadLocalString.get());

    // Java Optional
    Optional<Integer> optional = new ArrayList<Integer>().stream().min(Integer::compareTo);
    System.out.println(optional);

    // Files can now return streams
    try {
      Stream stream = Files.list(Paths.get("c:\\temp\\"));
      stream = Files.lines(Paths.get("c:\\temp\\"), Charset.forName("UTF_32"));
      stream = Files.find(Paths.get("c:\\"), 5, (T, U) -> (T == U));

    } catch (IOException e) {
      UncheckedIOException ex = new UncheckedIOException("cause", e);
      System.out.println(ex.getMessage());
    }

    // Rejoice, for we finally have string joins!
    String joinExample = String.join(",", "a", "b", "c", "4", "E", "6");
    System.out.println(joinExample);

    StringJoiner joiner = new StringJoiner("-");
    joiner.add("abbie");
    joiner.add("doobie");
    System.out.println(joiner.toString());
  }
  @FXML
  private void initialize() {
    ObservableList<String> kunden =
        FXCollections.observableArrayList(KundeSession.getAllKundenNamen());
    kunden.add(0, "Alle");
    kundenChoiceBox.setItems(kunden);
    kundenChoiceBox.setValue("Alle");

    String dm = now.getDayOfMonth() + "." + now.getMonthValue() + ".";
    day1Label.setText("1.1. - " + dm);
    day2Label.setText("1.1. - " + dm);

    List<Auftrag> auftraege = AuftragSession.getAllAuftraege();
    auftraege.sort(Comparator.comparing(Auftrag::getErstellung));
    LocalDate oldestAuftrag = auftraege.get(0).getErstellung();

    ObservableList<Number> years = FXCollections.observableArrayList();
    for (int i = now.getYear(); i >= oldestAuftrag.getYear(); i--) {
      years.add(i);
    }
    year1ChoiceBox.setItems(years);
    year1ChoiceBox.setValue(years.get(1));
    year2ChoiceBox.setItems(years);
    year2ChoiceBox.setValue(years.get(0));

    calculate();

    pNrColumn.setCellValueFactory(cellData -> cellData.getValue().produktNr);
    bezColumn.setCellValueFactory(cellData -> cellData.getValue().bezeichnung);
    bildColumn.setCellValueFactory(cellData -> cellData.getValue().bild);
    bildColumn.setCellFactory(imageCellFactory);
    s1Column.setCellValueFactory(cellData -> cellData.getValue().stuckzahl1);
    u1Column.setCellValueFactory(cellData -> cellData.getValue().umsatz1);
    s2Column.setCellValueFactory(cellData -> cellData.getValue().stuckzahl2);
    u2Column.setCellValueFactory(cellData -> cellData.getValue().umsatz2);
    pInfoTable.setItems(dataShow);

    kundenChoiceBox.valueProperty().addListener(observable -> calculate());
    year1ChoiceBox.valueProperty().addListener(observable -> calculate());
    year2ChoiceBox.valueProperty().addListener(observable -> calculate());
  }
  private void initializeImplicitConstructor(SymbolResolver resolver) {
    List<? extends FormalParameter> inheritedParams = Collections.emptyList();
    if (getBaseType().isPresent()) {
      List<InternalConstructorDefinition> constructors =
          getBaseType().get().asReferenceTypeUsage().getTypeDefinition().getConstructors();
      if (constructors.size() != 1) {
        throw new UnsupportedOperationException();
      }
      inheritedParams = constructors.get(0).getFormalParameters();
    }

    List<FormalParameterNode> newParams =
        this.assignableProperties(resolver)
            .stream()
            .map(
                (p) ->
                    new FormalParameterNode(
                        p.getTypeUsage().copy(), p.getName(), p.getDefaultValue()))
            .collect(Collectors.toList());
    List<FormalParameter> allParams = new LinkedList<>();
    allParams.addAll(inheritedParams);
    allParams.addAll(newParams);
    allParams.sort(
        new Comparator<FormalParameter>() {
          @Override
          public int compare(FormalParameter o1, FormalParameter o2) {
            return Boolean.compare(o1.hasDefaultValue(), o2.hasDefaultValue());
          }
        });
    for (FormalParameter p : allParams) {
      // needed to solve symbols
      if (p.isNode()) {
        p.asNode().setParent(this);
      }
    }
    addConstructorWithParams(allParams, resolver);
  }
  @NotNull
  private static List<String> parsePackageVersionsFromArchives(@NotNull String archivesUrl)
      throws IOException {
    return HttpRequests.request(archivesUrl)
        .userAgent(getUserAgent())
        .connect(
            request -> {
              final List<String> versions = new ArrayList<>();
              final Reader reader = request.getReader();
              new ParserDelegator()
                  .parse(
                      reader,
                      new HTMLEditorKit.ParserCallback() {
                        HTML.Tag myTag;

                        @Override
                        public void handleStartTag(HTML.Tag tag, MutableAttributeSet set, int i) {
                          myTag = tag;
                        }

                        @Override
                        public void handleText(@NotNull char[] data, int pos) {
                          if (myTag != null && "a".equals(myTag.toString())) {
                            String packageVersion = String.valueOf(data);
                            final String suffix = ".tar.gz";
                            if (!packageVersion.endsWith(suffix)) return;
                            packageVersion = StringUtil.trimEnd(packageVersion, suffix);
                            versions.add(splitNameVersion(packageVersion).second);
                          }
                        }
                      },
                      true);
              versions.sort(PackageVersionComparator.VERSION_COMPARATOR.reversed());
              return versions;
            });
  }
Beispiel #17
0
 public List<Player> getPlayerList() {
   List<Player> playerList = new LinkedList<>(getPlayers());
   playerList.sort((a, b) -> a.getOrder() - b.getOrder());
   return Collections.unmodifiableList(playerList);
 }
  public static void main(String[] args) {
    // DBResourcesManager.initHibernate();

    OffertaEvento of = new OffertaEvento();
    of.setNome("ofevent");
    of.setTipologia("Concerto");
    of.setPrezzo(69);
    // of.setDataScadenza("21/08/2019");
    of.setCittà("Roma");

    Offerta offertaArray[] = {new OffertaEvento(), new OffertaPernotto(), new OffertaTrasporto()};
    /*
    for(Offerta o : offertaArray) {
        System.out.println(o.getClass().getSimpleName() + "\n");
        Method[] methods = o.getClass().getMethods();
        for (Method m : methods) {
            int l = m.getName().length();
            if (m.getName().substring(0, 3).equals("set") && !m.getName().substring(l - 2, l).equals("ID"))
                System.out.println(m.getName());
        }
    }*/
    /*
    OffertaBean object = new OffertaEventoBean();


    String query = "from "+ object.getClass().getSimpleName() + " where ";

    System.out.println(object.getClass().getSimpleName() + "\n");
    Method[] methods = object.getClass().getMethods();
    for (Method m : methods) {
        int l = m.getName().length();
        if (m.getName().substring(0, 3).equals("get") && !m.getName().substring(l - 2, l).equals("ID") && !m.getName().equals("getClass"))
        {
            String s = m.getName().substring(0,1).toLowerCase();
            String attributeLower = s + m.getName().substring(1);
            query = query + attributeLower + " = ";
        }
    }*/
    String città = "Roma";
    String dataScadenza = "11/07/2009";
    String nome = "Bubu";
    String prezzo = "4";
    String tipologia = "Museo";

    String query = "from OffertaEvento offertaEvento";

    query = query + " where ";
    if (città != null) query = query + "offertaEvento.città = '" + città + "' && ";
    if (dataScadenza != null)
      query = query + "offertaEvento.dataScadenza = '" + dataScadenza + "' && ";
    if (nome != null) query = query + "offertaEvento.nome = '" + nome + "' && ";
    if (prezzo != null) query = query + "offertaEvento.prezzo = '" + prezzo + "' && ";
    if (tipologia != null) query = query + "offertaEvento.tipologia = '" + tipologia + "'";

    System.out.println(query);

    ArrayList<String> ls = new ArrayList<String>();
    ls.add(città);
    ls.add(dataScadenza);
    ls.add(nome);
    ls.add(prezzo);
    ls.add(tipologia);
    System.out.println("\nNuova query\n");

    if (!ls.isEmpty()) query.join(" where");

    for (int i = 0; i < ls.size(); i++) {
      if (!ls.get(i).equals("") && i == 0)
        query.join(" && offertaEvento.città = '" + ls.get(i) + "'");
      if (!ls.get(i).equals("") && i == 1)
        query.join(" && offertaEvento.dataScadenza = '" + ls.get(i) + "'");
      if (!ls.get(i).equals("") && i == 2)
        query.join(" && offertaEvento.nome = '" + ls.get(i) + "'");
      if (!ls.get(i).equals("") && i == 3)
        query.join(" && offertaEvento.prezzo = '" + ls.get(i) + "'");
      if (!ls.get(i).equals("") && i == 4)
        query.join(" && offertaEvento.tipologia = '" + ls.get(i) + "'");
    }

    System.out.println(query);

    Offerta o = new OffertaEvento();

    List<Method> fields = Arrays.asList(o.getClass().getDeclaredMethods());

    Class c = o.getClass().getSuperclass();

    List<Method> superfields = Arrays.asList(c.getDeclaredMethods());

    List<Method> allfields = new ArrayList<Method>(fields);
    allfields.addAll(superfields);

    allfields.sort(
        new Comparator<Method>() {
          public int compare(Method o1, Method o2) {
            return o1.getName().compareTo(o1.getName());
          }
        });
    /*
    for(Method f: allfields){

    }*/
    java.sql.Date date = Date.valueOf(LocalDate.now());
    System.out.println(date);
    String datestring = date.toString();
    System.out.println(datestring);
    Date data2 = Date.valueOf(datestring);
    System.out.println(data2);
    // OffertaEventoDAO.store(of);

    // System.out.println(((List<OffertaEvento>)DAOFactory.getDAOFactory(TipoOfferta.OffertaEvento).getOffertaDAO().getList()).size());

    // DBResourcesManager.shutdown();

    // OffertaDaoAnnotations.findAllOffertaEntitysA("offertaevento","Concerto");
  }
Beispiel #19
0
  // Does point to point routing with data from request
  public ProfileResponse getPlan(ProfileRequest request) {
    long startRouting = System.currentTimeMillis();
    request.zoneId = transportNetwork.getTimeZone();
    // Do the query and return result
    ProfileResponse profileResponse = new ProfileResponse();

    ProfileOption option = new ProfileOption();

    findDirectPaths(request, option);
    option.summary = option.generateSummary();
    profileResponse.addOption(option);

    if (request.hasTransit()) {
      Map<LegMode, StreetRouter> accessRouter = new HashMap<>(request.accessModes.size());
      Map<LegMode, StreetRouter> egressRouter = new HashMap<>(request.egressModes.size());

      // This map saves which access mode was used to access specific stop in access mode
      TIntObjectMap<LegMode> stopModeAccessMap = new TIntObjectHashMap<>();
      // This map saves which egress mode was used to access specific stop in egress mode
      TIntObjectMap<LegMode> stopModeEgressMap = new TIntObjectHashMap<>();

      findAccessPaths(request, accessRouter);

      findEgressPaths(request, egressRouter);

      // fold access and egress times into single maps
      TIntIntMap accessTimes =
          combineMultimodalRoutingAccessTimes(accessRouter, stopModeAccessMap, request);
      TIntIntMap egressTimes =
          combineMultimodalRoutingAccessTimes(egressRouter, stopModeEgressMap, request);

      McRaptorSuboptimalPathProfileRouter router =
          new McRaptorSuboptimalPathProfileRouter(
              transportNetwork, request, accessTimes, egressTimes);
      List<PathWithTimes> usefullpathList = new ArrayList<>();

      // getPaths actually returns a set, which is important so that things are deduplicated.
      // However we need a list
      // so we can sort it below.
      usefullpathList.addAll(router.getPaths());

      // This sort is necessary only for text debug output so it will be disabled when it is
      // finished

      /**
       * Orders first no transfers then one transfers 2 etc - then orders according to first trip: -
       * board stop - alight stop - alight time - same for one transfer trip
       */
      usefullpathList.sort(
          (o1, o2) -> {
            int c;
            c = Integer.compare(o1.patterns.length, o2.patterns.length);
            if (c == 0) {
              c = Integer.compare(o1.boardStops[0], o2.boardStops[0]);
            }
            if (c == 0) {
              c = Integer.compare(o1.alightStops[0], o2.alightStops[0]);
            }
            if (c == 0) {
              c = Integer.compare(o1.alightTimes[0], o2.alightTimes[0]);
            }
            if (c == 0 && o1.patterns.length == 2) {
              c = Integer.compare(o1.boardStops[1], o2.boardStops[1]);
              if (c == 0) {
                c = Integer.compare(o1.alightStops[1], o2.alightStops[1]);
              }
              if (c == 0) {
                c = Integer.compare(o1.alightTimes[1], o2.alightTimes[1]);
              }
            }
            return c;
          });
      LOG.info("Usefull paths:{}", usefullpathList.size());
      int seen_paths = 0;
      int boardStop = -1, alightStop = -1;
      for (PathWithTimes path : usefullpathList) {
        profileResponse.addTransitPath(
            accessRouter,
            egressRouter,
            stopModeAccessMap,
            stopModeEgressMap,
            path,
            transportNetwork,
            request.getFromTimeDateZD());
        // LOG.info("Num patterns:{}", path.patterns.length);
        // ProfileOption transit_option = new ProfileOption();

        /*if (path.patterns.length == 1) {
            continue;
        }*/

        /*if (seen_paths > 20) {
            break;
        }*/

        if (LOG.isDebugEnabled()) {
          LOG.debug(" ");
          for (int i = 0; i < path.patterns.length; i++) {
            // TransitSegment transitSegment = new TransitSegment(transportNetwork.transitLayer,
            // path.boardStops[i], path.alightStops[i], path.patterns[i]);
            if (!(((boardStop == path.boardStops[i] && alightStop == path.alightStops[i])))) {
              LOG.debug(
                  "   BoardStop: {} pattern: {} allightStop: {}",
                  path.boardStops[i],
                  path.patterns[i],
                  path.alightStops[i]);
            }
            TripPattern pattern = transportNetwork.transitLayer.tripPatterns.get(path.patterns[i]);
            if (pattern.routeIndex >= 0) {
              RouteInfo routeInfo = transportNetwork.transitLayer.routes.get(pattern.routeIndex);
              LOG.debug(
                  "     Pattern:{} on route:{} ({}) with {} stops",
                  path.patterns[i],
                  routeInfo.route_long_name,
                  routeInfo.route_short_name,
                  pattern.stops.length);
            }
            LOG.debug(
                "     {}->{} ({}:{})",
                transportNetwork.transitLayer.stopNames.get(path.boardStops[i]),
                transportNetwork.transitLayer.stopNames.get(path.alightStops[i]),
                path.alightTimes[i] / 3600,
                path.alightTimes[i] % 3600 / 60);
            // transit_option.addTransit(transitSegment);
          }
          boardStop = path.boardStops[0];
          alightStop = path.alightStops[0];
        }
        seen_paths++;
      }
      profileResponse.generateStreetTransfers(transportNetwork, request);
    }

    LOG.info("Returned {} options", profileResponse.getOptions().size());
    LOG.info("Took {} ms", System.currentTimeMillis() - startRouting);

    return profileResponse;
  }
  /**
   * Puts the given lesson plans into classrooms based on the distance the member fo staff will have
   * to travel between each lesson.
   *
   * @param lessonPlans The lessonPlans to be put into classrooms.
   * @param classrooms The classrooms to put lessons plans into.
   * @param distances The distances between the classrooms.
   * @return The list of lessonPlans after they have been put into classrooms.
   */
  private boolean putLessonPlansIntoClassrooms(
      List<LessonPlan> lessonPlans, List<Classroom> classrooms, List<Distance> distances) {

    // Create a week of periods for this subject
    List<List<LessonPlan>> week = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
      week.add(new ArrayList<>());
    }
    lessonPlans
        .stream()
        .forEach(lessonPlan -> week.get(lessonPlan.period.day.id - 1).add(lessonPlan));

    List<Period> periods;
    // Iterate through each day
    for (int dayNo = 0; dayNo < week.size(); dayNo++) {
      // Get the periods of this day
      try {
        periods =
            daoManager
                .getPeriodDao()
                .getAllByDay(
                    daoManager
                        .getDayDao()
                        .getById(dayNo + 1)
                        .orElseThrow(
                            () -> new IllegalStateException("Failed to find periods in a day")));
        // The above exception should never be thrown
        periods.sort((o1, o2) -> o1.startTime.getHour() - o2.startTime.getHour());
      } catch (DataAccessException e) {
        DataExceptionHandler.handleJavaFx(e, "period", false);
        return false;
      } catch (DataConnectionException e) {
        DataExceptionHandler.handleJavaFx(e, null, true);
        return false;
      }

      // Get this days lessons and randomly allocate the first period
      List<LessonPlan> day = week.get(dayNo);
      List<LessonPlan> firstPeriod = new ArrayList<>();
      day.forEach(
          lessonPlan -> {
            if (lessonPlan.period.startTime.equals(LocalTime.of(9, 10))) {
              firstPeriod.add(lessonPlan);
            }
          });
      classrooms
          .stream()
          .forEach(
              classroom -> {
                for (LessonPlan lessonPlan : firstPeriod) {
                  if (lessonPlan.classroom.id == -1) {
                    lessonPlan.classroom = classroom;
                    break;
                  }
                }
              });
      // Store the first period in the timetabled list
      firstPeriod.forEach(
          lessonPlan -> {
            int index = lessonPlans.indexOf(lessonPlan);
            lessonPlans.set(index, lessonPlan);
          });

      List<LessonPlan> previousPeriod = new ArrayList<>(firstPeriod);
      // Iterate through the other periods
      for (int periodNo = 1; periodNo < 5; periodNo++) {
        List<LessonPlan> period = new ArrayList<>();
        for (LessonPlan lessonPlan : day) {
          if (lessonPlan.period.equals(periods.get(periodNo - 1))) {
            period.add(lessonPlan);
          }
        }

        // Timetable lessons where the staff member had a lesson previously
        for (LessonPlan lessonPlan : period) {
          Staff staff = lessonPlan.staff;
          Optional<LessonPlan> previousLesson =
              previousPeriod.stream().filter(lesson -> lesson.staff.equals(staff)).findFirst();

          if (previousLesson.isPresent()) {
            Optional<LessonPlan> planOptional =
                period
                    .stream()
                    .filter(plan -> plan.classroom.equals(previousLesson.get().classroom))
                    .findFirst();

            if (planOptional.isPresent()) {
              List<Distance> availableRooms =
                  distances
                      .stream()
                      .filter(
                          distance ->
                              distance.startRoom.equals(planOptional.get().classroom)
                                  || distance.endRoom.equals(planOptional.get().classroom))
                      .collect(Collectors.toList());
              availableRooms.removeIf(
                  distance -> {
                    boolean remove = false;
                    for (LessonPlan plan : period) {
                      if (plan.classroom.equals(distance.startRoom)
                          || plan.classroom.equals(distance.endRoom)) {
                        remove = true;
                      }
                    }

                    return remove;
                  });

              availableRooms.sort((o1, o2) -> o1.distance - o2.distance);
              Distance nextTrip = availableRooms.get(0);

              if (nextTrip.startRoom.equals(planOptional.get().classroom)) {
                lessonPlan.classroom = nextTrip.endRoom;
              } else if (nextTrip.endRoom.equals(planOptional.get().classroom)) {
                lessonPlan.classroom = nextTrip.startRoom;
              } else {
                assert false : "The new classroom should be one from the shortest distance!";
              }
            } else {
              lessonPlan.classroom = previousLesson.get().classroom;
            }
          }
        }

        // Timetable the remaining lessons randomly
        for (LessonPlan lessonPlan : period) {
          if (lessonPlan.classroom != null) {
            List<Classroom> availableRooms = new ArrayList<>();
            availableRooms.addAll(classrooms);

            availableRooms.removeIf(
                classroom -> {
                  boolean remove = false;
                  for (LessonPlan plan : period) {
                    if (classroom.equals(plan.classroom)) {
                      remove = true;
                    }
                  }
                  return remove;
                });
            lessonPlan.classroom = availableRooms.get(0);
          }
        }

        previousPeriod = period;
      }
    }
    return true;
  }