private void processElements( RoundEnvironment roundEnv ) { Set<? extends Element> functions = roundEnv.getElementsAnnotatedWith( supportedAnnotationType ); visitedElements.addAll( functions ); functions.stream().flatMap( this::validate ).forEachOrdered( messagePrinter::print ); }
private static void testForEach() { System.out.println(); System.out.println("For each start"); Collection<String> collection = Arrays.asList("a1", "a2", "a3", "a1"); // Print debug information for every element System.out.print("forEach = "); collection.stream().map(String::toUpperCase).forEach((e) -> System.out.print(e + ",")); // print forEach = A1,A2,A3,A1, System.out.println(); Collection<StringBuilder> list = Arrays.asList(new StringBuilder("a1"), new StringBuilder("a2"), new StringBuilder("a3")); list.stream().forEachOrdered((p) -> p.append("_new")); System.out.println("forEachOrdered = " + list); // print forEachOrdered = [a1_new, a2_new, a3_new] }
private static Collection<OptionWithMetaInfo> findCommonOptions(String rootDir, String module, String packageName, String pathPrefix) throws IOException, ClassNotFoundException { Collection<OptionWithMetaInfo> commonOptions = new ArrayList<>(32); processConfigOptions(rootDir, module, packageName, pathPrefix, optionsClass -> extractConfigOptions(optionsClass).stream() .filter(optionWithMetaInfo -> optionWithMetaInfo.field.getAnnotation(Documentation.CommonOption.class) != null) .forEachOrdered(commonOptions::add)); return commonOptions; }
/** * Populate the Queue with given HFiles */ private void populateLoadQueue(Deque<LoadQueueItem> ret, Map<byte[], List<Path>> map) { map.forEach((k, v) -> v.stream().map(p -> new LoadQueueItem(k, p)).forEachOrdered(ret::add)); }
/** * Reads all lines of text from this source, running the given {@code action} for each line as it * is read. * * <p>Like {@link BufferedReader#readLine()}, this method considers a line to be a sequence of * text that is terminated by (but does not include) one of {@code \r\n}, {@code \r} or {@code * \n}. If the source's content does not end in a line termination sequence, it is treated as if * it does. * * @throws IOException if an I/O error occurs while reading from this source or if {@code action} * throws an {@code UncheckedIOException} * @since 22.0 */ @Beta public void forEachLine(Consumer<? super String> action) throws IOException { try (Stream<String> lines = lines()) { // The lines should be ordered regardless in most cases, but use forEachOrdered to be sure lines.forEachOrdered(action); } catch (UncheckedIOException e) { throw e.getCause(); } }
private <T> void addToLockedResources(List<LockedResource> lockedResources, Map<T, LockAndQueue> locks, Function<T, String> keyTransformer, LockedResourceType resourcesType) { locks.entrySet().stream().filter(e -> e.getValue().isLocked()) .map(e -> createLockedResource(resourcesType, keyTransformer.apply(e.getKey()), e.getValue())) .forEachOrdered(lockedResources::add); }
@Override public Void visitArray(List<? extends AnnotationValue> vals, Void aVoid) { vals.stream().forEachOrdered(v -> v.accept(this, null)); return super.visitArray(vals, aVoid); } },
private static void printJobStatusMessages(List<JobStatusMessage> jobs) { SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss"); Comparator<JobStatusMessage> startTimeComparator = (o1, o2) -> (int) (o1.getStartTime() - o2.getStartTime()); Comparator<Map.Entry<JobStatus, List<JobStatusMessage>>> statusComparator = (o1, o2) -> String.CASE_INSENSITIVE_ORDER.compare(o1.getKey().toString(), o2.getKey().toString()); Map<JobStatus, List<JobStatusMessage>> jobsByState = jobs.stream().collect(Collectors.groupingBy(JobStatusMessage::getJobState)); jobsByState.entrySet().stream() .sorted(statusComparator) .map(Map.Entry::getValue).flatMap(List::stream).sorted(startTimeComparator) .forEachOrdered(job -> System.out.println(dateFormat.format(new Date(job.getStartTime())) + " : " + job.getJobId() + " : " + job.getJobName() + " (" + job.getJobState() + ")")); }
public HDFSBlocksDistribution getHDFSBlocksDistribution() { HDFSBlocksDistribution hdfsBlocksDistribution = new HDFSBlocksDistribution(); stores.values().stream().filter(s -> s.getStorefiles() != null) .flatMap(s -> s.getStorefiles().stream()).map(HStoreFile::getHDFSBlockDistribution) .forEachOrdered(hdfsBlocksDistribution::add); return hdfsBlocksDistribution; }
/** Returns a string descriptor of a method's reference type. */ private String methodReferenceDescriptor(Types types, MethodSymbol sym) { StringBuilder sb = new StringBuilder(); sb.append(sym.getSimpleName()).append('('); if (!sym.isStatic()) { sb.append(Signatures.descriptor(sym.owner.type, types)); } sym.params().stream().map(p -> Signatures.descriptor(p.type, types)).forEachOrdered(sb::append); sb.append(")"); return sb.toString(); } }
private void logRegionFiles() { if (LOG.isTraceEnabled()) { LOG.trace(getRegionInfo().getEncodedName() + " : Store files for region: "); stores.values().stream().filter(s -> s.getStorefiles() != null) .flatMap(s -> s.getStorefiles().stream()) .forEachOrdered(sf -> LOG.trace(getRegionInfo().getEncodedName() + " : " + sf)); } }
private void assertLogLevel(LoggerLevel level, String... expected) { List<String> logs = logTester.logs(level); assertThat(logs).hasSize(expected.length); Iterator<String> iterator = logs.iterator(); Arrays.stream(expected).forEachOrdered(log -> { if (log.endsWith(" | time=")) { assertThat(iterator.next()).startsWith(log); } else { assertThat(iterator.next()).isEqualTo(log); } }); }
@Override protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { super.serializeStateData(serializer); ReopenTableRegionsStateData.Builder builder = ReopenTableRegionsStateData.newBuilder() .setTableName(ProtobufUtil.toProtoTableName(tableName)); regions.stream().map(ProtobufUtil::toRegionLocation).forEachOrdered(builder::addRegion); serializer.serialize(builder.build()); }
private TableDescriptor getBasic3FamilyHTableDescriptor(TableName tableName) { TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName); Arrays.stream(TEST_FAMILY).map(ColumnFamilyDescriptorBuilder::of) .forEachOrdered(builder::setColumnFamily); return builder.build(); }
public static TableDescriptor createTableDescriptor(TableName tableName, byte[]... family) { TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName); Stream.of(family).map(ColumnFamilyDescriptorBuilder::of) .forEachOrdered(builder::setColumnFamily); return builder.build(); }
private static TableDescriptor createHTableDescriptor(final int regionNum, final int numFamilies) { TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(TableName.valueOf(TABLE_NAME + ":" + regionNum)); IntStream.range(0, numFamilies) .mapToObj(i -> ColumnFamilyDescriptorBuilder.of(FAMILY_PREFIX + i)) .forEachOrdered(builder::setColumnFamily); return builder.build(); }
private static void validateFilterKeys(String... metricKeys) { ProjectMeasuresQuery query = new ProjectMeasuresQuery(); Arrays.stream(metricKeys).forEachOrdered(metricKey -> query.addMetricCriterion(create(metricKey, ProjectMeasuresQuery.Operator.LT, 80d))); ProjectMeasuresQueryValidator.validate(query); } }
private static WAL.Entry generateEdit(int i, RegionInfo hri, TableName tableName, byte[] row, int columnCount, long timestamp, MultiVersionConcurrencyControl mvcc) { WALKeyImpl key = new WALKeyImpl(hri.getEncodedNameAsBytes(), tableName, i, timestamp, HConstants.DEFAULT_CLUSTER_ID, mvcc); WALEdit edit = new WALEdit(); int prefix = i; IntStream.range(0, columnCount).mapToObj(j -> toValue(prefix, j)) .map(value -> new KeyValue(row, row, row, timestamp, value)).forEachOrdered(edit::add); return new WAL.Entry(key, edit); }
private TableDescriptor getTableDesc(TableName tableName, byte[]... families) { TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName); Arrays.stream(families).map( f -> ColumnFamilyDescriptorBuilder.newBuilder(f).setMaxVersions(Integer.MAX_VALUE).build()) .forEachOrdered(builder::setColumnFamily); return builder.build(); }
private TableDescriptor getTableDesc(TableName tableName, int regionReplication, byte[]... families) { TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName).setRegionReplication(regionReplication); Arrays.stream(families).map(family -> ColumnFamilyDescriptorBuilder.newBuilder(family) .setMaxVersions(Integer.MAX_VALUE).build()).forEachOrdered(builder::setColumnFamily); return builder.build(); }