How to use

anyMatch

method

in

java.util.stream.Stream

private AcceptPredicate(Set<MediaType> mediaTypes) {
  super(headers -> {
    List<MediaType> acceptedMediaTypes = acceptedMediaTypes(headers);
    boolean match = acceptedMediaTypes.stream()
        .anyMatch(acceptedMediaType -> mediaTypes.stream()
            .anyMatch(acceptedMediaType::isCompatibleWith));
    traceMatch("Accept", mediaTypes, acceptedMediaTypes, match);
    return match;
  });
  this.mediaTypes = mediaTypes;
}

private static boolean isS3Storage(String path)
{
  return SUPPORTED_S3_PREFIXES.stream().anyMatch(path::startsWith);
}

private static <T> boolean containsNoneDomain(Map<T, Domain> domains)
{
  return domains.values().stream().anyMatch(Domain::isNone);
}

@Override
public boolean inheritsFields() {
  return projections.stream().filter(FieldProjection.class::isInstance) //
      .map(FieldProjection.class::cast) //
      .anyMatch(FieldProjection::isExcluded);
}

  private boolean splitFields(Method model) {
    return model.getFields().size() >= 3 || model.getFields().stream()
      .anyMatch(f -> !f.getAnnotations().isEmpty());
  }
}

private boolean hasComments(List<? extends Node> nodes) {
  return nodes.stream().anyMatch(it -> it.getComments().size() > 0);
}

private static Map<String, PartitionStatistics> getPartitionsStatistics(SemiTransactionalHiveMetastore metastore, SchemaTableName table, List<HivePartition> hivePartitions)
{
  if (hivePartitions.isEmpty()) {
    return ImmutableMap.of();
  }
  boolean unpartitioned = hivePartitions.stream().anyMatch(partition -> partition.getPartitionId().equals(UNPARTITIONED_ID));
  if (unpartitioned) {
    checkArgument(hivePartitions.size() == 1, "expected only one hive partition");
    return ImmutableMap.of(UNPARTITIONED_ID, metastore.getTableStatistics(table.getSchemaName(), table.getTableName()));
  }
  Set<String> partitionNames = hivePartitions.stream()
      .map(HivePartition::getPartitionId)
      .collect(toImmutableSet());
  return metastore.getPartitionStatistics(table.getSchemaName(), table.getTableName(), partitionNames);
}

private static void validatePropertySet(SetRequest request, @Nullable PropertyDefinition definition) {
 checkRequest(definition != null, "Setting '%s' is undefined", request.getKey());
 checkRequest(PropertyType.PROPERTY_SET.equals(definition.type()), "Parameter '%s' is used for setting of property set type only", PARAM_FIELD_VALUES);
 Set<String> fieldKeys = definition.fields().stream().map(PropertyFieldDefinition::key).collect(Collectors.toSet());
 ListMultimap<String, String> valuesByFieldKeys = ArrayListMultimap.create(fieldKeys.size(), request.getFieldValues().size() * fieldKeys.size());
 request.getFieldValues().stream()
  .map(oneFieldValues -> readOneFieldValues(oneFieldValues, request.getKey()))
  .peek(map -> checkRequest(map.values().stream().anyMatch(StringUtils::isNotBlank), MSG_NO_EMPTY_VALUE))
  .flatMap(map -> map.entrySet().stream())
  .peek(entry -> valuesByFieldKeys.put(entry.getKey(), entry.getValue()))
  .forEach(entry -> checkRequest(fieldKeys.contains(entry.getKey()), "Unknown field key '%s' for setting '%s'", entry.getKey(), request.getKey()));
 checkFieldType(request, definition, valuesByFieldKeys);
}

@Override
public boolean isAccepted(MediaType mediaType) {
  Objects.requireNonNull(mediaType, "Parameter 'mediaType' is null!");
  List<MediaType> acceptedTypes = acceptedTypes();
  return acceptedTypes.isEmpty() || acceptedTypes.stream().anyMatch(mediaType);
}

@Test
public void testHandleDeadWorker() throws Exception {
 Table table = TEST_UTIL.createTable(TABLE_NAME, FAMILY, TEST_UTIL.KEYS_FOR_HBA_CREATE_TABLE);
 for (int i = 0; i < 10; i++) {
  TEST_UTIL.loadTable(table, FAMILY);
 }
 HRegionServer testServer = TEST_UTIL.getHBaseCluster().getRegionServer(0);
 ProcedureExecutor<MasterProcedureEnv> masterPE = master.getMasterProcedureExecutor();
 List<FileStatus> wals = splitWALManager.getWALsToSplit(testServer.getServerName(), false);
 Assert.assertEquals(1, wals.size());
 TEST_UTIL.getHBaseCluster().killRegionServer(testServer.getServerName());
 TEST_UTIL.waitFor(30000, () -> master.getProcedures().stream()
   .anyMatch(procedure -> procedure instanceof SplitWALProcedure));
 Procedure splitWALProcedure = master.getProcedures().stream()
   .filter(procedure -> procedure instanceof SplitWALProcedure).findAny().get();
 Assert.assertNotNull(splitWALProcedure);
 TEST_UTIL.waitFor(5000, () -> ((SplitWALProcedure) splitWALProcedure).getWorker() != null);
 TEST_UTIL.getHBaseCluster()
   .killRegionServer(((SplitWALProcedure) splitWALProcedure).getWorker());
 ProcedureTestingUtility.waitProcedure(masterPE, splitWALProcedure.getProcId());
 Assert.assertTrue(splitWALProcedure.isSuccess());
 ProcedureTestingUtility.waitAllProcedures(masterPE);
}

private static boolean hasSpatialPartitioningAggregation(AggregationNode aggregation)
{
  return aggregation.getAggregations().values().stream()
      .map(Aggregation::getCall)
      .anyMatch(call -> call.getName().toString().equals(NAME) && call.getArguments().size() == 1);
}

@Test
public void testCommandManagerLoadsUserCommand() throws Exception {
 Properties props = new Properties();
 props.setProperty(ConfigurationProperties.USER_COMMAND_PACKAGES, "com.examples");
 CommandManager commandManager = new CommandManager(props, null);
 assertThat(
   commandManager.getCommandMarkers().stream().anyMatch(c -> c instanceof UserGfshCommand));
}

  private void validate(short version, List<AclBindingFilter> filters) {
    if (version == 0) {
      final boolean unsupported = filters.stream()
        .map(AclBindingFilter::patternFilter)
        .map(ResourcePatternFilter::patternType)
        .anyMatch(patternType -> patternType != PatternType.LITERAL && patternType != PatternType.ANY);
      if (unsupported) {
        throw new UnsupportedVersionException("Version 0 only supports literal resource pattern types");
      }
    }

    final boolean unknown = filters.stream().anyMatch(AclBindingFilter::isUnknown);
    if (unknown) {
      throw new IllegalArgumentException("Filters contain UNKNOWN elements");
    }
  }
}

private boolean handleExcludeURL(HttpServletRequest request) {
  if (excludes == null || excludes.isEmpty()) {
    return false;
  }
  String url = request.getServletPath();
  return excludes.stream().map(pattern -> Pattern.compile("^" + pattern)).map(p -> p.matcher(url)).anyMatch(Matcher::find);
}

public WebUserTokenInterceptor(UserTokenManager userTokenManager, List<UserTokenParser> userTokenParser,AopMethodAuthorizeDefinitionParser definitionParser) {
  this.userTokenManager = userTokenManager;
  this.userTokenParser = userTokenParser;
  this.parser=definitionParser;
  enableBasicAuthorization = userTokenParser.stream()
      .filter(UserTokenForTypeParser.class::isInstance)
      .anyMatch(parser -> "basic".equalsIgnoreCase(((UserTokenForTypeParser) parser).getTokenType()));
}

@Override
public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType) {
  if (mimeType == null) {
    return true;
  }
  return this.decodableMimeTypes.stream().anyMatch(candidate -> candidate.isCompatibleWith(mimeType));
}

private static boolean hasSourceDistributedStage(Set<SqlStageExecution> phase)
{
  return phase.stream().anyMatch(stage -> !stage.getFragment().getPartitionedSources().isEmpty());
}

public static List<String> getSansTop25(Collection<String> cwe) {
 return SANS_TOP_25_CWE_MAPPING
  .keySet()
  .stream()
  .filter(k -> cwe.stream().anyMatch(SANS_TOP_25_CWE_MAPPING.get(k)::contains))
  .collect(toList());
}

  public static boolean dependsOn(WindowNode parent, WindowNode child)
  {
    return parent.getPartitionBy().stream().anyMatch(child.getCreatedSymbols()::contains)
        || (parent.getOrderingScheme().isPresent() && parent.getOrderingScheme().get().getOrderBy().stream().anyMatch(child.getCreatedSymbols()::contains))
        || parent.getWindowFunctions().values().stream()
        .map(WindowNode.Function::getFunctionCall)
        .map(SymbolsExtractor::extractUnique)
        .flatMap(Collection::stream)
        .anyMatch(child.getCreatedSymbols()::contains);
  }
}

public boolean hasOrderings()
{
  return aggregations.values().stream()
      .map(Aggregation::getCall)
      .map(FunctionCall::getOrderBy)
      .anyMatch(Optional::isPresent);
}