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
}));
}
public void _0001(GDBD.Specifications.AdapterClassSpec <object> ident)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
_RepositoryProperty = ident;
}
internal void _0002(GDBD.Specifications.AdapterClassSpec <object> res)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
getterProperty = res;
}
public void _0001(GDBD.Specifications.AdapterClassSpec <object> spec)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
identifierProperty = spec;
}
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);
}
public MessageTest(Type instance)
{
//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(instance);
_ErrorProperty = (ParameterFilterResolver)2;
m_GlobalTest = (base._0003().IsArray || (_InstanceProperty.CallReader() && _InstanceProperty.GetGenericTypeDefinition().FullName == "System.Linq.EmptyPartition`1"));
bool forcedef;
Type _0004;
if (this._0002())
{
_ProductTest = ResolverErrorFilter.EnableReader(base._0002());
composerProperty = true;
_AlgoTest = typeof(List <>).MakeGenericType(this._0001());
forcedef = true;
m_InterceptorTest = (base._0003().IsArray&& base._0002().GetArrayRank() > 1);
}
else if (typeof(IList).IsAssignableFrom(_InstanceProperty))
{
if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(ICollection <>), out _AlgoTest))
{
_ProductTest = _AlgoTest.GetGenericArguments()[0];
}
else
{
_ProductTest = ResolverErrorFilter.EnableReader(_InstanceProperty);
}
if (_InstanceProperty == typeof(IList))
{
_0002(typeof(List <object>));
}
if (this._0001() != null)
{
_TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001());
}
composerProperty = ResolverErrorFilter.RunReader(_InstanceProperty, typeof(ReadOnlyCollection <>));
forcedef = true;
}
else if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(ICollection <>), out _AlgoTest))
{
_ProductTest = _AlgoTest.GetGenericArguments()[0];
if (ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(ICollection <>)) || ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(IList <>)))
{
_0002(typeof(List <>).MakeGenericType(this._0001()));
}
if (ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(ISet <>)))
{
_0002(typeof(HashSet <>).MakeGenericType(this._0001()));
}
_TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001());
forcedef = true;
_WrapperTest = true;
}
else if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(IEnumerable <>), out _0004))
{
_ProductTest = _0004.GetGenericArguments()[0];
if (ResolverErrorFilter.OrderReader(base._0002(), typeof(IEnumerable <>)))
{
_0002(typeof(List <>).MakeGenericType(this._0001()));
}
_TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001());
StartClient(_InstanceProperty);
if (_InstanceProperty.CallReader() && _InstanceProperty.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
_AlgoTest = _0004;
composerProperty = false;
_WrapperTest = false;
forcedef = true;
}
else
{
_AlgoTest = typeof(List <>).MakeGenericType(this._0001());
composerProperty = true;
_WrapperTest = true;
forcedef = _0006();
}
}
else
{
forcedef = false;
_WrapperTest = true;
}
_0001(forcedef);
if (this._0001() != null && ParamRequestStrategy.CalcIssuer(_InstanceProperty, this._0001(), out Type _00042, out GDBD.Specifications.AdapterClassSpec <object> _0005))
{
_0002(_00042);
m_ExpressionTest = _0005;
composerProperty = true;
_0001(forcedef: true);
}
}
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);
}
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);
}