public object ConvertValueToExpectedType(string value, Type expectedType, IArgumentConverter converter)
{
if (value == null)
{
return(null);
}
if (expectedType == typeof(string))
{
return(value);
}
if (converter != null && converter.CanConvert(expectedType))
{
return(converter.Convert(expectedType, value));
}
foreach (var c in _argumentConverters)
{
if (c.CanConvert(expectedType))
{
return(c.Convert(expectedType, value));
}
}
throw new MissingConverterException(expectedType);
}
public OverloadResolver(IArgumentConverter argumentConverter)
{
if (argumentConverter == null)
throw new ArgumentNullException(nameof(argumentConverter));
_argumentConverter = argumentConverter;
}
/// <summary>
/// Registers an argument converter for specified type.
/// </summary>
/// <typeparam name="T">Type for which to register the converter.</typeparam>
/// <param name="converter">Converter to register.</param>
public void RegisterConverter <T>(IArgumentConverter <T> converter)
{
if (converter == null)
{
throw new ArgumentNullException(nameof(converter), "Converter cannot be null.");
}
var t = typeof(T);
var ti = t.GetTypeInfo();
this.ArgumentConverters[t] = converter;
if (!ti.IsValueType)
{
return;
}
var nullableConverterType = typeof(NullableConverter <>).MakeGenericType(t);
var nullableType = typeof(Nullable <>).MakeGenericType(t);
if (this.ArgumentConverters.ContainsKey(nullableType))
{
return;
}
var nullableConverter = Activator.CreateInstance(nullableConverterType) as IArgumentConverter;
this.ArgumentConverters[nullableType] = nullableConverter;
}
public void Setup()
{
_reflector = Substitute.For <IArgumentPropertyReflector>();
_generator = new FFmpegArgumentGenerator(_reflector);
_mockConverter = Substitute.For <IArgumentConverter>();
_mockConverter.Convert(Arg.Any <string>(), Arg.Any <object>()).Returns(x => $"{x[0]} {x[1]}");
}
/// <summary>
/// Registers an argument converter for specified type.
/// </summary>
/// <typeparam name="T">Type for which to register the converter.</typeparam>
/// <param name="converter">Converter to register.</param>
public static void RegisterConverter <T>(IArgumentConverter <T> converter)
{
if (converter == null)
{
throw new ArgumentNullException("Converter cannot be null.", nameof(converter));
}
ArgumentConverters[typeof(T)] = converter;
}
/// <summary>
/// コマンド行引数を指定された型'<typeparamref name="T"/>'へ変換します。
/// </summary>
/// <typeparam name="T">変換後のオブジェクトです。</typeparam>
/// <param name="converter">実際に変換を行うオブジェクトです。</param>
/// <param name="args">コマンド行引数の全部または一部を表す文字列配列です。</param>
/// <returns>変換結果を表す新しい指定された型'<typeparamref name="T"/>'のオブジェクトです。</returns>
/// <exception cref="System.ArgumentNullException"/>
public static T Convert <T>(this IArgumentConverter <T> converter, IEnumerable <string> args)
{
if (converter == null)
{
throw new ArgumentNullException(nameof(converter));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
return(converter.Convert(args.ToArray()));
}
public bool AddConverter(IArgumentConverter converter)
{
if (!_converter_list.Add(converter ?? throw new ArgumentNullException(nameof(converter))))
{
return(false);
}
foreach (KeyValuePair <Type, HashSet <IArgumentConverter> > kvp in _converters)
{
if (converter.GetCompatibilty(kvp.Key) == ConversionCompability.Possible)
{
kvp.Value.Add(converter);
}
}
return(true);
}
IArgumentConverter GetConverter(Type type)
{
IArgumentConverter result = DEFAULT_CONVERTER;
if (type != null)
{
result = _convertersByType.GetValueOrDefault(type)
?? Activator.CreateInstance(type) as IArgumentConverter;
}
if (result != null)
{
result.Reflector = this;
}
return(result);
}
/// <summary>Attempts to convert argument to parameter type.</summary>
/// <param name="parameter">Parameter to convert argument to.</param>
/// <param name="argIndex">Index of argument.</param>
/// <param name="values">Builder values. Must contain Args and ArgumentConverterProvider.</param>
/// <param name="result">Result of the conversion. Null if conversion failed.</param>
/// <param name="error">Exception that occured when converting. Null if there was no exception.</param>
/// <returns>True if converting was successful; otherwise false.</returns>
protected static bool TryConvertArgument(ParameterInfo parameter, int argIndex, ParameterBuilderValues values, out object result, out Exception error)
{
if (argIndex < 0)
{
throw new ArgumentException("Argument index cannot be negative", nameof(argIndex));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
error = null;
result = null;
// check if we didn't run out of args
if (values.Args == null || values.Args.Length - 1 < argIndex)
{
return(false);
}
// get from provider
IArgumentConverterProvider provider = values.ArgumentConverterProvider;
IArgumentConverter converter = provider?.GetConverter(parameter);
if (converter == null)
{
return(false);
}
try
{
result = converter.Convert(parameter, values.Args[argIndex]);
return(true);
}
catch (Exception ex)
{
error = ex;
return(false);
}
}
/// <summary>
/// Set converter
/// </summary>
/// <param name="converter">Converter instance</param>
/// <returns>Self instance</returns>
public ParameterSeriesBuilder <T> Converter(IArgumentConverter converter)
{
_converter = converter;
return(this);
}
/// <summary>
/// Registers Converter to convert argument values
/// </summary>
/// <param name="argumentConverter">Param Converter to register</param>
/// <returns>Self instance</returns>
public CliConfigurator RegisterConverter(IArgumentConverter argumentConverter)
{
_argumentConverters.Add(argumentConverter);
return(this);
}
/// <summary>
/// Set converter
/// </summary>
/// <param name="converter">Converter instance</param>
/// <returns>Self instance</returns>
public OptionBuilder <T> Converter(IArgumentConverter converter)
{
_converter = converter;
return(this);
}
public static Task <Optional <T> > ConvertAsync <T>(this IArgumentConverter <T> converter, string value, CommandContext ctx)
{
return(converter.ConvertAsync(value, ctx));
}
/// <summary>
/// Registers an argument converter for specified type.
/// </summary>
/// <typeparam name="T">Type for which to register the converter.</typeparam>
/// <param name="extensions">Extensions to register the converter on.</param>
/// <param name="converter">Converter to register.</param>
public static void RegisterConverter <T>(this IReadOnlyDictionary <int, CommandsNextExtension> extensions, IArgumentConverter <T> converter)
{
foreach (var extension in extensions.Values)
{
extension.RegisterConverter(converter);
}
}
// for argument converter provider /// <summary>Sets a fallback enum argument converter in Argument Converter Provider.</summary> /// <param name="builder">Hosted Commands Service builder.</param> /// <param name="converter">Converter to convert enums with.</param> /// <seealso cref="IArgumentConverterProvider"/> /// <seealso cref="IArgumentConverter"/> /// <seealso cref="ArgumentConverterProviderOptions.EnumConverter"/> public static IHostedCommandsServiceBuilder SetEnumArgumentConverter(this IHostedCommandsServiceBuilder builder, IArgumentConverter converter) => builder.ConfigureArgumentConverterProvider(options => options.EnumConverter = converter);
/// <summary>Maps an argument converter in Argument Converter Provider.</summary> /// <param name="builder">Hosted Commands Service builder.</param> /// <param name="parameterType">Type of parameter to set converter for.</param> /// <param name="converter">Converter to convert type with.</param> /// <seealso cref="IArgumentConverterProvider"/> /// <seealso cref="IArgumentConverter"/> /// <seealso cref="ArgumentConverterProviderOptions.Converters"/> public static IHostedCommandsServiceBuilder MapArgumentConverter(this IHostedCommandsServiceBuilder builder, Type parameterType, IArgumentConverter converter) => builder.ConfigureArgumentConverterProvider(options => options.Converters[parameterType] = converter);
/// <summary> /// Registers an argument converter for specified type. /// </summary> /// <typeparam name="T">Type for which to register the converter.</typeparam> /// <param name="converter">Converter to register.</param> public void RegisterConverter <T>(IArgumentConverter <T> converter) => CommandsNextUtilities.RegisterConverter(converter);
