Stream.allMatch
Code IndexAdd Codota to your IDE (free)

Best code snippets using java.util.stream.Stream.allMatch(Showing top 20 results out of 2,853)

Refine search

  • List.stream
  • Stream.map
  • Stream.collect
  • Collection.stream
  • Set.stream
  • Common ways to obtain Stream
private void myMethod () {
Stream s =
  • Stream.empty()
  • List list;list.stream()
  • AI code suggestions by Codota
}
origin: prestodb/presto

@Deprecated
private String rowToString()
{
  verify(parameters.stream().allMatch(parameter -> parameter.getKind() == ParameterKind.NAMED_TYPE),
      format("Incorrect parameters for row type %s", parameters));
  String fields = parameters.stream()
      .map(TypeSignatureParameter::getNamedTypeSignature)
      .map(parameter -> format("%s %s", parameter.getName(), parameter.getTypeSignature().toString()))
      .collect(Collectors.joining(","));
  return format("row(%s)", fields);
}
origin: prestodb/presto

  @Override
  public Type createType(TypeManager typeManager, List<TypeParameter> parameters)
  {
    checkArgument(parameters.size() >= 1, "Function type must have at least one parameter, got %s", parameters);
    checkArgument(
        parameters.stream().allMatch(parameter -> parameter.getKind() == ParameterKind.TYPE),
        "Expected only types as a parameters, got %s",
        parameters);
    List<Type> types = parameters.stream().map(parameter -> parameter.getType()).collect(toList());

    return new FunctionType(types.subList(0, types.size() - 1), types.get(types.size() - 1));
  }
}
origin: prestodb/presto

private static boolean isTypeWithLiteralParameters(TypeSignature typeSignature)
{
  return typeSignature.getParameters().stream()
      .map(TypeSignatureParameter::getKind)
      .allMatch(kind -> kind == ParameterKind.LONG || kind == ParameterKind.VARIABLE);
}
origin: prestodb/presto

private static boolean isScheduled(Optional<StageInfo> rootStage)
{
  if (!rootStage.isPresent()) {
    return false;
  }
  return getAllStages(rootStage).stream()
      .map(StageInfo::getState)
      .allMatch(state -> (state == StageState.RUNNING) || state.isDone());
}
origin: prestodb/presto

public boolean isDecomposable(FunctionRegistry functionRegistry)
{
  return (getAggregations().entrySet().stream()
      .map(entry -> functionRegistry.getAggregateFunctionImplementation(entry.getValue().getSignature()))
      .allMatch(InternalAggregationFunction::isDecomposable)) &&
      getAggregations().entrySet().stream()
          .allMatch(entry -> !entry.getValue().getCall().getOrderBy().isPresent());
}
origin: prestodb/presto

@GuardedBy("this")
private void checkFlushComplete()
{
  // This buffer type assigns each page to a single, arbitrary reader,
  // so we don't need to wait for no-more-buffers to finish the buffer.
  // Any readers added after finish will simply receive no data.
  BufferState state = this.state.get();
  if ((state == FLUSHING) || ((state == NO_MORE_PAGES) && masterBuffer.isEmpty())) {
    if (safeGetBuffersSnapshot().stream().allMatch(ClientBuffer::isDestroyed)) {
      destroy();
    }
  }
}
origin: apache/storm

/**
 * Convenience method for data.stream.allMatch(pred)
 */
public static <T> boolean isEvery(Collection<T> data, Predicate<T> pred) {
  return data.stream().allMatch(pred);
}

origin: spring-projects/spring-boot

@ReadOperation
public MetricResponse metric(@Selector String requiredMetricName,
    @Nullable List<String> tag) {
  Assert.isTrue(tag == null || tag.stream().allMatch((t) -> t.contains(":")),
      "Each tag parameter must be in the form key:value");
  List<Tag> tags = parseTags(tag);
  List<Meter> meters = new ArrayList<>();
  collectMeters(meters, this.registry, requiredMetricName, tags);
  if (meters.isEmpty()) {
    return null;
  }
  Map<Statistic, Double> samples = getSamples(meters);
  Map<String, Set<String>> availableTags = getAvailableTags(meters);
  tags.forEach((t) -> availableTags.remove(t.getKey()));
  return new MetricResponse(requiredMetricName, asList(samples, Sample::new),
      asList(availableTags, AvailableTag::new));
}
origin: druid-io/druid

SegmentProvider(List<DataSegment> segments)
{
 Preconditions.checkArgument(segments != null && !segments.isEmpty());
 final String dataSource = segments.get(0).getDataSource();
 Preconditions.checkArgument(
   segments.stream().allMatch(segment -> segment.getDataSource().equals(dataSource)),
   "segments should have the same dataSource"
 );
 this.segments = segments;
 this.dataSource = dataSource;
 this.interval = JodaUtils.umbrellaInterval(
   segments.stream().map(DataSegment::getInterval).collect(Collectors.toList())
 );
}
origin: prestodb/presto

@Override
public synchronized void noMoreSplits(PlanNodeId sourceId)
{
  noMoreSplits.add(sourceId);
  boolean allSourcesComplete = Stream.concat(fragment.getPartitionedSourceNodes().stream(), fragment.getRemoteSourceNodes().stream())
      .filter(Objects::nonNull)
      .map(PlanNode::getId)
      .allMatch(noMoreSplits::contains);
  if (allSourcesComplete) {
    taskStateMachine.finished();
  }
}
origin: prestodb/presto

@Override
public Boolean visitCall(CallExpression call, Void context)
{
  Signature signature = call.getSignature();
  if (registry.isRegistered(signature) && !registry.getScalarFunctionImplementation(signature).isDeterministic()) {
    return false;
  }
  return call.getArguments().stream()
      .allMatch(expression -> expression.accept(this, context));
}
origin: prestodb/presto

private static List<ColumnStatistics> toFileStats(List<List<ColumnStatistics>> stripes)
{
  if (stripes.isEmpty()) {
    return ImmutableList.of();
  }
  int columnCount = stripes.get(0).size();
  checkArgument(stripes.stream().allMatch(stripe -> columnCount == stripe.size()));
  ImmutableList.Builder<ColumnStatistics> fileStats = ImmutableList.builder();
  for (int i = 0; i < columnCount; i++) {
    int column = i;
    fileStats.add(ColumnStatistics.mergeColumnStatistics(stripes.stream()
        .map(stripe -> stripe.get(column))
        .collect(toList())));
  }
  return fileStats.build();
}
origin: prestodb/presto

@Override
protected Boolean visitArrayConstructor(ArrayConstructor node, Void context)
{
  return node.getValues().stream().allMatch(expression -> process(expression, context));
}
origin: prestodb/presto

@Override
public PlanNode visitProject(ProjectNode node, RewriteContext<Expression> context)
{
  Set<Symbol> deterministicSymbols = node.getAssignments().entrySet().stream()
      .filter(entry -> DeterminismEvaluator.isDeterministic(entry.getValue()))
      .map(Map.Entry::getKey)
      .collect(Collectors.toSet());
  Predicate<Expression> deterministic = conjunct -> SymbolsExtractor.extractUnique(conjunct).stream()
      .allMatch(deterministicSymbols::contains);
  Map<Boolean, List<Expression>> conjuncts = extractConjuncts(context.get()).stream().collect(Collectors.partitioningBy(deterministic));
  // Push down conjuncts from the inherited predicate that don't depend on non-deterministic assignments
  PlanNode rewrittenNode = context.defaultRewrite(node, inlineSymbols(node.getAssignments().getMap(), combineConjuncts(conjuncts.get(true))));
  // All non-deterministic conjuncts, if any, will be in the filter node.
  if (!conjuncts.get(false).isEmpty()) {
    rewrittenNode = new FilterNode(idAllocator.getNextId(), rewrittenNode, combineConjuncts(conjuncts.get(false)));
  }
  return rewrittenNode;
}
origin: prestodb/presto

private Map<TableColumnStatisticsCacheKey, Optional<HiveColumnStatistics>> loadColumnStatistics(Iterable<? extends TableColumnStatisticsCacheKey> keys)
{
  if (Iterables.isEmpty(keys)) {
    return ImmutableMap.of();
  }
  HiveTableName hiveTableName = stream(keys).findFirst().get().getHiveTableName();
  checkArgument(stream(keys).allMatch(key -> key.getHiveTableName().equals(hiveTableName)), "all keys must relate to same hive table");
  Set<String> columnNames = stream(keys).map(TableColumnStatisticsCacheKey::getColumnName).collect(Collectors.toSet());
  Optional<Map<String, HiveColumnStatistics>> columnStatistics = delegate.getTableColumnStatistics(hiveTableName.getDatabaseName(), hiveTableName.getTableName(), columnNames);
  ImmutableMap.Builder<TableColumnStatisticsCacheKey, Optional<HiveColumnStatistics>> resultMap = ImmutableMap.builder();
  for (TableColumnStatisticsCacheKey key : keys) {
    if (!columnStatistics.isPresent() || !columnStatistics.get().containsKey(key.getColumnName())) {
      resultMap.put(key, Optional.empty());
    }
    else {
      resultMap.put(key, Optional.of(columnStatistics.get().get(key.getColumnName())));
    }
  }
  return resultMap.build();
}
origin: prestodb/presto

private static void verifyFileHasColumnNames(List<String> physicalColumnNames, Path path)
{
  if (!physicalColumnNames.isEmpty() && physicalColumnNames.stream().allMatch(physicalColumnName -> DEFAULT_HIVE_COLUMN_NAME_PATTERN.matcher(physicalColumnName).matches())) {
    throw new PrestoException(
        HIVE_FILE_MISSING_COLUMN_NAMES,
        "ORC file does not contain column names in the footer: " + path);
  }
}
origin: prestodb/presto

private boolean isImplicitRowType(Type type)
{
  return type.getTypeSignature().getParameters()
      .stream()
      .map(TypeSignatureParameter::getNamedTypeSignature)
      .map(NamedTypeSignature::getName)
      .allMatch(name -> name.startsWith(implicitPrefix));
}
origin: google/error-prone

private static Predicate<String> areAllReturnStatementsAssignable(
  ImmutableSet<ClassType> returnStatementsTypes) {
 return s ->
   returnStatementsTypes
     .stream()
     .map(MutableMethodReturnType::getImmutableSuperTypesForClassType)
     .allMatch(c -> c.contains(s));
}
origin: prestodb/presto

public boolean isPartitionedOn(Collection<Symbol> columns, Set<Symbol> knownConstants)
{
  // partitioned on (k_1, k_2, ..., k_n) => partitioned on (k_1, k_2, ..., k_n, k_n+1, ...)
  // can safely ignore all constant columns when comparing partition properties
  return arguments.stream()
      .filter(ArgumentBinding::isVariable)
      .map(ArgumentBinding::getColumn)
      .filter(symbol -> !knownConstants.contains(symbol))
      .allMatch(columns::contains);
}
origin: eclipse/che

@Override
public void actionPerformed(ActionEvent e) {
 Set<PartStack> partStacks = new HashSet<>(3);
 partStacks.add(workspaceAgent.getPartStack(NAVIGATION));
 partStacks.add(workspaceAgent.getPartStack(TOOLING));
 partStacks.add(workspaceAgent.getPartStack(INFORMATION));
 Set<State> states = partStacks.stream().map(PartStack::getPartStackState).collect(toSet());
 if (states.stream().anyMatch(state -> MINIMIZED == state)) {
  partStacks.forEach(PartStack::restore);
  activateEditor();
  return;
 }
 PartPresenter activePart = workspaceAgent.getActivePart();
 if (activePart == null || !(activePart instanceof EditorPartPresenter)) {
  activateEditor();
  return;
 }
 if (states.stream().allMatch(state -> HIDDEN == state)) {
  partStacks.forEach(PartStack::show);
  activateEditor();
  return;
 }
 partStacks.forEach(PartStack::minimize);
 activateEditor();
}
java.util.streamStreamallMatch

Javadoc

Returns whether all elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then true is returned and the predicate is not evaluated.

This is a short-circuiting terminal operation.

Popular methods of Stream

  • collect
  • map
  • filter
  • forEach
  • findFirst
  • of
  • anyMatch
  • flatMap
  • sorted
  • toArray
  • count
  • findAny
  • count,
  • findAny,
  • reduce,
  • concat,
  • distinct,
  • mapToInt,
  • iterator,
  • empty,
  • limit

Popular classes and methods

  • getSharedPreferences (Context)
  • setScale (BigDecimal)
    Returns a new BigDecimal instance with the specified scale. If the new scale is greater than the old
  • getResourceAsStream (ClassLoader)
    Returns a stream for the resource with the specified name. See #getResource(String) for a descriptio
  • Selector (java.nio.channels)
    A controller for the selection of SelectableChannel objects. Selectable channels can be registered w
  • Format (java.text)
    Format is an abstract base class for formatting locale-sensitive information such as dates, messages
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • ReentrantLock (java.util.concurrent.locks)
    A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor
  • Reference (javax.naming)
  • Scheduler (org.quartz)
    This is the main interface of a Quartz Scheduler. A Scheduler maintains a registry of org.quartz.Job
  • SAXParseException (org.xml.sax)
    Encapsulate an XML parse error or warning.> This module, both source code and documentation, is in t

For IntelliJ IDEA and
Android Studio

  • Codota IntelliJ IDEA pluginCodota Android Studio pluginCode IndexSign in
  • EnterpriseFAQAboutContact Us
  • Terms of usePrivacy policyCodeboxFind Usages
Add Codota to your IDE (free)