public void Ctor_SByte_UInt() { var eh = new ExtensionHeader(1, 2u); Assert.Equal(1, eh.TypeCode); Assert.Equal(2u, eh.Length); }
public static TerrainTile Parse(Stream tileStream) { var terrainTile = new TerrainTile(); using (var reader = new BinaryReader(tileStream)) { terrainTile.Header = new TerrainTileHeader(reader); terrainTile.VertexData = new VertexData(reader); terrainTile.IndexData16 = new IndexData16(reader); terrainTile.EdgeIndices16 = new EdgeIndices16(reader); // do not read extentions right now... while (reader.BaseStream.Position != reader.BaseStream.Length) { var extensionHeader = new ExtensionHeader(reader); // extensionid 1: per vertex lighting attributes if (extensionHeader.extensionId == 1) { // oct-encoded per vertex normals // todo: terrainTile.NormalExtensionData = new NormalExtensionData(reader, extensionHeader.extensionLength); //quantizedMeshTile.NormalExtensionData = new NormalExtensionData(reader, quantizedMeshTile.VertexData.vertexCount); } else if (extensionHeader.extensionId == 2) { // todo extensionid 2: per vertex watermark } } } return(terrainTile); }
public void Equality() { var eh1 = new ExtensionHeader(1, 2); var eh2 = new ExtensionHeader(2, 2); var eh3 = new ExtensionHeader(1, 1); Assert.True(eh1.Equals(eh1)); Assert.False(eh1.Equals(eh2)); Assert.False(eh1.Equals(eh3)); Assert.False(eh2.Equals(eh3)); }
public void CompressionData() { var originalData = Enumerable.Range(1, 1000).Select(x => x).ToArray(); var lz4Data = MessagePackSerializer.Serialize(originalData, MessagePackSerializerOptions.LZ4Standard); PeekMessagePackType(lz4Data).Is(MessagePackType.Extension); var lz4DataReader = new MessagePackReader(lz4Data); ExtensionHeader header = lz4DataReader.ReadExtensionFormatHeader(); header.TypeCode.Is(MessagePackSerializer.LZ4ExtensionTypeCode); var decompress = MessagePackSerializer.Deserialize <int[]>(lz4Data, MessagePackSerializerOptions.LZ4Standard); decompress.Is(originalData); }
public void TryReadExtensionFormatHeader() { var sequence = new Sequence <byte>(); var writer = new MessagePackWriter(sequence); var expectedExtensionHeader = new ExtensionHeader(4, 100); writer.WriteExtensionFormatHeader(expectedExtensionHeader); writer.Flush(); var reader = new MessagePackReader(sequence.AsReadOnlySequence.Slice(0, sequence.Length - 1)); Assert.False(reader.TryReadExtensionFormatHeader(out _)); reader = new MessagePackReader(sequence); Assert.True(reader.TryReadExtensionFormatHeader(out ExtensionHeader actualExtensionHeader)); Assert.Equal(expectedExtensionHeader, actualExtensionHeader); }
public void WriteExtensionFormatHeader_NegativeExtension() { var sequence = new Sequence <byte>(); var writer = new MessagePackWriter(sequence); var header = new ExtensionHeader(-1, 10); writer.WriteExtensionFormatHeader(header); writer.Flush(); var written = sequence.AsReadOnlySequence; var reader = new MessagePackReader(written); var readHeader = reader.ReadExtensionFormatHeader(); Assert.Equal(header.TypeCode, readHeader.TypeCode); Assert.Equal(header.Length, readHeader.Length); }
public void NonGenericAPI() { FirstSimpleData[] originalData = Enumerable.Range(1, 100).Select(x => new FirstSimpleData { Prop1 = x * x, Prop2 = "hoge", Prop3 = x }).ToArray(); var lz4Data = MessagePackSerializer.Serialize(typeof(FirstSimpleData[]), originalData, MessagePackSerializerOptions.LZ4Standard); PeekMessagePackType(lz4Data).Is(MessagePackType.Extension); var lz4DataReader = new MessagePackReader(lz4Data); ExtensionHeader header = lz4DataReader.ReadExtensionFormatHeader(); header.TypeCode.Is(MessagePackSerializer.LZ4ExtensionTypeCode); var decompress = MessagePackSerializer.Deserialize(typeof(FirstSimpleData[]), lz4Data, MessagePackSerializerOptions.LZ4Standard); decompress.IsStructuralEqual(originalData); }
public object Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } if (reader.NextMessagePackType == MessagePackType.Extension) { MessagePackReader peekReader = reader.CreatePeekReader(); ExtensionHeader ext = peekReader.ReadExtensionFormatHeader(); if (ext.TypeCode == ThisLibraryExtensionTypeCodes.TypelessFormatter) { reader = peekReader; // commit the experimental read made earlier. // it has type name serialized ReadOnlySequence <byte> typeName = reader.ReadStringSequence().Value; ArraySegment <byte> typeNameArraySegment; byte[] rented = null; if (!typeName.IsSingleSegment || !MemoryMarshal.TryGetArray(typeName.First, out typeNameArraySegment)) { rented = ArrayPool <byte> .Shared.Rent((int)typeName.Length); typeName.CopyTo(rented); typeNameArraySegment = new ArraySegment <byte>(rented, 0, (int)typeName.Length); } var result = this.DeserializeByTypeName(typeNameArraySegment, ref reader, options); if (rented != null) { ArrayPool <byte> .Shared.Return(rented); } return(result); } } // fallback return(DynamicObjectTypeFallbackFormatter.Instance.Deserialize(ref reader, options)); }
public object Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } if (reader.NextMessagePackType == MessagePackType.Extension) { ExtensionHeader ext = reader.ReadExtensionFormatHeader(); if (ext.TypeCode == TypelessFormatter.ExtensionTypeCode) { // it has type name serialized ReadOnlySequence <byte> typeName = reader.ReadStringSegment(); ArraySegment <byte> typeNameArraySegment; byte[] rented = null; if (!typeName.IsSingleSegment || !MemoryMarshal.TryGetArray(typeName.First, out typeNameArraySegment)) { rented = ArrayPool <byte> .Shared.Rent((int)typeName.Length); typeName.CopyTo(rented); typeNameArraySegment = new ArraySegment <byte>(rented, 0, (int)typeName.Length); } var result = this.DeserializeByTypeName(typeNameArraySegment, ref reader, options); if (rented != null) { ArrayPool <byte> .Shared.Return(rented); } return(result); } } // fallback return(Resolvers.TypelessFormatterFallbackResolver.Instance.GetFormatter <object>().Deserialize(ref reader, options)); }
public T[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } ExtensionHeader header = reader.ReadExtensionFormatHeader(); if (header.TypeCode != this.TypeCode) { throw new InvalidOperationException("Invalid typeCode."); } var byteLength = reader.ReadInt32(); var isLittleEndian = reader.ReadBoolean(); // Allocate a T[] that we will return. We'll then cast the T[] as byte[] so we can copy the byte sequence directly into it. var result = new T[byteLength / Marshal.SizeOf <T>()]; Span <byte> resultAsBytes = MemoryMarshal.Cast <T, byte>(result); reader.ReadRaw(byteLength).CopyTo(resultAsBytes); // Reverse the byte order if necessary. if (isLittleEndian != BitConverter.IsLittleEndian) { for (int i = 0, j = resultAsBytes.Length - 1; i < j; i++, j--) { byte tmp = resultAsBytes[i]; resultAsBytes[i] = resultAsBytes[j]; resultAsBytes[j] = tmp; } } return(result); }
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."); } }
private void ReadType(MessagePackType type) { int readSize = 0; switch (type) { case MessagePackType.Float: { double d; if (MessagePackCode.Float32 == PeekByte()) { d = MessagePackBinary.ReadSingle(mStream); } else { d = MessagePackBinary.ReadDouble(mStream); } if (FloatParseHandling == FloatParseHandling.Decimal) { SetToken(JsonToken.Float, Convert.ToDecimal(d, CultureInfo.InvariantCulture)); } else { SetToken(JsonToken.Float, d); } break; } case MessagePackType.String: { string str = MessagePackBinary.ReadString(mStream); SetToken(JsonToken.String, str); break; } case MessagePackType.Map: { SetToken(JsonToken.StartObject); ContainerContext newContext = new ContainerContext(MessagePackType.Map); PushContext(newContext); newContext.Length = MessagePackBinary.ReadMapHeader(mStream); break; } case MessagePackType.Array: { SetToken(JsonToken.StartArray); ContainerContext newContext = new ContainerContext(MessagePackType.Array); PushContext(newContext); newContext.Length = MessagePackBinary.ReadArrayHeader(mStream); break; } case MessagePackType.Binary: byte[] data = MessagePackBinary.ReadBytes(mStream); SetToken(JsonToken.Bytes, data); break; case MessagePackType.Unknown: SetToken(JsonToken.Undefined); break; case MessagePackType.Boolean: bool b = MessagePackBinary.ReadBoolean(mStream); SetToken(JsonToken.Boolean, b); break; case MessagePackType.Extension: long streamPosition = mStream.Position; ExtensionHeader ext = MessagePackBinary.ReadExtensionFormatHeader(mStream); mStream.Position = streamPosition; if (ext.TypeCode != ReservedMessagePackExtensionTypeCode.DateTime) { throw new InvalidOperationException("Invalid primitive bytes."); } DateTime dateTime = MessagePackBinary.ReadDateTime(mStream); SetToken(JsonToken.Date, dateTime); break; case MessagePackType.Nil: MessagePackBinary.ReadNil(mStream); SetToken(JsonToken.Null); break; case MessagePackType.Integer: object integer = ReadInteger(); SetToken(JsonToken.Integer, integer); break; default: throw new ArgumentOutOfRangeException(nameof(type), "Unexpected MessagePackType value: " + 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 InvalidOperationException("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: return(reader.ReadBytes()); case MessagePackType.Extension: ExtensionHeader 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(); IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>(); var array = new object[length]; for (int i = 0; i < length; i++) { array[i] = objectFormatter.Deserialize(ref reader, options); } return(array); } case MessagePackType.Map: { var length = reader.ReadMapHeader(); IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>(); var hash = new Dictionary <object, object>(length); 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); } return(hash); } case MessagePackType.Nil: reader.ReadNil(); return(null); default: throw new InvalidOperationException("Invalid primitive bytes."); } }