@Override public <T> T set(ConfigKey<T> key, T val) { assertValid(key, val); return setConfigInternal(key, val); }
@Override public T call() { try { return get(key); } catch (RuntimeInterruptedException e) { throw Exceptions.propagate(e); // expected; return gracefully } } };
@SuppressWarnings("unchecked") protected <T> T setConfigInternal(ConfigKey<T> key, Object val) { onConfigChanging(key, val); T result = (T) getConfigsInternal().setConfig(key, val); onConfigChanged(key, val); return result; }
@Override public <T> Maybe<T> getNonBlocking(final ConfigKey<T> key) { try { if (key instanceof StructuredConfigKey || key instanceof SubElementConfigKey) { return getNonBlockingResolvingStructuredKey(key); } else { return getNonBlockingResolvingSimple(key); } } catch (ImmediateValueNotAvailableException e) { return Maybe.absent(e); } catch (ImmediateUnsupportedException e) { return Maybe.absent(e); } }
@Override public ConfigMapWithInheritance<? extends BrooklynObject> getInternalConfigMap() { return getConfigsInternal(); }
/** * 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()); }
@Override public Maybe<Object> getRaw(HasConfigKey<?> key) { return getRaw(key.getConfigKey()); }
@Override public Maybe<Object> getLocalRaw(HasConfigKey<?> key) { return getLocalRaw(key.getConfigKey()); }
@Override public <T> Maybe<T> getNonBlocking(HasConfigKey<T> key) { return getNonBlocking(key.getConfigKey()); }
/** * For resolving a {@link StructuredConfigKey}, such as a {@link MapConfigKey}. Here we need to * execute the custom logic, as is done by {@link #get(ConfigKey)}, but non-blocking! */ protected <T> Maybe<T> getNonBlockingResolvingStructuredKey(final ConfigKey<T> key) { Callable<T> job = new Callable<T>() { @Override public T call() { try { return get(key); } catch (RuntimeInterruptedException e) { throw Exceptions.propagate(e); // expected; return gracefully } } }; Task<T> t = Tasks.<T>builder().body(job) .displayName("Resolving dependent value") .description("Resolving "+key.getName()) .tag(BrooklynTaskTags.TRANSIENT_TASK_TAG) .build(); try { return getContext().getImmediately(t); } catch (ImmediateUnsupportedException e) { return Maybe.absent(); } }
@Override public void removeKey(ConfigKey<?> key) { getConfigsInternal().removeKey(key); }
@Override public Set<ConfigKey<?>> findKeysDeclared(Predicate<? super ConfigKey<?>> filter) { return getConfigsInternal().findKeysDeclared(filter); }
@Override public <T> T get(HasConfigKey<T> key) { return get(key.getConfigKey()); }
@Override public Set<ConfigKey<?>> findKeysPresent(Predicate<? super ConfigKey<?>> filter) { return getConfigsInternal().findKeysPresent(filter); }
@SuppressWarnings("deprecation") @Override // see super; we aspire to depreate this due to poor treatment of inheritance public ConfigBag getBag() { return getConfigsInternal().getAllConfigBag(); }
@Override public Maybe<Object> getLocalRaw(ConfigKey<?> key) { return getConfigsInternal().getConfigLocalRaw(key); }
@Override public void removeKey(String key) { getConfigsInternal().removeKey(key); }
@Override public Map<ConfigKey<?>,Object> getAllLocalRaw() { return getConfigsInternal().getAllConfigLocalRaw(); }
@Override public <T> T get(ConfigKey<T> key) { return getConfigsInternal().getConfig(key); }
@Override public void putAll(Map<?, ?> vals) { getConfigsInternal().putAll(vals); }