protected static T Parse <T>(string value, ArgumentContext c)
{
var tt = typeof(T);
var nullable = tt.IsValueType && tt.IsGenericType &&
!tt.IsGenericTypeDefinition &&
tt.GetGenericTypeDefinition() == typeof(Nullable <>);
var targetType = nullable ? tt.GetGenericArguments()[0] : typeof(T);
var conv = TypeDescriptor.GetConverter(targetType);
var t = default(T);
try
{
if (value != null)
{
t = (T)conv.ConvertFromString(value);
}
}
catch (Exception e)
{
throw new ArgParseException(
string.Format(
c.ArgumentParser.MessageLocalizer("Could not convert string `{0}' to type {1} for Argument `{2}'."),
value, targetType.Name, c.ArgumentName),
c.ArgumentName, e);
}
return(t);
}
public void Invoke(ArgumentContext c)
{
OnParseComplete(c);
c.ArgumentName = null;
c.Argument = null;
c.ArgumentValues.Clear();
}
private static void Invoke(ArgumentContext c, string name, string value, Argument argument)
{
c.ArgumentName = name;
c.Argument = argument;
c.ArgumentValues.Add(value);
argument.Invoke(c);
}
private static void Unprocessed(ICollection <string> extra, Argument def, ArgumentContext c, string argument)
{
if (def == null)
{
extra.Add(argument);
return;
}
c.ArgumentValues.Add(argument);
c.Argument = def;
c.Argument.Invoke(c);
}
private bool ParseBool(string argument, string n, ArgumentContext c)
{
string rn;
if (n.Length < 1 || (n[n.Length - 1] != '+' && n[n.Length - 1] != '-') ||
!Contains(rn = n.Substring(0, n.Length - 1)))
{
return(false);
}
var p = this[rn];
var v = n[n.Length - 1] == '+' ? argument : null;
c.ArgumentName = argument;
c.Argument = p;
c.ArgumentValues.Add(v);
p.Invoke(c);
return(true);
}
private void ParseValue(string argument, ArgumentContext c)
{
if (argument != null)
{
foreach (var o in c.Argument.ValueSeparators != null ? argument.Split(c.Argument.ValueSeparators, c.Argument.MaxValueCount - c.ArgumentValues.Count, StringSplitOptions.None) : new[] { argument })
{
c.ArgumentValues.Add(o);
}
}
if (c.ArgumentValues.Count == c.Argument.MaxValueCount || c.Argument.ArgumentValueType == ArgumentValueType.Optional)
{
c.Argument.Invoke(c);
}
else if (c.ArgumentValues.Count > c.Argument.MaxValueCount)
{
throw new ArgParseException(MessageLocalizer(
$"Error: Found {c.ArgumentValues.Count} argument values when expecting {c.Argument.MaxValueCount}."), c.ArgumentName);
}
}
private bool ParseBundledValue(string f, string n, ArgumentContext c)
{
if (f != "-")
{
return(false);
}
for (var i = 0; i < n.Length; ++i)
{
var opt = f + n[i];
var rn = n[i].ToString();
if (!Contains(rn))
{
if (i == 0)
{
return(false);
}
throw new ArgParseException(string.Format(MessageLocalizer("Cannot use unregistered Argument '{0}' in bundle '{1}'."), rn, f + n), null);
}
var p = this[rn];
switch (p.ArgumentValueType)
{
case ArgumentValueType.None:
Invoke(c, opt, n, p);
break;
case ArgumentValueType.Optional:
case ArgumentValueType.Required:
{
var v = n.Substring(i + 1);
c.Argument = p;
c.ArgumentName = opt;
ParseValue(v.Length != 0 ? v : null, c);
return(true);
}
default:
throw new InvalidOperationException("Unknown ArgumentValueType: " + p.ArgumentValueType);
}
}
return(true);
}
protected virtual bool Parse(string argument, ArgumentContext c)
{
if (c.Argument != null)
{
ParseValue(argument, c);
return(true);
}
string f, n, s, v;
if (!GetArgumentParts(argument, out f, out n, out s, out v))
{
return(false);
}
if (!Contains(n))
{
return(ParseBool(argument, n, c) || ParseBundledValue(f, $"{n}{s}{v}", c));
}
var p = this[n];
c.ArgumentName = f + n;
c.Argument = p;
switch (p.ArgumentValueType)
{
case ArgumentValueType.None:
c.ArgumentValues.Add(n);
c.Argument.Invoke(c);
break;
case ArgumentValueType.Optional:
case ArgumentValueType.Required:
ParseValue(v, c);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(true);
}
protected abstract void OnParseComplete(ArgumentContext c);
internal ArgumentValueCollection(ArgumentContext c)
{
_c = c;
}
protected override void OnParseComplete(ArgumentContext c)
{
_action(c.ArgumentValues);
}
protected override void OnParseComplete(ArgumentContext c)
{
throw new NotSupportedException("Category.OnParseComplete should not be invoked.");
}
