Beispiel #1
0
        public void _0003(ParserFilterResolver param)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            CustomizeClass();
            ParserFilterResolver cust = param ?? PoolIssuer.VisitRequest();

            if (collectionIssuer.m_ServerIssuer == null)
            {
                _0001(0, cust, isconsumer: false);
            }
            else
            {
                _0001(0, cust);
            }
        }
 internal ParserFilterResolver CancelClass(ParserFilterResolver first, bool removevis)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (first == null)
     {
         return(PoolIssuer.VisitRequest());
     }
     if (removevis)
     {
         return(first);
     }
     if (first._0001() != null || first == this || (first._0001() && base._0005() == first))
     {
         first = first._0001();
     }
     return(first);
 }
 internal void InstantiateRequest(PoolIssuer first, WatcherComposer col)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (m_ParamIssuer != null)
     {
         m_ParamIssuer.Add(first);
         utilsIssuer = ((ParserFilterResolver)m_ParamIssuer)._0003();
         if (((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property)
         {
             m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001();
         }
     }
     else
     {
         _PublisherIssuer = (first ?? PoolIssuer.VisitRequest());
         utilsIssuer      = _PublisherIssuer;
     }
 }
        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());
        }