Struct HoprGraphPathSelector 

pub struct HoprGraphPathSelector<G> {
    me: OffchainPublicKey,
    graph: G,
    max_paths: usize,
    edge_penalty: f64,
    min_ack_rate: f64,
}

A lightweight graph-backed path selector.

Returns all candidate paths for a (src, dest, hops) query directly from the network graph — no caching is performed here. The caller (typically crate::path::planner::PathPlanner) is responsible for caching, TTL management, background refresh, and final path selection.

Stores the planner’s own identity (me) so that it can choose the appropriate cost function:

• forward path (src == me): [EdgeValueFn::forward]
• return path (dest == me): [EdgeValueFn::returning]

Fields

me: OffchainPublicKey

graph: G

max_paths: usize

edge_penalty: f64

min_ack_rate: f64

Implementations

impl<G> HoprGraphPathSelector<G>

where G: NetworkGraphTraverse<NodeId = OffchainPublicKey> + NetworkGraphView<NodeId = OffchainPublicKey> + Clone + Send + Sync + 'static, <G as NetworkGraphTraverse>::Observed: EdgeObservableRead + Send + 'static,

pub fn new( me: OffchainPublicKey, graph: G, max_paths: usize, edge_penalty: f64, min_ack_rate: f64, ) -> Self

Create a new selector.

• me – the planner’s own offchain public key, used to determine path direction.
• graph – the network graph to query.
• max_paths – maximum number of candidate paths to return per query.
• edge_penalty – penalty multiplier for edges lacking probe-based quality observations.
• min_ack_rate – minimum acceptable message acknowledgment rate for path selection.

fn compute_extended_forward_paths( &self, src: &OffchainPublicKey, dest: &OffchainPublicKey, shorter_length: NonZeroUsize, take: usize, existing: &[PathWithCost], ) -> Vec<PathWithCost>

Extended forward path search: find shorter paths using [EdgeValueFn::forward_without_self_loopback] and append dest to each one.

This handles the case where the last edge (relay -> dest) has no graph edge (e.g. no payment channel) but the path planner can still assume the last hop is reachable. Paths already found by Phase 1 are excluded via existing.

The cost from the shorter traversal is preserved as-is — the missing last edge contributes a neutral 1.0 multiplier (no quality data available).

Trait Implementations

impl<G: Clone> Clone for HoprGraphPathSelector<G>

fn clone(&self) -> HoprGraphPathSelector<G>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<G> PathSelector for HoprGraphPathSelector<G>

where G: NetworkGraphTraverse<NodeId = OffchainPublicKey> + NetworkGraphView<NodeId = OffchainPublicKey> + Clone + Send + Sync + 'static, <G as NetworkGraphTraverse>::Observed: EdgeObservableRead + Send + 'static,

fn select_path( &self, src: OffchainPublicKey, dest: OffchainPublicKey, hops: usize, ) -> Result<Vec<PathWithCost>>

Return all candidate paths from src to dest via hops relays.

Each returned tuple contains a path Vec<OffchainPublicKey> of length hops + 1 ([intermediates..., dest]; src excluded) paired with its accumulated traversal cost.

Returns Err(PathNotFound) when the graph yields no positive-cost paths.

The function has a potential to run expensive operations, it should be benchmarked in a production environment and possibly guarded (e.g. by offloading the long execution in an async executor to avoid blocking the caller).