Get self config string.

@param key config key with configAbsoluteClassPath in config file
@return config value string. Return null if not add config file or not config in config file.
@see #addSelfConfigs(String, OneProperties)
198321
public static String getHavePathSelfConfig(IConfigKeyWithPath key) {
        String configAbsoluteClassPath = key.getConfigPath();
        return getSelfConfig(configAbsoluteClassPath, key);
    }
320186
public static LocalCall<String> get(String key) {
        return new LocalCall<>(
            "config.get",
            Optional.of(Arrays.asList(key)),
            Optional.empty(),
            new TypeToken<String>() { });
    }
1219761
public SELF withConfigOption(String key, String value) {
        if (key == null) {
            throw new java.lang.NullPointerException("key marked @NonNull but is null");
        }
        if (value == null) {
            throw new java.lang.NullPointerException("value marked @NonNull but is null");
        }
        options.put(key, value);
        return self();
    }
1325064
public String getConfigAttribute(Map<String, Object> props, String key) {
        return getConfigAttributeWithDefaultValue(props, key, null);
    }
570257
public static String getStringProperty(Configuration config, String key) throws DeployerConfigurationException {
        return getStringProperty(config, key, null);
    }
19803
public String getString(final String key) {
    if (containsKey(key)) {
      return get(key);
    } else {
      throw new UndefinedPropertyException("Missing required property '" + key
          + "'");
    }
  }
1144877
@Override
	public String getProperty(String key) {
		for (PropertyLoader loader : loaders) {
			String value = loader.getProperty(key);
			if(value != null)
				return value;
		}
		return null;
	}
1130916
private static Optional<String[]> getTrimmedStrings(final YarnConfiguration configuration, final String key) {
    final String[] result = configuration.getTrimmedStrings(key);
    if (null == result || result.length == 0) {
      return Optional.empty();
    } else {
      return Optional.of(result);
    }
  }
505438
public String getString(String key) {
		if (key == null || key.isEmpty()) {
			return null;
		}
		String property = null;
		for (ConfigurationSource configurationSource : configurationSources) {
			property = configurationSource.getValue(key);
			if (property != null) {
				break;
			}
		}
		return property;
	}
627479
@Override
    public List<Object> getProperty(String key) {
        List<?> nodes = fetchNodeList(key);

        if (nodes.size() == 0) {
            return null;
        } else {
            List<Object> list = new ArrayList<>();
            for (Object node : nodes) {
                ConfigurationNode configurationNode = (ConfigurationNode) node;
                if (configurationNode.getValue() != null) {
                    list.add(configurationNode.getValue());
                }
            }

            if (list.size() < 1) {
                return null;
            } else {
                return list;
            }
        }
    }
1342760
@Override
	public String getProperty(String key) {
		String p = super.getProperty(key);
		if (StrKit.isBlank(p)) {
			new IllegalArgumentException("`"+key+"` Cannot be empty, set `"+key+"` in "+cfg+" file");
		}
		return p;
	}
1171240
protected function _getConfig($key = null) {
		$language = Configure::read('Config.language');
		$key = (string)$key;

		if ($key === 'Language') {
			if (empty($language)) {
				return null;
			}

			$configs = $language;
		} else {
			$configPath = $this->_modelConfigSettingsApp->getNameConfigKey();
			if (!empty($key)) {
				$configPath .= '.' . $key;
			}

			$configs = Configure::read($configPath);
			if ($configs === null) {
				return null;
			}

			if (empty($key)) {
				$configs['Language'] = $language;
			}
		}

		if (!empty($key)) {
			$configs = [$key => $configs];
		}

		$listSerializedFields = $this->_modelConfigSettingsApp->getListSerializeFields();
		$result = [];
		foreach ($configs as $configName => $configValue) {
			switch ($configName) {
				case 'EmailSmtppassword':
					if (!empty($configValue)) {
						$result[$this->alias][$configName] = Security::decrypt(base64_decode($configValue), Configure::read('Security.key'));
					} else {
						$result[$this->alias][$configName] = $configValue;
					}
					break;
				default:
					if (in_array($configName, $listSerializedFields) && !empty($configValue)) {
						$configValue = unserialize($configValue);
					}
					$result[$this->alias][$configName] = $configValue;
			}
		}

		if (!empty($key)) {
			return Hash::get($result, $this->alias . '.' . $key);
		}

		if (empty($result)) {
			return null;
		}

		return $result;
	}
887956
String getProperty(String key) {
        String value = properties.get(key);
        if (value == null) {
            throw new RuntimeException("No property value found for key " + key);
        }
        return value;
    }
1103818
public static File getAbsoluteFile(AbstractConfig config, String key) {
    Preconditions.checkNotNull(config, "config cannot be null");
    String path = config.getString(key);
    File file = new File(path);
    if (!file.isAbsolute()) {
      throw new ConfigException(
          key,
          path,
          "Must be an absolute path."
      );
    }
    return new File(path);
  }
210686
public String getString(String key) {
    Object value = get(key);
    if (value instanceof String) {
      return (String) value;
    } else if (value != null) {
      return String.valueOf(value);
    }
    return null;
  }
760189
protected Object extractSpecificConfig(String key)
    {
        if (this.specificConfig == null)
        {
            return null;
        }

        Object result = this.specificConfig.get(key);
        return result;
    }
538490
private Object getValue(String key) {

        // iterate over configuration tree
        String[] splittedKeys = key.split("\\.");
        Object value = config;

        for (int i = 0; i < splittedKeys.length; i++) {

            String splittedKey = splittedKeys[i];

            if (value == null) {
                return null;
            }

            // parse arrays
            if (representsArray(splittedKey)) {

                // value array support
                int arrayIndex;
                int openingBracket = splittedKey.indexOf("[");
                int closingBracket = splittedKey.indexOf("]");

                try {
                    arrayIndex = Integer.parseInt(splittedKey.substring(openingBracket + 1, closingBracket));
                } catch (NumberFormatException e) {

                    if (log != null) {
                        log.severe("Cannot cast array index.");
                    }

                    return null;
                }

                splittedKey = splittedKey.substring(0, openingBracket);

                if (value instanceof Map) {
                    value = ((Map) value).get(splittedKey);
                } else {
                    return null;
                }

                if (value instanceof List) {
                    value = (arrayIndex < ((List) value).size()) ? ((List) value).get(arrayIndex) : null;
                }

            } else {
                if (value instanceof Map) {

                    Object tmpValue = ((Map) value).get(splittedKey);

                    if (tmpValue == null && i != splittedKeys.length - 1) {

                        String postfixKey = Arrays.stream(splittedKeys).skip(i)
                                .collect(Collectors.joining("."));

                        return ((Map) value).get(postfixKey);
                    } else {

                        value = tmpValue;
                    }
                } else {
                    return null;
                }
            }
        }

        return value;
    }