@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public <T> Maybe<Class<? extends T>> tryLoadClass(String className, @Nullable Class<T> supertype) { Maybe<Class<?>> result = tryLoadClass(className); if (result.isAbsent()) return (Maybe)result; Class<?> clazz = result.get(); if (supertype==null || supertype.isAssignableFrom(clazz)) return (Maybe)result; throw new ClassCastException(className+" is not an instance of "+supertype); }
@Override public T apply(Maybe<JsonElement> input) { if (input.isAbsent()) return defaultValue; return cast(expected).apply(input.get()); } }
/** * @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())); }
/** as {@link #invokeMethodFromArgs(Object, String, List)} but giving control over whether to set it accessible */ public static Maybe<Object> invokeMethodFromArgs(Object clazzOrInstance, String method, List<?> args, boolean setAccessible, Optional<? extends TypeCoercer> coercer) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException { Maybe<Method> maybeMethod = getMethodFromArgs(clazzOrInstance, method, args); if (coercer.isPresent() && maybeMethod.isAbsent()) { maybeMethod = getMethodFromArgs(clazzOrInstance, method, args, coercer); } if (maybeMethod.isAbsent()) { return Maybe.absent(Maybe.getException(maybeMethod)); } Method m = maybeMethod.get(); return Maybe.of(invokeMethodFromArgs(clazzOrInstance, m, args, setAccessible, coercer)); }
@SuppressWarnings("unchecked") @Override public Maybe<T> apply(Maybe<Object> input) { if (raw || input==null || input.isAbsent()) return (Maybe<T>)input; return Maybe.ofAllowingNull(coerce(input.get(), type)); } };
@Override @Deprecated public Maybe<Location> resolve(String spec, Boolean manage, Map locationFlags) { if (manage!=null) { locationFlags = MutableMap.copyOf(locationFlags); locationFlags.put(LocalLocationManager.CREATE_UNMANAGED, !manage); } Maybe<LocationSpec<? extends Location>> lSpec = getLocationSpec(spec, locationFlags); if (lSpec.isAbsent()) return (Maybe)lSpec; return Maybe.of((Location)mgmt.getLocationManager().createLocation(lSpec.get())); }
protected void tryTransform(AttributeSensor<?> sensor) { if (!isRunning()) { return; } Maybe<MachineLocation> machine = getMachine(); if (machine.isAbsent()) { return; } tryTransform(machine.get(), sensor); }
protected void setActualState(Maybe<Lifecycle> state) { if (log.isTraceEnabled()) log.trace("{} setting actual state {}", this, state); if (((EntityInternal)entity).getManagementSupport().isNoLongerManaged()) { // won't catch everything, but catches some BrooklynLogging.log(log, BrooklynLogging.levelDebugOrTraceIfReadOnly(entity), entity+" is no longer managed when told to set actual state to "+state+"; suppressing"); return; } Object newVal = (state.isAbsent() ? Entities.UNCHANGED : (state.get() == null ? Entities.REMOVE : state.get())); emit(SERVICE_STATE_ACTUAL, newVal); }
@Test public void testWalkMWrong1() { Maybe<JsonElement> m = JsonFunctions.walkM("europe", "spain", "barcelona").apply( Maybe.of( europeMap()) ); Assert.assertTrue(m.isAbsent()); }
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); }
private void assertThrowsNoSuchElement(String val) { try { resolve(val); fail(); } catch (NoSuchElementException e) { // success } // and check the long form returns an Absent (not throwing) Assert.assertTrue(managementContext.getLocationRegistry().getLocationSpec(val).isAbsent()); }
@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); } }
private void assertThrowsIllegalArgument(String val) { try { resolve(val); fail(); } catch (IllegalArgumentException e) { // success } // and check the long form returns an Absent (not throwing) Assert.assertTrue(managementContext.getLocationRegistry().getLocationSpec(val).isAbsent()); } }
/** * @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 testAttributeWhenReadyEmptyImmediatelyDoesNotBlock() throws Exception { BrooklynDslDeferredSupplier<?> dsl = BrooklynDslCommon.attributeWhenReady(TestApplication.MY_ATTRIBUTE.getName()); Maybe<?> actualValue = execDslImmediately(dsl, TestApplication.MY_ATTRIBUTE.getType(), app, true); assertTrue(actualValue.isAbsent()); }
@Test public void testAttributeWhenReadyEmptyDoesNotBlock() throws Exception { BrooklynDslDeferredSupplier<?> dsl = BrooklynDslCommon.attributeWhenReady(TestApplication.MY_ATTRIBUTE.getName()); Maybe<?> actualValue = execDslRealRealQuick(dsl, TestApplication.MY_ATTRIBUTE.getType(), app); assertTrue(actualValue.isAbsent()); }
public void testUnsubmittedTaskWhenNoExecutionContextFails() { Task<String> t = newSleepTask(Duration.ZERO, "foo"); // Below, we call ValueResolver.getMaybe() with no execution context. Therefore it will not execute the task. Maybe<String> result = Tasks.resolving(t).as(String.class).timeout(Duration.ZERO).getMaybe(); Assert.assertTrue(result.isAbsent(), "result="+result); Exception exception = Maybe.getException(result); Assert.assertTrue(exception.toString().contains("no execution context available"), "exception="+exception); }
protected static Effector<?> assertHasInitializers(Entity entity, String effectorName) { Maybe<Effector<?>> effectorMaybe = entity.getEntityType().getEffectorByName(effectorName); assertFalse(effectorMaybe.isAbsent()); return effectorMaybe.get(); }
@Override protected void initEnrichers() { if (config().getLocalRaw(UP_QUORUM_CHECK).isAbsent()) { config().set(UP_QUORUM_CHECK, QuorumChecks.newInstance(2, 1.0, false)); } super.initEnrichers(); ServiceStateLogic.newEnricherFromChildrenUp().checkChildrenOnly().requireUpChildren(getConfig(UP_QUORUM_CHECK)).addTo(this); }
@Override public boolean isUp() { if (!Entitlements.isEntitled(mgmt().getEntitlementManager(), Entitlements.SERVER_STATUS, null)) throw WebResourceUtils.forbidden("User '%s' is not authorized for this operation", Entitlements.getEntitlementContext().user()); Maybe<ManagementContext> mm = mgmtMaybe(); return !mm.isAbsent() && mm.get().isStartupComplete() && mm.get().isRunning(); }