< Summary

Class:Itinero.Routing.IRouterExtensions
Assembly:Itinero
File(s):/home/runner/work/routing2/routing2/src/Itinero/Routing/IRouterExtensions.cs
Covered lines:92
Uncovered lines:34
Coverable lines:126
Total lines:234
Line coverage:73% (92 of 126)
Covered branches:25
Total branches:36
Branch coverage:69.4% (25 of 36)
Tag:268_34224473380

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
From(...)100%1100%
From(...)100%1100%
From(...)100%10%
From(...)100%10%
From(...)100%10%
From(...)100%10%
CalculateAsync()90%10100%
<CalculateAsync()50%257.14%
CalculateAsync()80%1090.32%
<CalculateAsync()50%257.14%

File(s)

/home/runner/work/routing2/routing2/src/Itinero/Routing/IRouterExtensions.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Threading;
 4using System.Threading.Tasks;
 5using Itinero.Geo;
 6using Itinero.Geo.Directions;
 7using Itinero.Network;
 8using Itinero.Routes.Paths;
 9using Itinero.Routing.Alternatives;
 10using Itinero.Routing.Costs;
 11using Itinero.Routing.Flavours.Dijkstra;
 12using Itinero.Snapping;
 13
 14namespace Itinero.Routing;
 15
 16/// <summary>
 17///     Contains extensions for the IRouter interface.
 18/// </summary>
 19public static class IRouterExtensions
 20{
 21    /// <summary>
 22    ///     Configures the router to route from the given point.
 23    /// </summary>
 24    /// <param name="router">The router.</param>
 25    /// <param name="snapPoint">The point to route from.</param>
 26    /// <returns>A configured router.</returns>
 27    public static IHasSource From(this IRouter router, SnapPoint snapPoint)
 1161128    {
 1161129        return router.From((snapPoint, (bool?)null));
 1161130    }
 31
 32    /// <summary>
 33    ///     Configures the router to route from the given point.
 34    /// </summary>
 35    /// <param name="router">The router.</param>
 36    /// <param name="directedSnapPoint">The point to route from.</param>
 37    /// <returns>A configured router.</returns>
 38    public static IHasSource From(this IRouter router, (SnapPoint snapPoint, bool? direction) directedSnapPoint)
 1161139    {
 1161140        return new Router(router.Network, router.Settings)
 1161141        {
 1161142            Source = directedSnapPoint
 1161143        };
 1161144    }
 45
 46    /// <summary>
 47    ///     Configures the router to route from the given point.
 48    /// </summary>
 49    /// <param name="router">The router.</param>
 50    /// <param name="directedSnapPoint">The point to route from.</param>
 51    /// <returns>A configured router.</returns>
 52    public static IHasSource From(this IRouter router,
 53        (SnapPoint snapPoint, DirectionEnum? direction) directedSnapPoint)
 054    {
 055        return router.From(directedSnapPoint.ToDirected(router.Network));
 056    }
 57
 58    /// <summary>
 59    ///     Configures the router to route from the given point.
 60    /// </summary>
 61    /// <param name="router">The router.</param>
 62    /// <param name="snapPoints">The points to route from.</param>
 63    /// <returns>A configured router.</returns>
 64    public static IHasSources From(this IRouter router, IReadOnlyList<SnapPoint> snapPoints)
 065    {
 066        return router.From(snapPoints.ToDirected());
 067    }
 68
 69    /// <summary>
 70    ///     Configures the router to route from the given point.
 71    /// </summary>
 72    /// <param name="router">The router.</param>
 73    /// <param name="directedSnapPoints">The points to route from.</param>
 74    /// <returns>A configured router.</returns>
 75    public static IHasSources From(this IRouter router,
 76        IReadOnlyList<(SnapPoint snapPoint, DirectionEnum? direction)> directedSnapPoints)
 077    {
 078        return router.From(directedSnapPoints.ToDirected(router.Network));
 079    }
 80
 81    /// <summary>
 82    ///     Configures the router to route from the given point.
 83    /// </summary>
 84    /// <param name="router">The router.</param>
 85    /// <param name="directedSnapPoints">The points to route from.</param>
 86    /// <returns>A configured router.</returns>
 87    public static IHasSources From(this IRouter router,
 88        IReadOnlyList<(SnapPoint snapPoint, bool? direction)> directedSnapPoints)
 089    {
 090        return new Router(router.Network, router.Settings)
 091        {
 092            Sources = directedSnapPoints
 093        };
 094    }
 95
 96    internal static async Task<IReadOnlyList<IReadOnlyList<Result<Path>>>> CalculateAsync(this IRouter manyToManyRouter,
 97        IReadOnlyList<SnapPoint> sources, IReadOnlyList<SnapPoint> targets, CancellationToken cancellationToken)
 1154298    {
 1154299        var settings = manyToManyRouter.Settings;
 11542100        var routingNetwork = manyToManyRouter.Network;
 101
 11542102        var profile = settings.Profile;
 11542103        var costFunction = routingNetwork.GetCostFunctionFor(profile);
 11542104        if (settings.CostFunctionWrapper != null) costFunction = settings.CostFunctionWrapper(costFunction);
 105
 11542106        var maxBox = settings.MaxBoxFor(routingNetwork, sources);
 107
 108        bool CheckMaxDistance(VertexId v)
 304245109        {
 304245110            if (maxBox == null)
 4111            {
 4112                return false;
 113            }
 114
 304241115            if (routingNetwork == null)
 0116            {
 0117                throw new Exception("Router cannot be null here.");
 118            }
 119
 304241120            var vertex = routingNetwork.GetVertex(v);
 304241121            if (!maxBox.Value.Overlaps(vertex))
 51273122            {
 51273123                return true;
 124            }
 125
 252968126            return false;
 304245127        }
 128
 11542129        var isMainN = routingNetwork.GetIsMainNFunc(profile);
 11542130        var results = new IReadOnlyList<Result<Path>>[sources.Count];
 46168131        for (var s = 0; s < sources.Count; s++)
 11542132        {
 11542133            var source = sources[s];
 11542134            var pathsAndCosts = await Flavours.Dijkstra.Dijkstra.Default.RunAsync(routingNetwork, source, targets,
 11542135                costFunction.GetDijkstraWeightFunc(),
 11542136                async v =>
 304245137                {
 304245138                    if (!routingNetwork.UsageNotifier.IsVertexDataReady(routingNetwork, v.vertexId))
 0139                    {
 0140                        await routingNetwork.UsageNotifier.NotifyVertex(routingNetwork, v.vertexId, cancellationToken);
 0141                    }
 304245142                    return CheckMaxDistance(v.vertexId);
 315787143                }, isMainN: isMainN);
 144
 11542145            var sourceResults = new Result<Path>[pathsAndCosts.Length];
 402636146            for (var r = 0; r < sourceResults.Length; r++)
 189776147            {
 189776148                var (path, _) = pathsAndCosts[r];
 189776149                if (path == null)
 59484150                {
 59484151                    sourceResults[r] = new Result<Path>("Path not found!");
 59484152                }
 153                else
 130292154                {
 130292155                    sourceResults[r] = path;
 130292156                }
 189776157            }
 158
 11542159            results[s] = sourceResults;
 11542160        }
 161
 11542162        return results;
 11542163    }
 164
 165    internal static async Task<IReadOnlyList<IReadOnlyList<Result<Path>>>> CalculateAsync(this IRouter manyToManyRouter,
 166        IReadOnlyList<(SnapPoint snapPoint, bool? direction)> sources,
 167        IReadOnlyList<(SnapPoint snapPoint, bool? direction)> targets)
 5168    {
 5169        var settings = manyToManyRouter.Settings;
 5170        var routerDb = manyToManyRouter.Network;
 171
 5172        var profile = settings.Profile;
 5173        var costFunction = routerDb.GetCostFunctionFor(profile);
 5174        if (settings.CostFunctionWrapper != null) costFunction = settings.CostFunctionWrapper(costFunction);
 175
 5176        var maxBox = settings.MaxBoxFor(routerDb, sources);
 177
 178        bool CheckMaxDistance(VertexId v)
 12179        {
 12180            if (maxBox == null)
 12181            {
 12182                return false;
 183            }
 184
 0185            if (routerDb == null)
 0186            {
 0187                throw new Exception("Router cannot be null here.");
 188            }
 189
 0190            var vertex = routerDb.GetVertex(v);
 0191            if (!maxBox.Value.Overlaps(vertex))
 0192            {
 0193                return true;
 194            }
 195
 0196            return false;
 12197        }
 198
 5199        var isMainN = routerDb.GetIsMainNFunc(profile);
 5200        var results = new IReadOnlyList<Result<Path>>[sources.Count];
 20201        for (var s = 0; s < sources.Count; s++)
 5202        {
 5203            var source = sources[s];
 5204            var paths = await Flavours.Dijkstra.Dijkstra.Default.RunAsync(routerDb, source, targets,
 5205                costFunction.GetDijkstraWeightFunc(),
 5206                async e =>
 12207                {
 12208                    if (!routerDb.UsageNotifier.IsVertexDataReady(routerDb, e.vertexId))
 0209                    {
 0210                        await routerDb.UsageNotifier.NotifyVertex(routerDb, e.vertexId);
 0211                    }
 12212                    return CheckMaxDistance(e.vertexId);
 17213                }, isMainN: isMainN);
 214
 5215            var sourceResults = new Result<Path>[paths.Length];
 20216            for (var r = 0; r < sourceResults.Length; r++)
 5217            {
 5218                var (path, _) = paths[r];
 5219                if (path == null)
 5220                {
 5221                    sourceResults[r] = new Result<Path>("Routes not found!");
 5222                }
 223                else
 0224                {
 0225                    sourceResults[r] = path;
 0226                }
 5227            }
 228
 5229            results[s] = sourceResults;
 5230        }
 231
 5232        return results;
 5233    }
 234}
Generated by: ReportGenerator 4.8.2.0
09/08/2026 - 12:11:09
GitHub | www.palmmedia.de

Methods/Properties

From(...)
From(...)
From(...)
From(...)
From(...)
From(...)
CalculateAsync()
<CalculateAsync()
CalculateAsync()
<CalculateAsync()