[−][src]Struct generic_graph::SimpleVertex
A default implementation for vertexes. This implementation should be suitable for most of the problem one can encounter requiring graph.
Contrary to other graph implementation this library does not expect the vertexes to store if they have been visited, or if they were marked. The reason for this is that the author believes such an information should be stored in a structure extern and independent to the graph, this to ensure consistency between threads and to allow different algorithms to use different structures according to their needs
methods are self explanatory
Methods
impl<K: Hash + Eq + Clone, V> SimpleVertex<K, V>
[src]
pub fn new(key: K, value: V) -> SimpleVertex<K, V>
[src]
Creates a new instance of SimpleVertex
Trait Implementations
impl<K: Debug + Hash + Eq + Clone, V: Debug> Debug for SimpleVertex<K, V>
[src]
impl<K: Hash + Eq + Clone, V, W: Add + Sub + Eq + Ord + Copy> DirectedGraph<SimpleVertex<K, V>, DirectedEdge<K, W>, K, V, W, CompoundKey<K>> for AdjacencyGraph<K, V, W>
[src]
AdjacencyGraph
implement the DirectedGraph trait Specifying the vertex type (DirectedVertex),
the edge type (Directed Edge), and the edge key type (CompoundKey). But the vertex key type,
the vertex value type and the edge weight type remain generics.
fn adjacent(&self, from: &K, to: &K) -> bool
[src]
Check if an edge going from the first to the second vertex exists
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes, VariableEdges, DirectedGraph}; use generic_graph::adjacency_list::elements::DirectedEdge; let mut graph = AdjacencyGraph::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); graph.add_vertex(SimpleVertex::new(3, "c")); graph.add_edge(DirectedEdge::new(2, 3, 3)).expect("Won't fail"); graph.add_edge(DirectedEdge::new(1, 3, 3)).expect("Won't fail"); assert_eq!(true, graph.adjacent(&1, &3)); assert_eq!(false, graph.adjacent(&3, &1)); assert_eq!(false, graph.adjacent(&2, &1));
fn neighbors(&self, from: &K) -> Vec<&K>
[src]
Returns a Vector containing the keys of the vertexes reached by edges leaving from the vertex identified by the passed key
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes, VariableEdges, DirectedGraph}; use generic_graph::adjacency_list::elements::DirectedEdge; let mut graph = AdjacencyGraph::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); graph.add_vertex(SimpleVertex::new(3, "c")); graph.add_edge(DirectedEdge::new(2, 3, 3)).expect("Won't fail"); graph.add_edge(DirectedEdge::new(2, 1, 3)).expect("Won't fail"); graph.add_edge(DirectedEdge::new(1, 3, 3)).expect("Won't fail"); let mut neighbors = graph.neighbors(&2); neighbors.sort(); assert_eq!(neighbors, vec![&1,&3]);
fn leading_to(&self, to: &K) -> Vec<&K>
[src]
Returns a vector containing the keys of the Vertexes from which an edge leave to reach the vertex identified by the passed key
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes, VariableEdges, DirectedGraph}; use generic_graph::adjacency_list::elements::DirectedEdge; let mut graph = AdjacencyGraph::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); graph.add_vertex(SimpleVertex::new(3, "c")); graph.add_edge(DirectedEdge::new(2, 3, 3)).expect("Won't fail"); graph.add_edge(DirectedEdge::new(1, 3, 3)).expect("Won't fail"); let mut leading_to = graph.leading_to(&3); leading_to.sort(); assert_eq!(leading_to, vec![&1,&2]);
fn get_all_keys(&self) -> Vec<&K>
[src]
Returns a vector containing the references to keys of all vertexes in the graph
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes, VariableEdges, DirectedGraph}; use generic_graph::adjacency_list::elements::DirectedEdge; let mut graph = AdjacencyGraph::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); graph.add_vertex(SimpleVertex::new(3, "c")); graph.add_edge(DirectedEdge::new(2, 3, 3)).expect("Won't fail"); graph.add_edge(DirectedEdge::new(1, 3, 3)).expect("Won't fail"); let mut keys = graph.get_all_keys(); keys.sort(); assert_eq!(keys, vec![&1, &2, &3]);
fn get_all_pairs(&self) -> Vec<(&K, &K)>
[src]
Returns a vector containing the pairs of all edges in the graph
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes, VariableEdges, DirectedGraph}; use generic_graph::adjacency_list::elements::DirectedEdge; let mut graph = AdjacencyGraph::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); graph.add_vertex(SimpleVertex::new(3, "c")); graph.add_edge(DirectedEdge::new(2, 3, 3)).expect("Won't fail"); graph.add_edge(DirectedEdge::new(1, 3, 3)).expect("Won't fail"); let mut pairs = graph.get_all_pairs(); pairs.sort(); assert_eq!(pairs, vec![(&1, &3), (&2, &3)]);
fn get_vertex(&self, key: &K) -> Option<&SimpleVertex<K, V>>
[src]
Returns a reference to the vertex identified by the passed key
fn get_mut_vertex(&mut self, key: &K) -> Option<&mut SimpleVertex<K, V>>
[src]
Returns a mutable reference to the vertex identified by the passed key
fn get_edge(&self, pair: (&K, &K)) -> Option<&DirectedEdge<K, W>>
[src]
Returns a reference to the edge identified by the passed pair of keys
fn get_mut_edge(&mut self, pair: (&K, &K)) -> Option<&mut DirectedEdge<K, W>>
[src]
Returns a mutable reference to the edge identified by the passed pair of keys
impl<K: Eq + Hash + Clone, V: Eq> Eq for SimpleVertex<K, V>
[src]
impl<K: PartialEq + Hash + Eq + Clone, V: PartialEq> PartialEq<SimpleVertex<K, V>> for SimpleVertex<K, V>
[src]
fn eq(&self, other: &SimpleVertex<K, V>) -> bool
[src]
fn ne(&self, other: &SimpleVertex<K, V>) -> bool
[src]
impl<K: Hash + Eq + Clone, V> StructuralEq for SimpleVertex<K, V>
[src]
impl<K: Hash + Eq + Clone, V> StructuralPartialEq for SimpleVertex<K, V>
[src]
impl<K: Hash + Eq + Clone, V, W: Add + Sub + Eq + Ord + Copy> VariableEdges<SimpleVertex<K, V>, DirectedEdge<K, W>, K, V, W, CompoundKey<K>> for AdjacencyGraph<K, V, W>
[src]
AdjacencyGraph
uses HashMaps to store edges, allowing fast insertion and removal of the latter
fn add_edge(
&mut self,
edge: DirectedEdge<K, W>
) -> Result<Option<DirectedEdge<K, W>>, EdgeSide>
[src]
&mut self,
edge: DirectedEdge<K, W>
) -> Result<Option<DirectedEdge<K, W>>, EdgeSide>
The add_edge()
method shall return Ok(None)
if the element was not previously set. Otherwise the element shall be updated (but no the key)
and the old element shall be returned as Ok(Some(old_element))
. If one or both of the concerned vertexes are missing an error
containing an enum specifying which side is missing (Err(EdgeSide)
)
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes, VariableEdges}; use generic_graph::adjacency_list::elements::DirectedEdge; use generic_graph::EdgeSide::Right; let mut graph = AdjacencyGraph::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); graph.add_vertex(SimpleVertex::new(3, "c")); assert_eq!(Ok(None), graph.add_edge(DirectedEdge::new(1, 2, 0))); assert_eq!(Ok(None), graph.add_edge(DirectedEdge::new(2, 1, 0))); assert_eq!(Ok(None), graph.add_edge(DirectedEdge::new(3, 2, 0))); assert_eq!( Ok(Some(DirectedEdge::new(1, 2, 0))), graph.add_edge(DirectedEdge::new(1, 2, 3)) ); assert_eq!(Err(Right), graph.add_edge(DirectedEdge::new(1, 4, 0)));
fn remove_edge(&mut self, pair: (&K, &K)) -> Option<DirectedEdge<K, W>>
[src]
The remove_edge()
method shall return None
if the element was not found, or Some(element)
if it was found and removed.
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes, VariableEdges}; use generic_graph::adjacency_list::elements::DirectedEdge; use generic_graph::EdgeSide::Right; let mut graph = AdjacencyGraph::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); graph.add_edge(DirectedEdge::new(1, 2, 3)); assert_eq!( Some(DirectedEdge::new(1, 2, 3)), graph.remove_edge((&1, &2)) ); assert_eq!(None, graph.remove_edge((&1, &2)));
impl<K: Hash + Eq + Clone, V, W: Add + Sub + Eq + Ord + Copy> VariableVertexes<SimpleVertex<K, V>, DirectedEdge<K, W>, K, V, W, CompoundKey<K>> for AdjacencyGraph<K, V, W>
[src]
AdjacencyGraph
uses HashMaps to store vertexes, allowing fast insertion and removal of the latter
fn add_vertex(
&mut self,
vertex: SimpleVertex<K, V>
) -> Option<SimpleVertex<K, V>>
[src]
&mut self,
vertex: SimpleVertex<K, V>
) -> Option<SimpleVertex<K, V>>
This method adds (or, if present, updates maintaining its edges) a vertex and returns None ore Some(old_vertex)
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes}; let mut graph = AdjacencyGraph::<i32, &str, i32>::new(); assert_eq!(None, graph.add_vertex(SimpleVertex::new(1, "a"))); assert_eq!(None, graph.add_vertex(SimpleVertex::new(2, "b"))); assert_eq!(Some(SimpleVertex::new(1, "a")), graph.add_vertex(SimpleVertex::new(1, "c")))
fn remove_vertex(&mut self, key: K) -> Option<SimpleVertex<K, V>>
[src]
This method removes a vertex and its edges from the graph and returns None ore Some(old_vertex)
Examples
use generic_graph::adjacency_list::AdjacencyGraph; use generic_graph::{SimpleVertex, VariableVertexes}; let mut graph = AdjacencyGraph::<i32, &str, i32>::new(); graph.add_vertex(SimpleVertex::new(1, "a")); graph.add_vertex(SimpleVertex::new(2, "b")); assert_eq!(None, graph.remove_vertex(0)); assert_eq!(Some(SimpleVertex::new(1, "a")), graph.remove_vertex(1)); assert_eq!(Some(SimpleVertex::new(2, "b")), graph.remove_vertex(2)); assert_eq!(None, graph.remove_vertex(1));
impl<K: Hash + Eq + Clone, V> Vertex<K, V> for SimpleVertex<K, V>
[src]
SimpleVertex
implement the Vertex trait maintaining the key type and the value type generics
Auto Trait Implementations
impl<K, V> RefUnwindSafe for SimpleVertex<K, V> where
K: RefUnwindSafe,
V: RefUnwindSafe,
K: RefUnwindSafe,
V: RefUnwindSafe,
impl<K, V> Send for SimpleVertex<K, V> where
K: Send,
V: Send,
K: Send,
V: Send,
impl<K, V> Sync for SimpleVertex<K, V> where
K: Sync,
V: Sync,
K: Sync,
V: Sync,
impl<K, V> Unpin for SimpleVertex<K, V> where
K: Unpin,
V: Unpin,
K: Unpin,
V: Unpin,
impl<K, V> UnwindSafe for SimpleVertex<K, V> where
K: UnwindSafe,
V: UnwindSafe,
K: UnwindSafe,
V: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,