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.");
}
}
