public override void _0003()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
((RecordClassDispatcher)m_ComposerIssuer)._0003();
errorIssuer._0003();
base._0003();
}
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 _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();
}
public DicIssuer(RecordClassDispatcher 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();
errorIssuer = asset;
m_PropertyIssuer = new StringWriter(CultureInfo.InvariantCulture);
m_PropertyIssuer.Write("Serialized JSON: " + Environment.NewLine);
m_ComposerIssuer = new StatusDicCandidate(m_PropertyIssuer);
m_ComposerIssuer._0001((TimeState)1);
m_ComposerIssuer._0001(asset._0001());
m_ComposerIssuer._0001(asset._0001());
m_ComposerIssuer._0007(asset._0003());
m_ComposerIssuer._0001(asset._0001());
m_ComposerIssuer._0001(asset._0001());
}
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();
}
internal virtual void _0001(RecordClassDispatcher param, object cont, Type c)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(param, "jsonWriter");
TimeState?timeState = null;
if (_RuleError.HasValue && param._0001() != _RuleError)
{
timeState = param._0001();
param._0001(_RuleError.GetValueOrDefault());
}
FindDirection?findDirection = null;
if (m_BridgeError.HasValue && param._0001() != m_BridgeError)
{
findDirection = param._0001();
param._0001(m_BridgeError.GetValueOrDefault());
}
PsMaxLengths?psMaxLengths = null;
if (importerError.HasValue && param._0001() != importerError)
{
psMaxLengths = param._0001();
param._0001(importerError.GetValueOrDefault());
}
ApplicationPartitionType?applicationPartitionType = null;
if (m_IndexerError.HasValue && param._0001() != m_IndexerError)
{
applicationPartitionType = param._0001();
param._0001(m_IndexerError.GetValueOrDefault());
}
GraphGroupStyle?graphGroupStyle = null;
if (_FieldError.HasValue && param._0001() != _FieldError)
{
graphGroupStyle = param._0001();
param._0001(_FieldError.GetValueOrDefault());
}
CultureInfo cultureInfo = null;
if (m_ItemError != null && !m_ItemError.Equals(param._0001()))
{
cultureInfo = param._0001();
param._0001(m_ItemError);
}
string var = null;
if (proccesorError && param._0003() != containerError)
{
var = param._0003();
param._0007(containerError);
}
DicIssuer dicIssuer = (this._0001() != null && this._0001()._0001() >= TraceLevel.Verbose) ? new DicIssuer(param) : null;
new InterceptorInstanceExpression(this).ListBroadcaster(dicIssuer ?? param, cont, c);
if (dicIssuer != null)
{
this._0001()._0001(TraceLevel.Verbose, dicIssuer.ReflectClass(), null);
}
if (timeState.HasValue)
{
param._0001(timeState.GetValueOrDefault());
}
if (findDirection.HasValue)
{
param._0001(findDirection.GetValueOrDefault());
}
if (psMaxLengths.HasValue)
{
param._0001(psMaxLengths.GetValueOrDefault());
}
if (applicationPartitionType.HasValue)
{
param._0001(applicationPartitionType.GetValueOrDefault());
}
if (graphGroupStyle.HasValue)
{
param._0001(graphGroupStyle.GetValueOrDefault());
}
if (proccesorError)
{
param._0007(var);
}
if (cultureInfo != null)
{
param._0001(cultureInfo);
}
}
private string AddClass(RecordClassDispatcher item, object result, ProcTest temp, out bool last2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (temp._ErrorProperty == (ParameterFilterResolver)3)
{
ProccesorClassSpec proccesorClassSpec = (ProccesorClassSpec)temp;
switch (proccesorClassSpec._0001())
{
case (SettingsSerializeAs)26:
case (SettingsSerializeAs)27:
{
DateTime token = DescriptorIteratorMapping.ReadProperty((DateTime)result, item._0001());
last2 = false;
StringWriter stringWriter2 = new StringWriter(CultureInfo.InvariantCulture);
DescriptorIteratorMapping.TestProperty(stringWriter2, token, item._0001(), item._0003(), item._0001());
return(stringWriter2.ToString());
}
case (SettingsSerializeAs)28:
case (SettingsSerializeAs)29:
{
last2 = false;
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
DescriptorIteratorMapping.AssetProperty(stringWriter, (DateTimeOffset)result, item._0001(), item._0003(), item._0001());
return(stringWriter.ToString());
}
case (SettingsSerializeAs)24:
case (SettingsSerializeAs)25:
{
double num = (double)result;
last2 = false;
return(num.ToString("R", CultureInfo.InvariantCulture));
}
case (SettingsSerializeAs)22:
case (SettingsSerializeAs)23:
{
float num2 = (float)result;
last2 = false;
return(num2.ToString("R", CultureInfo.InvariantCulture));
}
default:
{
last2 = true;
if (proccesorClassSpec._FilterProperty && InfoFilterResolver.InsertIssuer(proccesorClassSpec._InstanceProperty, result, null, out string _0005))
{
return(_0005);
}
return(Convert.ToString(result, CultureInfo.InvariantCulture));
}
}
}
if (ExcludeBroadcaster(result, result.GetType(), out string _0004))
{
last2 = true;
return(_0004);
}
last2 = true;
return(result.ToString());
}