private void ResolveClass(RecordClassDispatcher task, IDynamicMetaObjectProvider connection, ProducerProperty role, ProductInstanceExpression last2, InitializerTest result3, ProductInstanceExpression reg4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(task, role, connection);
wrapperProperty.Add(connection);
SortBroadcaster(task, connection, role, last2, result3, reg4);
int lengthpred = task._0002();
for (int i = 0; i < role._0001().Count; i++)
{
ProductInstanceExpression productInstanceExpression = role._0001()[i];
if (productInstanceExpression._0004())
{
try
{
if (CollectBroadcaster(task, connection, role, last2, productInstanceExpression, out ProcTest _0007, out object _0008))
{
productInstanceExpression.DefineClient(task);
InvokeBroadcaster(task, _0008, _0007, productInstanceExpression, role, last2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(connection, role, productInstanceExpression._0001(), null, task._0001(), ident))
{
throw;
}
EnableClass(task, lengthpred);
}
}
}
foreach (string item in connection.ResolveIssuer())
{
if (role.CancelClient(connection, item, out object _0004))
{
try
{
ProcTest procTest = DeleteBroadcaster(_0004);
if (FillClass(_0004) && CustomizeBroadcaster(task, _0004, null, procTest, role, last2))
{
string task2 = (role._0001() != null) ? role._0001()(item) : item;
task._0002(task2);
InvokeBroadcaster(task, _0004, procTest, null, role, last2);
}
}
catch (Exception ident2)
{
if (!CheckBroadcaster(connection, role, item, null, task._0001(), ident2))
{
throw;
}
EnableClass(task, lengthpred);
}
}
}
task._0011();
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(task, role, connection);
}
private bool MapClass(RecordClassDispatcher res, ProductInstanceExpression attr, object temp)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (attr._0001() == null)
{
return(true);
}
bool flag = attr._0001()(temp);
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
{
containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), "ShouldSerialize result for property '{0}' on {1}: {2}".DeleteReader(CultureInfo.InvariantCulture, attr._0001(), attr._0001(), flag)), null);
}
return(flag);
}
private bool CustomizeBroadcaster(RecordClassDispatcher res, object pol, ProductInstanceExpression filter, ProcTest second2, InitializerTest cfg3, ProductInstanceExpression visitor4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (pol == null)
{
return(true);
}
if (second2._ErrorProperty == (ParameterFilterResolver)3 || second2._ErrorProperty == (ParameterFilterResolver)4)
{
return(true);
}
FacadeComposer?facadeComposer = null;
if (filter != null)
{
facadeComposer = filter._0001();
}
if (!facadeComposer.HasValue && visitor4 != null)
{
facadeComposer = visitor4._0002();
}
if (!facadeComposer.HasValue && cfg3 != null)
{
facadeComposer = cfg3._0001();
}
if ((baseProperty.m_SpecificationError != null) ? wrapperProperty.CollectTest(pol, baseProperty.m_SpecificationError) : wrapperProperty.Contains(pol))
{
string str = "Self referencing loop detected";
if (filter != null)
{
str += " for property '{0}'".ListReader(CultureInfo.InvariantCulture, filter._0001());
}
str += " with type '{0}'.".ListReader(CultureInfo.InvariantCulture, pol.GetType());
switch (facadeComposer.GetValueOrDefault(baseProperty.helperError))
{
case (FacadeComposer)0:
throw StrategyError.ValidateComposer(null, res._0001(), str, null);
case (FacadeComposer)1:
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
{
containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), str + ". Skipping serializing self referenced value."), null);
}
return(false);
case (FacadeComposer)2:
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
{
containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), str + ". Serializing self referenced value."), null);
}
return(true);
}
}
return(true);
}
private void DefineBroadcaster(RecordClassDispatcher task, object visitor, PrototypeFilterResolver proc, ProductInstanceExpression cust2, InitializerTest first3, ProductInstanceExpression v4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(task, proc, visitor);
wrapperProperty.Add(visitor);
SortBroadcaster(task, visitor, proc, cust2, first3, v4);
int lengthpred = task._0002();
for (int i = 0; i < proc._0001().Count; i++)
{
ProductInstanceExpression productInstanceExpression = proc._0001()[i];
try
{
if (CollectBroadcaster(task, visitor, proc, cust2, productInstanceExpression, out ProcTest _0007, out object _0008))
{
productInstanceExpression.DefineClient(task);
InvokeBroadcaster(task, _0008, _0007, productInstanceExpression, proc, cust2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(visitor, proc, productInstanceExpression._0001(), null, task._0001(), ident))
{
throw;
}
EnableClass(task, lengthpred);
}
}
IEnumerable <KeyValuePair <object, object> > enumerable = proc._0001()?.Invoke(visitor);
if (enumerable != null)
{
foreach (KeyValuePair <object, object> item in enumerable)
{
ProcTest temp = TestBroadcaster(item.Key);
ProcTest procTest = DeleteBroadcaster(item.Value);
string text = AddClass(task, item.Key, temp, out bool _);
text = ((proc._0001() != null) ? proc._0001()(text) : text);
if (CountBroadcaster(item.Value, null, procTest, proc, cust2))
{
task._0002(text);
QueryBroadcaster(task, item.Value);
}
else if (CustomizeBroadcaster(task, item.Value, null, procTest, proc, cust2))
{
task._0002(text);
InvokeBroadcaster(task, item.Value, procTest, null, proc, cust2);
}
}
}
task._0011();
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(task, proc, visitor);
}
private bool AssetBroadcaster(object asset, PrototypeFilterResolver cont, ProductInstanceExpression consumer)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (asset == null && WriteClient(cont, consumer) == (ApplicationState)1)
{
return(false);
}
if (RevertBroadcaster(consumer._0001().GetValueOrDefault(baseProperty._FactoryError), (ConnectActionCursor)1) && CustomerListAnnotation.TestIssuer(asset, consumer.InitClient()))
{
return(false);
}
return(true);
}
private bool RunClass(SparklineAxisMinMaxValues spec, ProcTest caller, ProductInstanceExpression field, InitializerTest connection2, ProductInstanceExpression selection3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
SparklineAxisMinMaxValues first = field?._0001() ?? selection3?._0002() ?? connection2?._0001() ?? baseProperty.m_ParserError;
if (CheckClass(first, spec))
{
return(true);
}
if (CheckClass(first, (SparklineAxisMinMaxValues)4))
{
if (field != null)
{
if (caller._InstanceProperty != field._0001()._0003())
{
return(true);
}
}
else if (connection2 != null)
{
if (connection2._0001() == null || caller._InstanceProperty != connection2._0001()._0003())
{
return(true);
}
}
else if (_VisitorProperty != null && wrapperProperty.Count == globalProperty)
{
ProcTest procTest = baseProperty.listenerError._0001(_VisitorProperty);
if (caller._InstanceProperty != procTest._0003())
{
return(true);
}
}
}
return(false);
}
private bool?PrintBroadcaster(ProcTest v, ProductInstanceExpression cfg, InitializerTest serv, ProductInstanceExpression param2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
bool?result = null;
if (cfg != null)
{
result = cfg._0001();
}
if (!result.HasValue && param2 != null)
{
result = param2._0002();
}
if (!result.HasValue && serv != null)
{
result = serv._0001();
}
if (!result.HasValue)
{
result = v._0002();
}
return(result);
}
private bool CollectBroadcaster(RecordClassDispatcher init, object pol, InitializerTest helper, [global::_0008._0012(2)] ProductInstanceExpression _0005, ProductInstanceExpression asset3, [global::_0008._0012(2)][ConsumerBroadcasterDispatcher(true)] out ProcTest _0007, [ConsumerBroadcasterDispatcher(true)][global::_0008._0012(2)] out object _0008)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!asset3._0001() && asset3._0002() && MapClass(init, asset3, pol) && InsertClass(init, asset3, pol))
{
if (asset3._0001() == null)
{
asset3._0001(baseProperty.listenerError._0001(asset3._0002()));
}
_0008 = asset3._0001()._0001(pol);
_0007 = (asset3._0001().propertyProperty ? asset3._0001() : DeleteBroadcaster(_0008));
if (AssetBroadcaster(_0008, helper as PrototypeFilterResolver, asset3))
{
if (CountBroadcaster(_0008, asset3, _0007, helper, _0005))
{
asset3.DefineClient(init);
QueryBroadcaster(init, _0008);
return(false);
}
if (!CustomizeBroadcaster(init, _0008, asset3, _0007, helper, _0005))
{
return(false);
}
if (_0008 == null)
{
PrototypeFilterResolver prototypeFilterResolver = helper as PrototypeFilterResolver;
switch (asset3.contextProperty ?? (prototypeFilterResolver?._0001()).GetValueOrDefault())
{
case (SpecificationTestItem)2:
throw StrategyError.ValidateComposer(null, init._0001(), "Cannot write a null value for property '{0}'. Property requires a value.".ListReader(CultureInfo.InvariantCulture, asset3._0001()), null);
case (SpecificationTestItem)3:
throw StrategyError.ValidateComposer(null, init._0001(), "Cannot write a null value for property '{0}'. Property requires a non-null value.".ListReader(CultureInfo.InvariantCulture, asset3._0001()), null);
}
}
return(true);
}
}
_0007 = null;
_0008 = null;
return(false);
}
private bool CallBroadcaster(InitializerTest init, ProductInstanceExpression col)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return((init as PrototypeFilterResolver)?._0002().Contains(col._0001()) ?? false);
}
private void InvokeBroadcaster(RecordClassDispatcher last, object b, ProcTest proc, ProductInstanceExpression second2, InitializerTest second3, ProductInstanceExpression vis4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (b == null)
{
last._0008();
return;
}
BroadcasterError broadcasterError = second2?._0001() ?? vis4?._0002() ?? second3?._0001() ?? proc._0002() ?? baseProperty.CloneComposer(proc._0002()) ?? proc._0003();
if (broadcasterError != null && broadcasterError._0001())
{
DisableClass(last, broadcasterError, b, proc, second3, vis4);
return;
}
switch (proc._ErrorProperty)
{
case (ParameterFilterResolver)1:
DefineBroadcaster(last, b, (PrototypeFilterResolver)proc, second2, second3, vis4);
break;
case (ParameterFilterResolver)2:
{
MessageTest messageTest = (MessageTest)proc;
if (!messageTest._0001())
{
VerifyClass(last, (IEnumerable)b, messageTest, second2, second3, vis4);
}
else
{
PatchClass(last, (Array)b, messageTest, second2, second3, vis4);
}
break;
}
case (ParameterFilterResolver)3:
ConcatBroadcaster(last, b, (ProccesorClassSpec)proc, second2, second3, vis4);
break;
case (ParameterFilterResolver)4:
SetupBroadcaster(last, b, (StubIteratorMapping)proc);
break;
case (ParameterFilterResolver)5:
{
ParamClientBridge paramClientBridge = (ParamClientBridge)proc;
IDictionary dictionary = b as IDictionary;
IDictionary attr;
if (dictionary == null)
{
IDictionary dictionary2 = paramClientBridge.CountClient(b);
attr = dictionary2;
}
else
{
attr = dictionary;
}
CompareClass(last, attr, paramClientBridge, second2, second3, vis4);
break;
}
case (ParameterFilterResolver)6:
ResolveClass(last, (IDynamicMetaObjectProvider)b, (ProducerProperty)proc, second2, second3, vis4);
break;
case (ParameterFilterResolver)7:
OrderClass(last, (ISerializable)b, (CollectionProperty)proc, second2, second3, vis4);
break;
case (ParameterFilterResolver)8:
((ParserFilterResolver)b)._0001(last, baseProperty._0001().ToArray());
break;
}
}
private bool InsertClass(RecordClassDispatcher value, ProductInstanceExpression visitor, object helper)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (visitor._0003() == null)
{
return(true);
}
bool flag = visitor._0003()(helper);
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
{
containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, value._0002(), "IsSpecified result for property '{0}' on {1}: {2}".DeleteReader(CultureInfo.InvariantCulture, visitor._0001(), visitor._0001(), flag)), null);
}
return(flag);
}
