com.speedment.runtime.core.internal.stream.builder.streamterminator.ReferenceStreamTerminator Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of tool-deploy Show documentation
A Speedment bundle that shades all dependencies into one jar. This is useful when deploying an application on a server.
The newest version!
/*
 *
 * Copyright (c) 2006-2019, Speedment, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); You may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.speedment.runtime.core.internal.stream.builder.streamterminator;

import com.speedment.runtime.core.internal.stream.builder.pipeline.ReferencePipeline;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Optional;
import java.util.Spliterator;
import java.util.function.*;
import java.util.stream.Collector;

import static java.util.Objects.requireNonNull;

/**
 *
 * @author pemi
 */
public interface ReferenceStreamTerminator extends BaseStreamTerminator {

    default  void forEach(ReferencePipeline pipeline, Consumer action) {
        requireNonNull(pipeline);
        requireNonNull(action);
        optimize(pipeline).getAsReferenceStream().forEach(action);
    }

    default  void forEachOrdered(ReferencePipeline pipeline, Consumer action) {
        requireNonNull(pipeline);
        requireNonNull(action);
        optimize(pipeline).getAsReferenceStream().forEachOrdered(action);
    }

    default  Object[] toArray(ReferencePipeline pipeline) {
        requireNonNull(pipeline);
        return optimize(pipeline).getAsReferenceStream().toArray();
    }

    default  A[] toArray(ReferencePipeline pipeline, IntFunction generator) {
        requireNonNull(pipeline);
        requireNonNull(generator);
        return optimize(pipeline).getAsReferenceStream().toArray(generator);
    }

    default  T reduce(ReferencePipeline pipeline, T identity, BinaryOperator accumulator) {
        requireNonNull(pipeline);
        requireNonNull(identity);
        requireNonNull(accumulator);
        return optimize(pipeline).getAsReferenceStream().reduce(identity, accumulator);
    }

    default  Optional reduce(ReferencePipeline pipeline, BinaryOperator accumulator) {
        requireNonNull(pipeline);
        requireNonNull(accumulator);
        return optimize(pipeline).getAsReferenceStream().reduce(accumulator);
    }

    default  U reduce(ReferencePipeline pipeline, U identity,
        BiFunction accumulator,
        BinaryOperator combiner) {
        requireNonNull(pipeline);
        requireNonNull(identity);
        requireNonNull(accumulator);
        requireNonNull(combiner);
        return optimize(pipeline).getAsReferenceStream().reduce(identity, accumulator, combiner);
    }

    default  R collect(ReferencePipeline pipeline, Supplier supplier,
        BiConsumer accumulator,
        BiConsumer combiner) {
        requireNonNull(pipeline);
        requireNonNull(supplier);
        requireNonNull(accumulator);
        return optimize(pipeline).getAsReferenceStream().collect(supplier, accumulator, combiner);
    }

    default  R collect(ReferencePipeline pipeline, Collector collector) {
        requireNonNull(pipeline);
        requireNonNull(collector);
        return optimize(pipeline).getAsReferenceStream().collect(collector);
    }

    default  Optional min(ReferencePipeline pipeline, Comparator comparator) {
        requireNonNull(pipeline);
        requireNonNull(comparator);
        return optimize(pipeline).getAsReferenceStream().min(comparator);
    }

    default  Optional max(ReferencePipeline pipeline, Comparator comparator) {
        requireNonNull(pipeline);
        requireNonNull(comparator);
        return optimize(pipeline).getAsReferenceStream().max(comparator);
    }

    default  long count(ReferencePipeline pipeline) {
        //return count(pipeline, p -> p.getAsReferenceStream().count());
        requireNonNull(pipeline);
        return optimize(pipeline).getAsReferenceStream().count();
    }

    default  boolean anyMatch(ReferencePipeline pipeline, Predicate predicate) {
        //return anyMatch(pipeline, (pip, pre) -> pip.getAsReferenceStream().anyMatch(pre), predicate);
        requireNonNull(pipeline);
        requireNonNull(predicate);
        return optimize(pipeline).getAsReferenceStream().anyMatch(predicate);
    }

    default  boolean allMatch(ReferencePipeline pipeline, Predicate predicate) {
        requireNonNull(pipeline);
        requireNonNull(predicate);
        return optimize(pipeline).getAsReferenceStream().allMatch(predicate);
    }

    default  boolean noneMatch(ReferencePipeline pipeline, Predicate predicate) {
        requireNonNull(pipeline);
        requireNonNull(predicate);
        return optimize(pipeline).getAsReferenceStream().noneMatch(predicate);
    }

    default  Optional findFirst(ReferencePipeline pipeline) {
        requireNonNull(pipeline);
        return optimize(pipeline).getAsReferenceStream().findFirst();
    }

    default  Optional findAny(ReferencePipeline pipeline) {
        requireNonNull(pipeline);
        return optimize(pipeline).getAsReferenceStream().findAny();
    }

    default  Iterator iterator(ReferencePipeline pipeline) {
        requireNonNull(pipeline);
        return optimize(pipeline).getAsReferenceStream().iterator();
    }

    default  Spliterator spliterator(ReferencePipeline pipeline) {
        requireNonNull(pipeline);
        return optimize(pipeline).getAsReferenceStream().spliterator();
    }

}