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()); } } 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"); }
internal override long DeserializeContentProcessed(ReadOnlySequence <byte> payload) { var reader = new MessagePackReader(payload); reader.ReadArrayHeader(); return(reader.ReadInt64()); }
public MessageHeader Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { string userName = reader.ReadString(); string messageId = reader.ReadString(); long createTime = reader.ReadInt64(); long requestTime = reader.ReadInt64(); bool isFragmented = reader.ReadBoolean(); bool? firstFragment = MsgPackUtils.ReadNullableBool(ref reader); bool? lastFragment = MsgPackUtils.ReadNullableBool(ref reader); int? offset = MsgPackUtils.ReadNullableInt(ref reader); int? fullDataSize = MsgPackUtils.ReadNullableInt(ref reader); int dataType = reader.ReadInt32(); return(new MessageHeader(userName, messageId, createTime, requestTime, isFragmented, firstFragment, lastFragment, offset, fullDataSize, (DataType)dataType)); }
public global::Common.Fix64 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { throw new InvalidOperationException("typecode is null, struct not supported"); } options.Security.DepthStep(ref reader); IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __RawValue__ = default(long); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __RawValue__ = reader.ReadInt64(); break; default: reader.Skip(); break; } } var ____result = new global::Common.Fix64(__RawValue__); ____result.RawValue = __RawValue__; reader.Depth--; return(____result); }
public Int64?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } return(reader.ReadInt64()); }
public global::Server.SharedThings.Packets.Representations.Character Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __Nickname__ = default(string); var __Authority__ = default(global::Server.SharedThings.Enums.AuthorityType); var __TimeOfCreation__ = default(global::System.DateTime); var __LastTimePlayed__ = default(global::System.DateTime); var __MapId__ = default(long); for (int i = 0; i < length; i++) { var key = i; switch (key) { case 0: __Nickname__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; case 1: __Authority__ = formatterResolver.GetFormatterWithVerify <global::Server.SharedThings.Enums.AuthorityType>().Deserialize(ref reader, options); break; case 2: __TimeOfCreation__ = formatterResolver.GetFormatterWithVerify <global::System.DateTime>().Deserialize(ref reader, options); break; case 3: __LastTimePlayed__ = formatterResolver.GetFormatterWithVerify <global::System.DateTime>().Deserialize(ref reader, options); break; case 4: __MapId__ = reader.ReadInt64(); break; default: reader.Skip(); break; } } var ____result = new global::Server.SharedThings.Packets.Representations.Character(); ____result.Nickname = __Nickname__; ____result.Authority = __Authority__; ____result.TimeOfCreation = __TimeOfCreation__; ____result.LastTimePlayed = __LastTimePlayed__; ____result.MapId = __MapId__; return(____result); }
public RequestId Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.NextMessagePackType == MessagePackType.Integer) { return(new RequestId(reader.ReadInt64())); } else { return(new RequestId(reader.ReadString())); } }
public DateTime Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.GetMessagePackType() == MessagePackType.Extension) { return(DateTimeFormatter.Instance.Deserialize(ref reader, formatterResolver)); } var dateData = reader.ReadInt64(); return(DateTime.FromBinary(dateData)); }
public DateTime Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.NextMessagePackType == MessagePackType.Integer) { var d = reader.ReadInt64(); return(d.ToDateTime()); } else { return(reader.ReadDateTime()); } }
internal override Channel.AcceptanceParameters DeserializeAcceptanceParameters(ReadOnlySequence <byte> payload) { var reader = new MessagePackReader(payload); int elementsCount = reader.ReadArrayHeader(); long?remoteWindowSize = null; if (elementsCount > 0) { remoteWindowSize = reader.ReadInt64(); } return(new Channel.AcceptanceParameters(remoteWindowSize)); }
public Int64[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } var len = reader.ReadArrayHeader(); var array = new Int64[len]; for (int i = 0; i < array.Length; i++) { array[i] = reader.ReadInt64(); } return(array); }
protected override VersionInfoContextInfo? DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options) { NuGetVersion? nuGetVersion = null; long? downloadCount = null; PackageDeprecationMetadataContextInfo? packageDeprecationMetadata = null; PackageSearchMetadataContextInfo? packageSearchMetadata = null; int propertyCount = reader.ReadMapHeader(); for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++) { switch (reader.ReadString()) { case NuGetVersionPropertyName: nuGetVersion = NuGetVersionFormatter.Instance.Deserialize(ref reader, options); break; case DownloadCountPropertyName: if (!reader.TryReadNil()) { downloadCount = reader.ReadInt64(); } break; case PackageDeprecationMetadataPropertyName: if (!reader.TryReadNil()) { packageDeprecationMetadata = PackageDeprecationMetadataContextInfoFormatter.Instance.Deserialize(ref reader, options); } break; case PackageSearchMetadataPropertyName: if (!reader.TryReadNil()) { packageSearchMetadata = PackageSearchMetadataContextInfoFormatter.Instance.Deserialize(ref reader, options); } break; default: reader.Skip(); break; } } Assumes.NotNull(nuGetVersion); return new VersionInfoContextInfo(nuGetVersion, downloadCount) { PackageSearchMetadata = packageSearchMetadata, PackageDeprecationMetadata = packageDeprecationMetadata, }; }
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 DateTime[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } var len = reader.ReadArrayHeader(); var array = new DateTime[len]; for (int i = 0; i < array.Length; i++) { var dateData = reader.ReadInt64(); array[i] = DateTime.FromBinary(dateData); } return(array); }
public QueryRequestData Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { int size = reader.ReadArrayHeader(); string select = reader.ReadString(); ConsistencyType consistency = (ConsistencyType)Enum.Parse(typeof(ConsistencyType), reader.ReadString(), true); long timeout = reader.ReadInt64(); int?querypagesize = null; int?querytype = null; if (size == 5) { querypagesize = reader.ReadInt32(); querytype = reader.ReadInt32(); } return(new QueryRequestData(select, consistency, timeout, querypagesize, (QueryType)querytype)); }
public TraceRecord Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { // Older trace records (N3 RC3 and before) did not have gas consumed value. // When parsing TraceRecords, if there are only two fields in the TraceRecord array, provide a dummy gasConsumed value. var fieldCount = reader.ReadArrayHeader(); if (fieldCount != 2 && fieldCount != 3) { throw new MessagePackSerializationException($"Invalid TraceRecord Array Header {fieldCount}"); } var state = options.Resolver.GetFormatterWithVerify <VMState>().Deserialize(ref reader, options); var gasConsumed = fieldCount == 3 ? reader.ReadInt64() : 0; var stackFrames = options.Resolver.GetFormatterWithVerify <IReadOnlyList <TraceRecord.StackFrame> >().Deserialize(ref reader, options); return(new TraceRecord(state, gasConsumed, stackFrames)); }
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);
public DateTime[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } else { var len = reader.ReadArrayHeader(); var array = new DateTime[len]; for (int i = 0; i < array.Length; i++) { var dateData = reader.ReadInt64(); array[i] = DateTime.FromBinary(dateData); } return(array); } }
internal override Channel.OfferParameters DeserializeOfferParameters(ReadOnlySequence <byte> payload) { var reader = new MessagePackReader(payload); int elementsCount = reader.ReadArrayHeader(); if (elementsCount == 0) { throw new MultiplexingProtocolException("Insufficient elements in offer parameter payload."); } string name = reader.ReadString(); long? remoteWindowSize = null; if (elementsCount > 1) { remoteWindowSize = reader.ReadInt64(); } return(new Channel.OfferParameters(name, remoteWindowSize)); }
private static 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(); // MessagePack ensures there are at least as many bytes in the message as declared by the byte header. // Consequently it is safe to do ToArray on the returned SequenceReader instance. return(bytes.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 void Int64Test(long 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); // bug of msgpack-cli if (target == 255) { packer.Pack((byte)255).Position.Is(sequence.Length); } else if (target == 50000) { packer.Pack((ushort)50000).Position.Is(sequence.Length); } else if (target == uint.MaxValue) { packer.Pack(uint.MaxValue).Position.Is(sequence.Length); } else { packer.Pack(target).Position.Is(sequence.Length); } //// stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue(); var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence); sequenceReader.ReadInt64().Is(target); sequenceReader.End.IsTrue(); this.CreateUnpackedReference(sequence).AsInt64().Is(target); }
public Period Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.IsNil) { return(null); } var count = reader.ReadArrayHeader(); if (count != 10) { throw new InvalidOperationException("Invalid array count"); } var years = reader.ReadInt32(); var months = reader.ReadInt32(); var weeks = reader.ReadInt32(); var days = reader.ReadInt32(); var hours = reader.ReadInt64(); var minutes = reader.ReadInt64(); var seconds = reader.ReadInt64(); var milliseconds = reader.ReadInt64(); var ticks = reader.ReadInt64(); var nano = reader.ReadInt64(); return(new PeriodBuilder() { Years = years, Months = months, Weeks = weeks, Days = days, Hours = hours, Minutes = minutes, Seconds = seconds, Milliseconds = milliseconds, Ticks = ticks, Nanoseconds = nano, } .Build()); }
public TimeSpan Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { return(new TimeSpan(reader.ReadInt64())); }
public LocalTime Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { var nanos = reader.ReadInt64(); return(LocalTime.Midnight.PlusNanoseconds(nanos)); }
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 DateTime Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { var dateData = reader.ReadInt64(); return(DateTime.FromBinary(dateData)); }
public DateTime Deserialize(ref MessagePackReader reader, IFormatterResolver resolver) { var dateData = reader.ReadInt64(); return(DateTime.FromBinary(dateData)); }
public TimeSpan Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { return(new TimeSpan(reader.ReadInt64())); }
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 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(); } }