@SuppressWarnings("Convert2MethodRef") protected ByteBuffer[] keysAndArgs(RedisElementWriter argsWriter, List<K> keys, List<?> args) { return Stream.concat(keys.stream().map(t -> keySerializer().getWriter().write(t)), args.stream().map(t -> argsWriter.write(t))).toArray(size -> new ByteBuffer[size]); }
private void printSensors(Collection<ModuleSensorWrapper> moduleSensors, Collection<ModuleSensorWrapper> globalSensors) { String sensors = Stream .concat(moduleSensors.stream(), globalSensors.stream()) .map(Object::toString) .collect(Collectors.joining(" -> ")); LOG.debug("Sensors : {}", sensors); }
.map(String::trim) .filter(blank.negate()); .map(String::trim) .filter(blank.negate()) .flatMap(packageName -> cp.getTopLevelClasses(packageName).stream()) .map(ClassPath.ClassInfo::load) .filter(ZuulFilter.class::isAssignableFrom) .map(Class::getCanonicalName); String[] filterClassNames = Stream.concat(classNameStream, packageStream).toArray(String[]::new); if (filterClassNames.length != 0) { LOG.info("Using filter classnames: ");
private List<String> searchEditableProfiles(DbSession dbSession, OrganizationDto organization) { if (!userSession.isLoggedIn()) { return emptyList(); } String login = userSession.getLogin(); UserDto user = dbClient.userDao().selectActiveUserByLogin(dbSession, login); checkState(user != null, "User with login '%s' is not found'", login); return Stream.concat( dbClient.qProfileEditUsersDao().selectQProfileUuidsByOrganizationAndUser(dbSession, organization, user).stream(), dbClient.qProfileEditGroupsDao().selectQProfileUuidsByOrganizationAndGroups(dbSession, organization, userSession.getGroups()).stream()) .collect(toList()); }
private static HighlightBuilder.Field createHighlighterField() { HighlightBuilder.Field field = new HighlightBuilder.Field(FIELD_NAME); field.highlighterType("fvh"); field.matchedFields( Stream.concat( Stream.of(FIELD_NAME), Arrays .stream(NAME_ANALYZERS) .map(a -> a.subField(FIELD_NAME))) .toArray(String[]::new)); return field; }
private static <RAW extends Trackable, BASE extends Trackable> List<BASE> concatIssues( NonClosedTracking<RAW, BASE> nonClosedTracking, ClosedTracking<RAW, BASE> closedTracking) { Collection<BASE> nonClosedIssues = nonClosedTracking.getBaseInput().getIssues(); Collection<BASE> closeIssues = closedTracking.getBaseInput().getIssues(); return Stream.concat(nonClosedIssues.stream(), closeIssues.stream()) .collect(toList(nonClosedIssues.size() + closeIssues.size())); } }
@Override public void deleteIndexes(String name, String... otherNames) { GetMappingsResponse mappings = client.nativeClient().admin().indices().prepareGetMappings("_all").get(); Set<String> existingIndices = Sets.newHashSet(mappings.mappings().keysIt()); Stream.concat(Stream.of(name), Arrays.stream(otherNames)) .distinct() .filter(existingIndices::contains) .forEach(this::deleteIndex); }
private String[] exclusions(Function<String, String[]> configProvider, String globalExclusionsProperty, String exclusionsProperty) { String[] globalExclusions = configProvider.apply(globalExclusionsProperty); String[] exclusions = configProvider.apply(exclusionsProperty); return Stream.concat(Arrays.stream(globalExclusions), Arrays.stream(exclusions)) .map(StringUtils::trim) .toArray(String[]::new); }
@Test public void checkNode_returns_YELLOW_status_if_only_GREEN_and_at_least_one_YELLOW_statuses_returned_by_NodeHealthCheck() { List<Health.Status> statuses = new ArrayList<>(); Stream.concat( IntStream.range(0, 1 + random.nextInt(20)).mapToObj(i -> YELLOW), // at least 1 YELLOW IntStream.range(0, random.nextInt(20)).mapToObj(i -> GREEN)).forEach(statuses::add); // between 0 and 19 GREEN Collections.shuffle(statuses); HealthCheckerImpl underTest = newNodeHealthCheckerImpl(statuses.stream()); assertThat(underTest.checkNode().getStatus()) .describedAs("%s should have been computed from %s statuses", YELLOW, statuses) .isEqualTo(YELLOW); }
public static <T> T[] symmetricDifference(T[] first, T[] second) { Set<T> sA = new HashSet<>(Arrays.asList(first)); Set<T> sB = new HashSet<>(Arrays.asList(second)); return Stream.concat( Arrays.stream(first).filter(a -> !sB.contains(a)), Arrays.stream(second).filter(b -> !sA.contains(b)) ).toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass())); }
@Override public String toString() { List<String> allConstraints = concat( typeVariableConstraints.stream().map(TypeVariableConstraint::toString), longVariableConstraints.stream().map(LongVariableConstraint::toString)) .collect(Collectors.toList()); return name + (allConstraints.isEmpty() ? "" : "<" + Joiner.on(",").join(allConstraints) + ">") + "(" + Joiner.on(",").join(argumentTypes) + "):" + returnType; }
public static KeyStoreHelper create(VertxInternal vertx, TrustOptions options) throws Exception { if (options instanceof KeyCertOptions) { return create(vertx, (KeyCertOptions) options); } else if (options instanceof PemTrustOptions) { PemTrustOptions trustOptions = (PemTrustOptions) options; Stream<Buffer> certValues = trustOptions. getCertPaths(). stream(). map(path -> vertx.resolveFile(path).getAbsolutePath()). map(vertx.fileSystem()::readFileBlocking); certValues = Stream.concat(certValues, trustOptions.getCertValues().stream()); return new KeyStoreHelper(loadCA(certValues), null); } else { return null; } }
.map(String::trim) .filter(blank.negate()); .map(String::trim) .filter(blank.negate()) .flatMap(packageName -> cp.getTopLevelClasses(packageName).stream()) .map(ClassPath.ClassInfo::load) .filter(ZuulFilter.class::isAssignableFrom) .map(Class::getCanonicalName); String[] filterClassNames = Stream.concat(classNameStream, packageStream).toArray(String[]::new); if (filterClassNames.length != 0) { LOG.info("Using filter classnames: ");