Shortcut version of {@link #prop(String, Enum, Function)}. Used when default converters could be used.

@param name   property name
@param option option
@param <T>    helper option type
@return mapper instance for chained calls
498966
public <T extends Enum & Option> OptionsMapper prop(final String name, final T option) {
        return prop(name, option, null);
    }
1096812
public <T> T getOneOptional(Class<T> type, String name) {
		Object locator = find(name);
		return locator != null ? _references.getOneOptional(type, locator) : null;
	}
1131051
public PropertyBuilder string(final String name) {
        name(name);
        type(Property.Type.String);
        return this;
    }
344056
function Governor(options) {
  this.autocrat = options.autocrat;
  this.wards = this.autocrat.wards;

  var nameCapCamel = this.constructor.name.replace(/governor/i,'');
  var name = nameCapCamel[0].toLowerCase() + nameCapCamel.slice(1);
  this.name = name

  this.props = {};
  this._propVals = {};
  this._propStreams = {};
  this._propAddresses = this._parsePropAddresses();

  this.initialize.apply(this, arguments);
}
586212
function(option) {

  // Swap alias and name around.
  if (option.name && option.alias && option.name.length > option.alias.length) {
    var name = option.alias;
    option.alias = option.name;
    option.name = name;
  }

  var defaults = {
    alias: null,
    kind: 'boolean'
  };
  var keys = Object.keys(option);
  _.each(defaults, function(val, key) {
    if (!_.contains(keys, key)) {
      option[key] = val;
    }
  });
}
495145
public static SmartBinder from(Class<?> retType, String name, Class<?> type) {
        return from(Signature.returning(retType).appendArg(name, type));
    }
410383
function(options, type) {
    return _.without(_.map(options, function(option) {
      if (option[type]) {
        option[type].name = option.name;
        return option[type];
      }
    }), undefined);
  }
811486
function(proto, name, combo) {
		var base = Object.getOwnPropertyDescriptor(proto, name);
		if(base) {
			Object.defineProperty(proto, name, {
				enumerable: true,
				configurable: true,
				get: function() {
					return base.get.call(this);
				},
				set: combo(function(value) {
					base.set.call(this, value);
				})
			});
		}
	}
190282
public Options param(String name, String value) {
		options.put(name, value);
		return this;
	}
207450
@SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
    @Nullable
    public <T> T getProperty(String name) {
        return (T) config.getProperties().get(name);
    }
781664
public String getPropertyValueName(int property, int value, int nameChoice) {
        int valueMapIndex=findProperty(property);
        if(valueMapIndex==0) {
            throw new IllegalArgumentException(
                    "Invalid property enum "+property+" (0x"+Integer.toHexString(property)+")");
        }
        int nameGroupOffset=findPropertyValueNameGroup(valueMaps[valueMapIndex+1], value);
        if(nameGroupOffset==0) {
            throw new IllegalArgumentException(
                    "Property "+property+" (0x"+Integer.toHexString(property)+
                    ") does not have named values");
        }
        return getName(nameGroupOffset, nameChoice);
    }
1136524
public static function createConvertType(
        string $name,
        string $type,
        bool $emptyToNull = false
    ): DenormalizationFieldMappingBuilderInterface {
        $self = new self($name);
        $self->fieldDenormalizer = new ConvertTypeFieldDenormalizer(new PropertyAccessor($name), $type, $emptyToNull);

        return $self;
    }
385303
function( options ){
			if(this.name == getCurrent().name){
				return options.fn(this)
			} else {
				return helpers.ifHasActive.apply(this, arguments);
			}
		}
807617
public static MapPropertySource of(String name, Map<String, Object> map) {
        return new MapPropertySource(name, map);
    }
341549
@SuppressWarnings("unchecked")
    protected OptionHandler createOptionHandler(CmdLineParser parser, OptionDef o, Setter setter) {
        checkNonNull(o, "CmdLineParser");
        checkNonNull(o, "OptionDef");
        checkNonNull(setter, "Setter");

        Class<? extends OptionHandler> h = o.handler();
        if(h==OptionHandler.class) {
            // infer the type
            Class<?> t = setter.getType();

            // enum is the special case
            if(Enum.class.isAssignableFrom(t))
                return new EnumOptionHandler(parser,o,setter,t);

            OptionHandlerFactory factory = handlers.get(t);
            if (factory==null)
                throw new IllegalAnnotationError(Messages.UNKNOWN_HANDLER.format(t));

            return factory.getHandler(parser, o, setter);
        } else {
            // explicit handler specified
            return new DefaultConstructorHandlerFactory(h).getHandler(parser, o, setter);
        }
    }
255772
public PropertyBuilder select(final String name) {
        name(name);
        type(Property.Type.Select);
        return this;
    }
316464
public Object getOptionValue( String name )
    {
        if (!hasOptionValue( name )) throw new IllegalArgumentException( "Don't know option: " + name );
        return getOptionValues().get( name );
    }