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 _0008()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
m_ComposerIssuer._0008();
errorIssuer._0008();
base._000E();
}
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);
}
public override void _0001(RecordClassDispatcher v, object col, PrototypeError role)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (col == null)
{
v._0008();
return;
}
RateRequest(col.GetType());
PublisherRequestStrategy publisherRequestStrategy = role._0001() as PublisherRequestStrategy;
string init = (string)m_SerializerIssuer.CancelIssuer(col, "Key");
object obj = m_SerializerIssuer.CancelIssuer(col, "Value");
Type type = obj?.GetType();
v._0002();
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key");
v._0004(init);
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Type") : "Type");
v._0004(type?.FullName);
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value");
if (type != null)
{
if (InterceptorInstanceExpression.ExcludeBroadcaster(obj, type, out string _0004))
{
v._0004(_0004);
}
else
{
v._0001(obj);
}
}
else
{
v._0008();
}
v._0011();
}
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();
}
}
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();
}
}
public override void _0001(RecordClassDispatcher config, object col, PrototypeError dic)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (col == null)
{
config._0008();
return;
}
ModelInstanceExpression modelInstanceExpression = m_ListenerIssuer.InitReader(col.GetType());
PublisherRequestStrategy publisherRequestStrategy = dic._0001() as PublisherRequestStrategy;
config._0002();
config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key");
dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Key"), modelInstanceExpression.SetupIssuer("Key"));
config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value");
dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Value"), modelInstanceExpression.SetupIssuer("Value"));
config._0011();
}
public override void _0001(RecordClassDispatcher spec, object map, PrototypeError consumer)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (map == null)
{
spec._0008();
return;
}
Regex regex = (Regex)map;
TaskIteratorMapping taskIteratorMapping = spec as TaskIteratorMapping;
if (taskIteratorMapping != null)
{
StartRequest(taskIteratorMapping, regex);
}
else
{
ListRequest(spec, regex, consumer);
}
}
public override void _0001(RecordClassDispatcher res, object connection, PrototypeError third)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (connection == null)
{
res._0008();
return;
}
DataSet obj = (DataSet)connection;
PublisherRequestStrategy publisherRequestStrategy = third._0001() as PublisherRequestStrategy;
FieldReaderMapper fieldReaderMapper = new FieldReaderMapper();
res._0002();
foreach (DataTable table in obj.Tables)
{
res._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(table.TableName) : table.TableName);
fieldReaderMapper._0001(res, table, third);
}
res._0011();
}
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();
}
public override void _0001(RecordClassDispatcher i, object visitor, PrototypeError third)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (visitor == null)
{
i._0008();
return;
}
CreatorIssuer creatorIssuer = CountRequest(visitor);
XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
AssetRequest(creatorIssuer, xmlNamespaceManager);
if (!_0004())
{
i._0002();
}
InitRequest(i, creatorIssuer, xmlNamespaceManager, !_0004());
if (!_0004())
{
i._0011();
}
}
public override void _0001(RecordClassDispatcher task, BroadcasterError[] counter)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (counter != null && counter.Length != 0 && m_InvocationIssuer != null)
{
BroadcasterError broadcasterError = PrototypeError.LogoutComposer(counter, m_InvocationIssuer.GetType());
if (broadcasterError != null && broadcasterError._0001())
{
broadcasterError._0001(task, m_InvocationIssuer, PrototypeError.FillComposer());
return;
}
}
switch (_ValIssuer)
{
case Newtonsoft.Rules.UnicodeCategory.Comment:
task._0005(m_InvocationIssuer?.ToString());
break;
case Newtonsoft.Rules.UnicodeCategory.Raw:
task._0006(m_InvocationIssuer?.ToString());
break;
case Newtonsoft.Rules.UnicodeCategory.Null:
task._0008();
break;
case Newtonsoft.Rules.UnicodeCategory.Undefined:
task._000E();
break;
case Newtonsoft.Rules.UnicodeCategory.Integer:
{
object invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is int)
{
int first_Low = (int)invocationIssuer;
task._0001(first_Low);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is long)
{
long asset2 = (long)invocationIssuer;
task._0001(asset2);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is ulong)
{
ulong specID = (ulong)invocationIssuer;
task._0001(specID);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is BigInteger)
{
BigInteger bigInteger = (BigInteger)invocationIssuer;
task._0001(bigInteger);
}
else
{
task._0001(Convert.ToInt64(m_InvocationIssuer, CultureInfo.InvariantCulture));
}
break;
}
case Newtonsoft.Rules.UnicodeCategory.Float:
{
object invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is decimal)
{
decimal asset = (decimal)invocationIssuer;
task._0001(asset);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is double)
{
double last = (double)invocationIssuer;
task._0001(last);
break;
}
invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is float)
{
float init = (float)invocationIssuer;
task._0001(init);
}
else
{
task._0001(Convert.ToDouble(m_InvocationIssuer, CultureInfo.InvariantCulture));
}
break;
}
case Newtonsoft.Rules.UnicodeCategory.String:
task._0004(m_InvocationIssuer?.ToString());
break;
case Newtonsoft.Rules.UnicodeCategory.Boolean:
task._0001(Convert.ToBoolean(m_InvocationIssuer, CultureInfo.InvariantCulture));
break;
case Newtonsoft.Rules.UnicodeCategory.Date:
{
object invocationIssuer = m_InvocationIssuer;
if (invocationIssuer is DateTimeOffset)
{
DateTimeOffset last2 = (DateTimeOffset)invocationIssuer;
task._0001(last2);
}
else
{
task._0001(Convert.ToDateTime(m_InvocationIssuer, CultureInfo.InvariantCulture));
}
break;
}
case Newtonsoft.Rules.UnicodeCategory.Bytes:
task._0001((byte[])m_InvocationIssuer);
break;
case Newtonsoft.Rules.UnicodeCategory.Guid:
task._0001((m_InvocationIssuer != null) ? ((Guid?)m_InvocationIssuer) : null);
break;
case Newtonsoft.Rules.UnicodeCategory.TimeSpan:
task._0001((m_InvocationIssuer != null) ? ((TimeSpan?)m_InvocationIssuer) : null);
break;
case Newtonsoft.Rules.UnicodeCategory.Uri:
task._0001((Uri)m_InvocationIssuer);
break;
default:
throw CustomerListAnnotation.ConcatIssuer("Type", _ValIssuer, "Unexpected token type.");
}
}
private void InitRequest(RecordClassDispatcher first, CreatorIssuer second, XmlNamespaceManager template, bool isresult2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (second._0001())
{
case XmlNodeType.Document:
case XmlNodeType.DocumentFragment:
ExcludeRequest(first, second, template, isresult2);
break;
case XmlNodeType.Element:
if (CancelRequest(second) && DefineRequest(second) && second._0001().Count > 0)
{
ExcludeRequest(first, second, template, hasattr2: false);
break;
}
template.PushScope();
foreach (CreatorIssuer item in second._0002())
{
if (item._0003() == "http://www.w3.org/2000/xmlns/")
{
string prefix = (item._0001() != "xmlns") ? XmlConvert.DecodeName(item._0001()) : string.Empty;
string text = item._0002();
if (text == null)
{
throw new StrategyError("Namespace attribute must have a value.");
}
template.AddNamespace(prefix, text);
}
}
if (isresult2)
{
first._0002(QueryRequest(second, template));
}
if (!ResolveIterator(second._0002()) && second._0001().Count == 1 && second._0001()[0]._0001() == XmlNodeType.Text)
{
first._0004(second._0001()[0]._0002());
}
else if (second._0001().Count == 0 && second._0002().Count == 0)
{
if (((InfoRequestStrategy)second)._0001())
{
first._0008();
}
else
{
first._0004(string.Empty);
}
}
else
{
first._0002();
for (int i = 0; i < second._0002().Count; i++)
{
InitRequest(first, second._0002()[i], template, isresult2: true);
}
ExcludeRequest(first, second, template, hasattr2: true);
first._0011();
}
template.PopScope();
break;
case XmlNodeType.Comment:
if (isresult2)
{
first._0005(second._0002());
}
break;
case XmlNodeType.Attribute:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if ((!(second._0003() == "http://www.w3.org/2000/xmlns/") || !(second._0002() == "http://james.newtonking.com/projects/json")) && (!(second._0003() == "http://james.newtonking.com/projects/json") || !(second._0001() == "Array")))
{
if (isresult2)
{
first._0002(QueryRequest(second, template));
}
first._0004(second._0002());
}
break;
case XmlNodeType.XmlDeclaration:
{
DicEventConsumer dicEventConsumer = (DicEventConsumer)second;
first._0002(QueryRequest(second, template));
first._0002();
if (!SetterTest.StartReader(dicEventConsumer._0004()))
{
first._0002("@version");
first._0004(dicEventConsumer._0004());
}
if (!SetterTest.StartReader(dicEventConsumer._0005()))
{
first._0002("@encoding");
first._0004(dicEventConsumer._0005());
}
if (!SetterTest.StartReader(dicEventConsumer._0006()))
{
first._0002("@standalone");
first._0004(dicEventConsumer._0006());
}
first._0011();
break;
}
case XmlNodeType.DocumentType:
{
IndexerIssuer indexerIssuer = (IndexerIssuer)second;
first._0002(QueryRequest(second, template));
first._0002();
if (!SetterTest.StartReader(indexerIssuer._0004()))
{
first._0002("@name");
first._0004(indexerIssuer._0004());
}
if (!SetterTest.StartReader(indexerIssuer._0006()))
{
first._0002("@public");
first._0004(indexerIssuer._0006());
}
if (!SetterTest.StartReader(indexerIssuer._0005()))
{
first._0002("@system");
first._0004(indexerIssuer._0005());
}
if (!SetterTest.StartReader(indexerIssuer._0007()))
{
first._0002("@internalSubset");
first._0004(indexerIssuer._0007());
}
first._0011();
break;
}
default:
throw new StrategyError("Unexpected XmlNodeType when serializing nodes: " + second._0001());
}
}
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;
}
}