/// <summary> /// Imports collection by reading its data from a <see cref="BinaryReader"/> provided. /// </summary> /// <param name="type"><see cref="SerializeType"/> type of importing collection.</param> /// <param name="br"><see cref="BinaryReader"/> to read data with.</param> public override void Import(SerializeType type, BinaryReader br) { var position = br.BaseStream.Position; var header = new SerializationHeader(); header.Read(br); if (header.ID != BinBlockID.Nikki) { throw new Exception($"Missing serialized header in the imported collection"); } if (header.Game != this.GameINT) { throw new Exception($"Stated game inside collection is {header.Game}, while should be {this.GameINT}"); } var manager = this.GetManager(header.Name); if (manager == null) { throw new Exception($"Cannot find manager named {header.Name}"); } br.BaseStream.Position = position; manager.Import(type, br); }
/// <summary> /// Serializes instance into a byte array and stores it in the file provided. /// </summary> /// <param name="bw"><see cref="BinaryWriter"/> to write data with.</param> public override void Serialize(BinaryWriter bw) { byte[] array; var size = this._data.Length + (this.FEngColorCount << 3) + this.CollectionName.Length + 0x20; using (var ms = new MemoryStream(size)) using (var writer = new BinaryWriter(ms)) { writer.WriteNullTermUTF8(this.CollectionName); writer.Write(this.FEngColorCount); foreach (var color in this._colorinfo) { writer.Write(color.Offset); writer.Write(color.Alpha); writer.Write(color.Red); writer.Write(color.Green); writer.Write(color.Blue); } writer.Write(this._data.Length); writer.Write(this._data); array = ms.ToArray(); } array = Interop.Compress(array, LZCompressionType.RAWW); var header = new SerializationHeader(array.Length, this.GameINT, this.Manager.Name); header.Write(bw); bw.Write(array.Length); bw.Write(array); }
/// <summary> /// Imports collection from file provided and attempts to add it to the end of /// this <see cref="Manager{T}"/> in case it does not exist. /// </summary> /// <param name="type">Type of serialization of a collection.</param> /// <param name="br"><see cref="BinaryReader"/> to read data with.</param> public override void Import(SerializeType type, BinaryReader br) { var position = br.BaseStream.Position; var header = new SerializationHeader(); header.Read(br); var collection = new FNGroup(); if (header.ID != BinBlockID.Nikki) { br.BaseStream.Position = position; collection.Disassemble(br); } else { if (header.Game != this.GameINT) { throw new Exception($"Stated game inside collection is {header.Game}, while should be {this.GameINT}"); } if (header.Name != this.Name) { throw new Exception($"Imported collection is not a collection of type {this.Name}"); } collection.Deserialize(br); } var index = this.IndexOf(collection); if (index == -1) { // Allow import of FNGroups because it is safe this._is_read_only = false; ++this.Capacity; collection.Manager = this; this.Add(collection); this._is_read_only = true; } else { switch (type) { case SerializeType.Negate: break; case SerializeType.Synchronize: case SerializeType.Override: collection.Manager = this; this.Replace(collection, index); break; default: break; } } }
/// <summary> /// Imports collection from file provided and attempts to add it to the end of /// this <see cref="Manager{T}"/> in case it does not exist. /// </summary> /// <param name="type">Type of serialization of a collection.</param> /// <param name="br"><see cref="BinaryReader"/> to read data with.</param> public override void Import(SerializeType type, BinaryReader br) { var position = br.BaseStream.Position; var header = new SerializationHeader(); header.Read(br); var collection = new DBModelPart(); if (header.ID != BinBlockID.Nikki) { throw new Exception($"Missing serialized header in the imported collection"); } else { if (header.Game != this.GameINT) { throw new Exception($"Stated game inside collection is {header.Game}, while should be {this.GameINT}"); } if (header.Name != this.Name) { throw new Exception($"Imported collection is not a collection of type {this.Name}"); } collection.Deserialize(br); } var index = this.IndexOf(collection); if (index == -1) { collection.Manager = this; this.Add(collection); } else { switch (type) { case SerializeType.Negate: break; case SerializeType.Override: collection.Manager = this; this.Replace(collection, index); break; case SerializeType.Synchronize: this[index].Synchronize(collection); break; default: break; } } }
public void FromToBytes() { // Arrange var version = new ProtocolVersion(1, 0); var name = "Something"; // Act var header = new SerializationHeader(version, name); var bytes = header.ToBytes(); var header2 = SerializationHeader.FromBytes(bytes); // Assert Assert.That(header2.Protocol, Is.EqualTo(version)); Assert.That(header2.InvariantName, Is.EqualTo(name)); }
/// <summary> /// Extracts a response from the <see cref="NetMQMessage"/> /// </summary> /// <param name="message"><see cref="NetMQMessage"/> wrapping a response object</param> /// <returns>Request identifier, response object contained within the <see cref="NetMQMessage"/></returns> public (int requestId, object response) ExtractResponse(NetMQMessage message) { var requestId = message[1].ConvertToInt32(); var data = message[3].ToByteArray(); var header = SerializationHeader.FromBytes(data); if (!serializerCache.SerializerFor(header.InvariantName, out var serializer)) { throw new MissingSerializerException(header.InvariantName); } var package = serializer.Deserialize <Package>(data, header.EncodedLength); var response = packageFactory.Unpack(package); return(requestId, response); }
/// <summary> /// Creates a <see cref="NetMQMessage"/> wrapping a request object /// </summary> /// <param name="request">Request object to be wrapped in a <see cref="NetMQMessage"/></param> /// <param name="requestId">An <see cref="int"/> identifier for matching asynchronous requests and responses</param> /// <returns><see cref="NetMQMessage"/> wrapping the request object</returns> public NetMQMessage CreateRequestMessage(object request, int requestId) { var serializer = serializerCache.DefaultSerializer; var package = packageFactory.Pack(request); var header = new SerializationHeader(new ProtocolVersion(1, 0), serializer.Descriptor.InvariantName); var data = serializer.Serialize(package, header.EncodedLength); header.ToBytes(data); var message = new NetMQMessage(4); message.AppendEmptyFrame(); message.Append(requestId); message.AppendEmptyFrame(); message.Append(data); return(message); }
/// <summary> /// Extracts a request from the <see cref="NetMQMessage"/> /// </summary> /// <param name="message"><see cref="NetMQMessage"/> wrapping a request object</param> /// <returns>Request object contained within the <see cref="NetMQMessage"/>, address of remote sender, and request identifier</returns> public (object request, byte[] address, int requestId, string serializationName) ExtractRequest(NetMQMessage message) { var address = message[0].ToByteArray(); var requestId = message[2].ConvertToInt32(); var data = message[4].ToByteArray(); var header = SerializationHeader.FromBytes(data); if (!serializerCache.SerializerFor(header.InvariantName, out var serializer)) { throw new MissingSerializerException(header.InvariantName); } var package = serializer.Deserialize <Package>(data, header.EncodedLength); var request = packageFactory.Unpack(package); return(request, address, requestId, header.InvariantName); }
/// <summary> /// Creates a <see cref="NetMQMessage"/> wrapping a response object /// </summary> /// <param name="response">Response object to be wrapped in a <see cref="NetMQMessage"/></param> /// <param name="address">Address of the remote</param> /// <param name="requestId">An <see cref="int"/> identifier for matching asynchronous requests and responses</param> /// <param name="serializerName"><see cref="SerializationDescriptor"/> of the <see cref="ISerializer"/> to use</param> /// <returns><see cref="NetMQMessage"/> wrapping the response object</returns> public NetMQMessage CreateResponseMessage(object response, byte[] address, int requestId, string serializerName) { if (!serializerCache.SerializerFor(serializerName, out var serializer)) { throw new MissingSerializerException(serializerName); } var package = packageFactory.Pack(response); var header = new SerializationHeader(new ProtocolVersion(1, 0), serializerName); var data = serializer.Serialize(package, header.EncodedLength); header.ToBytes(data); var message = new NetMQMessage(5); message.Append(address); message.AppendEmptyFrame(); message.Append(requestId); message.AppendEmptyFrame(); message.Append(data); return(message); }
/// <summary> /// Imports collection from file provided and attempts to add it to the end of /// this <see cref="Manager{T}"/> in case it does not exist. /// </summary> /// <param name="type">Type of serialization of a collection.</param> /// <param name="br"><see cref="BinaryReader"/> to read data with.</param> public override void Import(SerializeType type, BinaryReader br) { var position = br.BaseStream.Position; var header = new SerializationHeader(); header.Read(br); var collection = new TPKBlock(); if (header.ID != BinBlockID.Nikki) { br.BaseStream.Position = position; while (br.BaseStream.Position < br.BaseStream.Length) { var offset = br.BaseStream.Position; var id = br.ReadEnum <BinBlockID>(); var size = br.ReadInt32(); br.BaseStream.Position = offset; if (id == BinBlockID.EmitterTexturePage) { collection.ReadTexturePages(br); } if (id == BinBlockID.TPKBlocks) { collection.Disassemble(br); break; } br.BaseStream.Position = offset + size + 8; } } else { if (header.Game != this.GameINT) { throw new Exception($"Stated game inside collection is {header.Game}, while should be {this.GameINT}"); } if (header.Name != this.Name) { throw new Exception($"Imported collection is not a collection of type {this.Name}"); } collection.Deserialize(br); } var index = this.IndexOf(collection); if (index == -1) { collection.Manager = this; this.Add(collection); } else { switch (type) { case SerializeType.Negate: break; case SerializeType.Override: collection.Manager = this; this.Replace(collection, index); break; case SerializeType.Synchronize: this[index].Synchronize(collection); break; default: break; } } }