Struct bigraph::NodeBigraphWrapper

pub struct NodeBigraphWrapper<NodeData, EdgeData, IndexType: PrimInt, Topology> {
    pub topology: Topology,
    // some fields omitted
}

Wrapper for a static graph that adds a binode mapping function.

Bigraphs can be represented with this struct by creating their topology as normal directed graph where each binode is split into its two parts. The binode mapping function then associates the parts with each other.

use bigraph::node_bigraph_wrapper::NodeBigraphWrapper;
use bigraph::{StaticBigraph, MutableGraphContainer, StaticBigraphFromDigraph};
use bigraph::petgraph_impl;

let mut graph = petgraph_impl::new();
let n1 = graph.add_node(0);
let n2 = graph.add_node(1);
graph.add_edge(n1.clone(), n2.clone(), ());
graph.add_edge(n2.clone(), n1.clone(), ());
let bigraph = NodeBigraphWrapper::new(graph, |n| if n % 2 == 0 {n + 1} else {n - 1});
assert_eq!(Some(n2.clone()), bigraph.partner_node(n1.clone()));
assert_eq!(Some(n1.clone()), bigraph.partner_node(n2.clone()));

Fields

topology: Topology

Trait Implementations

impl<NodeData: Debug, EdgeData: Debug, IndexType: Debug + PrimInt, Topology: Debug> Debug for NodeBigraphWrapper<NodeData, EdgeData, IndexType, Topology>

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

Formats the value using the given formatter.

impl<NodeData, EdgeData, IndexType: PrimInt, T: Default> Default for NodeBigraphWrapper<NodeData, EdgeData, IndexType, T>

fn default() -> Self

Returns the "default value" for a type.

impl<NodeData: BidirectedNodeData, EdgeData: Clone, IndexType: PrimInt, T: DynamicGraph<NodeData, EdgeData, IndexType>> DynamicBigraph<NodeData, EdgeData, IndexType> for NodeBigraphWrapper<NodeData, EdgeData, IndexType, T>

fn add_partner_nodes(&mut self)

Adds nodes such that the graph becomes a valid bigraph. The indices of existing nodes are not altered.

fn add_mirror_edges(&mut self)

Adds edges such that the graph fulfils the [mirror property]. Mirror edges get the cloned EdgeData from their existing mirror.

impl<NodeData, EdgeData, IndexType: PrimInt, T: ImmutableGraphContainer<NodeData, EdgeData, IndexType>> ImmutableGraphContainer<NodeData, EdgeData, IndexType> for NodeBigraphWrapper<NodeData, EdgeData, IndexType, T>

fn node_indices(&self) -> NodeIndices<IndexType>ⓘ

Important traits for NodeIndices<IndexType>

impl<IndexType> Iterator for NodeIndices<IndexType> where
    IndexType: PrimInt,  type Item = NodeIndex<IndexType>;

fn edge_indices(&self) -> EdgeIndices<IndexType>ⓘ

Important traits for EdgeIndices<IndexType>

impl<IndexType> Iterator for EdgeIndices<IndexType> where
    IndexType: PrimInt,  type Item = EdgeIndex<IndexType>;

fn node_count(&self) -> usize

fn edge_count(&self) -> usize

fn node_data(&self, node_id: NodeIndex<IndexType>) -> Option<&NodeData>

fn edge_data(&self, edge_id: EdgeIndex<IndexType>) -> Option<&EdgeData>

fn node_data_mut(
    &mut self,
    node_id: NodeIndex<IndexType>
) -> Option<&mut NodeData>

fn edge_data_mut(
    &mut self,
    edge_id: EdgeIndex<IndexType>
) -> Option<&mut EdgeData>

fn contains_edge(
    &self,
    from: NodeIndex<IndexType>,
    to: NodeIndex<IndexType>
) -> bool

impl<NodeData, EdgeData, IndexType: PrimInt, T: MutableGraphContainer<NodeData, EdgeData, IndexType>> MutableGraphContainer<NodeData, EdgeData, IndexType> for NodeBigraphWrapper<NodeData, EdgeData, IndexType, T>

fn add_node(&mut self, node_data: NodeData) -> NodeIndex<IndexType>

fn add_edge(
    &mut self,
    from: NodeIndex<IndexType>,
    to: NodeIndex<IndexType>,
    edge_data: EdgeData
) -> EdgeIndex<IndexType>

fn remove_node(&mut self, node_id: NodeIndex<IndexType>) -> Option<NodeData>

fn remove_edge(&mut self, edge_id: EdgeIndex<IndexType>) -> Option<EdgeData>

impl<'a, NodeData, EdgeData, IndexType: PrimInt, T: NavigableGraph<'a, NodeData, EdgeData, IndexType>> NavigableGraph<'a, NodeData, EdgeData, IndexType> for NodeBigraphWrapper<NodeData, EdgeData, IndexType, T>

type OutNeighbors = <T as NavigableGraph<'a, NodeData, EdgeData, IndexType>>::OutNeighbors

type InNeighbors = <T as NavigableGraph<'a, NodeData, EdgeData, IndexType>>::InNeighbors

fn out_neighbors(
    &'a self,
    node_id: NodeIndex<IndexType>
) -> Option<Self::OutNeighbors>

fn in_neighbors(
    &'a self,
    node_id: NodeIndex<IndexType>
) -> Option<Self::InNeighbors>

impl<NodeData, EdgeData, IndexType: PrimInt, T: StaticGraph<NodeData, EdgeData, IndexType>> StaticBigraph<NodeData, EdgeData, IndexType> for NodeBigraphWrapper<NodeData, EdgeData, IndexType, T>

fn partner_node(
    &self,
    node_id: NodeIndex<IndexType>
) -> Option<NodeIndex<IndexType>>

Returns the unique partner of the given node id, or None if the given node id does not exist.

fn verify_node_pairing(&self) -> bool

Returns true if each node has exactly one partner, and this relation is symmetric.

fn verify_mirror_property(&self) -> bool

Returns true if the [mirror property] of edges is fulfilled. Assumes that the node pairing is correct (See verify_node_pairing())

fn verify_unitig_length_is_zero(&self) -> bool

Returns true if all unitigs in the graph have length of at most one node.

impl<NodeData: Eq + Hash + Debug, EdgeData, IndexType: PrimInt + Debug, Topology: StaticGraph<NodeData, EdgeData, IndexType>> StaticBigraphFromDigraph<NodeData, EdgeData, IndexType> for NodeBigraphWrapper<NodeData, EdgeData, IndexType, Topology>

type Topology = Topology

The type of directed topology the bigraph is created from.

fn new(
    topology: Self::Topology,
    binode_mapping_function: fn(_: &NodeData) -> NodeData
) -> Self

Converts the given topology into a bigraph with the given mapping function. If the resulting graph has wrongly mapped nodes, the method panics.

fn new_unchecked(
    _topology: Self::Topology,
    _binode_mapping_function: fn(_: &NodeData) -> NodeData
) -> Self

Converts the given topology into a bigraph with the given mapping function. Unmapped nodes are stored without mapping. If a node maps to another node, but the other node does not map back, then this method panics.