Struct NetworkRef 

pub struct NetworkRef { /* private fields */ }

RAII guard providing zero-cost access to a cached RoadNetwork.

Implementations

impl NetworkRef

pub fn cache_key(&self) -> &str

Methods from Deref<Target = 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>>

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 both coordinates to the nearest road-network nodes, then runs the public travel-time search over those snapped nodes. The current implementation passes a zero heuristic to astar, so its behavior is equivalent to Dijkstra’s algorithm.

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

Find a route between two edge-snapped locations.

Use this when start and end should stay on their containing road segments instead of being snapped all the way to graph nodes.

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

Find a route between two node-snapped coordinates.

This expects SnappedCoord values produced by snap_to_road_detailed and returns geometry along graph nodes, not projected edge endpoints.

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

Find a route between two coordinates with an explicit optimization objective.

Like route, this method snaps to the nearest graph nodes first and uses admissible straight-line lower bounds for both objectives.

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

Trait Implementations

impl Deref for NetworkRef

type Target = RoadNetwork

The resulting type after dereferencing.

fn deref(&self) -> &RoadNetwork

Dereferences the value.