Struct ddgg::Graph

pub struct Graph<V, E> { /* private fields */ }

Main graph structure

Implementations

impl<V, E> Graph<V, E>

pub fn from_constraints() -> Graph<V, E>

impl<V: Clone, E: Clone> Graph<V, E>

pub fn new() -> Graph<V, E>

pub fn add_vertex(&mut self, vertex_data: V) -> (VertexIndex, GraphDiff<V, E>)

pub fn add_edge( &mut self, from_index: VertexIndex, to_index: VertexIndex, edge_data: E ) -> Result<(EdgeIndex, GraphDiff<V, E>), GraphError>

pub fn update_vertex( &mut self, index: VertexIndex, value: V ) -> Result<(V, GraphDiff<V, E>), GraphError>

pub fn update_edge( &mut self, index: EdgeIndex, value: E ) -> Result<(E, GraphDiff<V, E>), GraphError>

pub fn remove_edge( &mut self, edge_index: EdgeIndex ) -> Result<(E, GraphDiff<V, E>), GraphError>

pub fn remove_vertex( &mut self, vertex_index: VertexIndex ) -> Result<(V, GraphDiff<V, E>), GraphError>

pub fn apply_diff(&mut self, diff: GraphDiff<V, E>) -> Result<(), GraphError>

pub fn rollback_diff(&mut self, diff: GraphDiff<V, E>) -> Result<(), GraphError>

impl<V: Clone, E: Clone> Graph<V, E>

pub fn get_vertex(&self, index: VertexIndex) -> Option<&Vertex<V>>

pub fn get_vertex_data(&self, index: VertexIndex) -> Option<&V>

pub fn get_vertex_data_mut(&mut self, index: VertexIndex) -> Option<&mut V>

Note: changes here will not be tracked. It’s usually better to use Graph::update_vertex

pub fn get_edge(&self, index: EdgeIndex) -> Option<&Edge<E>>

pub fn get_edge_data(&self, index: EdgeIndex) -> Option<&E>

pub fn get_edge_data_mut(&mut self, index: EdgeIndex) -> Option<&mut E>

Note: changes here will not be tracked. It’s usually better to use Graph::update_edge

pub fn assert_vertex_exists(&self, index: VertexIndex) -> Result<(), GraphError>

Check that a vertex exists. Returns a result containing VertexDoesNotExist if it doesn’t exist

pub fn assert_edge_exists(&self, index: EdgeIndex) -> Result<(), GraphError>

pub fn shared_edges( &self, from: VertexIndex, to: VertexIndex ) -> Result<impl Iterator<Item = EdgeIndex> + '_, GraphError>

Get a list of edges between two nodes. This only returns connections in one direction.

pub fn get_verticies(&self) -> &GenVec<Vertex<V>>

pub fn get_edges(&self) -> &GenVec<Edge<E>>

pub fn vertex_indexes(&self) -> impl Iterator<Item = VertexIndex> + '_

pub fn edge_indexes(&self) -> impl Iterator<Item = EdgeIndex> + '_

pub fn vertex_iter( &self ) -> impl Iterator<Item = (VertexIndex, &Vertex<V>)> + '_

pub fn edge_iter(&self) -> impl Iterator<Item = (EdgeIndex, &Edge<E>)> + '_

pub fn vertex_data_iter(&self) -> impl Iterator<Item = (VertexIndex, &V)> + '_

pub fn edge_data_iter(&self) -> impl Iterator<Item = (EdgeIndex, &E)> + '_

Trait Implementations

impl<V: Clone, E: Clone> Clone for Graph<V, E>

fn clone(&self) -> Graph<V, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, E: Debug> Debug for Graph<V, E>

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

Formats the value using the given formatter.

impl<V: Clone, E: Clone> Default for Graph<V, E>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, V, E> Deserialize<'de> for Graph<V, E>

where V: Deserialize<'de>, E: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V: Clone, E: Clone> Index<EdgeIndex> for Graph<V, E>

type Output = Edge<E>

The returned type after indexing.

fn index(&self, index: EdgeIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<V: Clone, E: Clone> Index<VertexIndex> for Graph<V, E>

type Output = Vertex<V>

The returned type after indexing.

fn index(&self, index: VertexIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<V: Clone, E: Clone> IndexMut<EdgeIndex> for Graph<V, E>

fn index_mut(&mut self, index: EdgeIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<V: Clone, E: Clone> IndexMut<VertexIndex> for Graph<V, E>

fn index_mut(&mut self, index: VertexIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<V, E> Serialize for Graph<V, E>

where V: Serialize, E: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.