Struct GraphSpy 

pub struct GraphSpy<G: SwhGraph, MAPS: MaybeMaps = NoMaps, TIMESTAMPS: MaybeTimestamps = NoTimestamps, PERSONS: MaybePersons = NoPersons, CONTENTS: MaybeContents = NoContents, STRINGS: MaybeStrings = NoStrings, LABELNAMES: MaybeLabelNames = NoLabelNames> {
    pub history: Arc<Mutex<Vec<GraphAccessRecord>>>,
    /* private fields */
}

Wraps a graph, and records calls to its methods, useful for tests

Fields

history: Arc<Mutex<Vec<GraphAccessRecord>>>

History of graph accesses

Implementations

impl<G: SwhGraphWithProperties<Contents: OptContents>, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames> GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, NoContents, STRINGS, LABELNAMES>

pub fn with_contents( self, ) -> GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, ContentsSpy<G>, STRINGS, LABELNAMES>

impl<G: SwhGraphWithProperties<LabelNames: LabelNames>, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings> GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, NoLabelNames>

pub fn with_label_names( self, ) -> GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LabelNamesSpy<G>>

impl<G: SwhGraphWithProperties<Maps: Maps>, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames> GraphSpy<G, NoMaps, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

pub fn with_maps( self, ) -> GraphSpy<G, MapsSpy<G>, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

impl<G: SwhGraphWithProperties<Persons: OptPersons>, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames> GraphSpy<G, MAPS, TIMESTAMPS, NoPersons, CONTENTS, STRINGS, LABELNAMES>

pub fn with_persons( self, ) -> GraphSpy<G, MAPS, TIMESTAMPS, PersonsSpy<G>, CONTENTS, STRINGS, LABELNAMES>

impl<G: SwhGraphWithProperties<Strings: OptStrings>, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, LABELNAMES: MaybeLabelNames> GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, NoStrings, LABELNAMES>

pub fn with_strings( self, ) -> GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, StringsSpy<G>, LABELNAMES>

impl<G: SwhGraphWithProperties<Timestamps: OptTimestamps>, MAPS: MaybeMaps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames> GraphSpy<G, MAPS, NoTimestamps, PERSONS, CONTENTS, STRINGS, LABELNAMES>

pub fn with_timestamps( self, ) -> GraphSpy<G, MAPS, TimestampsSpy<G>, PERSONS, CONTENTS, STRINGS, LABELNAMES>

impl<G: SwhGraph> GraphSpy<G, NoMaps, NoTimestamps, NoPersons, NoContents, NoStrings, NoLabelNames>

pub fn new(graph: G) -> Self

impl<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES> GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

where G: SwhGraph, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames,

pub fn graph(&self) -> &G

Trait Implementations

impl<G: Debug + SwhGraph, MAPS: Debug + MaybeMaps, TIMESTAMPS: Debug + MaybeTimestamps, PERSONS: Debug + MaybePersons, CONTENTS: Debug + MaybeContents, STRINGS: Debug + MaybeStrings, LABELNAMES: Debug + MaybeLabelNames> Debug for GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

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

Formats the value using the given formatter.

impl<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES> SwhBackwardGraph for GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

where G: SwhBackwardGraph, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames,

type Predecessors<'succ> = <G as SwhBackwardGraph>::Predecessors<'succ> where Self: 'succ

fn predecessors(&self, node_id: NodeId) -> Self::Predecessors<'_>

Return an IntoIterator over the predecessors of a node.

fn indegree(&self, node_id: NodeId) -> usize

Return the number of predecessors of a node.

impl<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES> SwhForwardGraph for GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

where G: SwhForwardGraph, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames,

type Successors<'succ> = <G as SwhForwardGraph>::Successors<'succ> where Self: 'succ

fn successors(&self, node_id: NodeId) -> Self::Successors<'_>

Return an IntoIterator over the successors of a node.

fn outdegree(&self, node_id: NodeId) -> usize

Return the number of successors of a node.

impl<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES> SwhGraph for GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

where G: SwhGraph, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames,

fn path(&self) -> &Path

Return the base path of the graph

fn is_transposed(&self) -> bool

Returns whether the graph is in the ori->snp->rel,rev->dir->cnt direction (with a few dir->rev arcs)

fn num_nodes(&self) -> usize

Return the largest node id in the graph plus one.

fn has_node(&self, node_id: NodeId) -> bool

Returns whether the given node id exists in the graph

fn num_arcs(&self) -> u64

Return the number of arcs in the graph.

fn num_nodes_by_type(&self) -> Result<HashMap<NodeType, usize>>

Returns the number of nodes of each type, if known.

fn num_arcs_by_type(&self) -> Result<HashMap<(NodeType, NodeType), usize>>

Returns the number of arcs of each type, if known.

fn has_arc(&self, src_node_id: NodeId, dst_node_id: NodeId) -> bool

Return whether there is an arc going from src_node_id to dst_node_id.

fn actual_num_nodes(&self) -> Result<usize>

Returns the number of nodes in the graph, if known.

fn iter_nodes<'a>( &'a self, pl: impl ProgressLog + 'a, ) -> impl Iterator<Item = NodeId> + 'a

Returns an iterator on all the nodes

fn par_iter_nodes<'a>( &'a self, pl: impl ConcurrentProgressLog + 'a, ) -> impl ParallelIterator<Item = NodeId> + 'a

where Self: Sync,

Returns a parallel iterator on all the nodes

impl<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES> SwhGraphWithProperties for GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

where G: SwhGraphWithProperties, MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames,

type Maps = MAPS

type Timestamps = TIMESTAMPS

type Persons = PERSONS

type Contents = CONTENTS

type Strings = STRINGS

type LabelNames = LABELNAMES

fn properties( &self, ) -> &SwhGraphProperties<Self::Maps, Self::Timestamps, Self::Persons, Self::Contents, Self::Strings, Self::LabelNames>

impl<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES> SwhLabeledBackwardGraph for GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

where G: SwhLabeledBackwardGraph, MAPS: Maps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames,

type LabeledArcs<'arc> = <G as SwhLabeledBackwardGraph>::LabeledArcs<'arc> where Self: 'arc

type LabeledPredecessors<'succ> = <G as SwhLabeledBackwardGraph>::LabeledPredecessors<'succ> where Self: 'succ

fn untyped_labeled_predecessors( &self, node_id: NodeId, ) -> Self::LabeledPredecessors<'_>

Return an IntoIterator over the predecessors of a node along with a list of labels of each arc

fn labeled_predecessors( &self, node_id: NodeId, ) -> impl IntoIterator<Item = (usize, impl Iterator<Item = EdgeLabel>)> + IntoFlattenedLabeledArcsIterator<EdgeLabel> + '_

Return an IntoIterator over the predecessors of a node along with a list of labels of each arc

impl<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES> SwhLabeledForwardGraph for GraphSpy<G, MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

where G: SwhLabeledForwardGraph, MAPS: Maps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames,

type LabeledArcs<'arc> = <G as SwhLabeledForwardGraph>::LabeledArcs<'arc> where Self: 'arc

type LabeledSuccessors<'succ> = <G as SwhLabeledForwardGraph>::LabeledSuccessors<'succ> where Self: 'succ

fn untyped_labeled_successors( &self, node_id: NodeId, ) -> Self::LabeledSuccessors<'_>

Return an IntoIterator over the successors of a node along with a list of labels of each arc

fn labeled_successors( &self, node_id: NodeId, ) -> impl Iterator<Item = (usize, impl Iterator<Item = EdgeLabel>)> + IntoFlattenedLabeledArcsIterator<EdgeLabel> + '_

Return an IntoIterator over the successors of a node along with a list of labels of each arc