org.eclipse.collections.api.LazyIterable Maven / Gradle / Ivy
/*
* Copyright (c) 2018 Goldman Sachs and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.api;
import java.util.Collection;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.primitive.BooleanFunction;
import org.eclipse.collections.api.block.function.primitive.ByteFunction;
import org.eclipse.collections.api.block.function.primitive.CharFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleFunction;
import org.eclipse.collections.api.block.function.primitive.FloatFunction;
import org.eclipse.collections.api.block.function.primitive.IntFunction;
import org.eclipse.collections.api.block.function.primitive.LongFunction;
import org.eclipse.collections.api.block.function.primitive.ShortFunction;
import org.eclipse.collections.api.block.predicate.Predicate;
import org.eclipse.collections.api.block.predicate.Predicate2;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.ordered.OrderedIterable;
import org.eclipse.collections.api.tuple.Pair;
/**
* A LazyIterable is RichIterable which will defer evaluation for certain methods like select, reject, collect, etc.
* Any methods that do not return a LazyIterable when called will cause evaluation to be forced.
*
* @since 1.0
*/
public interface LazyIterable
extends RichIterable
{
@Override
T getFirst();
/**
* Creates a deferred iterable for selecting elements from the current iterable.
*/
@Override
LazyIterable select(Predicate predicate);
@Override
LazyIterable selectWith(Predicate2 predicate, P parameter);
@Override
LazyIterable selectInstancesOf(Class clazz);
/**
* Creates a deferred iterable for rejecting elements from the current iterable.
*/
@Override
LazyIterable reject(Predicate predicate);
@Override
LazyIterable rejectWith(Predicate2 predicate, P parameter);
/**
* Creates a deferred iterable for collecting elements from the current iterable.
*/
@Override
LazyIterable collect(Function function);
@Override
LazyIterable collectWith(Function2 function, P parameter);
/**
* Creates a deferred iterable for selecting and collecting elements from the current iterable.
*/
@Override
LazyIterable collectIf(Predicate predicate, Function function);
/**
* Creates a deferred take iterable for the current iterable using the specified count as the limit.
*/
LazyIterable take(int count);
/**
* Creates a deferred drop iterable for the current iterable using the specified count as the limit.
*/
LazyIterable drop(int count);
/**
* @see OrderedIterable#takeWhile(Predicate)
* @since 8.0
*/
LazyIterable takeWhile(Predicate predicate);
/**
* @see OrderedIterable#dropWhile(Predicate)
* @since 8.0
*/
LazyIterable dropWhile(Predicate predicate);
/**
* Creates a deferred distinct iterable to get distinct elements from the current iterable.
*
* @since 5.0
*/
LazyIterable distinct();
/**
* Creates a deferred flattening iterable for the current iterable.
*/
@Override
LazyIterable flatCollect(Function> function);
/**
* @since 9.2
*/
@Override
default LazyIterable flatCollectWith(Function2> function, P parameter)
{
return this.flatCollect(each -> function.apply(each, parameter));
}
/**
* Creates a deferred iterable that will join this iterable with the specified iterable.
*/
LazyIterable concatenate(Iterable iterable);
/**
* Creates a deferred zip iterable.
*/
@Override
LazyIterable> zip(Iterable that);
/**
* Creates a deferred zipWithIndex iterable.
*/
@Override
LazyIterable> zipWithIndex();
/**
* Creates a deferred chunk iterable.
*/
@Override
LazyIterable> chunk(int size);
/**
* Creates a deferred tap iterable.
*/
@Override
LazyIterable tap(Procedure procedure);
/**
* Iterates over this iterable adding all elements into the target collection.
*/
@Override
> R into(R target);
/**
* Returns a lazy BooleanIterable which will transform the underlying iterable data to boolean values based on the booleanFunction.
*/
@Override
LazyBooleanIterable collectBoolean(BooleanFunction booleanFunction);
/**
* Returns a lazy ByteIterable which will transform the underlying iterable data to byte values based on the byteFunction.
*/
@Override
LazyByteIterable collectByte(ByteFunction byteFunction);
/**
* Returns a lazy CharIterable which will transform the underlying iterable data to char values based on the charFunction.
*/
@Override
LazyCharIterable collectChar(CharFunction charFunction);
/**
* Returns a lazy DoubleIterable which will transform the underlying iterable data to double values based on the doubleFunction.
*/
@Override
LazyDoubleIterable collectDouble(DoubleFunction doubleFunction);
/**
* Returns a lazy FloatIterable which will transform the underlying iterable data to float values based on the floatFunction.
*/
@Override
LazyFloatIterable collectFloat(FloatFunction floatFunction);
/**
* Returns a lazy IntIterable which will transform the underlying iterable data to int values based on the intFunction.
*/
@Override
LazyIntIterable collectInt(IntFunction intFunction);
/**
* Returns a lazy LongIterable which will transform the underlying iterable data to long values based on the longFunction.
*/
@Override
LazyLongIterable collectLong(LongFunction longFunction);
/**
* Returns a lazy ShortIterable which will transform the underlying iterable data to short values based on the shortFunction.
*/
@Override
LazyShortIterable collectShort(ShortFunction shortFunction);
}