public T GetParameter <T>(string parameterName, TryParseDelegate <T> tryParseDelegate)
{
byte tries = 0;
T result = default(T);
bool success = false;
do
{
Console.Write($"Please enter {parameterName}: ");
string readValue = Console.ReadLine();
success = tryParseDelegate(readValue, out result);
} while (tries++ < MaxRetries && !success);
return(result);
}
private static T Parse <T>(string value, TryParseDelegate <T> tryParse)
where T : struct
{
if (string.IsNullOrWhiteSpace(value))
{
throw new ParseException("No value was provided.");
}
if (tryParse(value, out var parsed))
{
return(parsed);
}
throw new ParseException($"Unable to parse value '{value}' as '{typeof(T).Name}'.");
}
private bool GetTagValue <T>(TestClassGenerationContext generationContext, Scenario scenario, string retryTag,
TryParseDelegate <T> parser, out T value)
{
value = default(T);
var tagNames = scenario.Tags?.Select(_ => _.GetNameWithoutAt()) ?? new string[0];
tagNames = tagNames.ToList();
string retryCountValue;
return(_tagFilterMatcher.GetTagValue(retryTag, tagNames, out retryCountValue) &&
parser(retryCountValue, out value) ||
_tagFilterMatcher.GetTagValue(retryTag, generationContext.Document, out retryCountValue) &&
parser(retryCountValue, out value));
}
public static GenericRouteParameterType Create <T>(string partRegex, TryParseDelegate <T> parser)
{
return(new GenericRouteParameterType(s => partRegex, (s, p) =>
{
T r;
if (parser(s, out r))
{
return ParameterParseResult.Create((object)r);
}
else
{
return ParameterParseResult.Failed;
}
}));
}
public static T ValueAs <T>(this XElement element, TryParseDelegate <T> parseDelegate, T defaultValue)
{
if (null == element)
{
return(defaultValue);
}
T result;
bool ok = parseDelegate(element.Value, out result);
if (ok)
{
return(result);
}
return(defaultValue);
}
static TryParseMarshaller()
{
var type = typeof(T);
try
{
TRY_PARCE = (TryParseDelegate)type
.GetMethod("TryParse")
.CreateDelegate(typeof(TryParseDelegate));
}
catch
{
throw new NotSupportedException($"Тип: {typeof(T).Name} не содержит в себе метода bool TryParse(string, out T)");
}
}
private bool TryGetValue <T>(string name, TryParseDelegate <T> parseDelegate, out T result)
{
string s;
result = default(T);
if (!internalCache.TryGetValue(name, out s))
{
return(false);
}
if (!parseDelegate(s, out result))
{
throw new FormatException(string.Format("Key '{0}': '{1}' is not a value of type {2}", name, s,
typeof(T).Name));
}
return(true);
}
public EnumTypeParser(Type enumType, CommandService service)
{
_tryParse = (TryParseDelegate <T>)Utilities.TryParseDelegates[typeof(T)];
var names = Enum.GetNames(enumType);
_enumByNames = new Dictionary <string, object>(names.Length, service.StringComparer);
_enumByValues = new Dictionary <T, object>();
for (var i = 0; i < names.Length; i++)
{
var name = names[i];
var value = Enum.Parse(enumType, name);
_enumByNames[name] = value;
_enumByValues[(T)value] = value;
}
}
public static GenericRouteParameterType Create <T>(string partRegex, TryParseDelegate <T> parser)
{
return(new GenericRouteParameterType(s => partRegex, (s, p) =>
{
#pragma warning disable CS8717
if (parser(s, out var r))
{
return ParameterParseResult.Create((object)r !);
}
#pragma warning restore CS8717
else
{
return ParameterParseResult.Failed;
}
}));
}
/// <summary>
/// Gets the parsed value or null.
/// </summary>
/// <typeparam name="T">The type to try parse.</typeparam>
/// <param name="value">a String</param>
/// <param name="parser">a delegate of: bool f(string, out T)</param>
/// <returns>T or null</returns>
public static T?AsNullableOf <T>(this string value, TryParseDelegate <T> parser) where T : struct
{
T?result;
T _t;
if (parser(value, out _t))
{
result = _t;
}
else
{
result = null;
}
return(result);
}
static Parser()
{
var method = HarmonyLib.AccessTools.Method(typeof(T), "TryParse");
if (method == null)
{
return;
}
var outValue = Expression.Parameter(typeof(T).MakeByRefType());
var stringValue = Expression.Parameter(typeof(string));
tryParse = Expression.Lambda <TryParseDelegate>(
Expression.Call(method, stringValue, outValue),
stringValue,
outValue
).Compile();
}
public static T?ToNullablePrimitive <T>(this string data,
TryParseDelegate <T> func) where T : struct
{
if (string.IsNullOrEmpty(data))
{
return(null);
}
T output;
if (func(data, out output))
{
return((T?)output);
}
return(null);
}
public virtual T Get <T>(string key, TryParseDelegate <T> tryParse, T defaultvalue)
{
if (Contains(key))
{
var value = Get(key);
if (tryParse(value, out var result))
{
return(result);
}
return(defaultvalue);
}
else
{
return(defaultvalue);
}
}
public T GetQueryParam <T>(string key, TryParseDelegate <T> parseDelegate, T defaultVal = default(T))
{
string value = GetQueryParam(key);
if (value == null)
{
return(defaultVal);
}
T retVal;
if (!parseDelegate(value, out retVal))
{
return(defaultVal);
}
return(retVal);
}
/// <summary>
/// Registers the current try parser and its nullable form so it can be used upon request.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tryParser"></param>
public void RegisterNullable <T>(TryParseDelegate <T> tryParser) where T : struct
{
_TryParsers.Add(typeof(T), tryParser);
_TryParsers.Add(typeof(T?), new TryParseDelegate <T?>((string s, out T? result) =>
{
//If the value passed in is null, allow that since this is a nullable type.
if (s == null)
{
result = null;
return(true);
}
//Otherwise, only allow successfully parsed values
var success = tryParser(s, out var temp);
result = success ? (T?)temp : null;
return(success);
}));
}
/// <summary>
/// Convert the given string to the specified type.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The source string.</param>
/// <param name="parseFunc">The parse function used to parse the string.</param>
/// <returns>specified type</returns>
private static T?To <T>(string source, TryParseDelegate <T> parseFunc) where T : struct
{
if (source.IsNullOrEmpty())
{
return(null);
}
else
{
var parseSucceeded = parseFunc(source, out T output);
if (parseSucceeded)
{
return((T?)output);
}
else
{
return(null);
}
}
}
}//end method
//does an operation aggregating the entire line
public static Nullable <T> LineOperation <T>(this TextFieldParser parser,
TryParseDelegate <String, T> func, OperationToPreform <T> operation,
int start, int end) where T : struct
{
Nullable <T> aggregation = new T();
T result = new T();
String[] toks = parser.ReadFields();
if (start < 1)
{
throw new ArgumentException("Starting column is less than one. "
+ "Column numbers start at one. ");
}
if (end < start)
{
throw new ArgumentException("End column is less than the starting column. ");
}
if (toks != null)
{
for (int i = start - 1; i < toks.Length && toks[i] != "" && i < end; i++)
{
if (func.Invoke(toks[i], out result))
{
aggregation = operation.Invoke(aggregation.Value, result);
}
else
{
throw new IOException(typeof(T).Name + " data not found in file line "
+ (parser.LineNumber - 1) + " column " + (i + 1));
}
//At this point have read one line past where we were, so LineNumber - 1
} //end loop
} //end if
else
{
return(null);
}
return(aggregation);
}//end method
private static T?TryParse <T>(string value, TryParseDelegate <T> tryParse, bool throwExceptionOnInvalid)
where T : struct
{
if (string.IsNullOrWhiteSpace(value))
{
return(null);
}
if (tryParse(value, out var parsed))
{
return(parsed);
}
if (throwExceptionOnInvalid)
{
throw new ParseException($"Unable to parse value '{value}' as '{typeof(T).Name}'.");
}
return(null);
}
public IConverter <string, TOutput> TryCreate <TOutput>()
{
// bool succeeded = TOutput.TryParse(string input, out TOutput result);
MethodInfo tryParseMethod = typeof(TOutput).GetMethod("TryParse", BindingFlags.Public | BindingFlags.Static,
null, new[] { typeof(string), typeof(TOutput).MakeByRefType() }, null);
// Can't convert for the following close non-matches (don't match TryParseDelegate<TOutput>):
// *<non-bool>* TryParse(string input, out TOutput result)
// bool TryParse(string input, *ref* TOutput result)
if (tryParseMethod == null || tryParseMethod.ReturnType != typeof(bool) ||
!tryParseMethod.GetParameters()[1].IsOut)
{
return(null);
}
TryParseDelegate <TOutput> tryParseDelegate =
(TryParseDelegate <TOutput>)Delegate.CreateDelegate(typeof(TryParseDelegate <TOutput>), tryParseMethod);
return(new TryParseStringToTConverter <TOutput>(tryParseDelegate));
}
private static T ReadFromConsole <T>(TryParseDelegate <T> tryParseMethod, string errorMessage)
{
bool inputSuccess = false;
T parsedValue;
do
{
string input = Console.ReadLine();
if (tryParseMethod(input, out parsedValue))
{
inputSuccess = true;
}
else
{
Console.WriteLine(errorMessage);
}
}while (!inputSuccess);
return(parsedValue);
}
public EnumTypeParser(Type enumType, bool ignoreCase)
{
_tryParse = (TryParseDelegate <T>)ReflectionUtilities.TryParseDelegates[typeof(T)];
var names = Enum.GetNames(enumType);
_enumByNames = new Dictionary <string, object>(names.Length, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
_enumByValues = new Dictionary <T, object>();
for (var i = 0; i < names.Length; i++)
{
var name = names[i];
var value = Enum.Parse(enumType, name);
_enumByNames.Add(name, value);
if (!_enumByValues.ContainsKey((T)value))
{
_enumByValues.Add((T)value, value);
}
}
}
public static T ParseValue <T>(ConfigNode node, string valueName, TryParseDelegate <T> tryParse, bool isOptional = false, T defaultValue = default)
{
string valueString = node.GetValue(valueName);
if (isOptional)
{
if (string.IsNullOrEmpty(valueString))
{
return(defaultValue);
}
}
else
{
if (valueString == null)
{
throw new FormatException($"Missing {typeof(T)} value for {valueName}");
}
if (valueString == string.Empty)
{
throw new FormatException($"Empty {typeof(T)} value for {valueName}");
}
}
if (tryParse(valueString, out var value))
{
return(value);
}
if (isOptional)
{
return(defaultValue);
}
else
{
throw new FormatException($"Improperly formatted {typeof(T)} value for {valueName} : '{valueString}");
}
}
/// <summary>
/// Converts the string representation of a number to its <see cref="Rational<T>"/> equivalent.
/// A return value indicates whether the conversion succeeded or failed.
/// </summary>
/// <param name="value"></param>
/// <param name="rational"></param>
/// <returns></returns>
public static bool TryParse(string value, out Rational <T> rational)
{
if (string.IsNullOrEmpty(value))
{
rational = Empty;
return(false);
}
if (TryParser == null)
{
TryParser = BuildTryParser();
}
T numerator, denominator;
string[] parts = value.Split(DelimSet, 2, StringSplitOptions.RemoveEmptyEntries);
if (!TryParser(parts[0], out numerator))
{
rational = Empty;
return(false);
}
if (parts.Length > 1)
{
if (!TryParser(parts[1], out denominator))
{
rational = Empty;
return(false);
}
}
else
{
denominator = default(T);
}
rational = new Rational <T>(numerator, denominator);
return(parts.Length == 2);
}
private static TryParseDelegate <T?> SupportNullable(TryParseDelegate <T> parser)
{
return(TryParseNullable);
bool TryParseNullable(ReadOnlySpan <char> value, [MaybeNullWhen(false)] out T?result)
{
if (value.IsEmpty)
{
result = default;
return(true);
}
else if (parser(value, out var parsedValue))
{
result = parsedValue;
return(true);
}
else
{
result = default;
return(false);
}
}
}
public EnumTypeParser(Type enumType, bool ignoreCase)
{
_tryParse = (TryParseDelegate <T>)TypeParserUtils.TryParseDelegates[typeof(T)];
var enumValuesByNames = ImmutableDictionary.CreateBuilder <string, object>(ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
var enumValuesByValues = ImmutableDictionary.CreateBuilder <T, object>();
var names = Enum.GetNames(enumType);
for (var i = 0; i < names.Length; i++)
{
var name = names[i];
var value = Enum.Parse(enumType, name, ignoreCase);
enumValuesByNames.Add(name, value);
if (!enumValuesByValues.ContainsKey((T)value))
{
enumValuesByValues.Add((T)value, value);
}
}
_enumByNames = enumValuesByNames.ToImmutable();
_enumByValues = enumValuesByValues.ToImmutable();
}
private static TryParseDelegate GetParser()
{
if (s_deleCache != null)
{
return(s_deleCache);
}
var type = typeof(T);
var s = Expression.Parameter(typeof(string));
var refType = type.MakeByRefType();
var result = Expression.Parameter(refType);
var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Public | BindingFlags.Static, null, new[] { s.Type, refType }, null);
if (tryParseMethod == null)
{
throw new MissingMethodException(type.FullName, "TryParse");
}
var caller = Expression.Call(tryParseMethod, s, result) as Expression;
s_deleCache = Expression.Lambda <TryParseDelegate>(caller, s, result).Compile();
return(s_deleCache);
}
public Utf8DictionaryKeyConverter()
{
MethodInfo?tryParseMethod = typeof(Utf8Parser).GetMethod(
nameof(Utf8Parser.TryParse),
new[] { typeof(ReadOnlySpan <byte>), typeof(T).MakeByRefType(), typeof(int).MakeByRefType(), typeof(char) });
if (tryParseMethod == null)
{
throw new JsonException($"Cannot find method Utf8Parser.TryParse for type {typeof(T)}");
}
_tryParseFunc = (TryParseDelegate)tryParseMethod.CreateDelegate(typeof(TryParseDelegate));
MethodInfo?tryFormatMethod = typeof(Utf8Formatter).GetMethod(
nameof(Utf8Formatter.TryFormat),
new[] { typeof(T), typeof(Span <byte>), typeof(int).MakeByRefType(), typeof(StandardFormat) });
if (tryFormatMethod == null)
{
throw new JsonException($"Cannot find method Utf8Parser.TryFormat for type {typeof(T)}");
}
_tryFormatFunc = (TryFormatDelegate)tryFormatMethod.CreateDelegate(typeof(TryFormatDelegate));
}
public static Func <string[], Tuple <T1> > CreateToTuple <T1>(TryParseDelegate <T1> converter1)
{
Contract.Requires <ArgumentNullException>(converter1 != null, "converter1");
Contract.Ensures(Contract.Result <Func <string[], Tuple <T1> > >() != null);
return((s) =>
{
if (s.Length != 1)
{
return null;
}
T1 t1;
if (!converter1(s[0], out t1))
{
return null;
}
return Tuple.Create(t1);
});
}
public HeaderTypeInfo(string name, TryParseDelegate <T> parser, HttpHeaderKind headerKind)
: base(name, headerKind)
{
this.parser = parser;
}
public static HeaderInfo CreateSingle <T> (string name, TryParseDelegate <T> parser, HttpHeaderKind headerKind)
{
return(new HeaderTypeInfo <T, object> (name, parser, headerKind));
}
