@Override public ZippedFlow<A, B> sort(Comparator<Tuple<A, B>> comparator) { return create(tupleFlow.sort(comparator)); }
@Override public ZippedFlow<A, B> sort(Comparator<Tuple<A, B>> comparator) { return create(tupleFlow.sort(comparator)); }
public List<String> getStackNames() { return F.flow(configuration.keySet()).sort().toList(); }
private void validate(String category, Map<String, Set<String>> map) { boolean header = false; for (String name : F.flow(map.keySet()).sort()) { Set<String> classNames = map.get(name); if (classNames.size() == 1) { continue; } if (!header) { logger.error(String.format("Some %s(s) map to more than one Java class.", category)); header = true; invalid = true; } logger.error(String.format("%s '%s' maps to %s", InternalUtils.capitalize(category), name, InternalUtils.joinSorted(classNames))); } } }
public List<String> getLibraryNames() { return F.flow(libraryNameToPackageNames.keySet()).remove(F.IS_BLANK).sort().toList(); }
public void transform(PlasticClass plasticClass, TransformationSupport support, MutableComponentModel model) { Flow<PlasticField> parametersFields = F.flow(plasticClass.getFieldsWithAnnotation(Parameter.class)).sort(byPrincipalThenName); for (PlasticField field : parametersFields) { convertFieldIntoParameter(plasticClass, model, field); } }
@Test(expectedExceptions = ClassCastException.class) public void unable_to_sort_a_flow_of_non_comparables() { Flow<Locale> flow = F.flow(Locale.ENGLISH, Locale.FRANCE); flow.sort(); }
@Test public void sort_comparable_list() { assertFlowValues(F.flow("fred", "barney", "wilma", "betty").sort(), "barney", "betty", "fred", "wilma"); }
@Test public void sort_non_array_flow() { assertFlowValues(filteredEmpty.append(7, 3, 9).sort(), 3, 7, 9); }
@Test public void sort_using_explicit_comparator() { Flow<String> flow = F.flow("a", "eeeee", "ccc", "bb", "dddd"); Comparator<String> comparator = new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }; assertFlowValues(flow.sort(comparator), "a", "bb", "ccc", "dddd", "eeeee"); }
@Test public void sort_a_short_list_returns_same() { Flow<String> zero = F.flow(); Comparator<String> comparator = new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }; assertSame(zero.sort(), zero); assertSame(zero.sort(comparator), zero); Flow<String> one = F.flow("Hello"); assertSame(one.sort(), one); assertSame(one.sort(comparator), one); }
public Iterable<Track> getTracks() { return F.flow(library.getTracks()).sort(new Comparator<Track>(){ @Override public int compare(Track arg0, Track arg1) { return arg0.getId().compareTo(arg1.getId()); } }); }
@Test public void operations_on_empty_list_yield_empty() { assertSame(filteredEmpty.reverse(), F.EMPTY_FLOW); assertSame(filteredEmpty.sort(), F.EMPTY_FLOW); assertSame(filteredEmpty.sort(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { unreachable(); return 0; } }), F.EMPTY_FLOW); }
t.getThreadGroup()); }).sort().toList();
@Test public void sort_with_comparator_on_non_array_flow() { Flow<String> flow = F.flow("Mary", "had", "a", "little", "lamb"); List<String> result = flow.filter(new Predicate<String>() { @Override public boolean accept(String object) { return object.contains("a"); } }).sort(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); }; }).toList(); assertListsEquals(result, "a", "had", "Mary", "lamb"); }
public void commit() { if (focusFieldId != null) { require("t5/core/pageinit").invoke("focus").with(focusFieldId); } F.flow(stylesheetLinks).each(new Worker<StylesheetLink>() { public void work(StylesheetLink value) { linker.addStylesheetLink(value); } }); F.flow(inits).sort(new Comparator<InitializationImpl>() { public int compare(InitializationImpl o1, InitializationImpl o2) { return o1.priority.compareTo(o2.priority); } }).each(new Worker<InitializationImpl>() { public void work(InitializationImpl element) { linker.addInitialization(element.priority, element.moduleName, element.functionName, element.arguments); } }); }