示例#1
0
        protected void WriteAttributeData(BinaryStream stream, NomadValue attr, int baseOffset = 0)
        {
            var ptr = (int)stream.Position + baseOffset;

            var data = attr.Data;
            var type = data.Type;
            var size = data.Size;

            var buffer = data.Buffer;

            if (data.Type == DataType.RML)
            {
                throw new InvalidOperationException("Cannot serialize RML data directly!");
            }

            var oldSize = size;

            var attrData = (Format != FormatType.Resource)
                ? Utils.GetAttributeDataMiniBuffer(buffer, type)
                : Utils.GetAttributeDataBuffer(buffer, type);

            size = attrData.Length;

            var writeData = true;

            if (size > 4)
            {
                // return cached instance, else cache it and return empty
                var cache = WriteCache.PreCache(ptr, attrData, size);

                if (!cache.IsEmpty)
                {
                    // sizes must match
                    if (cache.Size == size)
                    {
                        var nD = DescriptorTag.CreateReference(cache.Offset, ReferenceType.Offset);
                        nD.WriteTo(stream, baseOffset);

                        writeData = false;
                    }
                }
            }

            if (writeData)
            {
                var nD = DescriptorTag.Create(size);
                nD.WriteTo(stream);

                stream.Write(attrData);
            }
        }
示例#2
0
        protected void WriteAttributesData_FmtB(BinaryStream stream, List <NomadValue> attributes, int baseOffset)
        {
            var ptr    = (int)stream.Position + baseOffset;
            var nAttrs = attributes.Count;

            if (nAttrs > 0)
            {
                var attrData = new byte[nAttrs * 4];

                using (var bs = new BinaryStream(attrData))
                {
                    foreach (var attr in attributes)
                    {
                        bs.Write(attr.Id.Hash);
                    }
                }

                var cache = WriteCache.PreCache(ptr, attrData, nAttrs);

                if (!cache.IsEmpty)
                {
                    var ndAttrs = DescriptorTag.CreateReference(cache.Offset, ReferenceType.Offset);
                    ndAttrs.WriteTo(stream, baseOffset);
                }
                else
                {
                    var count = DescriptorTag.Create(nAttrs);
                    count.WriteTo(stream);

                    stream.Write(attrData);
                }

                foreach (var attr in attributes)
                {
                    WriteAttribute_FmtB(stream, attr, baseOffset);
                }
            }
            else
            {
                // nothing to write
                stream.WriteByte(0);
            }
        }
示例#3
0
        private void WriteAttributeHashes(BinaryStream stream)
        {
            var ptr    = (int)stream.Position;
            var nAttrs = Attributes.Count;

            if (nAttrs > 0)
            {
                var attrHBuf = new byte[(nAttrs * 4) + 1];

                using (var buf = new BinaryStream(attrHBuf))
                {
                    buf.WriteByte(nAttrs);

                    foreach (var attr in Attributes)
                    {
                        attr.Serialize(buf, true);
                    }
                }

                if (WriteCache.IsCached(attrHBuf, nAttrs))
                {
                    var cache = WriteCache.GetData(attrHBuf, nAttrs);

                    var nhD = DescriptorTag.CreateReference(cache.Offset, ReferenceType.Offset);
                    nhD.WriteTo(stream);
                }
                else
                {
                    WriteCache.Cache(ptr, attrHBuf, nAttrs);
                    stream.Write(attrHBuf);
                }
            }
            else
            {
                // nothing to write
                stream.WriteByte(0);
            }
        }
示例#4
0
        public override void Serialize(BinaryStream stream)
        {
            Offset = (int)stream.Position;

            var nChildren   = Children.Count;
            var nAttributes = Attributes.Count;

            var writeData = true;

            if (Size > 16)
            {
                if (WriteCache.IsCached(this))
                {
                    var cache = WriteCache.GetData(this);
                    var obj   = cache.Object as NodeClass;

                    if ((obj != null) && obj.Equals(this))
                    {
                        Debug.WriteLine($">> [Class:{Offset:X8}] Instance cached @ {cache.Offset:X8} with key {cache.Checksum:X8}");

                        var nD = DescriptorTag.CreateReference(cache.Offset, ReferenceType.Offset);
                        nD.WriteTo(stream);

                        writeData = false;
                    }
                    else
                    {
                        Debug.WriteLine($">> [Class:{Offset:X8}] !!! FALSE POSITIVE !!!");
                    }
                }
                else
                {
                    Debug.WriteLine($">> [Class:{Offset:X8}] Caching new instance with key {GetHashCode():X8}");
                    WriteCache.Cache(Offset, this);
                }
            }

            if (writeData)
            {
                var nD = DescriptorTag.Create(nChildren);
                nD.WriteTo(stream);

                stream.Write(Hash);

                // skip size parameter for now
                stream.Position += 2;

                var attrsPtr = stream.Position;

                if (nAttributes > 0)
                {
                    WriteAttributeHashes(stream);

                    // write attribute data
                    foreach (var attribute in Attributes)
                    {
                        attribute.Serialize(stream);
                    }
                }
                else
                {
                    // no attributes to write!
                    stream.WriteByte(0);
                }

                var childrenPtr = stream.Position;
                var attrsSize   = (int)(childrenPtr - attrsPtr);

                if (attrsSize > 65535)
                {
                    throw new InvalidOperationException("Attribute data too large.");
                }

                // write attributes size
                stream.Position = (attrsPtr - 2);
                stream.Write((short)attrsSize);

                // now write the children out
                stream.Position = childrenPtr;

                foreach (var child in Children)
                {
                    child.Serialize(stream);
                }
            }
        }