@Override public Flow<A> firsts() { return tupleFlow.map(new Mapper<Tuple<A, B>, A>() { @Override public A map(Tuple<A, B> value) { return value.first; } }); }
@Override public Flow<B> seconds() { return tupleFlow.map(new Mapper<Tuple<A, B>, B>() { @Override public B map(Tuple<A, B> value) { return value.second; } }); }
@Override public Flow<B> seconds() { return tupleFlow.map(new Mapper<Tuple<A, B>, B>() { @Override public B map(Tuple<A, B> value) { return value.second; } }); }
@Override public <X, Y> ZippedFlow<X, Y> mapTuples(Mapper<Tuple<A, B>, Tuple<X, Y>> mapper) { return create(tupleFlow.map(mapper)); }
@Override public AnnotationProvider getMethodAnnotationProvider(final String methodName, final Class... argumentTypes) { return AnnotationProviderChain.create(searchPath().map(new Mapper<Class, Method>() { @Override public Method map(Class element) { return InternalUtils.findMethod(element, methodName, argumentTypes); } }).map(InternalUtils.METHOD_TO_AP_MAPPER).toList()); }
/** * @since 5.3.1, 5.4 */ public static Object[] realizeObjects(ObjectCreator[] creators) { return F.flow(creators).map(CREATE_OBJECT).toArray(Object.class); }
private List<Class> toProviderClasses(final List<PersistenceProvider> providers) { return F.flow(providers).map(new Mapper<PersistenceProvider, Class>() { @Override public Class map(PersistenceProvider element) { return element.getClass(); } }).toList(); }
private Flow<ServiceDef2> getLocalServiceDefs(final ModuleDef moduleDef) { return F.flow(moduleDef.getServiceIds()).map(new Mapper<String, ServiceDef2>() { @Override public ServiceDef2 map(String value) { return InternalUtils.toServiceDef2(moduleDef.getServiceDef(value)); } }); }
private Flow<ServiceDef2> getLocalServiceDefs(final ModuleDef moduleDef) { return F.flow(moduleDef.getServiceIds()).map(new Mapper<String, ServiceDef2>() { @Override public ServiceDef2 map(String value) { return InternalUtils.toServiceDef2(moduleDef.getServiceDef(value)); } }); }
private List<Class> toProviderClasses(final List<PersistenceProvider> providers) { return F.flow(providers).map(new Mapper<PersistenceProvider, Class>() { @Override public Class map(PersistenceProvider element) { return element.getClass(); } }).toList(); }
private Asset[] convertPathsToAssetArray(final ComponentResources resources, String[] assetPaths, final String libraryName) { return F.flow(assetPaths).map(new Mapper<String, Asset>() { public Asset map(String assetPath) { return assetSource.getComponentAsset(resources, assetPath, libraryName); } }).toArray(Asset.class); }
private List<String> toPaths(List<Asset> assets) { assert assets != null; return F.flow(assets).map(toPath).toList(); }
public Set<Page> getAllPages() { return F.flow(pageCache.values()).map(new Mapper<SoftReference<Page>, Page>() { public Page map(SoftReference<Page> element) { return element.get(); } }).removeNulls().toSet(); } }
@Override public AnnotationProvider getClassAnnotationProvider() { return AnnotationProviderChain.create(searchPath().map(InternalUtils.CLASS_TO_AP_MAPPER).toList()); }
private LazyFunction<T> nextFunction() { if (valueIndex < flows.size() - 1) { return new Interleaver<T>(flows, valueIndex + 1); } List<Flow<T>> nextFlows = F.flow(flows).map(new Mapper<Flow<T>, Flow<T>>() { @Override public Flow<T> map(Flow<T> element) { return element.rest(); } }).toList(); return new Interleaver<T>(nextFlows, 0); }
@Test public void toString_mapper() { Flow<Integer> flow = F.flow(1, 2, 3); assertFlowValues(flow.map(F.<Integer> stringValueOf()), "1", "2", "3"); }
@Test public void map2() { Flow<Integer> left = F.range(10, 13); Flow<Integer> right = F.series(20, 2); assertFlowValues(left.map(F.ADD_INTS, right), 10 + 20, 11 + 22, 12 + 24); } }
@Test public void combine_mappers() { List<Boolean> even = F.flow("Mary", "had", "a", "little", "lamb").map(F.combine(stringToLength, toEven)) .toList(); assertListsEquals(even, true, false, false, true, true); }
@Test public void array_flow_reduce() { int total = F.flow(F.flow("Mary", "had", "a", "little", "lamb").map(stringToLength).toList()).reduce( F.SUM_INTS, 0); assertEquals(total, 18); }
@Test public void count_of_a_mapped_filtered_empty_flow() { Flow<Integer> flow = F.flow("Mary", "had", "etc.").filter(F.isNull()).map(stringToLength); assertTrue(flow.isEmpty()); assertEquals(flow.count(), 0); }