public static FunctionalParser <TInput, TSourceState, TResultState> Create <TInput, TSourceState, TResultState>(
ParseFunc <TInput, TSourceState, TResultState> func,
TInput lookAhead
)
{
return(new FunctionalParser <TInput, TSourceState, TResultState>(func, lookAhead));
}
private IParser <T> ApplyOptionsAndGetValueTypeParserObject <T>(ParseFunc <T> parseFunc, TryParseFunc <T> tryParseFunc, MissingTryParseHandling missingTryParse)
where T : struct
{
if (parseFunc is null)
{
return(new FunctorParserObject <T>(ParseThrowsNotSupportedException <T>, TryParseThrowsNotSupportedException));
}
ParseFunc <T> valueTypeParseFunc = parseFunc; // Just keeping with the pattern.
TryParseFunc <T> valueTypeTryParseFunc = tryParseFunc;
if (tryParseFunc is null)
{
if (missingTryParse == MissingTryParseHandling.WrapParseInTryCatch)
{
valueTypeTryParseFunc = CreateWrapperForTryParse(valueTypeParseFunc);
}
else if (missingTryParse == MissingTryParseHandling.ReturnFalse)
{
valueTypeTryParseFunc = TryParseReturnsFalse;
}
else
{
valueTypeTryParseFunc = TryParseThrowsNotSupportedException;
}
}
return(new FunctorParserObject <T>(valueTypeParseFunc, valueTypeTryParseFunc));
}
/// <summary>
/// 获取配置文件appSettings集合中指定索引的值
/// </summary>
/// <typeparam name="T">返回值类型参数</typeparam>
/// <param name="key">索引键</param>
/// <param name="parseValue">将指定索引键的值转化为返回类型的值的委托方法</param>
/// <param name="defaultValue">默认值</param>
/// <returns></returns>
private static T getValue <T>(string key, ParseFunc <string, T> parseValue, T?defaultValue) where T : struct
{
string value = appSettings[key];
if (value != null)
{
T parsedValue = default(T);
if (parseValue(value, out parsedValue))
{
return(parsedValue);
}
else
{
throw new ApplicationException(string.Format("Settings '{0}' was not a valid {1}", key, typeof(T).FullName));
}
}
if (!defaultValue.HasValue)
{
throw new ApplicationException("在配置文件的appSettings节点集合中找不到key为" + key + "的子节点，且没有指定默认值");
}
else
{
return(defaultValue.Value);
}
}
public Command(String device, String cmd, String apkPath,
ParseFunc parse)
{
Device = device;
Cmd = cmd;
ApkPath = apkPath;
Parse = parse;
}
public LogIndex(string Name, ParseFunc Parse)
{
CsvIndex = -1;
Index = -1;
this.Name = Name;
this.Parse = Parse;
}
private IParser <T> ApplyOptionsAndGetReferenceTypeParserObject <T>(ParseFunc <T> parseFunc, TryParseFunc <T> tryParseFunc, MissingTryParseHandling missingTryParse)
where T : class
{
if (parseFunc is null)
{
return(new FunctorParserObject <T>(ParseThrowsNotSupportedException <T>, TryParseThrowsNotSupportedException));
}
ParseFunc <T> referenceTypeParseFunc = parseFunc;
TryParseFunc <T> referenceTypeTryParseFunc = tryParseFunc;
if (_referenceTypesParseNullToNull)
{
referenceTypeParseFunc = s =>
{
if (s is null)
{
return(null);
}
return(parseFunc(s));
};
}
if (tryParseFunc is null)
{
if (missingTryParse == MissingTryParseHandling.WrapParseInTryCatch)
{
referenceTypeTryParseFunc = CreateWrapperForTryParse(referenceTypeParseFunc);
}
else if (missingTryParse == MissingTryParseHandling.ReturnFalse)
{
referenceTypeTryParseFunc = TryParseReturnsFalse;
}
else
{
referenceTypeTryParseFunc = TryParseThrowsNotSupportedException;
}
}
else
{
if (_referenceTypesParseNullToNull)
{
referenceTypeTryParseFunc = (string s, out T result) =>
{
if (s is null)
{
result = null;
return(true);
}
return(tryParseFunc(s, out result));
};
}
}
return(new FunctorParserObject <T>(referenceTypeParseFunc, referenceTypeTryParseFunc));
}
SheetInfo CreateSheetInfo <K, V>(BuildFunc buildFunc, ParseFunc parseFunc = null) where V : AssetData <K>
{
var si = new SheetInfo();
si.sheetname = typeof(V).Name;
si.buildFunc = buildFunc;
si.parseFunc = null != parseFunc ? parseFunc : this.ParseFromCsv <K, V>;
return(si);
}
public void T_2()
{
var fp = new ParseFunc[]{
ThrowSt.Singleton()
};
var input = @"throw new Exception(@""hoge"");";
var expect = new String[]{
@"throw new Exception(@""hoge"");",
};
TestUtils.Eq(fp, input, expect);
}
public void T_06()
{
var fp = new ParseFunc[]{
AssignSt.Singleton()
};
var input = @"x %= 1 + 4 + f(4, g());";
var expect = new String[]{
@"x %= 1 + 4 + f(4, g());",
};
TestUtils.Eq(fp, input, expect);
}
public void T_3()
{
var fp = new ParseFunc[]{
CaseSt.Singleton()
};
var input = @" case Hoge.Foo :";
var expect = new String[]{
@"case Hoge.Foo:",
};
TestUtils.Eq(fp, input, expect);
}
public void T_06()
{
var fp = new ParseFunc[]{
ExprSt.Singleton()
};
var input = @"8 + (8 - 8);";
var expect = new String[]{
@"8 + (8 - 8);",
};
TestUtils.Eq(fp, input, expect);
}
public void T_05()
{
var fp = new ParseFunc[]{
ExprSt.Singleton()
};
var input = @"8 + 8 - 8 * 8 / 8 < 8 > 8 << 8 >> 8 % 8 & 8 && 8 || 8 | 8;";
var expect = new String[]{
@"8 + 8 - 8 * 8 / 8 < 8 > 8 << 8 >> 8 % 8 & 8 && 8 || 8 | 8;",
};
TestUtils.Eq(fp, input, expect);
}
public void T_endif()
{
var fp = new ParseFunc[]{
DirectiveIfSt.Singleton()
};
var input = @"#endif";
var expect = new String[]{
@"#endif",
};
TestUtils.Eq(fp, input, expect);
}
public void T_06()
{
var fp = new ParseFunc[]{
DefineLocalVariableSt.Singleton()
};
var input = @"List<String, List<String, List<String, String>>> a = new List<String, List<String, List<String, String>>>();";
var expect = new String[]{
@"List<String, List<String, List<String, String>>> a = new List<String, List<String, List<String, String>>>();",
};
TestUtils.Eq(fp, input, expect);
}
public void T_2()
{
var fp = new ParseFunc[]{
ReturnSt.Singleton()
};
var input = @"return new String[]{};";
var expect = new String[]{
@"return new String[]{};",
};
TestUtils.Eq(fp, input, expect);
}
public void T_2()
{
var fp = new ParseFunc[]{
BreakSt.Singleton()
};
var input = @"yield break;";
var expect = new String[]{
@"yield break;",
};
TestUtils.Eq(fp, input, expect);
}
public void T_1()
{
var fp = new ParseFunc[]{
ThrowSt.Singleton()
};
var input = @"throw;";
var expect = new String[]{
@"throw;",
};
TestUtils.Eq(fp, input, expect);
}
public static List <T> ParseList <T>(ParseFunc <T> parse, string value)
{
List <T> res = new List <T>();
List <string> values = ParseType(value); //value.Split(";");
for (int i = 0; i < values.Count; i++)
{
res.Add(parse(values[i]));
}
return(res);
}
public void T_Alias_2()
{
var fp = new ParseFunc[]{
UsingSt.Singleton()
};
var input = @" using A = NUnit.Framework;";
var expect = new String[]{
@"using A = NUnit.Framework;",
};
TestUtils.Eq(fp, input, expect);
}
public void T_Alias_3()
{
var fp = new ParseFunc[]{
UsingSt.Singleton()
};
var input = @" using A = System.IO.Path;";
var expect = new String[]{
@"using A = System.IO.Path;",
};
TestUtils.Eq(fp, input, expect);
}
public void T_05()
{
var fp = new ParseFunc[]{
AttributeSt.Singleton()
};
var input = @"[assembly:DllImport(""msvcrt.dll"")]";
var expect = new String[]{
@"[assembly: DllImport(""msvcrt.dll"")]",
};
TestUtils.Eq(fp, input, expect);
}
public void T1()
{
var fp = new ParseFunc[]{
UsingSt.Singleton()
};
var input = @" using System;";
var expect = new String[]{
@"using System;",
};
TestUtils.Eq(fp, input, expect);
}
public void T_04()
{
var fp = new ParseFunc[]{
AttributeSt.Singleton()
};
var input = @"[Conditional(""DEBUG""),Conditional(""TEST"")]";
var expect = new String[]{
@"[Conditional(""DEBUG""), Conditional(""TEST"")]",
};
TestUtils.Eq(fp, input, expect);
}
public void T_1()
{
var fp = new ParseFunc[]{
DefaultSt.Singleton()
};
var input = @"default:";
var expect = new String[]{
@"default:",
};
TestUtils.Eq(fp, input, expect);
}
private IParser <T> AltCreateParserObject <T>(ParseFunc <T> parseFunc, TryParseFunc <T> tryParseFunc, MissingTryParseHandling missingTryParse)
{
Type type = typeof(T);
string methodName = type.GetTypeInfo().IsValueType ? nameof(ApplyOptionsAndGetValueTypeParserObject) : nameof(ApplyOptionsAndGetReferenceTypeParserObject);
MethodInfo factoryMethod = ReflectionHelper.GetPrivateGenericMethod(typeof(ParserContainer), methodName, type);
Func <ParseFunc <T>, TryParseFunc <T>, MissingTryParseHandling, IParser <T> > factory = factoryMethod.CreateDelegate <Func <ParseFunc <T>, TryParseFunc <T>, MissingTryParseHandling, IParser <T> > >(this);
return(factory(parseFunc, tryParseFunc, missingTryParse));
}
public void T_04()
{
var fp = new ParseFunc[]{
DefineLocalVariableSt.Singleton()
};
var input = @"var str = @""hi"";";
var expect = new String[]{
@"var str = @""hi"";",
};
TestUtils.Eq(fp, input, expect);
}
public void T_02()
{
var fp = new ParseFunc[]{
AttributeSt.Singleton()
};
var input = @"[return:0]";
var expect = new String[]{
@"[return: 0]",
};
TestUtils.Eq(fp, input, expect);
}
public void T_3()
{
var fp = new ParseFunc[]{
UsingBlockSt.Singleton()
};
var input = @" using (var a = new String[]{} ) idx++; ";
var expect = new String[]{
@"using (var a = new String[]{})",
@" idx++;",
};
TestUtils.Eq(fp, input, expect);
}
public void T_3()
{
var fp = new ParseFunc[]{
WhileSt.Singleton()
};
var input = @" while ( idx < 10 ) idx++; ";
var expect = new String[]{
@"while (idx < 10)",
@" idx++;",
};
TestUtils.Eq(fp, input, expect);
}
public static void Eq(ParseFunc[] pf, String input, String[] expect)
{
var psr = new Parser(Lexer.LexerString(input));
var result = psr.Evalute(pf);
var joinedExpect = @"";
foreach (var line in expect)
{
joinedExpect += line + "\n";
}
Assert.AreEqual(result.Output, joinedExpect);
Assert.True(result.Success);
}
public NumberParser(Type fieldType)
{
if (fieldType == typeof(int))
{
parseFunction = (string input, out object value) => { int parsedVal; bool result = int.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (int)value1 == (int)value2;
}
else if (fieldType == typeof(uint))
{
parseFunction = (string input, out object value) => { uint parsedVal; bool result = uint.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (uint)value1 == (uint)value2;
}
else if (fieldType == typeof(long))
{
parseFunction = (string input, out object value) => { long parsedVal; bool result = long.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (long)value1 == (long)value2;
}
else if (fieldType == typeof(ulong))
{
parseFunction = (string input, out object value) => { ulong parsedVal; bool result = ulong.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (ulong)value1 == (ulong)value2;
}
else if (fieldType == typeof(byte))
{
parseFunction = (string input, out object value) => { byte parsedVal; bool result = byte.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (byte)value1 == (byte)value2;
}
else if (fieldType == typeof(sbyte))
{
parseFunction = (string input, out object value) => { sbyte parsedVal; bool result = sbyte.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (sbyte)value1 == (sbyte)value2;
}
else if (fieldType == typeof(short))
{
parseFunction = (string input, out object value) => { short parsedVal; bool result = short.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (short)value1 == (short)value2;
}
else if (fieldType == typeof(ushort))
{
parseFunction = (string input, out object value) => { ushort parsedVal; bool result = ushort.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (ushort)value1 == (ushort)value2;
}
else if (fieldType == typeof(char))
{
parseFunction = (string input, out object value) => { char parsedVal; bool result = char.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (char)value1 == (char)value2;
}
else
{
parseFunction = null;
equalsFunction = null;
}
}
public void T_05()
{
var fp = new ParseFunc[]{
ForSt.Singleton()
};
var input = @" for(; idx < 10;) idx++; ";
var expect = new String[]{
@"for (; idx < 10;)",
@" idx++;",
};
TestUtils.Eq(fp, input, expect);
}
public void T_00()
{
var fp = new ParseFunc[]{
ClassMethodSt.Singleton()
};
var input = @"private static void F([MarshalAs(UnmanagedType.LPStr)]Dictionary<List<String>,Tuple<List<String>,Int32>> ttt){}";
var expect = new String[]{
@"private static void F([MarshalAs(UnmanagedType.LPStr)] Dictionary<List<String>, Tuple<List<String>, Int32>> ttt)",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
public static bool TryParse <T>(string value, ParseFunc <T> parser, out T result)
{
try
{
result = parser(value);
return(true);
}
catch
{
result = default(T);
return(false);
}
}
public void T_2()
{
var fp = new ParseFunc[]{
IfSt.Singleton()
};
var input = @" if(true ) {} ";
var expect = new String[]{
@"if (true)",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
public void T_03()
{
var fp = new ParseFunc[]{
ForSt.Singleton()
};
var input = @" for( idx = 0; idx < 10;) { } ";
var expect = new String[]{
@"for ( idx = 0; idx < 10;)",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
protected TOut TryGetAttributeValue <TOut>(XmlElement element, string name, ParseFunc <TOut> tryParse, TOut defaultValue = default(TOut))
{
TOut result;
var attrValue = element.GetAttribute(name);
if (!string.IsNullOrEmpty(attrValue) && tryParse(attrValue, out result))
{
return(result);
}
return(defaultValue);
}
public void T_01()
{
var fp = new ParseFunc[]{
ClassMethodSt.Singleton()
};
var input = @"private Dictionary<List<String>,Tuple<List<String>,Int32>> F(){}";
var expect = new String[]{
@"private Dictionary<List<String>, Tuple<List<String>, Int32>> F()",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
public void T_04()
{
var fp = new ParseFunc[]{
ClassMethodSt.Singleton()
};
var input = @"private String Hoge(Int32 a, Boolean b){}";
var expect = new String[]{
@"private String Hoge(Int32 a, Boolean b)",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
// Check text of a TextBox by specified Double parser, and render color of the text.
public static void TextBoxCheckByParserDouble(object sender, ParseFunc <string, Double> parser)
{
TextBox tb = sender as TextBox;
if (parser(tb.Text, out _))
{
tb.ForeColor = Color.Black;
}
else
{
tb.ForeColor = Color.Red;
}
}
public void T_1()
{
var fp = new ParseFunc[]{
NamespaceSt.Singleton()
};
var input = @" namespace Hoge . Foo { } ";
var expect = new String[]{
@"namespace Hoge.Foo",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
private IParser <T> GetReferenceTypeParserObject <T>()
where T : class
{
if (typeof(T) == typeof(string))
{
return((IParser <T>) new StringParser());
}
ParseFunc <T> parseFunc = GetDefaultParseFunc <T>();
TryParseFunc <T> tryParseFunc = GetDefaultTryParseFunc <T>();
return(ApplyOptionsAndGetReferenceTypeParserObject(parseFunc, tryParseFunc, _missingTryParse));
}
public void T_2()
{
var fp = new ParseFunc[]{
UnsafeSt.Singleton()
};
var input = @"unsafe{}";
var expect = new String[]{
@"unsafe",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
public void T_01()
{
var fp = new ParseFunc[]{
EnumSt.Singleton()
};
var input = @"public enum Hoge{}";
var expect = new String[]{
@"public enum Hoge",
@"{",
@"}",
};
TestUtils.Eq(fp, input, expect);
}
private IParser <T?> GetNullableValueTypeParserObject <T>()
where T : struct
{
IParser <T> valueTypeParser = (IParser <T>)ForInternal(typeof(T));
ParseFunc <T?> parseFunc = s =>
{
if (s is null)
{
if (_nullableValueTypesParseNullToNull)
{
return(null);
}
}
else if (s.Length == 0)
{
if (_nullableValueTypesParseEmptyStringToNull)
{
return(null);
}
}
return(valueTypeParser.Parse(s));
};
TryParseFunc <T?> tryParseFunc = (string s, out T? result) =>
{
if (s is null)
{
if (_nullableValueTypesParseNullToNull)
{
result = null;
return(true);
}
}
else if (s.Length == 0)
{
if (_nullableValueTypesParseEmptyStringToNull)
{
result = null;
return(true);
}
}
bool returnValue = valueTypeParser.TryParse(s, out T temp);
result = temp;
return(returnValue);
};
return(new FunctorParserObject <T?>(parseFunc, tryParseFunc));
}
private IParser <T> GetValueTypeParserObject <T>()
where T : struct
{
Type type = typeof(T);
if (type.GetTypeInfo().IsEnum)
{
return(GetEnumTypeParserObject <T>());
}
ParseFunc <T> parseFunc = GetDefaultParseFunc <T>();
TryParseFunc <T> tryParseFunc = GetDefaultTryParseFunc <T>();
return(ApplyOptionsAndGetValueTypeParserObject(parseFunc, tryParseFunc, _missingTryParse));
}
private static TryParseFunc <T> CreateWrapperForTryParse <T>(ParseFunc <T> parseFunc)
{
return((string s, out T result) =>
{
try
{
result = parseFunc(s);
return true;
}
catch
{
result = default(T);
return false;
}
});
}
/// <summary>
/// Create a Matrix by parsing the file. The MatrixFactory may try many different parsers to get a result.
/// </summary>
/// <param name="filename">The name of the file containing the matrix information.</param>
/// <param name="missingValue">The special value that represents missing in the created matrix.</param>
/// <param name="parallelOptions">A ParallelOptions instance that configures the multithreaded behavior of this operation.</param>
/// <param name="result">The matrix created.</param>
/// <returns>true, if some parse succeeds; otherwise, false</returns>
public bool TryParse(string filename, TValue missingValue, ParallelOptions parallelOptions, out Matrix <TRowKey, TColKey, TValue> result)
{
result = null;
TextWriter origErrorWriter = Console.Error;
MFErrorWriter mfErrorWriter = new MFErrorWriter();
Console.SetError(mfErrorWriter);
if (_registeredParsers.Count == 0 && _builtInParsers.Count == 0)
{
Console.Error.WriteLine("No matching parsers found");
}
foreach (TryParseMatrixDelegate <TRowKey, TColKey, TValue> ParseFunc in _registeredParsers)
{
mfErrorWriter.SetLabel(ParseFunc.ToString());
if (ParseFunc(filename, missingValue, parallelOptions, out result))
{
ErrorMessages = mfErrorWriter.ToString();
Console.SetError(origErrorWriter);
return(true);
}
}
object[] methodParams4 = new object[] { filename, missingValue, parallelOptions, result };
object[] methodParams3 = new object[] { filename, missingValue, result };
foreach (MethodInfo ParseFuncMemberInfo in _builtInParsers)
{
mfErrorWriter.SetLabel(ParseFuncMemberInfo.DeclaringType.Name + "." + ParseFuncMemberInfo.Name);
int argCount = ParseFuncMemberInfo.GetParameters().Length;
Helper.CheckCondition(argCount == 3 || argCount == 4, Properties.Resource.ExpectedArgCountOfThreeOrFour);
object[] methodParams = (3 == argCount) ? methodParams3 : methodParams4;
bool success = (bool)ParseFuncMemberInfo.Invoke(null, methodParams);
if (success)
{
result = (Matrix <TRowKey, TColKey, TValue>)methodParams[argCount - 1];//!!!const
ErrorMessages = mfErrorWriter.ToString();
Console.SetError(origErrorWriter);
return(true);
}
}
ErrorMessages = mfErrorWriter.ToString();
Console.SetError(origErrorWriter);
return(false);
}
ExpressionToken ParseBinary(List<ExpressionToken> toks, ref int pos, ParseFunc nextlevel, params TokenKind[] kinds)
{
var res = nextlevel(toks, ref pos);
while (true)
{
var kind = GetKind(toks, pos);
if (Array.IndexOf(kinds,kind)>=0)
{
var newres = toks[pos];
newres.Tok1 = res;
pos++;
newres.Tok2 = nextlevel(toks, ref pos);
res = newres;
}
else break;
}
return res;
}
public NumberParser(Type fieldType)
{
if (fieldType == typeof(float))
{
parseFunction = (string input, out object value) => { float parsedVal; bool result = float.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (float)value1 == (float)value2;
}
else if (fieldType == typeof(double))
{
parseFunction = (string input, out object value) => { double parsedVal; bool result = double.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (double)value1 == (double)value2;
}
else if (fieldType == typeof(decimal))
{
parseFunction = (string input, out object value) => { decimal parsedVal; bool result = decimal.TryParse(input, out parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (decimal)value1 == (decimal)value2;
}
else
{
parseFunction = null;
equalsFunction = null;
}
}
/** Registers a parser hook.
*
* Hooks have the following format:
* <fmt> ::= <name> [<type> <name>]* [?<type> <name>]*
* <type> ::= int | str | sym | rand | char
* The first <name> is called the directive for this hook. Any other hooks with
* the same directive are superseded by this hook. It is an error for a
* mandatory field to follow an optional field. It is an error for any field to
* follow a field of type `str`, since `str` fields are not delimited and will
* consume the entire rest of the line.
*/
public Error Register(string fmt, ParseFunc pf)
{
//Misc.assert(p); //if p (self) was null, we wouldn't be here
Misc.assert(fmt != null);
Misc.assert(pf != null);
Parser_Hook h = new Parser_Hook();
h.func = pf;
/*h.next = p.hooks;
* h.func = func;*/
Error r = parse_specs(h, fmt);
if (r != Error.NONE)
{
return(r);
}
hooks.Add(h);
//p.hooks = h;
//mem_free(cfmt);
return(Error.NONE);
}
static ParseFunc <T> GetParseFunc <T>(params object[] additionalParameters)
{
var type = typeof(T);
var additionalParameterTypes = additionalParameters.Select(ap => ap != null ? ap.GetType() : typeof(void))
.ToArray();
var lutHash = GetHashForTryParse(type, additionalParameterTypes);
if (!tryParseLut.TryGetValue(lutHash, out var tryParseMethod))
{
tryParseMethod = type.GetTypeInfo().DeclaredMethods
.Where(mi => {
if (mi.Name != "TryParse")
{
return(false);
}
// It needs to be static, we don't have a T instance.
if (!mi.IsStatic)
{
return(false);
}
// If it doesn't return bool, it's no good.
if (mi.ReturnType != typeof(bool))
{
return(false);
}
var parameters = mi.GetParameters();
// If it doesn't take a string, it's no good.
if (parameters[0].ParameterType != typeof(string))
{
return(false);
}
var lastParameter = parameters.Last();
// If the last parameter isn't T&, it's no good.
if (lastParameter.ParameterType != typeof(T).MakeByRefType())
{
return(false);
}
var parameterCount = parameters.Length;
// There's no way this matches, if it doesn't have the right
// number of parameters.
if (parameterCount < (2 + additionalParameters.Length))
{
return(false);
}
var additionalTypesMatch = true;
for (var i = 0; i < additionalParameterTypes.Length; i++)
{
// Skip the first parameter.
var additionalParameterType = additionalParameterTypes[i];
// Null was passed, so don't type-check it.
if (additionalParameterType == typeof(void))
{
continue;
}
var parameter = parameters[i + 1];
additionalTypesMatch &= parameter.ParameterType == additionalParameterType;
}
// If the additional types don't match, it's not match.
if (!additionalTypesMatch)
{
return(false);
}
return(true);
}).FirstOrDefault();
tryParseLut.Add(lutHash, tryParseMethod);
}
if (tryParseMethod == null)
{
return(null);
}
ParseFunc <T> del = delegate(string s, object[] additionalParams, out T result) {
result = default(T);
var methodParams = new object[] { s }.Concat(additionalParams)
.Concat(new object[] { null })
.ToArray();
var parsed = (bool)tryParseMethod.Invoke(null, methodParams);
if (parsed)
{
result = (T)methodParams.Last();
}
return(parsed);
};
return(del);
}
/// <summary> /// Configures parsing of <typeparamref name="T"/> to use the provided function. /// </summary> /// <typeparam name="T">The type for which to configure parsing.</typeparam> /// <param name="parseFunc">A function that implements Parse method functionality for <typeparamref name="T"/>.</param> public void UseFunc <T>(ParseFunc <T> parseFunc) => UseFunc(parseFunc, MissingTryParseHandling.ThrowNotSupportedException);
/// <summary> /// Configures parsing of <typeparamref name="T"/> to use the provided function. /// </summary> /// <typeparam name="T">The type for which to configure parsing.</typeparam> /// <param name="parseFunc">A function that implements Parse method functionality for <typeparamref name="T"/>.</param> /// <param name="missingTryParse">A value indicating how to configure TryParse functionality if the type does not have a TryParse method</param> public abstract void UseFunc <T>(ParseFunc <T> parseFunc, MissingTryParseHandling missingTryParse);
public ProxySimpleTypeParser(ParseFunc procParse)
{
ProcParse = procParse;
}
/// <summary> /// Configures parsing of <typeparamref name="T"/> to use the provided functions. /// </summary> /// <typeparam name="T">The type for which to configure parsing.</typeparam> /// <param name="parseFunc">A function that implements Parse method functionality for <typeparamref name="T"/>.</param> /// <param name="tryParseFunc">A function that implements the TryParse method functionality for <typeparamref name="T"/>.</param> public abstract void UseFunc <T>(ParseFunc <T> parseFunc, TryParseFunc <T> tryParseFunc);
public FunctorParserObject(ParseFunc <T> parseFunc, TryParseFunc <T> tryParseFunc)
{
_parseFunc = parseFunc;
_tryParseFunc = tryParseFunc;
}
public NumberParser(Type fieldType)
{
// 整型
if (fieldType == typeof(int))
{
parseFunction = (string input, out object value) => { bool result = int.TryParse(input, out int parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (int)value1 == (int)value2;
}
else if (fieldType == typeof(uint))
{
parseFunction = (string input, out object value) => { bool result = uint.TryParse(input, out uint parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (uint)value1 == (uint)value2;
}
else if (fieldType == typeof(long))
{
parseFunction = (string input, out object value) => { bool result = long.TryParse(input, out long parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (long)value1 == (long)value2;
}
else if (fieldType == typeof(ulong))
{
parseFunction = (string input, out object value) => { bool result = ulong.TryParse(input, out ulong parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (ulong)value1 == (ulong)value2;
}
else if (fieldType == typeof(byte))
{
parseFunction = (string input, out object value) => { bool result = byte.TryParse(input, out byte parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (byte)value1 == (byte)value2;
}
else if (fieldType == typeof(sbyte))
{
parseFunction = (string input, out object value) => { bool result = sbyte.TryParse(input, out sbyte parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (sbyte)value1 == (sbyte)value2;
}
else if (fieldType == typeof(short))
{
parseFunction = (string input, out object value) => { bool result = short.TryParse(input, out short parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (short)value1 == (short)value2;
}
else if (fieldType == typeof(ushort))
{
parseFunction = (string input, out object value) => { bool result = ushort.TryParse(input, out ushort parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (ushort)value1 == (ushort)value2;
}
else if (fieldType == typeof(char))
{
parseFunction = (string input, out object value) => { bool result = char.TryParse(input, out char parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (char)value1 == (char)value2;
}
// 浮点型
else if (fieldType == typeof(float))
{
parseFunction = (string input, out object value) => { bool result = float.TryParse(input, out float parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (float)value1 == (float)value2;
}
else if (fieldType == typeof(double))
{
parseFunction = (string input, out object value) => { bool result = double.TryParse(input, out double parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (double)value1 == (double)value2;
}
else if (fieldType == typeof(decimal))
{
parseFunction = (string input, out object value) => { bool result = decimal.TryParse(input, out decimal parsedVal); value = parsedVal; return(result); };
equalsFunction = (object value1, object value2) => (decimal)value1 == (decimal)value2;
}
else
{
throw new Exception("Type必须是数字类型");
}
}
