Struct GraphTransaction

pub struct GraphTransaction<'a, T> { /* private fields */ }

Tracks changes and provides rollback capability

Implementations

impl<'a, T> GraphTransaction<'a, T>

pub fn new(graph: &'a mut Graph<T>) -> Self

pub fn commit(self) -> TransactionResult<T>

pub fn commit_with( self, validator: Option<&dyn Fn(&Graph<T>) -> bool>, ) -> TransactionResult<T>

pub fn len(&self) -> usize

pub fn add_node(&mut self, node: GraphNode<T>) -> usize

pub fn attach(&mut self, from: usize, to: usize)

pub fn detach(&mut self, from: usize, to: usize)

pub fn change_direction(&mut self, index: usize, direction: Direction)

pub fn rollback(self) -> Vec<ReplayStep<T>>

pub fn replay(&mut self, steps: Vec<ReplayStep<T>>)

pub fn is_valid(&self) -> bool

pub fn set_cycles(&mut self)

pub fn get_insertion_steps( &self, source_idx: usize, target_idx: usize, new_node_idx: usize, ) -> Vec<InsertStep>

pub fn random_source_node(&self) -> Option<&GraphNode<T>>

The below functions are used to get random nodes from the graph. These are useful for creating connections between nodes. Neither of these functions will return an edge node. This is because edge nodes are not valid source or target nodes for connections as they they only allow one incoming and one outgoing connection, thus they can’t be used to create new connections. Instread, edge nodes are used to represent the weights of the connections

Get a random node that can be used as a source node for a connection. A source node can be either an input or a vertex node.

pub fn random_target_node(&self) -> Option<&GraphNode<T>>

Get a random node that can be used as a target node for a connection. A target node can be either an output or a vertex node.

Methods from Deref<Target = Graph<T>>

pub fn len(&self) -> usize

Returns the number of nodes in the graph.

pub fn is_empty(&self) -> bool

Returns true if the graph is empty.

pub fn get(&self, index: usize) -> Option<&GraphNode<T>>

Returns a reference to the node at the specified index.

pub fn iter(&self) -> impl Iterator<Item = &GraphNode<T>>

iterates over the nodes in the graph. The nodes are returned in the order they were added, so there is no real order to this iterator.

pub fn get_cycles(&self, index: usize) -> Vec<usize>

Get the cycles in the graph that include the node at the specified index.

Arguments

• index: The index of the node to get the cycles for.

Trait Implementations

impl<'a, T> Deref for GraphTransaction<'a, T>

type Target = Graph<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.