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 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 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 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 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 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));
}
}
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()));
}
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);
}
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 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
}));
}
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 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);
}
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 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 static DecoratorReaderMapper VerifyRequest(TagTestItem config, CodeIteratorMapping col)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(config, "reader");
if (config._0001() == WatcherComposer.None && !config._0001())
{
throw ContextError.CheckComposer(config, "Error reading JObject from JsonReader.");
}
config.RevertError();
if (config._0001() != WatcherComposer.StartObject)
{
throw ContextError.CheckComposer(config, "Error reading JObject from JsonReader. Current JsonReader item is not an object: {0}".ListReader(CultureInfo.InvariantCulture, config._0001()));
}
DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper();
decoratorReaderMapper.TestClass(config as IdentifierClientBridge, col);
decoratorReaderMapper.CollectClass(config, col);
return(decoratorReaderMapper);
}
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);
}
private void VerifyIterator(TagTestItem setup, AttrBroadcasterFilter visitor, CreatorIssuer temp, string setup2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (setup2 == "?xml")
{
string instance = null;
string caller = null;
string tag = null;
while (setup._0001() && setup._0001() != WatcherComposer.EndObject)
{
switch (setup._0001()?.ToString())
{
case "@version":
setup.SortError();
instance = WriteRequest(setup);
break;
case "@encoding":
setup.SortError();
caller = WriteRequest(setup);
break;
case "@standalone":
setup.SortError();
tag = WriteRequest(setup);
break;
default:
throw StrategyError.PatchComposer(setup, "Unexpected property name encountered while deserializing XmlDeclaration: " + setup._0001());
}
}
CreatorIssuer asset = visitor._0001(instance, caller, tag);
temp._0001(asset);
}
else
{
CreatorIssuer asset2 = visitor._0001(setup2.Substring(1), WriteRequest(setup));
temp._0001(asset2);
}
}
private void PatchIterator(TagTestItem setup, AttrBroadcasterFilter selection, CreatorIssuer util)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string spec = null;
string caller = null;
string state = null;
string config = null;
while (setup._0001() && setup._0001() != WatcherComposer.EndObject)
{
switch (setup._0001()?.ToString())
{
case "@name":
setup.SortError();
spec = WriteRequest(setup);
break;
case "@public":
setup.SortError();
caller = WriteRequest(setup);
break;
case "@system":
setup.SortError();
state = WriteRequest(setup);
break;
case "@internalSubset":
setup.SortError();
config = WriteRequest(setup);
break;
default:
throw StrategyError.PatchComposer(setup, "Unexpected property name encountered while deserializing XmlDeclaration: " + setup._0001());
}
}
CreatorIssuer asset = selection._0001(spec, caller, state, config);
util._0001(asset);
}
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));
}
private object PostRequest(TagTestItem init)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
IList <object> list = new List <object>();
while (init._0001())
{
switch (init._0001())
{
case WatcherComposer.EndArray:
return(list);
case WatcherComposer.Comment:
continue;
}
object item = RemoveRequest(init);
list.Add(item);
}
throw StrategyError.PatchComposer(init, "Unexpected end when reading ExpandoObject.");
}
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 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 static bool ChangeIssuer(TagTestItem i, out long?counter, [_0008._0012(2)] out string _0004)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
counter = null;
_0004 = null;
if (!i._0001())
{
_0004 = "Unexpected end when reading date constructor.";
return(false);
}
if (i._0001() == WatcherComposer.EndConstructor)
{
return(true);
}
if (i._0001() != WatcherComposer.Integer)
{
_0004 = "Unexpected token when reading date constructor. Expected Integer, got " + i._0001();
return(false);
}
counter = (long)i._0001();
return(true);
}
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;
}
}
private object RemoveRequest(TagTestItem spec)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!spec.RevertError())
{
throw StrategyError.PatchComposer(spec, "Unexpected end when reading ExpandoObject.");
}
switch (spec._0001())
{
case WatcherComposer.StartObject:
return(ChangeRequest(spec));
case WatcherComposer.StartArray:
return(PostRequest(spec));
default:
if (RulesClientBridge.StartIssuer(spec._0001()))
{
return(spec._0001());
}
throw StrategyError.PatchComposer(spec, "Unexpected token when converting ExpandoObject: {0}".ListReader(CultureInfo.InvariantCulture, spec._0001()));
}
}
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));
}
}
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 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 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);
}
}
