Get Configuration By Name

@param  $config_name
@return array
18273
public function getConfigByName($config_name)
    {
        if ($this->isSingle()) {
            if (isset($this->containers['config'])) {
                return $this->containers['config']->get($config_name);
            }
        }
        return [];
    }
337057
public function getItemConfig($name = null, array $config = [])
    {
        return array_merge([
            'domain' => $name,
            'nginx'  => $this,
            'class'  => $this->defaultClass,
        ], $config);
    }
1056781
public function getConfig($configKey)
    {
        if (array_key_exists($configKey, $this->config)) {
            return $this->config[$configKey];
        }
        return false;
    }
1227888
public function getConstList($include_default = false) {
        static $constCache = array();
        $class             = get_class($this);
        if (!isset($constCache[$class])) {
            $reflector          = new ReflectionObject($this);
            $constCache[$class] = $reflector->getConstants();
        }
        if (!$include_default) {
            $constants = $constCache[$class];
            unset($constants['__DEFAULT']);
            return $constants;
        }
        return $constCache[$class];
    }
1144559
public static function get($name = '')
    {
        if (!empty($name)) {
            if (false !== strpos($name, '.')) {

                $data = explode('.', $name, 2);
                $data[0] = strtolower($data[0]);

                if (isset($data[1]) && $data[1]) {
                    return isset(self::$config[$data[0]][$data[1]]) ? self::$config[$data[0]][$data[1]] : null;
                }
                return isset(self::$config[$data[0]]) ? self::$config[$data[0]] : null;
            } else {
                return isset(self::$config[$name]) ? self::$config[$name] : null;
            }
        }
        return self::$config;
    }
675275
protected static function _getConfig() {
        if (null === self::$_classConfigCacheEnabled) {
            self::$_classConfigCacheEnabled = CM_Config::get()->classConfigCacheEnabled;
        }

        $calledClass = get_called_class();
        $cacheKey = CM_CacheConst::ClassConfig . '_className:' . $calledClass;
        $cache = new CM_Cache_Storage_Apc();
        if (!self::$_classConfigCacheEnabled || !isset(self::$_classConfigList[$calledClass])) {
            if (!self::$_classConfigCacheEnabled || false === ($result = $cache->get($cacheKey))) {
                $result = self::_getConfigRaw();
                if (self::$_classConfigCacheEnabled) {
                    $cache->set($cacheKey, $result);
                }
            }
            self::$_classConfigList[$calledClass] = $result;
        }

        return self::$_classConfigList[$calledClass];
    }
1038389
def get_config_section(self, name):
        
        if self.config.has_section(name):
            return self.config.items(name)
        return []
1145847
public function configObject($name)
    {
        // make sure we always get the config object
        if (!$this->configExists($name)) {
            $this->reloadConfig($name);
        }

        // Load corresponding class and get config array
        return $this->config[$name];
    }
556455
public function getEntitiesConfig($entity_names=null, $merge_standard=true)
    {
        $configured_entities = $this->setup->getSynchronizerConfig('entities');
        $configured_entities = array_merge_recursive($entity_names);

        if ($entity_names === null) {
        } else {
        }
    }
1148622
public static function getConfig($name = 'application', $context = null)
    {
        if($context == null)
            $context = getenv('ERDIKO_CONTEXT');

        $filename = ERDIKO_APP."/config/{$context}/{$name}.json";
        return static::getConfigFile($filename);
    }
458593
def get_build_configuration_by_name(name):
    
    response = utils.checked_api_call(pnc_api.build_configs, 'get_all', q='name==' + name).content
    if not response:
        return None
    return response[0]
553432
protected function getYamlConfig($config_name)
    {
        if ($this->configStorage->exists($config_name)) {
            $configuration = $this->configStorage->read($config_name);
            $configurationEncoded = Yaml::encode($configuration);
        }

        return $configurationEncoded;
    }
611457
public function getExtensionConfig($name)
    {
        if (!isset($this->extensionConfigs[$name])) {
            $this->extensionConfigs[$name] = [];
        }

        return $this->extensionConfigs[$name];
    }
147384
public function getConfig(string $name = 'default') : array
    {
        if (isset($this->config['host']) && ! is_array($this->config['host'])) {
            $this->logger->warning(
                'laravel-bitcoind: You are using legacy config format which '.
                'was deprecated and will be removed in the next version. '.
                'Please update your config file by running [php artisan '.
                'vendor:publish '.
                '--provider="Denpa\Bitcoin\Providers\ServiceProvider" --force].'
            );

            return $this->withDefaults($this->config);
        }

        if (! array_key_exists($name, $this->config)) {
            throw new InvalidArgumentException(
                "Could not find client configuration [$name]"
            );
        }

        return $this->withDefaults($this->config[$name]);
    }
262134
public function get($name = null) {
		if ($name === null) {
			$result = [];
			$this->_configurations = array_filter($this->_configurations);

			foreach ($this->_configurations as $key => $value) {
				$result[$key] = $this->get($key);
			}
			return $result;
		}

		$settings = &$this->_configurations;

		if (!isset($settings[$name])) {
			return null;
		}

		if (isset($settings[$name][0])) {
			return $settings[$name][0];
		}
		$env = Environment::get();

		$config = isset($settings[$name][$env]) ? $settings[$name][$env] : $settings[$name];

		$method = is_callable($this->initConfig) ? $this->initConfig : null;
		$settings[$name][0] = $method ? $method($name, $config) : $config;
		return $settings[$name][0];
	}
86215
public static function getConfig(array $options, string $name, $default = null)
    {
        $options = self::normalize($options);
        if (array_key_exists($name, $options)) {
            return $options[$name];
        }

        return $default;
    }
70526
public static function getConfigFiles(array $names, $configDir = null)
    {
        $dirs = ($configDir === null) ? self::getConfigDirs() : [$configDir];

        return self::getRealFiles($dirs, $names);
    }