public Iterable<String> formatResults(Iterable<Result> results, final Server server) { return from(results).transformAndConcat(new Function<Result, List<String>>() { @Override public List<String> apply(Result input) { return formatResult(input, server); } }).toList(); }
public LoadMeasureComputersStep(MutableMeasureComputersHolder measureComputersHolder, Metrics[] metricsRepositories, MeasureComputer[] measureComputers) { this.measureComputersHolder = measureComputersHolder; this.measureComputers = measureComputers; this.pluginMetricKeys = from(Arrays.asList(metricsRepositories)) .transformAndConcat(MetricsToMetricList.INSTANCE) .transform(MetricToKey.INSTANCE) .toSet(); }
public static <T> ImmutableList<T> toObjects(final ImmutableList<InputStream> streams, final Class<T> elementClass) { final CollectionType type = DEFAULT_FACTORY.constructCollectionType(List.class, elementClass); return FluentIterable.from(streams).transformAndConcat(Jsons.<T>toObject(type)).toList(); }
public void testTransformAndConcat_wildcardFunctionGenerics() { List<Integer> input = asList(1, 2, 3); FluentIterable<String> unused = FluentIterable.from(input).transformAndConcat(new RepeatedStringValueOfWildcardFunction()); }
public static String asHeaders(final HttpMessage message) { return HEAD_JOINER.join(from(message.getHeaders().entrySet()) .transformAndConcat(toMapEntries())); }
private void validateMetrics(List<MeasureComputerWrapper> wrappers) { from(wrappers).transformAndConcat(ToInputMetrics.INSTANCE).filter(new ValidateInputMetric()).size(); from(wrappers).transformAndConcat(ToOutputMetrics.INSTANCE).filter(new ValidateOutputMetric()).size(); from(wrappers).filter(new ValidateUniqueOutputMetric()).size(); }
public void testTransformAndConcat() { List<Integer> input = asList(1, 2, 3); Iterable<String> result = FluentIterable.from(input).transformAndConcat(new RepeatedStringValueOfFunction()); assertEquals(asList("1", "1", "2", "2", "3", "3"), Lists.newArrayList(result)); }
.transformAndConcat(new Function<List<String>, Iterable<Reservation>>() .transformAndConcat(new Function<Reservation, Iterable<Instance>>()
.transformAndConcat(new Function<List<String>, Iterable<Reservation>>() .transformAndConcat(new Function<Reservation, Iterable<Instance>>()
@Override protected Optional<String[]> doExtract(final HttpRequest request) { String[] extractedValues = from(request.getHeaders().entrySet()) .filter(isForHeaderName(name)) .transform(toValue()) .transformAndConcat(arrayAsIterable()) .toArray(String.class); if (extractedValues.length > 0) { return of(extractedValues); } return absent(); }
public SettingRunner(final InputStream stream, final StartArgs args) { this.env = args.getEnv(); this.globalSettings = parser.parse(stream); this.files = from(globalSettings).transformAndConcat(toFiles()); this.startArgs = args; }
.transformAndConcat( new Function<String, Iterable<Object[]>>()
.transformAndConcat( new Function<String, Iterable<Object[]>>()
@Override public Set<Class<?>> getRequiredRoots() { return FluentIterable.from(getAllMetrics()) .transformAndConcat(new Function<Metric<?>, Iterable<Class<?>>>() { @Nullable @Override public Iterable<Class<?>> apply(Metric<?> input) { return input.getRequiredRoots(); } }).toSet(); }
@Override public Set<Class<?>> getRequiredRoots() { return FluentIterable.from(getAllMetrics()) .transformAndConcat(new Function<Metric<?>, Iterable<Class<?>>>() { @Nullable @Override public Iterable<Class<?>> apply(Metric<?> input) { return input.getRequiredRoots(); } }).toSet(); }
public static Iterable<Map<String, Object>> join(Iterable<Map<?, ?>> input, int batchSize, Function<List<?>, List<Map<String, ?>>> getRowsFunction) { Iterable<Entry<?, ?>> entries = Iterables.concat(Iterables.transform(input, Map::entrySet)); return FluentIterable.from(Iterables.partition(entries, batchSize)).transformAndConcat( batch -> { List<?> keys = batch.stream().map(Entry::getKey).collect(Collectors.toList()); List<Map<String, ?>> batchResult = getRowsFunction.apply(keys); Map<?, ?> resultMap = Maps.uniqueIndex(batchResult, m -> m.get("row")); return batch.stream() .filter(inputItem -> resultMap.containsKey(inputItem.getKey())) .map(batchItem -> { Map<String, Object> map = Maps.newHashMap(); Object row = batchItem.getKey(); map.put(JoinComponent.JOIN_KEY.toString(), row); map.put(JoinComponent.OUTPUT_VALUE.toString(), resultMap.get(row)); map.put(JoinComponent.INPUT_VALUE.toString(), batchItem.getValue()); return map; }).collect(Collectors.toList()); } ); } }
.transformAndConcat(input -> { Timer.Context timer = getTimer("processedRangeMillis").time(); Map<RangeRequest, TokenBackedBasicResultsPage<RowResult<Value>, byte[]>> firstPages =
private List<FragmentWork> getFragments() { return FluentIterable.from(hostFragmentMap.values()) .transformAndConcat(new Function<HostFragments, Iterable<FragmentWork>>() { @Override public Iterable<FragmentWork> apply(HostFragments hostFragments) { return hostFragments.fragmentQueue; } }).toList(); }
protected static Iterable<NullReference> nulls(FunctionRender... renders){ return FluentIterable.of(renders).transformAndConcat(new Function<FunctionRender, Iterable<NullReference>>(){ @Override public Iterable<NullReference> apply(FunctionRender input) { return input.getNulls(); }}); }
private List<DataPartition> getDataPartitions() { return ImmutableList.copyOf(materializationStore.getRefreshes(materialization) .transformAndConcat(new Function<Refresh, Iterable<DataPartition>>() { @Override public Iterable<DataPartition> apply(Refresh input) { return input.getPartitionList() != null ? input.getPartitionList() : ImmutableList.of(); } }).toSet()); }