Returns all of the {@link ConfigurationOption} in the specified {@link Addon}.
545151
public static Iterable<ConfigurationOption> getWindupConfigurationOptions(Addon addon)
    {
        IdentityHashMap<ClassLoader, Addon> classLoaderToAddon = new IdentityHashMap<>();
        for (Addon loadedAddon : FurnaceHolder.getAddonRegistry().getAddons())
        {
            classLoaderToAddon.put(loadedAddon.getClassLoader(), loadedAddon);
        }

        List<ConfigurationOption> results = new ArrayList<>();
        Imported<ConfigurationOption> options = FurnaceHolder.getAddonRegistry()
                    .getServices(ConfigurationOption.class);
        for (ConfigurationOption option : options)
        {
            ClassLoader optionClassLoader = option.getClass().getClassLoader();
            Addon optionAddon = classLoaderToAddon.get(optionClassLoader);
            if (optionAddon.equals(addon))
            {
                results.add(option);
            }
        }
        return results;
    }
365186
public static Config getOverriddenConfig(@Nonnull final Config config, @Nullable final AbstractConfiguration ... overrideConfigurations)
    {
        if (overrideConfigurations == null || overrideConfigurations.length == 0) {
            return config;
        }

        final CombinedConfiguration cc = new CombinedConfiguration(new OverrideCombiner());

        int index  = 0;
        final AbstractConfiguration first = config.config.getNumberOfConfigurations() > 0 ?
            AbstractConfiguration.class.cast(config.config.getConfiguration(index)) // cast always succeeds, internally this returns cd.getConfiguration() which is AbstractConfiguration
            : null;


        // If the passed in configuration has a system config, add this as the very first one so
        // that system properties override still works.
        if(first != null && first.getClass() == SystemConfiguration.class) {
            cc.addConfiguration(first);
            index++;
        }
        else {
            // Otherwise, if any of the passed in configuration objects is a SystemConfiguration,
            // put that at the very beginning.
            for (AbstractConfiguration c : overrideConfigurations) {
                if (c.getClass() == SystemConfiguration.class) {
                    cc.addConfiguration(c);
                }
            }
        }

        for (AbstractConfiguration c : overrideConfigurations) {
            if (c.getClass() != SystemConfiguration.class) {
                cc.addConfiguration(c); // Skip system configuration objects, they have been added earlier.
            }
        }

        // Finally, add the existing configuration elements at lowest priority.
        while (index < config.config.getNumberOfConfigurations()) {
            final AbstractConfiguration c = AbstractConfiguration.class.cast(config.config.getConfiguration(index++));
            if (c.getClass() != SystemConfiguration.class) {
                cc.addConfiguration(c);
            }
        }

        return new Config(cc);
    }
464735
public static <T extends Enum<T>> ConfigurationOptionBuilder<T> enumOption(Class<T> clazz) {
		final ConfigurationOptionBuilder<T> optionBuilder = new ConfigurationOptionBuilder<T>(new EnumValueConverter<T>(clazz), clazz);
		for (T enumConstant : clazz.getEnumConstants()) {
			optionBuilder.addValidOption(enumConstant);
		}
		optionBuilder.sealValidOptions();
		return optionBuilder;
	}
1018110
public static <C extends Configurable> C getConfiguration(Class<C> klass) {
        String defaultPropertyFile = "datumbox." + klass.getSimpleName().toLowerCase(Locale.ENGLISH) + DEFAULT_POSTFIX + ".properties";

        Properties properties = new Properties();
        
        ClassLoader cl = klass.getClassLoader();
        
        //Load default properties from jar
        try (InputStream in = cl.getResourceAsStream(defaultPropertyFile)) {
            properties.load(in);
        }
        catch(IOException ex) {
            throw new UncheckedIOException(ex);
        }
        
        //Look for user defined properties
        String propertyFile = defaultPropertyFile.replaceFirst(DEFAULT_POSTFIX, "");
        if(cl.getResource(propertyFile)!=null) {
            //Override the default if they exist
            try (InputStream in = cl.getResourceAsStream(propertyFile)) {
                properties.load(in);
            }
            catch(IOException ex) {
                throw new UncheckedIOException(ex);
            }
            logger.trace("Loading properties file {}: {}", propertyFile, properties);
        }
        else {
            logger.warn("Using default properties file {}: {}", defaultPropertyFile, properties);
        }

        return getConfiguration(klass, properties);
    }
777227
public java.util.List<ConfigurationItem> getConfigurationItems() {
        if (configurationItems == null) {
            configurationItems = new com.amazonaws.internal.SdkInternalList<ConfigurationItem>();
        }
        return configurationItems;
    }
582031
public static ConfigurationOptionBuilder<Collection<Pattern>> regexListOption() {
		return new ConfigurationOptionBuilder<Collection<Pattern>>(new SetValueConverter<Pattern>(RegexValueConverter.INSTANCE), Collection.class)
				.defaultValue(Collections.<Pattern>emptySet());
	}
1257804
@SuppressWarnings("unchecked")
    public Dictionary<String, String> getConfigurationProperties(Dictionary<String, String> dictionary, boolean returnCopy)
    {
        if (returnCopy)
            dictionary = putAll(dictionary, null);
        if (dictionary == null)
            dictionary = new Hashtable<String, String>();
        try {
            String servicePid = this.getServicePid();
            if (servicePid != null)
            {
                ServiceReference caRef = context.getServiceReference(ConfigurationAdmin.class.getName());
                if (caRef != null)
                {
                    ConfigurationAdmin configAdmin = (ConfigurationAdmin)context.getService(caRef);
                    Configuration config = configAdmin.getConfiguration(servicePid);

                    Dictionary<String, String> configProperties = config.getProperties();
                    dictionary = putAll(configProperties, dictionary);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return dictionary;
    }
402734
@RequestMapping(value = "configurations", method = RequestMethod.GET)
    public Resources<CombinedIssueServiceConfiguration> getConfigurationList() {
        return Resources.of(
                configurationService.getConfigurationList(),
                uri(on(getClass()).getConfigurationList())
        )
                .with(Link.CREATE, uri(on(getClass()).getConfigurationForm()))
                ;
    }
164491
public Map<String, Object> getAllConfig() {
        Map<String, Object> map = config.getAll();
        map.put("version", version);
        map.put("buildDate", buildDate);
        return map;
    }
987783
public static ProgressBarConfig getConfiguration(ConfigurationFactory configFactory) {
		assert configFactory != null;
		return configFactory.config(ProgressBarConfig.class, PREFIX);
	}
1096311
public static FeaturableConfig imports(Configurer configurer)
    {
        Check.notNull(configurer);

        return imports(configurer.getRoot());
    }
1001750
def with_options(self, component):
        """"""
        options = component.get_required_config()
        component_name = _get_component_name(component)
        return BoundConfig(self._get_base_config(), component_name, options)
537967
function getConfig(api /*: any */) /*: BabelCoreOptions */ {
  api.cache.never();

  return {
    babelrc: false,
    presets: presets.map(preset => require.resolve(preset)),
    plugins: plugins.map(plugin => require.resolve(plugin)),
  };
}
123587
public synchronized String installAddOns(List<String> addons) {
        StringBuilder errorMessages = new StringBuilder();
        AddOnCollection aoc = getLatestVersionInfo();
        if (aoc == null) {
            String error = Constant.messages.getString("cfu.cmdline.nocfu");
            errorMessages.append(error);
            CommandLine.error(error);
        } else {
            for (String aoName : addons) {
                AddOn ao = aoc.getAddOn(aoName);
                if (ao == null) {
                    String error = Constant.messages.getString("cfu.cmdline.noaddon", aoName);
                    errorMessages.append(error);
                    errorMessages.append("\n");
                    CommandLine.error(error);
                    continue;
                }
                AddOnDependencyChecker addOnDependencyChecker = new AddOnDependencyChecker(getLocalVersionInfo(), aoc);
                AddOnDependencyChecker.AddOnChangesResult result;
                // Check to see if its already installed
                AddOn iao = getLocalVersionInfo().getAddOn(aoName);
                if (iao != null) {
                    if (!ao.isUpdateTo(iao)) {
                        CommandLine.info(Constant.messages.getString("cfu.cmdline.addoninst", iao.getFile().getAbsolutePath()));
                        continue;
                    }

                    result = addOnDependencyChecker.calculateUpdateChanges(ao);
                } else {
                    result = addOnDependencyChecker.calculateInstallChanges(ao);
                }
                
                if (!result.getUninstalls().isEmpty()) {
                    String error = Constant.messages
                            .getString("cfu.cmdline.addoninst.uninstalls.required", result.getUninstalls());
                    errorMessages.append(error);
                    errorMessages.append("\n");
                    CommandLine.error(error);
                    continue;
                }

                Set<AddOn> allAddOns = new HashSet<>();
                allAddOns.addAll(result.getInstalls());
                allAddOns.addAll(result.getNewVersions());
                for (AddOn addOn : allAddOns) {
                    CommandLine.info(Constant.messages.getString("cfu.cmdline.addonurl", addOn.getUrl()));
                }

                processAddOnChanges(null, result);
            }
            if (!waitAndInstallDownloads()) {
                errorMessages.append(Constant.messages.getString("cfu.cmdline.addoninst.error")).append("\n");
            }
        }
        return errorMessages.toString();
    }
1171540
public void getConfigurationInto(Entries configuration) {
    for (String prefix : prefixes) {
      configuration.setBoolean(prefix + ENABLE_SERVICE_ACCOUNTS_SUFFIX, isServiceAccountEnabled());
      if (getServiceAccountEmail() != null) {
        configuration.set(prefix + SERVICE_ACCOUNT_EMAIL_SUFFIX, getServiceAccountEmail());
      }
      if (getServiceAccountPrivateKeyId() != null) {
        configuration.set(
            prefix + SERVICE_ACCOUNT_PRIVATE_KEY_ID_SUFFIX, getServiceAccountPrivateKeyId());
      }
      if (getServiceAccountPrivateKey() != null) {
        configuration.set(
            prefix + SERVICE_ACCOUNT_PRIVATE_KEY_SUFFIX, getServiceAccountPrivateKey());
      }
      if (getServiceAccountKeyFile() != null) {
        configuration.set(prefix + SERVICE_ACCOUNT_KEYFILE_SUFFIX, getServiceAccountKeyFile());
      }
      if (getServiceAccountJsonKeyFile() != null) {
        configuration.set(prefix + JSON_KEYFILE_SUFFIX, getServiceAccountJsonKeyFile());
      }
      if (getClientId() != null) {
        configuration.set(prefix + CLIENT_ID_SUFFIX, getClientId());
      }
      if (getClientSecret() != null) {
        configuration.set(prefix + CLIENT_SECRET_SUFFIX, getClientSecret());
      }
      if (getOAuthCredentialFile() != null) {
        configuration.set(prefix + OAUTH_CLIENT_FILE_SUFFIX, getOAuthCredentialFile());
      }
      configuration.setBoolean(prefix + ENABLE_NULL_CREDENTIAL_SUFFIX, isNullCredentialEnabled());
    }

    // Transport configuration does not use prefixes
    if (getProxyAddress() != null) {
      configuration.set(PROXY_ADDRESS_KEY, getProxyAddress());
    }
    if (getProxyUsername() != null) {
      configuration.set(PROXY_USERNAME_KEY, getProxyUsername());
    }
    if (getProxyPassword() != null) {
      configuration.set(PROXY_PASSWORD_KEY, getProxyPassword());
    }
    configuration.set(HTTP_TRANSPORT_KEY, getTransportType().name());
  }
1191158
@SuppressWarnings("static-method")
	@Provides
	@Singleton
	public SarlConfig getSarlcConfig(ConfigurationFactory configFactory, Injector injector) {
		final SarlConfig config = SarlConfig.getConfiguration(configFactory);
		injector.injectMembers(config);
		return config;
	}
1127725
@Produces
	@Configuration
	public org.apache.commons.configuration.Configuration getConfiguration(InjectionPoint injectionPoint) {
		// get configuration annotation
		ConfigurationWrapper annotation = this.getConfigurationWrapper(injectionPoint);
		// use shared implementation to get configuration
		return this.getConfiguration(annotation);
	}