How to use

FlagUtils$FlagConfigKeyAndValueRecord

in

org.apache.brooklyn.util.core.flags

protected boolean isRecordEqual(FlagConfigKeyAndValueRecord val1, ExpectedFlagConfigKeyAndValueRecord val2) {
  return Objects.equal(val1.getConfigKey(), val2.configKey)
      && Objects.equal(val1.getFlagName(), val2.flagName)
      && Objects.equal(val1.getConfigKeyMaybeValue(), val2.configKeyValue)
      && Objects.equal(val1.getFlagMaybeValue(), val2.flagValue);
}

/** gets all the keys in the given config bag which are applicable to the given list of parameters */
public static List<FlagConfigKeyAndValueRecord> findAllParameterConfigKeys(List<SpecParameter<?>> parameters, ConfigBag input) {
  List<FlagConfigKeyAndValueRecord> output = new ArrayList<FlagUtils.FlagConfigKeyAndValueRecord>();
  for (SpecParameter<?> param : parameters) {
    FlagConfigKeyAndValueRecord record = getFlagConfigKeyRecord(null, param.getConfigKey(), input);
    if (record.isValuePresent())
      output.add(record);
  }
  return output;
}

/** sets _all_ accessible _{@link ConfigKey}_ and {@link HasConfigKey} fields on the given object, 
 * using the indicated flags/config-bag */
public static void setAllConfigKeys(Configurable o, ConfigBag bag, boolean includeFlags) {
  for (Field f: getAllFields(o.getClass())) {
    ConfigKey<?> key = getFieldAsConfigKey(o, f);
    if (key!=null) {
      FlagConfigKeyAndValueRecord record = getFlagConfigKeyRecord(f, key, bag);
      if ((includeFlags && record.isValuePresent()) || record.getConfigKeyMaybeValue().isPresent()) {
        setField(o, f, record.getValueOrNullPreferringConfigKey(), null);
      }
    }
  }
}

public Object getValueOrNullPreferringFlag() {
  return getFlagMaybeValue().or(getConfigKeyMaybeValue()).orNull();
}
/** true if value is present for either flag or config key */

private void configureWithResolvedConfigKey(FlagUtils.FlagConfigKeyAndValueRecord r, EntitySpec spec, Set<String> keyNamesUsed){
  try {
    Optional<Object> resolvedValue = resolveValue(r.getConfigKeyMaybeValue().get(), Optional.<TypeToken>of(r.getConfigKey().getTypeToken()));
    if (resolvedValue.isPresent()) {
      spec.configure(r.getConfigKey(), resolvedValue.get());
    }
    // todo: Should this be in the if block?
    keyNamesUsed.add(r.getConfigKey().getName());
  } catch (Exception e) {
    String message = String.format("Cannot set config key %s, could not coerce %s to %s",
        r.getConfigKey(), r.getConfigKeyMaybeValue(), r.getConfigKey().getTypeToken());
    LOG.warn(message, e);
  }
}

private void configureWithResolvedFlag(FlagUtils.FlagConfigKeyAndValueRecord r, EntitySpec spec, Set<String> keyNamesUsed){
  Optional<Object> resolvedValue = resolveValue(r.getFlagMaybeValue().get(), Optional.<TypeToken>absent());
  if (resolvedValue.isPresent()) {
    spec.configure(r.getFlagName(), resolvedValue.get());
  }
  keyNamesUsed.add(r.getFlagName());
}

private void configureWithAllRecords(Collection<FlagUtils.FlagConfigKeyAndValueRecord> records, EntitySpec spec, Set<String> keyNamesUsed){
  for (FlagUtils.FlagConfigKeyAndValueRecord r : records) {
    if (r.getFlagMaybeValue().isPresent()) {
      configureWithResolvedFlag(r, spec, keyNamesUsed);
    }
    if (r.getConfigKeyMaybeValue().isPresent()) {
      configureWithResolvedConfigKey(r, spec, keyNamesUsed);
    }
  }
}

/** gets all the flags/keys in the given config bag which are applicable to the given type's config keys and flags */
public static <T> List<FlagConfigKeyAndValueRecord> findAllFlagsAndConfigKeys(T optionalInstance, Class<? extends T> type, ConfigBag input) {
  List<FlagConfigKeyAndValueRecord> output = new ArrayList<FlagUtils.FlagConfigKeyAndValueRecord>();
  for (Field f: getAllFields(type)) {
    ConfigKey<?> key = getFieldAsConfigKey(optionalInstance, f);
    FlagConfigKeyAndValueRecord record = getFlagConfigKeyRecord(f, key, input);
    if (record.isValuePresent())
      output.add(record);
  }
  return output;
}

public Object getValueOrNullPreferringConfigKey() {
  return getConfigKeyMaybeValue().or(getFlagMaybeValue()).orNull();
}
public Object getValueOrNullPreferringFlag() {

/** returns the flag/config-key record for the given input */
private static FlagConfigKeyAndValueRecord getFlagConfigKeyRecord(Field f, ConfigKey<?> key, ConfigBag input) {
  FlagConfigKeyAndValueRecord result = new FlagConfigKeyAndValueRecord(); 
  result.configKey = key;
  if (key!=null && input.containsKey(key))
    result.configKeyValue = input.getObjKeyMaybe(key);
  if (f != null) {
    SetFromFlag flag = f.getAnnotation(SetFromFlag.class);
    if (flag!=null) {
      String flagName = elvis(flag.value(), f.getName());
      result.flagName = flagName;
      if (input.containsKey(flagName))
        result.flagValue = Maybe.of(input.getStringKey(flagName));
    }
  }
  return result;
}