public RabbitMQInvocation ReadInvocation(ReadOnlyMemory <byte> data)
        {
            // See WriteInvocation for the format
            ValidateArraySize(ref data, 2, "Invocation");

            // Read excluded Ids
            IReadOnlyList <string> excludedConnectionIds = null;
            var idCount = MessagePackUtil.ReadArrayHeader(ref data);

            if (idCount > 0)
            {
                var ids = new string[idCount];
                for (var i = 0; i < idCount; i++)
                {
                    ids[i] = MessagePackUtil.ReadString(ref data);
                }

                excludedConnectionIds = ids;
            }

            // Read payload
            var message = ReadSerializedHubMessage(ref data);

            return(new RabbitMQInvocation(message, excludedConnectionIds));
        }
        private static void ValidateArraySize(ref ReadOnlyMemory <byte> data, int expectedLength, string messageType)
        {
            var length = MessagePackUtil.ReadArrayHeader(ref data);

            if (length < expectedLength)
            {
                throw new InvalidDataException($"Insufficient items in {messageType} array.");
            }
        }
        public RabbitMQGroupCommand ReadGroupCommand(ReadOnlyMemory <byte> data)
        {
            // See WriteGroupCommand for format.
            ValidateArraySize(ref data, 5, "GroupCommand");

            var id           = MessagePackUtil.ReadInt32(ref data);
            var serverName   = MessagePackUtil.ReadString(ref data);
            var action       = (GroupAction)MessagePackUtil.ReadByte(ref data);
            var groupName    = MessagePackUtil.ReadString(ref data);
            var connectionId = MessagePackUtil.ReadString(ref data);

            return(new RabbitMQGroupCommand(id, action, serverName, groupName, connectionId));
        }
        public static SerializedHubMessage ReadSerializedHubMessage(ref ReadOnlyMemory <byte> data)
        {
            var count          = MessagePackUtil.ReadMapHeader(ref data);
            var serializations = new SerializedMessage[count];

            for (var i = 0; i < count; i++)
            {
                var protocol   = MessagePackUtil.ReadString(ref data);
                var serialized = MessagePackUtil.ReadBytes(ref data);
                serializations[i] = new SerializedMessage(protocol, serialized);
            }

            return(new SerializedHubMessage(serializations));
        }
        public IReadOnlyList <string> ReadList(ReadOnlyMemory <byte> data)
        {
            IReadOnlyList <string> list = null;
            var itemCount = MessagePackUtil.ReadArrayHeader(ref data);

            if (itemCount > 0)
            {
                var items = new string[itemCount];
                for (var i = 0; i < itemCount; i++)
                {
                    items[i] = MessagePackUtil.ReadString(ref data);
                }
                list = items;
            }
            return(list);
        }
 public int ReadAck(ReadOnlyMemory <byte> data)
 {
     // See WriteAck for format
     ValidateArraySize(ref data, 1, "Ack");
     return(MessagePackUtil.ReadInt32(ref data));
 }