Java Code Examples for org.apache.brooklyn.config.ConfigKey#getDeprecatedNames()

private static ConfigValue getValue(Map<?,?> flags, ConfigKey<?> key) {
    Maybe<Object> val;
    String keyName = key.getName();
    if (flags.containsKey(keyName)) {
        val = Maybe.of(flags.get(keyName));
        flags.remove(keyName);
    } else {
        val = Maybe.absent();
    }
    Map<String, Object> deprecatedValues = new LinkedHashMap<>(key.getDeprecatedNames().size());
    for (String deprecatedName : key.getDeprecatedNames()) {
        if (flags.containsKey(deprecatedName)) {
            deprecatedValues.put(deprecatedName, flags.get(deprecatedName));
            flags.remove(deprecatedName);
        }
    }
    return new ConfigValue(val, deprecatedValues);
}
 

protected BrooklynTypeSnapshot(String name, Map<String, ConfigKey<?>> configKeys) {
    this.name = name;
    this.configKeys = ImmutableMap.copyOf(configKeys);
    this.configKeysSet = ImmutableSet.copyOf(this.configKeys.values());
    
    this.configKeysByDeprecatedName = new LinkedHashMap<>();
    for (ConfigKey<?> key : configKeysSet) {
        for (String deprecatedName : key.getDeprecatedNames()) {
            if (configKeys.containsKey(deprecatedName)) {
                LOG.warn("Conflicting config key name '"+deprecatedName+"' used in "+configKeys.get(deprecatedName)+" and as deprecated name of "+key+"; will prefer "+key+" but may cause problems");
            } else if (configKeysByDeprecatedName.containsKey(deprecatedName)) {
                LOG.warn("Conflicting config key name '"+deprecatedName+"' used as deprecated name in both "+configKeysByDeprecatedName.get(deprecatedName)+" and "+key+"; may cause problems");
            } else {
                configKeysByDeprecatedName.put(deprecatedName, key);
            }
        }
    }
}
 

@Override @Deprecated
public Maybe<Object> getConfigRaw(ConfigKey<?> key, boolean includeInherited) {
    // does not currently respect inheritance modes
    if (ownConfig.containsKey(key)) {
        return Maybe.of(ownConfig.get(key));
    }
    for (String deprecatedName : key.getDeprecatedNames()) {
        // Unfortunately `config.putAll(map.of(string, val))` (for dynamic config keys, 
        // i.e. where the key is not pre-defined on the entity). Unfortunately that
        // means subsequent lookup must synthesise keys for each deprecated name.
        ConfigKey<?> deprecatedKey = ConfigKeys.newConfigKeyRenamed(deprecatedName, key);
        if (ownConfig.containsKey(deprecatedKey)) {
            LOG.warn("Retrieving value with deprecated config key name '"+deprecatedName+"' for key "+key);
            return Maybe.of(ownConfig.get(deprecatedKey));
        }
    }
    if (!includeInherited || getParent()==null) return Maybe.absent();
    return getParentInternal().config().getInternalConfigMap().getConfigRaw(key, includeInherited);
}
 

/** finds the value at the given container/key, taking in to account any resolution expected by the key (eg for map keys).
 * the input is the value in the {@link #ownConfig} map taken from {@link #getRawValueAtContainer(BrooklynObject, ConfigKey)}, 
 * but the key may have other plans.
 * current impl just uses the key to extract again which is a little bit wasteful but simpler. 
 * <p>
 * this does not do any resolution with respect to ancestors. */
protected Maybe<Object> resolveRawValueFromContainer(TContainer container, ConfigKey<?> key, Maybe<Object> value) {
    Maybe<Object> result = resolveRawValueFromContainerIgnoringDeprecatedNames(container, key, value);
    if (result.isPresent()) return result;
    
    // See AbstractconfigMapImpl.getConfigRaw(ConfigKey<?> key, boolean includeInherited) for how/why it
    // handles deprecated names
    for (String deprecatedName : key.getDeprecatedNames()) {
        ConfigKey<?> deprecatedKey = ConfigKeys.newConfigKeyRenamed(deprecatedName, key);
        result = resolveRawValueFromContainerIgnoringDeprecatedNames(container, deprecatedKey, value);
        if (result.isPresent()) {
            LOG.warn("Retrieving value with deprecated config key name '"+deprecatedName+"' for key "+key);
            return result;
        }
    }
    return result;
}
 

public boolean containsKey(ConfigKey<?> key) {
    boolean found = containsKey(key.getName());
    if (!found) {
        for (String deprecatedName : key.getDeprecatedNames()) {
            found = containsKey(deprecatedName);
            if (found) break;
        }
    }
    return found;
}
 

private synchronized Maybe<Object> getKeyMaybeInternal(ConfigKey<?> key, Function<String, Maybe<Object>> getKey) {
    Maybe<Object> val = getKey.apply(key.getName());

    String firstDeprecatedName = null;
    Maybe<Object> firstDeprecatedVal = null;
    for (String deprecatedName : key.getDeprecatedNames()) {
        Maybe<Object> deprecatedVal = getKey.apply(deprecatedName);
        if (deprecatedVal.isPresent()) {
            if (val.isPresent()) {
                if (!Objects.equal(val.get(), deprecatedVal.get())) {
                    log.warn("Conflicting value for key "+key+" from deprecated name '"+deprecatedName+"'; "
                        + "using value from preferred name "+key.getName());
                } else {
                    log.warn("Duplicate value for key "+key+" from deprecated name '"+deprecatedName+"'; "
                        + "using same value from preferred name "+key.getName());
                }
            } else if (firstDeprecatedVal != null && firstDeprecatedVal.isPresent()) {
                if (!Objects.equal(firstDeprecatedVal.get(), deprecatedVal.get())) {
                    log.warn("Conflicting value for key "+key+" from deprecated name '"+deprecatedName+"'; "
                        + "using earlier deprecated name "+firstDeprecatedName);
                } else {
                    log.warn("Duplicate value for key "+key+" from deprecated name '"+deprecatedName+"'; "
                        + "using same value from earlier depreated name "+key.getName());
                }
            } else {
                // new value, from deprecated name
                log.warn("Value for key "+key+" found with deprecated name '"+deprecatedName+"'; "
                    + "recommend changing to preferred name '"+key.getName()+"'; this will not be supported in future versions");
                firstDeprecatedName = deprecatedName;
                firstDeprecatedVal = deprecatedVal;
            }
        }
    }

    return val.isPresent() ? val : (firstDeprecatedVal != null && firstDeprecatedVal.isPresent() ? firstDeprecatedVal : val);
}