public global::DRXLibrary.Models.Drx.DrxFlagColour Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
var length = reader.ReadArrayHeader();
var __A__ = default(byte);
var __R__ = default(byte);
var __G__ = default(byte);
var __B__ = default(byte);
for (int i = 0; i < length; i++)
{
switch (i)
{
case 0:
__A__ = reader.ReadByte();
break;
case 1:
__R__ = reader.ReadByte();
break;
case 2:
__G__ = reader.ReadByte();
break;
case 3:
__B__ = reader.ReadByte();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::DRXLibrary.Models.Drx.DrxFlagColour();
____result.A = __A__;
____result.R = __R__;
____result.G = __G__;
____result.B = __B__;
reader.Depth--;
return(____result);
}
public global::UnityEngine.Color32 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var __r__ = default(byte);
var __g__ = default(byte);
var __b__ = default(byte);
var __a__ = default(byte);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__r__ = reader.ReadByte();
break;
case 1:
__g__ = reader.ReadByte();
break;
case 2:
__b__ = reader.ReadByte();
break;
case 3:
__a__ = reader.ReadByte();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::UnityEngine.Color32(__r__, __g__, __b__, __a__);
____result.r = __r__;
____result.g = __g__;
____result.b = __b__;
____result.a = __a__;
return(____result);
}
public global::GatewayServer.Packet.PKTReqMatching Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __MatchingType__ = default(byte);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__MatchingType__ = reader.ReadByte();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::GatewayServer.Packet.PKTReqMatching();
____result.MatchingType = __MatchingType__;
reader.Depth--;
return(____result);
}
public global::Server.SharedThings.Packets.ClientPackets.CharacterListRequest Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __A__ = default(byte);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__A__ = reader.ReadByte();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.ClientPackets.CharacterListRequest();
____result.A = __A__;
return(____result);
}
public byte[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.NextMessagePackType == MessagePackType.Array)
{
int len = reader.ReadArrayHeader();
if (len == 0)
{
return(Array.Empty <byte>());
}
byte[] array = new byte[len];
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < len; i++)
{
reader.CancellationToken.ThrowIfCancellationRequested();
array[i] = reader.ReadByte();
}
}
finally
{
reader.Depth--;
}
return(array);
}
else
{
return(reader.ReadBytes()?.ToArray());
}
}
public object Deserialize(int id, ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (id == 0)
{
return(reader.ReadString());
}
if (id == 1)
{
return(reader.ReadInt32());
}
if (id == 2)
{
return(reader.ReadByte());
}
if (id == 4)
{
return(options.Resolver.GetFormatterWithVerify <Vector3>().Deserialize(ref reader, options));
}
if (id == 5)
{
return(reader.ReadSingle());
}
return(null);
}
public override TestSerializable Deserialize(MessagePackReader reader)
{
var value = reader.ReadByte();
var testSerializable = new TestSerializable(value);
return(testSerializable);
}
public Byte?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(reader.ReadByte());
}
public Color Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("type code is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var r = default(byte);
var g = default(byte);
var b = default(byte);
var a = default(byte);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
r = reader.ReadByte();
break;
case 1:
g = reader.ReadByte();
break;
case 2:
b = reader.ReadByte();
break;
case 3:
a = reader.ReadByte();
break;
default:
reader.Skip();
break;
}
}
var result = new Color(r, g, b, a);
return(result);
}
public RigidbodyWrapper.Wrapper Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
options.Security.DepthStep(ref reader);
int length = reader.ReadArrayHeader();
RigidbodyWrapper.Wrapper wrapper = new RigidbodyWrapper.Wrapper
{
Values = new Dictionary <int, object>(5),
Dirty = new Dictionary <int, bool>(5)
};
for (int i = 0; i < length / 2; i++)
{
byte id = reader.ReadByte();
switch (id)
{
case 0:
wrapper.Values[0] = wrapper.Deserialize(0, ref reader, options);
wrapper.Dirty[0] = true;
break;
case 1:
wrapper.Values[1] = wrapper.Deserialize(1, ref reader, options);
wrapper.Dirty[1] = true;
break;
case 2:
wrapper.Values[2] = wrapper.Deserialize(2, ref reader, options);
wrapper.Dirty[2] = true;
break;
case 3:
wrapper.Values[3] = wrapper.Deserialize(3, ref reader, options);
wrapper.Dirty[3] = true;
break;
case 4:
wrapper.Values[4] = wrapper.Deserialize(4, ref reader, options);
wrapper.Dirty[4] = true;
break;
default:
reader.Skip();
break;
}
}
reader.Depth--;
return(wrapper);
}
public RedisGroupCommand ReadGroupCommand(ReadOnlyMemory <byte> data)
{
var reader = new MessagePackReader(data);
// See WriteGroupCommand for format.
ValidateArraySize(ref reader, 5, "GroupCommand");
var id = reader.ReadInt32();
var serverName = reader.ReadString();
var action = (GroupAction)reader.ReadByte();
var groupName = reader.ReadString();
var connectionId = reader.ReadString();
return(new RedisGroupCommand(id, serverName, action, groupName, connectionId));
}
public global::GatewayServer.Packet.PKTNTFGamePut Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Result__ = default(ushort);
var __PutPos__ = default((int, int));
var __Type__ = default(byte);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Result__ = reader.ReadUInt16();
break;
case 1:
__PutPos__ = formatterResolver.GetFormatterWithVerify <(int, int)>().Deserialize(ref reader, options);
break;
case 2:
__Type__ = reader.ReadByte();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::GatewayServer.Packet.PKTNTFGamePut();
____result.Result = __Result__;
____result.PutPos = __PutPos__;
____result.Type = __Type__;
reader.Depth--;
return(____result);
}
private Message ReadCompletion(ref MessagePackReader reader)
{
// https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#completion-message-encoding-1
ReadHeaders(ref reader);
string invocationId = reader.ReadString();
byte resultKind = reader.ReadByte();
switch (resultKind)
{
// 1 - Error result - Result contains a String with the error message
case 1:
string error = reader.ReadString();
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId,
error = error
});
// 2 - Void result - Result is absent
case 2:
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId
});
// 3 - Non-Void result - Result contains the value returned by the server
case 3:
object item = ReadItem(ref reader, invocationId);
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId,
item = item,
result = item
});
default:
throw new NotImplementedException("Unknown resultKind: " + resultKind);
}
}
public void ByteTest(byte target, int length)
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.Write(target);
writer.Flush();
sequence.Length.Is(length);
packer.Pack(target).Position.Is(sequence.Length);
stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
sequenceReader.ReadByte().Is(target);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).AsByte().Is(target);
}
public static InterprocessMessage ReadPubSubMessage(byte[] buffer)
{
var reader = new MessagePackReader(buffer);
if (reader.ReadArrayHeader() != 3)
{
throw new InvalidOperationException("Invalid messagepack buffer.");
}
var b = reader.ReadByte();
var msgType = (MessageType)b;
var keyIndex = (int)reader.Consumed;
reader.Skip();
var keyOffset = (int)reader.Consumed;
reader.Skip();
return(new InterprocessMessage(msgType, buffer, keyIndex, keyOffset));
}
public void ParseMessages(BufferSegment segment, ref List <Message> messages)
{
int offset = segment.Offset;
while (offset < segment.Count)
{
int length = (int)ReadVarInt(segment.Data, ref offset);
var reader = new MessagePackReader(new ReadOnlyMemory <byte>(segment.Data, offset, length));
int arrayLength = reader.ReadArrayHeader();
int messageType = reader.ReadByte();
switch ((MessageTypes)messageType)
{
case MessageTypes.Invocation: messages.Add(ReadInvocation(ref reader)); break;
case MessageTypes.StreamItem: messages.Add(ReadStreamItem(ref reader)); break;
case MessageTypes.Completion: messages.Add(ReadCompletion(ref reader)); break;
case MessageTypes.StreamInvocation: messages.Add(ReadStreamInvocation(ref reader)); break;
case MessageTypes.CancelInvocation: messages.Add(ReadCancelInvocation(ref reader)); break;
case MessageTypes.Ping:
// https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#ping-message-encoding-1
messages.Add(new Message {
type = MessageTypes.Ping
});
break;
case MessageTypes.Close: messages.Add(ReadClose(ref reader)); break;
}
offset += length;
}
}
public object Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
var type = reader.GetMessagePackType();
switch (type)
{
case MessagePackType.Integer:
var code = reader.Peek();
if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else
{
switch (code)
{
case MessagePackCode.Int8: return(reader.ReadSByte());
case MessagePackCode.Int16: return(reader.ReadInt16());
case MessagePackCode.Int32: return(reader.ReadInt32());
case MessagePackCode.Int64: return(reader.ReadInt64());
case MessagePackCode.UInt8: return(reader.ReadByte());
case MessagePackCode.UInt16: return(reader.ReadUInt16());
case MessagePackCode.UInt32: return(reader.ReadUInt32());
case MessagePackCode.UInt64: return(reader.ReadUInt64());
default: ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
}
}
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (MessagePackCode.Float32 == reader.Peek())
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
return(reader.ReadBytes());
case MessagePackType.Extension:
var extTypeCode = reader.GetExtensionFormatTypeCode();
if (extTypeCode != ReservedMessagePackExtensionTypeCode.DateTime)
{
ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes();
}
return(reader.ReadDateTime());
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
var objectFormatter = formatterResolver.GetFormatter <object>();
var array = new object[length];
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, formatterResolver);
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
var objectFormatter = formatterResolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length);
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, formatterResolver);
var value = objectFormatter.Deserialize(ref reader, formatterResolver);
hash.Add(key, value);
}
return(hash);
}
case MessagePackType.Nil:
reader.Advance(1);
return(null);
default:
ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
}
}
public global::Server.SharedThings.Enums.AuthorityType Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
return((global::Server.SharedThings.Enums.AuthorityType)reader.ReadByte());
}
public override T Deserialize(ref MessagePackReader reader)
{
byte value = reader.ReadByte();
return(MessagePackUnsafeUtility.As <byte, T>(ref value));
}
public void ForceBlockFormatters()
{
var block = new BlockFormattedIntegers
{
UInt8Property = 1,
UInt16Property = 2,
UInt32Property = 3,
UInt64Property = 4,
Int8Property = 1,
Int16Property = 2,
Int32Property = 3,
Int64Property = 4,
NullableUInt8Property = 1,
NullableUInt16Property = 2,
NullableUInt32Property = 3,
NullableUInt64Property = 4,
NullableInt8Property = 1,
NullableInt16Property = 2,
NullableInt32Property = 3,
NullableInt64Property = 4,
};
byte[] packed = MessagePackSerializer.Serialize(block, MessagePackSerializerOptions.Standard);
var reader = new MessagePackReader(packed);
reader.ReadArrayHeader();
Assert.Equal(MessagePackCode.UInt8, reader.NextCode);
Assert.Equal(1, reader.ReadByte());
Assert.Equal(MessagePackCode.UInt16, reader.NextCode);
Assert.Equal(2, reader.ReadUInt16());
Assert.Equal(MessagePackCode.UInt32, reader.NextCode);
Assert.Equal(3u, reader.ReadUInt32());
Assert.Equal(MessagePackCode.UInt64, reader.NextCode);
Assert.Equal(4u, reader.ReadUInt64());
Assert.Equal(MessagePackCode.Int8, reader.NextCode);
Assert.Equal(1, reader.ReadSByte());
Assert.Equal(MessagePackCode.Int16, reader.NextCode);
Assert.Equal(2, reader.ReadInt16());
Assert.Equal(MessagePackCode.Int32, reader.NextCode);
Assert.Equal(3, reader.ReadInt32());
Assert.Equal(MessagePackCode.Int64, reader.NextCode);
Assert.Equal(4, reader.ReadInt64());
Assert.Equal(MessagePackCode.UInt8, reader.NextCode);
Assert.Equal(1, reader.ReadByte());
Assert.Equal(MessagePackCode.UInt16, reader.NextCode);
Assert.Equal(2, reader.ReadUInt16());
Assert.Equal(MessagePackCode.UInt32, reader.NextCode);
Assert.Equal(3u, reader.ReadUInt32());
Assert.Equal(MessagePackCode.UInt64, reader.NextCode);
Assert.Equal(4u, reader.ReadUInt64());
Assert.Equal(MessagePackCode.Int8, reader.NextCode);
Assert.Equal(1, reader.ReadSByte());
Assert.Equal(MessagePackCode.Int16, reader.NextCode);
Assert.Equal(2, reader.ReadInt16());
Assert.Equal(MessagePackCode.Int32, reader.NextCode);
Assert.Equal(3, reader.ReadInt32());
Assert.Equal(MessagePackCode.Int64, reader.NextCode);
Assert.Equal(4, reader.ReadInt64());
}
public object Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
var type = reader.NextMessagePackType;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (MessagePackCode.Float32 == reader.NextCode)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
return(reader.ReadBytes());
case MessagePackType.Extension:
var ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
var objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, resolver);
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
var objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length);
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, resolver);
var value = objectFormatter.Deserialize(ref reader, resolver);
hash.Add(key, value);
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new InvalidOperationException("Invalid primitive bytes.");
}
}
public object Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
MessagePackType type = reader.NextMessagePackType;
IFormatterResolver resolver = options.Resolver;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (code >= MessagePackCode.MinNegativeFixInt && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (code >= MessagePackCode.MinFixInt && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (reader.NextCode == MessagePackCode.Float32)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
// We must copy the sequence returned by ReadBytes since the reader's sequence is only valid during deserialization.
return(reader.ReadBytes()?.ToArray());
case MessagePackType.Extension:
ExtensionHeader ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
if (length == 0)
{
return(Array.Empty <object>());
}
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, options);
}
}
finally
{
reader.Depth--;
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length, options.Security.GetEqualityComparer <object>());
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, options);
var value = objectFormatter.Deserialize(ref reader, options);
hash.Add(key, value);
}
}
finally
{
reader.Depth--;
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new MessagePackSerializationException("Invalid primitive bytes.");
}
}
public override byte Deserialize(MessagePackReader reader)
{
return(reader.ReadByte());
}
public Byte Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
return(reader.ReadByte());
}
public StatusCode Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new StatusCode(reader.ReadByte(), reader.ReadUInt16()));
}