Пример #1
0
        public static OptionMap Create(object target, ParserSettings settings)
        {
            IList <Pair <PropertyInfo, BaseOptionAttribute> > list =
                ReflectionHelper.RetrievePropertyList <BaseOptionAttribute>(target);

            if (list is null)
            {
                return(null);
            }

            var map = new OptionMap(list.Count, settings);

            foreach (Pair <PropertyInfo, BaseOptionAttribute> pair in list)
            {
                if (pair.Left != null && pair.Right != null)
                {
                    string uniqueName;
                    if (pair.Right.AutoLongName)
                    {
                        uniqueName          = pair.Left.Name.ToLowerInvariant();
                        pair.Right.LongName = uniqueName;
                    }
                    else
                    {
                        uniqueName = pair.Right.UniqueName;
                    }

                    map[uniqueName] = new OptionInfo(pair.Right, pair.Left, settings.ParsingCulture);
                }
            }

            map.RawOptions = target;
            return(map);
        }
Пример #2
0
        public static OptionMap Create(
            object target,
            IList <Pair <PropertyInfo, VerbOptionAttribute> > verbs,
            ParserSettings settings)
        {
            var map = new OptionMap(verbs.Count, settings);

            foreach (Pair <PropertyInfo, VerbOptionAttribute> verb in verbs)
            {
                var optionInfo = new OptionInfo(verb.Right, verb.Left, settings.ParsingCulture)
                {
                    HasParameterLessCtor =
                        verb.Left.PropertyType.GetConstructor(Type.EmptyTypes) != null
                };

                if (!optionInfo.HasParameterLessCtor && verb.Left.GetValue(target, null) is null)
                {
                    throw new ParserException("Type {0} must have a parameterless constructor or" +
                                              " be already initialized to be used as a verb command.".FormatInvariant(
                                                  verb.Left.PropertyType));
                }

                map[verb.Right.UniqueName] = optionInfo;
            }

            map.RawOptions = target;
            return(map);
        }
Пример #3
0
 public abstract PresentParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options);
Пример #4
0
        public override PresentParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
        {
            var optionGroup = new OneCharStringEnumerator(argumentEnumerator.Current.Substring(1));

            while (optionGroup.MoveNext())
            {
                OptionInfo option = map[optionGroup.Current];
                if (option is null)
                {
                    return(_ignoreUnkwnownArguments ? PresentParserState.MoveOnNextElement : PresentParserState.Failure);
                }

                option.IsDefined = true;

                EnsureOptionArrayAttributeIsNotBoundToScalar(option);

                if (!option.IsBoolean)
                {
                    if (argumentEnumerator.IsLast && optionGroup.IsLast)
                    {
                        return(PresentParserState.Failure);
                    }

                    bool valueSetting;
                    if (!optionGroup.IsLast)
                    {
                        if (!option.IsArray)
                        {
                            valueSetting = option.SetValue(optionGroup.GetRemainingFromNext(), options);
                            if (!valueSetting)
                            {
                                DefineOptionThatViolatesFormat(option);
                            }

                            return(BooleanToParserState(valueSetting));
                        }

                        EnsureOptionAttributeIsArrayCompatible(option);

                        IList <string> items = GetNextInputValues(argumentEnumerator);
                        items.Insert(0, optionGroup.GetRemainingFromNext());

                        valueSetting = option.SetValue(items, options);
                        if (!valueSetting)
                        {
                            DefineOptionThatViolatesFormat(option);
                        }

                        return(BooleanToParserState(valueSetting, true));
                    }

                    if (!argumentEnumerator.IsLast && !IsInputValue(argumentEnumerator.Next))
                    {
                        return(PresentParserState.Failure);
                    }

                    if (!option.IsArray)
                    {
                        valueSetting = option.SetValue(argumentEnumerator.Next, options);
                        if (!valueSetting)
                        {
                            DefineOptionThatViolatesFormat(option);
                        }

                        return(BooleanToParserState(valueSetting, true));
                    }

                    EnsureOptionAttributeIsArrayCompatible(option);

                    IList <string> moreItems = GetNextInputValues(argumentEnumerator);

                    valueSetting = option.SetValue(moreItems, options);
                    if (!valueSetting)
                    {
                        DefineOptionThatViolatesFormat(option);
                    }

                    return(BooleanToParserState(valueSetting));
                }

                if (!optionGroup.IsLast && map[optionGroup.Next] is null)
                {
                    return(PresentParserState.Failure);
                }

                if (!option.SetValue(true, options))
                {
                    return(PresentParserState.Failure);
                }
            }

            return(PresentParserState.Success);
        }
Пример #5
0
        public override PresentParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
        {
            string[]   parts  = argumentEnumerator.Current.Substring(2).Split(new[] { '=' }, 2);
            OptionInfo option = map[parts[0]];

            if (option is null)
            {
                return(_ignoreUnkwnownArguments ? PresentParserState.MoveOnNextElement : PresentParserState.Failure);
            }

            option.IsDefined = true;

            EnsureOptionArrayAttributeIsNotBoundToScalar(option);

            bool valueSetting;

            if (!option.IsBoolean)
            {
                if (parts.Length == 1 && (argumentEnumerator.IsLast || !IsInputValue(argumentEnumerator.Next)))
                {
                    return(PresentParserState.Failure);
                }

                if (parts.Length == 2)
                {
                    if (!option.IsArray)
                    {
                        valueSetting = option.SetValue(parts[1], options);
                        if (!valueSetting)
                        {
                            DefineOptionThatViolatesFormat(option);
                        }

                        return(BooleanToParserState(valueSetting));
                    }

                    EnsureOptionAttributeIsArrayCompatible(option);

                    IList <string> items = GetNextInputValues(argumentEnumerator);
                    items.Insert(0, parts[1]);

                    valueSetting = option.SetValue(items, options);
                    if (!valueSetting)
                    {
                        DefineOptionThatViolatesFormat(option);
                    }

                    return(BooleanToParserState(valueSetting));
                }
                else
                {
                    if (!option.IsArray)
                    {
                        valueSetting = option.SetValue(argumentEnumerator.Next, options);
                        if (!valueSetting)
                        {
                            DefineOptionThatViolatesFormat(option);
                        }

                        return(BooleanToParserState(valueSetting, true));
                    }

                    EnsureOptionAttributeIsArrayCompatible(option);

                    IList <string> items = GetNextInputValues(argumentEnumerator);

                    valueSetting = option.SetValue(items, options);
                    if (!valueSetting)
                    {
                        DefineOptionThatViolatesFormat(option);
                    }

                    return(BooleanToParserState(valueSetting));
                }
            }

            if (parts.Length == 2)
            {
                return(PresentParserState.Failure);
            }

            valueSetting = option.SetValue(true, options);
            if (!valueSetting)
            {
                DefineOptionThatViolatesFormat(option);
            }

            return(BooleanToParserState(valueSetting));
        }