public Result<T,TE> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
return default;
var count = reader.ReadArrayHeader();
if (count != HeaderCount)
throw new InvalidOperationException();
if (!reader.ReadBoolean())
{
reader.ReadNil();
var formatter = options.Resolver.GetFormatterWithVerify<T>();
var value = formatter.Deserialize(ref reader, options);
return Result.Success<T,TE>(value);
}
else
{
var formatter = options.Resolver.GetFormatterWithVerify<TE>();
var error = formatter.Deserialize(ref reader, options);
return Result.Failure<T,TE>(error);
}
}
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);
}
public static int?ReadNullableInt(ref MessagePackReader reader)
{
if (!reader.IsNil)
{
return(reader.ReadInt32());
}
else
{
reader.ReadNil();
return(null);
}
}
public T?Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
if (reader.IsNil)
{
reader.ReadNil();
return(null);
}
else
{
return(resolver.GetFormatterWithVerify <T>().Deserialize(ref reader, resolver));
}
}
public T?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
reader.ReadNil();
return(null);
}
else
{
return(options.Resolver.GetFormatterWithVerify <T>().Deserialize(ref reader, options));
}
}
public static bool?ReadNullableBool(ref MessagePackReader reader)
{
if (!reader.IsNil)
{
return(reader.ReadBoolean());
}
else
{
reader.ReadNil();
return(null);
}
}
public ConnectionAckTypeData Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.NextMessagePackType.Equals(MessagePackType.Array))
{
return(new ConnectionAckTypeData(
MessagePackSerializer.Deserialize <ConnectionData>(ref reader, options)));
}
else if (reader.NextMessagePackType.Equals(MessagePackType.Map))
{
return(new ConnectionAckTypeData(MessagePackSerializer.Deserialize <Dictionary <int, string> >(ref reader)));
}
else
{
reader.ReadNil();
return(null);
}
}
private static string ReadString(ref MessagePackReader reader, string field)
{
if (reader.End)
{
ThrowInvalidDataException(field, "String");
}
if (reader.IsNil)
{
reader.ReadNil();
return(null);
}
else if (reader.NextMessagePackType == MessagePackType.String)
{
return(reader.ReadString());
}
ThrowInvalidDataException(field, "String");
return(null); //This should never be reached.
}
public void NilTest()
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.WriteNil();
writer.Flush();
sequence.Length.Is(1);
packer.PackNull().Position.Is(sequence.Length);
stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
sequenceReader.ReadNil().Is(Nil.Default);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).IsNil.IsTrue();
}
protected virtual (FrameHeader Header, ReadOnlySequence <byte> Payload) DeserializeFrame(ReadOnlySequence <byte> frameSequence)
{
var reader = new MessagePackReader(frameSequence);
int headerElementCount = reader.ReadArrayHeader();
if (headerElementCount < 1)
{
throw new MultiplexingProtocolException("Not enough elements in frame header.");
}
FrameHeader header;
var code = (ControlCode)reader.ReadInt32();
ulong? channelId = null;
if (headerElementCount > 1)
{
if (reader.IsNil)
{
reader.ReadNil();
}
else
{
channelId = reader.ReadUInt64();
}
if (headerElementCount > 2)
{
var payload = reader.ReadBytes() ?? default;
header = this.CreateFrameHeader(code, channelId, null);
return(header, payload);
}
}
header = this.CreateFrameHeader(code, channelId, null);
return(header, default);
}
public Nil?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(reader.ReadNil());
}
public Nil?Deserialize(ref MessagePackReader reader, IFormatterResolver typeResolver)
{
return(reader.ReadNil());
}
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 ConnectionData Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
reader.ReadNil();
return(null);
}
int size = reader.ReadArrayHeader();
if (size < 4 || 6 < size)
{
throw new FormatException(string.Format("ConnectionData expected 4, 5 or 6 elements but found {0} instead!", size));
}
bool clusterIncluded = false;
string clusterName = null;
if (reader.NextMessagePackType == MessagePackType.String)
{
clusterName = reader.ReadString();
clusterIncluded = true;
}
else if (reader.IsNil)
{
clusterIncluded = true;
reader.ReadNil();
}
bool serveOnSame = reader.ReadBoolean();
int protocol = reader.ReadInt32();
bool fragment = reader.ReadBoolean();
long?fragTransUnit = null;
if (reader.IsNil)
{
reader.ReadNil();
}
else
{
fragTransUnit = reader.ReadInt64();
}
string[] reservedFields = null;
if ((size == 5 && !clusterIncluded) || size == 6)
{
if (reader.IsNil)
{
reader.ReadNil();
}
else
{
int innerSize = reader.ReadArrayHeader();
reservedFields = new string[innerSize];
for (int i = 0; i < innerSize; ++i)
{
if (reader.IsNil)
{
reader.ReadNil();
}
else
{
reservedFields[i] = reader.ReadString();
}
}
}
}
return(new ConnectionData(clusterName, serveOnSame, protocol, fragment, fragTransUnit, reservedFields));
}
public StackItem Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var count = reader.ReadArrayHeader();
if (count != 2)
{
throw new MessagePackSerializationException($"Invalid StackItem Array Header {count}");
}
var type = options.Resolver.GetFormatterWithVerify <StackItemType>().Deserialize(ref reader, options);
switch (type)
{
case StackItemType.Any:
reader.ReadNil();
return(StackItem.Null);
case StackItemType.Boolean:
return(reader.ReadBoolean() ? StackItem.True : StackItem.False);
case StackItemType.Buffer:
{
var bytes = options.Resolver.GetFormatter <byte[]>().Deserialize(ref reader, options);
return(new NeoBuffer(bytes));
}
case StackItemType.ByteString:
{
var bytes = options.Resolver.GetFormatter <byte[]>().Deserialize(ref reader, options);
return(new NeoByteString(bytes));
}
case StackItemType.Integer:
{
var integer = options.Resolver.GetFormatterWithVerify <BigInteger>().Deserialize(ref reader, options);
return(new NeoInteger(integer));
}
case StackItemType.InteropInterface:
{
var typeName = options.Resolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
return(new TraceInteropInterface(typeName));
}
case StackItemType.Pointer:
reader.ReadNil();
return(new NeoPointer(Array.Empty <byte>(), 0));
case StackItemType.Map:
{
var map = new NeoMap();
var mapCount = reader.ReadMapHeader();
for (int i = 0; i < mapCount; i++)
{
var key = (PrimitiveType)Deserialize(ref reader, options);
map[key] = Deserialize(ref reader, options);
}
return(map);
}
case StackItemType.Array:
case StackItemType.Struct:
{
var array = type == StackItemType.Array
? new NeoArray()
: new NeoStruct();
var arrayCount = reader.ReadArrayHeader();
for (int i = 0; i < arrayCount; i++)
{
array.Add(Deserialize(ref reader, options));
}
return(array);
}
}
throw new MessagePackSerializationException($"Invalid StackItem {type}");
}
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 Unit Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
reader.ReadNil();
return(null);
}