/** * Create a new Stream that infiniteable cycles the provided Stream * @param s Stream to cycle * @return New cycling stream */ public static <U> Stream<U> cycle(Stream<U> s){ return StreamUtils.cycle(s); } /**
/** * Create a Stream that infiniteable cycles the provided Streamable * @param s Streamable to cycle * @return New cycling stream */ public static <U> Stream<U> cycle(Streamable<U> s){ return StreamUtils.cycle(s); }
/** * Create a Stream that infiniteable cycles the provided Streamable * @param s Streamable to cycle * @return New cycling stream */ public static <U> Stream<U> cycle(int times,Streamable<U> s){ return StreamUtils.cycle(times, s); }
public static Stream<Object> stream(Object t){ if(t instanceof Iterable){ return Stream.concat(StreamUtils.stream((Iterable)t).map(SeqUtils::nonNull),(StreamUtils.cycle(Stream.of(EMPTY)))); } if(t instanceof Stream){ return Stream.concat( ((Stream)t).map(SeqUtils::nonNull),(StreamUtils.cycle(Stream.of(EMPTY)))); } if(t instanceof Iterator){ return Stream.concat( StreamUtils.stream((Iterator)t).map(SeqUtils::nonNull),(StreamUtils.cycle(Stream.of(EMPTY)))); } if(t instanceof Map){ return Stream.concat(StreamUtils.stream((Map)t).map(SeqUtils::nonNull),(StreamUtils.cycle(Stream.of(EMPTY)))); } return Stream.concat(Stream.of(t).map(SeqUtils::nonNull),(StreamUtils.cycle(Stream.of(EMPTY)))); }
/** * Convert to a Stream with the values infinitely cycled * * <pre> * {@code * assertEquals(asList(1, 1, 1, 1, 1,1),of(1).cycle().limit(6).toList()); * } * </pre> * * @return Stream with values repeated */ public final SequenceM<T> cycle() { return StreamUtils.sequenceM(StreamUtils.cycle(stream),reversable); } /**
/** * Convert to a Stream with the values infinitely cycled * * <pre> * {@code * assertEquals(asList(1, 1, 1, 1, 1,1),of(1).cycle().limit(6).toList()); * } * </pre> * * @return Stream with values repeated */ public final SequenceM<T> cycle() { return new SequenceM(StreamUtils.cycle(monad)); } /**
/** * Repeat in a Stream while specified predicate holds * <pre> * {@code * int count =0; * assertThat(StreamUtils.cycleWhile(Stream.of(1,2,2) ,next -> count++<6 ) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2))); * } * </pre> * @param predicate * repeat while true * @return Repeating Stream */ public final static <T> Stream<T> cycleWhile(Stream<T> stream,Predicate<? super T> predicate) { return StreamUtils.limitWhile(StreamUtils.cycle(stream),predicate); }
/** * Repeat in a Stream until specified predicate holds * * <pre> * {@code * count =0; assertThat(StreamUtils.cycleUntil(Stream.of(1,2,2,3) ,next -> count++>10 ) .collect(Collectors.toList()),equalTo(Arrays.asList(1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2))); * } * </pre> * @param predicate * repeat while true * @return Repeating Stream */ public final static <T> Stream<T> cycleUntil(Stream<T> stream,Predicate<? super T> predicate) { return StreamUtils.limitUntil(StreamUtils.cycle(stream),predicate); }
/** * Create a new Stream that infiniteable cycles the provided Stream * * <pre> * {@code * assertThat(StreamUtils.cycle(Stream.of(1,2,3)) * .limit(6) * .collect(Collectors.toList()), * equalTo(Arrays.asList(1,2,3,1,2,3))); } * </pre> * @param s Stream to cycle * @return New cycling stream */ public static <U> Stream<U> cycle(Stream<U> s){ return cycle(AsStreamable.asStreamable(s)); } /**
/** * Create a new Stream that infiniteable cycles the provided Stream * * <pre> * {@code * assertThat(StreamUtils.cycle(Stream.of(1,2,3)) * .limit(6) * .collect(Collectors.toList()), * equalTo(Arrays.asList(1,2,3,1,2,3))); } * </pre> * @param s Stream to cycle * @return New cycling stream */ public static <U> Stream<U> cycle(Stream<U> s){ return cycle(AsStreamable.fromStream(s)); } /**
/** * Repeat in a Stream while specified predicate holds * <pre> * {@code * int count =0; * assertThat(StreamUtils.cycleWhile(Stream.of(1,2,2) ,next -> count++<6 ) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2))); * } * </pre> * @param predicate * repeat while true * @return Repeating Stream */ public final static <T> Stream<T> cycleWhile(Stream<T> stream,Predicate<? super T> predicate) { return StreamUtils.limitWhile(StreamUtils.cycle(stream),predicate); }
/** * Repeat in a Stream until specified predicate holds * * <pre> * {@code * count =0; assertThat(StreamUtils.cycleUntil(Stream.of(1,2,2,3) ,next -> count++>10 ) .collect(Collectors.toList()),equalTo(Arrays.asList(1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2))); * } * </pre> * @param predicate * repeat while true * @return Repeating Stream */ public final static <T> Stream<T> cycleUntil(Stream<T> stream,Predicate<? super T> predicate) { return StreamUtils.limitUntil(StreamUtils.cycle(stream),predicate); }
/** * Repeat in a Stream until specified predicate holds * <pre> * {@code * count =0; assertThat(anyM(Stream.of(1,2,2)).asSequence() .cycleUntil(next -> count++>6) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2,1))); * * } * * * @param predicate * repeat while true * @return Repeating Stream */ public final SequenceM<T> cycleUntil(Predicate<? super T> predicate) { return monad(StreamUtils.cycle(monad)).limitWhile(predicate.negate()); } /**
/** * Repeat in a Stream until specified predicate holds * <pre> * {@code * count =0; assertThat(anyM(Stream.of(1,2,2)).asSequence() .cycleUntil(next -> count++>6) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2,1))); * * } * * * @param predicate * repeat while true * @return Repeating Stream */ public final SequenceM<T> cycleUntil(Predicate<? super T> predicate) { return StreamUtils.sequenceM(StreamUtils.cycle(stream),reversable).limitWhile(predicate.negate()); } /**
/** * Repeat in a Stream while specified predicate holds * * <pre> * {@code * count =0; assertThat(anyM(Stream.of(1,2,2)).asSequence() .cycleWhile(next -> count++<6) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2))); * } * </pre> * * @param predicate * repeat while true * @return Repeating Stream */ public final SequenceM<T> cycleWhile(Predicate<? super T> predicate) { return monad(StreamUtils.cycle(monad)).limitWhile(predicate); }
/** * Repeat in a Stream while specified predicate holds * * <pre> * {@code * count =0; assertThat(anyM(Stream.of(1,2,2)).asSequence() .cycleWhile(next -> count++<6) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2))); * } * </pre> * * @param predicate * repeat while true * @return Repeating Stream */ public final SequenceM<T> cycleWhile(Predicate<? super T> predicate) { return StreamUtils.sequenceM(StreamUtils.cycle(stream),reversable).limitWhile(predicate); }
/** * Convert to a Stream with the result of a reduction operation repeated * specified times * * <pre> * {@code * List<Integer> list = StreamUtils.cycle(Stream.of(1,2,2),Reducers.toCountInt(),3) * . * .collect(Collectors.toList()); * //is asList(3,3,3); * } * </pre> * * @param m * Monoid to be used in reduction * @param times * Number of times value should be repeated * @return Stream with reduced values repeated */ public final static <T> Stream<T> cycle(Stream<T> stream,Monoid<T> m, int times) { return StreamUtils.cycle(times,AsStreamable.asStreamable(m.reduce(stream))); }
/** * Convert to a Stream with the values repeated specified times * * <pre> * {@code * assertThat(anyM(Stream.of(1,2,2)).asSequence() .cycle(3).collect(Collectors.toList()), equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2))); * * } * </pre> * @param times * Times values should be repeated within a Stream * @return Stream with values repeated */ public final SequenceM<T> cycle(int times) { return StreamUtils.sequenceM(StreamUtils.cycle(times,AsStreamable.fromStream(stream)),reversable); } /**
/** * Convert to a Stream with the values repeated specified times * * @param times Times values should be repeated within a Stream * @return Stream with values repeated */ default Monad<Stream<T>,T> cycle(int times){ return monad(StreamUtils.cycle(times,AsStreamable.asStreamable(stream()))); } @Override
/** * Convert to a Stream with the result of a reduction operation repeated * specified times * * <pre> * {@code * List<Integer> list = AsGenericMonad,asMonad(Stream.of(1,2,2)) * .cycle(Reducers.toCountInt(),3) * .collect(Collectors.toList()); * //is asList(3,3,3); * } * </pre> * * @param m * Monoid to be used in reduction * @param times * Number of times value should be repeated * @return Stream with reduced values repeated */ public final SequenceM<T> cycle(Monoid<T> m, int times) { return monad(StreamUtils.cycle(times,AsStreamable.asStreamable(m.reduce(monad)))); }