Struct fera_graph::graphs::static_::Static

pub struct Static<V: Num, K: StaticEdgeKind> { /* private fields */ }

Trait Implementations

impl<V: Num, K: StaticEdgeKind> Adjacency for Static<V, K>

fn out_neighbors(&self, v: Vertex<Self>) -> OutNeighborIter<'_, Self>

fn out_degree(&self, v: Vertex<Self>) -> usize

impl<V: Num, K: StaticEdgeKind> Choose for Static<V, K>

fn choose_vertex<R: Rng>(&self, rng: R) -> Option<Vertex<Self>>

Returns a random vertex of this graph or None if the graph has no vertices.

fn choose_out_neighbor<R: Rng>(
    &self,
    v: Vertex<Self>,
    rng: R
) -> Option<Vertex<Self>>

Returns a random neighbor vertex of v or None if v has no neighbors.

fn choose_edge<R: Rng>(&self, rng: R) -> Option<Edge<Self>>

Returns a random edge of this graph or None if the graph has no edges.

fn choose_out_edge<R: Rng>(&self, v: Vertex<Self>, rng: R) -> Option<Edge<Self>>

Returns a random out edge of v or None if v has no out edges.

fn choose_vertex_iter<R: Rng>(&self, rng: R) -> ChooseVertexIter<'_, Self, R>

Returns an iterator that repeatedly calls choose_vertex.

fn choose_out_neighbor_iter<R: Rng>(
    &self,
    v: Vertex<Self>,
    rng: R
) -> ChooseOutNeighborIter<'_, Self, R>

Returns an iterator that repeatedly calls choose_out_neighbor(v).

fn choose_edge_iter<R: Rng>(&self, rng: R) -> ChooseEdgeIter<'_, Self, R>

Returns an iterator that repeatedly calls choose_edge.

fn choose_out_edge_iter<R: Rng>(
    &self,
    v: Vertex<Self>,
    rng: R
) -> ChooseOutEdgeIter<'_, Self, R>

Returns an iterator that repeatedly calls choose_out_edge(v).

fn random_walk<R: Rng>(&self, rng: R) -> RandomWalk<'_, Self, R>

Returns a iterator that produces a sequence of random edges that forms a walk, that is, the target vertex of the previous edge is the source vertex of the next edge.

impl<V: Clone + Num, K: Clone + StaticEdgeKind> Clone for Static<V, K>where
    K::Edge: Clone,

fn clone(&self) -> Static<V, K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug + Num, K: Debug + StaticEdgeKind> Debug for Static<V, K>where
    K::Edge: Debug,

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

Formats the value using the given formatter.

impl<V: Num, K: StaticEdgeKind> EdgeList for Static<V, K>

fn num_edges(&self) -> usize

fn edges(&self) -> EdgeIter<'_, Self>

fn get_edge_by_ends(&self, u: Vertex<Self>, v: Vertex<Self>) -> Option<Edge<Self>>

fn edges_ends(&self) -> EdgesEnds<'_, Self, EdgeIter<'_, Self>>

fn edges_with_ends(&self) -> EdgesWithEnds<'_, Self, EdgeIter<'_, Self>>

fn edge_by_ends(&self, u: Vertex<Self>, v: Vertex<Self>) -> Edge<Self>

impl<'a, V: Num, K: StaticEdgeKind> EdgeTypes<'a, Static<V, K>> for Static<V, K>

type EdgeIter = Map<Range<usize>, fn(_: usize) -> <K as StaticEdgeKind>::Edge>

type OutEdgeIter = Cloned<Iter<'a, <Static<V, K> as WithEdge>::Edge>>

impl<V: Num, K: StaticEdgeKind> Incidence for Static<V, K>

fn out_edges(&self, v: Vertex<Self>) -> OutEdgeIter<'_, Self>

fn out_edges_ends(
    &self,
    v: Vertex<Self>
) -> EdgesEnds<'_, Self, OutEdgeIter<'_, Self>>

fn out_edges_with_ends(
    &self,
    v: Vertex<Self>
) -> EdgesWithEnds<'_, Self, OutEdgeIter<'_, Self>>

impl<V: PartialEq + Num, K: PartialEq + StaticEdgeKind> PartialEq<Static<V, K>> for Static<V, K>where
    K::Edge: PartialEq,

fn eq(&self, other: &Static<V, K>) -> bool

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

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

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

impl<V: Num, K: StaticEdgeKind> VertexList for Static<V, K>

fn num_vertices(&self) -> usize

fn vertices(&self) -> VertexIter<'_, Self>

impl<'a, V: Num, K: StaticEdgeKind> VertexTypes<'a, Static<V, K>> for Static<V, K>

type VertexIter = <V as Num>::Range

type OutNeighborIter = OutNeighborFromOutEdge<'a, Static<V, K>, <Static<V, K> as EdgeTypes<'a, Static<V, K>>>::OutEdgeIter>

impl<V: Num, K: StaticEdgeKind> WithBuilder for Static<V, K>

type Builder = StaticBuilder<V, K>

The builder for this graph type.

fn builder(num_vertices: usize, num_edges: usize) -> Self::Builder

Creates a new builder for a graph of this type with n vertices and initial capacity for m edges.

fn new_with_edges<I>(n: usize, edges: I) -> Selfwhere
    I: IntoIterator<Item = (usize, usize)>,

Creates a new graph with n vertices from edges iterator.

fn new_empty(n: usize) -> Self

Creates a graph with n vertices and no edges.

fn new_random_tree<R: Rng>(n: usize, rng: R) -> Self

Creates a graph with n vertices that is a tree, that is, is connected and acyclic.

fn new_random_tree_with_diameter<R: Rng>(n: u32, d: u32, rng: R) -> Option<Self>

Similar to [new_random_tree] but creates a tree with diameter d. Returns None if the diameter is invalid.

impl<V: Num, K: StaticEdgeKind> WithEdge for Static<V, K>

type Kind = <K as StaticEdgeKind>::Kind

type Edge = <K as StaticEdgeKind>::Edge

type OptionEdge = Optioned<<Static<V, K> as WithEdge>::Edge, MaxNone<<Static<V, K> as WithEdge>::Edge>>

fn orientation(&self, _e: Edge<Self>) -> Orientation

fn source(&self, e: Edge<Self>) -> Vertex<Self>

fn target(&self, e: Edge<Self>) -> Vertex<Self>

fn get_reverse(&self, e: Edge<Self>) -> Option<Edge<Self>>

fn ends<'a, I, O>(&'a self, item: I) -> Owhere
    I: Ends<'a, Self, O>,

fn end_vertices(&self, e: Edge<Self>) -> (Vertex<Self>, Vertex<Self>)

fn with_ends<I>(&self, iter: I) -> EdgesWithEnds<'_, Self, I::IntoIter> where
    I: IntoIterator,
    I::Item: IntoOwned<Edge<Self>>,

fn opposite(&self, u: Vertex<Self>, e: Edge<Self>) -> Vertex<Self>

fn is_incident(&self, v: Vertex<Self>, e: Edge<Self>) -> bool

fn edge_none() -> OptionEdge<Self>

fn edge_some(e: Edge<Self>) -> OptionEdge<Self>

fn edge_prop<P, T>(&self, value: T) -> Pwhere
    P: EdgePropMutNew<Self, T>,
    T: Clone,

fn edge_prop_from_fn<P, F, T>(&self, fun: F) -> Pwhere
    Self: EdgeList,
    P: EdgePropMutNew<Self, T>,
    F: FnMut(Edge<Self>) -> T,
    T: Default + Clone,

impl<V: Num, K: StaticEdgeKind> WithEdgeIndexProp for Static<V, K>

type EdgeIndexProp = SEdgeIndexProp<K>

fn edge_index(&self) -> EdgeIndexProp<Self>

Creates an edge index map.

impl<T, V: Num, K: StaticEdgeKind> WithEdgeProp<T> for Static<V, K>

type EdgeProp = ArrayProp<<Static<V, K> as WithEdgeIndexProp>::EdgeIndexProp, Vec<T, Global>>

impl<V: Num, K: StaticEdgeKind> WithVertex for Static<V, K>

type Vertex = V

type OptionVertex = Optioned<V, MaxNone<V>>

fn vertex_none() -> OptionVertex<Self>

fn vertex_some(v: Vertex<Self>) -> OptionVertex<Self>

fn vertex_prop<P, T>(&self, value: T) -> Pwhere
    P: VertexPropMutNew<Self, T>,
    T: Clone,

fn vertex_prop_from_fn<P, T, F>(&self, fun: F) -> Pwhere
    Self: VertexList,
    P: VertexPropMutNew<Self, T>,
    F: FnMut(Vertex<Self>) -> T,
    T: Default + Clone,

impl<V: Num, K: StaticEdgeKind> WithVertexIndexProp for Static<V, K>

type VertexIndexProp = SVertexIndexProp

fn vertex_index(&self) -> VertexIndexProp<Self>

Creates an vertex index map.

impl<T, V: Num, K: StaticEdgeKind> WithVertexProp<T> for Static<V, K>

type VertexProp = ArrayProp<<Static<V, K> as WithVertexIndexProp>::VertexIndexProp, Vec<T, Global>>

The vertex property type.

impl<V: Num, K: StaticEdgeKind> BasicEdgeProps for Static<V, K>

impl<V: Num, K: StaticEdgeKind> BasicProps for Static<V, K>

impl<V: Num, K: StaticEdgeKind> BasicVertexProps for Static<V, K>

impl<V: Num, K: StaticEdgeKind> StructuralPartialEq for Static<V, K>