Struct Zip 

pub struct Zip<L: SequentialLabeling, R: SequentialLabeling>(pub L, pub R);

Zips together two labelings.

A wrapper tuple struct that zips together two labelings, and provides in return a labeling on pairs. It can be used simply to combine labelings over the same graph, but, more importantly, to attach a labeling to a graph, obtaining a labeled graph. Depending on the traits implemented by the two component labelings, the resulting labeling will be sequential or random-access.

Note that the two labelings should be on the same graph: a debug_assert! will check if two sequential iterators have the same length and return nodes in the same order, but no such check is possible for labels as we use Iterator::zip, which does not perform length checks. For extra safety, consider using Zip::verify to perform a complete scan of the two labelings.

Tuple Fields

0: L

1: R

Implementations

impl<L: SequentialLabeling, R: SequentialLabeling> Zip<L, R>

pub fn verify(&self) -> bool

Performs a complete scan of the content of the two component labelings, returning true if they are compatible, that is, their iterators have the same length and return nodes in the same order, and the two iterators paired to each node return the same number of elements.

Trait Implementations

impl<L: Clone + SequentialLabeling, R: Clone + SequentialLabeling> Clone for Zip<L, R>

fn clone(&self) -> Zip<L, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug + SequentialLabeling, R: Debug + SequentialLabeling> Debug for Zip<L, R>

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

Formats the value using the given formatter.

impl<'a, L: SequentialLabeling, R: SequentialLabeling> IntoLender for &'a Zip<L, R>

type Lender = <Zip<L, R> as SequentialLabeling>::Lender<'a>

The lender type that this type converts into.

fn into_lender(self) -> Self::Lender

Converts this type into a Lender.

impl<G: RandomAccessGraph, L: RandomAccessLabeling> LabeledRandomAccessGraph<<L as SequentialLabeling>::Label> for Zip<G, L>

fn successors( &self, node_id: usize, ) -> <Self as RandomAccessLabeling>::Labels<'_>

Returns pairs given by successors of a node and their labels.

fn has_arc(&self, src: usize, dst: usize) -> bool

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

impl<L: Ord + SequentialLabeling, R: Ord + SequentialLabeling> Ord for Zip<L, R>

fn cmp(&self, other: &Zip<L, R>) -> 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<L: PartialEq + SequentialLabeling, R: PartialEq + SequentialLabeling> PartialEq for Zip<L, R>

fn eq(&self, other: &Zip<L, R>) -> 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<L: PartialOrd + SequentialLabeling, R: PartialOrd + SequentialLabeling> PartialOrd for Zip<L, R>

fn partial_cmp(&self, other: &Zip<L, R>) -> 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<L: RandomAccessLabeling, R: RandomAccessLabeling> RandomAccessLabeling for Zip<L, R>

type Labels<'succ> = Zip<<<L as RandomAccessLabeling>::Labels<'succ> as IntoIterator>::IntoIter, <<R as RandomAccessLabeling>::Labels<'succ> as IntoIterator>::IntoIter> where <L as RandomAccessLabeling>::Labels<'succ>: IntoIterator<Item = <L as SequentialLabeling>::Label>, <R as RandomAccessLabeling>::Labels<'succ>: IntoIterator<Item = <R as SequentialLabeling>::Label>, Self: 'succ

The type of the iterator over the labels of a node returned by labels.

fn num_arcs(&self) -> u64

Returns the number of arcs in the graph.

fn labels(&self, node_id: usize) -> <Self as RandomAccessLabeling>::Labels<'_>

Returns the labels associated with a node.

fn outdegree(&self, _node_id: usize) -> usize

Returns the number of labels associated with a node.

impl<L: SequentialLabeling, R: SequentialLabeling> SequentialLabeling for Zip<L, R>

type Label = (<L as SequentialLabeling>::Label, <R as SequentialLabeling>::Label)

type Lender<'node> = NodeLabels<<L as SequentialLabeling>::Lender<'node>, <R as SequentialLabeling>::Lender<'node>> where Self: 'node

The type of Lender over the successors of a node returned by iter.

fn num_nodes(&self) -> usize

Returns the number of nodes in the graph.

fn iter_from(&self, from: usize) -> Self::Lender<'_>

Returns an iterator over the labeling starting at from (included).

fn num_arcs_hint(&self) -> Option<u64>

Returns the number of arcs in the graph, if available.

fn iter(&self) -> Self::Lender<'_>

Returns an iterator over the labeling.

fn build_dcf(&self) -> DCF

Builds the degree cumulative function for this labeling.

fn par_node_apply<A: Default + Send, F: Fn(Range<usize>) -> A + Sync, R: Fn(A, A) -> A + Sync>( &self, func: F, fold: R, granularity: Granularity, pl: &mut impl ConcurrentProgressLog, ) -> A

Applies func to each chunk of nodes of size node_granularity in parallel, and folds the results using fold.

fn par_apply<F: Fn(Range<usize>) -> A + Sync, A: Default + Send, R: Fn(A, A) -> A + Sync, D: for<'a> Succ<Input = usize, Output<'a> = usize>>( &self, func: F, fold: R, granularity: Granularity, deg_cumul: &D, pl: &mut impl ConcurrentProgressLog, ) -> A

Applies func to each chunk of nodes containing approximately arc_granularity arcs in parallel and folds the results using fold.

impl<L: Eq + SequentialLabeling, R: Eq + SequentialLabeling> Eq for Zip<L, R>

impl<G: SequentialGraph, L: SequentialLabeling> LabeledSequentialGraph<<L as SequentialLabeling>::Label> for Zip<G, L>

impl<L: SequentialLabeling, R: SequentialLabeling> StructuralPartialEq for Zip<L, R>