private static ConfigObject getAsConfigObject(final ConfigList configList) {
    final Map<String, ConfigValue> flattenedConfigValues = new HashMap<>(configList.size());

    for (int i = 0; i < configList.size(); i++) {
        final ConfigValue configValue = configList.get(i);
        final String configPath;
        if (ConfigValueType.OBJECT == configValue.valueType()) {
            configPath = getName((ConfigObject) configValue);
        } else {
            configPath = String.valueOf(i);
        }
        flattenedConfigValues.put(configPath, configValue);
    }

    return ConfigValueFactory.fromMap(flattenedConfigValues);
}
 

public HoconTreeTraversingParser(ConfigObject n, ObjectCodec codec)
{
    super(0);
    _rootObject = n;
    _objectCodec = codec;
    if (n.valueType() == ConfigValueType.LIST) {
        _nextToken = JsonToken.START_ARRAY;
        _nodeCursor = new HoconNodeCursor.Array(n, null);
    } else if (n.valueType() == ConfigValueType.OBJECT) {
        if (HoconNodeCursor.isNumericallyIndexed(n)) {
            _nextToken = JsonToken.START_ARRAY;
            _nodeCursor = new HoconNodeCursor.NumericallyIndexedObjectBackedArray(n, null);
        } else {
            _nextToken = JsonToken.START_OBJECT;
            _nodeCursor = new HoconNodeCursor.Object(n, null);
        }
    } else { // value node
        _nodeCursor = new HoconNodeCursor.RootValue(n, null);
    }
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(REGEX_CONFIG, ConfigValueType.STRING)
      .mandatoryPath(FIELDS_CONFIG, ConfigValueType.LIST)
      .add(new Validation() {
        @Override
        public ValidationResult validate(Config config) {
          try {
            Pattern.compile(config.getString(REGEX_CONFIG));
          }
          catch (PatternSyntaxException pse) {
            return new ValidationResult(this, Validity.INVALID, "Regular expression does not have valid syntax");
          }
          return new ValidationResult(this, Validity.VALID, "Regular expression has valid syntax");
        }
        @Override
        public Set<String> getKnownPaths() {
          return Sets.newHashSet(REGEX_CONFIG);
        }
      })
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(IF_TRUE_STEP_NAMES_PROPERTY, ConfigValueType.LIST)
      .mandatoryPath(DECISION_METHOD_PROPERTY, ConfigValueType.STRING)
      .allowedValues(DECISION_METHOD_PROPERTY, LITERAL_DECISION_METHOD, STEP_BY_KEY_DECISION_METHOD, STEP_BY_VALUE_DECISION_METHOD)
      .ifPathHasValue(DECISION_METHOD_PROPERTY, LITERAL_DECISION_METHOD, 
          new MandatoryPathValidation(LITERAL_RESULT_PROPERTY, ConfigValueType.BOOLEAN))
      .ifPathHasValue(DECISION_METHOD_PROPERTY, STEP_BY_KEY_DECISION_METHOD, 
          new MandatoryPathValidation(STEP_BY_KEY_KEY_PROPERTY, ConfigValueType.STRING))
      .ifPathHasValue(DECISION_METHOD_PROPERTY, STEP_BY_KEY_DECISION_METHOD, 
          new MandatoryPathValidation(STEP_BY_KEY_STEP_PROPERTY, ConfigValueType.STRING))
      .ifPathHasValue(DECISION_METHOD_PROPERTY, STEP_BY_VALUE_DECISION_METHOD, 
          new MandatoryPathValidation(STEP_BY_VALUE_STEP_PROPERTY, ConfigValueType.STRING))
      .addAll(super.getValidations())
      .build();
}
 

@Test
public void testValidationsBuilder() {
  Validations v = Validations
      .builder()
      .mandatoryPath("mandatory1")
      .mandatoryPath("mandatory2", ConfigValueType.STRING)
      .optionalPath("optional1")
      .optionalPath("optional2", ConfigValueType.NUMBER)
      .atMostOnePathExists("atmostone1", "atmostone2")
      .atMostOnePathExists(ConfigValueType.BOOLEAN, "atmostone3", "atmostone4")
      .exactlyOnePathExists("exactlyone1", "exactlyone2")
      .exactlyOnePathExists(ConfigValueType.STRING, "exactlyone3", "exactlyone4")
      .ifPathHasValue("hasvalue", true, Validations.single().allowedValues("hasvalue", true))
      .ifPathExists("pathexists", Validations.single().mandatoryPath("pathexists"))
      .allowedValues("allowed", "hello", "world")
      .build();

  // The specified validations plus the automatic non-empty validations
  assertEquals(26, v.size());
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .optionalPath(CACHE_ENABLED_PROPERTY, ConfigValueType.BOOLEAN)
      .optionalPath(CACHE_STORAGE_LEVEL_PROPERTY, ConfigValueType.STRING)
      .optionalPath(SMALL_HINT_PROPERTY, ConfigValueType.BOOLEAN)
      .optionalPath(PRINT_SCHEMA_ENABLED_PROPERTY, ConfigValueType.BOOLEAN)
      .optionalPath(PRINT_DATA_ENABLED_PROPERTY, ConfigValueType.BOOLEAN)
      .ifPathHasValue(PRINT_DATA_ENABLED_PROPERTY, true,
          Validations.single().optionalPath(PRINT_DATA_LIMIT_PROPERTY, ConfigValueType.NUMBER))
      .optionalPath(INPUT_TYPE, ConfigValueType.OBJECT)
      .optionalPath(DERIVER_TYPE, ConfigValueType.OBJECT)
      .optionalPath(PLANNER_TYPE, ConfigValueType.OBJECT)
      .optionalPath(PARTITIONER_TYPE, ConfigValueType.OBJECT)
      .optionalPath(OUTPUT_TYPE, ConfigValueType.OBJECT)
      .exactlyOnePathExists(INPUT_TYPE, DERIVER_TYPE)
      .handlesOwnValidationPath(INPUT_TYPE)
      .handlesOwnValidationPath(DERIVER_TYPE)
      .handlesOwnValidationPath(PLANNER_TYPE)
      .handlesOwnValidationPath(PARTITIONER_TYPE)
      .handlesOwnValidationPath(OUTPUT_TYPE)
      .addAll(super.getValidations())
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(MODE_PROPERTY, ConfigValueType.STRING)
      .mandatoryPath(SOURCE_PROPERTY, ConfigValueType.STRING)
      .allowedValues(SOURCE_PROPERTY, SOURCE_RANGE, SOURCE_LIST, SOURCE_STEP)
      .ifPathHasValue(SOURCE_PROPERTY, SOURCE_RANGE,
          new MandatoryPathValidation(RANGE_START_PROPERTY))
      .ifPathHasValue(SOURCE_PROPERTY, SOURCE_RANGE,
          new MandatoryPathValidation(RANGE_END_PROPERTY))
      .ifPathHasValue(SOURCE_PROPERTY, SOURCE_LIST, 
          new MandatoryPathValidation(LIST_PROPERTY, ConfigValueType.LIST))
      .ifPathHasValue(SOURCE_PROPERTY, SOURCE_STEP, 
          new MandatoryPathValidation(STEP_PROPERTY, ConfigValueType.STRING))
      .ifPathHasValue(SOURCE_PROPERTY, SOURCE_RANGE, 
          new MandatoryPathValidation(PARAMETER_PROPERTY, ConfigValueType.STRING))
      .ifPathHasValue(SOURCE_PROPERTY, SOURCE_LIST, 
          new MandatoryPathValidation(PARAMETER_PROPERTY, ConfigValueType.STRING))
      .ifPathHasValue(SOURCE_PROPERTY, SOURCE_STEP, 
          new MandatoryPathValidation(SUFFIX_PROPERTY, ConfigValueType.STRING))
      .addAll(super.getValidations())
      .build();
}
 

/**
 * returns a version of a config with only values - no nested objects.
 *
 * @param config config
 * @return result
 */
private Config valuesOnly(Config config) {
  for (String key : config.root().keySet()) {
    LOGGER.debug("key: ", key);
    try {
      ConfigValue value = config.getValue(key);
      LOGGER.debug("child type: ", value.valueType());
      if (value.valueType() == ConfigValueType.OBJECT) {
        config = config.withoutPath(key);
      }
    } catch(ConfigException configExceptions) {
      LOGGER.debug("error processing");
      config = config.withoutPath("\""+key+"\"");
    }
  }
  return config;
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(DELIMITER_CONFIG_NAME, ConfigValueType.STRING)
      .mandatoryPath(SCHEMA_CONFIG, ConfigValueType.OBJECT)
      .add(new SupportedFieldTypesValidation(SCHEMA_CONFIG, 
          new HashSet<DataType>(Arrays.asList(new DecimalType(),    DataTypes.StringType,
                                              DataTypes.FloatType,  DataTypes.DoubleType,
                                              DataTypes.ShortType,  DataTypes.IntegerType,
                                              DataTypes.LongType,   DataTypes.BooleanType,
                                              DataTypes.BinaryType, DataTypes.DateType,
                                              DataTypes.TimestampType))))
      .optionalPath(DELIMITER_REGEX_CONFIG_NAME, ConfigValueType.BOOLEAN)
      .optionalPath(TIMESTAMP_FORMAT_CONFIG_NAME, ConfigValueType.LIST)
      .handlesOwnValidationPath(SCHEMA_CONFIG)
      .build();
}
 

/**
 * Parse a play configuration.
 *
 * @param config play configuration
 * @return ebean parsed configuration
 * @see com.typesafe.config.Config
 */
public static EbeanParsedConfig parseFromConfig(Config config) {
    Config playEbeanConfig = config.getConfig("play.ebean");
    String defaultDatasource = playEbeanConfig.getString("defaultDatasource");
    String ebeanConfigKey = playEbeanConfig.getString("config");

    Map<String, List<String>> datasourceModels = new HashMap<>();

    if (config.hasPath(ebeanConfigKey)) {
        Config ebeanConfig = config.getConfig(ebeanConfigKey);
        ebeanConfig.root().forEach((key, raw) -> {
            List<String> models;
            if (raw.valueType() == ConfigValueType.STRING) {
                // Support legacy comma separated string
                models = Arrays.asList(((String) raw.unwrapped()).split(","));
            } else {
                models = ebeanConfig.getStringList(key);
            }

            datasourceModels.put(key, models);
        });
    }
    return new EbeanParsedConfig(defaultDatasource, datasourceModels);
}
 

/**
 * Initializes the configuration class by loading the configuration file.
 * @param conf overrides the default configuration
 */
public static void init(com.typesafe.config.Config conf) {
	try {
		config = ConfigFactory.load().getConfig(PARA);

		if (conf != null) {
			config = conf.withFallback(config);
		}

		configMap = new HashMap<>();
		for (Map.Entry<String, ConfigValue> con : config.entrySet()) {
			if (con.getValue().valueType() != ConfigValueType.LIST) {
				configMap.put(con.getKey(), config.getString(con.getKey()));
			}
		}
	} catch (Exception ex) {
		logger.warn("Para configuration file 'application.(conf|json|properties)' is invalid or missing from classpath.");
		config = com.typesafe.config.ConfigFactory.empty();
	}
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(KEY_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(VALUE_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(TIMESTAMP_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(EFFECTIVE_FROM_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(EFFECTIVE_TO_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .optionalPath(CURRENT_FLAG_FIELD_NAME_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(CURRENT_FLAG_YES_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(CURRENT_FLAG_NO_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(LAST_UPDATED_FIELD_NAME_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(SURROGATE_KEY_FIELD_NAME_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(CARRY_FORWARD_CONFIG_NAME, ConfigValueType.BOOLEAN)
      .optionalPath(EVENT_TIME_MODEL_CONFIG_NAME, ConfigValueType.OBJECT)
      .optionalPath(LAST_UPDATED_TIME_MODEL_CONFIG_NAME, ConfigValueType.OBJECT)
      .handlesOwnValidationPath(EVENT_TIME_MODEL_CONFIG_NAME)
      .handlesOwnValidationPath(LAST_UPDATED_TIME_MODEL_CONFIG_NAME)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(KEY_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(VALUE_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(TIMESTAMP_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(EVENT_TIME_EFFECTIVE_FROM_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(EVENT_TIME_EFFECTIVE_TO_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(SYSTEM_TIME_EFFECTIVE_FROM_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .mandatoryPath(SYSTEM_TIME_EFFECTIVE_TO_FIELD_NAMES_CONFIG_NAME, ConfigValueType.LIST)
      .optionalPath(CURRENT_FLAG_FIELD_NAME_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(CURRENT_FLAG_YES_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(CURRENT_FLAG_NO_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(SURROGATE_KEY_FIELD_NAME_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(CARRY_FORWARD_CONFIG_NAME, ConfigValueType.BOOLEAN)
      .optionalPath(EVENT_TIME_MODEL_CONFIG_NAME, ConfigValueType.OBJECT)
      .optionalPath(SYSTEM_TIME_MODEL_CONFIG_NAME, ConfigValueType.OBJECT)
      .handlesOwnValidationPath(EVENT_TIME_MODEL_CONFIG_NAME)
      .handlesOwnValidationPath(SYSTEM_TIME_MODEL_CONFIG_NAME)
      .build();
}
 

private int tryToGetIntValue(final String path) {
    try {
        return config.getInt(path);
    } catch (final ConfigException.WrongType e) {
        final ConfigValue configValue = config.getValue(path);
        if (ConfigValueType.STRING == configValue.valueType()) {
            return Integer.parseInt(String.valueOf(configValue.unwrapped()));
        }
        throw e;
    }
}
 

private long tryToGetLongValue(final String path) {
    try {
        return config.getLong(path);
    } catch (final ConfigException.WrongType e) {
        final ConfigValue configValue = config.getValue(path);
        if (ConfigValueType.STRING == configValue.valueType()) {
            return Long.parseLong(String.valueOf(configValue.unwrapped()));
        }
        throw e;
    }
}
 

@Test
public void getConfigForVcapServicesStringReturnsExpected() {
    final VcapServicesStringToConfig underTest = VcapServicesStringToConfig.getInstance();

    final Config actual = underTest.apply(vcapServicesString);

    assertThat(actual.hasPath(VcapServicesStringToConfig.VCAP_CONFIG_PATH)).isTrue();
    assertThat(actual.getValue(VcapServicesStringToConfig.VCAP_CONFIG_PATH)).satisfies(vcapConfig -> {
        assertThat(vcapConfig.valueType()).isEqualTo(ConfigValueType.OBJECT);
        assertThat((ConfigObject) vcapConfig).containsOnlyKeys("MongoDB-Service", "mongodb", "permissions-service",
                "permissions", "usage-server", "usage");
    });
}
 

private static ConfigValueType getValueTypeOrNull(Class<?> parameterClass) {
    if (parameterClass == Boolean.class || parameterClass == boolean.class) {
        return ConfigValueType.BOOLEAN;
    } else if (parameterClass == Integer.class || parameterClass == int.class) {
        return ConfigValueType.NUMBER;
    } else if (parameterClass == Double.class || parameterClass == double.class) {
        return ConfigValueType.NUMBER;
    } else if (parameterClass == Long.class || parameterClass == long.class) {
        return ConfigValueType.NUMBER;
    } else if (parameterClass == String.class) {
        return ConfigValueType.STRING;
    } else if (parameterClass == Duration.class) {
        return null;
    } else if (parameterClass == ConfigMemorySize.class) {
        return null;
    } else if (parameterClass == List.class) {
        return ConfigValueType.LIST;
    } else if (parameterClass == Map.class) {
        return ConfigValueType.OBJECT;
    } else if (parameterClass == Config.class) {
        return ConfigValueType.OBJECT;
    } else if (parameterClass == ConfigObject.class) {
        return ConfigValueType.OBJECT;
    } else if (parameterClass == ConfigList.class) {
        return ConfigValueType.LIST;
    } else {
        return null;
    }
}
 

public static Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(TABLE_NAME_PROPERTY, ConfigValueType.STRING)
      .mandatoryPath(ROWKEY_PROPERTY)
      .mandatoryPath(COLUMNS_PROPERTY, ConfigValueType.OBJECT)
      .optionalPath(ZK_QUORUM_PROPERTY, ConfigValueType.STRING)
      .optionalPath(HBASE_BATCH_SIZE, ConfigValueType.NUMBER)
      .optionalPath(SERDE_PROPERTY, ConfigValueType.STRING)
      .optionalPath(KEY_SEPARATOR, ConfigValueType.STRING)
      .handlesOwnValidationPath(COLUMNS_PROPERTY)
      .handlesOwnValidationPath(HBASE_PASSTHRU_PREFIX)
      .add(new HBaseColumnsValidation())
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(ZooKeeperConnection.CONNECTION_CONFIG, ConfigValueType.STRING)
      .mandatoryPath(SCHEMA_CONFIG, ConfigValueType.OBJECT)
      .mandatoryPath(KEY_FIELD_NAMES_CONFIG, ConfigValueType.LIST)
      .optionalPath(ZNODE_PREFIX_CONFIG, ConfigValueType.STRING)
      .optionalPath(SESSION_TIMEOUT_MS_CONFIG, ConfigValueType.NUMBER)
      .optionalPath(CONNECTION_TIMEOUT_MS_CONFIG, ConfigValueType.NUMBER)
      .handlesOwnValidationPath(SCHEMA_CONFIG)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(DUMMY_FLAT_FIELDS_CONFIG, ConfigValueType.LIST)
      .mandatoryPath(DUMMY_FLAT_TYPES_CONFIG, ConfigValueType.LIST)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(CONNECTION_CONFIG_NAME, ConfigValueType.STRING)
      .mandatoryPath(TABLE_CONFIG_NAME, ConfigValueType.STRING)
      .optionalPath(INSERT_IGNORE_CONFIG_NAME, ConfigValueType.BOOLEAN)
      .optionalPath(IGNORE_MISSING_COLUMNS_CONFIG_NAME, ConfigValueType.BOOLEAN)
      .optionalPath(IS_SECURE_CONFIG_NAME, ConfigValueType.BOOLEAN)
      .ifPathExists(KERBEROS_PREFIX, KerberosParameterValidations.getValidations())
      .addAll(SecurityUtils.getValidations())
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(CONNECTION_CONFIG_NAME, ConfigValueType.STRING)
      .mandatoryPath(TABLE_NAME_CONFIG_NAME, ConfigValueType.STRING)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(TRANSLATOR_PROPERTY, ConfigValueType.OBJECT)
      .optionalPath(REPARTITION_NUM_PARTITIONS_PROPERTY, ConfigValueType.NUMBER)
      .add(new InputTranslatorCompatibilityValidation())
      .handlesOwnValidationPath(TRANSLATOR_PROPERTY)
      .addAll(super.getValidations())
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .optionalPath(STEP_NAME_CONFIG, ConfigValueType.STRING)
      .mandatoryPath(KEY_FIELD_NAMES_CONFIG, ConfigValueType.LIST)
      .mandatoryPath(TIMESTAMP_FIELD_NAME_CONFIG, ConfigValueType.STRING)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(EXCLUSION_COMPARE_CONFIG, ConfigValueType.STRING)
      .mandatoryPath(EXCLUSION_FIELDS_CONFIG, ConfigValueType.LIST)
      .mandatoryPath(EXCLUSION_WITH_CONFIG, ConfigValueType.STRING)
      .build();
}
 

@Test
public void testInvalid() {
  ProvidesValidations validee = new ProvidesValidations() {
    @Override
    public Validations getValidations() {
      return Validations.builder().mandatoryPath("hello", ConfigValueType.STRING).build();
    }
  };

  assertValidationFailures(validee, ConfigFactory.empty());
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .optionalPath(STEP_NAME_CONFIG, ConfigValueType.STRING)
      .exactlyOnePathExists(ConfigValueType.LIST, INCLUDE_FIELDS, EXCLUDE_FIELDS)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(SCHEMA_CONFIG, ConfigValueType.OBJECT)
      .optionalPath(EXACT_MATCH_CONFIG, ConfigValueType.BOOLEAN)
      .handlesOwnValidationPath(SCHEMA_CONFIG)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .mandatoryPath(FIELDS_CONFIG, ConfigValueType.LIST)
      .mandatoryPath(VALUES_CONFIG, ConfigValueType.LIST)
      .mandatoryPath(FIELD_TYPE_CONFIG, ConfigValueType.STRING)
      .optionalPath(CASE_SENSITIVE_CONFIG, ConfigValueType.BOOLEAN)
      .build();
}
 

@Override
public Validations getValidations() {
  return Validations.builder()
      .optionalPath(EXPECTED_LITERAL_CONFIG, ConfigValueType.NUMBER)
      .optionalPath(EXPECTED_DEPENDENCY_CONFIG, ConfigValueType.STRING)
      .exactlyOnePathExists(EXPECTED_LITERAL_CONFIG, EXPECTED_DEPENDENCY_CONFIG)
      .build();
}