Struct BfsOptions 

pub struct BfsOptions<'a> {
    pub mode: NeighborMode,
    pub unreachable: bool,
    pub restricted: Option<&'a [VertexId]>,
}

Parameters of a breadth-first search (Graph::bfs, Graph::bfs_with).

The defaults are: follow out-edges (NeighborMode::Out), do not visit vertices unreachable from the roots, no restriction.

use igraph::prelude::*;
use igraph::visitor::BfsOptions;

let restricted = [0, 1, 2];
let opts = BfsOptions::default()
    .with_mode(NeighborMode::All)
    .with_unreachable(true)
    .with_restricted(&restricted);
assert_eq!(opts.mode, NeighborMode::All);
assert!(opts.unreachable);
assert_eq!(opts.restricted, Some(&restricted[..]));

Fields

mode: NeighborMode

Which edges to follow in directed graphs: NeighborMode::Out follows the edge directions, NeighborMode::In goes against them and NeighborMode::All ignores them. Ignored for undirected graphs.

unreachable: bool

If true, once the roots are exhausted, further searches are started from the not yet visited vertices, in increasing id order, until every (allowed) vertex has been visited.

restricted: Option<&'a [VertexId]>

If set, the search only walks on these vertices: every other vertex is treated as already visited (even when it is given as a root, in which case it is silently skipped).

Implementations

impl<'a> BfsOptions<'a>

pub fn with_mode(self, mode: NeighborMode) -> Self

Sets mode.

pub fn with_unreachable(self, unreachable: bool) -> Self

Sets unreachable.

pub fn with_restricted(self, vertices: &'a [VertexId]) -> Self

Sets restricted to Some(vertices).

Trait Implementations

impl<'a> Clone for BfsOptions<'a>

fn clone(&self) -> BfsOptions<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for BfsOptions<'a>

impl<'a> Debug for BfsOptions<'a>

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

Formats the value using the given formatter.

impl Default for BfsOptions<'_>

fn default() -> Self

Returns the “default value” for a type.

impl<'a> Eq for BfsOptions<'a>

impl<'a> PartialEq for BfsOptions<'a>

fn eq(&self, other: &BfsOptions<'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> StructuralPartialEq for BfsOptions<'a>