< Summary

Class:	Itinero.Network.Tiles.NetworkTile
Assembly:	Itinero
File(s):	/home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.Attributes.cs /home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.cs /home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.Geo.cs /home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.Serialization.cs /home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.TurnCosts.cs
Covered lines:	816
Uncovered lines:	114
Coverable lines:	930
Total lines:	1472
Line coverage:	87.7% (816 of 930)
Covered branches:	230
Total branches:	278
Branch coverage:	82.7% (230 of 278)
Tag:	224_14471318300

Metrics

Method	Branch coverage	Cyclomatic complexity	Line coverage
.ctor(...)	100%	1	100%
SetAttributes(...)	87.5%	8	81.25%
GetAttributes()	100%	6	100%
AddOrGetString(...)	100%	6	100%
WriteAttributesTo(...)	100%	4	100%
ReadAttributesFrom(...)	100%	4	100%
.ctor(...)	100%	2	100%
.ctor(...)	100%	1	100%
Clone()	100%	1	100%
get_TileId()	100%	1	100%
get_VertexCount()	100%	1	100%
get_EdgeTypeMapId()	100%	1	100%
AddVertex(...)	100%	1	100%
HasVertex(...)	100%	2	100%
TryGetVertex(...)	100%	2	100%
AddEdge(...)	81.81%	22	91.42%
DeleteEdge(...)	100%	2	100%
IsEdgeDeleted(...)	100%	2	100%
get_HasDeletedEdges()	100%	1	100%
RemoveDeletedEdges()	83.33%	24	88.73%
CloneForEdgeTypeMap(...)	66.66%	12	83.07%
VertexEdgePointer(...)	100%	1	100%
EncodeVertex(...)	100%	6	100%
DecodeVertex(...)	100%	2	100%
DecodeEdgeCrossId(...)	100%	1	100%
GetEdgeCrossPointer(...)	100%	1	100%
EncodePointer(...)	100%	2	100%
DecodePointer(...)	100%	1	100%
SetDynamicUIn32Nullable(...)	50%	2	57.14%
GetTailHeadOrder(...)	100%	1	100%
DecodeEdgePointerId(...)	100%	1	100%
WriteEdgesAndVerticesTo(...)	83.33%	6	82.35%
ReadEdgesAndVerticesFrom(...)	83.33%	6	85%
.ctor(...)	100%	1	100%
SetCoordinate(...)	77.77%	18	76.31%
GetCoordinate(...)	100%	4	100%
SetShape(...)	93.75%	16	96.77%
GetShape()	86.36%	22	91.83%
WriteGeoTo(...)	100%	6	100%
ReadGeoFrom(...)	100%	6	100%
WriteTo(...)	100%	1	100%
ReadFrom(...)	50%	2	86.66%
.ctor(...)	100%	1	100%
AddTurnCosts(...)	82.5%	40	81.44%
GetTurnCosts()	68.18%	22	63.79%
SetTailHeadOrder(...)	64.28%	14	82.85%
WriteTurnCostsTo(...)	50%	4	50%
ReadTurnCostsFrom(...)	50%	4	57.14%

File(s)

/home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.Attributes.cs

	#	Line		Line coverage
		1		using System.Collections.Generic;
		2		using System.IO;
		3		using Itinero.Data;
		4		using Itinero.IO;
		5		using Itinero.Network.Storage;
		6		using Reminiscence.Arrays;
		7
		8		namespace Itinero.Network.Tiles;
		9
		10		internal partial class NetworkTile
		11		{
		12		/// <summary>
		13		/// Stores the attributes, starting with the number of attributes and then alternating key-value pairs.
		14		/// </summary>
		15		private readonly ArrayBase<byte> _attributes;
		16
	210	17		private uint _nextAttributePointer = 0;
		18
		19		/// <summary>
		20		/// Stores each string once.
		21		/// </summary>
		22		private readonly ArrayBase<string> _strings;
		23
	210	24		private uint _nextStringId = 0;
		25
		26		private uint SetAttributes(IEnumerable<(string key, string value)> attributes)
	126	27		{
	126	28		var start = _nextAttributePointer;
		29
	126	30		long cPos = start;
	126	31		long p = start + 1;
	126	32		var c = 0;
	528	33		foreach (var (key, value) in attributes)
	75	34		{
	75	35		if (_attributes.Length <= p + 16)
	38	36		{
	38	37		_attributes.Resize(_attributes.Length + 256);
	38	38		}
		39
	75	40		var id = this.AddOrGetString(key);
	75	41		p += _attributes.SetDynamicUInt32(p, id);
	75	42		id = this.AddOrGetString(value);
	75	43		p += _attributes.SetDynamicUInt32(p, id);
		44
	75	45		c++;
	75	46		if (c == 255)
	0	47		{
	0	48		_attributes[cPos] = 255;
	0	49		c = 0;
	0	50		cPos = p;
	0	51		p++;
	0	52		}
	75	53		}
		54
	126	55		if (_attributes.Length <= cPos)
	51	56		{
	51	57		_attributes.Resize(_attributes.Length + 256);
	51	58		}
		59
	126	60		_attributes[cPos] = (byte)c;
		61
	126	62		_nextAttributePointer = (uint)p;
		63
	126	64		return start;
	126	65		}
		66
		67		internal IEnumerable<(string key, string value)> GetAttributes(uint? pointer)
	117	68		{
	117	69		if (pointer == null)
	44	70		{
	44	71		yield break;
		72		}
		73
	73	74		var p = pointer.Value;
		75
	73	76		var count = -1;
		77		do
	73	78		{
	73	79		count = _attributes[p];
	73	80		p++;
		81
	246	82		for (var i = 0; i < count; i++)
	79	83		{
	79	84		p += (uint)_attributes.GetDynamicUInt32(p, out var keyId);
	79	85		p += (uint)_attributes.GetDynamicUInt32(p, out var valId);
		86
	79	87		yield return (_strings[keyId], _strings[valId]);
	50	88		}
	88	89		} while (count == 255);
	44	90		}
		91
		92		private uint AddOrGetString(string s)
	150	93		{
	696	94		for (uint i = 0; i < _nextStringId; i++)
	226	95		{
	226	96		var existing = _strings[i];
	226	97		if (existing == s)
	28	98		{
	28	99		return i;
		100		}
	198	101		}
		102
	122	103		if (_strings.Length <= _nextStringId)
	38	104		{
	38	105		_strings.Resize(_strings.Length + 256);
	38	106		}
		107
	122	108		var id = _nextStringId;
	122	109		_nextStringId++;
		110
	122	111		_strings[id] = s;
	122	112		return id;
	150	113		}
		114
		115		private void WriteAttributesTo(Stream stream)
	8	116		{
	8	117		stream.WriteVarUInt32(_nextAttributePointer);
	40	118		for (var i = 0; i < _nextAttributePointer; i++)
	12	119		{
	12	120		stream.WriteByte(_attributes[i]);
	12	121		}
		122
	8	123		stream.WriteVarUInt32(_nextStringId);
	36	124		for (var i = 0; i < _nextStringId; i++)
	10	125		{
	10	126		stream.WriteWithSize(_strings[i]);
	10	127		}
	8	128		}
		129
		130		private void ReadAttributesFrom(Stream stream)
	8	131		{
	8	132		_nextAttributePointer = stream.ReadVarUInt32();
	8	133		_attributes.Resize(_nextAttributePointer);
	40	134		for (var i = 0; i < _nextAttributePointer; i++)
	12	135		{
	12	136		_attributes[i] = (byte)stream.ReadByte();
	12	137		}
		138
	8	139		_nextStringId = stream.ReadVarUInt32();
	8	140		_strings.Resize(_nextStringId);
	36	141		for (var i = 0; i < _nextStringId; i++)
	10	142		{
	10	143		_strings[i] = stream.ReadWithSizeString();
	10	144		}
	8	145		}
		146		}

/home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections.Generic;
		3		using System.IO;
		4		using Itinero.IO;
		5		using Itinero.Network.Storage;
		6		using Itinero.Network.TurnCosts;
		7		using Reminiscence.Arrays;
		8
		9		namespace Itinero.Network.Tiles;
		10
		11		internal partial class NetworkTile
		12		{
		13		private const int DefaultSizeIncrease = 16;
		14
		15		private readonly uint _tileId;
		16		private readonly int _zoom; // the zoom level.
		17		private readonly Guid _edgeTypeMapId; // the edge type index id.
		18
	210	19		private uint _nextVertexId = 0; // the next vertex id.
		20
		21		// the pointers, per vertex, to their first edge.
		22		// TODO: investigate if it's worth storing these with less precision, one tile will never contain this much data.
		23		// TODO: investigate if we can not use one-increasing vertex ids but also use their pointers like with the edges.
		24		private readonly ArrayBase<uint> _pointers;
		25		private uint _nextCrossTileId; // the next id for an edge that crosses tile boundaries.
		26		private readonly ArrayBase<uint> _crossEdgePointers; // points to the cross tile boundary edges.
		27
		28		// the next edge id.
	210	29		private uint _nextEdgeId = 0;
		30
		31		// the edges.
		32		private readonly ArrayBase<byte> _edges;
		33
		34		/// <summary>
		35		/// Creates a new tile.
		36		/// </summary>
		37		/// <param name="zoom">The zoom level.</param>
		38		/// <param name="tileId">The tile id.</param>
		39		/// <param name="edgeTypeMapId">The edge type index id.</param>
	194	40		public NetworkTile(int zoom, uint tileId, Guid? edgeTypeMapId = null)
	194	41		{
	194	42		_zoom = zoom;
	194	43		_tileId = tileId;
	194	44		_edgeTypeMapId = edgeTypeMapId ?? Guid.Empty;
	194	45		_nextCrossTileId = 0;
		46
	194	47		_pointers = new MemoryArray<uint>(0);
	194	48		_edges = new MemoryArray<byte>(0);
	194	49		_crossEdgePointers = new MemoryArray<uint>(0);
		50
	194	51		_coordinates = new MemoryArray<byte>(0);
	194	52		_shapes = new MemoryArray<byte>(0);
	194	53		_attributes = new MemoryArray<byte>(0);
	194	54		_strings = new MemoryArray<string>(0);
	194	55		}
		56
	16	57		private NetworkTile(int zoom, uint tileId, Guid edgeTypeMapId, uint nextCrossTileId, ArrayBase<uint> pointers,
	16	58		ArrayBase<byte> edges,
	16	59		ArrayBase<uint> crossEdgePointers, ArrayBase<byte> coordinates, ArrayBase<byte> shapes,
	16	60		ArrayBase<byte> attributes,
	16	61		ArrayBase<string> strings, ArrayBase<byte> turnCosts, uint nextVertexId, uint nextEdgeId,
	16	62		uint nextAttributePointer,
	16	63		uint nextShapePointer, uint nextStringId)
	16	64		{
	16	65		_zoom = zoom;
	16	66		_tileId = tileId;
	16	67		_edgeTypeMapId = edgeTypeMapId;
	16	68		_nextCrossTileId = nextCrossTileId;
	16	69		_pointers = pointers;
	16	70		_edges = edges;
	16	71		_crossEdgePointers = crossEdgePointers;
		72
	16	73		_coordinates = coordinates;
	16	74		_shapes = shapes;
	16	75		_attributes = attributes;
	16	76		_strings = strings;
	16	77		_turnCosts = turnCosts;
		78
	16	79		_nextVertexId = nextVertexId;
	16	80		_nextEdgeId = nextEdgeId;
	16	81		_nextAttributePointer = nextAttributePointer;
	16	82		_nextShapePointer = nextShapePointer;
	16	83		_nextStringId = nextStringId;
	16	84		}
		85
		86		/// <summary>
		87		/// Clones this graph tile.
		88		/// </summary>
		89		/// <returns>The copy of this tile.</returns>
		90		public NetworkTile Clone()
	10	91		{
	10	92		return new(_zoom, _tileId, _edgeTypeMapId, _nextCrossTileId, _pointers.Clone(), _edges.Clone(),
	10	93		_crossEdgePointers.Clone(),
	10	94		_coordinates.Clone(), _shapes.Clone(), _attributes.Clone(), _strings.Clone(), _turnCosts.Clone(),
	10	95		_nextVertexId,
	10	96		_nextEdgeId, _nextAttributePointer, _nextShapePointer, _nextStringId);
	10	97		}
		98
		99		/// <summary>
		100		/// Gets the tile id.
		101		/// </summary>
	2726	102		public uint TileId => _tileId;
		103
		104		/// <summary>
		105		/// Gets the number of vertices.
		106		/// </summary>
	362	107		public uint VertexCount => _nextVertexId;
		108
		109		/// <summary>
		110		/// Gets the edge type map id.
		111		/// </summary>
	988	112		public Guid EdgeTypeMapId => _edgeTypeMapId;
		113
		114		/// <summary>
		115		/// Adds a new vertex and returns its id.
		116		/// </summary>
		117		/// <param name="longitude">The longitude.</param>
		118		/// <param name="latitude">The latitude.</param>
		119		/// <param name="e">The elevation in meters.</param>
		120		/// <returns>The ID of the new vertex.</returns>
		121		public VertexId AddVertex(double longitude, double latitude, float? e = null)
	433	122		{
		123		// set coordinate.
	433	124		this.SetCoordinate(_nextVertexId, longitude, latitude, e);
		125
		126		// create id.
	433	127		var vertexId = new VertexId(_tileId, _nextVertexId);
	433	128		_nextVertexId++;
		129
		130		// make room.
	433	131		_pointers.EnsureMinimumSize(vertexId.LocalId, DefaultSizeIncrease);
		132
	433	133		return vertexId;
	433	134		}
		135
		136		/// <summary>
		137		/// Returns true if the vertex exists.
		138		/// </summary>
		139		/// <param name="vertex"></param>
		140		/// <returns></returns>
		141		public bool HasVertex(VertexId vertex)
	34	142		{
	34	143		if (vertex.LocalId >= _nextVertexId)
	11	144		{
	11	145		return false;
		146		}
		147
	23	148		return true;
	34	149		}
		150
		151		/// <summary>
		152		/// Gets the vertex with the given id.
		153		/// </summary>
		154		/// <param name="vertex">The vertex.</param>
		155		/// <param name="longitude">The longitude.</param>
		156		/// <param name="latitude">The latitude.</param>
		157		/// <param name="elevation">The elevation.</param>
		158		/// <returns>True if the vertex exists.</returns>
		159		public bool TryGetVertex(VertexId vertex, out double longitude, out double latitude, out float? elevation)
	691	160		{
	691	161		longitude = default;
	691	162		latitude = default;
	691	163		elevation = null;
	691	164		if (vertex.LocalId >= _nextVertexId)
	11	165		{
	11	166		return false;
		167		}
		168
	680	169		this.GetCoordinate(vertex.LocalId, out longitude, out latitude, out elevation);
	680	170		return true;
	691	171		}
		172
		173		/// <summary>
		174		/// Adds a new edge and returns its id.
		175		/// </summary>
		176		/// <param name="vertex1">The first vertex.</param>
		177		/// <param name="vertex2">The second vertex.</param>
		178		/// <param name="shape">The shape."</param>
		179		/// <param name="attributes">The attributes."</param>
		180		/// <param name="edgeId">The edge id if this edge is a part of another tile.</param>
		181		/// <param name="edgeTypeId">The edge type id, if any.</param>
		182		/// <param name="length">The length in centimeters.</param>
		183		/// <returns>The new edge id.</returns>
		184		public EdgeId AddEdge(VertexId vertex1, VertexId vertex2,
		185		IEnumerable<(double longitude, double latitude, float? e)>? shape = null,
		186		IEnumerable<(string key, string value)>? attributes = null, EdgeId? edgeId = null, uint? edgeTypeId = null,
		187		uint? length = null)
	270	188		{
	270	189		if (vertex2.TileId != _tileId)
	7	190		{
		191		// this edge crosses tiles boundaries, it need special treatment and a stable id.
		192		// because the edge originates in this tile, this tile is responsible for generating the id.
	7	193		if (edgeId != null) throw new ArgumentException(
	0	194		"The edge id shouldn't be a given, it should be generated by the originating tile.",
	0	195		nameof(edgeId));
	7	196		if (vertex1.TileId != _tileId) throw new ArgumentException("None of the two vertices in this edge are in thi
	0	197		nameof(vertex1));
		198
		199		// generate a new cross tile id and store pointer to edge.
	7	200		edgeId = EdgeId.CrossEdgeId(_tileId, _nextCrossTileId);
	7	201		_crossEdgePointers.EnsureMinimumSize(_nextCrossTileId + 1);
	7	202		_crossEdgePointers[_nextCrossTileId] = _nextEdgeId;
	7	203		_nextCrossTileId++;
	7	204		}
	263	205		else if (vertex1.TileId != _tileId)
	6	206		{
		207		// this edge crosses tiles boundaries, it need special treatment and a stable id.
		208		// because the edge originates in another tile it should already have an id.
	6	209		if (edgeId == null) throw new ArgumentException(
	0	210		"Cannot add an edge that doesn't start in this tile without a proper edge id.",
	0	211		nameof(edgeId));
	6	212		if (edgeId.Value.TileId != vertex1.TileId) throw new ArgumentException("The edge id doesn't match the tile i
	0	213		nameof(edgeId));
	6	214		}
		215		else
	257	216		{
		217		// this edge starts in this tile, it get an id from this tile.
	257	218		edgeId = new EdgeId(_tileId, _nextEdgeId);
	257	219		}
		220
		221		// write the edge data.
	270	222		var newEdgePointer = _nextEdgeId;
	270	223		var size = EncodeVertex(_edges, _tileId, _nextEdgeId, vertex1);
	270	224		_nextEdgeId += size;
	270	225		size = EncodeVertex(_edges, _tileId, _nextEdgeId, vertex2);
	270	226		_nextEdgeId += size;
		227
		228		// get previous pointers if vertex already has edges
		229		// set the new pointers.
	270	230		uint? v1p = null;
	270	231		if (vertex1.TileId == _tileId)
	264	232		{
	264	233		v1p = _pointers[vertex1.LocalId].DecodeNullableData();
	264	234		_pointers[vertex1.LocalId] = newEdgePointer.EncodeToNullableData();
	264	235		}
		236
	270	237		uint? v2p = null;
	270	238		if (vertex2.TileId == _tileId)
	263	239		{
	263	240		v2p = _pointers[vertex2.LocalId].DecodeNullableData();
	263	241		_pointers[vertex2.LocalId] = newEdgePointer.EncodeToNullableData();
	263	242		}
		243
		244		// set next pointers.
	270	245		size = EncodePointer(_edges, _nextEdgeId, v1p);
	270	246		_nextEdgeId += size;
	270	247		size = EncodePointer(_edges, _nextEdgeId, v2p);
	270	248		_nextEdgeId += size;
		249
		250		// write edge id explicitly if not in this edge.
	270	251		if (vertex1.TileId != vertex2.TileId)
	13	252		{
		253		// this data will only be there for edges crossing tile boundaries.
	13	254		_nextEdgeId += (uint)_edges.SetDynamicUInt32(_nextEdgeId,
	13	255		edgeId.Value.LocalId - EdgeId.MinCrossId);
	13	256		}
		257
		258		// write edge profile id.
	270	259		_nextEdgeId += SetDynamicUIn32Nullable(_edges, _nextEdgeId, edgeTypeId);
		260
		261		// write length.
	270	262		_nextEdgeId += SetDynamicUIn32Nullable(_edges, _nextEdgeId, length);
		263
		264		// set tail and head order.
	270	265		_edges.SetTailHeadOrder(_nextEdgeId, null, null);
	270	266		_nextEdgeId++;
		267
		268		// take care of shape if any.
	270	269		uint? shapePointer = null;
	270	270		if (shape != null)
	88	271		{
	88	272		shapePointer = this.SetShape(shape);
	88	273		}
		274
	270	275		size = EncodePointer(_edges, _nextEdgeId, shapePointer);
	270	276		_nextEdgeId += size;
		277
		278		// take care of attributes if any.
	270	279		uint? attributesPointer = null;
	270	280		if (attributes != null)
	113	281		{
	113	282		attributesPointer = this.SetAttributes(attributes);
	113	283		}
		284
	270	285		size = EncodePointer(_edges, _nextEdgeId, attributesPointer);
	270	286		_nextEdgeId += size;
		287
	270	288		return edgeId.Value;
	270	289		}
		290
		291		private HashSet<EdgeId>? _deletedEdges;
		292
		293		/// <summary>
		294		/// Marks the given edge as deleted.
		295		/// </summary>
		296		/// <param name="edge">The edge to delete.</param>
		297		internal void DeleteEdge(EdgeId edge)
	10	298		{
	10	299		_deletedEdges ??= new HashSet<EdgeId>();
	10	300		_deletedEdges.Add(edge);
	10	301		}
		302
		303		/// <summary>
		304		/// Returns true if the edge is deleted.
		305		/// </summary>
		306		/// <param name="edge">The edge.</param>
		307		/// <returns>True if the edge was deleted.</returns>
		308		internal bool IsEdgeDeleted(EdgeId edge)
	1105	309		{
	2204	310		if (_deletedEdges == null) return false;
		311
	6	312		return _deletedEdges.Contains(edge);
	1105	313		}
		314
		315		/// <summary>
		316		/// Returns true if there are deleted edges.
		317		/// </summary>
	123	318		internal bool HasDeletedEdges => _deletedEdges != null;
		319
		320		/// <summary>
		321		/// Removes all the deleted edges.
		322		/// </summary>
		323		/// <remarks>This changes all the edges if all edges written after a deleted edge.</remarks>
		324		internal void RemoveDeletedEdges()
	10	325		{
	10	326		if (_deletedEdges == null) return;
		327
		328		// reset vertex pointers.
	340	329		for (var i = 0; i < _pointers.Length; i++)
	160	330		{
	160	331		_pointers[i] = 0;
	160	332		}
		333
		334		// redo edges, skipping deleted edges.
	10	335		var nextEdgeId = _nextEdgeId;
	10	336		var p = 0U;
	10	337		var newP = 0U;
	24	338		while (p < nextEdgeId)
	14	339		{
		340		// read edge data.
	14	341		var currentEdgeId = p;
	14	342		p += this.DecodeVertex(p, out var local1Id, out var tile1Id);
	14	343		var vertex1 = new VertexId(tile1Id, local1Id);
	14	344		p += this.DecodeVertex(p, out var local2Id, out var tile2Id);
	14	345		var vertex2 = new VertexId(tile2Id, local2Id);
	14	346		p += this.DecodePointer(p, out _);
	14	347		p += this.DecodePointer(p, out _);
	14	348		uint? crossEdgeId = null;
	14	349		if (tile1Id != tile2Id)
	4	350		{
	4	351		p += (uint)_edges.GetDynamicUInt32(p, out var c);
	4	352		crossEdgeId = c;
	4	353		}
		354
	14	355		p += (uint)_edges.GetDynamicUInt32Nullable(p, out var edgeTypeId);
	14	356		p += (uint)_edges.GetDynamicUInt32Nullable(p, out var length);
	14	357		var tailHeadOrder = _edges[p];
	14	358		p++;
	14	359		p += this.DecodePointer(p, out var shapePointer);
	14	360		p += this.DecodePointer(p, out var attributePointer);
		361
		362		// check if edge was deleted.
	20	363		if (_deletedEdges.Contains(new EdgeId(_tileId, currentEdgeId))) continue;
	8	364		if (crossEdgeId.HasValue)
	4	365		{
	8	366		if (_deletedEdges.Contains(EdgeId.CrossEdgeId(vertex1.TileId, crossEdgeId.Value))) continue;
	0	367		}
		368
		369		// no need to overwrite identical data.
	4	370		if (p == newP) continue;
		371
		372		// write edge data again.
	4	373		var newEdgePointer = newP;
	4	374		newP += EncodeVertex(_edges, _tileId, newP, vertex1);
	4	375		newP += EncodeVertex(_edges, _tileId, newP, vertex2);
	4	376		uint? v1p = null;
	4	377		if (vertex1.TileId == _tileId)
	4	378		{
	4	379		v1p = _pointers[vertex1.LocalId].DecodeNullableData();
	4	380		_pointers[vertex1.LocalId] = newEdgePointer.EncodeToNullableData();
	4	381		}
		382
	4	383		uint? v2P = null;
	4	384		if (vertex2.TileId == _tileId)
	4	385		{
	4	386		v2P = _pointers[vertex2.LocalId].DecodeNullableData();
	4	387		_pointers[vertex2.LocalId] = newEdgePointer.EncodeToNullableData();
	4	388		}
		389
	4	390		newP += EncodePointer(_edges, newP, v1p);
	4	391		newP += EncodePointer(_edges, newP, v2P);
	4	392		if (crossEdgeId != null)
	0	393		{
	0	394		newP += (uint)_edges.SetDynamicUInt32(newP, crossEdgeId.Value);
	0	395		if (vertex1.TileId == _tileId)
	0	396		{
	0	397		_crossEdgePointers[crossEdgeId.Value] = newEdgePointer;
	0	398		}
	0	399		}
		400
	4	401		newP += (uint)_edges.SetDynamicUInt32Nullable(newP, edgeTypeId);
	4	402		newP += (uint)_edges.SetDynamicUInt32Nullable(newP, length);
	4	403		_edges[newP] = tailHeadOrder;
	4	404		newP++;
	4	405		newP += EncodePointer(_edges, newP, shapePointer);
	4	406		newP += EncodePointer(_edges, newP, attributePointer);
	4	407		}
		408
	10	409		_nextEdgeId = newP;
	10	410		_deletedEdges = null;
	10	411		}
		412
		413		internal NetworkTile CloneForEdgeTypeMap(
		414		(Guid id, Func<IEnumerable<(string key, string value)>, uint> func) edgeTypeMap)
	6	415		{
	6	416		var edges = new MemoryArray<byte>(_edges.Length);
	6	417		var pointers = new MemoryArray<uint>(_pointers.Length);
	6	418		var crossEdgePointers = new MemoryArray<uint>(_crossEdgePointers.Length);
	6	419		var nextEdgeId = _nextEdgeId;
	6	420		var p = 0U;
	6	421		var newP = 0U;
	16	422		while (p < nextEdgeId)
	10	423		{
		424		// read edge data.
	10	425		p += this.DecodeVertex(p, out var local1Id, out var tile1Id);
	10	426		var vertex1 = new VertexId(tile1Id, local1Id);
	10	427		p += this.DecodeVertex(p, out var local2Id, out var tile2Id);
	10	428		var vertex2 = new VertexId(tile2Id, local2Id);
	10	429		p += this.DecodePointer(p, out _);
	10	430		p += this.DecodePointer(p, out _);
	10	431		uint? crossEdgeId = null;
	10	432		if (tile1Id != tile2Id)
	0	433		{
	0	434		p += (uint)_edges.GetDynamicUInt32(p, out var c);
	0	435		crossEdgeId = c;
	0	436		}
		437
	10	438		p += (uint)_edges.GetDynamicUInt32Nullable(p, out var _);
	10	439		p += (uint)_edges.GetDynamicUInt32Nullable(p, out var length);
	10	440		var tailHeadOrder = _edges[p];
	10	441		p++;
	10	442		p += this.DecodePointer(p, out var shapePointer);
	10	443		p += this.DecodePointer(p, out var attributePointer);
		444
		445		// generate new edge type id.
	10	446		var newEdgeTypeId = edgeTypeMap.func(this.GetAttributes(attributePointer));
		447
		448		// write edge data again.
	10	449		var newEdgePointer = newP;
	10	450		newP += EncodeVertex(edges, _tileId, newP, vertex1);
	10	451		newP += EncodeVertex(edges, _tileId, newP, vertex2);
	10	452		uint? v1p = null;
	10	453		if (vertex1.TileId == _tileId)
	10	454		{
	10	455		v1p = pointers[vertex1.LocalId].DecodeNullableData();
	10	456		pointers[vertex1.LocalId] = newEdgePointer.EncodeToNullableData();
	10	457		}
		458
	10	459		uint? v2p = null;
	10	460		if (vertex2.TileId == _tileId)
	10	461		{
	10	462		v2p = pointers[vertex2.LocalId].DecodeNullableData();
	10	463		pointers[vertex2.LocalId] = newEdgePointer.EncodeToNullableData();
	10	464		}
		465
	10	466		newP += EncodePointer(edges, newP, v1p);
	10	467		newP += EncodePointer(edges, newP, v2p);
	10	468		if (crossEdgeId != null)
	0	469		{
	0	470		newP += (uint)edges.SetDynamicUInt32(newP, crossEdgeId.Value);
	0	471		if (vertex1.TileId == _tileId)
	0	472		{
	0	473		crossEdgePointers[crossEdgeId.Value] = newEdgePointer;
	0	474		}
	0	475		}
		476
	10	477		newP += (uint)edges.SetDynamicUInt32Nullable(newP, newEdgeTypeId);
	10	478		newP += (uint)edges.SetDynamicUInt32Nullable(newP, length);
	10	479		edges[newP] = tailHeadOrder;
	10	480		newP++;
	10	481		newP += EncodePointer(edges, newP, shapePointer);
	10	482		newP += EncodePointer(edges, newP, attributePointer);
	10	483		}
		484
	6	485		return new NetworkTile(_zoom, _tileId, edgeTypeMap.id, _nextCrossTileId, pointers, edges, crossEdgePointers,
	6	486		_coordinates,
	6	487		_shapes, _attributes, _strings, _turnCosts, _nextVertexId, _nextEdgeId,
	6	488		_nextAttributePointer, _nextShapePointer, _nextStringId);
	6	489		}
		490
		491		internal uint VertexEdgePointer(uint vertex)
	374	492		{
	374	493		return _pointers[vertex];
	374	494		}
		495
		496		internal static uint EncodeVertex(ArrayBase<byte> edges, uint localTileId, uint location, VertexId vertexId)
	568	497		{
	568	498		if (vertexId.TileId == localTileId)
	555	499		{
		500		// same tile, only store local id.
	555	501		if (edges.Length <= location + 5)
	173	502		{
	173	503		edges.Resize(edges.Length + DefaultSizeIncrease);
	173	504		}
		505
	555	506		return (uint)edges.SetDynamicUInt32(location, vertexId.LocalId);
		507		}
		508
		509		// other tile, store full id.
	13	510		if (edges.Length <= location + 10)
	6	511		{
	6	512		edges.Resize(edges.Length + DefaultSizeIncrease);
	6	513		}
		514
	13	515		var encodedId = vertexId.Encode();
	13	516		return (uint)edges.SetDynamicUInt64(location, encodedId);
	568	517		}
		518
		519		internal uint DecodeVertex(uint location, out uint localId, out uint tileId)
	2304	520		{
	2304	521		var size = (uint)_edges.GetDynamicUInt64(location, out var encodedId);
	2304	522		if (encodedId < uint.MaxValue)
	2290	523		{
	2290	524		localId = (uint)encodedId;
	2290	525		tileId = _tileId;
	2290	526		return size;
		527		}
		528
	14	529		VertexId.Decode(encodedId, out tileId, out localId);
	14	530		return size;
	2304	531		}
		532
		533		internal uint DecodeEdgeCrossId(uint location, out uint edgeCrossId)
	9	534		{
	9	535		var s = _edges.GetDynamicUInt32(location, out var c);
	9	536		edgeCrossId = EdgeId.MinCrossId + c;
	9	537		return (uint)s;
	9	538		}
		539
		540		internal uint GetEdgeCrossPointer(uint edgeCrossId)
	3	541		{
	3	542		return _crossEdgePointers[edgeCrossId];
	3	543		}
		544
		545		internal static uint EncodePointer(ArrayBase<byte> edges, uint location, uint? pointer)
	1136	546		{
		547		// TODO: save the diff instead of the full pointer.
	1136	548		if (edges.Length <= location + 5)
	79	549		{
	79	550		edges.Resize(edges.Length + DefaultSizeIncrease);
	79	551		}
		552
	1136	553		return (uint)edges.SetDynamicUInt32(location,
	1136	554		pointer.EncodeAsNullableData());
	1136	555		}
		556
		557		internal uint DecodePointer(uint location, out uint? pointer)
	4560	558		{
	4560	559		var size = _edges.GetDynamicUInt32(location, out var data);
	4560	560		pointer = data.DecodeNullableData();
	4560	561		return (uint)size;
	4560	562		}
		563
		564		internal static uint SetDynamicUIn32Nullable(ArrayBase<byte> edges, uint pointer, uint? data)
	540	565		{
	540	566		while (edges.Length <= pointer + 5)
	0	567		{
	0	568		edges.Resize(edges.Length + DefaultSizeIncrease);
	0	569		}
		570
	540	571		return (uint)edges.SetDynamicUInt32Nullable(pointer, data);
	540	572		}
		573
		574		internal void GetTailHeadOrder(uint location, ref byte? tail, ref byte? head)
	1127	575		{
	1127	576		_edges.GetTailHeadOrder(location, ref tail, ref head);
	1127	577		}
		578
		579		internal uint DecodeEdgePointerId(uint location, out uint? edgeProfileId)
	2254	580		{
	2254	581		return (uint)_edges.GetDynamicUInt32Nullable(location, out edgeProfileId);
	2254	582		}
		583
		584		private void WriteEdgesAndVerticesTo(Stream stream)
	8	585		{
		586		// write vertex pointers.
	8	587		stream.WriteVarUInt32(_nextVertexId);
	42	588		for (var i = 0; i < _nextVertexId; i++)
	13	589		{
	13	590		stream.WriteVarUInt32(_pointers[i]);
	13	591		}
		592
		593		// write edges.
	8	594		stream.WriteVarUInt32(_nextEdgeId);
	106	595		for (var i = 0; i < _nextEdgeId; i++)
	45	596		{
	45	597		stream.WriteByte(_edges[i]);
	45	598		}
		599
		600		// write cross edge pointers.
	8	601		stream.WriteVarUInt32(_nextCrossTileId);
	16	602		for (var i = 0; i < _nextCrossTileId; i++)
	0	603		{
	0	604		stream.WriteVarUInt32(_crossEdgePointers[i]);
	0	605		}
	8	606		}
		607
		608		private void ReadEdgesAndVerticesFrom(Stream stream)
	8	609		{
		610		// read vertex pointers.
	8	611		_nextVertexId = stream.ReadVarUInt32();
	8	612		_pointers.Resize(_nextVertexId);
	42	613		for (var i = 0; i < _nextVertexId; i++)
	13	614		{
	13	615		_pointers[i] = stream.ReadVarUInt32();
	13	616		}
		617
		618		// read edges.
	8	619		_nextEdgeId = stream.ReadVarUInt32();
	8	620		_edges.Resize(_nextEdgeId);
	106	621		for (var i = 0; i < _nextEdgeId; i++)
	45	622		{
	45	623		_edges[i] = (byte)stream.ReadByte();
	45	624		}
		625
		626		// read cross tile edge pointers.
	8	627		_nextCrossTileId = stream.ReadVarUInt32();
	8	628		_crossEdgePointers.Resize(_nextCrossTileId);
	16	629		for (var i = 0; i < _nextCrossTileId; i++)
	0	630		{
	0	631		_crossEdgePointers[i] = stream.ReadVarUInt32();
	0	632		}
	8	633		}
		634		}

/home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.Geo.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections.Generic;
		3		using System.IO;
		4		using Itinero.IO;
		5		using Itinero.Network.Storage;
		6		using Reminiscence.Arrays;
		7
		8		namespace Itinero.Network.Tiles;
		9
		10		internal partial class NetworkTile
		11		{
		12		private const int CoordinateSizeInBytes = 3; // 3 bytes = 24 bits = 4096 x 4096.
		13		private const int TileResolutionInBits = CoordinateSizeInBytes * 8 / 2;
		14		private const int ElevationSizeInBytes = 2; // 2 bytes = 16 bits = [-32768, 32767], using dm as resolution
		15
		16		// the vertex coordinates.
		17		private readonly ArrayBase<byte> _coordinates;
		18		private int? _elevation; // the tile elevation.
		19
		20		// the shapes.
	210	21		private uint _nextShapePointer = 0;
		22		private readonly ArrayBase<byte> _shapes;
		23
		24		private void SetCoordinate(uint localId, double longitude, double latitude, float? e)
	433	25		{
		26		// set elevation if needed.
	433	27		if (_elevation != null && e == null)
	0	28		{
	0	29		throw new ArgumentNullException(nameof(e),
	0	30		"Elevation was set before, either always set elevation or never set elevation.");
		31		}
		32
	433	33		if (_elevation == null && e != null)
	13	34		{
	13	35		if (localId != 0)
	0	36		{
	0	37		throw new ArgumentNullException(nameof(e),
	0	38		"Elevation was not set before, either always set elevation or never set elevation.");
		39		}
		40
	13	41		_elevation = (int)(e * 10);
	13	42		}
		43
		44		// make sure coordinates fit.
		45		uint tileCoordinatePointer;
	433	46		if (_elevation == null)
	395	47		{
		48		// don't store elevation.
	395	49		tileCoordinatePointer = localId * CoordinateSizeInBytes * 2;
	395	50		_coordinates.EnsureMinimumSize(tileCoordinatePointer + (CoordinateSizeInBytes * 2),
	395	51		DefaultSizeIncrease);
	395	52		}
		53		else
	38	54		{
		55		// store elevation.
	38	56		tileCoordinatePointer = localId * ((CoordinateSizeInBytes * 2) + ElevationSizeInBytes);
	38	57		_coordinates.EnsureMinimumSize(tileCoordinatePointer + (CoordinateSizeInBytes * 2) + ElevationSizeInBytes,
	38	58		DefaultSizeIncrease);
	38	59		}
		60
		61		// write coordinates.
		62		const int resolution = (1 << TileResolutionInBits) - 1;
	433	63		var (x, y) = TileStatic.ToLocalTileCoordinates(_zoom, _tileId, longitude, latitude, resolution);
	433	64		_coordinates.SetFixed(tileCoordinatePointer, CoordinateSizeInBytes, x);
	433	65		_coordinates.SetFixed(tileCoordinatePointer + CoordinateSizeInBytes, CoordinateSizeInBytes, y);
		66
		67		// write elevation.
	433	68		if (_elevation != null)
	38	69		{
	38	70		if (e == null)
	0	71		{
	0	72		throw new ArgumentNullException(nameof(e),
	0	73		"Elevation was set before, either always set elevation or never set elevation.");
		74		}
		75
	38	76		var offset = (int)(e.Value * 10) - _elevation.Value;
	38	77		_coordinates.SetFixed(tileCoordinatePointer + CoordinateSizeInBytes + CoordinateSizeInBytes,
	38	78		ElevationSizeInBytes, offset);
	38	79		}
	433	80		}
		81
		82		private void GetCoordinate(uint localId, out double longitude, out double latitude, out float? elevation)
	680	83		{
	680	84		var tileCoordinatePointer = _elevation == null
	680	85		? localId * CoordinateSizeInBytes * 2
	680	86		: localId * ((CoordinateSizeInBytes * 2) + ElevationSizeInBytes);
		87
		88		const int resolution = (1 << TileResolutionInBits) - 1;
	680	89		_coordinates.GetFixed(tileCoordinatePointer, CoordinateSizeInBytes, out var x);
	680	90		_coordinates.GetFixed(tileCoordinatePointer + CoordinateSizeInBytes, CoordinateSizeInBytes, out var y);
	680	91		elevation = null;
	680	92		if (_elevation != null)
	47	93		{
	47	94		_coordinates.GetFixed(tileCoordinatePointer + CoordinateSizeInBytes + CoordinateSizeInBytes,
	47	95		ElevationSizeInBytes, out var offset);
	47	96		elevation = (_elevation.Value + offset) / 10.0f;
	47	97		}
		98
	680	99		TileStatic.FromLocalTileCoordinates(_zoom, _tileId, x, y, resolution, out longitude, out latitude);
	680	100		}
		101
		102		private uint SetShape(IEnumerable<(double longitude, double latitude, float? e)> shape)
	88	103		{
		104		const int resolution = (1 << TileResolutionInBits) - 1;
	88	105		var originalPointer = _nextShapePointer;
	88	106		var blockPointer = originalPointer;
	88	107		var pointer = blockPointer + 1;
		108
		109		// make sure there is space for the block pointer.
	88	110		_shapes.EnsureMinimumSize(blockPointer);
		111
	88	112		var coordinateBlockSize = 8;
	88	113		if (_elevation != null)
	24	114		{
	24	115		coordinateBlockSize += 4;
	24	116		}
		117
	88	118		using var enumerator = shape.GetEnumerator();
	88	119		var count = 0;
	88	120		(int x, int y, int? eOffset) previous = (int.MaxValue, int.MaxValue, null);
	443	121		while (enumerator.MoveNext())
	355	122		{
	355	123		var current = enumerator.Current;
	355	124		var (x, y) =
	355	125		TileStatic.ToLocalTileCoordinates(_zoom, _tileId, current.longitude, current.latitude, resolution);
	355	126		int? eOffset = null;
	355	127		var e = current.e ?? 0;
	355	128		if (_elevation != null)
	15	129		{
	15	130		eOffset = (int)(e * 10) - _elevation.Value;
	15	131		}
		132
		133		// make sure there is space for this coordinate.
	355	134		_shapes.EnsureMinimumSize(pointer + coordinateBlockSize);
		135
		136		// store coordinate.
	355	137		if (count == 0)
	48	138		{
		139		// first coordinate.
	48	140		pointer += (uint)_shapes.SetDynamicInt32(pointer, x);
	48	141		pointer += (uint)_shapes.SetDynamicInt32(pointer, y);
	48	142		if (eOffset != null)
	7	143		{
	7	144		pointer += (uint)_shapes.SetDynamicInt32(pointer, eOffset.Value);
	7	145		}
	48	146		}
		147		else
	307	148		{
		149		// calculate diff and then store.
	307	150		var diffX = x - previous.x;
	307	151		var diffY = y - previous.y;
	307	152		pointer += (uint)_shapes.SetDynamicInt32(pointer, diffX);
	307	153		pointer += (uint)_shapes.SetDynamicInt32(pointer, diffY);
	307	154		if (eOffset != null)
	8	155		{
	8	156		if (previous.eOffset == null)
	0	157		{
	0	158		throw new ArgumentException("Not all points have elevation set.");
		159		}
		160
	8	161		var diffE = eOffset.Value - previous.eOffset.Value;
	8	162		pointer += (uint)_shapes.SetDynamicInt32(pointer, diffE);
	8	163		}
	307	164		}
		165
	355	166		count++;
		167
	355	168		if (count == 255)
	1	169		{
		170		// start a new block, assign 255.
	1	171		_shapes[blockPointer] = 255;
	1	172		blockPointer = pointer;
	1	173		pointer = blockPointer + 1;
	1	174		count = 0;
	1	175		}
		176
	355	177		previous = (x, y, eOffset);
	355	178		}
		179
		180		// a block is still open, close it.
	88	181		_shapes[blockPointer] = (byte)count;
	88	182		_nextShapePointer = pointer;
		183
	88	184		return originalPointer;
	88	185		}
		186
		187		internal IEnumerable<(double longitude, double latitude, float? e)> GetShape(uint? pointer)
	365	188		{
	365	189		if (pointer == null)
	192	190		{
	192	191		yield break;
		192		}
		193
	173	194		var p = pointer.Value;
		195
		196		const int resolution = (1 << TileResolutionInBits) - 1;
	173	197		var count = -1;
	173	198		(int x, int y, int? eOffset) previous = (int.MaxValue, int.MaxValue, null);
	174	199		while (true)
	174	200		{
	174	201		count = _shapes[p];
	174	202		p++;
		203
	1276	204		for (var i = 0; i < count; i++)
	466	205		{
	466	206		p += (uint)_shapes.GetDynamicInt32(p, out var x);
	466	207		p += (uint)_shapes.GetDynamicInt32(p, out var y);
	466	208		int? eOffset = null;
	466	209		if (_elevation != null)
	24	210		{
	24	211		p += (uint)_shapes.GetDynamicInt32(p, out var e);
	24	212		eOffset = e;
	24	213		}
		214
	466	215		if (i > 0)
	352	216		{
	352	217		x = previous.x + x;
	352	218		y = previous.y + y;
	352	219		if (_elevation != null)
	12	220		{
	12	221		if (previous.eOffset == null)
	0	222		{
	0	223		throw new ArgumentException("Not all points have elevation set.");
		224		}
		225
	12	226		eOffset = previous.eOffset.Value + eOffset;
	12	227		}
	352	228		}
		229
	466	230		int? elevation = null;
	466	231		if (_elevation != null)
	24	232		{
	24	233		if (eOffset == null)
	0	234		{
	0	235		throw new ArgumentException("Not all points have elevation set.");
		236		}
		237
	24	238		elevation = _elevation.Value + eOffset.Value;
	24	239		}
		240
	466	241		TileStatic.FromLocalTileCoordinates(_zoom, _tileId, x, y, resolution, out var longitude,
	466	242		out var latitude);
	466	243		yield return (longitude, latitude, elevation / 10.0f);
		244
	464	245		previous = (x, y, eOffset);
	464	246		}
		247
	343	248		if (count < 255) break;
	1	249		}
	171	250		}
		251
		252		private void WriteGeoTo(Stream stream)
	8	253		{
	8	254		stream.WriteVarInt32Nullable(_elevation);
		255
		256		// write vertex locations.
	8	257		var coordinateSize = CoordinateSizeInBytes * 2;
	8	258		if (_elevation != null)
	2	259		{
	2	260		coordinateSize += ElevationSizeInBytes;
	2	261		}
		262
	8	263		var coordinateBytes = _nextVertexId * coordinateSize;
	184	264		for (var i = 0; i < coordinateBytes; i++)
	84	265		{
	84	266		stream.WriteByte(_coordinates[i]);
	84	267		}
		268
		269		// write shape locations.
	8	270		stream.WriteVarUInt32(_nextShapePointer);
	74	271		for (var i = 0; i < _nextShapePointer; i++)
	29	272		{
	29	273		stream.WriteByte(_shapes[i]);
	29	274		}
	8	275		}
		276
		277		private void ReadGeoFrom(Stream stream)
	8	278		{
	8	279		_elevation = stream.ReadVarInt32Nullable();
		280
		281		// read vertex locations.
	8	282		var coordinateSize = CoordinateSizeInBytes * 2;
	8	283		if (_elevation != null)
	2	284		{
	2	285		coordinateSize += ElevationSizeInBytes;
	2	286		}
		287
	8	288		var coordinateBytes = _nextVertexId * coordinateSize;
	8	289		_coordinates.Resize(coordinateBytes);
	184	290		for (var i = 0; i < coordinateBytes; i++)
	84	291		{
	84	292		_coordinates[i] = (byte)stream.ReadByte();
	84	293		}
		294
	8	295		_nextShapePointer = stream.ReadVarUInt32();
	8	296		_shapes.Resize(_nextShapePointer);
	74	297		for (var i = 0; i < _nextShapePointer; i++)
	29	298		{
	29	299		_shapes[i] = (byte)stream.ReadByte();
	29	300		}
	8	301		}
		302		}

/home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.Serialization.cs

	#	Line		Line coverage
		1		using System.IO;
		2		using Itinero.IO;
		3
		4		namespace Itinero.Network.Tiles;
		5
		6		internal partial class NetworkTile
		7		{
		8		public void WriteTo(Stream stream)
	8	9		{
		10		const int version = 1;
	8	11		stream.WriteVarInt32(version);
		12
		13		// write tile id/zoom.
	8	14		stream.WriteVarInt32(_zoom);
	8	15		stream.WriteVarUInt32(_tileId);
	8	16		stream.WriteGuid(_edgeTypeMapId);
		17
		18		// write vertices and edges.
	8	19		this.WriteEdgesAndVerticesTo(stream);
		20
		21		// write attributes.
	8	22		this.WriteAttributesTo(stream);
		23
		24		// write shapes.
	8	25		this.WriteGeoTo(stream);
		26
		27		// write turn costs.
	8	28		this.WriteTurnCostsTo(stream);
	8	29		}
		30
		31		public static NetworkTile ReadFrom(Stream stream)
	8	32		{
	8	33		var version = stream.ReadVarInt32();
	8	34		if (version != 1)
	0	35		{
	0	36		throw new InvalidDataException("Cannot deserialize tiles: Invalid version #.");
		37		}
		38
		39		// read tile id.
	8	40		var zoom = stream.ReadVarInt32();
	8	41		var tileId = stream.ReadVarUInt32();
	8	42		var edgeTypeMapId = stream.ReadGuid();
		43
		44		// create the tile.
	8	45		var graphTile = new NetworkTile(zoom, tileId, edgeTypeMapId);
		46
		47		// read vertices and edges.
	8	48		graphTile.ReadEdgesAndVerticesFrom(stream);
		49
		50		// read attributes.
	8	51		graphTile.ReadAttributesFrom(stream);
		52
		53		// read shapes.
	8	54		graphTile.ReadGeoFrom(stream);
		55
		56		// read turn costs.
	8	57		graphTile.ReadTurnCostsFrom(stream);
		58
	8	59		return graphTile;
	8	60		}
		61		}

/home/runner/work/routing2/routing2/src/Itinero/Network/Tiles/NetworkTile.TurnCosts.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections.Generic;
		3		using System.IO;
		4		using System.Linq;
		5		using Itinero.IO;
		6		using Itinero.Network.Storage;
		7		using Itinero.Network.TurnCosts;
		8		using Reminiscence.Arrays;
		9
		10		namespace Itinero.Network.Tiles;
		11
		12		internal partial class NetworkTile
		13		{
	210	14		private uint _turnCostPointer = 0;
	210	15		private readonly ArrayBase<uint> _turnCostPointers = new MemoryArray<uint>(0);
	210	16		private readonly ArrayBase<byte> _turnCosts = new MemoryArray<byte>(0);
		17
		18		internal void AddTurnCosts(VertexId vertex, uint turnCostType,
		19		EdgeId[] edges, uint[,] costs, IEnumerable<(string key, string value)> attributes,
		20		IEnumerable<EdgeId>? prefix = null)
	13	21		{
	13	22		prefix ??= ArraySegment<EdgeId>.Empty;
		23
	13	24		if (edges.Length > OrderCoder.MaxOrderHeadTail)
	0	25		{
	0	26		throw new ArgumentException(
	0	27		$"Cannot add turn costs for vertices with more than {OrderCoder.MaxOrderHeadTail} edges.");
		28		}
		29
		30		// enumerate the edges associated with the vertex.
	13	31		var enumerator = new NetworkTileEnumerator();
	13	32		enumerator.MoveTo(this);
	13	33		if (!enumerator.MoveTo(vertex))
	0	34		{
	0	35		throw new ArgumentException($"Cannot add turn costs to a vertex that doesn't exist.",
	0	36		nameof(vertex));
		37		}
		38
		39		// determine max existing order, perhaps there are other turn costs already.
	13	40		var orders = new byte?[edges.Length];
	13	41		var max = -1;
	39	42		while (enumerator.MoveNext())
	26	43		{
	48	44		if (!enumerator.TailOrder.HasValue) continue;
	4	45		if (enumerator.TailOrder.Value <= max) continue;
		46
	4	47		max = enumerator.TailOrder.Value;
	4	48		}
		49
		50		// assign missing orders if any.
	13	51		enumerator.Reset();
	13	52		var next = max + 1;
	39	53		while (enumerator.MoveNext())
	26	54		{
		55		// only assign orders of edges that are used.
	26	56		var i = Array.IndexOf(edges, enumerator.EdgeId);
	26	57		if (i == -1) continue;
		58
		59		// edge is used, assign or reuse existing.
	26	60		var order = enumerator.TailOrder;
	26	61		if (order == null)
	22	62		{
		63		// get next order.
	22	64		order = (byte)next;
	22	65		next++;
		66
		67		// set order, it's different.
	22	68		if (enumerator.Forward)
	11	69		{
		70		// if the edge is forward the tail in the enumerator is also the tail in the edge.
	11	71		this.SetTailHeadOrder(enumerator.EdgePointer, order, enumerator.HeadOrder);
	11	72		}
		73		else
	11	74		{
		75		// if the edge is backward the tail in the enumerator is head in the edge.
	11	76		this.SetTailHeadOrder(enumerator.EdgePointer, enumerator.TailOrder, order);
	11	77		}
	22	78		}
		79
	26	80		orders[i] = order;
	26	81		}
		82
		83		// reversed order array.
	13	84		var count = next;
	13	85		var reversedOrders = new byte?[count];
	78	86		for (var i = 0; i < orders.Length; i++)
	26	87		{
	26	88		var order = orders[i];
	26	89		if (order == null)
	0	90		{
	0	91		continue;
		92		}
		93
	26	94		reversedOrders[order.Value] = (byte)i;
	26	95		}
		96
		97		// make sure there is space in the pointers table.
		98		// and initialize new slots with null.
	24	99		while (_turnCostPointers.Length <= vertex.LocalId)
	11	100		{
	11	101		_turnCostPointers.Resize(_nextVertexId);
	11	102		}
		103
		104		// make sure there is space in the turn cost array.
		105		// and initialize new slots with null.
	13	106		var maxLength = _turnCostPointer + 5 + 1 + (count * count * 5) + 5;
	37	107		while (_turnCosts.Length <= maxLength)
	24	108		{
	24	109		_turnCosts.Resize(_turnCosts.Length + DefaultSizeIncrease);
	24	110		}
		111
		112		// update pointer to reflect new data.
	13	113		var previousPointer = _turnCostPointers[vertex.LocalId].DecodeNullableData();
	13	114		_turnCostPointers[vertex.LocalId] = _turnCostPointer.EncodeToNullableData();
		115
		116		// write turn cost types.
	13	117		_turnCostPointer += (uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, turnCostType);
		118
		119		// write attributes.
	13	120		var a = this.SetAttributes(attributes);
	13	121		_turnCostPointer += (uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, a);
		122
		123		// write prefix sequence.
	13	124		var prefixEdges = new List<EdgeId>(prefix);
	13	125		_turnCostPointer += (uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, (uint)prefixEdges.Count);
	39	126		foreach (var prefixEdge in prefixEdges)
	0	127		{
	0	128		if (prefixEdge.TileId == _tileId)
	0	129		{
	0	130		_turnCostPointer += (uint)_turnCosts.SetDynamicInt32(_turnCostPointer, (int)prefixEdge.LocalId);
	0	131		}
		132		else
	0	133		{
	0	134		_turnCostPointer += (uint)_turnCosts.SetDynamicInt32(_turnCostPointer, (int)-(prefixEdge.LocalId + 1));
	0	135		_turnCostPointer += (uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, prefixEdge.TileId);
	0	136		}
	0	137		}
		138
		139		// write turn costs.
	13	140		_turnCosts[_turnCostPointer] = (byte)count;
	13	141		_turnCostPointer++;
	78	142		for (var x = 0; x < count; x++)
	26	143		{
	26	144		var xOrder = reversedOrders[x];
	156	145		for (var y = 0; y < count; y++)
	52	146		{
	52	147		var yOrder = reversedOrders[y];
		148
		149		// get cost from original matrix.
	52	150		uint cost = 0;
	52	151		if (xOrder != null && yOrder != null)
	52	152		{
	52	153		cost = costs[xOrder.Value, yOrder.Value];
	52	154		}
		155
		156		// write cost.
	52	157		_turnCostPointer += (uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, cost);
	52	158		}
	26	159		}
		160
		161		// write previous turn cost pointer at the end.
	13	162		_turnCostPointer +=
	13	163		(uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, previousPointer.EncodeAsNullableData());
	13	164		}
		165
		166		internal IEnumerable<(uint turnCostType, IEnumerable<(string key, string value)> attributes, uint cost,
		167		IEnumerable<EdgeId> prefixEdges)>
		168		GetTurnCosts(VertexId vertex, byte fromOrder, byte toOrder)
	21	169		{
	21	170		if (_turnCostPointers.Length <= vertex.LocalId)
	0	171		{
	0	172		yield break;
		173		}
		174
	21	175		var pointerNullable = _turnCostPointers[vertex.LocalId].DecodeNullableData();
	21	176		if (pointerNullable == null)
	0	177		{
	0	178		yield break;
		179		}
		180
	21	181		var pointer = pointerNullable.Value;
	25	182		while (true)
	25	183		{
		184		// return turn cost type.
	25	185		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var turnCostType);
		186
		187		// read attributes.
	25	188		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var a);
	25	189		var attributes = this.GetAttributes(a);
		190
		191		// read prefix edges.
	25	192		IEnumerable<EdgeId> prefixEdges = ArraySegment<EdgeId>.Empty;
	25	193		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var prefixEdgeCount);
	25	194		if (prefixEdgeCount > 0)
	0	195		{
	0	196		var prefixEdgesList = new List<EdgeId>();
	0	197		while (prefixEdgeCount > 0)
	0	198		{
	0	199		pointer += (uint)_turnCosts.GetDynamicInt32(pointer, out var signedLocalId);
	0	200		if (signedLocalId >= 0)
	0	201		{
	0	202		prefixEdgesList.Add(new EdgeId(this.TileId, (uint)signedLocalId));
	0	203		}
		204		else
	0	205		{
	0	206		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var tileId);
	0	207		prefixEdgesList.Add(new EdgeId(tileId, (uint)-signedLocalId - 1));
	0	208		}
		209
	0	210		prefixEdgeCount--;
	0	211		}
		212
	0	213		prefixEdges = prefixEdgesList;
	0	214		}
		215
		216		// read turn cost table.
	25	217		var max = _turnCosts[pointer];
	25	218		pointer++;
		219
	126	220		for (var x = 0; x < max; x++)
	46	221		{
	252	222		for (var y = 0; y < max; y++)
	88	223		{
	88	224		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var cost);
	88	225		if (fromOrder != x || toOrder != y)
	63	226		{
	63	227		continue;
		228		}
		229
	25	230		if (cost != 0)
	23	231		{
	23	232		yield return (turnCostType, attributes, cost, prefixEdges);
	15	233		}
	17	234		}
	38	235		}
		236
		237		// get pointer to next turn cost table.
	17	238		_turnCosts.GetDynamicUInt32(pointer, out var p);
	17	239		pointerNullable = p.DecodeNullableData();
	17	240		if (pointerNullable == null)
	13	241		{
	13	242		break;
		243		}
		244
	4	245		pointer = pointerNullable.Value;
	4	246		}
	13	247		}
		248
		249		private void SetTailHeadOrder(uint pointer, byte? tailOrder, byte? headOrder)
	22	250		{
		251		// skip over vertices and next-pointers.
	22	252		var size = this.DecodeVertex(pointer, out _, out var t1);
	22	253		pointer += size;
	22	254		size = this.DecodeVertex(pointer, out _, out var t2);
	22	255		pointer += size;
	22	256		size = this.DecodePointer(pointer, out _);
	22	257		pointer += size;
	22	258		size = this.DecodePointer(pointer, out _);
	22	259		pointer += size;
		260
		261		// skip edge id if needed.
	22	262		if (t1 != t2)
	0	263		{
	0	264		size = (uint)_edges.GetDynamicUInt32(pointer, out _);
	0	265		pointer += size;
	0	266		}
		267
		268		// skip over length/type.
	22	269		size = this.DecodeEdgePointerId(pointer, out _);
	22	270		pointer += size;
	22	271		size = this.DecodeEdgePointerId(pointer, out _);
	22	272		pointer += size;
		273
		274		// get existing head/tail order.
	22	275		byte? existingTailOrder = null;
	22	276		byte? existingHeadOrder = null;
	22	277		this.GetTailHeadOrder(pointer, ref existingTailOrder, ref existingHeadOrder);
		278
		279		// set tail order if there is a value.
	22	280		if (tailOrder.HasValue)
	11	281		{
	11	282		if (existingTailOrder.HasValue && existingTailOrder.Value != tailOrder.Value)
	0	283		throw new InvalidOperationException("An edge tail or head order can only be set once.");
	11	284		existingTailOrder = tailOrder;
	11	285		}
		286
		287		// set head order if there is a value.
	22	288		if (headOrder.HasValue)
	11	289		{
	11	290		if (existingHeadOrder.HasValue && existingHeadOrder.Value != headOrder.Value)
	0	291		throw new InvalidOperationException("An edge tail or head order can only be set once.");
	11	292		existingHeadOrder = headOrder;
	11	293		}
		294
	22	295		_edges.SetTailHeadOrder(pointer, existingTailOrder, existingHeadOrder);
	22	296		}
		297
		298		private void WriteTurnCostsTo(Stream stream)
	8	299		{
	8	300		stream.WriteVarUInt32((uint)_turnCostPointers.Length);
	16	301		for (var i = 0; i < _turnCostPointers.Length; i++)
	0	302		{
	0	303		stream.WriteVarUInt32(_turnCostPointers[i]);
	0	304		}
		305
	8	306		stream.WriteVarUInt32(_turnCostPointer);
	16	307		for (var i = 0; i < _turnCostPointer; i++)
	0	308		{
	0	309		stream.WriteByte(_turnCosts[i]);
	0	310		}
	8	311		}
		312
		313		private void ReadTurnCostsFrom(Stream stream)
	8	314		{
	8	315		var turnCostPointersSize = stream.ReadVarUInt32();
	8	316		_turnCostPointers.Resize(turnCostPointersSize);
	16	317		for (var i = 0; i < turnCostPointersSize; i++)
	0	318		{
	0	319		_turnCostPointers[i] = stream.ReadVarUInt32();
	0	320		}
		321
	8	322		_turnCostPointer = stream.ReadVarUInt32();
	8	323		_turnCosts.Resize(_turnCostPointer);
	16	324		for (var i = 0; i < _turnCostPointer; i++)
	0	325		{
	0	326		_turnCosts[i] = (byte)stream.ReadByte();
	0	327		}
	8	328		}
		329		}