Ejemplo n.º 1
0
        protected bool CheckBroadcaster(object i, ProcTest attr, object helper, IdentifierClientBridge value2, string reference3, Exception ident4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ValErrorFilter valErrorFilter = RevertClient(i, helper, reference3, ident4);

            if (containerProperty != null && containerProperty._0001() >= TraceLevel.Error && !valErrorFilter._0001())
            {
                valErrorFilter._0001(containssetup: true);
                string str = (GetType() == typeof(InterceptorInstanceExpression)) ? "Error serializing" : "Error deserializing";
                if (attr != null)
                {
                    str = str + " " + attr._0002();
                }
                str = str + ". " + ident4.Message;
                if (!(ident4 is ListenerTestItem))
                {
                    str = QueueError.ComputeError(value2, reference3, str);
                }
                containerProperty._0001(TraceLevel.Error, str, ident4);
            }
            if (attr != null && i != null)
            {
                attr.ConcatClient(i, baseProperty._0001(), valErrorFilter);
            }
            if (!valErrorFilter._0002())
            {
                baseProperty.VisitComposer(new FilterClassDispatcher(i, valErrorFilter));
            }
            return(valErrorFilter._0002());
        }
 internal static CollectionComposer SelectTest(string first, string connection, Exception third)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     connection = QueueError.ComputeError(null, first, connection);
     return(new CollectionComposer(connection, first, third));
 }
        private bool CustomizeBroadcaster(RecordClassDispatcher res, object pol, ProductInstanceExpression filter, ProcTest second2, InitializerTest cfg3, ProductInstanceExpression visitor4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (pol == null)
            {
                return(true);
            }
            if (second2._ErrorProperty == (ParameterFilterResolver)3 || second2._ErrorProperty == (ParameterFilterResolver)4)
            {
                return(true);
            }
            FacadeComposer?facadeComposer = null;

            if (filter != null)
            {
                facadeComposer = filter._0001();
            }
            if (!facadeComposer.HasValue && visitor4 != null)
            {
                facadeComposer = visitor4._0002();
            }
            if (!facadeComposer.HasValue && cfg3 != null)
            {
                facadeComposer = cfg3._0001();
            }
            if ((baseProperty.m_SpecificationError != null) ? wrapperProperty.CollectTest(pol, baseProperty.m_SpecificationError) : wrapperProperty.Contains(pol))
            {
                string str = "Self referencing loop detected";
                if (filter != null)
                {
                    str += " for property '{0}'".ListReader(CultureInfo.InvariantCulture, filter._0001());
                }
                str += " with type '{0}'.".ListReader(CultureInfo.InvariantCulture, pol.GetType());
                switch (facadeComposer.GetValueOrDefault(baseProperty.helperError))
                {
                case (FacadeComposer)0:
                    throw StrategyError.ValidateComposer(null, res._0001(), str, null);

                case (FacadeComposer)1:
                    if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
                    {
                        containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), str + ". Skipping serializing self referenced value."), null);
                    }
                    return(false);

                case (FacadeComposer)2:
                    if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
                    {
                        containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), str + ". Serializing self referenced value."), null);
                    }
                    return(true);
                }
            }
            return(true);
        }
 private void InitBroadcaster(RecordClassDispatcher value, ProcTest caller, object rule)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
     {
         containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, value._0002(), "Finished serializing {0}".ListReader(CultureInfo.InvariantCulture, caller._0002())), null);
     }
     caller.SelectClient(rule, baseProperty.roleError);
 }
 private void ManageBroadcaster(RecordClassDispatcher asset, ProcTest counter, object res)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
     {
         containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, asset._0002(), "Started serializing {0}".ListReader(CultureInfo.InvariantCulture, counter._0002())), null);
     }
     counter.ListClient(res, baseProperty.roleError);
 }
        private void WriteBroadcaster(RecordClassDispatcher ident, Type map)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            string text = ResolverErrorFilter.PublishIssuer(map, baseProperty._StatusError, baseProperty.writerError);

            if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
            {
                containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, ident._0002(), "Writing type name '{0}' for {1}.".SelectReader(CultureInfo.InvariantCulture, text, map)), null);
            }
            ident._0001("$type", injectcust: false);
            ident._0004(text);
        }
        private void PublishBroadcaster(RecordClassDispatcher init, Type pred, object control)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            string text = CancelBroadcaster(init, control);

            if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
            {
                containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, init._0002(), "Writing object reference Id '{0}' for {1}.".SelectReader(CultureInfo.InvariantCulture, text, pred)), null);
            }
            init._0001("$id", injectcust: false);
            init._0004(text);
        }
        private void QueryBroadcaster(RecordClassDispatcher var1, object cust)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            string text = CancelBroadcaster(var1, cust);

            if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
            {
                containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, var1._0002(), "Writing object reference to Id '{0}' for {1}.".SelectReader(CultureInfo.InvariantCulture, text, cust.GetType())), null);
            }
            var1._0002();
            var1._0001("$ref", injectcust: false);
            var1._0004(text);
            var1._0011();
        }
        private bool InsertClass(RecordClassDispatcher value, ProductInstanceExpression visitor, object helper)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (visitor._0003() == null)
            {
                return(true);
            }
            bool flag = visitor._0003()(helper);

            if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
            {
                containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, value._0002(), "IsSpecified result for property '{0}' on {1}: {2}".DeleteReader(CultureInfo.InvariantCulture, visitor._0001(), visitor._0001(), flag)), null);
            }
            return(flag);
        }
        private bool MapClass(RecordClassDispatcher res, ProductInstanceExpression attr, object temp)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (attr._0001() == null)
            {
                return(true);
            }
            bool flag = attr._0001()(temp);

            if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
            {
                containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), "ShouldSerialize result for property '{0}' on {1}: {2}".DeleteReader(CultureInfo.InvariantCulture, attr._0001(), attr._0001(), flag)), null);
            }
            return(flag);
        }
Ejemplo n.º 11
0
        internal static ContextError VerifyComposer(IdentifierClientBridge task, string token, string util, Exception first2)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            util = QueueError.ComputeError(task, token, util);
            int helper_High;
            int spec2_min;

            if (task != null && task._0002())
            {
                helper_High = task._0001();
                spec2_min   = task._0002();
            }
            else
            {
                helper_High = 0;
                spec2_min   = 0;
            }
            return(new ContextError(util, token, helper_High, spec2_min, first2));
        }
Ejemplo n.º 12
0
        internal static StrategyError ValidateComposer(IdentifierClientBridge task, string counter, string res, Exception setup2)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            res = QueueError.ComputeError(task, counter, res);
            int sum_serv;
            int v2_max;

            if (task != null && task._0002())
            {
                sum_serv = task._0001();
                v2_max   = task._0002();
            }
            else
            {
                sum_serv = 0;
                v2_max   = 0;
            }
            return(new StrategyError(res, counter, sum_serv, v2_max, setup2));
        }
 private void DisableClass(RecordClassDispatcher var1, BroadcasterError second, object temp, ProcTest pol2, InitializerTest last3, ProductInstanceExpression res4)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (CountBroadcaster(temp, null, pol2, last3, res4))
     {
         QueryBroadcaster(var1, temp);
     }
     else if (CustomizeBroadcaster(var1, temp, null, pol2, last3, res4))
     {
         wrapperProperty.Add(temp);
         if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
         {
             containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, var1._0002(), "Started serializing {0} with converter {1}.".SelectReader(CultureInfo.InvariantCulture, temp.GetType(), second.GetType())), null);
         }
         second._0001(var1, temp, SelectBroadcaster());
         if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
         {
             containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, var1._0002(), "Finished serializing {0} with converter {1}.".SelectReader(CultureInfo.InvariantCulture, temp.GetType(), second.GetType())), null);
         }
         wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
     }
 }