ExpectedFlagConfigKeyAndValueRecord(ConfigKey<?> key, String flagName, Object val) { this.configKey = key; this.flagName = flagName; this.configKeyValue = Maybe.of(val); } @Override
@Override public Maybe<T> apply(T oldValue) { if (Objects.equal(oldValue, newValue)) { return lastValue = Maybe.absent("Skipping update, values equal"); } else { return lastValue = Maybe.of(newValue); } }
private synchronized Maybe<Object> getRawStringKeyMaybe(String key, boolean markUsed) { if (config.containsKey(key)) { if (markUsed) markUsed(key); return Maybe.of(config.get(key)); } return Maybe.absent(); }
private static <T> Maybe<T> lookupViaServiceLoader(Class<T> clazz, ClassLoader loader) { LOG.trace("Looking up " + clazz.getSimpleName() + " via ServiceLoader"); Maybe<T> result = Maybe.absent("No class " + clazz.getSimpleName() + " found with ServiceLoader"); ServiceLoader<T> LOADER = lookupAllViaServiceLoader(clazz, loader); for (T item : LOADER) { return Maybe.of(item); } return result; }
@Override public Maybe<Effector<?>> getEffectorByName(String name) { if (name != null) { for (Effector<?> contender : effectors) { if (name.equals(contender.getName())) return Maybe.<Effector<?>>of(contender); } } return Maybe.<Effector<?>>absent("No effector matching '" + name + "'"); }
@Nullable public static HostGeoLookup getDefaultLookup() throws InstantiationException, IllegalAccessException, ClassNotFoundException { if (cachedLookup==null) { cachedLookup = Maybe.of(findHostGeoLookupImpl()); } return cachedLookup.get(); }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public void setSubmittedByTask(Task<?> task) { submittedByTask = Maybe.softThen((Task)task, (Maybe)Maybe.of(BasicTask.newGoneTaskFor(task))); }
/** * @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())); }
/** @return a {@link Maybe} object which is absent if the argument {@link #isBlank(CharSequence)} */ public static <T extends CharSequence> Maybe<T> maybeNonBlank(T s) { if (isNonBlank(s)) return Maybe.of(s); return Maybe.absent(); }
@Override public Maybe<TValue> getDefaultValue() { if (key==null || !key.hasDefaultValue()) return Maybe.absent(); return conversionFunction.apply(Maybe.of((Object)key.getDefaultValue())); }
public static Maybe<String> findSubnetIp(Entity entity) { String sh = entity.getAttribute(Attributes.SUBNET_ADDRESS); if (sh!=null) return Maybe.of(sh); return findSubnetIp(entity.getLocations()); }
@Override protected synchronized Maybe<Object> getKeyMaybe(ConfigKey<?> key, boolean markUsed) { Maybe<Object> result = super.getKeyMaybe(key, markUsed); return (result.isPresent()) ? Maybe.of(getTransformer().apply(result.get())) : result; }
@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())); }
public static Maybe<CatalogBundle> resolve(ManagementContext mgmt, CatalogBundle b) { if (b.isNameResolved()) return Maybe.of(b); OsgiManager osgi = ((ManagementContextInternal)mgmt).getOsgiManager().orNull(); if (osgi==null) return Maybe.absent("No OSGi manager"); Maybe<Bundle> b2 = osgi.findBundle(b); if (b2.isAbsent()) return Maybe.absent("Nothing installed for "+b); return Maybe.of(new CatalogBundleDto(b2.get().getSymbolicName(), b2.get().getVersion().toString(), b.getUrl())); }
@Test public void testWalkM() { Maybe<JsonElement> pop = JsonFunctions.walkM("europe", "france", "population").apply( Maybe.of(europeMap()) ); Assert.assertEquals( (int)JsonFunctions.castM(Integer.class).apply(pop), 80*1000*1000 ); }
@Test(expectedExceptions=UnsupportedOperationException.class) public void testCastMWrong() { Maybe<JsonElement> m = JsonFunctions.walkM("europe", "france").apply( Maybe.of( europeMap()) ); JsonFunctions.castM(String.class).apply(m); }
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 Maybe<Object> getConfigRaw(ConfigKey<?> key) { if (containsKey(key.getName())) return Maybe.of(get(key.getName())); return Maybe.absent(); }
/** 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)); }