Struct BidirectedAdjacencyArray 

pub struct BidirectedAdjacencyArray<IndexType: GraphIndexInteger, NodeData, EdgeData> { /* private fields */ }

Implementations

impl<IndexType: GraphIndexInteger, NodeData, EdgeData> BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>

pub fn new( nodes: TaggedVec<NodeIndex<IndexType>, NodeData>, edges: TaggedVec<EdgeIndex<IndexType>, BidirectedEdge<IndexType, EdgeData>>, ) -> Self

Creates a bidirected adjacency array with the given bidirected nodes and edges.

Example

use bidirected_adjacency_array::graph::BidirectedAdjacencyArray;
use bidirected_adjacency_array::index::{NodeIndex, EdgeIndex};
use bidirected_adjacency_array::graph::BidirectedEdge;
use tagged_vec::TaggedVec;

let nodes = TaggedVec::from(vec!['A', 'B', 'C']);
let edges = TaggedVec::from(vec![
        BidirectedEdge::new(NodeIndex::from_usize(0).into_directed_forward(), NodeIndex::from_usize(1).into_directed_forward(), 1), // A+ -> B+
        BidirectedEdge::new(NodeIndex::from_usize(1).into_directed_reverse(), NodeIndex::from_usize(2).into_directed_forward(), 2), // B- -> C+
]);
let graph = BidirectedAdjacencyArray::<u8, _, _>::new(nodes, edges);

pub fn reorder_edges( &mut self, node: DirectedNodeIndex<IndexType>, comparator: impl FnMut(DirectedNodeIndex<IndexType>, DirectedNodeIndex<IndexType>) -> Ordering, )

Reorder the edges of the given node according to the given comparator.

The comparator receives two different to-nodes, representing the two edges from the given node to these to-nodes.

pub fn node_count(&self) -> usize

pub fn edge_count(&self) -> usize

pub fn iter_nodes(&self) -> impl Iterator<Item = NodeIndex<IndexType>>

pub fn iter_edges(&self) -> impl Iterator<Item = EdgeIndex<IndexType>>

pub fn iter_outgoing_edges( &self, node: DirectedNodeIndex<IndexType>, ) -> impl Iterator<Item = DirectedEdge<IndexType>>

pub fn iter_incident_edges( &self, node: NodeIndex<IndexType>, ) -> impl Iterator<Item = EdgeIndex<IndexType>>

Iterate over the bidirected edges incident to the given bidirected node.

pub fn node_data(&self, node: NodeIndex<IndexType>) -> &NodeData

pub fn edge( &self, edge: EdgeIndex<IndexType>, ) -> EdgeView<'_, IndexType, EdgeData>

pub fn directed_edge_data<'this>( &'this self, directed_edge: DirectedEdgeIndex<IndexType>, ) -> DirectedEdgeDataView<'this, IndexType, EdgeData>

pub fn directed_edge_into_bidirected( &self, directed_edge: DirectedEdgeIndex<IndexType>, ) -> EdgeIndex<IndexType>

impl<IndexType: GraphIndexInteger, NodeData, EdgeData> BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>

pub fn compare( &self, other: &Self, ) -> Result<(), GraphComparisonError<IndexType>>

where NodeData: Eq, EdgeData: Eq,

Compares this graph to another graph.

The comparison returns Ok if all nodes and edges are identical in both graphs. Otherwise, it returns an Err describing the differences.

Trait Implementations

impl<IndexType: Debug + GraphIndexInteger, NodeData: Debug, EdgeData: Debug> Debug for BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>

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

Formats the value using the given formatter.