Struct bigraph::NodeBigraphWrapper

pub struct NodeBigraphWrapper<Topology: GraphBase> {
    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<Topology: Debug + GraphBase> Debug for NodeBigraphWrapper<Topology> where
    Topology::OptionalNodeIndex: Debug, 

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

Formats the value using the given formatter.

impl<Topology: Default + GraphBase> Default for NodeBigraphWrapper<Topology>

fn default() -> Self

Returns the "default value" for a type.

impl<Topology: DynamicGraph> DynamicBigraph for NodeBigraphWrapper<Topology> where
    Self::NodeData: BidirectedNodeData,
    Self::EdgeData: Clone, 

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<'a, Topology: GraphBase> GraphBase for NodeBigraphWrapper<Topology>

type NodeData = Topology::NodeData

type EdgeData = Topology::EdgeData

type OptionalNodeIndex = Topology::OptionalNodeIndex

type OptionalEdgeIndex = Topology::OptionalEdgeIndex

type NodeIndex = Topology::NodeIndex

type EdgeIndex = Topology::EdgeIndex

impl<Topology: ImmutableGraphContainer> ImmutableGraphContainer for NodeBigraphWrapper<Topology>

fn node_indices(&self) -> GraphIndices<Self::NodeIndex, Self::OptionalNodeIndex>ⓘ

Important traits for GraphIndices<IndexType, OptionalIndexType>

impl<OptionalIndexType, IndexType> Iterator for GraphIndices<IndexType, OptionalIndexType> where
    IndexType: GraphIndex<OptionalIndexType>,
    OptionalIndexType: OptionalGraphIndex<IndexType>,  type Item = IndexType;

fn edge_indices(&self) -> GraphIndices<Self::EdgeIndex, Self::OptionalEdgeIndex>ⓘ

Important traits for GraphIndices<IndexType, OptionalIndexType>

impl<OptionalIndexType, IndexType> Iterator for GraphIndices<IndexType, OptionalIndexType> where
    IndexType: GraphIndex<OptionalIndexType>,
    OptionalIndexType: OptionalGraphIndex<IndexType>,  type Item = IndexType;

fn contains_node_index(&self, node_index: Self::NodeIndex) -> bool

fn contains_edge_index(&self, edge_index: Self::EdgeIndex) -> bool

fn node_count(&self) -> usize

fn edge_count(&self) -> usize

fn node_data(&self, node_id: Self::NodeIndex) -> &Self::NodeData

Returns the node data associated with the given node id, or None if there is no such node.

fn edge_data(&self, edge_id: Self::EdgeIndex) -> &Self::EdgeData

Returns the edge data associated with the given edge id, or None if there is no such edge.

fn node_data_mut(&mut self, node_id: Self::NodeIndex) -> &mut Self::NodeData

fn edge_data_mut(&mut self, edge_id: Self::EdgeIndex) -> &mut Self::EdgeData

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

fn is_empty(&self) -> bool

Returns true if the graph is empty, i.e. contains no nodes or edges.

impl<Topology: MutableGraphContainer + StaticGraph> MutableGraphContainer for NodeBigraphWrapper<Topology>

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

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

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

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

impl<'a, Topology: NavigableGraph<'a>> NavigableGraph<'a> for NodeBigraphWrapper<Topology>

type OutNeighbors = <Topology as NavigableGraph<'a>>::OutNeighbors

type InNeighbors = <Topology as NavigableGraph<'a>>::InNeighbors

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

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

impl<Topology: StaticGraph> StaticBigraph for NodeBigraphWrapper<Topology>

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

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<Topology: StaticGraph> StaticBigraphFromDigraph for NodeBigraphWrapper<Topology> where
    Self::NodeData: Eq + Hash + Debug, 

type Topology = Topology

The type of directed topology the bigraph is created from.

fn new(
    topology: Self::Topology,
    binode_mapping_function: fn(_: &Self::NodeData) -> Self::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(_: &Self::NodeData) -> Self::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.