Example #1
0
    //点对点发送消息
    public void DisparcherMessage(double delay, int sender, int receiver, MessageEnum msg)
    {
        BaseGameEntity pSender   = EntityManager.Instance().GetEntityFromID(sender);
        BaseGameEntity pReceiver = EntityManager.Instance().GetEntityFromID(receiver);

        if (pReceiver == null)
        {
            return;
        }

        Telegram telegram = new Telegram();

        telegram.SetTelegram(0, sender, receiver, msg);

        //如果没有延迟的话,就调用处理函数Discharge,这个函数会调用handlemessage函数
        if (delay <= 0.0f)
        {
            DisCharge(pReceiver, telegram);
        }

        //需要延迟发送的话就计算时间,计算要发送的时间,在delayDispatcher中根据时间判断并发送
        else
        {
            double CurrentTime = Time.time;
            telegram.DispatchTime = CurrentTime + delay;

            PriorityQ.Add(telegram);//把信息加入到链表中
        }
    }
 public AlarmActions(WarpEnum Warp, MessageEnum Message, Boolean PlaySound, Boolean DeleteWhenDone)
 {
     this.Warp = Warp;
     this.Message = Message;
     this.PlaySound = PlaySound;
     this.DeleteWhenDone = DeleteWhenDone;
 }
Example #3
0
 public void refuse()
 {
     this.msg.state = MessageEnum.SEND;
     this.network.refuseChange(this.msg);
     Session.Messages [this.pos].reset();
     this.msg = Session.Messages [this.pos];
 }
Example #4
0
    //点对面发送消息
    public void DisparcherMessage(double delay, int sender, MessageEnum msg)
    {
        BaseGameEntity pSender  = EntityManager.Instance().GetEntityFromID(sender);
        Telegram       telegram = new Telegram();

        //为什么这里设置信息不直接用delay
        telegram.SetTelegram(0, sender, msg);

        //如果没有延迟的话,就调用处理函数Discharge,这个函数会调用handlemessage函数
        if (delay <= 0.0f)
        {
            //遍历所有的basegameobject将消息发送出去,有处理这个方法的状态就会处理,没有的不做处理
            //遍历可能出错,检查的时候注意下!!!
            foreach (KeyValuePair <int, BaseGameEntity> pvr in EntityManager.Instance().EntityMap)
            {
                DisCharge(pvr.Value, telegram);
            }
        }

        else
        {
            double CurrentTime = Time.time;
            telegram.DispatchTime = CurrentTime + delay;

            PriorityQ.Add(telegram);//把信息加入到链表中
        }
    }
Example #5
0
    public void updateState()
    {
        this.state = this.msg.state;
        switch (state)
        {
        case MessageEnum.EDIT:
            this.ButtonEdit.SetActive(false);
            this.ButtonSend.SetActive(true);
            this.ButtonOk.SetActive(false);
            this.ButtonNo.SetActive(false);
            setActiveButton(true);
            break;

        case MessageEnum.SEND:
            this.ButtonEdit.SetActive(true);
            this.ButtonSend.SetActive(false);
            this.ButtonOk.SetActive(false);
            this.ButtonNo.SetActive(false);
            setActiveButton(false);
            break;

        case MessageEnum.RECIEVE:
            this.ButtonEdit.SetActive(true);
            this.ButtonSend.SetActive(false);
            this.ButtonOk.SetActive(true);
            this.ButtonNo.SetActive(true);
            setActiveButton(false);
            break;
        }
    }
 public void Read(__BinaryParser input)
 {
     this.messageEnum = (MessageEnum) input.ReadInt32();
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.NoReturnValue))
     {
         this.returnValue = null;
     }
     else if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueVoid))
     {
         this.returnValue = instanceOfVoid;
     }
     else if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueInline))
     {
         this.returnValue = IOUtil.ReadWithCode(input);
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInline))
     {
         this.scallContext = (string) IOUtil.ReadWithCode(input);
         LogicalCallContext context = new LogicalCallContext {
             RemotingData = { LogicalCallID = this.scallContext }
         };
         this.callContext = context;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInline))
     {
         this.args = IOUtil.ReadArgs(input);
     }
 }
Example #7
0
 public void Read(__BinaryParser input)
 {
     this.messageEnum = (MessageEnum)input.ReadInt32();
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.NoReturnValue))
     {
         this.returnValue = (object)null;
     }
     else if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueVoid))
     {
         this.returnValue = BinaryMethodReturn.instanceOfVoid;
     }
     else if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueInline))
     {
         this.returnValue = IOUtil.ReadWithCode(input);
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInline))
     {
         this.scallContext = (string)IOUtil.ReadWithCode(input);
         this.callContext  = (object)new LogicalCallContext()
         {
             RemotingData =
             {
                 LogicalCallID = this.scallContext
             }
         };
     }
     if (!IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInline))
     {
         return;
     }
     this.args = IOUtil.ReadArgs(input);
 }
Example #8
0
        public void Read(BinaryReader input)
        {
            messageEnum = (MessageEnum)input.ReadInt32();

            if (BinaryConverter.FlagTest(messageEnum, MessageEnum.NoReturnValue))
            {
                returnValue = invalidReturn;
            }
            else if (BinaryConverter.FlagTest(messageEnum, MessageEnum.ReturnValueVoid))
            {
                returnValue = invalidReturn;
            }
            else if (BinaryConverter.FlagTest(messageEnum, MessageEnum.ReturnValueInline))
            {
                returnValue = BinaryConverter.ReadWithCode(input);
            }

            if (BinaryConverter.FlagTest(messageEnum, MessageEnum.ContextInline))
            {
                scallContext = (String)BinaryConverter.ReadWithCode(input);
            }

            if (BinaryConverter.FlagTest(messageEnum, MessageEnum.ArgsInline))
            {
                args = BinaryConverter.ReadArgs(input);
            }
        }
Example #9
0
 //Message.SendMessage(MyEventNum.HitEvent, gameObject, otherGameobject)
 public static void SendMessage(MessageEnum ev, params GameObject[] objs)
 {
     if (ev == MessageEnum.NONE)
     {
         Debug.Log("Message sender is not setup for Event! " + ev.ToString());
         return;
     }
     if (messages.ContainsKey(ev))
     {
         if (objs.Length > 0)
         {
             for (int i = objs.Length - 1; i >= 0; i--)
             {
                 GameObject obj = objs[i];
                 if (messages[ev].ContainsKey(obj))
                 {
                     messages[ev][obj].Invoke();
                 }
             }
         }
         else
         {
             List <KeyValuePair <GameObject, Action> > values = messages[ev].ToList();
             for (int i = values.Count - 1; i >= 0; i--)
             //foreach (KeyValuePair<GameObject, Action> kv in messages[ev])
             {
                 values[i].Value.Invoke();
             }
         }
     }
     else
     {
         Debug.Log("No listeners for event: " + ev.ToString());
     }
 }
Example #10
0
        /// <summary>
        /// 显示输出
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="me"></param>
        /// <returns></returns>
        public static string OutPutShow(string key, object data = null, MessageEnum me = MessageEnum.Success)
        {
            if (data == null)
            {
                data = "";
            }
            string       mestr = me.ToString();
            MessageState ms    = new MessageState()
            {
                key = key
            };

            System.Type t      = me.GetType();
            FieldInfo[] filist = t.GetFields();
            foreach (var fi in filist)
            {
                if (fi.Name == mestr)
                {
                    MsgStateAttribute ai = (MsgStateAttribute)System.Attribute.GetCustomAttribute(fi, typeof(MsgStateAttribute), false);
                    ms.SetMsgState(ai.GetMsg());
                    break;
                }
            }
            ms.data  = data;
            ms.state = me.ConvertData <int>();
            return(MakeJson.ObjectToJson(new
            {
                ms.state,
                ms.key,
                ms.data
            }, "yyyy-MM-dd HH:mm:ss"));
        }
Example #11
0
        static public async Task <IMessage> ReceiveMessage(WebSocket socket)
        {
            IMessage    result = null;
            MessageEnum type   = (MessageEnum) await ReceiveInt16(socket);

            int messageLength = await ReceiveInt16(socket);

            if (messageLength > buffer.Length)
            {
                throw new SharedDataException($"message length[{messageLength} is greater than buffer.Length[{buffer.Length}]");
            }
            await ReceiveBuffer(socket, buffer, buffer.Length);

            using (MemoryStream ms = new MemoryStream(buffer, 0, messageLength))
            {
                switch (type)
                {
                case MessageEnum.Heartbeat:
                    result = Deserialize <Heartbeat>(ms);
                    break;

                case MessageEnum.LED:
                    result = Deserialize <LEDMessage>(ms);
                    break;

                case MessageEnum.Temperature:
                    result = Deserialize <Temperature>(ms);
                    break;
                }
            }
            return(result);
        }
Example #12
0
 public void SetTelegram(double time, int sender, int receiver, MessageEnum msg)
 {
     DispatchTime = time;
     Sender       = sender;
     Receiver     = receiver;
     Msg          = msg;
 }
 public AlarmActions(WarpEnum Warp, MessageEnum Message, Boolean PlaySound, Boolean DeleteWhenDone)
 {
     this.Warp           = Warp;
     this.Message        = Message;
     this.PlaySound      = PlaySound;
     this.DeleteWhenDone = DeleteWhenDone;
 }
Example #14
0
        /// <summary>
        /// This allows messages to adapt based on the Being involved and
        /// what messages have already been seen, how many times, et c.
        /// </summary>
        public void Message(IBeing being, MessageEnum messageKey)
        {
            Guard.Against(messageKey == MessageEnum.Unset, "Must set message key");
            if (!being.IsPlayer)
            {
                return;
            }

            switch (messageKey)
            {
            case MessageEnum.BarehandRotDamage:
                if (FirstTimeFor(messageKey))
                {
                    //0.2  promote to alert
                    WriteLine("I tear a chunk off the ground.  It fights back--burns my hands.");
                    WriteLine("The stuff withers away from where I grab it.");
                }
                else
                {
                    WriteLine("I hit it, and the stuff withers.");
                }

                break;

            case MessageEnum.RotDamageSpreads:
                WriteLine("The damage I did to this stuff spreads outward.  Good.");
                break;

            default:
                var need_message_for_key = $"Must code message for key [{messageKey}].";
                WriteLine(need_message_for_key);
                throw new Exception(need_message_for_key);
            }
        }
 public override bool OnMessage(Follower follower, MessageEnum msg)
 {
     switch (msg)
     {
     default: return(false);
     }
     return(true);
 }
 public override bool OnMessage(Player player, MessageEnum msg)
 {
     switch (msg)
     {
     case MessageEnum.StopWalking: player.GetFSM().ChangeState(player.States.IdleState); break;
     }
     return(true);
 }
        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
        {
            base.GetPropertyHeight(property, label);

            messageEnum = property.GetValue<MessageEnum>();

            return lineHeight;
        }
Example #18
0
 /// <summary>
 /// send a chat message
 /// </summary>
 public Message(string fromUserName, string toUserName, string content, MessageEnum type)
     : this(fromUserName, type)
 {
     this.ToUserName = ToUserName;
     this.Content = content;
     this.Type = type;
     this.SendTime = DateTime.Now;
 }
 public override bool OnMessage(MyCamera camera, MessageEnum msg)
 {
     switch (msg)
     {
     case MessageEnum.StartSpeech: camera.GetFSM().ChangeState(camera.States.LeaderViewState); break;
     }
     return(true);
 }
Example #20
0
 public override bool OnMessage(MyCamera camera, MessageEnum msg)
 {
     switch (msg)
     {
     case MessageEnum.LeaderCloseToPlayer: camera.GetFSM().ChangeState(camera.States.CloseSceneState); break;
     }
     return(true);
 }
Example #21
0
 public void SendMsg(MessageEnum msg, params object[] objs)
 {
     if (true)
     {
         tempFormatDataSend = FormatDataSend(msg, GamePlayer.Inst, objs);
         ReceiveMsg(tempFormatDataSend);
     }
 }
 public override bool OnMessage(Leader leader, MessageEnum msg)
 {
     switch (msg)
     {
     default: return(false);
     }
     return(true);
 }
 public override bool OnMessage(People people, MessageEnum msg)
 {
     //switch (msg)
     //{
     //    default: return false;
     //}
     return(true);
 }
 public override bool OnMessage(Leader leader, MessageEnum msg)
 {
     //switch (msg)
     //{
     //    default: return false;
     //}
     return(true);
 }
Example #25
0
 private MessageDataSend FormatDataSend(MessageEnum msg, params object[] objs)
 {
     return(new MessageDataSend
     {
         Msg = msg,
         Objs = objs,
     });
 }
Example #26
0
        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
        {
            base.GetPropertyHeight(property, label);

            messageEnum = property.GetValue <MessageEnum>();

            return(lineHeight);
        }
 public override bool OnMessage(MyCamera camera, MessageEnum msg)
 {
     switch (msg)
     {
     case MessageEnum.LeaderStopInteractive: camera.GetFSM().ChangeState(camera.States.PlayerViewState); break;
     }
     return(true);
 }
Example #28
0
 public override bool OnMessage(Player player, MessageEnum msg)
 {
     switch (msg)
     {
     //case MessageEnum.StartWalking: player.GetFSM().ChangeState(player.States.WalkingState); break;
     case MessageEnum.StartSpeech: player.GetFSM().ChangeState(player.States.ListeningState); break;
     }
     return(true);
 }
    public override bool OnMessage(Player player, MessageEnum msg)
    {
        switch (msg)
        {
        case MessageEnum.LeaderStopShakeHands: player.GetFSM().ChangeState(player.States.WaitingState); break;

        case MessageEnum.LeaderReturned: MessageDispatcher.Instance().DisparcherMessage(Const.PLAYER_SHAKEHANDS_TIME, player.ID(), player.ID(), MessageEnum.LeaderReturned); break;
        }
        return(true);
    }
    public override bool OnMessage(Player player, MessageEnum msg)
    {
        switch (msg)
        {
        case MessageEnum.StartWalking: player.GetFSM().ChangeState(player.States.WalkingState); break;

        default: return(false);
        }
        return(true);
    }
    public override bool OnMessage(People people, MessageEnum msg)
    {
        switch (msg)
        {
        case MessageEnum.LeaderStopSpeech: people.GetFSM().ChangeState(people.States.HandClapingState); break;

        default: return(false);
        }
        return(true);
    }
    public override bool OnMessage(Follower follower, MessageEnum msg)
    {
        switch (msg)
        {
        case MessageEnum.LeaderGotoInteractive: follower.GetFSM().ChangeState(follower.States.WalkingState); break;

        default: return(false);
        }
        return(true);
    }
    public override bool OnMessage(Player player, MessageEnum msg)
    {
        switch (msg)
        {
        case MessageEnum.LeaderStopSpeech: ClapHandsSwitch = true; break;

        default: return(false);
        }
        return(true);
    }
    public override bool OnMessage(Follower follower, MessageEnum msg)
    {
        switch (msg)
        {
        case MessageEnum.LeaderStopSpeech: follower.GetFSM().ChangeState(follower.States.HandClapingState); break;

        default: return(false);
        }
        return(true);
    }
 internal void Read(__BinaryParser input)
 {
     this.messageEnum = (MessageEnum) input.ReadInt32();
     this.methodName = (string) IOUtil.ReadWithCode(input);
     this.typeName = (string) IOUtil.ReadWithCode(input);
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInline))
     {
         this.scallContext = (string) IOUtil.ReadWithCode(input);
         LogicalCallContext context = new LogicalCallContext {
             RemotingData = { LogicalCallID = this.scallContext }
         };
         this.callContext = context;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInline))
     {
         this.args = IOUtil.ReadArgs(input);
     }
 }
Example #36
0
        public void Read(__BinaryParser input)
        {
             messageEnum = (MessageEnum)input.ReadInt32();

             if (IOUtil.FlagTest(messageEnum, MessageEnum.NoReturnValue))
                 returnValue = null;
             else if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueVoid))
             {
                 returnValue = FormatterServices.GetUninitializedObject(Converter.typeofSystemVoid);            
             }
             else if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInline))
                 returnValue = IOUtil.ReadWithCode(input);

             if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline))
             {
                 scallContext = (String)IOUtil.ReadWithCode(input);
                 LogicalCallContext lcallContext = new LogicalCallContext();
                 lcallContext.RemotingData.LogicalCallID = scallContext;
                 callContext = lcallContext;
             }

             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline))
                 args = IOUtil.ReadArgs(input);
        }
Example #37
0
 public EntityMessage(MessageEnum message, HierarchyScopes scope = HierarchyScopes.Self)
 {
     Message = message;
     this.scope = (int)scope;
 }
 internal static bool FlagTest(MessageEnum flag, MessageEnum target)
 {
     return ((flag & target) == target);
 }
Example #39
0
 /// <summary>
 /// Connect or disconnect to server
 /// </summary>
 /// <param name="fromUserName">my user name</param>
 /// <param name="type">chat | signin | signout</param>
 public Message(string fromUserName, MessageEnum type)
 {
     this.FromUserName = fromUserName;
     this.Type = type;
 }
 internal object[] WriteArray(object returnValue, object[] args, Exception exception, object callContext, object[] properties)
 {
     this.returnValue = returnValue;
     this.args = args;
     this.exception = exception;
     this.callContext = callContext;
     this.properties = properties;
     int num = 0;
     if ((args == null) || (args.Length == 0))
     {
         this.messageEnum = MessageEnum.NoArgs;
     }
     else
     {
         this.argTypes = new Type[args.Length];
         this.bArgsPrimitive = true;
         for (int i = 0; i < args.Length; i++)
         {
             if (args[i] != null)
             {
                 this.argTypes[i] = args[i].GetType();
                 if (!this.argTypes[i].IsPrimitive && !object.ReferenceEquals(this.argTypes[i], Converter.typeofString))
                 {
                     this.bArgsPrimitive = false;
                     break;
                 }
             }
         }
         if (this.bArgsPrimitive)
         {
             this.messageEnum = MessageEnum.ArgsInline;
         }
         else
         {
             num++;
             this.messageEnum = MessageEnum.ArgsInArray;
         }
     }
     if (returnValue == null)
     {
         this.messageEnum |= MessageEnum.NoReturnValue;
     }
     else if (returnValue.GetType() == typeof(void))
     {
         this.messageEnum |= MessageEnum.ReturnValueVoid;
     }
     else
     {
         this.returnType = returnValue.GetType();
         if (this.returnType.IsPrimitive || object.ReferenceEquals(this.returnType, Converter.typeofString))
         {
             this.messageEnum |= MessageEnum.ReturnValueInline;
         }
         else
         {
             num++;
             this.messageEnum |= MessageEnum.ReturnValueInArray;
         }
     }
     if (exception != null)
     {
         num++;
         this.messageEnum |= MessageEnum.ExceptionInArray;
     }
     if (callContext == null)
     {
         this.messageEnum |= MessageEnum.NoContext;
     }
     else if (callContext is string)
     {
         this.messageEnum |= MessageEnum.ContextInline;
     }
     else
     {
         num++;
         this.messageEnum |= MessageEnum.ContextInArray;
     }
     if (properties != null)
     {
         num++;
         this.messageEnum |= MessageEnum.PropertyInArray;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInArray) && (num == 1))
     {
         this.messageEnum ^= MessageEnum.ArgsInArray;
         this.messageEnum |= MessageEnum.ArgsIsArray;
         return args;
     }
     if (num <= 0)
     {
         return null;
     }
     int index = 0;
     this.callA = new object[num];
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInArray))
     {
         this.callA[index++] = args;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueInArray))
     {
         this.callA[index++] = returnValue;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ExceptionInArray))
     {
         this.callA[index++] = exception;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInArray))
     {
         this.callA[index++] = callContext;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.PropertyInArray))
     {
         this.callA[index] = properties;
     }
     return this.callA;
 }
 internal object[] WriteArray(string uri, string methodName, string typeName, Type[] instArgs, object[] args, object methodSignature, object callContext, object[] properties)
 {
     this.uri = uri;
     this.methodName = methodName;
     this.typeName = typeName;
     this.instArgs = instArgs;
     this.args = args;
     this.methodSignature = methodSignature;
     this.callContext = callContext;
     this.properties = properties;
     int num = 0;
     if ((args == null) || (args.Length == 0))
     {
         this.messageEnum = MessageEnum.NoArgs;
     }
     else
     {
         this.argTypes = new Type[args.Length];
         this.bArgsPrimitive = true;
         for (int i = 0; i < args.Length; i++)
         {
             if (args[i] != null)
             {
                 this.argTypes[i] = args[i].GetType();
                 if ((!this.argTypes[i].IsPrimitive && !object.ReferenceEquals(this.argTypes[i], Converter.typeofString)) || (args[i] is ISerializable))
                 {
                     this.bArgsPrimitive = false;
                     break;
                 }
             }
         }
         if (this.bArgsPrimitive)
         {
             this.messageEnum = MessageEnum.ArgsInline;
         }
         else
         {
             num++;
             this.messageEnum = MessageEnum.ArgsInArray;
         }
     }
     if (instArgs != null)
     {
         num++;
         this.messageEnum |= MessageEnum.GenericMethod;
     }
     if (methodSignature != null)
     {
         num++;
         this.messageEnum |= MessageEnum.MethodSignatureInArray;
     }
     if (callContext == null)
     {
         this.messageEnum |= MessageEnum.NoContext;
     }
     else if (callContext is string)
     {
         this.messageEnum |= MessageEnum.ContextInline;
     }
     else
     {
         num++;
         this.messageEnum |= MessageEnum.ContextInArray;
     }
     if (properties != null)
     {
         num++;
         this.messageEnum |= MessageEnum.PropertyInArray;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInArray) && (num == 1))
     {
         this.messageEnum ^= MessageEnum.ArgsInArray;
         this.messageEnum |= MessageEnum.ArgsIsArray;
         return args;
     }
     if (num <= 0)
     {
         return null;
     }
     int index = 0;
     this.callA = new object[num];
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInArray))
     {
         this.callA[index++] = args;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.GenericMethod))
     {
         this.callA[index++] = instArgs;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.MethodSignatureInArray))
     {
         this.callA[index++] = methodSignature;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInArray))
     {
         this.callA[index++] = callContext;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.PropertyInArray))
     {
         this.callA[index] = properties;
     }
     return this.callA;
 }
Example #42
0
 /// <summary>
 /// Supply english error messages. At the moment this method is invoked only by <see cref="RenderParsingErrorsText"/>.
 /// </summary>
 /// <param name="messageType">The type of message to return.</param>
 /// <returns>The <see cref="System.String"/> that contains the parsing error formattable text.</returns>
 protected string GetMessageText(MessageEnum messageType)
 {
     switch (messageType)
     {
         case MessageEnum.ParsingErrorViolatesRequired:
             return "The option {0} is mandatory, you must define it.";
         case MessageEnum.ParsingErrorViolatesFormat:
             return "The format of the entered value for the option {0} is invalid.";
         case MessageEnum.ParsingErrorViolatesExclusiveness:
             return "Two or more options are mutually exclusive with each other.";
         default:
             throw new InvalidOperationException();
     }
 }
        // If the argument list contains only primitive or strings it is written out as part of the header
        // if not the args are written out as a separate array 
        internal Object[] WriteArray(Object returnValue, Object[] args, Exception exception, Object callContext, Object[] properties)
        { 
            SerTrace.Log(this, "WriteArray returnValue ",returnValue, "exception ", exception, " callContext ",callContext," properties ", properties); 

            this.returnValue = returnValue; 
            this.args = args;
            this.exception = exception;
            this.callContext = callContext;
            this.properties = properties; 

            int arraySize = 0; 
            if (args == null || args.Length == 0) 
                messageEnum = MessageEnum.NoArgs;
            else 
            {
                argTypes = new Type[args.Length];

                // Check if args are all string or primitives 

                bArgsPrimitive = true; 
                for (int i =0; i<args.Length; i++) 
                {
                    if (args[i] != null) 
                    {
                        argTypes[i] = args[i].GetType();
                        if (!(argTypes[i].IsPrimitive || Object.ReferenceEquals(argTypes[i], Converter.typeofString)))
                        { 
                            bArgsPrimitive = false;
                            break; 
                        } 
                    }
                } 

                if (bArgsPrimitive)
                    messageEnum = MessageEnum.ArgsInline;
                else 
                {
                    arraySize++; 
                    messageEnum = MessageEnum.ArgsInArray; 
                }
            } 


            if (returnValue == null)
                messageEnum |= MessageEnum.NoReturnValue; 
            else if (returnValue.GetType() == typeof(void))
                messageEnum |= MessageEnum.ReturnValueVoid; 
            else 
            {
                returnType = returnValue.GetType(); 
                if (returnType.IsPrimitive || Object.ReferenceEquals(returnType, Converter.typeofString))
                    messageEnum |= MessageEnum.ReturnValueInline;
                else
                { 
                    arraySize++;
                    messageEnum |= MessageEnum.ReturnValueInArray; 
                } 
            }
 
            if (exception != null)
            {
                arraySize++;
                messageEnum |= MessageEnum.ExceptionInArray; 
            }
 
            if (callContext == null) 
                messageEnum |= MessageEnum.NoContext;
            else if (callContext is String) 
                messageEnum |= MessageEnum.ContextInline;
            else
            {
                arraySize++; 
                messageEnum |= MessageEnum.ContextInArray;
            } 
 
            if (properties != null)
            { 
                arraySize++;
                messageEnum |= MessageEnum.PropertyInArray;
            }
 
            if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray) && (arraySize == 1))
            { 
                messageEnum ^= MessageEnum.ArgsInArray; 
                messageEnum |= MessageEnum.ArgsIsArray;
                return args; 
            }

            if (arraySize > 0)
            { 
                int arrayPosition = 0;
                callA = new Object[arraySize]; 
                if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray)) 
                    callA[arrayPosition++] = args;
 
                if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInArray))
                    callA[arrayPosition++] = returnValue;

                if (IOUtil.FlagTest(messageEnum, MessageEnum.ExceptionInArray)) 
                    callA[arrayPosition++] = exception;
 
                if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInArray)) 
                    callA[arrayPosition++] = callContext;
 
                if (IOUtil.FlagTest(messageEnum, MessageEnum.PropertyInArray))
                    callA[arrayPosition] = properties;

                 return callA; 
            }
            else 
                return null; 
        }
        [System.Security.SecurityCritical]  // auto-generated
        internal void Read(__BinaryParser input) 
        {
             messageEnum = (MessageEnum)input.ReadInt32();
             //uri = (String)IOUtil.ReadWithCode(input);
             methodName = (String)IOUtil.ReadWithCode(input); 
             typeName = (String)IOUtil.ReadWithCode(input);
 
#if FEATURE_REMOTING 
             if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline))
             { 
                 scallContext = (String)IOUtil.ReadWithCode(input);
                 LogicalCallContext lcallContext = new LogicalCallContext();
                 lcallContext.RemotingData.LogicalCallID = scallContext;
                 callContext = lcallContext; 
             }
#endif 
 
             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline))
                 args = IOUtil.ReadArgs(input); 
        }
        // If the argument list contains only primitive or strings it is written out as part of the header 
        // if not the args are written out as a separate array
        internal Object[] WriteArray(String uri, String methodName, String typeName, Type[] instArgs, Object[] args, Object methodSignature, Object callContext, Object[] properties) 
        {
            this.uri = uri;
            this.methodName = methodName;
            this.typeName = typeName; 
            this.instArgs = instArgs;
            this.args = args; 
            this.methodSignature = methodSignature; 
            this.callContext = callContext;
            this.properties = properties; 

            int arraySize = 0;
            if (args == null || args.Length == 0)
                messageEnum = MessageEnum.NoArgs; 
            else
            { 
                argTypes = new Type[args.Length]; 
                // Check if args are all string or primitives
                bArgsPrimitive = true; 
                for (int i =0; i<args.Length; i++)
                {
                    if (args[i] != null)
                    { 
                        argTypes[i] = args[i].GetType();
                        if (!(argTypes[i].IsPrimitive || Object.ReferenceEquals(argTypes[i], Converter.typeofString)) || args[i] is ISerializable) 
                        { 
                            bArgsPrimitive = false;
                            break; 
                        }
                    }
                }
 

                if (bArgsPrimitive) 
                    messageEnum = MessageEnum.ArgsInline; 
                else
                { 
                    arraySize++;
                    messageEnum = MessageEnum.ArgsInArray;
                }
            } 

 
            if (instArgs != null) 
            {
                arraySize++; 
                messageEnum |= MessageEnum.GenericMethod;
            }

            if (methodSignature != null) 
            {
                arraySize++; 
                messageEnum |= MessageEnum.MethodSignatureInArray; 
            }
 
            if (callContext == null)
                messageEnum |= MessageEnum.NoContext;
            else if (callContext is String)
                messageEnum |= MessageEnum.ContextInline; 
            else
            { 
                arraySize++; 
                messageEnum |= MessageEnum.ContextInArray;
            } 

            if (properties != null)
            {
                arraySize++; 
                messageEnum |= MessageEnum.PropertyInArray;
            } 
 
            if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray) && arraySize == 1)
            { 
                messageEnum ^= MessageEnum.ArgsInArray;
                messageEnum |= MessageEnum.ArgsIsArray;
                return args;
            } 

 
            if (arraySize > 0) 
            {
                int arrayPosition = 0; 
                callA = new Object[arraySize];
                if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray))
                    callA[arrayPosition++] = args;
 
                if (IOUtil.FlagTest(messageEnum, MessageEnum.GenericMethod))
                    callA[arrayPosition++] = instArgs; 
 
                if (IOUtil.FlagTest(messageEnum, MessageEnum.MethodSignatureInArray))
                    callA[arrayPosition++] = methodSignature; 

                if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInArray))
                    callA[arrayPosition++] = callContext;
 
                if (IOUtil.FlagTest(messageEnum, MessageEnum.PropertyInArray))
                    callA[arrayPosition] = properties; 
 
                 return callA;
            } 
            else
                return null;
        }
        [System.Security.SecurityCritical]  // auto-generated 
        public void Read(__BinaryParser input)
        { 
             messageEnum = (MessageEnum)input.ReadInt32();

             if (IOUtil.FlagTest(messageEnum, MessageEnum.NoReturnValue))
                 returnValue = null; 
             else if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueVoid))
             { 
                 returnValue = instanceOfVoid; 
             }
             else if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInline)) 
                 returnValue = IOUtil.ReadWithCode(input);

#if FEATURE_REMOTING
             if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline)) 
             {
                 scallContext = (String)IOUtil.ReadWithCode(input); 
                 LogicalCallContext lcallContext = new LogicalCallContext(); 
                 lcallContext.RemotingData.LogicalCallID = scallContext;
                 callContext = lcallContext; 
             }
#endif
             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline))
                 args = IOUtil.ReadArgs(input); 
        }
 internal static bool FlagTest(MessageEnum flag, MessageEnum target) 
 {
     if ((flag & target) == target)
         return true;
     else 
         return false;
 }