@Override public Maybe<JsonElement> apply(Maybe<JsonElement> input) { Maybe<JsonElement> curr = input; for (String element : elements) { if (curr.isAbsent()) return curr; JsonObject jo = curr.get().getAsJsonObject(); JsonElement currO = jo.get(element); if (currO==null) return Maybe.absent("No element '"+element+" in JSON, when walking "+elements); curr = Maybe.of(currO); } return curr; } };
/** * @throws ImmediateSupplier.ImmediateUnsupportedException if cannot evaluate this in a timely manner */ public static Maybe<String> formatStringImmediately(final String spec, final Object ...args) { List<Object> resolvedArgs = Lists.newArrayList(); for (Object arg : args) { Maybe<?> argVal = resolveImmediately(arg); if (argVal.isAbsent()) return Maybe.Absent.castAbsent(argVal); resolvedArgs.add(argVal.get()); } return Maybe.of(String.format(spec, resolvedArgs.toArray())); }
private Maybe<T> coerceValue(Maybe<Object> valueMaybe, Class<T> type) { if (valueMaybe.isPresent()) { T coercedValue = TypeCoercions.coerce(valueMaybe.get(), type); return Maybe.of(coercedValue); } else { @SuppressWarnings("unchecked") Maybe<T> uncheckedValue = (Maybe<T>) valueMaybe; return uncheckedValue; } }
public static Maybe<String> findSubnetIp(Iterable<? extends Location> ll) { // TODO Or if can't find MachineLocation, should we throw new IllegalStateException("Cannot find hostname for among "+ll); Maybe<MachineLocation> l = findUniqueMachineLocation(ll); return (l.isPresent()) ? Machines.getSubnetIp(l.get()) : Maybe.<String>absent(); }
public static ExecutionTarget fromString(String name) { Maybe<ExecutionTarget> parsed = tryFromString(name); return parsed.get(); } public static Maybe<ExecutionTarget> tryFromString(String name) {
/** * @throws ImmediateSupplier.ImmediateUnsupportedException if cannot evaluate this in a timely manner */ public static Maybe<String> urlEncodeImmediately(Object arg) { Maybe<?> resolvedArg = resolveImmediately(arg); if (resolvedArg.isAbsent()) return Absent.castAbsent(resolvedArg); if (resolvedArg.isNull()) return Maybe.<String>of((String)null); String resolvedString = resolvedArg.get().toString(); return Maybe.of(Urls.encode(resolvedString)); }
@Test public void testMaybeGetNull() { Maybe<String> m = Maybe.ofAllowingNull(null); Assert.assertTrue(m.isPresent()); Assert.assertEquals(m.get(), null); }
/** Like {@link #cast(Maybe)} but allows any casting because that is valid for absents. * Enforces that the argument really is absent. */ @SuppressWarnings("unchecked") public static <T> Maybe<T> castAbsent(Maybe<?> absent) { if (absent!=null && absent.isPresent()) { throw new IllegalArgumentException("Expected an absent, but instead got: "+absent); } return (Maybe<T>)absent; } }
public static Maybe<ReleaseableLatch> maxConcurrencyImmediately(Object maxThreads) { Maybe<?> resolvedMaxThreads = resolveImmediately(maxThreads); if (resolvedMaxThreads.isAbsent()) return Maybe.absent(); Integer resolvedMaxThreadsInt = TypeCoercions.coerce(resolvedMaxThreads, Integer.class); ReleaseableLatch result = ReleaseableLatch.Factory.newMaxConcurrencyLatch(resolvedMaxThreadsInt); return Maybe.<ReleaseableLatch>of(result); }
@Override public Task<?> getSubmittedByTask() { if (submittedByTask==null) return null; return submittedByTask.orNull(); }
@Override public void init() { super.init(); getRequiredConfig(ENDPOINT); // just to confirm it's set, failing fast if (config().getRaw(SENSOR_FAILED).isAbsent()) { config().set(SENSOR_FAILED, CONNECTION_FAILED); } if (config().getRaw(SENSOR_RECOVERED).isAbsent()) { config().set(SENSOR_RECOVERED, CONNECTION_RECOVERED); } }
public Builder<T,V> onTimeoutThrow() { onTimeout = Maybe.<V>absent(); return this; } public Builder<T,V> onUnmanagedReturn(V val) {
@Test public void testMaybeAbsentMessageNoTraceDoesNotIncludeSource() { Maybe<Object> m = Maybe.absentNoTrace("nope"); Assert.assertFalse(m.isPresent()); Exception e = assertGetFailsContaining(m, "nope"); Assert.assertTrue(containsGetExplicitMethod(e), "Outer trace should be in explicit method"); Assert.assertFalse(containsMaybeMethod(e, "absentNoTrace"), "Outer trace should not be from 'absentNoTrace'"); Assert.assertNull(e.getCause()); }