public Int16?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(reader.ReadInt16());
}
public DateTimeOffset Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
var count = reader.ReadArrayHeader();
if (count != 2)
{
ThrowHelper.ThrowInvalidOperationException_DateTimeOffset_Format();
}
var utc = reader.ReadDateTime();
var dtOffsetMinutes = reader.ReadInt16();
return(new DateTimeOffset(utc.Ticks, TimeSpan.FromMinutes(dtOffsetMinutes)));
}
public DateTimeOffset Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var count = reader.ReadArrayHeader();
if (count != 2)
{
throw new MessagePackSerializationException("Invalid DateTimeOffset format.");
}
DateTime utc = reader.ReadDateTime();
var dtOffsetMinutes = reader.ReadInt16();
return(new DateTimeOffset(utc.Ticks, TimeSpan.FromMinutes(dtOffsetMinutes)));
}
public Int16[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var array = new Int16[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadInt16();
}
return(array);
}
public void Int16Test(short 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.ReadInt16().Is(target);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).AsInt16().Is(target);
}
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 Int16 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(reader.ReadInt16());
}
public global::Shared.Protocol.ErrCode Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
return((global::Shared.Protocol.ErrCode)reader.ReadInt16());
}
public void IntegerRangeTest()
{
// Int16 can accepts UInt8
// Int32 can accepts UInt16
// Int64 can accepts UInt32
{
var small = new Sequence <byte>();
var smallWriter = new MessagePackWriter(small);
smallWriter.Write(byte.MaxValue);
smallWriter.Flush();
var smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt16().Is(byte.MaxValue);
var target = new Sequence <byte>();
var targetWriter = new MessagePackWriter(target);
targetWriter.Write((short)byte.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
}
{
var small = new Sequence <byte>();
var smallWriter = new MessagePackWriter(small);
smallWriter.Write(byte.MaxValue);
smallWriter.Flush();
var smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt32().Is(byte.MaxValue);
var target = new Sequence <byte>();
var targetWriter = new MessagePackWriter(target);
targetWriter.Write((int)byte.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
small.Reset();
smallWriter = new MessagePackWriter(small);
smallWriter.Write(ushort.MaxValue);
smallWriter.Flush();
smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt32().Is(ushort.MaxValue);
target.Reset();
targetWriter = new MessagePackWriter(target);
targetWriter.Write((int)ushort.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
}
{
var small = new Sequence <byte>();
var smallWriter = new MessagePackWriter(small);
smallWriter.Write(byte.MaxValue);
smallWriter.Flush();
var smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt64().Is(byte.MaxValue);
var target = new Sequence <byte>();
var targetWriter = new MessagePackWriter(target);
targetWriter.Write((long)byte.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
small.Reset();
smallWriter = new MessagePackWriter(small);
smallWriter.Write(ushort.MaxValue);
smallWriter.Flush();
smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt64().Is(ushort.MaxValue);
target.Reset();
targetWriter = new MessagePackWriter(target);
targetWriter.Write((long)ushort.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
small.Reset();
smallWriter = new MessagePackWriter(small);
smallWriter.Write(uint.MaxValue);
smallWriter.Flush();
smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt64().Is(uint.MaxValue);
target.Reset();
targetWriter = new MessagePackWriter(target);
targetWriter.Write((long)uint.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
}
}
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 Int16 Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
return(reader.ReadInt16());
}
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 override T Deserialize(ref MessagePackReader reader)
{
short value = reader.ReadInt16();
return(MessagePackUnsafeUtility.As <short, T>(ref value));
}
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::Fenix.Common.DefaultErrCode Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
return((global::Fenix.Common.DefaultErrCode)reader.ReadInt16());
}