private void RevertRequest(TagTestItem instance, AttrBroadcasterFilter selection, string template, CreatorIssuer value2, XmlNamespaceManager item3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string dir = CustomerListAnnotation.CountIssuer(template);
InfoRequestStrategy infoRequestStrategy = FindIterator(template, selection, dir, item3);
value2._0001(infoRequestStrategy);
int num = 0;
while (instance._0001() && instance._0001() != WatcherComposer.EndArray)
{
CollectRequest(instance, selection, item3, template, infoRequestStrategy);
num++;
}
if (_0003())
{
LoginIterator(infoRequestStrategy, selection);
}
if (num == 1 && _0003())
{
foreach (CreatorIssuer item4 in ((CreatorIssuer)infoRequestStrategy)._0001())
{
InfoRequestStrategy infoRequestStrategy2 = item4 as InfoRequestStrategy;
if (infoRequestStrategy2 != null && ((CreatorIssuer)infoRequestStrategy2)._0001() == template)
{
LoginIterator(infoRequestStrategy2, selection);
break;
}
}
}
}
private byte[] RegisterRequest(TagTestItem spec)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
List <byte> list = new List <byte>();
while (spec._0001())
{
switch (spec._0001())
{
case WatcherComposer.Integer:
list.Add(Convert.ToByte(spec._0001(), CultureInfo.InvariantCulture));
break;
case WatcherComposer.EndArray:
return(list.ToArray());
default:
throw StrategyError.PatchComposer(spec, "Unexpected token when reading bytes: {0}".ListReader(CultureInfo.InvariantCulture, spec._0001()));
case WatcherComposer.Comment:
break;
}
}
throw StrategyError.PatchComposer(spec, "Unexpected end when reading bytes.");
}
private static WatcherIssuer CallClass(TagTestItem first, CodeIteratorMapping reg, IdentifierClientBridge util, ConfigurationIssuer col2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ColorMatrixFlag colorMatrixFlag = reg?._0001() ?? ((ColorMatrixFlag)0);
DecoratorReaderMapper obj = (DecoratorReaderMapper)col2;
string text = first._0001().ToString();
WatcherIssuer watcherIssuer = obj.DisableRequest(text, StringComparison.Ordinal);
if (watcherIssuer != null)
{
switch (colorMatrixFlag)
{
case (ColorMatrixFlag)1:
return(null);
case (ColorMatrixFlag)2:
throw ContextError.CheckComposer(first, "Property with the name '{0}' already exists in the current JSON object.".ListReader(CultureInfo.InvariantCulture, text));
}
}
WatcherIssuer watcherIssuer2 = new WatcherIssuer(text);
watcherIssuer2.TestClass(util, reg);
if (watcherIssuer == null)
{
col2.Add(watcherIssuer2);
}
else
{
watcherIssuer.DestroyClass(watcherIssuer2);
}
return(watcherIssuer2);
}
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);
}
private static Type SearchRequest(TagTestItem key)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
WatcherComposer watcherComposer = key._0001();
switch (watcherComposer)
{
case WatcherComposer.Integer:
case WatcherComposer.Float:
case WatcherComposer.String:
case WatcherComposer.Boolean:
case WatcherComposer.Date:
case WatcherComposer.Bytes:
return(key._0001());
case WatcherComposer.Null:
case WatcherComposer.Undefined:
case WatcherComposer.EndArray:
return(typeof(string));
case WatcherComposer.StartArray:
key.SortError();
if (key._0001() == WatcherComposer.StartObject)
{
return(typeof(DataTable));
}
return(SearchRequest(key).MakeArrayType());
default:
throw StrategyError.PatchComposer(key, "Unexpected JSON token when reading DataTable: {0}".ListReader(CultureInfo.InvariantCulture, watcherComposer));
}
}
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);
}
private object ChangeRequest(TagTestItem reference)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
IDictionary <string, object> dictionary = new ExpandoObject();
while (reference._0001())
{
switch (reference._0001())
{
case WatcherComposer.PropertyName:
{
string key = reference._0001().ToString();
if (!reference._0001())
{
throw StrategyError.PatchComposer(reference, "Unexpected end when reading ExpandoObject.");
}
object obj2 = dictionary[key] = RemoveRequest(reference);
break;
}
case WatcherComposer.EndObject:
return(dictionary);
}
}
throw StrategyError.PatchComposer(reference, "Unexpected end when reading ExpandoObject.");
}
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()));
}
internal override object _0001(TagTestItem value, Type cont)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (_ParamsProperty != null)
{
return(_ParamsProperty.PatchBroadcaster(value, cont, injectstate: false));
}
return(m_ExpressionProperty.AddComposer(value, cont));
}
private static void SetRequest(TagTestItem param, string ord)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
param.SortError();
if (param._0001() != WatcherComposer.PropertyName || !string.Equals(param._0001()?.ToString(), ord, StringComparison.OrdinalIgnoreCase))
{
throw new StrategyError("Expected JSON property '{0}'.".ListReader(CultureInfo.InvariantCulture, ord));
}
}
private ObjectIssuerImporter CreateComposer(TagTestItem key)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ObjectIssuerImporter objectIssuerImporter = new ObjectIssuerImporter(key);
if (key._0001() != 0)
{
objectIssuerImporter.InstantiateClass();
}
return(objectIssuerImporter);
}
public ObjectIssuerImporter(TagTestItem res)
{
//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();
_EventIssuer = res;
m_InstanceIssuer = new StringWriter(CultureInfo.InvariantCulture);
m_InstanceIssuer.Write("Deserialized JSON: " + Environment.NewLine);
filterIssuer = new StatusDicCandidate(m_InstanceIssuer);
filterIssuer._0001((TimeState)1);
}
public static MessageEventEntry FlushRequest(TagTestItem config)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
using (StatusDicCandidate statusDicCandidate = new StatusDicCandidate(stringWriter))
{
statusDicCandidate.IncludeTest(config);
return(new MessageEventEntry(stringWriter.ToString()));
}
}
}
private void SortRequest(TagTestItem spec, AttrBroadcasterFilter connection, CreatorIssuer template, string pred2, XmlNamespaceManager connection3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (SetterTest.StartReader(pred2))
{
throw StrategyError.PatchComposer(spec, "XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> token = null;
string asset = null;
if (!_0005())
{
token = (CheckIterator(spec) ? DisableIterator(spec, connection3) : null);
asset = CustomerListAnnotation.CountIssuer(pred2);
if (pred2.ExcludeReader('@'))
{
string text = pred2.Substring(1);
string reference = CustomerListAnnotation.CountIssuer(text);
PublishRequest(spec, connection, template, pred2, text, connection3, reference);
return;
}
if (pred2.ExcludeReader('$'))
{
switch (pred2)
{
case "$values":
pred2 = pred2.Substring(1);
asset = connection3.LookupPrefix("http://james.newtonking.com/projects/json");
CallRequest(spec, connection, template, pred2, connection3, asset, token);
return;
case "$id":
case "$ref":
case "$type":
case "$value":
{
string v = pred2.Substring(1);
string reference2 = connection3.LookupPrefix("http://james.newtonking.com/projects/json");
PublishRequest(spec, connection, template, pred2, v, connection3, reference2);
return;
}
}
}
}
else if (CheckIterator(spec))
{
spec.SortError();
}
CallRequest(spec, connection, template, pred2, connection3, asset, token);
}
public static bool PostIssuer(TagTestItem res, out DateTime reg, [ConsumerBroadcasterDispatcher(false)][_0008._0012(2)] out string _0004)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
reg = default(DateTime);
_0004 = null;
if (!ChangeIssuer(res, out long?counter, out _0004) || !counter.HasValue)
{
_0004 = (_0004 ?? "Date constructor has no arguments.");
return(false);
}
if (!ChangeIssuer(res, out long?counter2, out _0004))
{
return(false);
}
if (counter2.HasValue)
{
List <long> list = new List <long>
{
counter.Value,
counter2.Value
};
while (true)
{
if (!ChangeIssuer(res, out long?counter3, out _0004))
{
return(false);
}
if (!counter3.HasValue)
{
break;
}
list.Add(counter3.Value);
}
if (list.Count > 7)
{
_0004 = "Unexpected number of arguments when reading date constructor.";
return(false);
}
while (list.Count < 7)
{
list.Add(0L);
}
reg = new DateTime((int)list[0], (int)list[1] + 1, (int)((list[2] == 0L) ? 1 : list[2]), (int)list[3], (int)list[4], (int)list[5], (int)list[6]);
}
else
{
reg = DescriptorIteratorMapping.SearchProperty(counter.Value);
}
return(true);
}
private static void PublishRequest(TagTestItem def, AttrBroadcasterFilter cont, CreatorIssuer consumer, string res2, string v3, XmlNamespaceManager value4, string reference5)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (consumer._0001() == XmlNodeType.Document)
{
throw StrategyError.PatchComposer(def, "JSON root object has property '{0}' that will be converted to an attribute. A root object cannot have any attribute properties. Consider specifying a DeserializeRootElementName.".ListReader(CultureInfo.InvariantCulture, res2));
}
string text = XmlConvert.EncodeName(v3);
string text2 = WriteRequest(def);
CreatorIssuer key = (!SetterTest.StartReader(reference5)) ? cont._0002(text, value4.LookupNamespace(reference5), text2) : cont._0002(text, text2);
((InfoRequestStrategy)consumer)._0001(key);
}
private void CallRequest(TagTestItem def, AttrBroadcasterFilter attr, CreatorIssuer state, string pred2, XmlNamespaceManager reference3, string asset4, Dictionary <string, string> token5)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
InfoRequestStrategy infoRequestStrategy = FindIterator(pred2, attr, asset4, reference3);
state._0001(infoRequestStrategy);
if (token5 != null)
{
foreach (KeyValuePair <string, string> item in token5)
{
string text = XmlConvert.EncodeName(item.Key);
string text2 = CustomerListAnnotation.CountIssuer(item.Key);
CreatorIssuer key = (!SetterTest.StartReader(text2)) ? attr._0002(text, reference3.LookupNamespace(text2) ?? string.Empty, item.Value) : attr._0002(text, item.Value);
infoRequestStrategy._0001(key);
}
}
switch (def._0001())
{
case WatcherComposer.Null:
break;
case WatcherComposer.Integer:
case WatcherComposer.Float:
case WatcherComposer.String:
case WatcherComposer.Boolean:
case WatcherComposer.Date:
case WatcherComposer.Bytes:
{
string text3 = WriteRequest(def);
if (text3 != null)
{
((CreatorIssuer)infoRequestStrategy)._0001(attr._0002(text3));
}
break;
}
case WatcherComposer.EndObject:
reference3.RemoveNamespace(string.Empty, reference3.DefaultNamespace);
break;
default:
reference3.PushScope();
ValidateIterator(def, attr, reference3, infoRequestStrategy);
reference3.PopScope();
reference3.RemoveNamespace(string.Empty, reference3.DefaultNamespace);
break;
}
}
internal virtual object _0001(TagTestItem setup, Type vis)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(setup, "reader");
EnableComposer(setup, out CultureInfo selection, out PsMaxLengths? serv, out StubListAnnotation? visitor, out SudsUse? ident, out int?pred, out string attr);
ObjectIssuerImporter objectIssuerImporter = (this._0001() != null && this._0001()._0001() >= TraceLevel.Verbose) ? CreateComposer(setup) : null;
object result = new BroadcasterInstanceRule(this).PatchBroadcaster(objectIssuerImporter ?? setup, vis, this._0001());
if (objectIssuerImporter != null)
{
this._0001()._0001(TraceLevel.Verbose, objectIssuerImporter.CalcClass(), null);
}
MapComposer(setup, selection, serv, visitor, ident, pred, attr);
return(result);
}
internal void CollectClass(TagTestItem asset, CodeIteratorMapping selection)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
int num = asset._0003();
if (!asset._0001())
{
throw ContextError.CheckComposer(asset, "Error reading {0} from JsonReader.".ListReader(CultureInfo.InvariantCulture, GetType().Name));
}
SortClass(asset, selection);
if (asset._0003() > num)
{
throw ContextError.CheckComposer(asset, "Unexpected end of content while loading {0}.".ListReader(CultureInfo.InvariantCulture, GetType().Name));
}
}
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 object SelectRequest(TagTestItem ident)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = (string)ident._0001();
if (text.Length > 0 && text[0] == '/')
{
int num = text.LastIndexOf('/');
if (num > 0)
{
string pattern = text.Substring(1, num - 1);
RegexOptions options = CustomerListAnnotation.QueryIssuer(text.Substring(num + 1));
return(new Regex(pattern, options));
}
}
throw StrategyError.PatchComposer(ident, "Regex pattern must be enclosed by slashes.");
}
private void CollectRequest(TagTestItem def, AttrBroadcasterFilter cust, XmlNamespaceManager consumer, string reg2, CreatorIssuer second3)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!_0005())
{
switch (reg2)
{
case "#text":
second3._0001(cust._0002(WriteRequest(def)));
return;
case "#cdata-section":
second3._0001(cust._0003(WriteRequest(def)));
return;
case "#whitespace":
second3._0001(cust._0004(WriteRequest(def)));
return;
case "#significant-whitespace":
second3._0001(cust._0005(WriteRequest(def)));
return;
}
if (!SetterTest.StartReader(reg2) && reg2[0] == '?')
{
VerifyIterator(def, cust, second3, reg2);
return;
}
if (string.Equals(reg2, "!DOCTYPE", StringComparison.OrdinalIgnoreCase))
{
PatchIterator(def, cust, second3);
return;
}
}
if (def._0001() == WatcherComposer.StartArray)
{
RevertRequest(def, cust, reg2, second3, consumer);
}
else
{
SortRequest(def, cust, second3, reg2, consumer);
}
}
public static IndexerReaderMapper WriteClass(TagTestItem setup, CodeIteratorMapping reg)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (setup._0001() == WatcherComposer.None && !setup._0001())
{
throw ContextError.CheckComposer(setup, "Error reading JConstructor from JsonReader.");
}
setup.RevertError();
if (setup._0001() != WatcherComposer.StartConstructor)
{
throw ContextError.CheckComposer(setup, "Error reading JConstructor from JsonReader. Current JsonReader item is not a constructor: {0}".ListReader(CultureInfo.InvariantCulture, setup._0001()));
}
IndexerReaderMapper indexerReaderMapper = new IndexerReaderMapper((string)setup._0001());
indexerReaderMapper.TestClass(setup as IdentifierClientBridge, reg);
indexerReaderMapper.CollectClass(setup, reg);
return(indexerReaderMapper);
}
public static WatcherIssuer OrderRequest(TagTestItem info, CodeIteratorMapping selection)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (info._0001() == WatcherComposer.None && !info._0001())
{
throw ContextError.CheckComposer(info, "Error reading JProperty from JsonReader.");
}
info.RevertError();
if (info._0001() != WatcherComposer.PropertyName)
{
throw ContextError.CheckComposer(info, "Error reading JProperty from JsonReader. Current JsonReader item is not a property: {0}".ListReader(CultureInfo.InvariantCulture, info._0001()));
}
WatcherIssuer watcherIssuer = new WatcherIssuer((string)info._0001());
watcherIssuer.TestClass(info as IdentifierClientBridge, selection);
watcherIssuer.CollectClass(info, selection);
return(watcherIssuer);
}
public static InstanceClassDispatcher AssetClass(TagTestItem item, CodeIteratorMapping ivk)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (item._0001() == WatcherComposer.None && !item._0001())
{
throw ContextError.CheckComposer(item, "Error reading JArray from JsonReader.");
}
item.RevertError();
if (item._0001() != WatcherComposer.StartArray)
{
throw ContextError.CheckComposer(item, "Error reading JArray from JsonReader. Current JsonReader item is not an array: {0}".ListReader(CultureInfo.InvariantCulture, item._0001()));
}
InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher();
instanceClassDispatcher.TestClass(item as IdentifierClientBridge, ivk);
instanceClassDispatcher.CollectClass(item, ivk);
return(instanceClassDispatcher);
}
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.");
}
}
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.");
}
private bool CheckIterator(TagTestItem reference)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (reference._0001())
{
case WatcherComposer.StartConstructor:
case WatcherComposer.Integer:
case WatcherComposer.Float:
case WatcherComposer.String:
case WatcherComposer.Boolean:
case WatcherComposer.Null:
case WatcherComposer.Date:
case WatcherComposer.Bytes:
return(false);
default:
return(true);
}
}
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);
}