com.aol.cyclops.types.futurestream

Interface OperationsOnFutures<T>

public interface OperationsOnFutures<T>

Method Summary

Modifier and Type	Method and Description
default LazyFutureStream<T>	append(T... values) Append values to the end of this SequenceM
default LazyFutureStream<T>	appendFutures(java.util.concurrent.CompletableFuture<T>... values) Append the provided Futures to this Stream
default LazyFutureStream<T>	appendStream(java.util.stream.Stream<T> stream) Append Stream to this Stream
default LazyFutureStream<T>	appendStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream) Append a Stream of Futures to this Stream
default <R,A> R	collect(java.util.stream.Collector<? super java.util.concurrent.CompletableFuture<T>,A,R> collector) Collect a Stream
default LazyFutureStream<T>	concat(java.util.stream.Stream<T> other)
default LazyFutureStream<T>	concat(T... other)
default LazyFutureStream<T>	concat(T other)
default LazyFutureStream<T>	concatFutures(java.util.concurrent.CompletableFuture<T>... other) Concat supplied Futures to this Stream
default LazyFutureStream<T>	concatStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> other) Concat supplied Futures to this Stream
default LazyFutureStream<T>	cycle() Convert to a Stream with the values infinitely cycled
default LazyFutureStream<T>	cycle(int times) Convert to a Stream with the values repeated specified times
default LazyFutureStream<T>	deleteBetween(int start, int end) Delete elements between given indexes in a Stream
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>>	duplicate() Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
default java.util.Optional<T>	elementAt(long index) Return the elementAt index or Optional.empty
default java.util.concurrent.CompletableFuture<T>	foldLeft(java.util.concurrent.CompletableFuture<T> identity, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator) Sequentially reduce from the left
default java.util.concurrent.CompletableFuture<T>	foldRight(java.util.concurrent.CompletableFuture<T> identity, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator) Reduce sequentially from the right
LazyFutureStream<T>	fromStreamOfFutures(java.util.stream.Stream<com.aol.cyclops.internal.react.async.future.FastFuture<T>> stream)
default org.jooq.lambda.tuple.Tuple2<T,LazyFutureStream<T>>	get(long index) Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
com.aol.cyclops.internal.react.stream.LazyStreamWrapper<T>	getLastActive()
Continueable	getSubscription()
default LazyFutureStream<java.util.List<T>>	grouped(int groupSize) Group elements in a Stream
default HeadAndTail<T>	headAndTail() extract head and tail together, where head is expected to be present
default LazyFutureStream<T>	insertAt(int pos, T... values) Insert data into a stream at given position
default LazyFutureStream<T>	insertStreamAt(int pos, java.util.stream.Stream<T> stream) Insert a Stream into the middle of this stream at the specified position
default LazyFutureStream<T>	insertStreamFuturesAt(int pos, java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream) Insert a Stream into the middle of this stream at the specified position
default LazyFutureStream<T>	intersperse(java.util.concurrent.CompletableFuture<T> value) Returns a stream with a given value interspersed between any two values of this stream.
default LazyFutureStream<T>	intersperse(T value) Returns a stream with a given value interspersed between any two values of this stream.
default LazyFutureStream<T>	limit(long maxSize) assertThat(of(1,2,3,4,5).actOnFutures().limit(2).collect(Collectors.toList()).size(),is(2));
default LazyFutureStream<T>	limitLast(int num) Limit results to the last x elements in a SequenceM
default LazyFutureStream<T>	prepend(T... values) Prepend given values to the start of the Stream
default LazyFutureStream<T>	prependFutures(java.util.concurrent.CompletableFuture<T>... values) List<String> result = of(1,2,3).actOnFutures() .prependFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300)) .map(it ->it+"!!") .collect(Collectors.toList()); assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
default LazyFutureStream<T>	prependStream(java.util.stream.Stream<T> stream) Prepend Stream to this SequenceM
default LazyFutureStream<T>	prependStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream) Stream<CompletableFuture<Integer>> streamOfFutures = Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300)); List<String> result = of(1,2,3).actOnFutures() .prependStreamFutures(streamOfFutures) .map(it ->it+"!!") .collect(Collectors.toList()); assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
default org.jooq.lambda.tuple.Tuple4<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>>	quadruplicate() Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
default java.util.Optional<java.util.concurrent.CompletableFuture<T>>	reduce(java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator) Reduce a Stream
default java.util.concurrent.CompletableFuture<T>	reduce(java.util.concurrent.CompletableFuture<T> identity, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
default <U> java.util.concurrent.CompletableFuture<U>	reduce(java.util.concurrent.CompletableFuture<U> identity, java.util.function.BiFunction<java.util.concurrent.CompletableFuture<U>,? super java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<U>> accumulator, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<U>> combiner)
default LazyFutureStream<T>	reverse() Reverse this Stream, by reversing the order in which the underlying Futures will be processed
T	safeJoin(com.aol.cyclops.internal.react.async.future.FastFuture<T> f)
default LazyFutureStream<T>	shuffle()
default LazyFutureStream<T>	shuffle(java.util.Random random) Shuffle a stream using specified source of randomness // e.g.
default LazyFutureStream<T>	skip(long n) assertThat(of(1,2,3,4,5).actOnFutures().skip(2).collect(Collectors.toList()).size(),is(3));
default LazyFutureStream<T>	skipLast(int num) Skip the last num of elements from this Stream
default LazyFutureStream<T>	slice(long from, long to) Returns a limited interval from a given Stream.
default LazyFutureStream<java.util.List<T>>	sliding(int windowSize) Create a sliding view over this Sequence
default LazyFutureStream<java.util.List<T>>	sliding(int windowSize, int increment) Create a sliding view over this Sequence
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>>	splitAt(int where) Split at supplied location
default org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,LazyFutureStream<T>>	splitAtHead() Split a Stream at it's head (similar to headAndTail)
default <R> LazyFutureStream<R>	thenCombine(java.util.function.BiFunction<T,T,R> combiner) Combines every pair of values (any odd remaining value will be dropped)
default <C extends java.util.Collection<java.util.concurrent.CompletableFuture<T>>> C	toCollection(java.util.function.Supplier<C> collectionFactory) Collect a Stream into a Collection
default java.util.List<java.util.concurrent.CompletableFuture<T>>	toList() Collect a Stream into a List.
default java.util.Set<java.util.concurrent.CompletableFuture<T>>	toSet() Collect a Stream into a Set.
default ReactiveSeq<java.util.concurrent.CompletableFuture<T>>	toStream() Convert this FutureStream to a Stream of CompletableFutures
default org.jooq.lambda.tuple.Tuple3<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>>	triplicate() Triplicates a Stream.
LazyFutureStream<T>	withLastActive(com.aol.cyclops.internal.react.stream.LazyStreamWrapper<T> active)
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>>	zip(java.util.stream.Stream<R> other) Zip two Streams.
default <S,U> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<T,S,U>>	zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third) zip 3 Streams into one
default <S,U> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<T,S,U>>	zip3Lfs(LazyFutureStream<? extends S> second, LazyFutureStream<? extends U> third) Zip 3 LazyFutureStreams based on the order of the data in the underlying Futures
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>	zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth) zip 4 Streams into 1
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>	zip4Lfs(LazyFutureStream<T2> second, LazyFutureStream<T3> third, LazyFutureStream<T4> fourth) Zip 4 LazyFutureStreams into 1
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>>	zipLfs(LazyFutureStream<R> other) Zip two LazyFutureStreams by combining the underlying Futures
default <R,T2> LazyFutureStream<R>	zipLfs(LazyFutureStream<T2> other, java.util.function.BiFunction<java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<T2>,java.util.concurrent.CompletableFuture<R>> combiner) Zip two LazyFutureStreams using the provided combiner
default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	zipWithIndex() Add an index to the current Stream

Method Detail

fromStreamOfFutures

LazyFutureStream<T> fromStreamOfFutures(java.util.stream.Stream<com.aol.cyclops.internal.react.async.future.FastFuture<T>> stream)

getLastActive

com.aol.cyclops.internal.react.stream.LazyStreamWrapper<T> getLastActive()

withLastActive

LazyFutureStream<T> withLastActive(com.aol.cyclops.internal.react.stream.LazyStreamWrapper<T> active)

safeJoin

T safeJoin(com.aol.cyclops.internal.react.async.future.FastFuture<T> f)

getSubscription

Continueable getSubscription()

reverse

default LazyFutureStream<T> reverse()

Reverse this Stream, by reversing the order in which the underlying Futures will be processed

  
 LazyFutureStream.of(1, 2, 3).actOnFutures()
            						.reverse()
            						.toList();
            						
         //3,2,1   						
 
 

Returns:

reversed Stream

cycle

default LazyFutureStream<T> cycle(int times)

Convert to a Stream with the values repeated specified times

  
 		assertThat(LazyFutureStream.of(1,2,2)
                              .actOnFutures()
 								.cycle(3)
 								.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));
 
 
 
 

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

cycle

default LazyFutureStream<T> cycle()

Convert to a Stream with the values infinitely cycled

  
   assertEquals(asList(1, 1, 1, 1, 1,1),LazyFutureStream.of(1)
   												.actOnFutures()
   												.cycle()
   												.limit(6).toList());
   
 

Returns:

Stream with values repeated

duplicate

default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>> duplicate()

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

 
     	Tuple2<LazyFutureStream<<Integer>, LazyFutureStream<<Integer>> copies = of(1, 2, 3, 4, 5, 6)
 			actOnFutures().duplicate();
 	assertTrue(copies.v1.anyMatch(i -> i == 2));
 	assertTrue(copies.v2.anyMatch(i -> i == 2));
 
 
 

Returns:

duplicated stream

triplicate

default org.jooq.lambda.tuple.Tuple3<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>> triplicate()

Triplicates a Stream. Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
  Tuple3<LazyFutureStream<Integer>, LazyFutureStream<Integer>, LazyFutureStream<Integer>> copies =of(1,2,3,4,5,6).actOnFutures().triplicate();
    	 assertTrue(copies.v1.anyMatch(i->i==2));
    	 assertTrue(copies.v2.anyMatch(i->i==2));
    	 assertTrue(copies.v3.anyMatch(i->i==2));
 
 
    
 

quadruplicate

default org.jooq.lambda.tuple.Tuple4<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>> quadruplicate()

Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
  Tuple4<LazyFutureStream<Integer>, LazyFutureStream<Integer>, LazyFutureStream<Integer>,LazyFutureStream<Integer>> copies =of(1,2,3,4,5,6).actOnFutures().quadruplicate();
    	 assertTrue(copies.v1.anyMatch(i->i==2));
    	 assertTrue(copies.v2.anyMatch(i->i==2));
    	 assertTrue(copies.v3.anyMatch(i->i==2));
    	 assertTrue(copies.v4.anyMatch(i->i==2));
 
 
 

Returns:

splitAtHead

default org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,LazyFutureStream<T>> splitAtHead()

Split a Stream at it's head (similar to headAndTail)

  
 LazyFutureStream.of(1,2,3).actOnFutures().splitAtHead()
 
  //Optional[1], SequenceM[2,3]
 
 
 

splitAt

default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>> splitAt(int where)

Split at supplied location

  
 LazyFutureStream.of(1,2,3).actOnFutures().splitAt(1)
 
  //SequenceM[1], SequenceM[2,3]
 
 
 

zipLfs

default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>> zipLfs(LazyFutureStream<R> other)

Zip two LazyFutureStreams by combining the underlying Futures

  
 
 List<Tuple2<Integer,Integer>> list =
    				of(1,2,3,4,5,6).actOnFutures().zipLfs(of(100,200,300,400))
    												.peek(it -> System.out.println(it)).collect(Collectors.toList());
 
 // [1,100],[2,200],[3,300],[4,400]
 
 

Parameters:

other -

Returns:

zipLfs

default <R,T2> LazyFutureStream<R> zipLfs(LazyFutureStream<T2> other,
                                          java.util.function.BiFunction<java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<T2>,java.util.concurrent.CompletableFuture<R>> combiner)

Zip two LazyFutureStreams using the provided combiner

  
  BiFunction<CompletableFuture<Integer>,CompletableFuture<Integer>,CompletableFuture<Tuple2<Integer,Integer>>> combiner = 
    				 			(cf1,cf2)->cf1.<Integer,Tuple2<Integer,Integer>>thenCombine(cf2, (v1,v2)->Tuple.tuple(v1,v2));
    		List<Tuple2<Integer,Integer>> list =
    				of(1,2,3,4,5,6).actOnFutures().zipLfs(of(100,200,300,400), combiner)
    												.peek(it -> System.out.println(it)).collect(Collectors.toList());
    		
    		List<Integer> right = list.stream().map(t -> t.v2).collect(Collectors.toList());
    		assertThat(right,hasItem(100));
    		assertThat(right,hasItem(200));
    		assertThat(right,hasItem(300));
    		assertThat(right,hasItem(400));
 
 
 
 

zip

default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>> zip(java.util.stream.Stream<R> other)

Zip two Streams. Futures from this Stream will be paired with data from provided Stream (if the other Stream is also a LazyFutureStream this operator will pair based on Futures from this Stream with results from the other].

 
 List<Tuple2<Integer,Integer>> list =
    				of(1,2,3,4,5,6).actOnFutures().zip(of(100,200,300,400))
    												.peek(it -> System.out.println(it)).collect(Collectors.toList());
 
 // [1,100],[2,200],[3,300],[4,400]
 
 

Example with two LazyFutureStreams

 
 List<Tuple2<Integer,Integer>> list =
    				LazyFutureStream.of(slow,fast,med).actOnFutures().zip(LazyFutureStream.of(slow,fast,med))
    												.peek(it -> System.out.println(it)).collect(Collectors.toList());
 
 // [slow,fast],[fast,med],[med,slow]
 
 

zip3

default <S,U> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
                                                                         java.util.stream.Stream<? extends U> third)

zip 3 Streams into one

 
 	List<Tuple3<Integer,Integer,Character>> list =
    			of(1,2,3,4,5,6).actOnFutures().zip3(of(100,200,300,400),of('a','b','c'))
    										.collect(Collectors.toList());
 
 // [1,100,'a'],[2,200,'b'],[3,300,'c']
 
 

 List<Tuple3<Integer,Integer,Character>> list =
    			of(slow,med,fast).actOnFutures().zip3(of(slow,med,fast),of(slow,med,fast))
    											.collect(Collectors.toList());
    	
    	
    	//[slow,fast,fast],[med,med,med],[fast,slow,slow]

zip3Lfs

default <S,U> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3Lfs(LazyFutureStream<? extends S> second,
                                                                            LazyFutureStream<? extends U> third)

Zip 3 LazyFutureStreams based on the order of the data in the underlying Futures

 List<Tuple3<Integer,Integer,Character>> list =
    			of(slow,med,fast).actOnFutures().zip3Lfs(of(slow,med,fast),of(slow,med,fast))
    											.collect(Collectors.toList());
    	
    	
    	//[slow,slow,slow],[med,med,med],[fast,fast,fast]

zip4

default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second,
                                                                                   java.util.stream.Stream<T3> third,
                                                                                   java.util.stream.Stream<T4> fourth)

zip 4 Streams into 1

 List<Tuple3<Integer,Integer,Character>> list =
    			of(slow,med,fast).actOnFutures().zip4(of(slow,med,fast),of(slow,med,fast),of(slow,med,fast))
    											.collect(Collectors.toList());
    	
    	
    	//[slow,fast,fast,fast],[med,med,med,med],[fast,slow,slow,slow]

zip4Lfs

default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4Lfs(LazyFutureStream<T2> second,
                                                                                      LazyFutureStream<T3> third,
                                                                                      LazyFutureStream<T4> fourth)

Zip 4 LazyFutureStreams into 1

 List<Tuple3<Integer,Integer,Character>> list =
    			of(slow,med,fast).actOnFutures().zip4(of(slow,med,fast),of(slow,med,fast),of(slow,med,fast))
    											.collect(Collectors.toList());
    	
    	
    	//[slow,slow,slow,slow],[med,med,med,med],[fast,fast,fast,fast]

zipWithIndex

default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

Add an index to the current Stream

  
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").actOnFutures().zipWithIndex().toList());
 
 

sliding

default LazyFutureStream<java.util.List<T>> sliding(int windowSize)

Create a sliding view over this Sequence

  
 List<List<Integer>> list = of(1,2,3,4,5,6).actOnFutures().sliding(2)
    									.collect(Collectors.toList());
    		
    	
    		assertThat(list.get(0),hasItems(1,2));
    		assertThat(list.get(1),hasItems(2,3));
    

Parameters:

windowSize - Size of sliding window

Returns:

SequenceM with sliding view

sliding

default LazyFutureStream<java.util.List<T>> sliding(int windowSize,
                                                    int increment)

Create a sliding view over this Sequence

  
 List<List<Integer>> list = of(1,2,3,4,5,6).actOnFutures().sliding(3,2)
    									.collect(Collectors.toList());
    		
    		
    		System.out.println(list.get(0));
    		assertThat(list.get(0),hasItems(1,2,3));
    		assertThat(list.get(1),hasItems(3,4,5));
 
 

Parameters:

windowSize - number of elements in each batch

increment - for each window

Returns:

SequenceM with sliding view

grouped

default LazyFutureStream<java.util.List<T>> grouped(int groupSize)

Group elements in a Stream

  
 assertThat(of(1,2,3,4,5,6).actOnFutures().grouped(3).collect(Collectors.toList()).size(),is(2));
 
 
 

Parameters:

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

skip

default LazyFutureStream<T> skip(long n)

  assertThat(of(1,2,3,4,5).actOnFutures().skip(2).collect(Collectors.toList()).size(),is(3)); 
 

Parameters:

n - Number of elemenets to skip

Returns:

Stream with elements skipped

limit

default LazyFutureStream<T> limit(long maxSize)

  assertThat(of(1,2,3,4,5).actOnFutures().limit(2).collect(Collectors.toList()).size(),is(2));
 

Parameters:

maxSize - Limit element size to num

Returns:

Limited Stream

headAndTail

default HeadAndTail<T> headAndTail()

extract head and tail together, where head is expected to be present

  
 LazyFutureStream<String> helloWorld = LazyFutureStream.of("hello",
    			"world", "last");
    	HeadAndTail<String> headAndTail = helloWorld.actOnFutures()
    			.headAndTail();
    	String head = headAndTail.head();
    	assertThat(head, equalTo("hello"));
    
    	ReactiveSeq<String> tail = headAndTail.tail();
    	assertThat(tail.headAndTail().head(), equalTo("world"));
 
 
 

Returns:

intersperse

default LazyFutureStream<T> intersperse(T value)

Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) LazyFutureStream.of(1, 2, 3, 4).actOnFutures().intersperse(0)

intersperse

default LazyFutureStream<T> intersperse(java.util.concurrent.CompletableFuture<T> value)

Returns a stream with a given value interspersed between any two values of this stream. LazyFutureStream.of(1, 2, 3, 4) .actOnFutures() .intersperse(CompletableFuture.completedFuture(0)); // (1, 0, 2, 0, 3, 0, 4)

shuffle

default LazyFutureStream<T> shuffle()

appendStream

default LazyFutureStream<T> appendStream(java.util.stream.Stream<T> stream)

Append Stream to this Stream

  
    	List<String> result = 	of(1,2,3).actOnFutures()
    									.appendStream(of(100,200,300))
    									.map(it ->it+"!!")
    									.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
 
 

Parameters:

stream - to append

Returns:

SequenceM with Stream appended

appendStreamFutures

default LazyFutureStream<T> appendStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)

Append a Stream of Futures to this Stream

  
 List<String> result = 	of(1,2,3).actOnFutures()
    										 .appendStreamFutures(Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300)))
    										 .map(it ->it+"!!")
    										 .collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
 
 
 

Parameters:

stream -

Returns:

prependStream

default LazyFutureStream<T> prependStream(java.util.stream.Stream<T> stream)

Prepend Stream to this SequenceM

  
 List<String> result = 	of(1,2,3).actOnFutures()
    										.prependStream(of(100,200,300))
    										.map(it ->it+"!!")
    										.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
 
 

Parameters:

stream - to Prepend

Returns:

SequenceM with Stream prepended

prependStreamFutures

default LazyFutureStream<T> prependStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)

  
  	Stream<CompletableFuture<Integer>> streamOfFutures = Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300));
    		List<String> result = 	of(1,2,3).actOnFutures()
    										.prependStreamFutures(streamOfFutures)
    										.map(it ->it+"!!")
    										.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
 
 

append

default LazyFutureStream<T> append(T... values)

Append values to the end of this SequenceM

  
 List<String> result = 	of(1,2,3).actOnFutures()
    										 .append(100,200,300)
    										 .map(it ->it+"!!")
    										 .collect(Collectors.toList());
    
    	assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
 
 

Parameters:

values - to append

Returns:

LazyFutureStream with appended values

appendFutures

default LazyFutureStream<T> appendFutures(java.util.concurrent.CompletableFuture<T>... values)

Append the provided Futures to this Stream

  
 List<String> result = 	of(1,2,3).actOnFutures()
    										 .appendFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300))
    										 .map(it ->it+"!!")
    										 .collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
 
 
 

Parameters:

values - Futures to append

Returns:

Stream with values appended

prepend

default LazyFutureStream<T> prepend(T... values)

Prepend given values to the start of the Stream

  
 List<String> result = 	LazyFutureStream.of(1,2,3).actOnFutures()
 									 				 .prepend(100,200,300)
 													 .map(it ->it+"!!")
 													 .collect(Collectors.toList());
 
 						assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
 

Parameters:

values - to prepend

Returns:

SequenceM with values prepended

prependFutures

default LazyFutureStream<T> prependFutures(java.util.concurrent.CompletableFuture<T>... values)

 
 List<String> result = 	of(1,2,3).actOnFutures()
    										.prependFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300))
    										.map(it ->it+"!!")
    										.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
 
 

insertAt

default LazyFutureStream<T> insertAt(int pos,
                                     T... values)

Insert data into a stream at given position

        
       List<String> result = 	of(1,2,3).actOnFutures()
    									 .insertAt(1,100,200,300)
    									 .map(it ->it+"!!")
    									 .collect(Collectors.toList());
    
    	assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
       
       
 

Parameters:

pos - to insert data at

values - to insert

Returns:

Stream with new data inserted

deleteBetween

default LazyFutureStream<T> deleteBetween(int start,
                                          int end)

Delete elements between given indexes in a Stream

  
 List<String> result = 	of(1,2,3,4,5,6).actOnFutures()
    											   .deleteBetween(2,4)
    											   .map(it ->it+"!!")
    											   .collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));
 
 
 

Parameters:

start - index

end - index

Returns:

Stream with elements removed

insertStreamAt

default LazyFutureStream<T> insertStreamAt(int pos,
                                           java.util.stream.Stream<T> stream)

Insert a Stream into the middle of this stream at the specified position

  
   List<String> result = 	of(1,2,3).actOnFutures()
    									.insertStreamAt(1,of(100,200,300))
    									.map(it ->it+"!!")
    									.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
 
 

Parameters:

pos - to insert Stream at

stream - to insert

Returns:

newly conjoined SequenceM

insertStreamFuturesAt

default LazyFutureStream<T> insertStreamFuturesAt(int pos,
                                                  java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)

Insert a Stream into the middle of this stream at the specified position

  
     		Stream<CompletableFuture<Integer>> streamOfFutures = Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300));
    
    		List<String> result = 	of(1,2,3).actOnFutures()
    								.insertStreamFuturesAt(1,streamOfFutures)
    								.map(it ->it+"!!")
    								.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
    	
 

Parameters:

pos - to insert Stream at

stream - to insert

Returns:

newly conjoined SequenceM

skipLast

default LazyFutureStream<T> skipLast(int num)

Skip the last num of elements from this Stream

  
 assertThat(LazyFutureStream.of(1,2,3,4,5)
    						.actOnFutures()
    						.skipLast(2)
    						.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 
 

limitLast

default LazyFutureStream<T> limitLast(int num)

Limit results to the last x elements in a SequenceM

  
 	assertThat(LazyFutureStream.of(1,2,3,4,5).actOnFutures()
 										.limitLast(2)
 										.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
 

Parameters:

num - of elements to return (last elements)

Returns:

SequenceM limited to last num elements

elementAt

default java.util.Optional<T> elementAt(long index)

Return the elementAt index or Optional.empty

 
 	assertThat(LazyFutureStream.of(1,2,3,4,5).actOnFutures().elementAt(2).get(),equalTo(3));
 
 

Parameters:

index - to extract element from

Returns:

elementAt index

get

default org.jooq.lambda.tuple.Tuple2<T,LazyFutureStream<T>> get(long index)

Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.

  
 LazyFutureStream.of(1,2,3,4,5).actOnFutures().get(2).v1
 //3
 
 

Parameters:

index - to extract element from

Returns:

Element and Sequence

thenCombine

default <R> LazyFutureStream<R> thenCombine(java.util.function.BiFunction<T,T,R> combiner)

Combines every pair of values (any odd remaining value will be dropped)

  
 assertThat(of(1,2,3,4).actOnFutures().thenCombine((a,b)->a+b).toList(),equalTo(Arrays.asList(3,7)));
 
 

Parameters:

combiner - Function to Combine pairs of values

Returns:

concat

default LazyFutureStream<T> concat(java.util.stream.Stream<T> other)

concat

default LazyFutureStream<T> concat(T other)

concat

default LazyFutureStream<T> concat(T... other)

concatFutures

default LazyFutureStream<T> concatFutures(java.util.concurrent.CompletableFuture<T>... other)

Concat supplied Futures to this Stream

  
 List<String> result = 	of(1,2,3).actOnFutures().concatFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300))
    		.map(it ->it+"!!").collect(Collectors.toList());
    
    	assertThat(result,containsInAnyOrder("1!!","2!!","100!!","200!!","3!!","300!!"));
 
 

Returns:

concatStreamFutures

default LazyFutureStream<T> concatStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> other)

Concat supplied Futures to this Stream

  
 List<String> result = 	of(1,2,3).actOnFutures()
                                   .concatStreamFutures(Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300)))
    		                             .map(it ->it+"!!")
    		                             .collect(Collectors.toList());
    
    	assertThat(result,containsInAnyOrder("1!!","2!!","100!!","200!!","3!!","300!!"));
 
 
 

shuffle

default LazyFutureStream<T> shuffle(java.util.Random random)

Shuffle a stream using specified source of randomness // e.g. (2, 3, 1) LazyFutureStream.of(1, 2, 3).actOnFutures().shuffle(new Random())

slice

default LazyFutureStream<T> slice(long from,
                                  long to)

Returns a limited interval from a given Stream.

 

 		LazyFutureStream.of(1, 2, 3, 4, 5, 6).actOnFutures().slice(3, 5)
    // (4, 5)
 
 

toStream

default ReactiveSeq<java.util.concurrent.CompletableFuture<T>> toStream()

Convert this FutureStream to a Stream of CompletableFutures

Returns:

Stream of CompletableFutures

toSet

default java.util.Set<java.util.concurrent.CompletableFuture<T>> toSet()

Collect a Stream into a Set.

collect

default <R,A> R collect(java.util.stream.Collector<? super java.util.concurrent.CompletableFuture<T>,A,R> collector)

Collect a Stream

Parameters:

collector - Collecto to use

Returns:

Collection

toList

default java.util.List<java.util.concurrent.CompletableFuture<T>> toList()

Collect a Stream into a List.

toCollection

default <C extends java.util.Collection<java.util.concurrent.CompletableFuture<T>>> C toCollection(java.util.function.Supplier<C> collectionFactory)

Collect a Stream into a Collection

reduce

default java.util.Optional<java.util.concurrent.CompletableFuture<T>> reduce(java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)

Reduce a Stream

  
  CompletableFuture<Integer> sum = of(1, 2, 3).actOnFutures()
            							.reduce((cf1,cf2)-> cf1.thenCombine(cf2, (a,b)->a+b)).get();
    
         assertThat(sum.join(),equalTo(6));
 
 
 

Parameters:

accumulator - CompletableFuture accumulator

Returns:

Reduced value

foldRight

default java.util.concurrent.CompletableFuture<T> foldRight(java.util.concurrent.CompletableFuture<T> identity,
                                                            java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)

Reduce sequentially from the right

  
 Supplier<LazyFutureStream<String>> s = () -> of("a", "b", "c");
    	CompletableFuture<String> identity = CompletableFuture.completedFuture("");
    	BinaryOperator<CompletableFuture<String>> concat = (cf1,cf2)-> cf1.thenCombine(cf2, String::concat);
    
    	assertTrue(s.get().actOnFutures().foldRight(identity, concat).join().contains("a"));
    	assertTrue(s.get().actOnFutures().foldRight(identity, concat).join().contains("b"));
    	assertTrue(s.get().actOnFutures().foldRight(identity, concat).join().contains("c"));
    	
 
 
 

Parameters:

identity - value

accumulator -

Returns:

Reduced value

foldLeft

default java.util.concurrent.CompletableFuture<T> foldLeft(java.util.concurrent.CompletableFuture<T> identity,
                                                           java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)

Sequentially reduce from the left

  
 Supplier<LazyFutureStream<String>> s = () -> of("a", "b", "c");
    
    	CompletableFuture<String> identity = CompletableFuture.completedFuture("");
    	BinaryOperator<CompletableFuture<String>> concat = (cf1,cf2)-> cf1.thenCombine(cf2, String::concat);
    	assertTrue(s.get().actOnFutures().foldLeft(identity, concat).join().contains("a"));
    	assertTrue(s.get().actOnFutures().foldLeft(identity, concat).join().contains("b"));
    	assertTrue(s.get().actOnFutures().foldLeft(identity, concat).join().contains("c"));
 
 
 

Parameters:

identity -

accumulator -

Returns:

reduce

default java.util.concurrent.CompletableFuture<T> reduce(java.util.concurrent.CompletableFuture<T> identity,
                                                         java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)

reduce

default <U> java.util.concurrent.CompletableFuture<U> reduce(java.util.concurrent.CompletableFuture<U> identity,
                                                             java.util.function.BiFunction<java.util.concurrent.CompletableFuture<U>,? super java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<U>> accumulator,
                                                             java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<U>> combiner)