Struct RoadNetwork 

pub struct RoadNetwork { /* private fields */ }

Implementations

impl RoadNetwork

pub async fn cache_stats() -> CacheStats

pub async fn clear_cache()

pub async fn evict(bbox: &BoundingBox) -> bool

pub async fn cached_regions() -> Vec<BoundingBox>

impl RoadNetwork

pub async fn load_or_fetch( bbox: &BoundingBox, config: &NetworkConfig, progress: Option<&Sender<RoutingProgress>>, ) -> Result<NetworkRef, RoutingError>

pub async fn fetch( bbox: &BoundingBox, config: &NetworkConfig, progress: Option<&Sender<RoutingProgress>>, ) -> Result<Self, RoutingError>

impl RoadNetwork

pub async fn compute_matrix( &self, locations: &[Coord], progress: Option<&Sender<RoutingProgress>>, ) -> TravelTimeMatrix

pub async fn compute_geometries( &self, locations: &[Coord], progress: Option<&Sender<RoutingProgress>>, ) -> HashMap<(usize, usize), Vec<Coord>>

impl RoadNetwork

pub fn new() -> Self

pub fn nodes_iter(&self) -> impl Iterator<Item = (f64, f64)> + '_

Iterate over all nodes as (lat, lng) pairs.

pub fn edges_iter(&self) -> impl Iterator<Item = (usize, usize, f64, f64)> + '_

Iterate over all edges as (from_idx, to_idx, travel_time_s, distance_m) tuples.

pub fn snap_to_road(&self, coord: Coord) -> Option<NodeIdx>

Snap a coordinate to the nearest node in the road network.

Returns None if the network is empty.

pub fn snap_to_road_detailed( &self, coord: Coord, ) -> Result<SnappedCoord, RoutingError>

Snap a coordinate to the road network with detailed information.

Returns a SnappedCoord containing both original and snapped coordinates, the snap distance, and an internal node index for routing.

pub fn snap_to_edge( &self, coord: Coord, ) -> Result<EdgeSnappedLocation, RoutingError>

Snap a coordinate to the nearest road segment (edge-based snapping).

This is production-grade snapping that projects the coordinate onto the nearest road segment rather than snapping to the nearest intersection.

pub fn route(&self, from: Coord, to: Coord) -> Result<RouteResult, RoutingError>

Find a route between two coordinates.

This method snaps the coordinates to the nearest road network nodes and then finds the shortest path by travel time.

pub fn route_edge_snapped( &self, from: &EdgeSnappedLocation, to: &EdgeSnappedLocation, ) -> Result<RouteResult, RoutingError>

Find a route between two edge-snapped locations.

This handles the case where start and end are on road segments, not necessarily at intersections.

pub fn route_snapped( &self, from: &SnappedCoord, to: &SnappedCoord, ) -> Result<RouteResult, RoutingError>

pub fn route_with( &self, from: Coord, to: Coord, objective: Objective, ) -> Result<RouteResult, RoutingError>

pub fn node_count(&self) -> usize

pub fn edge_count(&self) -> usize

pub fn strongly_connected_components(&self) -> usize

pub fn largest_component_fraction(&self) -> f64

pub fn is_strongly_connected(&self) -> bool

pub fn filter_to_largest_scc(&mut self)

Filter the network to keep only the largest strongly connected component.

impl RoadNetwork

pub fn from_test_data( nodes: &[(f64, f64)], edges: &[(usize, usize, f64, f64)], ) -> Self

Build a network from raw node/edge data (for testing).

Arguments

• nodes - Slice of (lat, lng) tuples for each node
• edges - Slice of (from_idx, to_idx, time_s, dist_m) tuples

Example

use solverforge_maps::RoadNetwork;

let nodes = &[(40.0, -75.0), (39.8, -75.2)];
let edges = &[(0, 1, 60.0, 1000.0), (1, 0, 60.0, 1000.0)];
let network = RoadNetwork::from_test_data(nodes, edges);

assert_eq!(network.node_count(), 2);
assert_eq!(network.edge_count(), 2);

Trait Implementations

impl Default for RoadNetwork

fn default() -> Self

Returns the “default value” for a type.