/** * @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())); }
public static Maybe<String> regexReplacementImmediately(Object source, Object pattern, Object replacement) { Maybe<?> resolvedSource = resolveImmediately(source); if (resolvedSource.isAbsent()) return Absent.castAbsent(resolvedSource); String resolvedSourceStr = String.valueOf(resolvedSource.get()); Maybe<?> resolvedPattern = resolveImmediately(pattern); if (resolvedPattern.isAbsent()) return Absent.castAbsent(resolvedPattern); String resolvedPatternStr = String.valueOf(resolvedPattern.get()); Maybe<?> resolvedReplacement = resolveImmediately(replacement); if (resolvedReplacement.isAbsent()) return Absent.castAbsent(resolvedReplacement); String resolvedReplacementStr = String.valueOf(resolvedReplacement.get()); String result = new StringFunctions.RegexReplacer(resolvedPatternStr, resolvedReplacementStr).apply(resolvedSourceStr); return Maybe.of(result); }
public static Maybe<Function<String, String>> regexReplacementImmediately(Object pattern, Object replacement) { Maybe<?> resolvedPattern = resolveImmediately(pattern); if (resolvedPattern.isAbsent()) return Absent.castAbsent(resolvedPattern); String resolvedPatternStr = String.valueOf(resolvedPattern.get()); Maybe<?> resolvedReplacement = resolveImmediately(replacement); if (resolvedReplacement.isAbsent()) return Absent.castAbsent(resolvedReplacement); String resolvedReplacementStr = String.valueOf(resolvedReplacement.get()); RegexReplacer result = new StringFunctions.RegexReplacer(resolvedPatternStr, resolvedReplacementStr); return Maybe.<Function<String, String>>of(result); }
/** * For resolving a "simple" config key - i.e. where there's not custom logic inside a * {@link StructuredConfigKey} such as a {@link MapConfigKey}. For those, we'd need to do the * same as is in {@link #get(ConfigKey)}, but non-blocking! * See {@link #getNonBlockingResolvingStructuredKey(ConfigKey)}. */ protected <T> Maybe<T> getNonBlockingResolvingSimple(ConfigKey<T> key) { // TODO See AbstractConfigMapImpl.getConfigImpl, for how it looks up the "container" of the // key, so that it gets the right context entity etc. // getRaw returns Maybe(val) if the key was explicitly set (where val can be null) // or Absent if the config key was unset. Object unresolved = getRaw(key).or(key.getDefaultValue()); Maybe<Object> resolved = Tasks.resolving(unresolved) .as(Object.class) .immediately(true) .deep(true) .context(getContext()) .getMaybe(); if (resolved.isAbsent()) return Maybe.Absent.<T>castAbsent(resolved); // likely we don't need this coercion if we set as(key.getType()) above, // but that needs confirmation and quite a lot of testing return TypeCoercions.tryCoerce(resolved.get(), key.getTypeToken()); }
/** * @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)); }