Struct hierarchical_pathfinding::generics::Path

pub struct Path<P> { /* fields omitted */ }

A generic implementation of a Path

Stores a sequence of Nodes and the total Cost of traversing these Nodes. Note that the individual costs of the steps within the Path cannot be retrieved through this struct.

This struct does not own the actual Path, it merely keeps an [Rc] to it. This makes cloning and reversing very efficient, but makes them immutable and limits some ways to access the contents

Implementations

impl<P> Path<P>

pub fn new(path: Vec<P>, cost: Cost) -> Path<P>

creates a new Path with the given sequence of Nodes and total Cost

Examples

Basic usage:

let path = Path::new(vec!['a', 'b', 'c'], 42);

assert_eq!(path, vec!['a', 'b', 'c']);
assert_eq!(path.cost(), 42);

pub fn from_slice(path: &[P], cost: Cost) -> Path<P> where
    P: Clone, 

creates a new Path with the given sequence of Nodes and total Cost

Examples

Basic usage:

let path = Path::from_slice(&['a', 'b', 'c'], 42);

assert_eq!(path, vec!['a', 'b', 'c']);
assert_eq!(path.cost(), 42);

pub fn cost(&self) -> Cost

Returns the Cost of the Path

pub fn len(&self) -> usize

Returns the length of the Path

pub fn is_empty(&self) -> bool

Returns if the Path is empty

pub fn reversed(&self, start_cost: Cost, end_cost: Cost) -> Path<P> where
    P: Clone, 

Returns a reversed version of the Path.

start_cost is what need to be subtracted, and end_cost is what needs to be added to the cost in the case of asymmetric paths. Can be set to 0 for symmetric paths.

This operation is low cost since Paths are based on [Rc]s.

Examples

Basic usage:

let path = Path::new(vec!['a', 'b', 'c'], 42);
let reversed = path.reversed(5, 2);

assert_eq!(reversed, vec!['c', 'b', 'a']);
assert_eq!(reversed.cost(), 39);

pub fn iter(&self) -> Iter<'_, P>

Returns an Iterator over the Path

pub fn as_vec(&self) -> Vec<P> where
    P: Clone, 

Extracts a Vec from the Path, cloning the data

Trait Implementations

impl<P: Clone> Clone for Path<P>

fn clone(&self) -> Path<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Path<P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P: Display> Display for Path<P>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P: Eq> Eq for Path<P>

impl<P> Index<usize> for Path<P>

type Output = P

The returned type after indexing.

fn index(&self, index: usize) -> &P

Performs the indexing (container[index]) operation.

impl<P: Eq> Ord for Path<P>

fn cmp(&self, other: &Path<P>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a, P: PartialEq> PartialEq<&'a [P]> for Path<P>

fn eq(&self, rhs: &&'a [P]) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<P: PartialEq> PartialEq<Path<P>> for Path<P>

fn eq(&self, other: &Path<P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Path<P>) -> bool

This method tests for !=.

impl<P: PartialEq> PartialEq<Vec<P>> for Path<P>

fn eq(&self, rhs: &Vec<P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<P: PartialEq> PartialOrd<Path<P>> for Path<P>

fn partial_cmp(&self, other: &Path<P>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P> StructuralEq for Path<P>

impl<P> StructuralPartialEq for Path<P>