/// <summary> /// Creates descriptions of parameters from the public property members of an /// object. /// </summary> /// <typeparam name="T">The object type to inspect.</typeparam> /// <param name="pOptions">The parser option</param> /// <param name="pInfos">Collection of properties</param> /// <returns>Parameter descriptions in syntax format.</returns> private static string ReflectDescriptions <T>(CliOptions pOptions, IEnumerable <PropertyInfo> pInfos) where T : class, new() { List <string> desc = new List <string>(); foreach (PropertyInfo info in pInfos) { eROLE role = eROLE.PASSED; string name = info.Name.ToLower(); CliName attrName = Attribute <CliName>(info); if (attrName != null) { role = attrName.Role; name = attrName.Name ?? name; } string str = string.Format( "{0}{1}:{2}", role == eROLE.NAMED ? pOptions.Prefix : "", name, info.PropertyType.Name.ToLower() ); CliOptional attrOptional = Attribute <CliOptional>(info); if (attrOptional != null) { str = string.Format("[{0}]", str); } desc.Add(str); } return(string.Join(" ", desc)); }
/// <summary> /// An easy factory method that uses an object's properties to /// define the command line arguments required for the application. /// </summary> /// <typeparam name="T">The object class to initialize.</typeparam> /// <param name="pOptions">The parser options</param> /// <param name="pArgs">The command line arguments.</param> /// <returns>A new class T with it's properties populated, or Null if command line arguments are invalid.</returns> public static T Create <T>(CliOptions pOptions, IEnumerable <string> pArgs) where T : class, new() { PropertyInfo[] infos = typeof(T).GetProperties(); string pattern = ReflectDescriptions <T>(pOptions, infos); List <Description> descs = DescriptionFactory.Create(pOptions, new HelpReflection(typeof(T)), pattern); Request request = Create(pOptions, pArgs, descs, new ConsoleFactory()); if (!request.Valid) { return(null); } T instance = Activator.CreateInstance <T>(); foreach (Description desc in descs) { PropertyInfo info = ReflectProperty(infos, desc.Name); if (!request.Contains(desc.Name) || info == null) { continue; } // TODO: Support multiples info.SetValue(instance, Convert.ChangeType(request.First(desc.Name).Value, info.PropertyType)); } return(instance); }
/// <summary> /// Creates a request object from the command line arguments. /// </summary> /// <param name="pOptions">The parser options.</param> /// <param name="pArgs">The command line arguments.</param> /// <param name="pDescs">Argument descriptions.</param> /// <param name="pOutput">Factory for handling output.</param> /// <returns></returns> public static Request Create(CliOptions pOptions, IEnumerable <string> pArgs, IEnumerable <Description> pDescs, iOutputFactory pOutput) { iOutputStream outputStream = pOutput.Create(); OutputMessages outputMessages = new OutputMessages(pOptions, outputStream); Validator validator = new Validator(outputMessages); return(Create(pOptions, validator, pArgs, pDescs.ToList())); }
/// <summary> /// </summary> /// <param name="pOptions"></param> /// <param name="pValidator"></param> /// <param name="pArgs"></param> /// <param name="pDescs"></param> /// <returns></returns> private static Request Create(CliOptions pOptions, iValidator pValidator, IEnumerable <string> pArgs, ICollection <Description> pDescs) { IEnumerable <Argument> arguments = ArgumentFactory.Create(pOptions.Prefix, pOptions.EqualChar, pArgs); Request request = new Request(arguments, pDescs); if (pValidator != null) { request.Valid = pValidator.Validate(pDescs.ToList(), request); } return(request); }