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);
}