private static void ApplyOption(ref RunContext ctx, IOptionToken token)
{
Option?opt = null;
if (token is ShortOptionToken shortOpt)
{
opt = ctx.Command.Options.SingleOrDefault(o => o.ShortName == shortOpt.Content);
}
else if (token is LongOptionToken longOpt)
{
opt = ctx.Command.Options.SingleOrDefault(o => o.LongName == longOpt.Content);
}
if (opt == null)
{
throw new RunException($"Unknown option at position {token.Position}");
}
if (!TryTakeValue(ref ctx, opt.ValueType, out var value))
{
if (opt.ValueType == typeof(bool))
{
value = true;
}
else
{
throw new RunException($"Expected value at position {ctx.Tokens.PeekOrDefault()?.Position}");
}
}
ValueSetter.SetValue(ctx.OptionsObj, opt.MemberExpression, value);
}
/// <summary>
/// Checks if given token matches current option.
/// </summary>
/// <param name="token">The token to match.</param>
/// <returns>True, if given token matches this option; false otherwise.</returns>
public bool MatchToken(IOptionToken token)
{
return(token switch
{
ShortOptionToken sToken => MatchToken(sToken),
LongOptionToken lToken => MatchToken(lToken),
_ => false,
});
public void AppendOptionToken(IOptionToken optionToken, string argument)
{
bool handled = AppendFlag(optionToken, argument) || AppendKeyValueOption(optionToken);
if (!handled)
{
throw new ArgParsingException(ArgsParsingErrorCode.UnknownOptionType, argument);
}
}
bool AppendFlag(IOptionToken optionToken, string argument)
{
if (optionToken.Definition.Type != OptionType.Flag)
{
return(false);
}
if (flags.ContainsKey(optionToken.Definition))
{
throw new ArgParsingException(
ArgsParsingErrorCode.DuplicateFlagsInArgs,
argument);
}
flags.Add(optionToken.Definition, true);
return(true);
}
bool AppendKeyValueOption(IOptionToken optionToken)
{
if (optionToken.Definition.Type != OptionType.KeyValue)
{
return(false);
}
if (keyValues.ContainsKey(optionToken.Definition))
{
keyValues[optionToken.Definition].Add(optionToken.Value);
}
else
{
keyValues[optionToken.Definition] =
new List <string> {
optionToken.Value
};
}
return(true);
}
private static void ApplyOption(ref RunContext ctx, IOptionToken token)
{
Option?opt = null;
if (token is ShortOptionToken shortOpt)
{
opt = ctx.Command.Options.SingleOrDefault(o => o.ShortName == shortOpt.Content);
}
else if (token is LongOptionToken longOpt)
{
opt = ctx.Command.Options.SingleOrDefault(o => o.LongName == longOpt.Content);
}
if (opt == null)
{
throw new RunException($"Unknown option at position {token.Position}");
}
var propertyType = opt.ValueType;
bool isList = false;
if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(IList <>))
{
propertyType = propertyType.GetGenericArguments()[0];
isList = true;
}
if (!TryTakeValue(ref ctx, propertyType, out var value))
{
if (opt.ValueType == typeof(bool))
{
value = true;
}
else
{
throw new RunException($"Expected value at position {ctx.Tokens.PeekOrDefault()?.Position}");
}
}
ValueSetter.SetValue(ctx.OptionsObj, opt.MemberExpression, value, isList);
}
public void AddOption(IOptionToken token)
{
var info = GetOptionInfo(token);
if (info.IsCollection)
{
assignedOptions.Add(
new CollectionOptionParser(info, info.ChooseConverter(convertersFactory) as CollectionConverter, token));
}
else if (assignedOptions.Exists(p => p.OptionToken.Equals(token)))
{
throw new ArgumentException("This option was already declared.");
}
else if (info.IsImplicit)
{
assignedOptions.Add(
new ImplicitOptionParser(info, info.ChooseConverter(convertersFactory) as IValueConverter, token));
}
else
{
assignedOptions.Add(
new SingleValueOptionParser(info, info.ChooseConverter(convertersFactory) as IValueConverter, token));
}
}
public ImplicitOptionParser(ParsingArgumentInfo argumentInfo, IValueConverter valueConverter, IOptionToken optionToken)
: base(argumentInfo, valueConverter, optionToken)
{
}
private ParsingOptionInfo GetOptionInfo(IOptionToken token)
=> typeInfo.GetMatchingOptionInfo(token)
?? throw new ArgumentException($"This type does not contain the {token} option.", nameof(token));
protected void HandleOption(IOptionToken token)
{
EnsureLastOptionSet();
builder.AddOption(token);
}
public SingleValueOptionParser(ParsingArgumentInfo argumentInfo, IValueConverter valueConverter, IOptionToken optionToken) : base(argumentInfo, valueConverter)
{
OptionToken = optionToken ?? throw new ArgumentNullException(nameof(optionToken));
}
public AssignedValueToken(IOptionToken option, IValueToken value)
{
Option = option;
Value = value;
}
public CollectionOptionParser(ParsingArgumentInfo argumentInfo, CollectionConverter converter, IOptionToken optionToken)
: base(argumentInfo, converter)
{
OptionToken = optionToken;
}
/// <summary> /// Gets <see cref="ParsingOptionInfo"/> that matches the given token. /// </summary> /// <param name="token">Token to be matched.</param> /// <returns><see cref="ParsingOptionInfo"/> that matches the given token.</returns> public ParsingOptionInfo GetMatchingOptionInfo(IOptionToken token) => Options.SingleOrDefault(x => x.MatchToken(token));
