@Override public CloseableIterable<?> deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException { final JavaType typeReference = ctxt.getTypeFactory() .constructCollectionType(List.class, valueType); return new WrappedCloseableIterable<>(ctxt.<Iterable<?>>readValue(jp, typeReference)); }
@Test public void getObjectsShouldReturnGeneratedObjectTransformIterable() { // Given final OneToOneObjectGenerator<String> generator = new OneToOneObjectGeneratorImpl(); // When final TransformIterable<Element, String> result = (TransformIterable<Element, String>) generator.apply(Arrays.asList(elm1, elm2)); // Then final Iterator<String> itr = result.iterator(); assertSame(obj1, itr.next()); assertSame(obj2, itr.next()); assertFalse(itr.hasNext()); }
@Test public void shouldAddEmptyIterableOfEntities() { // Given // [A] -> [E] -> [D] -> [A] // \ \ // (BasicEntity) (EmptyIterable) // When final Walk walk = new Walk.Builder() .edge(EDGE_AE) .entity(ENTITY_E) .edges(EDGE_ED, EDGE_DA) .entities(new EmptyClosableIterable<>()) .build(); // Then assertThat(walk.getEntitiesAsEntries(), hasSize(4)); // A, D, E, A assertThat(walk.getEdges(), hasSize(3)); // A -> E, E -> D, D -> A assertThat(walk.getEdges().stream().flatMap(Set::stream).collect(Collectors.toList()), contains(EDGE_AE, EDGE_ED, EDGE_DA)); assertThat(walk.getEntities(), contains(Collections.emptySet(), Sets.newHashSet(ENTITY_E), Collections.emptySet(), Collections.emptySet())); assertThat(walk.getVerticesOrdered(), contains("A", "E", "D", "A")); }
@Override public void close() { if (null != iterator) { iterator.close(); } }
@Override public CloseableIterator<T> iterator() { return new LimitedCloseableIterator<>(iterable.iterator(), start, end, truncate); } }
@Override public void close() { iterable.close(); }
@Override public CloseableIterator<T> iterator() { if (null != cachedIterable) { return new WrappedCloseableIterator<>(cachedIterable.iterator()); } if (tooLarge) { return new WrappedCloseableIterator<>(iterable.iterator()); } return new CachingIterator(); }
/** * Constructs an {@code TransformIterable} with the given input {@link java.lang.Iterable} and no validation. * * @param input the input {@link java.lang.Iterable} */ public TransformIterable(final Iterable<? extends I> input) { this(input, new AlwaysValid<>(), false); }
@Override public CloseableIterator<T> iterator() { // By design, only 1 iterator can be open at a time closeBatch(); return new BatchedIterator(); }
public WrappedCloseableIterator(final Iterator<T> iterator) { if (null == iterator) { this.iterator = new EmptyCloseableIterator<>(); } else { this.iterator = iterator; } }
@Override public boolean hasNext() { return !isEmpty(); }
public boolean addAll(final Iterable<E> items) { boolean result = false; for (final E item : items) { if (add(item)) { result = true; } } return result; }
@Override public Iterator<T> iterator() { return new RepeatItemIterator<>(item, repeats); } }
@Override public CloseableIterator<T> iterator() { return new IteratorWrapper(); }
public WrappedCloseableIterable(final Iterable<T> iterable) { if (null == iterable) { this.iterable = new EmptyClosableIterable<>(); } else { this.iterable = iterable; } }
@Override public void close() { iterator.close(); }
/** * Constructs an {@code TransformOneToManyIterable} with the given input {@link Iterable} and no validation. * * @param input the input {@link Iterable} */ public TransformOneToManyIterable(final Iterable<? extends I> input) { this(input, new AlwaysValid<>(), false); }
@Test public void getElementsShouldReturnGeneratedElementTransformIterable() { // Given final OneToOneElementGenerator<String> generator = new OneToOneElementGeneratorImpl(); // When final TransformIterable<String, Element> result = (TransformIterable<String, Element>) generator.apply(Arrays.asList(obj1, obj2)); // Then final Iterator<Element> itr = result.iterator(); assertSame(elm1, itr.next()); assertSame(elm2, itr.next()); assertFalse(itr.hasNext()); }