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();
}
public override void _000F()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
m_ComposerIssuer._000F();
errorIssuer._000F();
base._000F();
}
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();
}
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 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();
}
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 SetupRequest(RecordClassDispatcher reference, XmlNamespaceManager cont, bool addcomp, List <CreatorIssuer> vis2, string ident3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (vis2.Count == 1 && !CancelRequest(vis2[0]))
{
InitRequest(reference, vis2[0], cont, addcomp);
return;
}
if (addcomp)
{
reference._0002(ident3);
}
reference._0003();
for (int i = 0; i < vis2.Count; i++)
{
InitRequest(reference, vis2[i], cont, isresult2: false);
}
reference._000F();
}
public override void _0001(RecordClassDispatcher v, object ivk, PrototypeError util)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (ivk == null)
{
v._0008();
return;
}
PublisherRequestStrategy publisherRequestStrategy = util._0001() as PublisherRequestStrategy;
Type res = m_PrototypeIssuer.InitReader(ivk.GetType());
UtilsClientBridge utilsClientBridge = m_ParameterIssuer.InitReader(res);
int num = (int)utilsClientBridge._ParserIssuer.ConnectIssuer(new object[1]
{
ivk
});
FactoryDicCandidate factoryDicCandidate = utilsClientBridge.m_StatusIssuer.Single((FactoryDicCandidate P_0) => P_0.pageIssuer == num);
v._0002();
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Case") : "Case");
v._0004(factoryDicCandidate._HelperIssuer);
if (factoryDicCandidate.exceptionIssuer != null && factoryDicCandidate.exceptionIssuer.Length != 0)
{
object[] obj = (object[])factoryDicCandidate.attributeIssuer.ConnectIssuer(new object[1]
{
ivk
});
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Fields") : "Fields");
v._0003();
object[] array = obj;
foreach (object reg in array)
{
util.FlushComposer(v, reg);
}
v._000F();
}
v._0011();
}