Uses of Class
net.sf.staccatocommons.collections.restrictions.Projection

Packages that use Projection

net.sf.staccatocommons.collections.stream

This package contains the interfaces that define a Stream, a lazy, rich, Iterable, an abstract implementation of it, and the Streams hub with class methods for creating simple Streams

Uses of Projection in net.sf.staccatocommons.collections.stream

Methods in net.sf.staccatocommons.collections.stream with annotations of type Projection

Stream<A>	Stream.append(A element) Adds an element as the last one of the stream.
Stream<A>	Stream.append(Iterable<A> other) Deprecated. use Stream.concat(Iterable) instead
Stream<A>	Stream.append(Thunk<A> thunk) Deprecated. use Stream.delayedAppend(Thunk) instead
Stream<A>	Stream.appendUndefined() Concatenates this Stream with the undefined Stream.
<B,C> Stream<Tuple2<B,C>>	Stream.branch(Applicable<? super A,? extends B> function0, Applicable<? super A,? extends C> function1) Answers a Stream of pairs, where each one contains both results of applying the given functions.
<B> Stream<Tuple2<A,B>>	Stream.clone(Applicable<? super A,? extends B> function) Answers a stream that retrieves a tuple per each element, formed by the original element as the first component, and the result of applying the given function to it as the second component.
Stream<A>	Stream.concat(A... elements) Concatenates this with the given elements It answers an Stream that retrieves elements from this Stream, and then, after its last element, the given elements.
Stream<A>	Stream.concat(Iterable<? extends A> other) Concatenates this with other It answers an Stream that retrieves elements from this Stream, and then, after its last element, from the given iterable.
static <A> Stream<A>	Streams.cons(A... elements) Creates a new Stream that retrieves the elements from the given array.
static <A> Stream<A>	Streams.cons(A element) Creates a new Stream that will retrieve just the given element
static <A> Stream<A>	Streams.cons(A head, Stream<? extends A> tail) Creates a new Stream that retrieves elements from a head, and another Iterable, called tail.
static <A> Stream<A>	Streams.cons(Thunk<A> element) Creates a one-element new Stream that will retrieve the thunk's value.
static <A> Stream<A>	Streams.cons(Thunk<A> head, Stream<? extends A> tail) Creates a new Stream that retrieves elements from a head's thunk, and another Iterable, called tail.
Stream<Tuple2<A,A>>	Stream.cross() Answers the Cartesian product of this stream and itself
<B> Stream<Tuple2<A,B>>	Stream.cross(Iterable<B> other) Answers the cartesian product of this Stream and the given Iterable
<B> Stream<Tuple2<A,B>>	Stream.cross(Iterator<B> other) Answers the cartesian product of this Stream and the given Iterator
<B> Stream<Tuple2<A,B>>	Stream.cross(Stream<B> other) Answers the Cartesian product of this stream and the given one
Stream<Stream<A>>	Stream.crossStreams(Stream<Stream<A>> streamOfStreams) Answers the cartesian product of this Stream and each one of the given streamOfStreams
Stream<A>	Stream.delayedAppend(Thunk<A> thunk) Adds an element's thunk as the last one of the stream.
Stream<A>	Stream.delayedPrepend(Thunk<A> thunk) Adds an element's thunk as the first one of the stream.
Stream<A>	Stream.drop(int amountOfElements) Discards up to N elements from this Stream.
Stream<A>	Stream.dropWhile(Evaluable<? super A> predicate) Discards all elements while they satisfy the given predicate
Stream<A>	Stream.each(Executable<? super A> block) Maps the given side effect over this stream, by answering a Stream that lazily applies the given side effect over each stream elements, and retrieves them.
static Stream<Integer>	Streams.enumerate(int start) Iterates from the starting integer, adding 1.
static Stream<Integer>	Streams.enumerate(int start, int stop) Iterates from the start integer, by adding 1, up to the stop integer, inclusive.
static Stream<Integer>	Streams.enumerate(int start, int stop, int step) Iterates from the start integer, by adding step, up to the stop integer, inclusive.
Stream<A>	Stream.filter(Evaluable<? super A> predicate) Preserves elements that satisfy the given predicate Example: //Answers stream [hello, world], which has only strings whose length is 5 Streams.cons("a", "hello", "world", "of", "streams", "!").
Stream<A>	Stream.filterIndex(Evaluable<Integer> predicate) Preserves elements that whose index satisfy the given predicate
<B> Stream<B>	Stream.flatMap(Function<? super A,? extends Iterable<? extends B>> function) Transformes each element into an iterable using the given function, and concatenates (flattens) the result
<B> Stream<B>	Stream.flatMapArray(Function<? super A,? extends B[]> function) Transformes each element into an array using the given function, and concatenates (flattens) the result
static <A> Stream<A>	Streams.from(A[] elements) Creates a new Stream that retrieves the elements from the given array.
static Stream<Character>	Streams.from(CharSequence charSequence) Creates a new Stream that retrieves character elements from the given charSequence
static <A> Stream<A>	Streams.from(Collection<? extends A> collection) Creates a new Stream that will retrieve elements from the given collection
static <A> Stream<A>	Streams.from(Deque<? extends A> list) Creates a new Stream that retrieves elements from a Deque.
static <A> Stream<A>	Streams.from(Enumeration<? extends A> enumeration) Creates a new Stream that retrieves elements from the given Enumeration.
static <A> Stream<A>	Streams.from(Iterable<? extends A> iterable) Create a new Stream that retrieves elements from the given Iterable.
static <A> Stream<A>	Streams.from(Iterator<? extends A> iterator) Creates a new Stream that retrieves elements from the given iterator.
static <A> Stream<A>	Streams.from(List<? extends A> list) Creates a new Stream that retrieves elements from a list.
Stream<A>	Stream.incorporate(A element) Inserts the given value after each element of the stream.
Stream<A>	Stream.incorporate(Function<? super A,? extends A> function) Inserts after each element the result of applying the given function to it.
Stream<Integer>	Stream.indices(Evaluable<? super A> predicate) Answers a stream containing all the zero-based indices of the elements that matches the given predicate
Stream<A>	Stream.insertBefore(A element, A reference) Inserts element before the first occurrence of reference.
Stream<A>	Stream.intersperse(A element) Inserts the given element between each retrieved element of this Stream
static <A> Stream<A>	Streams.iterate(A seed, Applicable<? super A,? extends A> generator) Creates a new infinite Stream that retrieves element from the sequence where the nth element is the given function applied to the nth-1.
static <A> Stream<A>	Streams.iterateUntilNull(A seed, Applicable<? super A,? extends A> generator) Creates a new, potentially infinte Stream that iterates over the given seed and generator, but will stop before any retrieved element would be null.
<B> Stream<B>	Stream.map(Applicable<? super A,? extends B> function) Transforms each element using the given function
<B> Stream<B>	Stream.map(Function<? super A,? extends B> function) Transforms each element using the given function.
Stream<A>	Stream.memoize() Memoizes stream elements and their order, by answering a lazy stream with Repeatable iteration order that caches elements evaluated during iteration.
Stream<A>	Stream.memorize() Deprecated. the exact name of this concept is memoization, not memorization. Use Stream.memoize() instead
Stream<A>	Stream.prepend(A element) Adds an element as the first one of the stream.
Stream<A>	Stream.prepend(Thunk<A> thunk) Deprecated. use Stream.delayedPrepend(Thunk)
static <A> Stream<A>	Streams.repeat(A element) Answers an infinite Stream that indefinitely retrieves the given element.
static <A> Stream<A>	Streams.repeat(Thunk<A> thunk) Answers an infinite Stream that indefinitely retrieves the given thunk's value.
Stream<A>	Stream.skip(A element) Preserves all elements but those that are equal to the given one.
Stream<A>	Stream.skipIndex(int index) Answers a streams that retrieves all the elements of this one, except of that at the given index
Stream<A>	Stream.slice(int beginIndex, int endIndex) Answers a stream that is a substream of this one.
Stream<A>	Stream.sort() Sorts this Stream, using their element's natural ordering
Stream<A>	Stream.sortBy(Comparator<A> comparator) Sorts this Stream, using the given comparator
<B extends Comparable<B>> Stream<A>	Stream.sortOn(Applicable<? super A,B> function) Sorts this Stream, using Compare.on(function) as comparator
Stream<A>	Stream.tail() Answers the tail of the Stream
Stream<A>	Stream.take(int amountOfElements) Preserves up to N elements.
Stream<A>	Stream.takeWhile(Evaluable<? super A> predicate) Preserves all elements while they satisfy the given predicate
<B> Stream<B>	Stream.transform(Applicable<Stream<A>,? extends Stream<B>> function) Lazily applies the given function to this Stream.
<B> Stream<B>	Stream.transform(Stream.DeconsApplicable<A,B> function) Lazily applies the given function to this stream, deconstructing this stream into head and tail, or into an empty stream.
<B> Stream<B>	Stream.transform(Stream.DelayedDeconsApplicable<A,B> function) Lazily applies the given function to this stream, deconstructing this stream into a head thunk and tail, or into an empty stream.
<B> Stream<Tuple2<A,B>>	Stream.zip(B... elements) Returns a Stream formed by by pair of element from this and the given elements.
<B> Stream<Tuple2<A,B>>	Stream.zip(Iterable<B> iterable) Returns a Stream formed by by pair of element from this and the given iterable.
<B,C> Stream<C>	Stream.zip(Iterable<B> iterable, Function2<? super A,? super B,C> function) Deprecated. use Stream.zipWith(Function2, Iterable)
<B,C> Stream<C>	Stream.zipWith(Function2<? super A,? super B,C> function, B... elements) Returns a Stream formed by the result of applying the given function to each pair of elements from this and the given iterable.
<B,C> Stream<C>	Stream.zipWith(Function2<? super A,? super B,C> function, Iterable<B> other) Returns a Stream formed by the result of applying the given function to each pair of elements from this and the given iterable.