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); } }