public override void _0001(RecordClassDispatcher item, object cfg, PrototypeError filter)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (cfg == null)
            {
                item._0008();
                return;
            }
            DataTable obj = (DataTable)cfg;
            PublisherRequestStrategy publisherRequestStrategy = filter._0001() as PublisherRequestStrategy;

            item._0003();
            foreach (DataRow row in obj.Rows)
            {
                item._0002();
                foreach (DataColumn column in row.Table.Columns)
                {
                    object obj2 = row[column];
                    if (filter._0001() != (ApplicationState)1 || (obj2 != null && obj2 != DBNull.Value))
                    {
                        item._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(column.ColumnName) : column.ColumnName);
                        filter.FlushComposer(item, obj2);
                    }
                }
                item._0011();
            }
            item._000F();
        }
Beispiel #2
0
 public override void _0008()
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     m_ComposerIssuer._0008();
     errorIssuer._0008();
     base._000E();
 }
 public override void _0001(RecordClassDispatcher config, object caller, PrototypeError comp)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (caller == null)
     {
         config._0008();
         return;
     }
     byte[] item = ReflectRequest(caller);
     config._0001(item);
 }
Beispiel #4
0
        public override void _0001(RecordClassDispatcher v, object col, PrototypeError role)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (col == null)
            {
                v._0008();
                return;
            }
            RateRequest(col.GetType());
            PublisherRequestStrategy publisherRequestStrategy = role._0001() as PublisherRequestStrategy;
            string init = (string)m_SerializerIssuer.CancelIssuer(col, "Key");
            object obj  = m_SerializerIssuer.CancelIssuer(col, "Value");
            Type   type = obj?.GetType();

            v._0002();
            v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key");
            v._0004(init);
            v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Type") : "Type");
            v._0004(type?.FullName);
            v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value");
            if (type != null)
            {
                if (InterceptorInstanceExpression.ExcludeBroadcaster(obj, type, out string _0004))
                {
                    v._0004(_0004);
                }
                else
                {
                    v._0001(obj);
                }
            }
            else
            {
                v._0008();
            }
            v._0011();
        }
 private void EnableClass(RecordClassDispatcher item, int lengthpred)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     LoginBroadcaster();
     if (item._0001() == (PlatformType)5)
     {
         item._0008();
     }
     while (item._0002() > lengthpred)
     {
         item.CollectTests();
     }
 }
Beispiel #6
0
        public override void _0001(RecordClassDispatcher v, BroadcasterError[] counter)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            v._0002(m_RepositoryIssuer);
            ParserFilterResolver parserFilterResolver = _0004();

            if (parserFilterResolver != null)
            {
                parserFilterResolver._0001(v, counter);
            }
            else
            {
                v._0008();
            }
        }
        public override void _0001(RecordClassDispatcher config, object col, PrototypeError dic)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (col == null)
            {
                config._0008();
                return;
            }
            ModelInstanceExpression  modelInstanceExpression  = m_ListenerIssuer.InitReader(col.GetType());
            PublisherRequestStrategy publisherRequestStrategy = dic._0001() as PublisherRequestStrategy;

            config._0002();
            config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key");
            dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Key"), modelInstanceExpression.SetupIssuer("Key"));
            config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value");
            dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Value"), modelInstanceExpression.SetupIssuer("Value"));
            config._0011();
        }
        public override void _0001(RecordClassDispatcher spec, object map, PrototypeError consumer)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (map == null)
            {
                spec._0008();
                return;
            }
            Regex regex = (Regex)map;
            TaskIteratorMapping taskIteratorMapping = spec as TaskIteratorMapping;

            if (taskIteratorMapping != null)
            {
                StartRequest(taskIteratorMapping, regex);
            }
            else
            {
                ListRequest(spec, regex, consumer);
            }
        }
        public override void _0001(RecordClassDispatcher res, object connection, PrototypeError third)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (connection == null)
            {
                res._0008();
                return;
            }
            DataSet obj = (DataSet)connection;
            PublisherRequestStrategy publisherRequestStrategy = third._0001() as PublisherRequestStrategy;
            FieldReaderMapper        fieldReaderMapper        = new FieldReaderMapper();

            res._0002();
            foreach (DataTable table in obj.Tables)
            {
                res._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(table.TableName) : table.TableName);
                fieldReaderMapper._0001(res, table, third);
            }
            res._0011();
        }
Beispiel #10
0
        public override void _0001(RecordClassDispatcher v, object ivk, PrototypeError util)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (ivk == null)
            {
                v._0008();
                return;
            }
            PublisherRequestStrategy publisherRequestStrategy = util._0001() as PublisherRequestStrategy;
            Type res = m_PrototypeIssuer.InitReader(ivk.GetType());
            UtilsClientBridge utilsClientBridge = m_ParameterIssuer.InitReader(res);
            int num = (int)utilsClientBridge._ParserIssuer.ConnectIssuer(new object[1]
            {
                ivk
            });
            FactoryDicCandidate factoryDicCandidate = utilsClientBridge.m_StatusIssuer.Single((FactoryDicCandidate P_0) => P_0.pageIssuer == num);

            v._0002();
            v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Case") : "Case");
            v._0004(factoryDicCandidate._HelperIssuer);
            if (factoryDicCandidate.exceptionIssuer != null && factoryDicCandidate.exceptionIssuer.Length != 0)
            {
                object[] obj = (object[])factoryDicCandidate.attributeIssuer.ConnectIssuer(new object[1]
                {
                    ivk
                });
                v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Fields") : "Fields");
                v._0003();
                object[] array = obj;
                foreach (object reg in array)
                {
                    util.FlushComposer(v, reg);
                }
                v._000F();
            }
            v._0011();
        }
Beispiel #11
0
        public override void _0001(RecordClassDispatcher i, object visitor, PrototypeError third)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (visitor == null)
            {
                i._0008();
                return;
            }
            CreatorIssuer       creatorIssuer       = CountRequest(visitor);
            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable());

            AssetRequest(creatorIssuer, xmlNamespaceManager);
            if (!_0004())
            {
                i._0002();
            }
            InitRequest(i, creatorIssuer, xmlNamespaceManager, !_0004());
            if (!_0004())
            {
                i._0011();
            }
        }
Beispiel #12
0
        public override void _0001(RecordClassDispatcher task, BroadcasterError[] counter)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (counter != null && counter.Length != 0 && m_InvocationIssuer != null)
            {
                BroadcasterError broadcasterError = PrototypeError.LogoutComposer(counter, m_InvocationIssuer.GetType());
                if (broadcasterError != null && broadcasterError._0001())
                {
                    broadcasterError._0001(task, m_InvocationIssuer, PrototypeError.FillComposer());
                    return;
                }
            }
            switch (_ValIssuer)
            {
            case Newtonsoft.Rules.UnicodeCategory.Comment:
                task._0005(m_InvocationIssuer?.ToString());
                break;

            case Newtonsoft.Rules.UnicodeCategory.Raw:
                task._0006(m_InvocationIssuer?.ToString());
                break;

            case Newtonsoft.Rules.UnicodeCategory.Null:
                task._0008();
                break;

            case Newtonsoft.Rules.UnicodeCategory.Undefined:
                task._000E();
                break;

            case Newtonsoft.Rules.UnicodeCategory.Integer:
            {
                object invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is int)
                {
                    int first_Low = (int)invocationIssuer;
                    task._0001(first_Low);
                    break;
                }
                invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is long)
                {
                    long asset2 = (long)invocationIssuer;
                    task._0001(asset2);
                    break;
                }
                invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is ulong)
                {
                    ulong specID = (ulong)invocationIssuer;
                    task._0001(specID);
                    break;
                }
                invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is BigInteger)
                {
                    BigInteger bigInteger = (BigInteger)invocationIssuer;
                    task._0001(bigInteger);
                }
                else
                {
                    task._0001(Convert.ToInt64(m_InvocationIssuer, CultureInfo.InvariantCulture));
                }
                break;
            }

            case Newtonsoft.Rules.UnicodeCategory.Float:
            {
                object invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is decimal)
                {
                    decimal asset = (decimal)invocationIssuer;
                    task._0001(asset);
                    break;
                }
                invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is double)
                {
                    double last = (double)invocationIssuer;
                    task._0001(last);
                    break;
                }
                invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is float)
                {
                    float init = (float)invocationIssuer;
                    task._0001(init);
                }
                else
                {
                    task._0001(Convert.ToDouble(m_InvocationIssuer, CultureInfo.InvariantCulture));
                }
                break;
            }

            case Newtonsoft.Rules.UnicodeCategory.String:
                task._0004(m_InvocationIssuer?.ToString());
                break;

            case Newtonsoft.Rules.UnicodeCategory.Boolean:
                task._0001(Convert.ToBoolean(m_InvocationIssuer, CultureInfo.InvariantCulture));
                break;

            case Newtonsoft.Rules.UnicodeCategory.Date:
            {
                object invocationIssuer = m_InvocationIssuer;
                if (invocationIssuer is DateTimeOffset)
                {
                    DateTimeOffset last2 = (DateTimeOffset)invocationIssuer;
                    task._0001(last2);
                }
                else
                {
                    task._0001(Convert.ToDateTime(m_InvocationIssuer, CultureInfo.InvariantCulture));
                }
                break;
            }

            case Newtonsoft.Rules.UnicodeCategory.Bytes:
                task._0001((byte[])m_InvocationIssuer);
                break;

            case Newtonsoft.Rules.UnicodeCategory.Guid:
                task._0001((m_InvocationIssuer != null) ? ((Guid?)m_InvocationIssuer) : null);
                break;

            case Newtonsoft.Rules.UnicodeCategory.TimeSpan:
                task._0001((m_InvocationIssuer != null) ? ((TimeSpan?)m_InvocationIssuer) : null);
                break;

            case Newtonsoft.Rules.UnicodeCategory.Uri:
                task._0001((Uri)m_InvocationIssuer);
                break;

            default:
                throw CustomerListAnnotation.ConcatIssuer("Type", _ValIssuer, "Unexpected token type.");
            }
        }
Beispiel #13
0
        private void InitRequest(RecordClassDispatcher first, CreatorIssuer second, XmlNamespaceManager template, bool isresult2)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            switch (second._0001())
            {
            case XmlNodeType.Document:
            case XmlNodeType.DocumentFragment:
                ExcludeRequest(first, second, template, isresult2);
                break;

            case XmlNodeType.Element:
                if (CancelRequest(second) && DefineRequest(second) && second._0001().Count > 0)
                {
                    ExcludeRequest(first, second, template, hasattr2: false);
                    break;
                }
                template.PushScope();
                foreach (CreatorIssuer item in second._0002())
                {
                    if (item._0003() == "http://www.w3.org/2000/xmlns/")
                    {
                        string prefix = (item._0001() != "xmlns") ? XmlConvert.DecodeName(item._0001()) : string.Empty;
                        string text   = item._0002();
                        if (text == null)
                        {
                            throw new StrategyError("Namespace attribute must have a value.");
                        }
                        template.AddNamespace(prefix, text);
                    }
                }
                if (isresult2)
                {
                    first._0002(QueryRequest(second, template));
                }
                if (!ResolveIterator(second._0002()) && second._0001().Count == 1 && second._0001()[0]._0001() == XmlNodeType.Text)
                {
                    first._0004(second._0001()[0]._0002());
                }
                else if (second._0001().Count == 0 && second._0002().Count == 0)
                {
                    if (((InfoRequestStrategy)second)._0001())
                    {
                        first._0008();
                    }
                    else
                    {
                        first._0004(string.Empty);
                    }
                }
                else
                {
                    first._0002();
                    for (int i = 0; i < second._0002().Count; i++)
                    {
                        InitRequest(first, second._0002()[i], template, isresult2: true);
                    }
                    ExcludeRequest(first, second, template, hasattr2: true);
                    first._0011();
                }
                template.PopScope();
                break;

            case XmlNodeType.Comment:
                if (isresult2)
                {
                    first._0005(second._0002());
                }
                break;

            case XmlNodeType.Attribute:
            case XmlNodeType.Text:
            case XmlNodeType.CDATA:
            case XmlNodeType.ProcessingInstruction:
            case XmlNodeType.Whitespace:
            case XmlNodeType.SignificantWhitespace:
                if ((!(second._0003() == "http://www.w3.org/2000/xmlns/") || !(second._0002() == "http://james.newtonking.com/projects/json")) && (!(second._0003() == "http://james.newtonking.com/projects/json") || !(second._0001() == "Array")))
                {
                    if (isresult2)
                    {
                        first._0002(QueryRequest(second, template));
                    }
                    first._0004(second._0002());
                }
                break;

            case XmlNodeType.XmlDeclaration:
            {
                DicEventConsumer dicEventConsumer = (DicEventConsumer)second;
                first._0002(QueryRequest(second, template));
                first._0002();
                if (!SetterTest.StartReader(dicEventConsumer._0004()))
                {
                    first._0002("@version");
                    first._0004(dicEventConsumer._0004());
                }
                if (!SetterTest.StartReader(dicEventConsumer._0005()))
                {
                    first._0002("@encoding");
                    first._0004(dicEventConsumer._0005());
                }
                if (!SetterTest.StartReader(dicEventConsumer._0006()))
                {
                    first._0002("@standalone");
                    first._0004(dicEventConsumer._0006());
                }
                first._0011();
                break;
            }

            case XmlNodeType.DocumentType:
            {
                IndexerIssuer indexerIssuer = (IndexerIssuer)second;
                first._0002(QueryRequest(second, template));
                first._0002();
                if (!SetterTest.StartReader(indexerIssuer._0004()))
                {
                    first._0002("@name");
                    first._0004(indexerIssuer._0004());
                }
                if (!SetterTest.StartReader(indexerIssuer._0006()))
                {
                    first._0002("@public");
                    first._0004(indexerIssuer._0006());
                }
                if (!SetterTest.StartReader(indexerIssuer._0005()))
                {
                    first._0002("@system");
                    first._0004(indexerIssuer._0005());
                }
                if (!SetterTest.StartReader(indexerIssuer._0007()))
                {
                    first._0002("@internalSubset");
                    first._0004(indexerIssuer._0007());
                }
                first._0011();
                break;
            }

            default:
                throw new StrategyError("Unexpected XmlNodeType when serializing nodes: " + second._0001());
            }
        }
        private void InvokeBroadcaster(RecordClassDispatcher last, object b, ProcTest proc, ProductInstanceExpression second2, InitializerTest second3, ProductInstanceExpression vis4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (b == null)
            {
                last._0008();
                return;
            }
            BroadcasterError broadcasterError = second2?._0001() ?? vis4?._0002() ?? second3?._0001() ?? proc._0002() ?? baseProperty.CloneComposer(proc._0002()) ?? proc._0003();

            if (broadcasterError != null && broadcasterError._0001())
            {
                DisableClass(last, broadcasterError, b, proc, second3, vis4);
                return;
            }
            switch (proc._ErrorProperty)
            {
            case (ParameterFilterResolver)1:
                DefineBroadcaster(last, b, (PrototypeFilterResolver)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)2:
            {
                MessageTest messageTest = (MessageTest)proc;
                if (!messageTest._0001())
                {
                    VerifyClass(last, (IEnumerable)b, messageTest, second2, second3, vis4);
                }
                else
                {
                    PatchClass(last, (Array)b, messageTest, second2, second3, vis4);
                }
                break;
            }

            case (ParameterFilterResolver)3:
                ConcatBroadcaster(last, b, (ProccesorClassSpec)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)4:
                SetupBroadcaster(last, b, (StubIteratorMapping)proc);
                break;

            case (ParameterFilterResolver)5:
            {
                ParamClientBridge paramClientBridge = (ParamClientBridge)proc;
                IDictionary       dictionary        = b as IDictionary;
                IDictionary       attr;
                if (dictionary == null)
                {
                    IDictionary dictionary2 = paramClientBridge.CountClient(b);
                    attr = dictionary2;
                }
                else
                {
                    attr = dictionary;
                }
                CompareClass(last, attr, paramClientBridge, second2, second3, vis4);
                break;
            }

            case (ParameterFilterResolver)6:
                ResolveClass(last, (IDynamicMetaObjectProvider)b, (ProducerProperty)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)7:
                OrderClass(last, (ISerializable)b, (CollectionProperty)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)8:
                ((ParserFilterResolver)b)._0001(last, baseProperty._0001().ToArray());
                break;
            }
        }