get the full configuration object that contains all the configuration
layers: customer, deployment and factory.

@return the configuration object
513536
public static Configuration getConfiguration() {
	    if(configuration == null){
            try {
                configuration = (Configuration) getContext().getBean("configuration");
            } catch (BeansException e) {
                LOGGER.error("Can't load config. Error: {}",e ,e);
            }
        }
	    return configuration;
	}
385104
public static ServerConfiguration loadConfiguration() {
        final ServerConfiguration configuration = createConfiguration();
        Assert.requireNonNull(configuration, "configuration");

        final ServiceLoader<ConfigurationProvider> serviceLoader = ServiceLoader.load(ConfigurationProvider.class);
        for(final ConfigurationProvider provider : serviceLoader) {
            final Map<String, String> additionalStringProperties = provider.getStringProperties();
            for(final Map.Entry<String, String> property : additionalStringProperties.entrySet()) {
                if(!configuration.containsProperty(property.getKey())) {
                    configuration.setProperty(property.getKey(), property.getValue());
                }
            }
            final Map<String, List<String>> additionalListProperties = provider.getListProperties();
            for(final Map.Entry<String, List<String>> property : additionalListProperties.entrySet()) {
                if(!configuration.containsProperty(property.getKey())) {
                    configuration.setListProperty(property.getKey(), property.getValue());
                }
            }
            final Map<String, Boolean> additionalBooleanProperties = provider.getBooleanProperties();
            for(final Map.Entry<String, Boolean> property : additionalBooleanProperties.entrySet()) {
                if(!configuration.containsProperty(property.getKey())) {
                    configuration.setBooleanProperty(property.getKey(), property.getValue());
                }
            }
            final Map<String, Integer> additionalIntegerProperties = provider.getIntegerProperties();
            for(final Map.Entry<String, Integer> property : additionalIntegerProperties.entrySet()) {
                if(!configuration.containsProperty(property.getKey())) {
                    configuration.setIntProperty(property.getKey(), property.getValue());
                }
            }
            final Map<String, Long> additionalLongProperties = provider.getLongProperties();
            for(final Map.Entry<String, Long> property : additionalLongProperties.entrySet()) {
                if(!configuration.containsProperty(property.getKey())) {
                    configuration.setLongProperty(property.getKey(), property.getValue());
                }
            }
        }
        LOG.debug("Configuration created with {} properties", configuration.getPropertyKeys().size());
        if(LOG.isTraceEnabled()) {
            for(final String key : configuration.getPropertyKeys()) {
                LOG.debug("Dolphin Platform configured with '{}'='{}'", key, configuration.getProperty(key, null));
            }
        }

        return configuration;
    }
799958
@Override
  public Configuration getServiceConfiguration() {

    final Configuration partialServiceConf = ServiceConfiguration.CONF
        .set(ServiceConfiguration.SERVICES, taskOutputStreamProvider.getClass())
        .set(ServiceConfiguration.ON_CONTEXT_STOP, ContextStopHandler.class)
        .set(ServiceConfiguration.ON_TASK_STARTED, TaskStartHandler.class)
        .build();

    return Tang.Factory.getTang()
        .newConfigurationBuilder(partialServiceConf)
        .bindImplementation(OutputStreamProvider.class, taskOutputStreamProvider.getClass())
        .bindImplementation(TaskOutputStreamProvider.class, taskOutputStreamProvider.getClass())
        .bindNamedParameter(OutputPath.class, outputPath)
        .build();
  }
338757
private Client getClient() {
        Client client = hostMap.get(basePath);
        if (client!=null) return client;

        final ClientConfig clientConfig = new ClientConfig();
        clientConfig.register(MultiPartFeature.class);
        if (debug) {
            clientConfig.register(LoggingFilter.class);
        }
        client = ClientBuilder.newClient(clientConfig);

        hostMap.putIfAbsent(basePath, client);
        return hostMap.get(basePath); //be sure to use the same in case of a race condition.
    }
284343
Configuration getConfiguration() {
    try {
      if (config == null || recheck) {
        if(xContext != null) {
          linguServices = new LinguisticServices(xContext);
        }
        if(docLanguage == null) {
          docLanguage = getLanguage();
        }
        initLanguageTool();
      }
    } catch (Throwable t) {
      MessageHandler.showError(t);
    }
    return config;
  }
765680
private Configuration getConfFromContext() {
    Configuration conf = (Configuration)getServletContext().getAttribute(
        HttpServer.CONF_CONTEXT_ATTRIBUTE);
    assert conf != null;
    return conf;
  }
688884
private void getConfigurationObject()
    {
        RDBMSPropertyReader reader = new RDBMSPropertyReader(externalProperties, kunderaMetadata
                .getApplicationMetadata().getPersistenceUnitMetadata(getPersistenceUnit()));
        this.conf = reader.load(getPersistenceUnit());
    }
448783
public function getConfiguration()
    {
        if (!$this->_configuration) {

            //If model is using
            if ($this->modelClass) {

                $this->_configuration = $this->_keyStorage->get($this->getKey()) ?: [];
                $modelClass = $this->modelClass;
                if (!$this->_configuration || !($this->_configuration instanceof $modelClass)) {
                    //Initialize new model. Default values must be set in model (init method)
                    $this->_configuration = Yii::createObject($modelClass, $this->modelConfig);
                }

                //Default values from 'attributes'
                if (is_array($this->attributes)) {
                    foreach ($this->attributes as $key => $default) {
                        if ($this->_configuration->{$key} === null) {
                            $this->_configuration->{$key} = $default;
                        }
                    }
                }

            } else {

                //Array configuration
                $dbConfig = $this->_keyStorage->get($this->getKey()) ?: [];

                if (is_array($this->attributes)) {
                    //Needs to filter
                    $config = [];
                    foreach ($this->attributes as $key => $default) {
                        $config[$key] = (isset($dbConfig[$key]) && $dbConfig[$key] !== null) ? $dbConfig[$key] : $default;
                    }
                    $this->_configuration = $config;
                } else {
                    $this->_configuration = $dbConfig;
                }

            }
        }
        return $this->_configuration;
    }
1065032
public static function getConfigurationObjectServices()
    {
        return ServiceFactory::getInstance()
            ->attach(ServiceInterface::SERVICE_CACHE)
            ->with(ServiceInterface::SERVICE_CACHE)
            ->setOption(CacheService::OPTION_CACHE_NAME, InternalCacheService::CONFIGURATION_OBJECT_CACHE_IDENTIFIER)
            ->setOption(CacheService::OPTION_CACHE_BACKEND, InternalCacheService::get()->getBackendCache())
            ->attach(ServiceInterface::SERVICE_PARENTS)
            ->attach(ServiceInterface::SERVICE_DATA_PRE_PROCESSOR)
            ->attach(ServiceInterface::SERVICE_MIXED_TYPES);
    }
974619
public function getConfig()
    {
        if(!$this->_config instanceof ObjectConfig) {
            $this->_config = new ObjectConfig($this->__config);
        }

        return $this->_config;
    }
601403
public static DocumentFactory getInstance() {
      if (CONFIGURED_INSTANCE == null) {
         synchronized (DocumentFactory.class) {
            if (CONFIGURED_INSTANCE == null) {
               CONFIGURED_INSTANCE = new DocumentFactory();
            }
         }
      }
      return CONFIGURED_INSTANCE;
   }
120992
private Configuration retrieveConfig(NestedConfigHelper configHelper, ConfigurationAdmin configAdmin) throws InitWithoutConfig {
        if (configHelper == null)
            throw new InitWithoutConfig("Configuration not found");
        // We need configAdmin to list the configurations of nested classloader elements with this application as their parent
        if (configAdmin == null)
            throw new InitWithoutConfig("ConfigurationAdmin service not found");

        String parentPid = (String) configHelper.get(Constants.SERVICE_PID);
        String sourcePid = (String) configHelper.get("ibm.extends.source.pid");
        if (sourcePid != null) {
            parentPid = sourcePid;
        }
        try {
            StringBuilder filter = new StringBuilder();
            filter.append("(&");
            filter.append(FilterUtils.createPropertyFilter("service.factoryPid", "com.ibm.ws.classloading.classloader"));
            filter.append(FilterUtils.createPropertyFilter("config.parentPID", parentPid));
            filter.append(")");
            Configuration[] configs = configAdmin.listConfigurations(filter.toString());
            if (configs == null || configs.length != 1) {
                throw new InitWithoutConfig("No classloader element found");
            }
            Configuration config = configs[0];
            if (config.getProperties() == null) {
                if (tc.isErrorEnabled())
                    Tr.error(tc, "cls.classloader.missing", config.getPid());
                config.delete();
                throw new InitWithoutConfig("Classloader config not found");
            }
            return config;
        } catch (IOException e) {
            throw new InitWithoutConfig("Configuration for classloader not found, exception " + e);
        } catch (InvalidSyntaxException e) {
            throw new InitWithoutConfig("Configuration for classloader not found, exception " + e);
        }
    }
580850
public List<FacesConfigFactoryType<WebFacesConfigDescriptor>> getAllFactory()
   {
      List<FacesConfigFactoryType<WebFacesConfigDescriptor>> list = new ArrayList<FacesConfigFactoryType<WebFacesConfigDescriptor>>();
      List<Node> nodeList = model.get("factory");
      for(Node node: nodeList)
      {
         FacesConfigFactoryType<WebFacesConfigDescriptor>  type = new FacesConfigFactoryTypeImpl<WebFacesConfigDescriptor>(this, "factory", model, node);
         list.add(type);
      }
      return list;
   }
385103
@Override
    public ContainerConfiguration createDeployableConfiguration() throws Exception {
        ContainerConfiguration config = SecurityActions.newInstance(
            deployableContainer.getConfigurationClass(), new Class<?>[0], new Object[0]);
        MapObject.populate(config, containerConfiguration.getContainerProperties());
        config.validate();
        return config;
    }
896522
public Properties getConfig() {
    try {
      Properties properties = new Properties();
      if (null != resources.getGlobal()) populateConfigItems(properties, resources.getGlobal());

      if (null != resources.getLocals()) {
        for (URL url : resources.getLocals()) {
          populateConfigItems(properties, url);
        }
      }

      if (null != resources.getUser()) populateConfigItems(properties, resources.getUser());
      return properties;
    } catch (Exception e) {
      logger.error("Exception", e);
      throw new RuntimeException(e);
    }
  }
1230006
public static FacetsConfig getFacetsConfig()
    {
        final FacetsConfig ret = new FacetsConfig();
        ret.setHierarchical(Indexer.Dimension.DIMCREATED.name(), true);
        return ret;
    }
629924
@Override
  public Configuration getMainConfiguration() {

    return Tang.Factory.getTang().newConfigurationBuilder()
            .bindImplementation(RuntimeClasspathProvider.class, YarnClasspathProvider.class)
            .bindConstructor(org.apache.hadoop.yarn.conf.YarnConfiguration.class, YarnConfigurationConstructor.class)
            .build();
  }