/** * Alias for {@link Stream#of(Object)} * * @param <T> Component type of element. * @param element An element. * @return A new {@link Stream} instance containing the given element */ public static <T> Stream<T> Stream(T element) { return Stream.of(element); }
/** * Alias for {@link Stream#of(Object...)} * * @param <T> Component type of elements. * @param elements Zero or more elements. * @return A new {@link Stream} instance containing the given elements * @throws NullPointerException if {@code elements} is null */ @SuppressWarnings("varargs") @SafeVarargs public static <T> Stream<T> Stream(T... elements) { return Stream.of(elements); } // -- Vector
/** * Chooses one of the given generators according to their frequency. * Only generators with positive frequencies are used in returned * generator. * * @param generators A non-empty array of Tuples (frequency, generator) * @param <T> Type to be generated * @return A new T generator * @throws java.lang.NullPointerException if generators is null * @throws java.lang.IllegalArgumentException if generators doesn't contain any generator with positive frequency */ @SuppressWarnings("varargs") @SafeVarargs static <T> Gen<T> frequency(Tuple2<Integer, Gen<T>>... generators) { Objects.requireNonNull(generators, "generators is null"); if (generators.length == 0) { throw new IllegalArgumentException("generators is empty"); } final Iterable<Tuple2<Integer, Gen<T>>> iterable = Stream.of(generators); return frequency(iterable); }
@Override default Stream<T> append(T element) { return isEmpty() ? Stream.of(element) : new AppendElements<>(head(), io.vavr.collection.Queue.of(element), this::tail); }
static <T> Stream<Node<T>> traversePreOrder(Node<T> node) { return node.getChildren().foldLeft(Stream.of(node), (acc, child) -> acc.appendAll(traversePreOrder(child))); }
/** * Recursively builds a non-empty {@code Tree}, starting with the given {@code seed} value and proceeding in depth-first order. * <p> * The children of a node are created by * <ol> * <li>applying the {@code descend} function to the node value</li> * <li>calling this method recursively by using each derived child value as new seed (in iteration order).</li> * </ol> * <p> * Example: * <pre>{@code * // = (1 (2 4 5) 3) * Tree.recurse(1, i -> * (i == 1) ? List.of(2, 3) : * (i == 2) ? List.(4, 5) : * List.empty() * ).toLispString(); * }</pre> * * @param seed The start value for the Tree * @param descend A function to calculate the child values * @param <T> Value type * @return a new, non-empty {@code Tree} instance * @throws NullPointerException if {@code descend} is null */ static <T> Node<T> recurse(T seed, Function<? super T, ? extends Iterable<? extends T>> descend) { Objects.requireNonNull(descend, "descend is null"); return Tree.of(seed, Stream.of(seed).flatMap(descend).map(children -> recurse(children, descend))); }
static <T> Stream<Stream<T>> apply(Stream<T> elements, int k) { if (k == 0) { return Stream.of(Stream.empty()); } else { return elements.zipWithIndex().flatMap( t -> apply(elements.drop(t._2 + 1), (k - 1)).map((Stream<T> c) -> c.prepend(t._1)) ); } } }
static <T> Stream<Node<T>> traverseInOrder(Node<T> node) { if (node.isLeaf()) { return Stream.of(node); } else { final io.vavr.collection.List<Node<T>> children = node.getChildren(); return children .tail() .foldLeft(Stream.<Node<T>> empty(), (acc, child) -> acc.appendAll(traverseInOrder(child))) .prepend(node) .prependAll(traverseInOrder(children.head())); } }
@Override default Stream<Stream<T>> permutations() { if (isEmpty()) { return Empty.instance(); } else { final Stream<T> tail = tail(); if (tail.isEmpty()) { return Stream.of(this); } else { final Stream<Stream<T>> zero = Empty.instance(); return distinct().foldLeft(zero, (xs, x) -> { final Function<Stream<T>, Stream<T>> prepend = l -> l.prepend(x); return xs.appendAll(remove(x).permutations().map(prepend)); }); } } }
/** * Alias for {@link Stream#of(Object)} * * @param <T> Component type of element. * @param element An element. * @return A new {@link Stream} instance containing the given element */ public static <T> Stream<T> Stream(T element) { return Stream.of(element); }
@Override public final <A extends Annotation> Iterable<Declaration<A>> declarations(Class<A> type) { return Stream.of(element.getAnnotationsByType(type)) .map(a -> new DeclExplicit<>(a, element.getQualifiedName().toString())); } }
/** * Table QuickSort by single column index and a sort order. * * @param columnIndex The column index to sort. * @param sortOrder The sort order. * @return Returns the results as a sorted Data View. */ @Override public Try<DataView> quickSort(Integer columnIndex, SortOrder sortOrder) { SortItem sortItem = new SortItem(columnIndex, sortOrder); return DataSort.quickSort(this.table, this.rows.asSeq(), Stream.of(sortItem)); }
static <T> Stream<Stream<T>> apply(Stream<T> elements, int k) { if (k == 0) { return Stream.of(Stream.empty()); } else { return elements.zipWithIndex().flatMap( t -> apply(elements.drop(t._2 + 1), (k - 1)).map((Stream<T> c) -> c.prepend(t._1)) ); } } }
@Test public void testStreamOfString() throws Exception { String src0 = "A"; String src1 = "B"; String src2 = "C"; Stream<String> src = Stream.of(src0, src1, src2); String json = MAPPER.writeValueAsString(new ParameterizedStreamPojo<>(src)); Assert.assertEquals(json, "{\"value\":[\"A\",\"B\",\"C\"]}"); ParameterizedStreamPojo<java.lang.String> restored = MAPPER.readValue(json, new TypeReference<ParameterizedStreamPojo<java.lang.String>>(){}); Assert.assertEquals(src, restored.getValue()); }
@Test public void testStreamOfTuple() throws Exception { String src00 = "A"; String src01 = "B"; Tuple2<String, String> src0 = Tuple.of(src00, src01); Stream<Tuple2<String, String>> src = Stream.of(src0); String json = MAPPER.writeValueAsString(new ParameterizedStreamPojo<>(src)); Assert.assertEquals(json, "{\"value\":[[\"A\",\"B\"]]}"); ParameterizedStreamPojo<io.vavr.Tuple2<java.lang.String, java.lang.String>> restored = MAPPER.readValue(json, new TypeReference<ParameterizedStreamPojo<io.vavr.Tuple2<java.lang.String, java.lang.String>>>(){}); Assert.assertEquals(src, restored.getValue()); }
@Test public void testStreamOfString() throws Exception { String src0 = "A"; String src1 = "B"; String src2 = "C"; Stream<String> src = Stream.of(src0, src1, src2); String json = MAPPER.writeValueAsString(new StreamOfString().setValue(src)); Assert.assertEquals(json, "{\"value\":[\"A\",\"B\",\"C\"]}"); StreamOfString restored = MAPPER.readValue(json, StreamOfString.class); Assert.assertEquals(src, restored.getValue()); }
@Test public void testStreamOfTuple() throws Exception { String src00 = "A"; String src01 = "B"; Tuple2<String, String> src0 = Tuple.of(src00, src01); Stream<Tuple2<String, String>> src = Stream.of(src0); String json = MAPPER.writeValueAsString(new StreamOfTuple().setValue(src)); Assert.assertEquals(json, "{\"value\":[[\"A\",\"B\"]]}"); StreamOfTuple restored = MAPPER.readValue(json, StreamOfTuple.class); Assert.assertEquals(src, restored.getValue()); }
static <T> Stream<Node<T>> traverseInOrder(Node<T> node) { if (node.isLeaf()) { return Stream.of(node); } else { final io.vavr.collection.List<Node<T>> children = node.getChildren(); return children .tail() .foldLeft(Stream.<Node<T>> empty(), (acc, child) -> acc.appendAll(traverseInOrder(child))) .prepend(node) .prependAll(traverseInOrder(children.head())); } }
@Test public void testStream() throws Exception { Stream<I> src = Stream.of(new A(), new B()); String json = MAPPER.writeValueAsString(new StreamPojo().setValue(src)); Assert.assertEquals(json, "{\"value\":[{\"type\":\"a\"},{\"type\":\"b\"}]}"); StreamPojo pojo = MAPPER.readValue(json, StreamPojo.class); Stream<I> restored = pojo.getValue(); Assert.assertTrue(restored.get(0) instanceof A); Assert.assertTrue(restored.get(1) instanceof B); }
@Test public void testStream() throws Exception { Stream<A> src = Stream.of(new B("a", "b")); String json = MAPPER.writeValueAsString(new StreamPojo().setValue(src)); Assert.assertEquals(json, "{\"value\":[{\"ExtFieldsPojoTest$B\":{\"a\":\"a\",\"b\":\"b\"}}]}"); StreamPojo pojo = MAPPER.readValue(json, StreamPojo.class); Stream<A> restored = pojo.getValue(); Assert.assertTrue(restored.get(0) instanceof B); Assert.assertEquals(restored.get(0).a, "a"); Assert.assertEquals(((B) restored.get(0)).b, "b"); }