Struct BvComp 

pub struct BvComp<E, W: Write> {
    pub offsets_writer: OffsetsWriter<W>,
    /* private fields */
}

Compresses a graph into the BV graph format.

This is the standard compressor: for each node, it considers the preceding nodes in a window of configurable size and greedily selects the reference that minimizes the bitstream length, subject to a maximum reference-chain depth (max_ref_count). It then splits the “extra” nodes (those that cannot be copied from the reference list) into intervals and residuals, as documented in the module-level documentation.

The compressor writes two bitstreams:

• the graph bitstream, through the encoder E;
• the offsets bitstream, through the OffsetsWriter.

Nodes must be pushed in order via push (or extend) and the compressor must be finalized with flush, which returns the CompStats.

In most cases you do not need to instantiate this struct directly: use BvComp::with_basename to obtain a BvCompConfig with suitable defaults, then call comp_graph or par_comp_graph on it.

For a compressor that uses an alternative reference-selection strategy based on dynamic programming, see BvCompZ.

Fields

offsets_writer: OffsetsWriter<W>

The offset writer, we should push the number of bits used by each node.

Implementations

impl BvComp<(), Sink>

pub fn with_basename(basename: impl AsRef<Path>) -> BvCompConfig

Convenience method returning a BvCompConfig with settings suitable for the standard Boldi–Vigna compressor.

impl<E: EncodeAndEstimate, W: Write> BvComp<E, W>

pub const NO_INTERVALS: usize = Compressor::NO_INTERVALS

This value for min_interval_length implies that no intervalization will be performed.

pub fn new( encoder: E, offsets_writer: OffsetsWriter<W>, compression_window: usize, max_ref_count: usize, min_interval_length: usize, start_node: usize, ) -> Self

Creates a new BvGraph compressor.

pub fn push<I: IntoIterator<Item = usize>>( &mut self, succ_iter: I, ) -> Result<()>

Push a new node to the compressor. The iterator must yield the successors of the node and the nodes HAVE TO BE CONTIGUOUS (i.e. if a node has no neighbors you have to pass an empty iterator)

pub fn flush(self) -> Result<CompStats>

Consume the compressor and return the statistics about compression.

pub fn extend<L>(&mut self, iter_nodes: L) -> Result<()>

where L: IntoLender, L::Lender: for<'next> NodeLabelsLender<'next, Label = usize>,

Given an iterator over the nodes successors iterators, push them all. The iterator must yield the successors of the node and the nodes HAVE TO BE CONTIGUOUS (i.e. if a node has no neighbors you have to pass an empty iterator).

This most commonly is called with a reference to a graph.

Trait Implementations

impl<E: Debug, W: Debug + Write> Debug for BvComp<E, W>

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

Formats the value using the given formatter.