/** * @return the first resolved value satisfying the {@code stopCondition}. * If none is found return the last element. */ public Maybe<Object> nextOrLast(Predicate<Object> stopCondition) { if (!hasNext()) { return prev; } Maybe<Object> item; do { item = next(); if (item.isAbsent() || stopCondition.apply(item.get())) { return item; } } while (hasNext()); return item; }
/** * Resolves the value recursively, returning the immediately resolved value. * If there's a resolve failure a {@link Maybe#absent()} is returned containing * the failure description as the last element. */ @Override public Maybe<Object> next() { if (!hasNext()) { if (prev.isPresent()) { throw new NoSuchElementException("The value " + prev.get() + " is non-resolvable"); } else { throw new NoSuchElementException("Last resolve failed: " + prev); } } prev = next; next = NEXT_VALUE; return prev; }
/** * @return the first resolved value instance of {@code type}. * If not found returns {@link Maybe#absent()} either due to * the end reached or a resolve error. To check if there was a * resolve error call {@code peek().isAbsent()}. */ public <S> Maybe<S> next(Class<S> type) { while (hasNext()) { Maybe<Object> item = next(); if (item.isAbsent() || type.isInstance(item.get())) { @SuppressWarnings("unchecked") Maybe<S> typedItem = (Maybe<S>) item; return typedItem; } } return Maybe.absent("Did not find items of type " + type + " in " + resolver); }
/** * @return the last element of the iterator reached either because * resolving no longer possible or there was a resolve error. */ @SuppressWarnings("unchecked") public Maybe<T> last() { Maybe<Object> last = peek(); while (hasNext()) { last = next(); if (last.isAbsent()) { return (Maybe<T>) last; } } return coerceValue(last, resolver.getType()); }
.immediately(resolveType.isImmediate()); ValueResolverIterator<Integer> iter = resolver.iterator(); assertTrue(iter.hasNext(), "expected o1"); Maybe<Object> o1Actual = iter.next(); assertEquals(o1Actual.get(), o1Expected); assertEquals(o1Actual, iter.peek()); assertTrue(iter.hasNext()); Maybe<Object> o2Actual = iter.next(); assertEquals(o2Actual.get(), o2Expected); assertEquals(o2Actual, iter.peek()); assertTrue(iter.hasNext()); Maybe<Object> o3Actual = iter.next(); assertEquals(o3Actual.get(), o3Expected); assertEquals(o3Actual, iter.peek()); assertFalse(iter.hasNext(), "expected no more elements"); try { iter.next();
@Test(dataProvider="resolveTypes") public void testNull(ResolveType resolveType) { ValueResolver<Void> resolver = Tasks.resolving(null) .as(Void.class) .context(app) .immediately(resolveType.isImmediate()); assertNull(resolver.get()); ValueResolverIterator<Void> iter = resolver.iterator(); assertTrue(iter.hasNext()); assertNull(iter.next().get()); assertFalse(iter.hasNext()); Maybe<Object> voidOrLast = resolver.iterator().nextOrLast(Void.class); assertNull(voidOrLast.get()); Maybe<Void> voidItem = resolver.iterator().next(Void.class); assertTrue(voidItem.isAbsent()); Maybe<Void> lastItem = resolver.iterator().last(); assertNull(lastItem.get()); }
.immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); assertTrue(iter.hasNext(), "expected wrapper"); Maybe<Object> wrapperActual = iter.next(); assertEquals(wrapperActual.get(), wrapperExpected); assertEquals(wrapperActual, iter.peek()); assertTrue(iter.hasNext()); Maybe<Object> failingActual = iter.next(); assertEquals(failingActual.get(), failingExpected); assertEquals(failingActual, iter.peek()); assertTrue(iter.hasNext()); Maybe<Object> absent = iter.next(); assertTrue(absent.isAbsent()); assertFalse(iter.hasNext(), "expected absent due to resolve failure"); try { iter.next();