[−][src]Struct generic_graph::adjacency_list::elements::DirectedEdge
The DirectedEdge type is the implementation an implementation od the Edge trait that uses CompoundKey as type, as such it also indicates the direction of the edge which lead from the left vertex to the right one.
Methods
impl<K: Hash + Eq + Clone, W: Add + Sub + Eq + Ord + Copy> DirectedEdge<K, W>
[src]
pub fn new(left: K, right: K, weight: W) -> DirectedEdge<K, W>
[src]
Returns an instance of Directed edge with the specified weight and pair of vertex keys
Trait Implementations
impl<K: Clone, W: Clone> Clone for DirectedEdge<K, W> where
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
[src]
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
fn clone(&self) -> DirectedEdge<K, W>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<K: Debug, W: Debug> Debug for DirectedEdge<K, W> where
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
[src]
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
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
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
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
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: Hash + Eq + Clone, W: Add + Sub + Eq + Ord + Copy> Edge<K, W, CompoundKey<K>> for DirectedEdge<K, W>
[src]
DirectedEdge
implement the Edge trait Specifying the edge key type (CompoundKey). But the vertex key type
and the edge weight type remain generics.
fn get_weight(&self) -> W
[src]
Returns a copy of the weight (the weight type is required to implement Copy)
fn set_weight(&mut self, weight: W)
[src]
change the value of weight
fn left(&self) -> &K
[src]
Returns a reference to the key of the left hand vertex
fn right(&self) -> &K
[src]
Returns a reference to the key of the right hand vertex
fn get_pair(&self) -> (&K, &K)
[src]
Returns a pair of reference to the vertex keys. Ordered from left to right
fn generate_key(pair: (&K, &K)) -> CompoundKey<K>
[src]
Returns a new instance of CompoundKey from a pair of reference to vertex keys
Example
use generic_graph::adjacency_list::elements::DirectedEdge; use generic_graph::Edge; let edge = DirectedEdge::new(1, 2, 3); let key = DirectedEdge::<i32, i32>::generate_key(edge.get_pair()); assert_eq!(key, edge.key());
fn key(&self) -> CompoundKey<K>
[src]
Returns an new instance of CompoundKey generated from the pair of keys stored isn the edge
Example
use generic_graph::adjacency_list::elements::DirectedEdge; use generic_graph::Edge; let edge = DirectedEdge::new(1, 2, 3); let key = DirectedEdge::<i32, i32>::generate_key(edge.get_pair()); assert_eq!(key, edge.key());
impl<K: Eq, W: Eq> Eq for DirectedEdge<K, W> where
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
[src]
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
impl<K: PartialEq, W: PartialEq> PartialEq<DirectedEdge<K, W>> for DirectedEdge<K, W> where
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
[src]
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
fn eq(&self, other: &DirectedEdge<K, W>) -> bool
[src]
fn ne(&self, other: &DirectedEdge<K, W>) -> bool
[src]
impl<K, W> StructuralEq for DirectedEdge<K, W> where
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
[src]
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
impl<K, W> StructuralPartialEq for DirectedEdge<K, W> where
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
[src]
K: Hash + Eq + Clone,
W: Add + Sub + Eq + Ord + Copy,
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));
Auto Trait Implementations
impl<K, W> RefUnwindSafe for DirectedEdge<K, W> where
K: RefUnwindSafe,
W: RefUnwindSafe,
K: RefUnwindSafe,
W: RefUnwindSafe,
impl<K, W> Send for DirectedEdge<K, W> where
K: Send,
W: Send,
K: Send,
W: Send,
impl<K, W> Sync for DirectedEdge<K, W> where
K: Sync,
W: Sync,
K: Sync,
W: Sync,
impl<K, W> Unpin for DirectedEdge<K, W> where
K: Unpin,
W: Unpin,
K: Unpin,
W: Unpin,
impl<K, W> UnwindSafe for DirectedEdge<K, W> where
K: UnwindSafe,
W: UnwindSafe,
K: UnwindSafe,
W: 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> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
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>,