< 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:	827
Uncovered lines:	293
Coverable lines:	1120
Total lines:	1724
Line coverage:	73.8% (827 of 1120)
Covered branches:	240
Total branches:	320
Branch coverage:	75% (240 of 320)
Tag:	251_23667616543

Metrics

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

/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.
	502	20		private uint _nextShapePointer = 0;
		21		private byte[] _shapes;
		22
		23		private void SetCoordinate(uint localId, double longitude, double latitude, float? e)
	36922	24		{
		25		// set elevation if needed.
	36922	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
	36922	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;
	36922	45		if (_elevation == null)
	36884	46		{
		47		// don't store elevation.
	36884	48		tileCoordinatePointer = localId * CoordinateSizeInBytes * 2;
	36884	49		ArrayBaseExtensions.EnsureMinimumSize(ref _coordinates, tileCoordinatePointer + (CoordinateSizeInBytes * 2),
	36884	50		DefaultSizeIncrease);
	36884	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;
	36922	62		var (x, y) = TileStatic.ToLocalTileCoordinates(_zoom, _tileId, longitude, latitude, resolution);
	36922	63		_coordinates.SetFixed(tileCoordinatePointer, CoordinateSizeInBytes, x);
	36922	64		_coordinates.SetFixed(tileCoordinatePointer + CoordinateSizeInBytes, CoordinateSizeInBytes, y);
		65
		66		// write elevation.
	36922	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		}
	36922	79		}
		80
		81		private void GetCoordinate(uint localId, out double longitude, out double latitude, out float? elevation)
	5819304	82		{
	5819304	83		var tileCoordinatePointer = _elevation == null
	5819304	84		? localId * CoordinateSizeInBytes * 2
	5819304	85		: localId * ((CoordinateSizeInBytes * 2) + ElevationSizeInBytes);
		86
		87		const int resolution = (1 << TileResolutionInBits) - 1;
	5819304	88		_coordinates.GetFixed(tileCoordinatePointer, CoordinateSizeInBytes, out var x);
	5819304	89		_coordinates.GetFixed(tileCoordinatePointer + CoordinateSizeInBytes, CoordinateSizeInBytes, out var y);
	5819304	90		elevation = null;
	5819304	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
	5819304	98		TileStatic.FromLocalTileCoordinates(_zoom, _tileId, x, y, resolution, out longitude, out latitude);
	5819304	99		}
		100
		101		private uint SetShape(IEnumerable<(double longitude, double latitude, float? e)> shape)
	51687	102		{
		103		const int resolution = (1 << TileResolutionInBits) - 1;
	51687	104		var originalPointer = _nextShapePointer;
	51687	105		var blockPointer = originalPointer;
	51687	106		var pointer = blockPointer + 1;
		107
		108		// make sure there is space for the block pointer.
	51687	109		ArrayBaseExtensions.EnsureMinimumSize(ref _shapes, blockPointer);
		110
	51687	111		var coordinateBlockSize = 8;
	51687	112		if (_elevation != null)
	24	113		{
	24	114		coordinateBlockSize += 4;
	24	115		}
		116
	51687	117		using var enumerator = shape.GetEnumerator();
	51687	118		var count = 0;
	51687	119		(int x, int y, int? eOffset) previous = (int.MaxValue, int.MaxValue, null);
	126361	120		while (enumerator.MoveNext())
	74674	121		{
	74674	122		var current = enumerator.Current;
	74674	123		var (x, y) =
	74674	124		TileStatic.ToLocalTileCoordinates(_zoom, _tileId, current.longitude, current.latitude, resolution);
	74674	125		int? eOffset = null;
	74674	126		var e = current.e ?? 0;
	74674	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.
	74674	133		ArrayBaseExtensions.EnsureMinimumSize(ref _shapes, pointer + coordinateBlockSize);
		134
		135		// store coordinate.
	74674	136		if (count == 0)
	21035	137		{
		138		// first coordinate.
	21035	139		pointer += (uint)_shapes.SetDynamicInt32(pointer, x);
	21035	140		pointer += (uint)_shapes.SetDynamicInt32(pointer, y);
	21035	141		if (eOffset != null)
	7	142		{
	7	143		pointer += (uint)_shapes.SetDynamicInt32(pointer, eOffset.Value);
	7	144		}
	21035	145		}
		146		else
	53639	147		{
		148		// calculate diff and then store.
	53639	149		var diffX = x - previous.x;
	53639	150		var diffY = y - previous.y;
	53639	151		pointer += (uint)_shapes.SetDynamicInt32(pointer, diffX);
	53639	152		pointer += (uint)_shapes.SetDynamicInt32(pointer, diffY);
	53639	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		}
	53639	163		}
		164
	74674	165		count++;
		166
	74674	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
	74674	176		previous = (x, y, eOffset);
	74674	177		}
		178
		179		// a block is still open, close it.
	51687	180		_shapes[(int)blockPointer] = (byte)count;
	51687	181		_nextShapePointer = pointer;
		182
	51687	183		return originalPointer;
	51687	184		}
		185
		186		internal IEnumerable<(double longitude, double latitude, float? e)> GetShape(uint? pointer)
	1295378	187		{
	1295378	188		if (pointer == null)
	119	189		{
	119	190		yield break;
		191		}
		192
	1295259	193		var p = pointer.Value;
		194
		195		const int resolution = (1 << TileResolutionInBits) - 1;
	1295259	196		var count = -1;
	1295259	197		(int x, int y, int? eOffset) previous = (int.MaxValue, int.MaxValue, null);
	1295260	198		while (true)
	1295260	199		{
	1295260	200		count = _shapes[(int)p];
	1295260	201		p++;
		202
	5305896	203		for (var i = 0; i < count; i++)
	1358711	204		{
	1358711	205		p += (uint)_shapes.GetDynamicInt32(p, out var x);
	1358711	206		p += (uint)_shapes.GetDynamicInt32(p, out var y);
	1358711	207		int? eOffset = null;
	1358711	208		if (_elevation != null)
	16	209		{
	16	210		p += (uint)_shapes.GetDynamicInt32(p, out var e);
	16	211		eOffset = e;
	16	212		}
		213
	1358711	214		if (i > 0)
	939846	215		{
	939846	216		x = previous.x + x;
	939846	217		y = previous.y + y;
	939846	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		}
	939846	227		}
		228
	1358711	229		int? elevation = null;
	1358711	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
	1358711	240		TileStatic.FromLocalTileCoordinates(_zoom, _tileId, x, y, resolution, out var longitude,
	1358711	241		out var latitude);
	1358711	242		yield return (longitude, latitude, elevation / 10.0f);
		243
	1357688	244		previous = (x, y, eOffset);
	1357688	245		}
		246
	2588473	247		if (count < 255) break;
	1	248		}
	1294236	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		{
	502	13		private uint _turnCostPointer = 0;
	502	14		private uint[] _turnCostPointers = new uint[0];
	502	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)
	1029	20		{
	1029	21		prefix ??= ArraySegment<EdgeId>.Empty;
		22
	1029	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.
	1029	30		var enumerator = new NetworkTileEnumerator();
	1029	31		enumerator.MoveTo(this);
	1029	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.
	1029	39		var orders = new byte?[edges.Length];
	1029	40		var max = -1;
	3183	41		while (enumerator.MoveNext())
	2154	42		{
	3272	43		if (!enumerator.TailOrder.HasValue) continue;
	1068	44		if (enumerator.TailOrder.Value <= max) continue;
		45
	1004	46		max = enumerator.TailOrder.Value;
	1004	47		}
		48
		49		// assign missing orders if any.
	1029	50		enumerator.Reset();
	1029	51		var next = max + 1;
	3183	52		while (enumerator.MoveNext())
	2154	53		{
		54		// only assign orders of edges that are used.
	2154	55		var i = Array.IndexOf(edges, enumerator.EdgeId);
	2250	56		if (i == -1) continue;
		57
		58		// edge is used, assign or reuse existing.
	2058	59		var order = enumerator.TailOrder;
	2058	60		if (order == null)
	1043	61		{
		62		// get next order.
	1043	63		order = (byte)next;
	1043	64		next++;
		65
		66		// set order, it's different.
	1043	67		if (enumerator.Forward)
	529	68		{
		69		// if the edge is forward the tail in the enumerator is also the tail in the edge.
	529	70		this.SetTailHeadOrder(enumerator.EdgePointer, order, enumerator.HeadOrder);
	529	71		}
		72		else
	514	73		{
		74		// if the edge is backward the tail in the enumerator is head in the edge.
	514	75		this.SetTailHeadOrder(enumerator.EdgePointer, enumerator.TailOrder, order);
	514	76		}
	1043	77		}
		78
	2058	79		orders[i] = order;
	2058	80		}
		81
		82		// reversed order array.
	1029	83		var count = next;
	1029	84		var reversedOrders = new byte?[count];
	6174	85		for (var i = 0; i < orders.Length; i++)
	2058	86		{
	2058	87		var order = orders[i];
	2058	88		if (order == null)
	0	89		{
	0	90		continue;
		91		}
		92
	2058	93		reversedOrders[order.Value] = (byte)i;
	2058	94		}
		95
		96		// make sure there is space in the pointers table.
		97		// and initialize new slots with null.
	1128	98		while (_turnCostPointers.Length <= vertex.LocalId)
	99	99		{
	99	100		Array.Resize(ref _turnCostPointers, (int)_nextVertexId);
	99	101		}
		102
		103		// make sure there is space in the turn cost array.
		104		// and initialize new slots with null.
	1029	105		var maxLength = _turnCostPointer + 5 + 1 + (count * count * 5) + 5;
	1913	106		while (_turnCosts.Length <= maxLength)
	884	107		{
	884	108		Array.Resize(ref _turnCosts, _turnCosts.Length + DefaultSizeIncrease);
	884	109		}
		110
		111		// update pointer to reflect new data.
	1029	112		var previousPointer = _turnCostPointers[(int)vertex.LocalId].DecodeNullableData();
	1029	113		_turnCostPointers[(int)vertex.LocalId] = _turnCostPointer.EncodeToNullableData();
		114
		115		// write turn cost types.
	1029	116		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, turnCostType);
		117
		118		// write attributes.
	1029	119		var a = this.SetAttributes(attributes, null);
	1029	120		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, a);
		121
		122		// write prefix sequence.
	1029	123		var prefixEdges = new List<EdgeId>(prefix);
	1029	124		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, (uint)prefixEdges.Count);
	3087	125		foreach (var prefixEdge in prefixEdges)
	0	126		{
	0	127		if (prefixEdge.TileId == _tileId)
	0	128		{
	0	129		_turnCostPointer += _turnCosts.SetDynamicInt32(_turnCostPointer, (int)prefixEdge.LocalId);
	0	130		}
		131		else
	0	132		{
	0	133		_turnCostPointer += _turnCosts.SetDynamicInt32(_turnCostPointer, (int)-(prefixEdge.LocalId + 1));
	0	134		_turnCostPointer += _turnCosts.SetDynamicUInt32(_turnCostPointer, prefixEdge.TileId);
	0	135		}
	0	136		}
		137
		138		// write turn costs.
	1029	139		_turnCosts[(int)_turnCostPointer] = (byte)count;
	1029	140		_turnCostPointer++;
	6216	141		for (var x = 0; x < count; x++)
	2079	142		{
	2079	143		var xOrder = reversedOrders[x];
	12600	144		for (var y = 0; y < count; y++)
	4221	145		{
	4221	146		var yOrder = reversedOrders[y];
		147
		148		// get cost from original matrix.
	4221	149		uint cost = 0;
	4221	150		if (xOrder != null && yOrder != null)
	4116	151		{
	4116	152		cost = costs[xOrder.Value, yOrder.Value];
	4116	153		}
		154
		155		// write cost.
	4221	156		_turnCostPointer += (uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, cost);
	4221	157		}
	2079	158		}
		159
		160		// write previous turn cost pointer at the end.
	1029	161		_turnCostPointer +=
	1029	162		(uint)_turnCosts.SetDynamicUInt32(_turnCostPointer, previousPointer.EncodeAsNullableData());
	1029	163		}
		164
		165		internal IEnumerable<(uint turnCostType, IEnumerable<(string key, string value)> attributes, uint cost,
		166		IEnumerable<EdgeId> prefixEdges)>
		167		GetTurnCosts(VertexId vertex, byte fromOrder, byte toOrder)
	2038	168		{
	2038	169		if (_turnCostPointers.Length <= vertex.LocalId)
	0	170		{
	0	171		yield break;
		172		}
		173
	2038	174		var pointerNullable = _turnCostPointers[(int)vertex.LocalId].DecodeNullableData();
	2038	175		if (pointerNullable == null)
	0	176		{
	0	177		yield break;
		178		}
		179
	2038	180		var pointer = pointerNullable.Value;
	4051	181		while (true)
	4051	182		{
		183		// return turn cost type.
	4051	184		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var turnCostType);
		185
		186		// read attributes.
	4051	187		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var a);
	4051	188		var attributes = this.GetAttributes(a);
		189
		190		// read prefix edges.
	4051	191		IEnumerable<EdgeId> prefixEdges = ArraySegment<EdgeId>.Empty;
	4051	192		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var prefixEdgeCount);
	4051	193		if (prefixEdgeCount > 0)
	0	194		{
	0	195		var prefixEdgesList = new List<EdgeId>();
	0	196		while (prefixEdgeCount > 0)
	0	197		{
	0	198		pointer += (uint)_turnCosts.GetDynamicInt32(pointer, out var signedLocalId);
	0	199		if (signedLocalId >= 0)
	0	200		{
	0	201		prefixEdgesList.Add(new EdgeId(this.TileId, (uint)signedLocalId));
	0	202		}
		203		else
	0	204		{
	0	205		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var tileId);
	0	206		prefixEdgesList.Add(new EdgeId(tileId, (uint)-signedLocalId - 1));
	0	207		}
		208
	0	209		prefixEdgeCount--;
	0	210		}
		211
	0	212		prefixEdges = prefixEdgesList;
	0	213		}
		214
		215		// read turn cost table.
	4051	216		var max = _turnCosts[(int)pointer];
	4051	217		pointer++;
		218
	24250	219		for (var x = 0; x < max; x++)
	8101	220		{
	48514	221		for (var y = 0; y < max; y++)
	16183	222		{
	16183	223		pointer += (uint)_turnCosts.GetDynamicUInt32(pointer, out var cost);
	16183	224		if (fromOrder != x || toOrder != y)
	12132	225		{
	12132	226		continue;
		227		}
		228
	4051	229		if (cost != 0)
	2040	230		{
	2040	231		yield return (turnCostType, attributes, cost, prefixEdges);
	2013	232		}
	4024	233		}
	8074	234		}
		235
		236		// get pointer to next turn cost table.
	4024	237		_turnCosts.GetDynamicUInt32(pointer, out var p);
	4024	238		pointerNullable = p.DecodeNullableData();
	4024	239		if (pointerNullable == null)
	2011	240		{
	2011	241		break;
		242		}
		243
	2013	244		pointer = pointerNullable.Value;
	2013	245		}
	2011	246		}
		247
		248		internal void SetTailHeadOrder(uint pointer, byte? tailOrder, byte? headOrder)
	1043	249		{
		250		// skip over vertices and next-pointers.
	1043	251		uint size = this.DecodeVertex(pointer, out _, out var t1);
	1043	252		pointer += size;
	1043	253		size = this.DecodeVertex(pointer, out _, out var t2);
	1043	254		pointer += size;
	1043	255		size = this.DecodePointer(pointer, out _);
	1043	256		pointer += size;
	1043	257		size = this.DecodePointer(pointer, out _);
	1043	258		pointer += size;
		259
		260		// skip edge id if needed.
	1043	261		if (t1 != t2)
	40	262		{
	40	263		size = _edges.GetDynamicUInt32(pointer, out _);
	40	264		pointer += size;
	40	265		}
		266
		267		// skip over length/type.
	1043	268		size = this.DecodeEdgePointerId(pointer, out _);
	1043	269		pointer += size;
	1043	270		size = this.DecodeEdgePointerId(pointer, out _);
	1043	271		pointer += size;
		272
		273		// get existing head/tail order.
	1043	274		byte? existingTailOrder = null;
	1043	275		byte? existingHeadOrder = null;
	1043	276		this.GetTailHeadOrder(pointer, ref existingTailOrder, ref existingHeadOrder);
		277
		278		// set tail order if there is a value.
	1043	279		if (tailOrder.HasValue)
	529	280		{
	529	281		if (existingTailOrder.HasValue && existingTailOrder.Value != tailOrder.Value)
	0	282		throw new InvalidOperationException("An edge tail or head order can only be set once.");
	529	283		existingTailOrder = tailOrder;
	529	284		}
		285
		286		// set head order if there is a value.
	1043	287		if (headOrder.HasValue)
	518	288		{
	518	289		if (existingHeadOrder.HasValue && existingHeadOrder.Value != headOrder.Value)
	0	290		throw new InvalidOperationException("An edge tail or head order can only be set once.");
	518	291		existingHeadOrder = headOrder;
	518	292		}
		293
	1043	294		_edges.SetTailHeadOrder(pointer, existingTailOrder, existingHeadOrder);
	1043	295		}
		296
		297		private void WriteTurnCostsTo(Stream stream)
	8	298		{
	8	299		stream.WriteVarUInt32((uint)_turnCostPointers.Length);
	16	300		for (var i = 0; i < _turnCostPointers.Length; i++)
	0	301		{
	0	302		stream.WriteVarUInt32(_turnCostPointers[i]);
	0	303		}
		304
	8	305		stream.WriteVarUInt32(_turnCostPointer);
	16	306		for (var i = 0; i < _turnCostPointer; i++)
	0	307		{
	0	308		stream.WriteByte(_turnCosts[i]);
	0	309		}
	8	310		}
		311
		312		private void ReadTurnCostsFrom(Stream stream)
	8	313		{
	8	314		var turnCostPointersSize = stream.ReadVarUInt32();
	8	315		Array.Resize(ref _turnCostPointers, (int)turnCostPointersSize);
	16	316		for (var i = 0; i < turnCostPointersSize; i++)
	0	317		{
	0	318		_turnCostPointers[i] = stream.ReadVarUInt32();
	0	319		}
		320
	8	321		_turnCostPointer = stream.ReadVarUInt32();
	8	322		Array.Resize(ref _turnCosts, (int)_turnCostPointer);
	16	323		for (var i = 0; i < _turnCostPointer; i++)
	0	324		{
	0	325		_turnCosts[i] = (byte)stream.ReadByte();
	0	326		}
	8	327		}
		328
		329		private void ReadTurnCostsFrom(byte[] data, ref int offset)
	0	330		{
	0	331		var turnCostPointersSize = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	332		Array.Resize(ref _turnCostPointers, (int)turnCostPointersSize);
	0	333		for (var i = 0; i < turnCostPointersSize; i++)
	0	334		{
	0	335		_turnCostPointers[i] = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	336		}
		337
	0	338		_turnCostPointer = BitCoderBuffer.GetVarUInt32(data, ref offset);
	0	339		Array.Resize(ref _turnCosts, (int)_turnCostPointer);
	0	340		Buffer.BlockCopy(data, offset, _turnCosts, 0, (int)_turnCostPointer);
	0	341		offset += (int)_turnCostPointer;
	0	342		}
		343
		344		private void WriteTurnCostsTo(byte[] data, ref int offset)
	0	345		{
	0	346		BitCoderBuffer.SetVarUInt32(data, ref offset, (uint)_turnCostPointers.Length);
	0	347		for (var i = 0; i < _turnCostPointers.Length; i++)
	0	348		{
	0	349		BitCoderBuffer.SetVarUInt32(data, ref offset, _turnCostPointers[i]);
	0	350		}
		351
	0	352		BitCoderBuffer.SetVarUInt32(data, ref offset, _turnCostPointer);
	0	353		Buffer.BlockCopy(_turnCosts, 0, data, offset, (int)_turnCostPointer);
	0	354		offset += (int)_turnCostPointer;
	0	355		}
		356		}