protected Config setupMessagesConfig() throws IOException {
    // copy reference across
    saveResource("messages.reference.conf", true);

    // parse fallback config
    final File reference = new File(getDataFolder(), "messages.reference.conf");
    final Config fallback = ConfigFactory.parseFile(reference);

    // parse user provided config
    final File regular = new File(getDataFolder(), "messages.conf");

    final Config user;
    if (regular.exists()) {
        user = ConfigFactory.parseFile(regular);
    } else {
        user = ConfigFactory.empty();
    }

    return user.withFallback(fallback).resolve(ConfigResolveOptions.noSystem());
}
 

public static Config load(Config overrides) {
  Config defaultOverrides = ConfigFactory.defaultOverrides();
  Config application = ConfigFactory.defaultApplication();
  Config reference = ConfigFactory.defaultReference();
  ConfigResolveOptions resolveOptions = ConfigResolveOptions.defaults();
  return overrides
      .withFallback(defaultOverrides)
      .withFallback(application)
      .withFallback(reference)
      .resolve(resolveOptions);
}
 

/**
 * Return the root configuration loaded from the helios configuration files.
 */
static Config loadConfig() {
  final ConfigResolveOptions resolveOptions = ConfigResolveOptions
      .defaults()
      .setAllowUnresolved(true);

  final ConfigParseOptions parseOptions = ConfigParseOptions.defaults();

  final Config baseConfig = ConfigFactory.load(BASE_CONFIG_FILE, parseOptions, resolveOptions);

  final Config appConfig = ConfigFactory.load(APP_CONFIG_FILE, parseOptions, resolveOptions);

  return appConfig.withFallback(baseConfig);
}
 

/**
 * @return All properties that are currently loaded from internal and
 * external files
 */
@Override
public Map<String, Object> asMap() {
    return configuration
            .resolve(ConfigResolveOptions.defaults().setUseSystemEnvironment(true).setAllowUnresolved(true))
            .root()
            .unwrapped();
}
 

@Override
public Config resolve(ConfigResolveOptions options) {
  return c.resolve(options);
}
 

@Override
public Config resolve(final ConfigResolveOptions options) {
    return serviceScopedConfig.resolve(options);
}
 

@Override
public Config resolveWith(final Config source, final ConfigResolveOptions options) {
    return serviceScopedConfig.resolveWith(source, options);
}
 

@Override
public Config resolve(final ConfigResolveOptions options) {
    return config.resolve(options);
}
 

@Override
public Config resolveWith(final Config source, final ConfigResolveOptions options) {
    return config.resolveWith(source, options);
}
 

@Override
public Config resolve(final ConfigResolveOptions options) {
    return baseConfig.resolve(options);
}
 

@Override
public Config resolveWith(final Config source, final ConfigResolveOptions options) {
    return baseConfig.resolveWith(source, options);
}
 

@Override
public Config resolve(ConfigResolveOptions options) {
  return config.resolve(options);
}
 

@Override
public Config resolveWith(Config arg0, ConfigResolveOptions arg1) {
  return config.resolveWith(arg0, arg1);
}
 

private static Config loadDefaultConfig(ClassLoader classLoader) {
    return ConfigFactory
            .load(classLoader, ConfigParseOptions.defaults(), ConfigResolveOptions.defaults()
            .setAllowUnresolved(true));
}
 

public HOCONInputStreamFlowTemplate(InputStream inputStream, URI flowTemplateDirUri, FlowCatalogWithTemplates catalog)
    throws SpecNotFoundException, IOException, JobTemplate.TemplateException, URISyntaxException {
  this(ConfigFactory.parseReader(new InputStreamReader(inputStream, Charsets.UTF_8)).resolve(
      ConfigResolveOptions.defaults().setAllowUnresolved(true)), flowTemplateDirUri, catalog);
}