Returns the value associated with the given config option as a string.

@param configOption The configuration option
@return the (default) value associated with the given config option
353716
@PublicEvolving
	public String getValue(ConfigOption<?> configOption) {
		Object o = getValueOrDefaultFromOption(configOption);
		return o == null ? null : o.toString();
	}
791526
@PublicEvolving
	public void setString(ConfigOption<String> key, String value) {
		setValueInternal(key.key(), value);
	}
995310
public function getConfigOption($option)
    {
        // An exception will be thrown instead of returning NULL or something similar.
        if ( ! array_key_exists($option, $this->config)) {
            throw new UnexpectedValueException("Unexpected option name: {$option}");
        }

        return $this->config[$option];
    }
314426
Option toOption() {
        DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();

        oBuilder.withShortName(option).withDescription(description).withRequired(required);

        if (longOptionName != null) {
            oBuilder.withLongName(longOptionName);
        }

        if (hasArgs) {
            ArgumentBuilder aBuilder = new ArgumentBuilder();

            if (argName != null) {
                aBuilder.withName(argName);
            }

            if (argsAreOptional) {
                aBuilder.withMinimum(0);
            }

            if (argsCount != null) {
                aBuilder.withMaximum(argsCount);
            } else {
                aBuilder.withMaximum(1);
            }

            if (argsValueSeparator != null && argsValueSeparator.length() != 0) {
                aBuilder.withInitialSeparator(argsValueSeparator.charAt(0));
                aBuilder.withSubsequentSeparator(argsValueSeparator.charAt(0));
            }
            oBuilder.withArgument(aBuilder.create());
        }

        return oBuilder.create();
    }
593175
@CheckResult @NonNull
  public Preference<String> getString(@NonNull String key, @NonNull String defaultValue) {
    checkNotNull(key, "key == null");
    checkNotNull(defaultValue, "defaultValue == null");
    return new RealPreference<>(preferences, key, defaultValue, StringAdapter.INSTANCE, keyChanges);
  }
987621
public Node getConfigurationOption (String optionName) {
		NodeList children = configuration.getChildNodes ();
		Node configurationOption = null;
		for (int childIndex = 0; childIndex < children.getLength (); childIndex++) {
			if (children.item (childIndex).getNodeName ().equals (optionName)) {
				configurationOption = children.item (childIndex);
				break;
			}
		}
		return configurationOption;
	}
356749
public Option getOption(String name) {
        if (shortOpts.containsKey(name)) {
            return shortOpts.get(name);
        }
        return longOpts.get(name);
    }
1260913
private String getSurrogateKeyForTaggedOption(
            final String rawOptionString,   // the raw option string provided by the user, including the prefix and option name
            final String rawArgumentValue,  // the raw argument value provided by the user
            final String tagString          // the tag string that has been peeled off of the raw option string, including logical name and any attributes
    )
    {
        final String surrogateKey = makeSurrogateKey(rawOptionString, rawArgumentValue);
        if (null != tagSurrogates.put(surrogateKey, Pair.of(tagString, rawArgumentValue))) {
            throw new CommandLineException.BadArgumentValue(
                    String.format("The argument value: \"%s %s\" was duplicated on the command line", rawOptionString, rawArgumentValue));
        }
        return surrogateKey;
    }
892472
public Option defaultValue(String defaultValue) throws RequiredParametersException {
		if (this.choices.isEmpty()) {
			return this.setDefaultValue(defaultValue);
		} else {
			if (this.choices.contains(defaultValue)) {
				return this.setDefaultValue(defaultValue);
			} else {
				throw new RequiredParametersException("Default value " + defaultValue +
						" is not in the list of valid values for option " + this.longName);
			}
		}
	}
7785
@Override
    public String getString( final String      key,
                             final String      defaultValue )
    {
        String  candidate;
        candidate = getFormattedPropValue( key );

        if ( candidate == null )
        {
            return defaultValue;
        }

        return candidate;
    }
498127
def getopt_default(self, option):
        
        if option not in self.conf:
            print("Unrecognized option %r" % option)
            return
        print("%s: %s" % (option, self.conf[option]))
277212
public static String getString(String name, String defaultValue) {
		return System.getProperty(name, defaultValue);
	}
963823
public String getConfig(String configName, String def)
  {
    if (config != null)
    {
      return config.getProperty(configName, def);
    }
    else
    {
      return def;
    }
  }
712060
public String getRequiredConfigAttributeWithDefaultValueAndConfigId(Map<String, Object> props, String key, String defaultValue, String configId) {
        String result = getAndTrimConfigAttribute(props, key);
        if (key != null && result == null) {
            if (defaultValue != null) {
                result = defaultValue;
            } else {
                logMessageForMissingRequiredAttribute(key, configId);
            }
        }
        return result;
    }
889369
protected final <T> String getString(final IKey<T> key) {
        final Object value = config.get(key.key());

        return String.valueOf(value != null ? value : key.getDefaultValue());
    }
974501
public static String getString(String name, String defaultVal){
        if(getConfiguration().containsKey(name)){
            return getConfiguration().getString(name);
        } else {
            return defaultVal;
        }
    }
659834
@PublicEvolving
	public float getFloat(ConfigOption<Float> configOption) {
		Object o = getValueOrDefaultFromOption(configOption);
		return convertToFloat(o, configOption.defaultValue());
	}