Struct SwhUnidirectionalGraph 

pub struct SwhUnidirectionalGraph<P, G: UnderlyingGraph = DefaultUnderlyingGraph> { /* private fields */ }

Class representing the compressed Software Heritage graph in a single direction.

Type parameters:

• P is either () or properties::SwhGraphProperties, manipulated using load_properties and load_all_properties
• G is the forward graph (either BvGraph, or Zip<BvGraph, SwhLabeling> load_labels

Implementations

impl SwhUnidirectionalGraph<()>

pub fn new(basepath: impl AsRef<Path>) -> Result<Self>

impl<G: UnderlyingGraph> SwhUnidirectionalGraph<(), G>

pub fn from_underlying_graph(basepath: PathBuf, graph: G) -> Self

impl<M: MaybeMaps, T: MaybeTimestamps, P: MaybePersons, C: MaybeContents, S: MaybeStrings, N: MaybeLabelNames, G: UnderlyingGraph> SwhUnidirectionalGraph<SwhGraphProperties<M, T, P, C, S, N>, G>

pub fn load_properties<M2: MaybeMaps, T2: MaybeTimestamps, P2: MaybePersons, C2: MaybeContents, S2: MaybeStrings, N2: MaybeLabelNames>( self, loader: impl FnOnce(SwhGraphProperties<M, T, P, C, S, N>) -> Result<SwhGraphProperties<M2, T2, P2, C2, S2, N2>>, ) -> Result<SwhUnidirectionalGraph<SwhGraphProperties<M2, T2, P2, C2, S2, N2>, G>>

Enriches the graph with more properties mmapped from disk

Example

use swh_graph::java_compat::mph::gov::GOVMPH;

swh_graph::graph::SwhUnidirectionalGraph::new(PathBuf::from("./graph"))
    .expect("Could not load graph")
    .init_properties()
    .load_properties(|properties| properties.load_maps::<GOVMPH>())
    .expect("Could not load SWHID maps")
    .load_properties(|properties| properties.load_timestamps())
    .expect("Could not load timestamps");

impl<G: UnderlyingGraph> SwhUnidirectionalGraph<(), G>

pub fn init_properties( self, ) -> SwhUnidirectionalGraph<SwhGraphProperties<NoMaps, NoTimestamps, NoPersons, NoContents, NoStrings, NoLabelNames>, G>

Prerequisite for load_properties

pub fn load_all_properties<MPHF: LoadableSwhidMphf>( self, ) -> Result<SwhUnidirectionalGraph<SwhGraphProperties<MappedMaps<MPHF>, MappedTimestamps, MappedPersons, MappedContents, MappedStrings, MappedLabelNames>, G>>

Enriches the graph with all properties, mmapped from disk

Example

use swh_graph::java_compat::mph::gov::GOVMPH;

swh_graph::graph::SwhUnidirectionalGraph::new(PathBuf::from("./graph"))
    .expect("Could not load graph")
    .load_all_properties::<GOVMPH>()
    .expect("Could not load properties");

impl<P, G: RandomAccessGraph + UnderlyingGraph> SwhUnidirectionalGraph<P, G>

pub fn load_labels( self, ) -> Result<SwhUnidirectionalGraph<P, Zip<G, SwhLabeling>>>

Consumes this graph and returns a new one that implements SwhLabeledForwardGraph

Trait Implementations

impl<P, G: UnderlyingGraph> SwhForwardGraph for SwhUnidirectionalGraph<P, G>

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.

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

impl<P, G: UnderlyingGraph> SwhGraph for SwhUnidirectionalGraph<P, G>

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 num_arcs(&self) -> u64

Return the number of arcs in the graph.

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 has_node(&self, node_id: NodeId) -> bool

Returns whether the given node id exists in the graph

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

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

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

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

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

Returns the number of arcs of each type, 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<MAPS: MaybeMaps, TIMESTAMPS: MaybeTimestamps, PERSONS: MaybePersons, CONTENTS: MaybeContents, STRINGS: MaybeStrings, LABELNAMES: MaybeLabelNames, G: UnderlyingGraph> SwhGraphWithProperties for SwhUnidirectionalGraph<SwhGraphProperties<MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>, G>

type Maps = MAPS

type Timestamps = TIMESTAMPS

type Persons = PERSONS

type Contents = CONTENTS

type Strings = STRINGS

type LabelNames = LABELNAMES

fn properties( &self, ) -> &SwhGraphProperties<MAPS, TIMESTAMPS, PERSONS, CONTENTS, STRINGS, LABELNAMES>

impl<P, G: UnderlyingGraph> SwhLabeledForwardGraph for SwhUnidirectionalGraph<P, G>

where <G as SequentialLabeling>::Label: Pair<Left = NodeId, Right: IntoIterator<Item: Borrow<u64>>>, for<'succ> <G as RandomAccessLabeling>::Labels<'succ>: Iterator<Item = (usize, <<G as SequentialLabeling>::Label as Pair>::Right)>,

type LabeledArcs<'arc> = LabeledArcIterator<<<<<G as RandomAccessLabeling>::Labels<'arc> as Iterator>::Item as Pair>::Right as IntoIterator>::IntoIter> where Self: 'arc

type LabeledSuccessors<'succ> = LabeledSuccessorIterator<<G as RandomAccessLabeling>::Labels<'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>

where Self: SwhGraphWithProperties + Sized, <Self as SwhGraphWithProperties>::Maps: Maps,

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