public void ReadSingle_ReadIntegersOfVariousLengthsAndMagnitudes()
{
foreach ((System.Numerics.BigInteger value, ReadOnlySequence <byte> encoded) in this.integersOfInterest)
{
this.logger.WriteLine("Decoding 0x{0:x} from {1}", value, MessagePackCode.ToFormatName(encoded.First.Span[0]));
Assert.Equal((float)(double)value, new MessagePackReader(encoded).ReadSingle());
}
}
public void ReadSingle_ReadIntegersOfVariousLengthsAndMagnitudes()
{
foreach (var(value, encoded) in IntegersOfInterest)
{
this.logger.WriteLine("Decoding 0x{0:x} from {1}", value, MessagePackCode.ToFormatName(encoded.First.Span[0]));
Assert.Equal((float)(double)value, new MessagePackReader(encoded).ReadSingle());
}
}
public Unit?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(Unit.Default);
}
else
{
throw new InvalidOperationException("Invalid Data type. Code: " + MessagePackCode.ToFormatName(reader.NextCode));
}
}
public Unit?Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(Unit.Default);
}
else
{
throw new InvalidOperationException("Invalid Data type. Code:" + MessagePackCode.ToFormatName(bytes[offset]));
}
}
public Double Read(ref MessagePackReader reader, ref byte position)
{
throw new InvalidOperationException(string.Format("code is invalid. code:{0} format:{1}", position, MessagePackCode.ToFormatName(position)));
}
public decimal Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (!(reader.ReadStringSequence() is ReadOnlySequence <byte> sequence))
{
throw new MessagePackSerializationException(string.Format("Unexpected msgpack code {0} ({1}) encountered.", MessagePackCode.Nil, MessagePackCode.ToFormatName(MessagePackCode.Nil)));
}
if (sequence.IsSingleSegment)
{
var span = sequence.First.Span;
if (System.Buffers.Text.Utf8Parser.TryParse(span, out decimal result, out var bytesConsumed))
{
if (span.Length != bytesConsumed)
{
throw new MessagePackSerializationException("Unexpected length of string.");
}
return(result);
}
}
else
{
// sequence.Length is not free
var seqLen = (int)sequence.Length;
if (seqLen < 128)
{
Span <byte> span = stackalloc byte[seqLen];
sequence.CopyTo(span);
if (System.Buffers.Text.Utf8Parser.TryParse(span, out decimal result, out var bytesConsumed))
{
if (seqLen != bytesConsumed)
{
throw new MessagePackSerializationException("Unexpected length of string.");
}
return(result);
}
}
else
{
var rentArray = ArrayPool <byte> .Shared.Rent(seqLen);
try
{
sequence.CopyTo(rentArray);
if (System.Buffers.Text.Utf8Parser.TryParse(rentArray.AsSpan(0, seqLen), out decimal result, out var bytesConsumed))
{
if (seqLen != bytesConsumed)
{
throw new MessagePackSerializationException("Unexpected length of string.");
}
return(result);
}
}
finally
{
ArrayPool <byte> .Shared.Return(rentArray);
}
}
}
throw new MessagePackSerializationException("Can't parse to decimal, input string was not in a correct format.");
}
public byte[] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var type = MessagePackBinary.GetMessagePackType(bytes, offset);
if (type == MessagePackType.Nil)
{
readSize = 1;
return(null);
}
else if (type == MessagePackType.Binary)
{
return(MessagePackBinary.ReadBytes(bytes, offset, out readSize));
}
else if (type == MessagePackType.String)
{
var code = bytes[offset];
unchecked
{
if (MessagePackCode.MinFixStr <= code && code <= MessagePackCode.MaxFixStr)
{
var length = bytes[offset] & 0x1F;
readSize = length + 1;
var result = new byte[length];
Buffer.BlockCopy(bytes, offset + 1, result, 0, result.Length);
return(result);
}
else if (code == MessagePackCode.Str8)
{
var length = (int)bytes[offset + 1];
readSize = length + 2;
var result = new byte[length];
Buffer.BlockCopy(bytes, offset + 2, result, 0, result.Length);
return(result);
}
else if (code == MessagePackCode.Str16)
{
var length = (bytes[offset + 1] << 8) + (bytes[offset + 2]);
readSize = length + 3;
var result = new byte[length];
Buffer.BlockCopy(bytes, offset + 3, result, 0, result.Length);
return(result);
}
else if (code == MessagePackCode.Str32)
{
var length = (int)((uint)(bytes[offset + 1] << 24) | (uint)(bytes[offset + 2] << 16) | (uint)(bytes[offset + 3] << 8) | (uint)bytes[offset + 4]);
readSize = length + 5;
var result = new byte[length];
Buffer.BlockCopy(bytes, offset + 5, result, 0, result.Length);
return(result);
}
}
}
throw new InvalidOperationException(string.Format("code is invalid. code:{0} format:{1}", bytes[offset], MessagePackCode.ToFormatName(bytes[offset])));
}
private static uint UnpackUIntX(Stream s)
{
int i = s.ReadByte();
if (i == -1)
{
throw new StreamSerializationException("Unexpected end of stream while unpacking msgpack code");
}
var b = (byte)i;
switch (b)
{
case MessagePackCode.UInt32:
return(UnpackUInt32(s));
case MessagePackCode.UInt16:
return(UnpackUInt16(s));
case MessagePackCode.UInt8:
return(UnpackUInt8(s));
default:
if ((b & 0x80) == 0)
{
return(UnpackFixedUInt(b));
}
else
{
throw new StreamSerializationException($"Unexpected msgpack code {b} ({MessagePackCode.ToFormatName(b)}) encountered.");
}
}
}
private bool TryReadHeader(Stream s, out int length)
{
int i = s.ReadByte();
if (i == -1)
{
length = default;
return(false);
}
byte b = (byte)i;
if (b != fmtCode_fixArraySize2)
{
throw new StreamSerializationException($"Unexpected msgpack code {b} ({MessagePackCode.ToFormatName(b)}) encountered. Expected {fmtCode_fixArraySize2}");
}
var ulength = UnpackUIntX(s);
if (ulength > int.MaxValue)
{
throw new StreamSerializationException($"Frame length too large: {ulength}");
}
length = (int)ulength;
return(true);
}
public unsafe Guid Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (!BitConverter.IsLittleEndian)
{
throw new Exception("BinaryGuidFormatter only allows on little endian env.");
}
if (!(offset + 18 <= bytes.Length))
{
throw new ArgumentOutOfRangeException();
}
fixed(byte *src = &bytes[offset])
{
if (src[0] != MessagePackCode.Bin8)
{
throw new InvalidOperationException(string.Format("code is invalid. code:{0} format:{1}", bytes[offset], MessagePackCode.ToFormatName(bytes[offset])));
}
if (src[1] != 16)
{
throw new InvalidOperationException("Invalid Guid Size.");
}
var target = *(Guid *)(src + 2);
readSize = 18;
return(target);
}
}
private void ReadElement()
{
mCurrentElementType =
MessagePackCode.ToMessagePackType((byte)PeekByte());
}
internal static object Deserialize(ObjectSerializationInfo metaInfo, ObjectSerializationInfo.EmittableMember[] readMembers, int[] constructorParameterIndexes, AutomataDictionary mapMemberDictionary, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var startOffset = offset;
object[] parameters = null;
var headerType = MessagePackBinary.GetMessagePackType(bytes, offset);
if (headerType == MessagePackType.Nil)
{
readSize = 1;
return(null);
}
else if (headerType == MessagePackType.Array)
{
var arraySize = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
// ReadValues
parameters = new object[arraySize];
for (int i = 0; i < arraySize; i++)
{
var info = readMembers[i];
if (info != null)
{
parameters[i] = MessagePackSerializer.NonGeneric.Deserialize(info.Type, bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
else
{
offset += MessagePackBinary.ReadNextBlock(bytes, offset);
}
}
}
else if (headerType == MessagePackType.Map)
{
var mapSize = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize);
offset += readSize;
// ReadValues
parameters = new object[mapSize];
for (int i = 0; i < mapSize; i++)
{
var rawPropName = MessagePackBinary.ReadStringSegment(bytes, offset, out readSize);
offset += readSize;
int index;
if (mapMemberDictionary.TryGetValue(rawPropName.Array, rawPropName.Offset, rawPropName.Count, out index))
{
var info = readMembers[index];
parameters[index] = MessagePackSerializer.NonGeneric.Deserialize(info.Type, bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
else
{
offset += MessagePackBinary.ReadNextBlock(bytes, offset);
}
}
}
else
{
throw new InvalidOperationException("Invalid MessagePackType:" + MessagePackCode.ToFormatName(bytes[offset]));
}
// CreateObject
object result = null;
if (constructorParameterIndexes.Length == 0)
{
result = Activator.CreateInstance(metaInfo.Type);
}
else
{
var args = new object[constructorParameterIndexes.Length];
for (int i = 0; i < constructorParameterIndexes.Length; i++)
{
args[i] = parameters[constructorParameterIndexes[i]];
}
result = Activator.CreateInstance(metaInfo.Type, args);
}
// SetMembers
for (int i = 0; i < readMembers.Length; i++)
{
var info = readMembers[i];
if (info != null)
{
info.ReflectionStoreValue(result, parameters[i]);
}
}
readSize = offset - startOffset;
return(result);
}
public LocalDate Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var dt = MessagePackBinary.ReadDateTime(bytes, offset, out readSize);
LocalDateTime ldt = LocalDateTime.FromDateTime(dt);
if (ldt.TimeOfDay != LocalTime.Midnight)
{
throw new InvalidOperationException($"code is invalid. code:{bytes[offset]} format:{MessagePackCode.ToFormatName(bytes[offset])}");
}
return(LocalDate.FromDateTime(dt));
}
public Unit?Deserialize(byte[] bytes, int offset, IFormatterResolver typeResolver, out int readSize)
{
if (bytes[offset] == MessagePackCode.Nil)
{
readSize = 1;
return(Unit.Default);
}
else
{
throw new InvalidOperationException(string.Format("code is invalid. code:{0} format:{1}", bytes[offset], MessagePackCode.ToFormatName(bytes[offset])));
}
}
public Ulid Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var bin = reader.ReadBytes();
if (bin == null)
{
throw new MessagePackSerializationException(string.Format("Unexpected msgpack code {0} ({1}) encountered.", MessagePackCode.Nil, MessagePackCode.ToFormatName(MessagePackCode.Nil)));
}
var seq = bin.Value;
if (seq.IsSingleSegment)
{
return(new Ulid(seq.First.Span));
}
else
{
Span <byte> buf = stackalloc byte[16];
seq.CopyTo(buf);
return(new Ulid(buf));
}
}
