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 remove_multiedges(&mut self) -> BTreeSet<EdgeIndex<IndexType>>

Removes multiedges between the same pair of directed nodes, keeping only one of them.

Warning: This does not check if the edge data of the multiedges is actually the same, and simply keeps one of them. It is the caller’s responsibility to ensure that this is the case if they want to keep the data consistent.

Returns the indices of the removed edges. Note that this method shifts the edge indices, and hence the returned indices now respond to different edges in the graph, or possibly no edge at all.

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: From<PlainGfaNodeData>, EdgeData: From<PlainGfaEdgeData>> BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>

pub fn read_gfa1( reader: impl BufRead, ) -> Result<BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>, GfaReadError>

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

pub fn write_gfa1(&self, writer: impl Write) -> Result<(), Error>

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: Clone + GraphIndexInteger, NodeData: Clone, EdgeData: Clone> Clone for BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>

fn clone(&self) -> BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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.

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

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

fn cmp( &self, other: &BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>, ) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

fn eq( &self, other: &BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>, ) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

fn partial_cmp( &self, other: &BidirectedAdjacencyArray<IndexType, NodeData, EdgeData>, ) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

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