private static ArgumentDefinition CreateArgumentDescriptor( IMutableMemberInfo member, ArgumentBaseAttribute attribute, object defaultValues, ArgumentSetDefinition argSet, object fixedDestination, ArgumentDefinition containingArgument, ServiceConfigurer serviceConfigurer) { if (!member.IsReadable || !member.IsWritable) { var declaringType = member.MemberInfo.DeclaringType; throw new InvalidArgumentSetException(member, string.Format( CultureInfo.CurrentCulture, Strings.MemberNotSupported, member.MemberInfo.Name, declaringType?.Name)); } var defaultFieldValue = (defaultValues != null) ? member.GetValue(defaultValues) : null; return(new ArgumentDefinition(member, attribute, argSet, defaultValue: defaultFieldValue, fixedDestination: fixedDestination, containingArgument: containingArgument, serviceConfigurer: serviceConfigurer)); }
/// <summary> /// Constructor. /// </summary> /// <param name="argSet">Argument set to create parser for.</param> /// <param name="options">Parser options.</param> public ArgumentSetParser(ArgumentSetDefinition argSet, CommandLineParserOptions options) { if (argSet == null) { throw new ArgumentNullException(nameof(argSet)); } // Clone the argument set definition, as parsing may mutate it. ArgumentSet = argSet.DeepClone(); // Save off the options provided; if none were provided, construct some quiet defaults. _options = options?.DeepClone() ?? CommandLineParserOptions.Quiet(); // If no reporter was provided, use a no-op one. if (_options.Reporter == null) { _options.Reporter = err => { }; } // If no file-system reader was provided, use our default implementation. if (_options.FileSystemReader == null) { _options.FileSystemReader = FileSystemReader.Create(); } }
public ArgumentDefinition(MemberInfo member, ArgumentBaseAttribute attribute, ArgumentSetDefinition argSet, object defaultValue = null, ArgumentDefinition containingArgument = null, ServiceConfigurer serviceConfigurer = null) : this(GetMutableMemberInfo(member), attribute, argSet, defaultValue, /*fixedDestination=*/ null, containingArgument, serviceConfigurer) { }
/// <summary> /// Internal constructor. /// </summary> /// <param name="member">Field to describe.</param> /// <param name="attribute">Argument attribute on the field.</param> /// <param name="argSet">Argument set containing this argument.</param> /// <param name="defaultValue">Default value for the field.</param> /// <param name="fixedDestination">Optionally provides fixed parse destination object.</param> /// <param name="containingArgument">Optionally provides a reference /// to the definition of the argument that "contains" these arguments. /// </param> /// <param name="serviceConfigurer">Optionally provides a service configurer.</param> internal ArgumentDefinition(IMutableMemberInfo member, ArgumentBaseAttribute attribute, ArgumentSetDefinition argSet, object defaultValue = null, object fixedDestination = null, ArgumentDefinition containingArgument = null, ServiceConfigurer serviceConfigurer = null) { Member = member ?? throw new ArgumentNullException(nameof(member)); Attribute = attribute ?? throw new ArgumentNullException(nameof(attribute)); ContainingSet = argSet ?? throw new ArgumentNullException(nameof(argSet)); ContainingArgument = containingArgument; FixedDestination = fixedDestination; IsPositional = attribute is PositionalArgumentAttribute; ArgumentType = GetArgumentType(Attribute, member, member.MemberType, serviceConfigurer); CollectionArgumentType = AsCollectionType(ArgumentType); HasDefaultValue = attribute.ExplicitDefaultValue || attribute.DynamicDefaultValue; ValidationAttributes = GetValidationAttributes(ArgumentType, Member); LongName = GetLongName(attribute, argSet.Attribute, member.MemberInfo); ExplicitShortName = HasExplicitShortName(attribute); ShortName = GetShortNameOrNull(attribute, argSet.Attribute, member.MemberInfo); DefaultValue = GetDefaultValue(attribute, member, defaultValue); var nullableBase = Nullable.GetUnderlyingType(member.MemberType); if (CollectionArgumentType != null) { ValueType = CollectionArgumentType.ElementType; } else if (nullableBase != null) { // For nullable arguments, we use the wrapped type (T in // Nullable<T>) as the value type. Parsing an enum or int is the // same as parsing an enum? or int?, for example, since null can // only arise if the value was not provided at all. ValueType = GetArgumentType(Attribute, member, nullableBase, serviceConfigurer); } else { ValueType = ArgumentType; } Debug.Assert(ValueType != null); if (Unique && !IsCollection) { throw new InvalidArgumentSetException(member, Strings.UniqueUsedOnNonCollectionArgument); } Debug.Assert(!string.IsNullOrEmpty(LongName)); }
/// <summary> /// Constructs a new stateful parser for the given argument. /// </summary> /// <param name="argSet">The argument set containing the argument to be parsed.</param> /// <param name="arg">The definition of the argument.</param> /// <param name="options">General options for parsing this argument set.</param> /// <param name="destination">The destination object into which the parsed result should go, /// if so desired; null otherwise to parse without saving results.</param> public ArgumentParser(ArgumentSetDefinition argSet, ArgumentDefinition arg, CommandLineParserOptions options, object destination = null) { ArgumentSet = argSet ?? throw new ArgumentNullException(nameof(argSet)); Argument = arg ?? throw new ArgumentNullException(nameof(arg)); Reporter = options?.Reporter ?? (s => { }); DestinationObject = arg.FixedDestination ?? destination; ParseContext = CreateParseContext(Argument, ArgumentSet.Attribute, options, DestinationObject); if (Argument.IsCollection) { CollectionValues = GenericCollectionFactory.CreateList(Argument.CollectionArgumentType.ElementType.Type); } }
public static ArgumentSetDefinition CreateArgumentSet( Type typeToReflectOn, ArgumentSetAttribute attribute = null, object defaultValues = null, object fixedDestination = null, ServiceConfigurer serviceConfigurer = null) { // Find high-level metadata for the argument set. var argSetAttrib = attribute ?? GetSetAttributeOrDefault(typeToReflectOn); // Construct an empty definition. var argSet = new ArgumentSetDefinition(argSetAttrib); // Add arguments. AddToArgumentSet( argSet, typeToReflectOn, defaultValues: defaultValues, fixedDestination: fixedDestination, serviceConfigurer: serviceConfigurer); return(argSet); }
public static void AddToArgumentSet( ArgumentSetDefinition argSet, Type typeToReflectOn, object defaultValues = null, object fixedDestination = null, ArgumentDefinition containingArgument = null, ServiceConfigurer serviceConfigurer = null) { // Extract argument descriptors from the defining type. var args = GetArgumentDescriptors( typeToReflectOn, argSet, defaultValues, fixedDestination, containingArgument, serviceConfigurer).ToList(); // Define the arguments. argSet.Add(args); // If the provided type we're reflecting on has an ArgumentSetAttribute, // then add that as auxiliary information. var auxiliaryAttrib = TryGetSetAttribute(typeToReflectOn); if (auxiliaryAttrib != null) { argSet.AddAuxiliaryAttribute(auxiliaryAttrib); } // If the argument set doesn't already have a default assembly associated // with it, then fill that out. if (argSet.DefaultAssembly == null) { argSet.DefaultAssembly = typeToReflectOn.GetTypeInfo().Assembly; } }
private static IEnumerable <ArgumentDefinition> CreateArgumentDescriptorsIfApplicable(IMutableMemberInfo member, object defaultValues, ArgumentSetDefinition argSet, object fixedDestination, ArgumentDefinition containingArgument, ServiceConfigurer serviceConfigurer) { var descriptors = Enumerable.Empty <ArgumentDefinition>(); var argAttrib = member.MemberInfo.GetSingleAttribute <ArgumentBaseAttribute>(); if (argAttrib != null) { descriptors = descriptors.Concat( new[] { CreateArgumentDescriptor( member, argAttrib, defaultValues, argSet, fixedDestination, containingArgument, serviceConfigurer) }); } return(descriptors); }
private static IEnumerable <ArgumentDefinition> GetArgumentDescriptors(Type type, ArgumentSetDefinition argSet, object defaultValues, object fixedDestination, ArgumentDefinition containingArgument, ServiceConfigurer serviceConfigurer) { // Find all fields and properties that have argument attributes on // them. For each that we find, capture information about them. var argList = GetAllFieldsAndProperties(type, includeNonPublicMembers: true) .SelectMany(member => CreateArgumentDescriptorsIfApplicable(member, defaultValues, argSet, fixedDestination, containingArgument, serviceConfigurer)); // If the argument set attribute indicates that we should also // include un-attributed, public, writable members as named // arguments, then look for them now. if (argSet.Attribute.PublicMembersAreNamedArguments) { argList = argList.Concat(GetAllFieldsAndProperties(type, includeNonPublicMembers: false) .Where(member => member.IsWritable) .Where(member => member.MemberInfo.GetSingleAttribute <ArgumentBaseAttribute>() == null) .Select(member => CreateArgumentDescriptor( member, new NamedArgumentAttribute(), defaultValues, argSet, fixedDestination, containingArgument, serviceConfigurer))); } return(argList); }