private bool ReadFlag(PropertyInfo pi, out object value) { value = null; FlagAttribute fa = pi.GetCustomAttribute <FlagAttribute>( ); if (fa == null) { return(false); } IFlag flag = _spec.Flags.FirstOrDefault(f => f.Name.Equals(fa.Name)); if (flag == null) { throw new Exception( $"property {pi.Name} has no corresponding {nameof( IFlag )} with name {fa.Name}"); } if (pi.PropertyType.IsAssignableFrom(typeof(bool))) { value = _pr.IsSet(flag); return(true); } throw new Exception( $"flag property {pi.Name} should be assignable from bool but is of type {pi.PropertyType}"); }
private void AddFlags(CliSpecification spec, Type t) { foreach (PropertyInfo pi in t.GetProperties( )) { FlagAttribute flagAttrib = pi.GetCustomAttribute <FlagAttribute>( ); if (flagAttrib == null) { continue; } AddFlag(spec, t, flagAttrib, pi); } }
public void SetFlagValue(MemberInfo member, FlagAttribute flagAttribute) { var memberType = TypeHelper.GetMemberType(member); if (TypeHelper.IsLazy(memberType)) { TypeHelper.SetValue(member, _tArgs, new Lazy <bool>(() => _args.GetFlag(flagAttribute.Name))); } else { TypeHelper.SetValue(member, _tArgs, _args.GetFlag(flagAttribute.Name)); } }
private void AddFlag( CliSpecification spec, Type t, FlagAttribute flagAttrib, PropertyInfo pi) { Flag flag = new Flag( flagAttrib.Name, flagAttrib.Optional, GetDynamicArgument(spec, t, pi.Name), GetArguments(spec, t, pi.Name)); flag.Description = flagAttrib.Description; spec.Flags.Add(flag); }
/// <summary> /// Gets the flags in this command. /// </summary> protected virtual string GetFlagsString(params string[] ignore) { StringBuilder builder = new StringBuilder(); PropertyInfo[] members = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (PropertyInfo member in members.Where(t => !(t.GetCustomAttribute <FlagAttribute>() is null))) { FlagAttribute flag = member.GetCustomAttribute <FlagAttribute>(); object value = member.GetValue(this, null); if (value is bool b && b && !ignore.Contains(flag.Name, StringComparer.InvariantCultureIgnoreCase)) { builder.Append(flag.Name.ToLowerInvariant()) .Append(' '); } } return(builder.ToString().Trim()); }
public void RegisterFlag(MemberInfo member, FlagAttribute flagAttribute) { ValidatePropertySetter(member); ValidateFlagMemberType(member); var flag = new Flag { Name = flagAttribute.Name, Abr = flagAttribute.Abr, Description = flagAttribute.Description, ValueType = typeof(bool), DefaultValue = flagAttribute.DefaultValue, EnvironmentVariable = flagAttribute.EnvironmentVariable, IsEnvironmentVariableLazy = TypeHelper.IsLazy(TypeHelper.GetMemberType(member)), ConfigPath = flagAttribute.ConfigPath, IsConfigPathLazy = TypeHelper.IsLazy(TypeHelper.GetMemberType(member)), Group = flagAttribute.Group }; _commandConfigurator.RegisterFlagInstance(flag); }
public IItem GetItem(string propertyName) { PropertyInfo pi = _t.GetProperty(propertyName); if (pi == null) { throw new Exception($"{_t} has no property {propertyName}"); } IItem item; OptionAttribute oa = pi.GetCustomAttribute <OptionAttribute>( ); FlagAttribute fa = pi.GetCustomAttribute <FlagAttribute>( ); if (oa != null) { UnifiedName optionName = _specDeriverConfig.PropertyNamingStyle.FromString( string.IsNullOrEmpty(oa.Name)? pi.Name : oa.Name); item = _spec.Options.FirstOrDefault(o => o.Name.Equals(optionName)); if (item == null) { throw new Exception($"no option mapped to property {propertyName}"); } } else if (fa != null) { item = _spec.Flags.FirstOrDefault(f => f.Name == fa.Name); if (item == null) { throw new Exception($"no flag mapped to property {propertyName}"); } } else { throw new Exception($"no item mapped to property {propertyName}"); } return(item); }
/// <summary> /// Updates the command's property members by referencing the <see cref="Arguments"/> collection. /// </summary> internal void UpdateArguments() { Type type = this.GetType(); PropertyInfo[] members = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); List <string> args = this.Arguments.Where(a => a.IndexOf('=') < 0).ToList(); args.RemoveAll(String.IsNullOrWhiteSpace); // get arguments without flags foreach (PropertyInfo member in members.Where(prop => !(prop.GetCustomAttribute <FlagAttribute>() is null)) .Where(prop => prop.PropertyType == typeof(bool))) { FlagAttribute flag = member.GetCustomAttribute <FlagAttribute>(); if (args.Select(a => a.ToUpperInvariant()).Contains(flag.Name.ToUpperInvariant())) { args.RemoveAll(a => a.Equals(flag.Name, StringComparison.InvariantCultureIgnoreCase)); } } this.Arguments = args.AsReadOnly(); foreach (PropertyInfo member in members.Where(prop => !(prop.ToVpParameter() is null)) .OrderBy(prop => prop.ToVpParameter().Index)) { ParameterAttribute attribute = member.ToVpParameter(); object value = member.GetDefaultValue(); value = SanitizeValue(member.PropertyType, args.Count > attribute.Index ? args[attribute.Index] : value); member.SetValue(this, value, null); } }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { if (property.propertyType == SerializedPropertyType.Integer) { position.height /= 2; FlagAttribute _Flag = attribute as FlagAttribute; EditorGUI.PropertyField(position, property, label); position.y += position.height; if (_Flag.itemStrs == null && _Flag.strName != "") { SerializedProperty _itemStrsProperty = property.serializedObject.FindProperty(_Flag.strName); if (_itemStrsProperty != null) { _Flag.itemStrs = SerializedPropertyValue.GetArray <string>(_itemStrsProperty); } else { EditorGUI.LabelField(position, label.text, "Property : \"" + _Flag.strName + "\" Not Found"); return; } } if (_Flag.itemStrs == null) { EditorGUI.LabelField(position, label.text, "Property : \"" + _Flag.strName + "\" Not String Array"); } else { property.intValue = ExtendGUI.Flag(position, property.intValue, _Flag.itemStrs); } } else { EditorGUI.LabelField(position, label.text, "[Flag] Only for Int"); } }
private void RegisterFlag(string currentCommand, ArgumentProperty argumentProperty, FlagAttribute flag) { _flagNames.Add(flag.ShortName); _flagNames.Add(flag.LongName); _argumentProperties[currentCommand][flag.ShortName] = argumentProperty; _argumentProperties[currentCommand][flag.LongName] = argumentProperty; }
public ParametersList(MethodInfo methodInfo) { List <Parameter> args = new List <Parameter>(); bool hasContextParameter = false; foreach (ParameterInfo param in methodInfo.GetParameters()) { if (param.IsOptional) { throw new UnsupportedOptionalParameterException(methodInfo, param); } bool isContext = false; if (param.ParameterType.IsAssignableFrom(typeof(ICommandContext))) { hasContextParameter = true; isContext = true; } FlagAttribute flagAttribute = param.GetCustomAttribute <FlagAttribute>(false); NameAttribute nameAttribute = param.GetCustomAttribute <NameAttribute>(false); if (flagAttribute != null && param.ParameterType != typeof(bool)) { throw new UnsupportedNonBooleanFlagException(methodInfo, param); } Type checkType = param.ParameterType; if (param.ParameterType.IsArray || (param.ParameterType.IsGenericType && param.ParameterType.GetGenericTypeDefinition() == typeof(List <>))) { checkType = param.ParameterType.GetElementType() ?? param.ParameterType.GetGenericArguments()[0]; } if (checkType != typeof(ICommandContext)) { ITypeParser parser = Parser.GetParserForType(checkType); if (parser == null) { throw new UnconvertableTypeParameterException(methodInfo, param); } } if (flagAttribute == null && !isContext) { RequiredParamterCount++; } args.Add(new Parameter( name: nameAttribute?.Name, parameterInfo: param, isFlag: flagAttribute != null, shortName: flagAttribute?.ShortName, longName: flagAttribute?.LongName, isParams: param.IsDefined(typeof(ParamArrayAttribute), false), isContext: isContext, defaultValue: flagAttribute?.DefaultValue ?? false)); } // Throw exception if a ICommandContext parameter isnt found if (!hasContextParameter) { throw new MissingContextParameterException(methodInfo); } Parameters = args; Syntax = GenerateSyntax(); }