public void TestSerialize() { OsmSharp.Math.Random.StaticRandomGenerator.Set(116542346); var box = new GeoCoordinateBox( new GeoCoordinate(90, 180), new GeoCoordinate(-90, -180)); var size = 5; var maxCollectionSize = 4; var referenceDictionary = new Dictionary <long, ICoordinateCollection>(); var coordinates = new HugeCoordinateCollectionIndex(100); for (int idx = 0; idx < size; idx++) { var currentSize = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(maxCollectionSize) + 1; var coordinatesArray = new GeoCoordinate[currentSize]; while (currentSize > 0) { coordinatesArray[currentSize - 1] = box.GenerateRandomIn(OsmSharp.Math.Random.StaticRandomGenerator.Get()); currentSize--; } var coordinatesCollection = new CoordinateArrayCollection <GeoCoordinate>(coordinatesArray); referenceDictionary[idx] = coordinatesCollection; coordinates[idx] = coordinatesCollection; } coordinates.Trim(); coordinates.Compress(); byte[] data = null; using (var stream = new MemoryStream()) { long length = coordinates.Serialize(stream); data = stream.ToArray(); Assert.AreEqual(168, length); Assert.AreEqual(data.Length, length); } var result = HugeCoordinateCollectionIndex.Deserialize(new MemoryStream(data)); // check result. for (int idx = 0; idx < size; idx++) { var referenceCollection = referenceDictionary[idx]; var collection = result[idx]; referenceCollection.Reset(); collection.Reset(); while (referenceCollection.MoveNext()) { Assert.IsTrue(collection.MoveNext()); Assert.AreEqual(referenceCollection.Latitude, collection.Latitude); Assert.AreEqual(referenceCollection.Longitude, collection.Longitude); } Assert.IsFalse(collection.MoveNext()); } result = HugeCoordinateCollectionIndex.Deserialize(new MemoryStream(data), true); // check result. for (int idx = 0; idx < size; idx++) { var referenceCollection = referenceDictionary[idx]; var collection = result[idx]; referenceCollection.Reset(); collection.Reset(); while (referenceCollection.MoveNext()) { Assert.IsTrue(collection.MoveNext()); Assert.AreEqual(referenceCollection.Latitude, collection.Latitude); Assert.AreEqual(referenceCollection.Longitude, collection.Longitude); } Assert.IsFalse(collection.MoveNext()); } }
/// <summary> /// Serializes this graph to disk. /// </summary> /// <param name="stream">The stream to write to. Writing will start at position 0.</param> /// <param name="edgeDataSize">The edge data size.</param> /// <param name="mapFrom">The map from for the edge data.</param> /// <param name="mapTo">The map to for the edge data.</param> public override long Serialize(System.IO.Stream stream, int edgeDataSize, MappedHugeArray <TEdgeData, uint> .MapFrom mapFrom, MappedHugeArray <TEdgeData, uint> .MapTo mapTo) { long vertexCount = (_nextVertexId - 1); long edgeCount = (_nextEdgeId / EDGE_SIZE); // write vertex and edge count. long position = 0; stream.Write(BitConverter.GetBytes((int)1), 0, 4); position = position + 4; stream.Write(BitConverter.GetBytes(vertexCount), 0, 8); // write exact number of vertices. position = position + 8; stream.Write(BitConverter.GetBytes(edgeCount), 0, 8); // write exact number of edges. position = position + 8; // write in this order: vertices, vertexCoordinates, edges, edgeData, edgeShapes. using (var file = new MemoryMappedStream(new OsmSharp.IO.LimitedStream(stream))) { // write vertices (each vertex = 1 uint (4 bytes)). var vertexArray = new MemoryMappedHugeArrayUInt32(file, (vertexCount + 1) * VERTEX_SIZE, (vertexCount + 1) * VERTEX_SIZE, 1024); vertexArray.CopyFrom(_vertices, 0, 0, (vertexCount + 1) * VERTEX_SIZE); vertexArray.Dispose(); // written, get rid of it! position = position + ((vertexCount + 1) * VERTEX_SIZE * 4); // write vertex coordinates (each vertex coordinate = 2 floats (8 bytes)). var vertexCoordinateArray = new MappedHugeArray <GeoCoordinateSimple, float>( new MemoryMappedHugeArraySingle(file, (vertexCount + 1) * 2, (vertexCount + 1) * 2, 1024), 2, (array, idx, coordinate) => { array[idx] = coordinate.Latitude; array[idx + 1] = coordinate.Longitude; }, (Array, idx) => { return(new GeoCoordinateSimple() { Latitude = Array[idx], Longitude = Array[idx + 1] }); }); vertexCoordinateArray.CopyFrom(_coordinates, 0, 0, (vertexCount + 1)); vertexCoordinateArray.Dispose(); // written, get rid of it! position = position + ((vertexCount + 1) * 2 * 4); // write edges (each edge = 4 uints (16 bytes)). var edgeArray = new MemoryMappedHugeArrayUInt32(file, edgeCount * EDGE_SIZE, edgeCount * EDGE_SIZE, 1024); edgeArray.CopyFrom(_edges, edgeCount * EDGE_SIZE); edgeArray.Dispose(); // written, get rid of it! position = position + (edgeCount * EDGE_SIZE * 4); // write edge data (each edgeData = edgeDataSize units (edgeDataSize * 4 bytes)). var edgeDataArray = new MappedHugeArray <TEdgeData, uint>( new MemoryMappedHugeArrayUInt32(file, edgeCount * edgeDataSize, edgeCount * edgeDataSize, 1024), edgeDataSize, mapTo, mapFrom); edgeDataArray.CopyFrom(_edgeData, edgeCount); edgeDataArray.Dispose(); // written, get rid of it! position = position + (edgeCount * edgeDataSize * 4); } // write shapes. stream.Seek(position, System.IO.SeekOrigin.Begin); position = position + _edgeShapes.Serialize(new OsmSharp.IO.LimitedStream(stream)); return(position); }