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);
}
public override void _0001(RecordClassDispatcher item, object cfg, PrototypeError filter)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (cfg == null)
{
item._0008();
return;
}
DataTable obj = (DataTable)cfg;
PublisherRequestStrategy publisherRequestStrategy = filter._0001() as PublisherRequestStrategy;
item._0003();
foreach (DataRow row in obj.Rows)
{
item._0002();
foreach (DataColumn column in row.Table.Columns)
{
object obj2 = row[column];
if (filter._0001() != (ApplicationState)1 || (obj2 != null && obj2 != DBNull.Value))
{
item._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(column.ColumnName) : column.ColumnName);
filter.FlushComposer(item, obj2);
}
}
item._0011();
}
item._000F();
}
private bool ValidateClass(RecordClassDispatcher value, object second, MessageTest helper, ProductInstanceExpression ord2, InitializerTest last3, ProductInstanceExpression t4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
bool flag = (PrintBroadcaster(helper, ord2, last3, t4) ?? LoginClass(baseProperty.m_PageError, (TaskListAnnotation)2)) && (ord2 == null || ord2._0003() || CallBroadcaster(last3, ord2));
bool flag2 = RunClass((SparklineAxisMinMaxValues)2, helper, ord2, last3, t4);
bool num = flag || flag2;
if (num)
{
value._0002();
if (flag)
{
PublishBroadcaster(value, ((ProcTest)helper)._0002(), second);
}
if (flag2)
{
WriteBroadcaster(value, second.GetType());
}
value._0001("$values", injectcust: false);
}
if (((InitializerTest)helper)._0001() == null)
{
helper._0001(baseProperty.listenerError._0001(helper._0001() ?? typeof(object)));
}
return(num);
}
private void SetupBroadcaster(RecordClassDispatcher init, object pol, StubIteratorMapping field)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(init, field, pol);
ExcludeBroadcaster(pol, ((ProcTest)field)._0002(), out string _0004);
init._0004(_0004);
InitBroadcaster(init, field, pol);
}
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 InitBroadcaster(RecordClassDispatcher value, ProcTest caller, object rule)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
{
containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, value._0002(), "Finished serializing {0}".ListReader(CultureInfo.InvariantCulture, caller._0002())), null);
}
caller.SelectClient(rule, baseProperty.roleError);
}
private void ManageBroadcaster(RecordClassDispatcher asset, ProcTest counter, object res)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
{
containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, asset._0002(), "Started serializing {0}".ListReader(CultureInfo.InvariantCulture, counter._0002())), null);
}
counter.ListClient(res, baseProperty.roleError);
}
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);
}
public override void _0001(RecordClassDispatcher setup, BroadcasterError[] cfg)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
setup._0002();
for (int i = 0; i < _StubIssuer.Count; i++)
{
_StubIssuer[i]._0001(setup, cfg);
}
setup._0011();
}
public override void _0001(RecordClassDispatcher param, BroadcasterError[] token)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
param._0003();
for (int i = 0; i < attrIssuer.Count; i++)
{
attrIssuer[i]._0001(param, token);
}
param._000F();
}
public override void _0001(RecordClassDispatcher config, object caller, PrototypeError comp)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (caller == null)
{
config._0008();
return;
}
byte[] item = ReflectRequest(caller);
config._0001(item);
}
private void CompareClass(RecordClassDispatcher instance, IDictionary attr, ParamClientBridge c, ProductInstanceExpression param2, InitializerTest caller3, ProductInstanceExpression ivk4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ProcessComposer processComposer = attr as ProcessComposer;
object obj = (processComposer != null) ? processComposer._0001() : attr;
ManageBroadcaster(instance, c, obj);
wrapperProperty.Add(obj);
SortBroadcaster(instance, obj, c, param2, caller3, ivk4);
if (((InitializerTest)c)._0001() == null)
{
c._0001(baseProperty.listenerError._0001(c._0004() ?? typeof(object)));
}
if (c._0003() == null)
{
c._0002(baseProperty.listenerError._0001(c._0001() ?? typeof(object)));
}
int lengthpred = instance._0002();
foreach (DictionaryEntry item in attr)
{
string text = AddClass(instance, item.Key, c._0003(), out bool last);
text = ((c._0001() != null) ? c._0001()(text) : text);
try
{
object value = item.Value;
ProcTest procTest = ((InitializerTest)c)._0002() ?? DeleteBroadcaster(value);
if (CountBroadcaster(value, null, procTest, c, param2))
{
instance._0001(text, last);
QueryBroadcaster(instance, value);
}
else if (CustomizeBroadcaster(instance, value, null, procTest, c, param2))
{
instance._0001(text, last);
InvokeBroadcaster(instance, value, procTest, null, c, param2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(obj, c, text, null, instance._0001(), ident))
{
throw;
}
EnableClass(instance, lengthpred);
}
}
instance._0011();
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(instance, c, obj);
}
private void ListRequest(RecordClassDispatcher i, Regex reg, PrototypeError tag)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
PublisherRequestStrategy publisherRequestStrategy = tag._0001() as PublisherRequestStrategy;
i._0002();
i._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Pattern") : "Pattern");
i._0004(reg.ToString());
i._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Options") : "Options");
tag.FlushComposer(i, reg.Options);
i._0011();
}
private void WriteBroadcaster(RecordClassDispatcher ident, Type map)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = ResolverErrorFilter.PublishIssuer(map, baseProperty._StatusError, baseProperty.writerError);
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
{
containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, ident._0002(), "Writing type name '{0}' for {1}.".SelectReader(CultureInfo.InvariantCulture, text, map)), null);
}
ident._0001("$type", injectcust: false);
ident._0004(text);
}
private void PublishBroadcaster(RecordClassDispatcher init, Type pred, object control)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = CancelBroadcaster(init, control);
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
{
containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, init._0002(), "Writing object reference Id '{0}' for {1}.".SelectReader(CultureInfo.InvariantCulture, text, pred)), null);
}
init._0001("$id", injectcust: false);
init._0004(text);
}
internal override void _0001(RecordClassDispatcher ident, object reg, Type tag)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (m_TemplateProperty != null)
{
m_TemplateProperty.ListBroadcaster(ident, reg, tag);
}
else
{
m_ExpressionProperty.FlushComposer(ident, reg);
}
}
private string CancelBroadcaster(RecordClassDispatcher info, object attr)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
try
{
return(baseProperty.StopComposer()._0001((object)this, attr));
}
catch (Exception setup)
{
throw StrategyError.ValidateComposer(null, info._0001(), "Error writing object reference for '{0}'.".ListReader(CultureInfo.InvariantCulture, attr.GetType()), setup);
}
}
public override void _0001(RecordClassDispatcher setup, BroadcasterError[] b)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
setup._0001(m_ObserverIssuer);
int count = m_DescriptorIssuer.Count;
for (int i = 0; i < count; i++)
{
m_DescriptorIssuer[i]._0001(setup, b);
}
setup._0010();
}
private void SortBroadcaster(RecordClassDispatcher v, object attr, ProcTest role, ProductInstanceExpression t2, InitializerTest visitor3, ProductInstanceExpression selection4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
v._0002();
if ((PrintBroadcaster(role, t2, visitor3, selection4) ?? LoginClass(baseProperty.m_PageError, (TaskListAnnotation)1)) && (t2 == null || t2._0003() || CallBroadcaster(visitor3, t2)))
{
PublishBroadcaster(v, role._0002(), attr);
}
if (RunClass((SparklineAxisMinMaxValues)1, role, t2, visitor3, selection4))
{
WriteBroadcaster(v, role._0002());
}
}
private void VerifyClass(RecordClassDispatcher value, IEnumerable second, MessageTest state, ProductInstanceExpression reference2, InitializerTest v3, ProductInstanceExpression init4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManagerErrorFilter managerErrorFilter = second as ManagerErrorFilter;
object obj = (managerErrorFilter != null) ? managerErrorFilter._0001() : second;
ManageBroadcaster(value, state, obj);
wrapperProperty.Add(obj);
bool flag = ValidateClass(value, obj, state, reference2, v3, init4);
value._0003();
int lengthpred = value._0002();
int num = 0;
foreach (object item in second)
{
try
{
ProcTest procTest = ((InitializerTest)state)._0002() ?? DeleteBroadcaster(item);
if (CountBroadcaster(item, null, procTest, state, reference2))
{
QueryBroadcaster(value, item);
}
else if (CustomizeBroadcaster(value, item, null, procTest, state, reference2))
{
InvokeBroadcaster(value, item, procTest, null, state, reference2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(obj, state, num, null, value._0001(), ident))
{
throw;
}
EnableClass(value, lengthpred);
}
finally
{
num++;
}
}
value._000F();
if (flag)
{
value._0011();
}
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(value, state, obj);
}
private void EnableClass(RecordClassDispatcher item, int lengthpred)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
LoginBroadcaster();
if (item._0001() == (PlatformType)5)
{
item._0008();
}
while (item._0002() > lengthpred)
{
item.CollectTests();
}
}
internal void DefineClient(RecordClassDispatcher res)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = this._0001();
if (_InfoProperty)
{
res._0001(text, injectcust: false);
}
else
{
res._0002(text);
}
}
private void QueryBroadcaster(RecordClassDispatcher var1, object cust)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = CancelBroadcaster(var1, cust);
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
{
containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, var1._0002(), "Writing object reference to Id '{0}' for {1}.".SelectReader(CultureInfo.InvariantCulture, text, cust.GetType())), null);
}
var1._0002();
var1._0001("$ref", injectcust: false);
var1._0004(text);
var1._0011();
}
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);
}
private void PatchClass(RecordClassDispatcher i, Array result, MessageTest tag, ProductInstanceExpression connection2, InitializerTest ord3, ProductInstanceExpression asset4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(i, tag, result);
wrapperProperty.Add(result);
bool num = ValidateClass(i, result, tag, connection2, ord3, asset4);
FindClass(i, result, tag, connection2, i._0002(), ObserverIteratorMapping.CheckProperty <int>());
if (num)
{
i._0011();
}
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(i, tag, result);
}
public override void _0001(RecordClassDispatcher config, object caller, PrototypeError template)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
TokenClassSpec tokenClassSpec = (TokenClassSpec)caller;
TaskIteratorMapping taskIteratorMapping = config as TaskIteratorMapping;
if (taskIteratorMapping != null)
{
taskIteratorMapping.PopIterator(tokenClassSpec._0001());
}
else
{
config._0001(tokenClassSpec._0001());
}
}
public override void _0001(RecordClassDispatcher v, BroadcasterError[] counter)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
v._0002(m_RepositoryIssuer);
ParserFilterResolver parserFilterResolver = _0004();
if (parserFilterResolver != null)
{
parserFilterResolver._0001(v, counter);
}
else
{
v._0008();
}
}
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 void FindClass(RecordClassDispatcher instance, Array cont, MessageTest rule, ProductInstanceExpression ivk2, int cust3max, int[] last4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
int num = last4.Length;
int[] array = new int[num + 1];
for (int i = 0; i < num; i++)
{
array[i] = last4[i];
}
instance._0003();
for (int j = cont.GetLowerBound(num); j <= cont.GetUpperBound(num); j++)
{
array[num] = j;
if (array.Length == cont.Rank)
{
object value = cont.GetValue(array);
try
{
ProcTest procTest = ((InitializerTest)rule)._0002() ?? DeleteBroadcaster(value);
if (CountBroadcaster(value, null, procTest, rule, ivk2))
{
QueryBroadcaster(instance, value);
}
else if (CustomizeBroadcaster(instance, value, null, procTest, rule, ivk2))
{
InvokeBroadcaster(instance, value, procTest, null, rule, ivk2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(cont, rule, j, null, instance._0001(), ident))
{
throw;
}
EnableClass(instance, cust3max + 1);
}
}
else
{
FindClass(instance, cont, rule, ivk2, cust3max + 1, array);
}
}
instance._000F();
}
private void ManageRequest(RecordClassDispatcher task, XmlNamespaceManager result, bool skipres, CreatorIssuer cust2, string instance3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!CancelRequest(cust2))
{
InitRequest(task, cust2, result, skipres);
return;
}
if (skipres)
{
task._0002(instance3);
}
task._0003();
InitRequest(task, cust2, result, isresult2: false);
task._000F();
}
