private static Int64 ReadMultisegment(ref MessagePackReader reader)
{
var valueSpan = reader.Peek(3);
reader.Advance(3);
ref byte b = ref MemoryMarshal.GetReference(valueSpan);
private static Double ReadMultisegment(ref MessagePackReader reader)
{
var valueSpan = reader.Peek(9);
reader.Advance(9);
return(new Float64Bits(ref MemoryMarshal.GetReference(valueSpan)).Value);
}
private static String ReadMultisegment(ref MessagePackReader reader)
{
var length = (int)reader.GetRawByte(1);
var readSize = length + 2;
var valueSpan = reader.Peek(readSize);
reader.Advance(readSize);
return(EncodingUtils.ToString(valueSpan.Slice(2, length)));
}
private static String ReadMultisegment(ref MessagePackReader reader, byte position)
{
var length = position & 0x1F;
var readSize = length + 1;
var valueSpan = reader.Peek(readSize);
reader.Advance(readSize);
return(EncodingUtils.ToString(valueSpan.Slice(1, length)));
}
private static ExtensionResult ReadMultisegment(ref MessagePackReader reader)
{
var valueSpan = reader.Peek(18);
reader.Advance(18);
var typeCode = unchecked ((sbyte)valueSpan[1]);
return(new ExtensionResult(typeCode, valueSpan.Slice(2, 16)));
}
private static byte[] ReadMultisegment(ref MessagePackReader reader)
{
var length = reader.GetRawByte(1);
if (0u >= length)
{
reader.Advance(2);
return(MessagePackBinary.Empty);
}
var readSize = length + 2;
var valueSpan = reader.Peek(readSize);
var newBytes = new byte[length];
valueSpan.Slice(2, length).CopyTo(newBytes);
reader.Advance(readSize);
return(newBytes);
}
static T DeserializeWithLengthPrefixExt <T>(Stream stream, IFormatterResolver resolver)
{
const int ExtTypeCode = 111; // sample ext code
using (var output = new ArrayBufferWriter(16))
{
MessagePackBinary.ReadMessageBlockFromStreamUnsafe(stream, output);
var reader = new MessagePackReader(output.WrittenSpan);
var header = reader.ReadExtensionFormatHeader();
if (header.TypeCode == ExtTypeCode)
{
// memo, read fully
var valueSpan = reader.Peek((int)header.Length);
var reader0 = new MessagePackReader(valueSpan);
return(resolver.GetFormatter <T>().Deserialize(ref reader0, resolver));
}
else
{
throw new Exception();
}
}
}
private static void ReadMultisegment(ref MessagePackReader reader)
{
var lenSpan = reader.Peek(3);
ref byte b = ref MemoryMarshal.GetReference(lenSpan);
private static DateTime ReadMultisegment(ref MessagePackReader reader)
{
var valueSpan = reader.Peek(6);
ref byte b = ref MemoryMarshal.GetReference(valueSpan);
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);
}
}