Struct caffe2_nomnigraph::NomGraph

pub struct NomGraph<T, U = EmptyEdgeData> { /* private fields */ }

| ———– | @brief | | A simple graph implementation | | Everything is owned by the graph to simplify | storage concerns. |

Implementations

impl<T, U> NomGraph<T, U>

pub fn create_node_with_data(&mut self, data: T) -> NodeRef<T, U>

| \brief Creates a node and retains | ownership of it. | | \p data An rvalue of the data being held | in the node. | | \return A reference to the node created.

pub fn create_node_with_arg<Arg>(&mut self, arg: Arg) -> NodeRef<T, U>

pub fn create_node(&mut self) -> NodeRef<T, U>

pub fn is_valid(&mut self) -> bool

| Validates the graph. Returns true if the | graph is valid and false if any node or | edge referenced in the graph is not | actually present in the graph.

pub fn swap_nodes(&mut self, n1: NodeRef<T, U>, n2: NodeRef<T, U>)

| Swap two nodes. | | Any edge V -> N1 becomes V -> N2, and N1 | -> V becomes N2 -> V.

pub fn replace_node( &mut self, old_node: &NodeRef<T, U>, new_node: &NodeRef<T, U> )

| \brief Replace a node in the graph with | another node. | | \note The node replaced simply has its | edges cut, but it not deleted from the | graph. Call NomGraph::deleteNode to | delete it. | | \p oldNode A node to be replaced in the | graph. | | \p newNode The node that inherit the old | node’s in-edges and out-edges.

pub fn replace_out_edges( &mut self, old_node: &NodeRef<T, U>, new_node: &NodeRef<T, U> )

| All out-edges oldNode -> V will be replaced | with newNode -> V |

pub fn replace_in_edges( &mut self, old_node: &NodeRef<T, U>, new_node: &NodeRef<T, U> )

| All in-edges V -> oldNode will be replaced | with V -> newNode |

pub fn create_edge( &mut self, tail: NodeRef<T, U>, head: NodeRef<T, U>, data: U ) -> EdgeRef<T, U>

| \brief Creates a directed edge and retains | ownership of it. | | \p tail The node that will have this edge | as an out-edge. | | \p head The node that will have this edge | as an in-edge. | | \return A reference to the edge created.

pub fn get_edge_if_exists( &self, tail: NodeRef<T, U>, head: NodeRef<T, U> ) -> EdgeRef<T, U>

| ———– | @brief | | Get a reference to the edge between two | nodes if it exists. Returns nullptr | if the edge does not exist. |

pub fn has_edge_between_given_nodes( &self, tail: NodeRef<T, U>, head: NodeRef<T, U> ) -> bool

| ———– | @brief | | Returns true if there is an edge between | the given two nodes. |

pub fn has_edge(&self, e: EdgeRef<T, U>) -> bool

pub fn get_edge( &self, tail: NodeRef<T, U>, head: NodeRef<T, U> ) -> EdgeRef<T, U>

| \brief Get a reference to the edge between | two nodes if it exists. | | note: will fail assertion if the edge does | not exist.

pub fn delete_node(&mut self, n: NodeRef<T, U>)

| ———– | @brief | | Deletes a node from the graph. | | ———– | @param n | | A reference to the node. |

pub fn delete_nodes(&mut self, nodes: &HashSet<NodeRef<T, U>>)

Delete all nodes in the set.

pub fn has_node(&self, node: NodeRef<T, U>) -> bool

pub fn delete_edge(&mut self, e: EdgeRef<T, U>)

| ———– | @brief | | Deletes a edge from the graph. | | \p e A reference to the edge. |

pub fn get_mutable_nodes(&mut self) -> Vec<NodeRef<T, U>>

pub fn get_nodes_count(&self) -> usize

pub fn get_mutable_edges(&mut self) -> Vec<EdgeRef<T, U>>

pub fn get_edges_count(&self) -> usize

pub fn print_edges(&mut self)

pub fn print_nodes(&self)

pub unsafe fn move_node( &mut self, node: NodeRef<T, U>, dest_graph: *mut NomGraph<T, U> )

| Note: | | The move functions below are unsafe. Use | them with caution and be sure to call | isValid() after each use.

| Move a node from this graph to the destGraph |

pub unsafe fn move_edge( &mut self, edge: EdgeRef<T, U>, dest_graph: *mut NomGraph<T, U> )

| Move an edge from this graph to the destGraph |

pub unsafe fn move_subgraph( &mut self, subgraph: &Subgraph<T, U>, dest_graph: *mut NomGraph<T, U> )

| Move entire subgraph to destGraph. | | Be sure to delete in/out edges from this | graph first.

pub unsafe fn create_node_internal( &mut self, node: NomNode<T, U> ) -> NodeRef<T, U>

Trait Implementations

impl<T, U> Default for NomGraph<T, U>

fn default() -> Self

Returns the “default value” for a type.

impl<T, U> GraphType for NomGraph<T, U>

type EdgeRef = *mut Edge<T, U>

type NodeRef = *mut NomNode<T, U>

type SubgraphType = Subgraph<T, U>