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 object _0001(TagTestItem def, Type ord, object dir, PrototypeError reg2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (def._0001() == WatcherComposer.Null)
{
return(null);
}
DataSet dataSet = (ord == typeof(DataSet)) ? new DataSet() : ((DataSet)Activator.CreateInstance(ord));
FieldReaderMapper fieldReaderMapper = new FieldReaderMapper();
def.SortError();
while (def._0001() == WatcherComposer.PropertyName)
{
DataTable dataTable = dataSet.Tables[(string)def._0001()];
bool num = dataTable != null;
dataTable = (DataTable)fieldReaderMapper._0001(def, typeof(DataTable), dataTable, reg2);
if (!num)
{
dataSet.Tables.Add(dataTable);
}
def.SortError();
}
return(dataSet);
}
public override object _0001(TagTestItem info, Type b, object c, PrototypeError asset2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (info._0001() == WatcherComposer.Null)
{
return(null);
}
DataTable dataTable = c as DataTable;
if (dataTable == null)
{
dataTable = ((b == typeof(DataTable)) ? new DataTable() : ((DataTable)Activator.CreateInstance(b)));
}
if (info._0001() == WatcherComposer.PropertyName)
{
dataTable.TableName = (string)info._0001();
info.SortError();
if (info._0001() == WatcherComposer.Null)
{
return(dataTable);
}
}
if (info._0001() != WatcherComposer.StartArray)
{
throw StrategyError.PatchComposer(info, "Unexpected JSON token when reading DataTable. Expected StartArray, got {0}.".ListReader(CultureInfo.InvariantCulture, info._0001()));
}
info.SortError();
while (info._0001() != WatcherComposer.EndArray)
{
RestartRequest(info, dataTable, asset2);
info.SortError();
}
return(dataTable);
}
public InterceptorInstanceExpression(PrototypeError config)
{
//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();
wrapperProperty = new List <object>();
base._002Ector(config);
}
private static void RestartRequest(TagTestItem instance, DataTable cont, PrototypeError template)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
DataRow dataRow = cont.NewRow();
instance.SortError();
while (instance._0001() == WatcherComposer.PropertyName)
{
string text = (string)instance._0001();
instance.SortError();
DataColumn dataColumn = cont.Columns[text];
if (dataColumn == null)
{
Type dataType = SearchRequest(instance);
dataColumn = new DataColumn(text, dataType);
cont.Columns.Add(dataColumn);
}
if (dataColumn.DataType == typeof(DataTable))
{
if (instance._0001() == WatcherComposer.StartArray)
{
instance.SortError();
}
DataTable dataTable = new DataTable();
while (instance._0001() != WatcherComposer.EndArray)
{
RestartRequest(instance, dataTable, template);
instance.SortError();
}
dataRow[text] = dataTable;
}
else if (!dataColumn.DataType.IsArray || !(dataColumn.DataType != typeof(byte[])))
{
object obj2 = dataRow[text] = ((instance._0001() != null) ? (template.AddComposer(instance, dataColumn.DataType) ?? DBNull.Value) : DBNull.Value);
}
else
{
if (instance._0001() == WatcherComposer.StartArray)
{
instance.SortError();
}
List <object> list = new List <object>();
while (instance._0001() != WatcherComposer.EndArray)
{
list.Add(instance._0001());
instance.SortError();
}
Array array = Array.CreateInstance(dataColumn.DataType.GetElementType(), list.Count);
((ICollection)list).CopyTo(array, 0);
dataRow[text] = array;
}
instance.SortError();
}
dataRow.EndEdit();
cont.Rows.Add(dataRow);
}
public override object _0001(TagTestItem setup, Type pol, object tag, PrototypeError def2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (setup._0001() != WatcherComposer.Bytes)
{
throw new StrategyError("Expected Bytes but got {0}.".ListReader(CultureInfo.InvariantCulture, setup._0001()));
}
return(new TokenClassSpec((byte[])setup._0001()));
}
public AlgoInstanceExpression(InterceptorInstanceExpression last)
{
//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();
ContextClientBridge.RunClient(last, "serializerWriter");
m_TemplateProperty = last;
m_ExpressionProperty = last.baseProperty;
}
public AlgoInstanceExpression(BroadcasterInstanceRule task)
{
//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();
ContextClientBridge.RunClient(task, "serializerReader");
_ParamsProperty = task;
m_ExpressionProperty = task.baseProperty;
}
protected RuleTestItem(PrototypeError item)
{
//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();
ContextClientBridge.RunClient(item, "serializer");
baseProperty = item;
containerProperty = item._0001();
}
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 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();
}
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 object _0001(TagTestItem config, Type ivk, object template, PrototypeError connection2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (config._0001() == WatcherComposer.Null)
{
if (!ResolverErrorFilter.PatchReader(ivk))
{
throw StrategyError.PatchComposer(config, "Cannot convert null value to KeyValuePair.");
}
return(null);
}
object obj = null;
object obj2 = null;
config.SortError();
Type res = ResolverErrorFilter.PatchReader(ivk) ? Nullable.GetUnderlyingType(ivk) : ivk;
ModelInstanceExpression modelInstanceExpression = m_ListenerIssuer.InitReader(res);
ProcTest procTest = connection2._0001()._0001(modelInstanceExpression.SetupIssuer("Key"));
ProcTest procTest2 = connection2._0001()._0001(modelInstanceExpression.SetupIssuer("Value"));
while (config._0001() == WatcherComposer.PropertyName)
{
string a = config._0001().ToString();
if (string.Equals(a, "Key", StringComparison.OrdinalIgnoreCase))
{
config.CallError(procTest, iscaller: false);
obj = connection2.AddComposer(config, procTest._0002());
}
else if (string.Equals(a, "Value", StringComparison.OrdinalIgnoreCase))
{
config.CallError(procTest2, iscaller: false);
obj2 = connection2.AddComposer(config, procTest2._0002());
}
else
{
config.AssetError();
}
config.SortError();
}
return(modelInstanceExpression._0001()(new object[2]
{
obj,
obj2
}));
}
private Regex DeleteRequest(TagTestItem config, PrototypeError result)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = null;
RegexOptions?regexOptions = null;
while (config._0001())
{
switch (config._0001())
{
case WatcherComposer.PropertyName:
{
string a = config._0001().ToString();
if (!config._0001())
{
throw StrategyError.PatchComposer(config, "Unexpected end when reading Regex.");
}
if (string.Equals(a, "Pattern", StringComparison.OrdinalIgnoreCase))
{
text = (string)config._0001();
}
else if (string.Equals(a, "Options", StringComparison.OrdinalIgnoreCase))
{
regexOptions = result.CompareComposer <RegexOptions>(config);
}
else
{
config.AssetError();
}
break;
}
case WatcherComposer.EndObject:
if (text == null)
{
throw StrategyError.PatchComposer(config, "Error deserializing Regex. No pattern found.");
}
return(new Regex(text, regexOptions.GetValueOrDefault()));
}
}
throw StrategyError.PatchComposer(config, "Unexpected end when reading Regex.");
}
public override object _0001(TagTestItem first, Type result, object pool, PrototypeError spec2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (first._0001())
{
case WatcherComposer.StartObject:
return(DeleteRequest(first, spec2));
case WatcherComposer.String:
return(SelectRequest(first));
case WatcherComposer.Null:
return(null);
default:
throw StrategyError.PatchComposer(first, "Unexpected token when reading Regex.");
}
}
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 object _0001(TagTestItem item, Type attr, object util, PrototypeError var12)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
RateRequest(attr);
object obj = m_SerializerIssuer._0001()(new object[0]);
SetRequest(item, "Key");
item.SortError();
m_SerializerIssuer.ExcludeIssuer(obj, "Key", item._0001()?.ToString());
SetRequest(item, "Type");
item.SortError();
Type type = Type.GetType(item._0001()?.ToString());
SetRequest(item, "Value");
item.SortError();
m_SerializerIssuer.ExcludeIssuer(obj, "Value", var12.AddComposer(item, type));
item.SortError();
return(obj);
}
public override object _0001(TagTestItem instance, Type pred, object res, PrototypeError reference2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (instance._0001() == WatcherComposer.Null)
{
if (!ResolverErrorFilter.VerifyReader(pred))
{
throw StrategyError.PatchComposer(instance, "Cannot convert null value to {0}.".ListReader(CultureInfo.InvariantCulture, pred));
}
return(null);
}
byte[] array;
if (instance._0001() == WatcherComposer.StartArray)
{
array = RegisterRequest(instance);
}
else
{
if (instance._0001() != WatcherComposer.String)
{
throw StrategyError.PatchComposer(instance, "Unexpected token parsing binary. Expected String or StartArray, got {0}.".ListReader(CultureInfo.InvariantCulture, instance._0001()));
}
array = Convert.FromBase64String(instance._0001().ToString());
}
Type type = ResolverErrorFilter.PatchReader(pred) ? Nullable.GetUnderlyingType(pred) : pred;
if (type.FullName == "System.Data.Linq.Binary")
{
ResetRequest(type);
return(_InfoIssuer._0001()(new object[1]
{
array
}));
}
if (type == typeof(SqlBinary))
{
return(new SqlBinary(array));
}
throw StrategyError.PatchComposer(instance, "Unexpected object type when writing binary: {0}".ListReader(CultureInfo.InvariantCulture, pred));
}
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 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 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();
}
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 spec, object selection, PrototypeError role)
{
} //Discarded unreachable code: IL_0002
public override object _0001(TagTestItem param, Type counter, object helper, PrototypeError config2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return(RemoveRequest(param));
}
public override object _0001(TagTestItem param, Type reg, object serv, PrototypeError first2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (param._0001())
{
case WatcherComposer.Null:
return(null);
default:
throw StrategyError.PatchComposer(param, "XmlNodeConverter can only convert JSON that begins with an object.");
case WatcherComposer.StartObject:
{
XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
AttrBroadcasterFilter attrBroadcasterFilter = null;
CreatorIssuer creatorIssuer = null;
if (typeof(XObject).IsAssignableFrom(reg))
{
if (reg != typeof(XContainer) && reg != typeof(XDocument) && reg != typeof(XElement) && reg != typeof(XNode) && reg != typeof(XObject))
{
throw StrategyError.PatchComposer(param, "XmlNodeConverter only supports deserializing XDocument, XElement, XContainer, XNode or XObject.");
}
attrBroadcasterFilter = new AuthenticationComposerPool(new XDocument());
creatorIssuer = attrBroadcasterFilter;
}
if (typeof(XmlNode).IsAssignableFrom(reg))
{
if (reg != typeof(XmlDocument) && reg != typeof(XmlElement) && reg != typeof(XmlNode))
{
throw StrategyError.PatchComposer(param, "XmlNodeConverter only supports deserializing XmlDocument, XmlElement or XmlNode.");
}
attrBroadcasterFilter = new ConnectionComposerWorker(new XmlDocument
{
XmlResolver = null
});
creatorIssuer = attrBroadcasterFilter;
}
if (attrBroadcasterFilter == null || creatorIssuer == null)
{
throw StrategyError.PatchComposer(param, "Unexpected type when converting XML: " + reg);
}
if (!SetterTest.StartReader(_0001()))
{
SortRequest(param, attrBroadcasterFilter, creatorIssuer, _0001(), xmlNamespaceManager);
}
else
{
param.SortError();
ValidateIterator(param, attrBroadcasterFilter, xmlNamespaceManager, creatorIssuer);
}
if (reg == typeof(XElement))
{
XElement obj = (XElement)((CreatorIssuer)attrBroadcasterFilter._0001())._0001();
obj.Remove();
return(obj);
}
if (reg == typeof(XmlElement))
{
return(((CreatorIssuer)attrBroadcasterFilter._0001())._0001());
}
return(((CreatorIssuer)attrBroadcasterFilter)._0001());
}
}
}
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.");
}
}
public override object _0001(TagTestItem ident, Type b, object field, PrototypeError config2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (ident._0001() == WatcherComposer.Null)
{
return(null);
}
FactoryDicCandidate factoryDicCandidate = null;
string text = null;
InstanceClassDispatcher instanceClassDispatcher = null;
ident.SortError();
while (ident._0001() == WatcherComposer.PropertyName)
{
string text2 = ident._0001().ToString();
if (string.Equals(text2, "Case", StringComparison.OrdinalIgnoreCase))
{
ident.SortError();
UtilsClientBridge utilsClientBridge = m_ParameterIssuer.InitReader(b);
text = ident._0001().ToString();
factoryDicCandidate = utilsClientBridge.m_StatusIssuer.SingleOrDefault((FactoryDicCandidate P_0) => P_0._HelperIssuer == text);
if (factoryDicCandidate == null)
{
throw StrategyError.PatchComposer(ident, "No union type found with the name '{0}'.".ListReader(CultureInfo.InvariantCulture, text));
}
}
else
{
if (!string.Equals(text2, "Fields", StringComparison.OrdinalIgnoreCase))
{
throw StrategyError.PatchComposer(ident, "Unexpected property '{0}' found when reading union.".ListReader(CultureInfo.InvariantCulture, text2));
}
ident.SortError();
if (ident._0001() != WatcherComposer.StartArray)
{
throw StrategyError.PatchComposer(ident, "Union fields must been an array.");
}
instanceClassDispatcher = (InstanceClassDispatcher)ParserFilterResolver.SelectClass(ident);
}
ident.SortError();
}
if (factoryDicCandidate == null)
{
throw StrategyError.PatchComposer(ident, "No '{0}' property with union name found.".ListReader(CultureInfo.InvariantCulture, "Case"));
}
object[] array = new object[factoryDicCandidate.exceptionIssuer.Length];
if (factoryDicCandidate.exceptionIssuer.Length != 0 && instanceClassDispatcher == null)
{
throw StrategyError.PatchComposer(ident, "No '{0}' property with union fields found.".ListReader(CultureInfo.InvariantCulture, "Fields"));
}
if (instanceClassDispatcher != null)
{
if (factoryDicCandidate.exceptionIssuer.Length != instanceClassDispatcher.get_Count())
{
throw StrategyError.PatchComposer(ident, "The number of field values does not match the number of properties defined by union '{0}'.".ListReader(CultureInfo.InvariantCulture, text));
}
for (int i = 0; i < instanceClassDispatcher.get_Count(); i++)
{
ParserFilterResolver parserFilterResolver = instanceClassDispatcher[i];
PropertyInfo propertyInfo = factoryDicCandidate.exceptionIssuer[i];
array[i] = parserFilterResolver.ListClass(propertyInfo.PropertyType, config2);
}
}
object[] task = new object[1]
{
array
};
return(factoryDicCandidate.m_DatabaseIssuer.ConnectIssuer(task));
}
