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);
        }
예제 #2
0
 public static DecoratorReaderMapper FindRequest(string config, CodeIteratorMapping second)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     using (TagTestItem tagTestItem = new RequestComposerPool(new StringReader(config)))
     {
         DecoratorReaderMapper result = VerifyRequest(tagTestItem, second);
         while (tagTestItem._0001())
         {
         }
         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));
            }
        }
예제 #4
0
        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);
        }
예제 #5
0
        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);
        }
예제 #6
0
        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);
        }
예제 #7
0
        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);
        }
        internal void SortClass(TagTestItem setup, CodeIteratorMapping cust)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ContextClientBridge.RunClient(setup, "r");
            IdentifierClientBridge identifierClientBridge = setup as IdentifierClientBridge;
            ConfigurationIssuer    configurationIssuer    = this;

            do
            {
                WatcherIssuer watcherIssuer = configurationIssuer as WatcherIssuer;
                if (watcherIssuer != null && watcherIssuer._0004() != null)
                {
                    if (configurationIssuer == this)
                    {
                        break;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                }
                switch (setup._0001())
                {
                case WatcherComposer.StartArray:
                {
                    InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher();
                    instanceClassDispatcher.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(instanceClassDispatcher);
                    configurationIssuer = instanceClassDispatcher;
                    break;
                }

                case WatcherComposer.EndArray:
                    if (configurationIssuer == this)
                    {
                        return;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                    break;

                case WatcherComposer.StartObject:
                {
                    DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper();
                    decoratorReaderMapper.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(decoratorReaderMapper);
                    configurationIssuer = decoratorReaderMapper;
                    break;
                }

                case WatcherComposer.EndObject:
                    if (configurationIssuer == this)
                    {
                        return;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                    break;

                case WatcherComposer.StartConstructor:
                {
                    IndexerReaderMapper indexerReaderMapper = new IndexerReaderMapper(setup._0001().ToString());
                    indexerReaderMapper.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(indexerReaderMapper);
                    configurationIssuer = indexerReaderMapper;
                    break;
                }

                case WatcherComposer.EndConstructor:
                    if (configurationIssuer == this)
                    {
                        return;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                    break;

                case WatcherComposer.Integer:
                case WatcherComposer.Float:
                case WatcherComposer.String:
                case WatcherComposer.Boolean:
                case WatcherComposer.Date:
                case WatcherComposer.Bytes:
                {
                    PoolIssuer poolIssuer = new PoolIssuer(setup._0001());
                    poolIssuer.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(poolIssuer);
                    break;
                }

                case WatcherComposer.Comment:
                    if (cust != null && cust._0001() == (XlOLEVerb)1)
                    {
                        PoolIssuer poolIssuer = PoolIssuer.LogoutRequest(setup._0001().ToString());
                        poolIssuer.TestClass(identifierClientBridge, cust);
                        configurationIssuer.Add(poolIssuer);
                    }
                    break;

                case WatcherComposer.Null:
                {
                    PoolIssuer poolIssuer = PoolIssuer.VisitRequest();
                    poolIssuer.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(poolIssuer);
                    break;
                }

                case WatcherComposer.Undefined:
                {
                    PoolIssuer poolIssuer = PoolIssuer.ViewRequest();
                    poolIssuer.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(poolIssuer);
                    break;
                }

                case WatcherComposer.PropertyName:
                {
                    WatcherIssuer watcherIssuer2 = CallClass(setup, cust, identifierClientBridge, configurationIssuer);
                    if (watcherIssuer2 != null)
                    {
                        configurationIssuer = watcherIssuer2;
                    }
                    else
                    {
                        setup.AssetError();
                    }
                    break;
                }

                default:
                    throw new InvalidOperationException("The JsonReader should not be on a token of type {0}.".ListReader(CultureInfo.InvariantCulture, setup._0001()));

                case WatcherComposer.None:
                    break;
                }
            }while (setup._0001());
        }