internal static bool CalcIssuer(Type i, Type b, [ConsumerBroadcasterDispatcher(true)][_0008._0012(2)] out Type _0004, [_0008._0012(new byte[]
{
2,
1
})][ConsumerBroadcasterDispatcher(true)] out GDBD.Specifications.AdapterClassSpec <object> _0005)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (i.CallReader())
{
Type genericTypeDefinition = i.GetGenericTypeDefinition();
string fullName = genericTypeDefinition.FullName;
RegistryTest registryTest = _QueueTest.FirstOrDefault((RegistryTest P_0) => P_0._0001() == fullName);
if (registryTest != null)
{
Type type = genericTypeDefinition.RevertReader().GetType(registryTest._0002());
Type type2 = genericTypeDefinition.RevertReader().GetType(registryTest._0003());
if (type != null && type2 != null)
{
MethodInfo methodInfo = type2.GetMethods().FirstOrDefault((MethodInfo spec) => spec.Name == "CreateRange" && spec.GetParameters().Length == 1);
if (methodInfo != null)
{
_0004 = type.MakeGenericType(b);
MethodInfo v = methodInfo.MakeGenericMethod(b);
_0005 = ConfigProperty._0001()._0001(v);
return(true);
}
}
}
}
_0004 = null;
_0005 = null;
return(false);
}
private PropertyTest(Assembly asset)
{
//Discarded unreachable code: IL_0002, IL_0006
//IL_0003: Incompatible stack heights: 0 vs 1
//IL_0007: Incompatible stack heights: 0 vs 1
SingletonReader.PushGlobal();
base._002Ector();
_0001(asset);
Type type = asset.GetType("Microsoft.FSharp.Reflection.FSharpType");
MethodInfo v = PopIssuer(type, "IsUnion", BindingFlags.Static | BindingFlags.Public);
_0001(ConfigProperty._0001()._0001 <object>(v));
MethodInfo v2 = PopIssuer(type, "GetUnionCases", BindingFlags.Static | BindingFlags.Public);
_0002(ConfigProperty._0001()._0001 <object>(v2));
Type type2 = asset.GetType("Microsoft.FSharp.Reflection.FSharpValue");
_0003(NewIssuer(type2, "PreComputeUnionTagReader"));
_0004(NewIssuer(type2, "PreComputeUnionReader"));
_0005(NewIssuer(type2, "PreComputeUnionConstructor"));
Type type3 = asset.GetType("Microsoft.FSharp.Reflection.UnionCaseInfo");
_0002(ConfigProperty._0001()._0001 <object>(type3.GetProperty("Name")));
_0003(ConfigProperty._0001()._0001 <object>(type3.GetProperty("Tag")));
_0001(ConfigProperty._0001()._0001 <object>(type3.GetProperty("DeclaringType")));
_0006(ConfigProperty._0001()._0001 <object>(type3.GetMethod("GetFields")));
Type type4 = asset.GetType("Microsoft.FSharp.Collections.ListModule");
clientTest = type4.GetMethod("OfSeq");
_BroadcasterTest = asset.GetType("Microsoft.FSharp.Collections.FSharpMap`2");
}
private static void CompareIssuer()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
Type type = Type.GetType("Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo, Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", throwOnError: true);
Type type2 = Type.GetType("Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags, Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", throwOnError: true);
Type type3 = Type.GetType("Microsoft.CSharp.RuntimeBinder.Binder, Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", throwOnError: true);
Type type4 = typeof(IEnumerable <>).MakeGenericType(type);
MethodInfo method = type3.GetMethod("GetMember", new Type[4]
{
type2,
typeof(string),
typeof(Type),
type4
});
_TemplateComposer = ConfigProperty._0001()._0001 <object>(method);
MethodInfo method2 = type3.GetMethod("SetMember", new Type[4]
{
type2,
typeof(string),
typeof(Type),
type4
});
expressionComposer = ConfigProperty._0001()._0001 <object>(method2);
}
public GDBD.Specifications.AdapterClassSpec <object> ForgotIssuer(Type param)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
MethodInfo v = clientTest.MakeGenericMethod(param);
return(ConfigProperty._0001()._0001(v));
}
internal new GDBD.Specifications.AdapterClassSpec <object> _0001()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (m_ExpressionTest == null && _TemplateTest != null)
{
m_ExpressionTest = ConfigProperty._0001()._0001(_TemplateTest);
}
return(m_ExpressionTest);
}
internal new GDBD.Specifications.AdapterClassSpec <object> _0001()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (_ObserverProperty == null && m_MappingProperty != null)
{
_ObserverProperty = ConfigProperty._0001()._0001(m_MappingProperty);
}
return(_ObserverProperty);
}
private static Newtonsoft.Rules.ClientInstanceRule <object, object> NewIssuer(Type task, string pol)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
MethodInfo methodInfo = PopIssuer(task, pol, BindingFlags.Static | BindingFlags.Public);
MethodInfo method = methodInfo.ReturnType.GetMethod("Invoke", BindingFlags.Instance | BindingFlags.Public);
Newtonsoft.Rules.ClientInstanceRule <object, object> clientInstanceRule = ConfigProperty._0001()._0001 <object>(methodInfo);
Newtonsoft.Rules.ClientInstanceRule <object, object> col = ConfigProperty._0001()._0001 <object>(method);
return((object P_0, object[] P_1) => new ParamsComposerWorker(clientInstanceRule(P_0, P_1), col));
}
internal IDictionary AssetClient()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (_TokenizerProperty == null)
{
Type task = typeof(Dictionary <, >).MakeGenericType(this._0001() ?? typeof(object), _0004() ?? typeof(object));
_TokenizerProperty = ConfigProperty._0001()._0001 <object>(task);
}
return((IDictionary)_TokenizerProperty());
}
internal IList GetClient()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (_VisitorTest == null)
{
Type type = (this._0001() || this._0001() == null) ? typeof(object) : this._0001();
Type task = typeof(List <>).MakeGenericType(type);
_VisitorTest = ConfigProperty._0001()._0001 <object>(task);
}
return((IList)_VisitorTest());
}
internal ProcessComposer CountClient(object key)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (candidateProperty == null)
{
m_ConfigurationProperty = typeof(IssuerInstanceRule <, >).MakeGenericType(this._0001(), _0004());
ConstructorInfo constructor = m_ConfigurationProperty.GetConstructor(new Type[1]
{
m_AttrProperty
});
candidateProperty = ConfigProperty._0001()._0001(constructor);
}
return((ProcessComposer)candidateProperty(new object[1]
{
key
}));
}
internal ManagerErrorFilter CalculateClient(object def)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (m_ExporterTest == null)
{
annotationTest = typeof(GDBD.Dispatcher.SetterComposer <>).MakeGenericType(this._0001());
Type type = (!ResolverErrorFilter.RunReader(_AlgoTest, typeof(List <>)) && !(_AlgoTest.GetGenericTypeDefinition() == typeof(IEnumerable <>))) ? _AlgoTest : typeof(ICollection <>).MakeGenericType(this._0001());
ConstructorInfo constructor = annotationTest.GetConstructor(new Type[1]
{
type
});
m_ExporterTest = ConfigProperty._0001()._0001(constructor);
}
return((ManagerErrorFilter)m_ExporterTest(new object[1]
{
def
}));
}
internal static bool InstantiateIssuer(Type setup, Type result, Type consumer, [ConsumerBroadcasterDispatcher(true)][_0008._0012(2)] out Type _0005, [ConsumerBroadcasterDispatcher(true)][_0008._0012(new byte[]
{
2,
1
})] out GDBD.Specifications.AdapterClassSpec <object> _0006)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (setup.CallReader())
{
Type genericTypeDefinition = setup.GetGenericTypeDefinition();
string fullName = genericTypeDefinition.FullName;
RegistryTest registryTest = proxyTest.FirstOrDefault((RegistryTest P_0) => P_0._0001() == fullName);
if (registryTest != null)
{
Type type = genericTypeDefinition.RevertReader().GetType(registryTest._0002());
Type type2 = genericTypeDefinition.RevertReader().GetType(registryTest._0003());
if (type != null && type2 != null)
{
MethodInfo methodInfo = type2.GetMethods().FirstOrDefault(delegate(MethodInfo v)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ParameterInfo[] parameters = v.GetParameters();
return(v.Name == "CreateRange" && parameters.Length == 1 && parameters[0].ParameterType.CallReader() && parameters[0].ParameterType.GetGenericTypeDefinition() == typeof(IEnumerable <>));
});
if (methodInfo != null)
{
_0005 = type.MakeGenericType(result, consumer);
MethodInfo v2 = methodInfo.MakeGenericMethod(result, consumer);
_0006 = ConfigProperty._0001()._0001(v2);
return(true);
}
}
}
}
_0005 = null;
_0006 = null;
return(false);
}
private static Func <object, object> FillProperty(GDBD.Workers.TemplateComposerWorker <Type, Type> init)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
Type workerTest = init.workerTest;
Type advisorTest = init._AdvisorTest;
MethodInfo methodInfo = advisorTest.GetMethod("op_Implicit", new Type[1]
{
workerTest
}) ?? advisorTest.GetMethod("op_Explicit", new Type[1]
{
workerTest
});
if (methodInfo == null)
{
return(null);
}
Newtonsoft.Rules.ClientInstanceRule <object, object> clientInstanceRule = ConfigProperty._0001()._0001 <object>(methodInfo);
return((object P_0) => clientInstanceRule(null, new object[1]
{
P_0
}));
}
public static ModelInstanceExpression InitIssuer(Type var1, MethodBase cfg, string[] field)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
VisitorComposer visitorComposer = ConfigProperty._0001();
GDBD.Specifications.AdapterClassSpec <object> last = null;
if (cfg != null)
{
last = visitorComposer._0001(cfg);
}
else if (ResolverErrorFilter.LoginReader(var1, isconnection: false))
{
Func <object> func = visitorComposer._0001 <object>(var1);
last = ((object[] P_0) => func());
}
ModelInstanceExpression modelInstanceExpression = new ModelInstanceExpression(last);
Newtonsoft.Rules.ClientInstanceRule <object, object> clientInstanceRule;
Newtonsoft.Rules.ClientInstanceRule <object, object> clientInstanceRule2;
foreach (string text in field)
{
MemberInfo[] member = var1.GetMember(text, BindingFlags.Instance | BindingFlags.Public);
if (member.Length != 1)
{
throw new ArgumentException("Expected a single member with the name '{0}'.".ListReader(CultureInfo.InvariantCulture, text));
}
MemberInfo memberInfo = member.Single();
StubTest stubTest = new StubTest();
switch (memberInfo.DefineReader())
{
case MemberTypes.Field:
case MemberTypes.Property:
if (ResolverErrorFilter.LogoutReader(memberInfo, updateb: false))
{
stubTest._0001(visitorComposer.ValidateIssuer <object>(memberInfo));
}
if (ResolverErrorFilter.VisitReader(memberInfo, calcconnection: false, addrule: false))
{
stubTest._0001(visitorComposer.OrderIssuer <object>(memberInfo));
}
break;
case MemberTypes.Method:
{
MethodInfo methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsPublic)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length == 0 && methodInfo.ReturnType != typeof(void))
{
clientInstanceRule = visitorComposer._0001 <object>(methodInfo);
stubTest._0001((object P_0) => clientInstanceRule(P_0, new object[0]));
}
else if (parameters.Length == 1 && methodInfo.ReturnType == typeof(void))
{
clientInstanceRule2 = visitorComposer._0001 <object>(methodInfo);
stubTest._0001(delegate(object P_0, object P_1)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
clientInstanceRule2(P_0, new object[1]
{
P_1
});
});
}
}
break;
}
default:
throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".SelectReader(CultureInfo.InvariantCulture, memberInfo.DefineReader(), memberInfo.Name));
}
stubTest._0001(ResolverErrorFilter.InsertReader(memberInfo));
modelInstanceExpression._0001()[text] = stubTest;
}
return(modelInstanceExpression);
}
