Response DeserializeResponse(ref MessagePackReader reader, MessagePackSerializerOptions options) =>
new Response
{
MsgId = reader.ReadInt32(),
Result = reader.ReadBytes().ToArray().AsSequence(),
Error = reader.ReadBytes().ToArray().AsSequence()
};
private static (bool IsOdd, Version ProtocolVersion) DeserializeHandshake(ReadOnlySpan <byte> localRandomNumber, ReadOnlySequence <byte> handshakeSequence, Options options)
{
var reader = new MessagePackReader(handshakeSequence);
int elementCount = reader.ReadArrayHeader();
if (elementCount < 2)
{
throw new MultiplexingProtocolException("Unexpected handshake.");
}
int versionElementCount = reader.ReadArrayHeader();
int versionMajor = reader.ReadInt32();
int versionMinor = reader.ReadInt32();
var remoteVersion = new Version(versionMajor, versionMinor);
Discard(ref reader, versionElementCount - 2);
if (remoteVersion.Major != ProtocolVersion.Major)
{
throw new MultiplexingProtocolException($"Incompatible version. Local version: {ProtocolVersion}. Remote version: {remoteVersion}.");
}
byte[]? remoteRandomNumber = reader.ReadBytes()?.ToArray();
if (remoteRandomNumber is null)
{
throw new MultiplexingProtocolException("Missing random number.");
}
bool isOdd = IsOdd(localRandomNumber, remoteRandomNumber);
Discard(ref reader, elementCount - 2);
return(isOdd, remoteVersion);
}
public T Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var objectType = typeof(T);
var tracker = (T)Activator.CreateInstance(objectType);
var length = reader.ReadArrayHeader();
List <string> list = new List <string>();
for (var i = 0; i < length; i++)
{
list.Add(reader.ReadString());
}
for (var i = 0; i < length; i++)
{
var pi = objectType.GetProperty(list[i]);
if (reader.TryReadNil())
{
pi.SetValue(tracker, null, null);
}
else
{
var data = reader.ReadBytes();
var method = SerializeMethodCache.GetDeserializeMethod(pi.PropertyType);
var value = method.Invoke(null, new object[] { data.Value, options, null });
pi.SetValue(tracker, value, null);
}
}
return(tracker);
}
Request DeserializeRequest(ref MessagePackReader reader, MessagePackSerializerOptions options) =>
new Request
{
MsgId = reader.ReadInt32(),
Method = reader.ReadString(),
Params = reader.ReadBytes().ToArray().AsSequence()
};
public static IPocoTracker <T> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var tracker = new TrackablePocoTracker <T>();
var length = reader.ReadArrayHeader();
List <string> list = new List <string>();
for (var i = 0; i < length; i++)
{
list.Add(reader.ReadString());
}
var objectType = typeof(T);
for (var i = 0; i < length; i++)
{
var pi = objectType.GetProperty(list[i]);
if (reader.TryReadNil())
{
tracker.TrackSet(pi, null, null);
}
else
{
var data = reader.ReadBytes();
var method = SerializeMethodCache.GetDeserializeMethod(pi.PropertyType);
var value = method.Invoke(null, new object[] { data.Value, options, null });
tracker.TrackSet(pi, null, value);
}
}
return(tracker);
}
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 void ArrayHeaderTest(uint target, int length)
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.WriteArrayHeader(target);
writer.Flush();
sequence.Length.Is(length);
packer.PackArrayHeader((int)target).Position.Is(sequence.Length);
stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
// Expand sequence enough that ReadArrayHeader doesn't throw due to its security check.
writer.Write(new byte[target]);
writer.Flush();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
sequenceReader.ReadArrayHeader().Is((int)target);
sequenceReader.ReadBytes(); // read the padding we added
sequenceReader.End.IsTrue();
var ms = new MemoryStream(sequence.AsReadOnlySequence.ToArray());
var unpacker = MsgPack.Unpacker.Create(ms);
long len;
unpacker.ReadArrayLength(out len).IsTrue();
len.Is(target);
}
public System.Numerics.BigInteger Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
ReadOnlySequence <byte> bytes = reader.ReadBytes().Value;
#if NETCOREAPP
if (bytes.IsSingleSegment)
{
return(new System.Numerics.BigInteger(bytes.First.Span));
}
else
{
byte[] bytesArray = ArrayPool <byte> .Shared.Rent((int)bytes.Length);
try
{
bytes.CopyTo(bytesArray);
return(new System.Numerics.BigInteger(bytesArray.AsSpan(0, (int)bytes.Length)));
}
finally
{
ArrayPool <byte> .Shared.Return(bytesArray);
}
}
#else
return(new System.Numerics.BigInteger(bytes.ToArray()));
#endif
}
public System.Numerics.BigInteger Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
var bytes = reader.ReadBytes();
#if NETCOREAPP2_1
if (bytes.IsSingleSegment)
{
return(new System.Numerics.BigInteger(bytes.First.Span));
}
else
{
byte[] bytesArray = ArrayPool <byte> .Shared.Rent((int)bytes.Length);
try
{
bytes.CopyTo(bytesArray);
return(new System.Numerics.BigInteger(bytesArray.AsSpan(0, (int)bytes.Length)));
}
finally
{
ArrayPool <byte> .Shared.Return(bytesArray);
}
}
#else
return(new System.Numerics.BigInteger(bytes.ToArray()));
#endif
}
public T Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
var serializedObject = reader.ReadBytes();
if (null == serializedObject)
{
return(default);
private static (FrameHeader Header, ReadOnlySequence <byte> Payload) DeserializeFrame(ReadOnlySequence <byte> frameSequence)
{
var reader = new MessagePackReader(frameSequence);
int headerElementCount = reader.ReadArrayHeader();
var header = default(FrameHeader);
if (headerElementCount < 1)
{
throw new MultiplexingProtocolException("Not enough elements in frame header.");
}
header.Code = (ControlCode)reader.ReadInt32();
if (headerElementCount > 1)
{
if (reader.IsNil)
{
reader.ReadNil();
}
else
{
header.ChannelId = reader.ReadInt32();
}
if (headerElementCount > 2)
{
var payload = reader.ReadBytes() ?? default;
return(header, payload);
}
}
return(header, default);
}
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
if (!bytes.HasValue)
{
return(null);
}
else if (bytes.Value.Length == 0)
{
return(Array.Empty <byte>());
}
return(bytes.Value.ToArray());
}
else if (type == typeof(JsonElement))
{
var bytes = reader.ReadBytes();
if (bytes is null)
{
return(default);
static byte[] ReadStringBytes(ref MessagePackReader reader)
{
if (reader.IsNil)
{
reader.Skip();
return(null);
}
return(reader.ReadBytes()?.ToArray());
}
public byte[] Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
return(reader.ReadBytes().ToArray());
}
}
public byte[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
return(reader.ReadBytes().ToArray());
}
}
private static byte[] ReadBytes(ref MessagePackReader reader, string field)
{
try
{
return(reader.ReadBytes()?.ToArray() ?? Array.Empty <byte>());
}
catch (Exception ex)
{
throw new InvalidDataException($"Reading '{field}' as Byte[] failed.", ex);
}
}
public void Write_ByteArray()
{
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
var buffer = new byte[] { 1, 2, 3 };
writer.Write(buffer);
writer.Flush();
var reader = new MessagePackReader(sequence.AsReadOnlySequence);
Assert.Equal(buffer, reader.ReadBytes().Value.ToArray());
}
public static RedisCompletion ReadCompletion(ReadOnlyMemory <byte> data)
{
// See WriteCompletionMessage for the format
var reader = new MessagePackReader(data);
ValidateArraySize(ref reader, 2, "CompletionMessage");
var protocolName = reader.ReadString();
var ros = reader.ReadBytes();
return(new RedisCompletion(protocolName, ros ?? new ReadOnlySequence <byte>()));
}
public void WriteBinHeader()
{
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.WriteBinHeader(5);
writer.WriteRaw(new byte[] { 1, 2, 3, 4, 5 });
writer.Flush();
var reader = new MessagePackReader(sequence);
Assert.Equal(new byte[] { 1, 2, 3, 4, 5 }, reader.ReadBytes().Value.ToArray());
}
public PublicKey Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
options.Security.DepthStep(ref reader);
var bytes = reader.ReadBytes();
if (bytes is null)
{
throw new NullReferenceException($"ReadBytes from serialized {nameof(PublicKey)} is null.");
}
return(new PublicKey(bytes.Value.ToArray()));
}
public FungibleAssetValue Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
options.Security.DepthStep(ref reader);
var bytes = reader.ReadBytes();
if (bytes is null)
{
throw new NullReferenceException($"ReadBytes from serialized {nameof(FungibleAssetValue)} is null.");
}
return(new Codec().Decode(bytes.Value.ToArray()).ToFungibleAssetValue());
}
T IMessagePackFormatter <T> .Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
options.Security.DepthStep(ref reader);
var bytes = reader.ReadBytes();
if (bytes is null)
{
throw new NullReferenceException($"ReadBytes from serialized {typeof(T).Name} is null.");
}
return((T) new Codec().Decode(bytes.Value.ToArray()));
}
public IAccountStateDelta Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
options.Security.DepthStep(ref reader);
var bytes = reader.ReadBytes();
if (bytes is null)
{
throw new NullReferenceException($"ReadBytes from serialized {nameof(IAccountStateDelta)} is null.");
}
return(new ActionBase.AccountStateDelta(new Codec().Decode(bytes.Value.ToArray())));
}
public static SerializedHubMessage ReadSerializedHubMessage(ref MessagePackReader reader)
{
var count = reader.ReadMapHeader();
var serializations = new SerializedMessage[count];
for (var i = 0; i < count; i++)
{
var protocol = reader.ReadString();
var serialized = reader.ReadBytes()?.ToArray() ?? Array.Empty <byte>();
serializations[i] = new SerializedMessage(protocol, serialized);
}
return(new SerializedHubMessage(serializations));
}
public IPAddress Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
#if NETCOREAPP
var addressBytes = reader.ReadSpan();
return(new IPAddress(addressBytes));
#else
var addressBytes = reader.ReadBytes();
return(new IPAddress(addressBytes));
#endif
}
public PolymorphicAction <ActionBase> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var bytes = reader.ReadBytes();
if (bytes is null)
{
return(null);
}
IValue value = new Codec().Decode(bytes.Value.ToArray());
var plainValue = (Dictionary)value;
var typeStr = plainValue["type_id"];
var innerAction = (ActionBase)Activator.CreateInstance(Types[(Text)typeStr]);
innerAction.LoadPlainValue(plainValue["values"]);
return(new NCAction(innerAction));
}
T IMessagePackFormatter <T> .Deserialize(ref MessagePackReader reader,
MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
var formatter = new BinaryFormatter();
byte[] bytes = reader.ReadBytes()?.ToArray();
using (var stream = new MemoryStream(bytes))
{
return((T)formatter.Deserialize(stream));
}
}
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
if (!bytes.HasValue)
{
return(null);
}
else if (bytes.Value.Length == 0)
{
return(Array.Empty <byte>());
}
return(bytes.Value.ToArray());
}
}
catch (Exception ex)
{
throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex);
}
throw new FormatException($"Type {type} is not supported");
}
public global::CoreLibrary.Models.Crypto.CryptoKeyProtector 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 __ProtectorKey__ = default(byte[]);
var __ProtectorState__ = default(object[]);
var __ProtectorName__ = default(string);
for (int i = 0; i < length; i++)
{
switch (i)
{
case 0:
__ProtectorKey__ = reader.ReadBytes()?.ToArray();
break;
case 1:
__ProtectorState__ = formatterResolver.GetFormatterWithVerify <object[]>().Deserialize(ref reader, options);
break;
case 2:
__ProtectorName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::CoreLibrary.Models.Crypto.CryptoKeyProtector();
____result.ProtectorKey = __ProtectorKey__;
____result.ProtectorState = __ProtectorState__;
____result.ProtectorName = __ProtectorName__;
____result.OnAfterDeserialize();
reader.Depth--;
return(____result);
}
public unsafe Decimal Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (!BitConverter.IsLittleEndian)
{
throw new InvalidOperationException("NativeDecimalFormatter only allows on little endian env.");
}
ReadOnlySequence <byte> valueSequence = reader.ReadBytes().Value;
if (valueSequence.Length != sizeof(decimal))
{
throw new MessagePackSerializationException("Invalid decimal Size.");
}
decimal result;
var resultSpan = new Span <byte>(&result, sizeof(decimal));
valueSequence.CopyTo(resultSpan);
return(result);
}