Esempio n. 1
0
        /// <summary>
        /// Serializes a tag structure into a context.
        /// </summary>
        /// <param name="context">The serialization context to use.</param>
        /// <param name="tagStructure">The tag structure.</param>
        public void Serialize(ISerializationContext context, object tagStructure, uint? offset = null)
        {
            // Serialize the structure to a data block
            var info = new TagStructureInfo(tagStructure.GetType(), _version);
            context.BeginSerialize(info);
            var tagStream = new MemoryStream();
            var structBlock = context.CreateBlock();
            SerializeStruct(context, tagStream, structBlock, info, tagStructure);

            // Finalize the block and write all of the tag data out
            var mainStructOffset = offset.HasValue ? offset.Value : structBlock.Finalize(tagStream);
            var data = tagStream.ToArray();
            context.EndSerialize(info, data, mainStructOffset);
        }
Esempio n. 2
0
        /// <summary>
        /// Serializes a tag structure into a context.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="context">The serialization context to use.</param>
        /// <param name="tagStructure">The tag structure.</param>
        public static void Serialize <T>(ISerializationContext context, T tagStructure)
        {
            // Serialize the structure to a data block
            context.BeginSerialize();
            var tagStream   = new MemoryStream();
            var structBlock = context.CreateBlock();

            SerializeStruct(context, tagStream, structBlock, tagStructure);

            // Finalize the block and write all of the tag data out
            var mainStructOffset = structBlock.Finalize(tagStream);
            var data             = tagStream.ToArray();

            context.EndSerialize(data, mainStructOffset);
        }
Esempio n. 3
0
        /// <summary>
        /// Serializes a tag structure into a context.
        /// </summary>
        /// <param name="context">The serialization context to use.</param>
        /// <param name="tagStructure">The tag structure.</param>
        /// <param name="offset">An optional offset to begin serializing at.</param>
        public void Serialize(ISerializationContext context, object tagStructure, uint?offset = null)
        {
            // Serialize the structure to a data block
            var info = TagStructure.GetTagStructureInfo(tagStructure.GetType(), Version);

            context.BeginSerialize(info);
            var tagStream   = new MemoryStream();
            var structBlock = context.CreateBlock();

            SerializeStruct(context, tagStream, structBlock, info, tagStructure);

            // Finalize the block and write all of the tag data out
            var mainStructOffset = offset ?? structBlock.Finalize(tagStream);
            var data             = tagStream.ToArray();

            context.EndSerialize(info, data, mainStructOffset);
        }
Esempio n. 4
0
        /// <summary>
        /// Serializes a tag structure into a context.
        /// </summary>
        /// <param name="context">The serialization context to use.</param>
        /// <param name="tagStructure">The tag structure.</param>
        /// <param name="offset">An optional offset to begin serializing at.</param>
        public override void Serialize(ISerializationContext context, object tagStructure, uint?offset = null)
        {
            if (context.GetType() != typeof(ResourceDefinitionSerializationContext))
            {
                throw new Exception($"Invalid context type given resource deserialization");
            }

            var resourceContext = context as ResourceDefinitionSerializationContext;

            // Serialize the structure to a data block
            var info = TagStructure.GetTagStructureInfo(tagStructure.GetType(), Version);

            context.BeginSerialize(info);
            var tagStream   = new MemoryStream();
            var structBlock = (ResourceDefinitionSerializationContext.ResourceDefinitionDataBlock)context.CreateBlock();

            structBlock.BlockType     = resourceContext.InitialAddressType;
            structBlock.Writer.Format = Format;
            SerializeStruct(context, tagStream, structBlock, info, tagStructure);

            // Finalize the block and write all of the tag data out
            var mainStructOffset = offset ?? structBlock.Finalize(tagStream);

            var data = tagStream.ToArray();

            context.EndSerialize(info, data, mainStructOffset);
            var mainOffset = resourceContext.MainStructOffset.Offset;

            // move over the remaining fixups to the context
            foreach (var fixup in structBlock.FixupLocations)
            {
                fixup.BlockOffset += (uint)mainOffset;
                resourceContext.FixupLocations.Add(fixup);
            }

            foreach (var location in structBlock.InteropLocations)
            {
                location.Address = new CacheAddress(location.Address.Type, (int)(location.Address.Offset + mainOffset));
                resourceContext.InteropLocations.Add(location);
            }
        }