Struct Sccs 

pub struct Sccs<C: AsRef<[usize]> = Box<[usize]>> { /* private fields */ }

Strongly connected components.

An instance of this structure stores the index of the component of each node. Components are numbered from 0 to num_components.

Moreover, this structure makes it possible to sort the components by size, possibly using parallel methods.

Implementations

impl<C: AsRef<[usize]>> Sccs<C>

pub fn new(num_components: usize, components: C) -> Self

pub fn num_components(&self) -> usize

Returns the number of strongly connected components.

pub fn components(&self) -> &[usize]

Returns a slice containing, for each node, the index of the component it belongs to.

pub fn compute_sizes(&self) -> Box<[usize]>

Returns the sizes of all components.

impl<C: AsMut<[usize]> + AsRef<[usize]>> Sccs<C>

pub fn sort_by_size(&mut self) -> Box<[usize]>

Renumbers the components by decreasing size.

After a call to this method, the sizes of strongly connected components will decreasing in the component index. The method returns the sizes of the components after the renumbering.

pub fn par_sort_by_size(&mut self) -> Box<[usize]>

Renumbers the components by decreasing size using parallel methods.

After a call to this method, the sizes of strongly connected components will decreasing in the component index. The method returns the sizes of the components after the renumbering.

Trait Implementations

impl<C> AlignHash for Sccs<C>

where usize: SerInner<SerType: AlignHash>, C: SerInner<SerType: AlignHash> + AsRef<[usize]>,

fn align_hash(hasher: &mut impl Hasher, offset_of: &mut usize)

Accumulates alignment information in hasher assuming to be positioned at offset_of.

fn align_hash_val(&self, hasher: &mut impl Hasher, offset_of: &mut usize)

Calls AlignHash::align_hash on a value.

impl<C: Clone + AsRef<[usize]>> Clone for Sccs<C>

fn clone(&self) -> Sccs<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: AsRef<[usize]>> CopyType for Sccs<C>

type Copy = Deep

impl<C: Debug + AsRef<[usize]>> Debug for Sccs<C>

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

Formats the value using the given formatter.

impl<C> DeserInner for Sccs<C>

where usize: DeserInner, C: DeserInner + AsRef<[usize]>, for<'__epserde_desertype> DeserType<'__epserde_desertype, C>: AsRef<[usize]>,

type DeserType<'__epserde_desertype> = Sccs<<C as DeserInner>::DeserType<'__epserde_desertype>>

The deserialization type associated with this type. It can be retrieved conveniently with the alias DeserType.

unsafe fn _deser_full_inner( backend: &mut impl ReadWithPos, ) -> Result<Self, Error>

Safety

unsafe fn _deser_eps_inner<'deser_eps_inner_lifetime>( backend: &mut SliceWithPos<'deser_eps_inner_lifetime>, ) -> Result<Self::DeserType<'deser_eps_inner_lifetime>, Error>

Safety

impl<C> SerInner for Sccs<C>

where usize: SerInner, C: SerInner + AsRef<[usize]>, SerType<C>: AsRef<[usize]>,

const IS_ZERO_COPY: bool

Inner constant used by the derive macros to keep track recursively of whether the type satisfies the conditions for being zero-copy. It is checked at runtime against the trait implemented by the type, and if a ZeroCopy type has this constant set to false serialization will panic.

type SerType = Sccs<<C as SerInner>::SerType>

This is the type that will be written in the header of the file, and thus the type that will be deserialized. In most cases it is Self, but in some cases, as for references to slices, it is customized.

unsafe fn _ser_inner(&self, backend: &mut impl WriteWithNames) -> Result<()>

Serializes this structure using the given backend.

impl<C> TypeHash for Sccs<C>

where usize: SerInner<SerType: TypeHash>, C: SerInner<SerType: TypeHash> + AsRef<[usize]>,

fn type_hash(hasher: &mut impl Hasher)

Accumulates type information in hasher.

fn type_hash_val(&self, hasher: &mut impl Hasher)

Calls TypeHash::type_hash on a value.

impl<C: Copy + AsRef<[usize]>> Copy for Sccs<C>