Example usage for java.util.stream Stream empty

Introduction

In this page you can find the example usage for java.util.stream Stream empty.

Prototype

public static <T> Stream<T> empty()

Source Link

Document

Returns an empty sequential Stream .

Usage

From source file:org.sonar.java.se.xproc.MethodYield.java

public Stream<ProgramState> parametersAfterInvocation(List<SymbolicValue> invocationArguments,
        List<Type> invocationTypes, ProgramState programState) {
    Set<ProgramState> results = new LinkedHashSet<>();
    for (int index = 0; index < invocationArguments.size(); index++) {
        PMap<Class<? extends Constraint>, Constraint> constraints = getConstraint(index, invocationTypes);
        if (constraints == null) {
            // no constraints on this parameter, let's try next one.
            continue;
        }/*from   w  w  w  . ja va 2s  .c o m*/

        SymbolicValue invokedArg = invocationArguments.get(index);
        Set<ProgramState> programStates = programStatesForConstraint(
                results.isEmpty() ? Lists.newArrayList(programState) : results, invokedArg, constraints);
        if (programStates.isEmpty()) {
            // constraints can't be satisfied, no need to process things further, this yield is not applicable.
            // TODO there might be some issue to report in this case.
            return Stream.empty();
        }
        results = programStates;
    }

    // resulting program states can be empty if all constraints on params are null or if method has no arguments.
    // That means that this yield is still possible and we need to stack a returned SV with its eventual constraints.
    if (results.isEmpty()) {
        results.add(programState);
    }
    return results.stream();
}

From source file:org.opensingular.lib.wicket.util.lambda.ILambdasMixin.java

default <T> IFunction<T, Stream<T>> recursiveCollection(IFunction<T, Collection<T>> childrenFunction) {
    IFunction<Collection<T>, Stream<T>> toStream = c -> (c == null) ? Stream.empty() : c.stream();
    return t -> Stream.concat(Stream.of(t), (t == null) ? Stream.empty()
            : toStream.apply(childrenFunction.apply(t)).flatMap(recursiveCollection(childrenFunction)));
}

From source file:de.qaware.chronix.storage.solr.timeseries.metric.MetricTimeSeries.java

/**
 * A stream over the points/*w  ww.  jav a 2  s.  c  o m*/
 *
 * @return the points as points
 */
public Stream<Point> points() {
    if (timestamps.isEmpty()) {
        return Stream.empty();
    }
    return Stream.iterate(of(0), pair -> of(pair.getIndex() + 1)).limit(timestamps.size());
}

From source file:org.cryptomator.filesystem.crypto.CryptoFolder.java

private Stream<File> nonConflictingFiles() {
    if (exists()) {
        final Stream<? extends File> files = physicalFolder().filter(Folder::exists).map(Folder::files)
                .orElse(Stream.empty());
        return files.filter(startsWithEncryptedName()).map(conflictResolver::resolveIfNecessary).distinct();
    } else {/*w w  w .jav a 2s . co  m*/
        throw new UncheckedIOException(new FileNotFoundException(format("Folder %s does not exist", this)));
    }
}

From source file:org.ecloudmanager.deployment.vm.GatewayVMDeployment.java

@Override
public Stream<Deployable> getRequired() {
    return Stream.empty();
}

From source file:com.uber.okbuck.core.util.ProjectUtil.java

@Nullable
public static String findVersionInClasspath(Project project, String group, String module) {
    return project.getBuildscript().getConfigurations().getByName("classpath").getIncoming().getArtifacts()
            .getArtifacts().stream()/*from ww  w . j a  v a2  s . c o  m*/
            .flatMap(artifactResult -> artifactResult.getId()
                    .getComponentIdentifier() instanceof ModuleComponentIdentifier
                            ? Stream.of(
                                    (ModuleComponentIdentifier) artifactResult.getId().getComponentIdentifier())
                            : Stream.empty())
            .filter(identifier -> (group.equals(identifier.getGroup())
                    && module.equals(identifier.getModule())))
            .findFirst().map(ModuleComponentIdentifier::getVersion).orElse(null);
}

From source file:com.uber.hoodie.common.model.HoodieFileGroup.java

/**
 * Provides a stream of committed file slices, sorted reverse base commit time.
 *
 * @return//  www  . j av  a 2  s  . c o  m
 */
public Stream<FileSlice> getAllFileSlices() {
    if (!timeline.empty()) {
        return fileSlices.entrySet().stream().map(sliceEntry -> sliceEntry.getValue())
                .filter(slice -> isFileSliceCommitted(slice));
    }
    return Stream.empty();
}

From source file:com.github.steveash.guavate.GuavateTest.java

@Test
public void test_ensureOnlyOne() {
    assertEquals(Stream.empty().reduce(Guavate.ensureOnlyOne()), Optional.empty());
    assertEquals(Stream.of("a").reduce(Guavate.ensureOnlyOne()), Optional.of("a"));
}

From source file:org.opensingular.lib.wicket.util.lambda.ILambdasMixin.java

default <T> IFunction<T, Stream<T>> recursiveIterable(IFunction<T, Iterable<T>> childrenFunction) {
    IFunction<Iterable<T>, Stream<T>> toStream = c -> (c == null) ? Stream.empty()
            : (c instanceof Collection) ? ((Collection<T>) c).stream()
                    : StreamSupport.stream(c.spliterator(), true);
    return t -> Stream.concat(Stream.of(t), (t == null) ? Stream.empty()
            : toStream.apply(childrenFunction.apply(t)).flatMap(recursiveIterable(childrenFunction)));
}

From source file:org.ajoberstar.reckon.core.git.GitInventorySupplier.java

@Override
public VcsInventory getInventory() {
    try (RevWalk walk = new RevWalk(repo)) {
        walk.setRetainBody(false);// www. ja  v a2 s  .c  o  m

        ObjectId headObjectId = repo.getRefDatabase().getRef("HEAD").getObjectId();

        if (headObjectId == null) {
            logger.debug("No HEAD commit. Presuming repo is empty.");
            return new VcsInventory(null, null, null, null, 0, null, null);
        }

        logger.debug("Found HEAD commit {}", headObjectId);

        RevCommit headCommit = walk.parseCommit(headObjectId);

        Set<TaggedVersion> taggedVersions = getTaggedVersions(walk);

        logger.debug("Found tagged versions: {}", taggedVersions);

        Version currentVersion = findCurrent(headCommit, taggedVersions.stream()).map(TaggedVersion::getVersion)
                .orElse(null);
        TaggedVersion baseNormal = findBase(walk, headCommit,
                taggedVersions.stream().filter(TaggedVersion::isNormal));
        TaggedVersion baseVersion = findBase(walk, headCommit, taggedVersions.stream());

        int commitsSinceBase = RevWalkUtils.count(walk, headCommit, baseNormal.getCommit());

        Set<TaggedVersion> parallelCandidates = findParallelCandidates(walk, headCommit, taggedVersions);

        Set<RevCommit> taggedCommits = taggedVersions.stream().map(TaggedVersion::getCommit)
                .collect(Collectors.toSet());
        Set<Version> parallelVersions = parallelCandidates.stream()
                .map(version -> findParallel(walk, headCommit, version, taggedCommits))
                // TODO Java 9 Optional::stream
                .flatMap(opt -> opt.isPresent() ? Stream.of(opt.get()) : Stream.empty())
                .collect(Collectors.toSet());

        Set<Version> claimedVersions = taggedVersions.stream().map(TaggedVersion::getVersion)
                .collect(Collectors.toSet());

        return new VcsInventory(headObjectId.getName(), currentVersion, baseVersion.getVersion(),
                baseNormal.getVersion(), commitsSinceBase, parallelVersions, claimedVersions);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}