Struct Neighbors

pub struct Neighbors<A> {
    pub me: Option<A>,
    pub parent: Option<A>,
    pub first_child: Option<A>,
    pub next_sibling: Option<A>,
    pub prev_sibling: Option<A>,
}

Structure containing neighboring information for a node.

Internally (for the navigator) this structure is used with A=usize to store how neighboring and (therby navigaiton) information for nodes (which noce is the parent node i.E.).

But it can also be used (and that is why it is public) for other neighboring information, like all the neighboring values of nodes.

Fields

me: Option<A>

parent: Option<A>

first_child: Option<A>

next_sibling: Option<A>

prev_sibling: Option<A>

Implementations

impl<A> Neighbors<A>

pub fn map<B, F>(&self, f: F) -> Neighbors<B>

where F: Fn(&A) -> B,

Map all the neigbors (which are not None) to some other value using the provided function.

Arguments

• f - The function used for mapping the values.

Result

A neighbors structure, where the neighbors are exchanged by the corresponding result of f.

pub fn map_and_then<B, F>(&self, f: F) -> Neighbors<B>

where F: Fn(&A) -> Option<B>,

Same as map, but removes double “Option” for a mapping function that returns an option.

impl<A> Neighbors<&A>

pub fn cloned(&self) -> Neighbors<A>

where A: Clone,

Clone the contained values (which have to be references)

impl Neighbors<usize>

pub fn map_and_then_with_values<'a, B>( &self, v: &'a [Option<B>], ) -> Neighbors<&'a B>

Do map_end_then but don’t use a mapping function but take the values directly form an vec.

Trait Implementations

impl<A: Clone> Clone for Neighbors<A>

fn clone(&self) -> Neighbors<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Neighbors<A>

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

Formats the value using the given formatter.

impl<A: PartialEq> PartialEq for Neighbors<A>

fn eq(&self, other: &Neighbors<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Eq> Eq for Neighbors<A>

impl<A> StructuralPartialEq for Neighbors<A>