Get config value from specific config.

@param key Config key
@return Specific Config value
760189
protected Object extractSpecificConfig(String key)
    {
        if (this.specificConfig == null)
        {
            return null;
        }

        Object result = this.specificConfig.get(key);
        return result;
    }
896219
public Object getMethodConfigValue(String methodName, String configKey) {
        if (configValueCache == null) {
            return null;
        }
        String key = buildmkey(methodName, configKey);
        return configValueCache.get(key);
    }
1271847
public static function get($key = null)
    {
        if ($key) {
            $config = static::findBy(['key' => $key]);
            return $config ? $config->getValue() : '';
        } else {
            $config = [];
            foreach (static::all() as $c) {
                $config[$c->key] = $c->getValue();
            }
            return $config;
        }
    }
91516
final public static function getConfig($key = null)
    {
        $calledClass = get_called_class();

        // Load config
        if (!isset(self::$loadedConfigSet[$calledClass]) || null === self::$loadedConfigSet[$calledClass]) {
            self::$loadedConfigSet[$calledClass] = array_merge(self::$configDefault, static::loadConfig());
        }

        // Get config property
        return (null === $key)
            ? self::$loadedConfigSet[$calledClass]
            : self::$loadedConfigSet[$calledClass][$key];
    }
253481
public static function key($key)
    {
        $config = static::where('key', $key)->first();

        return $config->value ?? config($key, null);
    }
444051
protected String getConfigValue(String key, Object[] args) {

        String value = getConfigValue(key);
        CmsMacroResolver resolver = CmsMacroResolver.newInstance();
        for (int i = 0; i < args.length; i++) {
            resolver.addMacro(String.valueOf(i), args[i].toString());
        }
        return resolver.resolveMacros(value);
    }
148753
private Optional<String> get(String key, Set<String> processingKeys) {

        for (ConfigurationSource configurationSource : config.getConfigurationSources()) {

            Optional<String> value = configurationSource.get(key);

            if (value.isPresent()) {

                return Optional.of(interpolateString(
                        key, ConfigurationDecoderUtils.decodeConfigValueIfEncoded(key, value.get()), processingKeys));
            }
        }

        return Optional.empty();
    }
1109456
public <T> T get(RythmConfigurationKey key) {
        Object o = data.get(key);
        if (null == o) {
            o = key.getConfiguration(raw);
            if (null != o) {
                data.put(key, o);
            } else {
                data.put(key, RawData.NULL);
            }
        }
        if (o == RawData.NULL) {
            return null;
        } else {
            return (T) o;
        }
    }
713153
@Override
	public String getProperty(final String key) {
		lock.readLock().lock();
		try {
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			final Object object = get(key, useLocalPrefixes);
			if (object instanceof String) {
				return (String) object;
			} else {
				if (object == null) {
					return null;
				}
				throw new IllegalStateException("The value of " + key + " is of type: " + object.getClass().getName());
			}
		} finally {
			lock.readLock().unlock();
		}
	}
862874
final protected function getConfigValue(string $key)
    {
        $retval = false;

        if (isset($this->config[$key], $this->config[$key][ConfigurationInterface::KEY_VALUE])) {
            $retval = $this->config[$key][ConfigurationInterface::KEY_VALUE];
        } elseif (isset($this->config[$key])) {
            $retval = $this->config[$key];
        }

        return $retval;
    }
1272910
public String getValue(String key) {
        KeyValue kv = getKV(key);
        return kv == null ? null : kv.getValue();
    }
996031
public static String getValueWithGlobalDefault(String section, ConfigConstant key) {
    String value = getValue(section, key);
    return (Strings.isNullOrEmpty(value) ? getGlobalValue(key) : value);
  }
50469
@Override
    public <T> T getValue(String key) {
        ValueObject vo = get(key);
        if (null == vo) {
            return null;
        }
        return vo.value();
    }
1320224
public boolean getRequiredBoolean(String key) {
        Boolean value = configuration.getBoolean(key, null);
        if (value != null) {
            return value;
        } else {
            throw new IllegalStateException(String.format("required key [%s] not found", key));
        }
    }
152881
public String getValue(String key) {
		for (Iterator iter = components.values().iterator(); iter.hasNext();) {
			LdapRdnComponent component = (LdapRdnComponent) iter.next();
			if (ObjectUtils.nullSafeEquals(component.getKey(), key)) {
				return component.getValue();
			}
		}

		throw new IllegalArgumentException("No RdnComponent with the key " + key);
	}
1121696
public static int getConfigInt(String key, int defaultValue) {
		return NumberUtils.toInt(getConfigParam(key, Integer.toString(defaultValue)));
	}
1020882
protected String getConfig(IConfigKey key) {
        if (configs == null) {
            loadConfigs();
        }
        String value = configs.getProperty(key.getKeyString());
        if (value == null && key instanceof IConfigKeyHaveDefault) {
            return ((IConfigKeyHaveDefault) key).getDefaultValueStr();
        }
        return value;
    }