Struct SpanningSubgraph 

pub struct SpanningSubgraph<'a, G>
where
    G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,
{ /* private fields */ }

Implementations

impl<'a, G> SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,

pub fn add_edge(&mut self, e: Edge<G>)

pub fn set_edges<I>(&mut self, iter: I)

where G: VertexList, I: IntoIterator, I::Item: IntoOwned<Edge<G>>,

pub fn add_edges<I>(&mut self, iter: I)

where I: IntoIterator, I::Item: IntoOwned<Edge<G>>,

pub fn clear_edges(&mut self)

where G: VertexList,

pub fn replace_edge(&mut self, old: Edge<G>, new: Edge<G>)

pub fn remove_edge(&mut self, e: Edge<G>)

Trait Implementations

impl<'a, G> Adjacency for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,

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

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

impl<'a, G> AsRef<G> for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,

fn as_ref(&self) -> &G

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, G> Choose for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>> + Choose,

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<'a, G> EdgeList for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,

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, 'b, G> EdgeTypes<'a, SpanningSubgraph<'b, G>> for SpanningSubgraph<'b, G>

where G: 'b + WithEdge + WithVertexProp<Vec<Edge<G>>>,

type EdgeIter = Cloned<Iter<'a, <G as WithEdge>::Edge>>

type OutEdgeIter = Cloned<Iter<'a, <G as WithEdge>::Edge>>

impl<'a, G> Incidence for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,

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<'a, G> VertexList for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>> + VertexList,

fn num_vertices(&self) -> usize

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

impl<'a, 'b, G> VertexTypes<'a, SpanningSubgraph<'b, G>> for SpanningSubgraph<'b, G>

where G: 'b + WithEdge + WithVertexProp<Vec<Edge<G>>>,

type VertexIter = <G as VertexTypes<'b, G>>::VertexIter

type OutNeighborIter = OutNeighborFromOutEdge<'b, G, <SpanningSubgraph<'b, G> as EdgeTypes<'a, SpanningSubgraph<'b, G>>>::OutEdgeIter>

impl<'a, G> WithEdge for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,

type Kind = <G as WithEdge>::Kind

type Edge = <G as WithEdge>::Edge

type OptionEdge = <G as WithEdge>::OptionEdge

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

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

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

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

fn opposite(&self, u: Vertex<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) -> O

where I: Ends<'a, Self, O>,

fn with_ends<I>(&self, iter: I) -> EdgesWithEnds<'_, Self, I::IntoIter>

where I: IntoIterator, I::Item: IntoOwned<Edge<Self>>,

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

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

where Self: WithEdge<Kind = Undirected>,

fn edge_none() -> OptionEdge<Self>

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

fn edge_prop<P, T>(&self, value: T) -> P

where P: EdgePropMutNew<Self, T>, T: Clone,

fn edge_prop_from_fn<P, F, T>(&self, fun: F) -> P

where Self: EdgeList, P: EdgePropMutNew<Self, T>, F: FnMut(Edge<Self>) -> T, T: Default + Clone,

impl<'a, G, T> WithEdgeProp<T> for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>> + WithEdgeProp<T>,

type EdgeProp = DelegateEdgeProp<G, T>

fn default_edge_prop(&self, value: T) -> DefaultEdgePropMut<Self, T>

where T: Clone,

Creates a new default edge property where the initial value associated with each edge is value.

fn default_edge_prop_from_fn<P, F>(&self, fun: F) -> P

where Self: EdgeList, P: EdgePropMutNew<Self, T>, F: FnMut(Edge<Self>) -> T, T: Default + Clone,

Creates a new default edge property where the initial value associated with each edge e is produced by fun(e).

impl<'a, G> WithVertex for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>>,

type Vertex = <G as WithVertex>::Vertex

type OptionVertex = <G as WithVertex>::OptionVertex

fn vertex_none() -> OptionVertex<Self>

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

fn vertex_prop<P, T>(&self, value: T) -> P

where P: VertexPropMutNew<Self, T>, T: Clone,

fn vertex_prop_from_fn<P, T, F>(&self, fun: F) -> P

where Self: VertexList, P: VertexPropMutNew<Self, T>, F: FnMut(Vertex<Self>) -> T, T: Default + Clone,

impl<'a, G, T> WithVertexProp<T> for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>> + WithVertexProp<T>,

type VertexProp = DelegateVertexProp<G, T>

The vertex property type.

fn default_vertex_prop(&self, value: T) -> DefaultVertexPropMut<Self, T>

where T: Clone,

Creates a new default vertex property where the initial value associated with each vertex is value.

fn default_vertex_prop_from_fn<P, F>(&self, fun: F) -> P

where Self: VertexList, P: VertexPropMutNew<Self, T>, F: FnMut(Vertex<Self>) -> T, T: Default + Clone,

Creates a new default vertex property where the initial value associated with each vertex v is produced by fun(v).

impl<'a, G> BasicEdgeProps for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>> + BasicEdgeProps,

impl<'a, G> BasicProps for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>> + BasicProps,

impl<'a, G> BasicVertexProps for SpanningSubgraph<'a, G>

where G: 'a + WithEdge + WithVertexProp<Vec<Edge<G>>> + BasicVertexProps,