Exemplo n.º 1
0
        /// <summary>
        /// Serializes all children of the given node.
        /// </summary>
        /// <param name="typeModel"></param>
        /// <param name="nodeBase"></param>
        /// <returns></returns>
        private Stream Serialize(RuntimeTypeModel typeModel, RTreeMemoryIndex <T> .Node nodeBase)
        {
            var stream = _streamCache.CreateNew();

            if (nodeBase.Children is List <RTreeMemoryIndex <T> .Node> )
            { // the node is not a leaf.
                long position      = 0;
                var  node          = (nodeBase as RTreeMemoryIndex <T> .Node);
                var  childrenIndex = new ChildrenIndex();
                childrenIndex.IsLeaf = new bool[nodeBase.Children.Count];
                childrenIndex.MinX   = new float[nodeBase.Children.Count];
                childrenIndex.MinY   = new float[nodeBase.Children.Count];
                childrenIndex.MaxX   = new float[nodeBase.Children.Count];
                childrenIndex.MaxY   = new float[nodeBase.Children.Count];
                childrenIndex.Starts = new int[nodeBase.Children.Count];
                var serializedChildren = new List <Stream>();
                for (int idx = 0; idx < nodeBase.Children.Count; idx++)
                {
                    var    child = (node.Children[idx] as RTreeMemoryIndex <T> .Node);
                    BoxF2D box   = node.Boxes[idx];
                    childrenIndex.MinX[idx]   = (float)box.Min[0];
                    childrenIndex.MinY[idx]   = (float)box.Min[1];
                    childrenIndex.MaxX[idx]   = (float)box.Max[0];
                    childrenIndex.MaxY[idx]   = (float)box.Max[1];
                    childrenIndex.IsLeaf[idx] = (
                        child.Children is List <T>);

                    Stream childSerialized = this.Serialize(typeModel, child);
                    serializedChildren.Add(childSerialized);

                    childrenIndex.Starts[idx] = (int)position;
                    position = position + childSerialized.Length;
                }
                childrenIndex.End = (int)position;

                // serialize this index object.
                var indexStream = new MemoryStream();
                typeModel.Serialize(indexStream, childrenIndex);
                byte[] indexBytes = indexStream.ToArray();

                // START WRITING THE DATA TO THE TARGET STREAM HERE!

                // 1: write the type of data.
                byte[] leafFlag = new[] { (byte)0 };
                stream.Write(leafFlag, 0, 1);

                // 2: Write the length of the meta data.
                byte[] indexLength = BitConverter.GetBytes(indexBytes.Length);
                stream.Write(indexLength, 0, indexLength.Length);

                // 3: write the meta data or the node-index.
                stream.Write(indexBytes, 0, indexBytes.Length);

                // 4: write the actual children.
                for (int idx = 0; idx < serializedChildren.Count; idx++)
                {
                    serializedChildren[idx].Seek(0, SeekOrigin.Begin);
                    serializedChildren[idx].CopyTo(stream);
                    _streamCache.Dispose(serializedChildren[idx]);
                    serializedChildren[idx] = null;
                }
            }
            else if (nodeBase.Children is List <T> )
            { // the node is a leaf node.
              // START WRITING THE DATA TO THE TARGET STREAM HERE!

                // 1: write the type of data.
                byte[] leafFlag = new[] { (byte)1 };
                stream.Write(leafFlag, 0, 1);

                // 2: write the leaf data.
                byte[] data = this.Serialize(typeModel,
                                             nodeBase.Children as List <T>,
                                             nodeBase.Boxes);
                stream.Write(data, 0, data.Length);
            }
            else
            {
                throw new Exception("Unknown node type!");
            }
            return(stream);
        }
Exemplo n.º 2
0
        private Stream Serialize(RuntimeTypeModel typeModel, RTreeMemoryIndex <T> .Node nodeBase)
        {
            Stream destination = this._streamCache.CreateNew();

            if (nodeBase.Children is List <RTreeMemoryIndex <T> .Node> )
            {
                long num = 0;
                RTreeMemoryIndex <T> .Node node = nodeBase;
                ChildrenIndex childrenIndex     = new ChildrenIndex();
                childrenIndex.IsLeaf = new bool[nodeBase.Children.Count];
                childrenIndex.MinX   = new float[nodeBase.Children.Count];
                childrenIndex.MinY   = new float[nodeBase.Children.Count];
                childrenIndex.MaxX   = new float[nodeBase.Children.Count];
                childrenIndex.MaxY   = new float[nodeBase.Children.Count];
                childrenIndex.Starts = new int[nodeBase.Children.Count];
                List <Stream> streamList = new List <Stream>();
                for (int index = 0; index < nodeBase.Children.Count; ++index)
                {
                    RTreeMemoryIndex <T> .Node child = node.Children[index] as RTreeMemoryIndex <T> .Node;
                    BoxF2D box = node.Boxes[index];
                    childrenIndex.MinX[index]   = (float)box.Min[0];
                    childrenIndex.MinY[index]   = (float)box.Min[1];
                    childrenIndex.MaxX[index]   = (float)box.Max[0];
                    childrenIndex.MaxY[index]   = (float)box.Max[1];
                    childrenIndex.IsLeaf[index] = child.Children is List <T>;
                    Stream stream = this.Serialize(typeModel, child);
                    streamList.Add(stream);
                    childrenIndex.Starts[index] = (int)num;
                    num += stream.Length;
                }
                childrenIndex.End = (int)num;
                MemoryStream memoryStream = new MemoryStream();
                ((TypeModel)typeModel).Serialize((Stream)memoryStream, (object)childrenIndex);
                byte[] array  = memoryStream.ToArray();
                byte[] buffer = new byte[1];
                destination.Write(buffer, 0, 1);
                byte[] bytes = BitConverter.GetBytes(array.Length);
                destination.Write(bytes, 0, bytes.Length);
                destination.Write(array, 0, array.Length);
                for (int index = 0; index < streamList.Count; ++index)
                {
                    streamList[index].Seek(0L, SeekOrigin.Begin);
                    streamList[index].CopyTo(destination);
                    this._streamCache.Dispose(streamList[index]);
                    streamList[index] = (Stream)null;
                }
            }
            else
            {
                if (!(nodeBase.Children is List <T>))
                {
                    throw new Exception("Unknown node type!");
                }
                byte[] buffer1 = new byte[1] {
                    (byte)1
                };
                destination.Write(buffer1, 0, 1);
                byte[] buffer2 = this.Serialize(typeModel, nodeBase.Children as List <T>, nodeBase.Boxes);
                destination.Write(buffer2, 0, buffer2.Length);
            }
            return(destination);
        }