< 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.Diffs.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:	909
Uncovered lines:	287
Coverable lines:	1196
Total lines:	1891
Line coverage:	76% (909 of 1196)
Covered branches:	284
Total branches:	370
Branch coverage:	76.7% (284 of 370)
Tag:	263_26948838820

Metrics

Method	Branch coverage	Cyclomatic complexity	Line coverage
.ctor(...)	100%	1	100%
SetAttributes(...)	83.33%	12	80%
GetGlobalEdgeId(...)	50%	4	100%
GetAttributes()	87.5%	8	80%
AddOrGetString(...)	100%	6	100%
WriteAttributesTo(...)	100%	4	100%
ReadAttributesFrom(...)	100%	4	100%
ReadAttributesFrom(...)	0%	2	0%
WriteAttributesTo(...)	0%	2	0%
.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(...)	80.76%	26	91.54%
DeleteEdge(...)	100%	2	100%
IsEdgeDeleted(...)	100%	2	100%
get_HasDeletedEdges()	100%	1	100%
RemoveDeletedEdges()	83.33%	24	88.88%
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(...)	100%	2	100%
GetTailHeadOrder(...)	100%	1	100%
DecodeEdgePointerId(...)	100%	1	100%
WriteEdgesAndVerticesTo(...)	83.33%	6	82.35%
ReadEdgesAndVerticesFrom(...)	83.33%	6	85%
ReadEdgesAndVerticesFrom(...)	0%	4	0%
WriteEdgesAndVerticesTo(...)	0%	4	0%
.ctor(...)	100%	1	100%
get_MaxLonDiff()	100%	1	100%
get_MaxLatDiff()	100%	1	100%
InvalidateDiffs()	100%	1	100%
EnsureDiffs(...)	80%	50	87.69%
.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%
ReadGeoFrom(...)	0%	2	0%
WriteGeoTo(...)	0%	2	0%
WriteTo(...)	100%	1	100%
ReadFrom(...)	50%	2	86.66%
ReadFromBuffer(...)	0%	2	0%
ReadFrom(...)	100%	1	0%
ToBytes()	0%	2	0%
WriteToBuffer(...)	100%	1	0%
GetSerializedSizeUpperBound()	0%	4	0%
.ctor(...)	100%	1	100%
AddTurnCosts(...)	85%	40	81.44%
GetTurnCosts()	68.18%	22	63.79%
SetTailHeadOrder(...)	85.71%	14	94.28%
WriteTurnCostsTo(...)	50%	4	50%
ReadTurnCostsFrom(...)	50%	4	57.14%
ReadTurnCostsFrom(...)	0%	2	0%
WriteTurnCostsTo(...)	0%	2	0%

File(s)

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

	#	Line		Line coverage
		1		using System;
		2		using System.Collections.Generic;
		3		using System.IO;
		4		using Itinero.Data;
		5		using Itinero.IO;
		6		using Itinero.Network.Storage;
		7		using Itinero.Network.Tiles.Standalone.Global;
		8
		9		namespace Itinero.Network.Tiles;
		10
		11		internal partial class NetworkTile
		12		{
		13		/// <summary>
		14		/// Stores the attributes, starting with the number of attributes and then alternating key-value pairs.
		15		/// </summary>
		16		private byte[] _attributes;
		17
	624	18		private uint _nextAttributePointer = 0;
		19
		20		/// <summary>
		21		/// Stores each string once.
		22		/// </summary>
		23		private string[] _strings;
		24
	624	25		private uint _nextStringId = 0;
		26
		27		private uint SetAttributes(IEnumerable<(string key, string value)> attributes, GlobalEdgeId? globalEdgeId)
	57472	28		{
		29		// ensure enough space for the globalEdgeId header (up to 20 bytes).
	57472	30		if (_attributes.Length <= _nextAttributePointer + 20)
	1645	31		{
	1645	32		Array.Resize(ref _attributes, _attributes.Length + 256);
	1645	33		}
		34
		35		// save position before globalEdgeId — GetAttributes/GetGlobalEdgeId read from here.
	57472	36		var start = _nextAttributePointer;
		37
	57472	38		if (globalEdgeId == null)
	57406	39		{
	57406	40		_nextAttributePointer += _attributes.SetDynamicInt64Nullable(_nextAttributePointer, null);
	57406	41		}
		42		else
	66	43		{
	66	44		_nextAttributePointer += _attributes.SetDynamicInt64Nullable(_nextAttributePointer, globalEdgeId.Value.EdgeI
	66	45		_nextAttributePointer += _attributes.SetDynamicUInt32(_nextAttributePointer, globalEdgeId.Value.Tail);
	66	46		_nextAttributePointer += _attributes.SetDynamicUInt32(_nextAttributePointer, globalEdgeId.Value.Head);
	66	47		}
		48
	57472	49		long cPos = _nextAttributePointer;
	57472	50		long p = _nextAttributePointer + 1;
	57472	51		var c = 0;
	659460	52		foreach (var (key, value) in attributes)
	243522	53		{
	243522	54		if (_attributes.Length <= p + 16)
	1315	55		{
	1315	56		Array.Resize(ref _attributes, _attributes.Length + 256);
	1315	57		}
		58
	243522	59		var id = this.AddOrGetString(key);
	243522	60		p += _attributes.SetDynamicUInt32(p, id);
	243522	61		id = this.AddOrGetString(value);
	243522	62		p += _attributes.SetDynamicUInt32(p, id);
		63
	243522	64		c++;
	243522	65		if (c == 255)
	0	66		{
	0	67		_attributes[(int)cPos] = 255;
	0	68		c = 0;
	0	69		cPos = p;
	0	70		p++;
	0	71		}
	243522	72		}
		73
	57472	74		if (_attributes.Length <= cPos)
	0	75		{
	0	76		Array.Resize(ref _attributes, _attributes.Length + 256);
	0	77		}
		78
	57472	79		_attributes[(int)cPos] = (byte)c;
		80
	57472	81		_nextAttributePointer = (uint)p;
		82
	57472	83		return start;
	57472	84		}
		85
		86		internal GlobalEdgeId? GetGlobalEdgeId(uint? pointer)
	41	87		{
	41	88		if (pointer == null) return null;
		89
	41	90		var p = pointer.Value;
	41	91		p += _attributes.GetDynamicInt64Nullable(p, out var edgeId);
	41	92		if (edgeId == null) return null;
	41	93		p += _attributes.GetDynamicUInt32(p, out var tail);
	41	94		p += _attributes.GetDynamicUInt32(p, out var head);
		95
	41	96		return GlobalEdgeId.Create(edgeId.Value, tail, head);
	41	97		}
		98
		99		internal IEnumerable<(string key, string value)> GetAttributes(uint? pointer)
	2667	100		{
	3162	101		if (pointer == null) yield break;
		102
	2172	103		var p = pointer.Value;
	2172	104		p += _attributes.GetDynamicInt64Nullable(p, out var edgeId);
	2172	105		if (edgeId != null)
	0	106		{
	0	107		p += _attributes.GetDynamicUInt32(p, out _);
	0	108		p += _attributes.GetDynamicUInt32(p, out _);
	0	109		}
		110
		111		int count;
		112		do
	2172	113		{
	2172	114		count = _attributes[(int)p];
	2172	115		p++;
		116
	28206	117		for (var i = 0; i < count; i++)
	12224	118		{
	12224	119		p += _attributes.GetDynamicUInt32(p, out var keyId);
	12224	120		p += _attributes.GetDynamicUInt32(p, out var valId);
		121
	12224	122		yield return (_strings[(int)keyId], _strings[(int)valId]);
	11931	123		}
	3758	124		} while (count == 255);
	1879	125		}
		126
		127		private uint AddOrGetString(string s)
	487044	128		{
	58386492	129		for (uint i = 0; i < _nextStringId; i++)
	29176694	130		{
	29176694	131		var existing = _strings[(int)i];
	29176694	132		if (existing == s)
	470492	133		{
	470492	134		return i;
		135		}
	28706202	136		}
		137
	16552	138		if (_strings.Length <= _nextStringId)
	387	139		{
	387	140		Array.Resize(ref _strings, _strings.Length + 256);
	387	141		}
		142
	16552	143		var id = _nextStringId;
	16552	144		_nextStringId++;
		145
	16552	146		_strings[(int)id] = s;
	16552	147		return id;
	487044	148		}
		149
		150		private void WriteAttributesTo(Stream stream)
	8	151		{
	8	152		stream.WriteVarUInt32(_nextAttributePointer);
	44	153		for (var i = 0; i < _nextAttributePointer; i++)
	14	154		{
	14	155		stream.WriteByte(_attributes[i]);
	14	156		}
		157
	8	158		stream.WriteVarUInt32(_nextStringId);
	36	159		for (var i = 0; i < _nextStringId; i++)
	10	160		{
	10	161		stream.WriteWithSize(_strings[i]);
	10	162		}
	8	163		}
		164
		165		private void ReadAttributesFrom(Stream stream)
	8	166		{
	8	167		_nextAttributePointer = stream.ReadVarUInt32();
	8	168		Array.Resize(ref _attributes, (int)_nextAttributePointer);
	44	169		for (var i = 0; i < _nextAttributePointer; i++)
	14	170		{
	14	171		_attributes[i] = (byte)stream.ReadByte();
	14	172		}
		173
	8	174		_nextStringId = stream.ReadVarUInt32();
	8	175		Array.Resize(ref _strings, (int)_nextStringId);
	36	176		for (var i = 0; i < _nextStringId; i++)
	10	177		{
	10	178		_strings[i] = stream.ReadWithSizeString();
	10	179		}
	8	180		}
		181
		182		private void ReadAttributesFrom(byte[] data, ref int offset)
	0	183		{
	0	184		_nextAttributePointer = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	185		Array.Resize(ref _attributes, (int)_nextAttributePointer);
	0	186		Buffer.BlockCopy(data, offset, _attributes, 0, (int)_nextAttributePointer);
	0	187		offset += (int)_nextAttributePointer;
		188
	0	189		_nextStringId = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	190		Array.Resize(ref _strings, (int)_nextStringId);
	0	191		for (var i = 0; i < _nextStringId; i++)
	0	192		{
	0	193		_strings[i] = BitCoderBuffer.GetWithSizeString(data, ref offset);
	0	194		}
	0	195		}
		196
		197		private void WriteAttributesTo(byte[] data, ref int offset)
	0	198		{
	0	199		BitCoderBuffer.SetVarUInt32(data, ref offset, _nextAttributePointer);
	0	200		Buffer.BlockCopy(_attributes, 0, data, offset, (int)_nextAttributePointer);
	0	201		offset += (int)_nextAttributePointer;
		202
	0	203		BitCoderBuffer.SetVarUInt32(data, ref offset, _nextStringId);
	0	204		for (var i = 0; i < _nextStringId; i++)
	0	205		{
	0	206		BitCoderBuffer.SetWithSizeString(data, ref offset, _strings[i]);
	0	207		}
	0	208		}
		209		}

/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.Tiles.Standalone.Global;
		7		using Itinero.Network.TurnCosts;
		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
	624	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 uint[] _pointers;
		25		private uint _nextCrossTileId; // the next id for an edge that crosses tile boundaries.
		26		private uint[] _crossEdgePointers; // points to the cross tile boundary edges.
		27
		28		// the next edge id.
	624	29		private uint _nextEdgeId = 0;
		30
		31		// the edges.
		32		private 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>
	608	40		public NetworkTile(int zoom, uint tileId, Guid? edgeTypeMapId = null)
	608	41		{
	608	42		_zoom = zoom;
	608	43		_tileId = tileId;
	608	44		_edgeTypeMapId = edgeTypeMapId ?? Guid.Empty;
	608	45		_nextCrossTileId = 0;
		46
	608	47		_pointers = new uint[0];
	608	48		_edges = new byte[0];
	608	49		_crossEdgePointers = new uint[0];
		50
	608	51		_coordinates = new byte[0];
	608	52		_shapes = new byte[0];
	608	53		_attributes = new byte[0];
	608	54		_strings = new string[0];
	608	55		}
		56
	16	57		private NetworkTile(int zoom, uint tileId, Guid edgeTypeMapId, uint nextCrossTileId, uint[] pointers,
	16	58		byte[] edges,
	16	59		uint[] crossEdgePointers, byte[] coordinates, byte[] shapes,
	16	60		byte[] attributes,
	16	61		string[] strings, 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, (uint[])_pointers.Clone(), (byte[])_edges.Clone(),
	10	93		(uint[])_crossEdgePointers.Clone(),
	10	94		(byte[])_coordinates.Clone(), (byte[])_shapes.Clone(), (byte[])_attributes.Clone(), (string[])_strings.Clone
	10	95		_nextVertexId,
	10	96		_nextEdgeId, _nextAttributePointer, _nextShapePointer, _nextStringId);
	10	97		}
		98
		99		/// <summary>
		100		/// Gets the tile id.
		101		/// </summary>
	15462826	102		public uint TileId => _tileId;
		103
		104		/// <summary>
		105		/// Gets the number of vertices.
		106		/// </summary>
	3794619	107		public uint VertexCount => _nextVertexId;
		108
		109		/// <summary>
		110		/// Gets the edge type map id.
		111		/// </summary>
	4221241	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)
	37718	122		{
		123		// set coordinate.
	37718	124		this.SetCoordinate(_nextVertexId, longitude, latitude, e);
		125
		126		// create id.
	37718	127		var vertexId = new VertexId(_tileId, _nextVertexId);
	37718	128		_nextVertexId++;
		129
		130		// make room.
	37718	131		ArrayBaseExtensions.EnsureMinimumSize(ref _pointers, vertexId.LocalId, DefaultSizeIncrease);
		132
	37718	133		return vertexId;
	37718	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)
	110	142		{
	110	143		if (vertex.LocalId >= _nextVertexId)
	22	144		{
	22	145		return false;
		146		}
		147
	88	148		return true;
	110	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)
	5612335	160		{
	5612335	161		longitude = default;
	5612335	162		latitude = default;
	5612335	163		elevation = null;
	5612335	164		if (vertex.LocalId >= _nextVertexId)
	5	165		{
	5	166		return false;
		167		}
		168
	5612330	169		this.GetCoordinate(vertex.LocalId, out longitude, out latitude, out elevation);
	5612330	170		return true;
	5612335	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		/// <param name="globalEdgeId">The global edge id, if any.</param>
		184		/// <returns>The new edge id.</returns>
		185		public EdgeId AddEdge(VertexId vertex1, VertexId vertex2,
		186		IEnumerable<(double longitude, double latitude, float? e)>? shape = null,
		187		IEnumerable<(string key, string value)>? attributes = null, EdgeId? edgeId = null, uint? edgeTypeId = null,
		188		uint? length = null, GlobalEdgeId? globalEdgeId = null)
	53036	189		{
		190		// Edge set changed → cached MaxLonDiff/MaxLatDiff are now stale.
	53036	191		this.InvalidateDiffs();
		192
	53036	193		if (vertex2.TileId != _tileId)
	2343	194		{
		195		// this edge crosses tiles boundaries, it need special treatment and a stable id.
		196		// because the edge originates in this tile, this tile is responsible for generating the id.
	2343	197		if (edgeId != null) throw new ArgumentException(
	0	198		"The edge id shouldn't be a given, it should be generated by the originating tile.",
	0	199		nameof(edgeId));
	2343	200		if (vertex1.TileId != _tileId) throw new ArgumentException("None of the two vertices in this edge are in thi
	0	201		nameof(vertex1));
		202
		203		// generate a new cross tile id and store pointer to edge.
	2343	204		edgeId = EdgeId.CrossEdgeId(_tileId, _nextCrossTileId);
	2343	205		ArrayBaseExtensions.EnsureMinimumSize(ref _crossEdgePointers, _nextCrossTileId + 1);
	2343	206		_crossEdgePointers[_nextCrossTileId] = _nextEdgeId;
	2343	207		_nextCrossTileId++;
	2343	208		}
	50693	209		else if (vertex1.TileId != _tileId)
	2342	210		{
		211		// this edge crosses tiles boundaries, it need special treatment and a stable id.
		212		// because the edge originates in another tile it should already have an id.
	2342	213		if (edgeId == null) throw new ArgumentException(
	0	214		"Cannot add an edge that doesn't start in this tile without a proper edge id.",
	0	215		nameof(edgeId));
	2342	216		if (edgeId.Value.TileId != vertex1.TileId) throw new ArgumentException("The edge id doesn't match the tile i
	0	217		nameof(edgeId));
	2342	218		}
		219		else
	48351	220		{
		221		// this edge starts in this tile, it get an id from this tile.
	48351	222		edgeId = new EdgeId(_tileId, _nextEdgeId);
	48351	223		}
		224
		225		// write the edge data.
	53036	226		var newEdgePointer = _nextEdgeId;
	53036	227		var size = EncodeVertex(ref _edges, _tileId, _nextEdgeId, vertex1);
	53036	228		_nextEdgeId += size;
	53036	229		size = EncodeVertex(ref _edges, _tileId, _nextEdgeId, vertex2);
	53036	230		_nextEdgeId += size;
		231
		232		// get previous pointers if vertex already has edges
		233		// set the new pointers.
	53036	234		uint? v1p = null;
	53036	235		if (vertex1.TileId == _tileId)
	50694	236		{
	50694	237		v1p = _pointers[vertex1.LocalId].DecodeNullableData();
	50694	238		_pointers[vertex1.LocalId] = newEdgePointer.EncodeToNullableData();
	50694	239		}
		240
	53036	241		uint? v2p = null;
	53036	242		if (vertex2.TileId == _tileId)
	50693	243		{
	50693	244		v2p = _pointers[vertex2.LocalId].DecodeNullableData();
	50693	245		_pointers[vertex2.LocalId] = newEdgePointer.EncodeToNullableData();
	50693	246		}
		247
		248		// set next pointers.
	53036	249		size = EncodePointer(ref _edges, _nextEdgeId, v1p);
	53036	250		_nextEdgeId += size;
	53036	251		size = EncodePointer(ref _edges, _nextEdgeId, v2p);
	53036	252		_nextEdgeId += size;
		253
		254		// write edge id explicitly if not in this edge.
	53036	255		if (vertex1.TileId != vertex2.TileId)
	4685	256		{
		257		// this data will only be there for edges crossing tile boundaries.
	4685	258		_nextEdgeId += (uint)_edges.SetDynamicUInt32(_nextEdgeId,
	4685	259		edgeId.Value.LocalId - EdgeId.MinCrossId);
	4685	260		}
		261
		262		// write edge profile id.
	53036	263		_nextEdgeId += SetDynamicUIn32Nullable(ref _edges, _nextEdgeId, edgeTypeId);
		264
		265		// write length.
	53036	266		_nextEdgeId += SetDynamicUIn32Nullable(ref _edges, _nextEdgeId, length);
		267
		268		// set tail and head order.
	53036	269		_edges.SetTailHeadOrder(_nextEdgeId, null, null);
	53036	270		_nextEdgeId++;
		271
		272		// take care of shape if any.
	53036	273		uint? shapePointer = null;
	53036	274		if (shape != null)
	52565	275		{
	52565	276		shapePointer = this.SetShape(shape);
	52565	277		}
		278
	53036	279		size = EncodePointer(ref _edges, _nextEdgeId, shapePointer);
	53036	280		_nextEdgeId += size;
		281
		282		// take care of attributes if any.
	53036	283		uint? attributesPointer = null;
	53036	284		if (attributes != null || globalEdgeId != null)
	52673	285		{
	52673	286		attributesPointer = this.SetAttributes(attributes ?? [], globalEdgeId);
	52673	287		}
		288
	53036	289		size = EncodePointer(ref _edges, _nextEdgeId, attributesPointer);
	53036	290		_nextEdgeId += size;
		291
	53036	292		return edgeId.Value;
	53036	293		}
		294
		295		private HashSet<EdgeId>? _deletedEdges;
		296
		297		/// <summary>
		298		/// Marks the given edge as deleted.
		299		/// </summary>
		300		/// <param name="edge">The edge to delete.</param>
		301		internal void DeleteEdge(EdgeId edge)
	10	302		{
	10	303		_deletedEdges ??= [];
	10	304		_deletedEdges.Add(edge);
	10	305		this.InvalidateDiffs();
	10	306		}
		307
		308		/// <summary>
		309		/// Returns true if the edge is deleted.
		310		/// </summary>
		311		/// <param name="edge">The edge.</param>
		312		/// <returns>True if the edge was deleted.</returns>
		313		internal bool IsEdgeDeleted(EdgeId edge)
	6466583	314		{
	12933160	315		if (_deletedEdges == null) return false;
		316
	6	317		return _deletedEdges.Contains(edge);
	6466583	318		}
		319
		320		/// <summary>
		321		/// Returns true if there are deleted edges.
		322		/// </summary>
	500	323		internal bool HasDeletedEdges => _deletedEdges != null;
		324
		325		/// <summary>
		326		/// Removes all the deleted edges.
		327		/// </summary>
		328		/// <remarks>This changes all the edges if all edges written after a deleted edge.</remarks>
		329		internal void RemoveDeletedEdges()
	10	330		{
	10	331		if (_deletedEdges == null) return;
	10	332		this.InvalidateDiffs();
		333
		334		// reset vertex pointers.
	340	335		for (var i = 0; i < _pointers.Length; i++)
	160	336		{
	160	337		_pointers[i] = 0;
	160	338		}
		339
		340		// redo edges, skipping deleted edges.
	10	341		var nextEdgeId = _nextEdgeId;
	10	342		var p = 0U;
	10	343		var newP = 0U;
	24	344		while (p < nextEdgeId)
	14	345		{
		346		// read edge data.
	14	347		var currentEdgeId = p;
	14	348		p += this.DecodeVertex(p, out var local1Id, out var tile1Id);
	14	349		var vertex1 = new VertexId(tile1Id, local1Id);
	14	350		p += this.DecodeVertex(p, out var local2Id, out var tile2Id);
	14	351		var vertex2 = new VertexId(tile2Id, local2Id);
	14	352		p += this.DecodePointer(p, out _);
	14	353		p += this.DecodePointer(p, out _);
	14	354		uint? crossEdgeId = null;
	14	355		if (tile1Id != tile2Id)
	4	356		{
	4	357		p += _edges.GetDynamicUInt32(p, out var c);
	4	358		crossEdgeId = c;
	4	359		}
		360
	14	361		p += _edges.GetDynamicUInt32Nullable(p, out var edgeTypeId);
	14	362		p += _edges.GetDynamicUInt32Nullable(p, out var length);
	14	363		var tailHeadOrder = _edges[p];
	14	364		p++;
	14	365		p += this.DecodePointer(p, out var shapePointer);
	14	366		p += this.DecodePointer(p, out var attributePointer);
		367
		368		// check if edge was deleted.
	20	369		if (_deletedEdges.Contains(new EdgeId(_tileId, currentEdgeId))) continue;
	8	370		if (crossEdgeId.HasValue)
	4	371		{
	8	372		if (_deletedEdges.Contains(EdgeId.CrossEdgeId(vertex1.TileId, crossEdgeId.Value))) continue;
	0	373		}
		374
		375		// no need to overwrite identical data.
	4	376		if (p == newP) continue;
		377
		378		// write edge data again.
	4	379		var newEdgePointer = newP;
	4	380		newP += EncodeVertex(ref _edges, _tileId, newP, vertex1);
	4	381		newP += EncodeVertex(ref _edges, _tileId, newP, vertex2);
	4	382		uint? v1p = null;
	4	383		if (vertex1.TileId == _tileId)
	4	384		{
	4	385		v1p = _pointers[vertex1.LocalId].DecodeNullableData();
	4	386		_pointers[vertex1.LocalId] = newEdgePointer.EncodeToNullableData();
	4	387		}
		388
	4	389		uint? v2P = null;
	4	390		if (vertex2.TileId == _tileId)
	4	391		{
	4	392		v2P = _pointers[vertex2.LocalId].DecodeNullableData();
	4	393		_pointers[vertex2.LocalId] = newEdgePointer.EncodeToNullableData();
	4	394		}
		395
	4	396		newP += EncodePointer(ref _edges, newP, v1p);
	4	397		newP += EncodePointer(ref _edges, newP, v2P);
	4	398		if (crossEdgeId != null)
	0	399		{
	0	400		newP += (uint)_edges.SetDynamicUInt32(newP, crossEdgeId.Value);
	0	401		if (vertex1.TileId == _tileId)
	0	402		{
	0	403		_crossEdgePointers[crossEdgeId.Value] = newEdgePointer;
	0	404		}
	0	405		}
		406
	4	407		newP += _edges.SetDynamicUInt32Nullable(newP, edgeTypeId);
	4	408		newP += _edges.SetDynamicUInt32Nullable(newP, length);
	4	409		_edges[newP] = tailHeadOrder;
	4	410		newP++;
	4	411		newP += EncodePointer(ref _edges, newP, shapePointer);
	4	412		newP += EncodePointer(ref _edges, newP, attributePointer);
	4	413		}
		414
	10	415		_nextEdgeId = newP;
	10	416		_deletedEdges = null;
	10	417		}
		418
		419		internal NetworkTile CloneForEdgeTypeMap(
		420		(Guid id, Func<IEnumerable<(string key, string value)>, uint> func) edgeTypeMap)
	6	421		{
	6	422		var edges = new byte[_edges.Length];
	6	423		var pointers = new uint[_pointers.Length];
	6	424		var crossEdgePointers = new uint[_crossEdgePointers.Length];
	6	425		var nextEdgeId = _nextEdgeId;
	6	426		var p = 0U;
	6	427		var newP = 0U;
	16	428		while (p < nextEdgeId)
	10	429		{
		430		// read edge data.
	10	431		p += this.DecodeVertex(p, out var local1Id, out var tile1Id);
	10	432		var vertex1 = new VertexId(tile1Id, local1Id);
	10	433		p += this.DecodeVertex(p, out var local2Id, out var tile2Id);
	10	434		var vertex2 = new VertexId(tile2Id, local2Id);
	10	435		p += this.DecodePointer(p, out _);
	10	436		p += this.DecodePointer(p, out _);
	10	437		uint? crossEdgeId = null;
	10	438		if (tile1Id != tile2Id)
	0	439		{
	0	440		p += (uint)_edges.GetDynamicUInt32(p, out var c);
	0	441		crossEdgeId = c;
	0	442		}
		443
	10	444		p += _edges.GetDynamicUInt32Nullable(p, out var _);
	10	445		p += _edges.GetDynamicUInt32Nullable(p, out var length);
	10	446		var tailHeadOrder = _edges[p];
	10	447		p++;
	10	448		p += this.DecodePointer(p, out var shapePointer);
	10	449		p += this.DecodePointer(p, out var attributePointer);
		450
		451		// generate new edge type id.
	10	452		var newEdgeTypeId = edgeTypeMap.func(this.GetAttributes(attributePointer));
		453
		454		// write edge data again.
	10	455		var newEdgePointer = newP;
	10	456		newP += EncodeVertex(ref edges, _tileId, newP, vertex1);
	10	457		newP += EncodeVertex(ref edges, _tileId, newP, vertex2);
	10	458		uint? v1p = null;
	10	459		if (vertex1.TileId == _tileId)
	10	460		{
	10	461		v1p = pointers[vertex1.LocalId].DecodeNullableData();
	10	462		pointers[vertex1.LocalId] = newEdgePointer.EncodeToNullableData();
	10	463		}
		464
	10	465		uint? v2p = null;
	10	466		if (vertex2.TileId == _tileId)
	10	467		{
	10	468		v2p = pointers[vertex2.LocalId].DecodeNullableData();
	10	469		pointers[vertex2.LocalId] = newEdgePointer.EncodeToNullableData();
	10	470		}
		471
	10	472		newP += EncodePointer(ref edges, newP, v1p);
	10	473		newP += EncodePointer(ref edges, newP, v2p);
	10	474		if (crossEdgeId != null)
	0	475		{
	0	476		newP += edges.SetDynamicUInt32(newP, crossEdgeId.Value);
	0	477		if (vertex1.TileId == _tileId)
	0	478		{
	0	479		crossEdgePointers[crossEdgeId.Value] = newEdgePointer;
	0	480		}
	0	481		}
		482
	10	483		newP += edges.SetDynamicUInt32Nullable(newP, newEdgeTypeId);
	10	484		newP += edges.SetDynamicUInt32Nullable(newP, length);
	10	485		edges[newP] = tailHeadOrder;
	10	486		newP++;
	10	487		newP += EncodePointer(ref edges, newP, shapePointer);
	10	488		newP += EncodePointer(ref edges, newP, attributePointer);
	10	489		}
		490
	6	491		return new NetworkTile(_zoom, _tileId, edgeTypeMap.id, _nextCrossTileId, pointers, edges, crossEdgePointers,
	6	492		_coordinates,
	6	493		_shapes, _attributes, _strings, _turnCosts, _nextVertexId, _nextEdgeId,
	6	494		_nextAttributePointer, _nextShapePointer, _nextStringId);
	6	495		}
		496
		497		internal uint VertexEdgePointer(uint vertex)
	1100192	498		{
	1100192	499		return _pointers[vertex];
	1100192	500		}
		501
		502		internal static byte EncodeVertex(ref byte[] edges, uint localTileId, uint location, VertexId vertexId)
	106100	503		{
	106100	504		if (vertexId.TileId == localTileId)
	101415	505		{
		506		// same tile, only store local id.
	101415	507		if (edges.Length <= location + 5)
	12965	508		{
	12965	509		Array.Resize(ref edges, edges.Length + DefaultSizeIncrease);
	12965	510		}
		511
	101415	512		return edges.SetDynamicUInt32(location, vertexId.LocalId);
		513		}
		514
		515		// other tile, store full id.
	4685	516		if (edges.Length <= location + 10)
	2013	517		{
	2013	518		Array.Resize(ref edges, edges.Length + DefaultSizeIncrease);
	2013	519		}
		520
	4685	521		var encodedId = vertexId.Encode();
	4685	522		return edges.SetDynamicUInt64(location, encodedId);
	106100	523		}
		524
		525		internal byte DecodeVertex(uint location, out uint localId, out uint tileId)
	12942474	526		{
	12942474	527		var size = _edges.GetDynamicUInt64(location, out var encodedId);
	12942474	528		if (encodedId < uint.MaxValue)
	12829363	529		{
	12829363	530		localId = (uint)encodedId;
	12829363	531		tileId = _tileId;
	12829363	532		return size;
		533		}
		534
	113111	535		VertexId.Decode(encodedId, out tileId, out localId);
	113111	536		return size;
	12942474	537		}
		538
		539		internal byte DecodeEdgeCrossId(uint location, out uint edgeCrossId)
	113005	540		{
	113005	541		var s = _edges.GetDynamicUInt32(location, out var c);
	113005	542		edgeCrossId = EdgeId.MinCrossId + c;
	113005	543		return s;
	113005	544		}
		545
		546		internal uint GetEdgeCrossPointer(uint edgeCrossId)
	51809	547		{
	51809	548		return _crossEdgePointers[edgeCrossId];
	51809	549		}
		550
		551		internal static byte EncodePointer(ref byte[] edges, uint location, uint? pointer)
	212200	552		{
		553		// TODO: save the diff instead of the full pointer.
	212200	554		if (edges.Length <= location + 5)
	27894	555		{
	27894	556		Array.Resize(ref edges, edges.Length + DefaultSizeIncrease);
	27894	557		}
		558
	212200	559		return edges.SetDynamicUInt32(location,
	212200	560		pointer.EncodeAsNullableData());
	212200	561		}
		562
		563		internal byte DecodePointer(uint location, out uint? pointer)
	14232614	564		{
	14232614	565		var size = _edges.GetDynamicUInt32(location, out var data);
	14232614	566		pointer = data.DecodeNullableData();
	14232614	567		return size;
	14232614	568		}
		569
		570		internal static byte SetDynamicUIn32Nullable(ref byte[] edges, uint pointer, uint? data)
	106072	571		{
	117003	572		while (edges.Length <= pointer + 5)
	10931	573		{
	10931	574		Array.Resize(ref edges, edges.Length + DefaultSizeIncrease);
	10931	575		}
		576
	106072	577		return edges.SetDynamicUInt32Nullable(pointer, data);
	106072	578		}
		579
		580		internal void GetTailHeadOrder(uint location, ref byte? tail, ref byte? head)
	6471212	581		{
	6471212	582		_edges.GetTailHeadOrder(location, ref tail, ref head);
	6471212	583		}
		584
		585		internal byte DecodeEdgePointerId(uint location, out uint? edgeProfileId)
	12942424	586		{
	12942424	587		return _edges.GetDynamicUInt32Nullable(location, out edgeProfileId);
	12942424	588		}
		589
		590		private void WriteEdgesAndVerticesTo(Stream stream)
	8	591		{
		592		// write vertex pointers.
	8	593		stream.WriteVarUInt32(_nextVertexId);
	42	594		for (var i = 0; i < _nextVertexId; i++)
	13	595		{
	13	596		stream.WriteVarUInt32(_pointers[i]);
	13	597		}
		598
		599		// write edges.
	8	600		stream.WriteVarUInt32(_nextEdgeId);
	106	601		for (var i = 0; i < _nextEdgeId; i++)
	45	602		{
	45	603		stream.WriteByte(_edges[i]);
	45	604		}
		605
		606		// write cross edge pointers.
	8	607		stream.WriteVarUInt32(_nextCrossTileId);
	16	608		for (var i = 0; i < _nextCrossTileId; i++)
	0	609		{
	0	610		stream.WriteVarUInt32(_crossEdgePointers[i]);
	0	611		}
	8	612		}
		613
		614		private void ReadEdgesAndVerticesFrom(Stream stream)
	8	615		{
		616		// read vertex pointers.
	8	617		_nextVertexId = stream.ReadVarUInt32();
	8	618		Array.Resize(ref _pointers, (int)_nextVertexId);
	42	619		for (var i = 0; i < _nextVertexId; i++)
	13	620		{
	13	621		_pointers[i] = stream.ReadVarUInt32();
	13	622		}
		623
		624		// read edges.
	8	625		_nextEdgeId = stream.ReadVarUInt32();
	8	626		Array.Resize(ref _edges, (int)_nextEdgeId);
	106	627		for (var i = 0; i < _nextEdgeId; i++)
	45	628		{
	45	629		_edges[i] = (byte)stream.ReadByte();
	45	630		}
		631
		632		// read cross tile edge pointers.
	8	633		_nextCrossTileId = stream.ReadVarUInt32();
	8	634		Array.Resize(ref _crossEdgePointers, (int)_nextCrossTileId);
	16	635		for (var i = 0; i < _nextCrossTileId; i++)
	0	636		{
	0	637		_crossEdgePointers[i] = stream.ReadVarUInt32();
	0	638		}
	8	639		}
		640
		641		private void ReadEdgesAndVerticesFrom(byte[] data, ref int offset)
	0	642		{
	0	643		_nextVertexId = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	644		Array.Resize(ref _pointers, (int)_nextVertexId);
	0	645		for (var i = 0; i < _nextVertexId; i++)
	0	646		{
	0	647		_pointers[i] = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	648		}
		649
	0	650		_nextEdgeId = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	651		Array.Resize(ref _edges, (int)_nextEdgeId);
	0	652		Buffer.BlockCopy(data, offset, _edges, 0, (int)_nextEdgeId);
	0	653		offset += (int)_nextEdgeId;
		654
	0	655		_nextCrossTileId = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	656		Array.Resize(ref _crossEdgePointers, (int)_nextCrossTileId);
	0	657		for (var i = 0; i < _nextCrossTileId; i++)
	0	658		{
	0	659		_crossEdgePointers[i] = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	660		}
	0	661		}
		662
		663		private void WriteEdgesAndVerticesTo(byte[] data, ref int offset)
	0	664		{
	0	665		BitCoderBuffer.SetVarUInt32(data, ref offset, _nextVertexId);
	0	666		for (var i = 0; i < _nextVertexId; i++)
	0	667		{
	0	668		BitCoderBuffer.SetVarUInt32(data, ref offset, _pointers[i]);
	0	669		}
		670
	0	671		BitCoderBuffer.SetVarUInt32(data, ref offset, _nextEdgeId);
	0	672		Buffer.BlockCopy(_edges, 0, data, offset, (int)_nextEdgeId);
	0	673		offset += (int)_nextEdgeId;
		674
	0	675		BitCoderBuffer.SetVarUInt32(data, ref offset, _nextCrossTileId);
	0	676		for (var i = 0; i < _nextCrossTileId; i++)
	0	677		{
	0	678		BitCoderBuffer.SetVarUInt32(data, ref offset, _crossEdgePointers[i]);
	0	679		}
	0	680		}
		681		}

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

	#	Line		Line coverage
		1		namespace Itinero.Network.Tiles;
		2
		3		/// <summary>
		4		/// Per-tile geographic extent bounds used by the tile-bounded snap algorithm
		5		/// in <c>EdgeSearch.SnapInBoxAsync</c>. See
		6		/// <c>src/Itinero/Network/Search/snap-algorithm.md</c> for the design.
		7		///
		8		/// <para>
		9		/// <see cref="MaxLonDiff"/> and <see cref="MaxLatDiff"/> bound how far any
		10		/// edge starting at a vertex in this tile can reach in each axis. They are
		11		/// the maxima of (edge.bbox.maxLon − edge.bbox.minLon) and
		12		/// (edge.bbox.maxLat − edge.bbox.minLat) over every edge with at least one
		13		/// vertex in the tile. Cross-tile edges contribute to both endpoint tiles'
		14		/// diffs (each tile sees them once during its own per-vertex iteration).
		15		/// </para>
		16		///
		17		/// <para>
		18		/// Computed lazily on first access via <see cref="EnsureDiffs"/>, which
		19		/// takes a network reference so that cross-tile edges' remote endpoints
		20		/// can be resolved to their actual coordinates. The lazy contract: the
		21		/// snap path's <c>NotifyBox</c> has already loaded the partner tiles by
		22		/// the time the snap algorithm asks for diffs. If a partner tile somehow
		23		/// isn't loaded, we fall back to the partner tile's geographic bbox
		24		/// (~tile-width-wide over-estimate) — correct but loose.
		25		/// </para>
		26		///
		27		/// <para>
		28		/// Invalidated to <see cref="double.NaN"/> whenever an edge is added or
		29		/// removed, so late boundary edges added by neighbouring tiles'
		30		/// <c>AddStandaloneTile</c> calls don't leave stale values.
		31		/// </para>
		32		/// </summary>
		33		internal partial class NetworkTile
		34		{
	624	35		private double _maxLonDiff = double.NaN;
	624	36		private double _maxLatDiff = double.NaN;
		37
		38		/// <summary>
		39		/// Max lon-span across all edges with a vertex in this tile. Returns
		40		/// <see cref="double.NaN"/> if <see cref="EnsureDiffs"/> hasn't been
		41		/// called yet. Callers should invoke <see cref="EnsureDiffs"/> first.
		42		/// </summary>
	10625	43		public double MaxLonDiff => _maxLonDiff;
		44
		45		/// <summary>
		46		/// Max lat-span across all edges with a vertex in this tile. See
		47		/// <see cref="MaxLonDiff"/>.
		48		/// </summary>
	10625	49		public double MaxLatDiff => _maxLatDiff;
		50
		51		/// <summary>
		52		/// Reset the cached diffs. Call from any mutation that could change
		53		/// the tile's edge set (AddEdge, DeleteEdge, RemoveDeletedEdges).
		54		/// </summary>
		55		private void InvalidateDiffs()
	53056	56		{
	53056	57		_maxLonDiff = double.NaN;
	53056	58		_maxLatDiff = double.NaN;
	53056	59		}
		60
		61		/// <summary>
		62		/// Compute the diffs if not already cached. Takes a network reference
		63		/// so cross-tile edges can resolve their remote endpoint's actual
		64		/// coordinate. If the partner tile isn't loaded, falls back to the
		65		/// partner's geographic bbox (correct but loose).
		66		/// </summary>
		67		internal void EnsureDiffs(Itinero.Network.Enumerators.Edges.IEdgeEnumerable network)
	5393	68		{
	10640	69		if (!double.IsNaN(_maxLonDiff)) return;
		70
		71		// Walk every edge once per endpoint that's in this tile. Intra-tile
		72		// edges are seen twice; max is idempotent so that's fine. Cross-tile
		73		// edges are seen once (from the local endpoint's pointer chain),
		74		// which is enough — the partner tile sees them independently from
		75		// its own side.
	146	76		double maxLon = 0;
	146	77		double maxLat = 0;
		78
	146	79		var enumerator = new NetworkTileEnumerator();
	146	80		enumerator.MoveTo(this);
		81
	52534	82		for (uint v = 0; v < _nextVertexId; v++)
	26121	83		{
	26121	84		var vertexId = new VertexId(_tileId, v);
	26121	85		if (!enumerator.MoveTo(vertexId)) continue;
	26121	86		if (!this.TryGetVertex(vertexId, out var tailLon, out var tailLat, out _)) continue;
		87
	96641	88		while (enumerator.MoveNext())
	70520	89		{
	70520	90		var minLon = tailLon;
	70520	91		var maxLonE = tailLon;
	70520	92		var minLat = tailLat;
	70520	93		var maxLatE = tailLat;
		94
		95		// Resolve the head endpoint's actual coordinate. For
		96		// intra-tile edges it's right here; for cross-tile edges
		97		// we ask the network for the partner tile.
	70520	98		var headResolved = false;
	141040	99		double headLon = 0, headLat = 0;
	70520	100		if (enumerator.Head.TileId == _tileId)
	68138	101		{
	68138	102		if (this.TryGetVertex(enumerator.Head, out headLon, out headLat, out _))
	68138	103		{
	68138	104		headResolved = true;
	68138	105		}
	68138	106		}
		107		else
	2382	108		{
	2382	109		var partnerTile = network.GetTileForRead(enumerator.Head.TileId);
	2382	110		if (partnerTile != null &&
	2382	111		partnerTile.TryGetVertex(enumerator.Head, out headLon, out headLat, out _))
	2382	112		{
	2382	113		headResolved = true;
	2382	114		}
	2382	115		}
		116
	70520	117		if (headResolved)
	70520	118		{
	104478	119		if (headLon < minLon) minLon = headLon;
	70377	120		else if (headLon > maxLonE) maxLonE = headLon;
	104342	121		if (headLat < minLat) minLat = headLat;
	70554	122		else if (headLat > maxLatE) maxLatE = headLat;
	70520	123		}
		124		else
	0	125		{
		126		// Partner tile isn't loaded — fall back to its bbox.
		127		// Over-estimates by up to ~one tile-width but stays
		128		// correct (the per-vertex predicate built on this
		129		// bound will be looser, never wrongly prune).
	0	130		var (hMinLon, hMinLat, hMaxLon, hMaxLat) =
	0	131		TileStatic.GetTileBoundingBox(_zoom, enumerator.Head.TileId);
	0	132		if (hMinLon < minLon) minLon = hMinLon;
	0	133		if (hMaxLon > maxLonE) maxLonE = hMaxLon;
	0	134		if (hMinLat < minLat) minLat = hMinLat;
	0	135		if (hMaxLat > maxLatE) maxLatE = hMaxLat;
	0	136		}
		137
		138		// Shape points (intermediate).
	381010	139		foreach (var (sLon, sLat, _) in enumerator.Shape)
	84725	140		{
	89065	141		if (sLon < minLon) minLon = sLon;
	85039	142		else if (sLon > maxLonE) maxLonE = sLon;
	89925	143		if (sLat < minLat) minLat = sLat;
	83626	144		else if (sLat > maxLatE) maxLatE = sLat;
	84725	145		}
		146
	70520	147		var dLon = maxLonE - minLon;
	70520	148		var dLat = maxLatE - minLat;
	70981	149		if (dLon > maxLon) maxLon = dLon;
	70957	150		if (dLat > maxLat) maxLat = dLat;
	70520	151		}
	26121	152		}
		153
	146	154		_maxLonDiff = maxLon;
	146	155		_maxLatDiff = maxLat;
	5393	156		}
		157		}

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

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

	#	Line		Line coverage
		1		using System;
		2		using System.IO;
		3		using Itinero.IO;
		4
		5		namespace Itinero.Network.Tiles;
		6
		7		internal partial class NetworkTile
		8		{
		9		public void WriteTo(Stream stream)
	8	10		{
		11		const int version = 1;
	8	12		stream.WriteVarInt32(version);
		13
		14		// write tile id/zoom.
	8	15		stream.WriteVarInt32(_zoom);
	8	16		stream.WriteVarUInt32(_tileId);
	8	17		stream.WriteGuid(_edgeTypeMapId);
		18
		19		// write vertices and edges.
	8	20		this.WriteEdgesAndVerticesTo(stream);
		21
		22		// write attributes.
	8	23		this.WriteAttributesTo(stream);
		24
		25		// write shapes.
	8	26		this.WriteGeoTo(stream);
		27
		28		// write turn costs.
	8	29		this.WriteTurnCostsTo(stream);
	8	30		}
		31
		32		public static NetworkTile ReadFrom(Stream stream)
	8	33		{
	8	34		var version = stream.ReadVarInt32();
	8	35		if (version != 1)
	0	36		{
	0	37		throw new InvalidDataException("Cannot deserialize tiles: Invalid version #.");
		38		}
		39
		40		// read tile id.
	8	41		var zoom = stream.ReadVarInt32();
	8	42		var tileId = stream.ReadVarUInt32();
	8	43		var edgeTypeMapId = stream.ReadGuid();
		44
		45		// create the tile.
	8	46		var graphTile = new NetworkTile(zoom, tileId, edgeTypeMapId);
		47
		48		// read vertices and edges.
	8	49		graphTile.ReadEdgesAndVerticesFrom(stream);
		50
		51		// read attributes.
	8	52		graphTile.ReadAttributesFrom(stream);
		53
		54		// read shapes.
	8	55		graphTile.ReadGeoFrom(stream);
		56
		57		// read turn costs.
	8	58		graphTile.ReadTurnCostsFrom(stream);
		59
	8	60		return graphTile;
	8	61		}
		62
		63		internal static NetworkTile ReadFromBuffer(byte[] data, ref int offset)
	0	64		{
	0	65		var version = BitCoderBuffer.GetVarInt32(data, ref offset);
	0	66		if (version != 1)
	0	67		{
	0	68		throw new InvalidDataException("Cannot deserialize tiles: Invalid version #.");
		69		}
		70
	0	71		var zoom = BitCoderBuffer.GetVarInt32(data, ref offset);
	0	72		var tileId = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	73		var edgeTypeMapId = BitCoderBuffer.GetGuid(data, ref offset);
		74
	0	75		var graphTile = new NetworkTile(zoom, tileId, edgeTypeMapId);
		76
	0	77		graphTile.ReadEdgesAndVerticesFrom(data, ref offset);
	0	78		graphTile.ReadAttributesFrom(data, ref offset);
	0	79		graphTile.ReadGeoFrom(data, ref offset);
	0	80		graphTile.ReadTurnCostsFrom(data, ref offset);
		81
	0	82		return graphTile;
	0	83		}
		84
		85		public static NetworkTile ReadFrom(byte[] data, int offset)
	0	86		{
	0	87		return ReadFromBuffer(data, ref offset);
	0	88		}
		89
		90		public byte[] ToBytes()
	0	91		{
	0	92		var maxSize = this.GetSerializedSizeUpperBound();
	0	93		var buffer = new byte[maxSize];
	0	94		var offset = 0;
	0	95		this.WriteToBuffer(buffer, ref offset);
	0	96		if (offset == maxSize) return buffer;
	0	97		var result = new byte[offset];
	0	98		Buffer.BlockCopy(buffer, 0, result, 0, offset);
	0	99		return result;
	0	100		}
		101
		102		internal void WriteToBuffer(byte[] data, ref int offset)
	0	103		{
		104		const int version = 1;
	0	105		BitCoderBuffer.SetVarInt32(data, ref offset, version);
	0	106		BitCoderBuffer.SetVarInt32(data, ref offset, _zoom);
	0	107		BitCoderBuffer.SetVarUInt32(data, ref offset, _tileId);
	0	108		BitCoderBuffer.SetGuid(data, ref offset, _edgeTypeMapId);
		109
	0	110		this.WriteEdgesAndVerticesTo(data, ref offset);
	0	111		this.WriteAttributesTo(data, ref offset);
	0	112		this.WriteGeoTo(data, ref offset);
	0	113		this.WriteTurnCostsTo(data, ref offset);
	0	114		}
		115
		116		internal int GetSerializedSizeUpperBound()
	0	117		{
	0	118		var size = 5 + 5 + 5 + 16;
		119
	0	120		size += 5 + (int)_nextVertexId * 5;
	0	121		size += 5 + (int)_nextEdgeId;
	0	122		size += 5 + (int)_nextCrossTileId * 5;
		123
	0	124		size += 5 + (int)_nextAttributePointer;
	0	125		size += 5;
	0	126		for (var i = 0; i < _nextStringId; i++)
	0	127		{
	0	128		size += 8 + System.Text.Encoding.Unicode.GetByteCount(_strings[i]);
	0	129		}
		130
	0	131		size += 5;
	0	132		var coordinateSize = CoordinateSizeInBytes * 2;
	0	133		if (_elevation != null) coordinateSize += ElevationSizeInBytes;
	0	134		size += (int)(_nextVertexId * coordinateSize);
	0	135		size += 5 + (int)_nextShapePointer;
		136
	0	137		size += 5 + _turnCostPointers.Length * 5;
	0	138		size += 5 + (int)_turnCostPointer;
		139
	0	140		return size;
	0	141		}
		142		}

/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
		9		namespace Itinero.Network.Tiles;
		10
		11		internal partial class NetworkTile
		12		{
	624	13		private uint _turnCostPointer = 0;
	624	14		private uint[] _turnCostPointers = new uint[0];
	624	15		private byte[] _turnCosts = new byte[0];
		16
		17		internal void AddTurnCosts(VertexId vertex, uint turnCostType,
		18		EdgeId[] edges, uint[,] costs, IEnumerable<(string key, string value)> attributes,
		19		IEnumerable<EdgeId>? prefix = null)
	4799	20		{
	4799	21		prefix ??= ArraySegment<EdgeId>.Empty;
		22
	4799	23		if (edges.Length > OrderCoder.MaxOrderHeadTail)
	0	24		{
	0	25		throw new ArgumentException(
	0	26		$"Cannot add turn costs for vertices with more than {OrderCoder.MaxOrderHeadTail} edges.");
		27		}
		28
		29		// enumerate the edges associated with the vertex.
	4799	30		var enumerator = new NetworkTileEnumerator();
	4799	31		enumerator.MoveTo(this);
	4799	32		if (!enumerator.MoveTo(vertex))
	0	33		{
	0	34		throw new ArgumentException($"Cannot add turn costs to a vertex that doesn't exist.",
	0	35		nameof(vertex));
		36		}
		37
		38		// determine max existing order, perhaps there are other turn costs already.
	4799	39		var orders = new byte?[edges.Length];
	4799	40		var max = -1;
	15032	41		while (enumerator.MoveNext())
	10233	42		{
	14973	43		if (!enumerator.TailOrder.HasValue) continue;
	6240	44		if (enumerator.TailOrder.Value <= max) continue;
		45
	4746	46		max = enumerator.TailOrder.Value;
	4746	47		}
		48
		49		// assign missing orders if any.
	4799	50		enumerator.Reset();
	4799	51		var next = max + 1;
	15032	52		while (enumerator.MoveNext())
	10233	53		{
		54		// only assign orders of edges that are used.
	10233	55		var i = Array.IndexOf(edges, enumerator.EdgeId);
	10868	56		if (i == -1) continue;
		57
		58		// edge is used, assign or reuse existing.
	9598	59		var order = enumerator.TailOrder;
	9598	60		if (order == null)
	4617	61		{
		62		// get next order.
	4617	63		order = (byte)next;
	4617	64		next++;
		65
		66		// set order, it's different.
	4617	67		if (enumerator.Forward)
	2296	68		{
		69		// if the edge is forward the tail in the enumerator is also the tail in the edge.
	2296	70		this.SetTailHeadOrder(enumerator.EdgePointer, order, enumerator.HeadOrder);
	2296	71		}
		72		else
	2321	73		{
		74		// if the edge is backward the tail in the enumerator is head in the edge.
	2321	75		this.SetTailHeadOrder(enumerator.EdgePointer, enumerator.TailOrder, order);
	2321	76		}
	4617	77		}
		78
	9598	79		orders[i] = order;
	9598	80		}
		81
		82		// reversed order array.
	4799	83		var count = next;
	4799	84		var reversedOrders = new byte?[count];
	28794	85		for (var i = 0; i < orders.Length; i++)
	9598	86		{
	9598	87		var order = orders[i];
	9598	88		if (order == null)
	0	89		{
	0	90		continue;
		91		}
		92
	9598	93		reversedOrders[order.Value] = (byte)i;
	9598	94		}
		95
		96		// make sure there is space in the pointers table.
		97		// and initialize new slots with null.
	4941	98		while (_turnCostPointers.Length <= vertex.LocalId)
	142	99		{
	142	100		Array.Resize(ref _turnCostPointers, (int)_nextVertexId);
	142	101		}
		102
		103		// make sure there is space in the turn cost array.
		104		// and initialize new slots with null.
	4799	105		var maxLength = _turnCostPointer + 5 + 1 + (count * count * 5) + 5;
	8613	106		while (_turnCosts.Length <= maxLength)
	3814	107		{
	3814	108		Array.Resize(ref _turnCosts, _turnCosts.Length + DefaultSizeIncrease);
	3814	109		}
		110
		111		// update pointer to reflect new data.
	4799	112		var previousPointer = _turnCostPointers[(int)vertex.LocalId].DecodeNullableData();
	4799	113		_turnCostPointers[(int)vertex.LocalId] = _turnCostPointer.EncodeToNullableData();
		114
		115		// write turn cost types.
	4799	116		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, turnCostType);
		117
		118		// write attributes.
	4799	119		var a = this.SetAttributes(attributes, null);
	4799	120		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, a);
		121
		122		// write prefix sequence.
		123		// Use Int64 so the same-tile/foreign-tile signal (sign of the encoded value) round-trips
		124		// correctly for any uint LocalId, including CrossEdgeIds where LocalId >= 0x7FFFFFFF.
		125		// (Int32 would silently overflow-wrap to a positive value when LocalId has the high bit set,
		126		// making the reader misread foreign edges as same-tile and skip the tile id varint.)
	4799	127		var prefixEdges = new List<EdgeId>(prefix);
	4799	128		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, (uint)prefixEdges.Count);
	14397	129		foreach (var prefixEdge in prefixEdges)
	0	130		{
	0	131		if (prefixEdge.TileId == _tileId)
	0	132		{
	0	133		_turnCostPointer += _turnCosts.SetDynamicInt64(_turnCostPointer, (long)prefixEdge.LocalId);
	0	134		}
		135		else
	0	136		{
	0	137		_turnCostPointer += _turnCosts.SetDynamicInt64(_turnCostPointer, -(long)prefixEdge.LocalId - 1);
	0	138		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, prefixEdge.TileId);
	0	139		}
	0	140		}
		141
		142		// write turn costs.
	4799	143		_turnCosts[(int)_turnCostPointer] = (byte)count;
	4799	144		_turnCostPointer++;
	29818	145		for (var x = 0; x < count; x++)
	10110	146		{
	10110	147		var xOrder = reversedOrders[x];
	64332	148		for (var y = 0; y < count; y++)
	22056	149		{
	22056	150		var yOrder = reversedOrders[y];
		151
		152		// get cost from original matrix.
	22056	153		uint cost = 0;
	22056	154		if (xOrder != null && yOrder != null)
	19196	155		{
	19196	156		cost = costs[xOrder.Value, yOrder.Value];
	19196	157		}
		158
		159		// write cost.
	22056	160		_turnCostPointer += (uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, cost);
	22056	161		}
	10110	162		}
		163
		164		// write previous turn cost pointer at the end.
	4799	165		_turnCostPointer +=
	4799	166		(uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, previousPointer.EncodeAsNullableData());
	4799	167		}
		168
		169		internal IEnumerable<(uint turnCostType, IEnumerable<(string key, string value)> attributes, uint cost,
		170		IEnumerable<EdgeId> prefixEdges)>
		171		GetTurnCosts(VertexId vertex, byte fromOrder, byte toOrder)
	19205	172		{
	19205	173		if (_turnCostPointers.Length <= vertex.LocalId)
	0	174		{
	0	175		yield break;
		176		}
		177
	19205	178		var pointerNullable = _turnCostPointers[(int)vertex.LocalId].DecodeNullableData();
	19205	179		if (pointerNullable == null)
	0	180		{
	0	181		yield break;
		182		}
		183
	19205	184		var pointer = pointerNullable.Value;
	40800	185		while (true)
	40800	186		{
		187		// return turn cost type.
	40800	188		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var turnCostType);
		189
		190		// read attributes.
	40800	191		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var a);
	40800	192		var attributes = this.GetAttributes(a);
		193
		194		// read prefix edges.
		195		// Pair with the Int64 writer above; Int32 would mis-decode the sign for CrossEdgeIds.
	40800	196		IEnumerable<EdgeId> prefixEdges = ArraySegment<EdgeId>.Empty;
	40800	197		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var prefixEdgeCount);
	40800	198		if (prefixEdgeCount > 0)
	0	199		{
	0	200		var prefixEdgesList = new List<EdgeId>();
	0	201		while (prefixEdgeCount > 0)
	0	202		{
	0	203		pointer += (uint)_turnCosts.GetDynamicInt64(pointer, out var signedLocalId);
	0	204		if (signedLocalId >= 0)
	0	205		{
	0	206		prefixEdgesList.Add(new EdgeId(this.TileId, (uint)signedLocalId));
	0	207		}
		208		else
	0	209		{
	0	210		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var tileId);
	0	211		prefixEdgesList.Add(new EdgeId(tileId, (uint)(-signedLocalId - 1)));
	0	212		}
		213
	0	214		prefixEdgeCount--;
	0	215		}
		216
	0	217		prefixEdges = prefixEdgesList;
	0	218		}
		219
		220		// read turn cost table.
	40800	221		var max = _turnCosts[(int)pointer];
	40800	222		pointer++;
		223
	250782	224		for (var x = 0; x < max; x++)
	84654	225		{
	526072	226		for (var y = 0; y < max; y++)
	178445	227		{
	178445	228		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var cost);
	178445	229		if (fromOrder != x || toOrder != y)
	138030	230		{
	138030	231		continue;
		232		}
		233
	40415	234		if (cost != 0)
	19204	235		{
	19204	236		yield return (turnCostType, attributes, cost, prefixEdges);
	19141	237		}
	40352	238		}
	84591	239		}
		240
		241		// get pointer to next turn cost table.
	40737	242		_turnCosts.GetDynamicUInt32(pointer, out var p);
	40737	243		pointerNullable = p.DecodeNullableData();
	40737	244		if (pointerNullable == null)
	19142	245		{
	19142	246		break;
		247		}
		248
	21595	249		pointer = pointerNullable.Value;
	21595	250		}
	19142	251		}
		252
		253		internal void SetTailHeadOrder(uint pointer, byte? tailOrder, byte? headOrder)
	4629	254		{
		255		// skip over vertices and next-pointers.
	4629	256		uint size = this.DecodeVertex(pointer, out _, out var t1);
	4629	257		pointer += size;
	4629	258		size = this.DecodeVertex(pointer, out _, out var t2);
	4629	259		pointer += size;
	4629	260		size = this.DecodePointer(pointer, out _);
	4629	261		pointer += size;
	4629	262		size = this.DecodePointer(pointer, out _);
	4629	263		pointer += size;
		264
		265		// skip edge id if needed.
	4629	266		if (t1 != t2)
	101	267		{
	101	268		size = _edges.GetDynamicUInt32(pointer, out _);
	101	269		pointer += size;
	101	270		}
		271
		272		// skip over length/type.
	4629	273		size = this.DecodeEdgePointerId(pointer, out _);
	4629	274		pointer += size;
	4629	275		size = this.DecodeEdgePointerId(pointer, out _);
	4629	276		pointer += size;
		277
		278		// get existing head/tail order.
	4629	279		byte? existingTailOrder = null;
	4629	280		byte? existingHeadOrder = null;
	4629	281		this.GetTailHeadOrder(pointer, ref existingTailOrder, ref existingHeadOrder);
		282
		283		// set tail order if there is a value.
	4629	284		if (tailOrder.HasValue)
	2298	285		{
	2298	286		if (existingTailOrder.HasValue && existingTailOrder.Value != tailOrder.Value)
	0	287		throw new InvalidOperationException("An edge tail or head order can only be set once.");
	2298	288		existingTailOrder = tailOrder;
	2298	289		}
		290
		291		// set head order if there is a value.
	4629	292		if (headOrder.HasValue)
	2437	293		{
	2437	294		if (existingHeadOrder.HasValue && existingHeadOrder.Value != headOrder.Value)
	0	295		throw new InvalidOperationException("An edge tail or head order can only be set once.");
	2437	296		existingHeadOrder = headOrder;
	2437	297		}
		298
	4629	299		_edges.SetTailHeadOrder(pointer, existingTailOrder, existingHeadOrder);
	4629	300		}
		301
		302		private void WriteTurnCostsTo(Stream stream)
	8	303		{
	8	304		stream.WriteVarUInt32((uint)_turnCostPointers.Length);
	16	305		for (var i = 0; i < _turnCostPointers.Length; i++)
	0	306		{
	0	307		stream.WriteVarUInt32(_turnCostPointers[i]);
	0	308		}
		309
	8	310		stream.WriteVarUInt32(_turnCostPointer);
	16	311		for (var i = 0; i < _turnCostPointer; i++)
	0	312		{
	0	313		stream.WriteByte(_turnCosts[i]);
	0	314		}
	8	315		}
		316
		317		private void ReadTurnCostsFrom(Stream stream)
	8	318		{
	8	319		var turnCostPointersSize = stream.ReadVarUInt32();
	8	320		Array.Resize(ref _turnCostPointers, (int)turnCostPointersSize);
	16	321		for (var i = 0; i < turnCostPointersSize; i++)
	0	322		{
	0	323		_turnCostPointers[i] = stream.ReadVarUInt32();
	0	324		}
		325
	8	326		_turnCostPointer = stream.ReadVarUInt32();
	8	327		Array.Resize(ref _turnCosts, (int)_turnCostPointer);
	16	328		for (var i = 0; i < _turnCostPointer; i++)
	0	329		{
	0	330		_turnCosts[i] = (byte)stream.ReadByte();
	0	331		}
	8	332		}
		333
		334		private void ReadTurnCostsFrom(byte[] data, ref int offset)
	0	335		{
	0	336		var turnCostPointersSize = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	337		Array.Resize(ref _turnCostPointers, (int)turnCostPointersSize);
	0	338		for (var i = 0; i < turnCostPointersSize; i++)
	0	339		{
	0	340		_turnCostPointers[i] = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	341		}
		342
	0	343		_turnCostPointer = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	344		Array.Resize(ref _turnCosts, (int)_turnCostPointer);
	0	345		Buffer.BlockCopy(data, offset, _turnCosts, 0, (int)_turnCostPointer);
	0	346		offset += (int)_turnCostPointer;
	0	347		}
		348
		349		private void WriteTurnCostsTo(byte[] data, ref int offset)
	0	350		{
	0	351		BitCoderBuffer.SetVarUInt32(data, ref offset, (uint)_turnCostPointers.Length);
	0	352		for (var i = 0; i < _turnCostPointers.Length; i++)
	0	353		{
	0	354		BitCoderBuffer.SetVarUInt32(data, ref offset, _turnCostPointers[i]);
	0	355		}
		356
	0	357		BitCoderBuffer.SetVarUInt32(data, ref offset, _turnCostPointer);
	0	358		Buffer.BlockCopy(_turnCosts, 0, data, offset, (int)_turnCostPointer);
	0	359		offset += (int)_turnCostPointer;
	0	360		}
		361		}