Struct igraph_inclist_t 

pub struct igraph_inclist_t { /* private fields */ }

Implementations

impl igraph_inclist_t

pub fn init_empty(n: usize) -> Result<Self>

Creates an incidence list for n vertices, all with empty lists (igraph_inclist_init_empty).

Useful to build a structure vertex by vertex, e.g. before turning it into a graph. Time complexity: O(n).

Binds igraph_inclist_init_empty.

Errors

ErrorKind::InvalidValue if n does not fit in an igraph_int_t, or an out-of-memory error if it is too large to be allocated.

pub fn len(&self) -> usize

Number of vertices, i.e. of lists, in the an incidence list (igraph_inclist_size).

Time complexity: O(1).

Binds igraph_inclist_size.

pub fn is_empty(&self) -> bool

Whether there are no vertices at all.

pub fn total_len(&self) -> usize

Total number of entries (edge ids) stored in all the lists.

pub fn clear(&mut self)

Removes all edge ids from every list, keeping the number of vertices (igraph_inclist_clear).

Time complexity: O(n), n being the number of vertices.

Binds igraph_inclist_clear.

pub fn as_raw_slice(&self) -> &[VectorInt]

The per-vertex lists as a slice of owned igraph vectors.

pub fn as_raw_mut_slice(&mut self) -> &mut [VectorInt]

The per-vertex lists as a mutable slice of owned igraph vectors: every list can be resized, pushed to, sorted, or even replaced by another VectorInt.

pub fn get(&self, v: VertexId) -> Option<&[igraph_int_t]>

The list of vertex v, or None if v is out of range (the igraph_inclist_get macro).

The panicking counterpart is indexing: list[v].

pub fn get_mut(&mut self, v: VertexId) -> Option<&mut VectorInt>

The list of vertex v as a mutable VectorInt, or None if v is out of range.

Unlike IndexMut, this allows changing the length of the list (push, pop, resize, clear, …).

pub fn iter(&self) -> Iter<'_>

Iterates over the lists of the vertices 0, 1, ..., as slices.

pub fn iter_mut(&mut self) -> IterMut<'_, VectorInt>

Iterates mutably over the lists of the vertices 0, 1, ....

pub fn to_vecs(&self) -> Vec<Vec<igraph_int_t>>

Copies the lists into nested Rust vectors.

pub fn print(&self) -> Result<()>

Prints the lists to the standard output, one vertex per line, entries separated by spaces (igraph_inclist_print).

The same text is produced by the Display implementation and by igraph_inclist_t::fprint.

Note that the text goes to the C stdout stream, bypassing Rust’s output capturing (e.g. in cargo test): prefer println!("{list}") in Rust code.

pub fn fprint(&self, out: &mut impl Write) -> Result<()>

Writes the lists to out in igraph’s textual format, one vertex per line (igraph_inclist_fprint).

The output is produced by the C library itself (through a memory stream), and it matches the Display implementation.

Errors

ErrorKind::File if writing fails.

impl igraph_inclist_t

pub fn new(graph: &Graph, mode: NeighborMode, loops: Loops) -> Result<Self>

Incidence list of graph: same as Graph::inclist_init.

Trait Implementations

impl Clone for igraph_inclist_t

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for igraph_inclist_t

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

Formats the value using the given formatter.

impl Default for igraph_inclist_t

fn default() -> Self

An empty structure with no vertices.

impl Display for igraph_inclist_t

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

One line per vertex with the entries separated by spaces, exactly like igraph_inclist_print.

impl Drop for igraph_inclist_t

fn drop(&mut self)

Frees the lists with igraph_inclist_destroy.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl From<&[Vec<i64>]> for igraph_inclist_t

fn from(lists: &[Vec<igraph_int_t>]) -> Self

Builds the structure from nested vectors, one per vertex.

impl From<&igraph_inclist_t> for Vec<Vec<igraph_int_t>>

fn from(list: &igraph_inclist_t) -> Self

Converts to this type from the input type.

impl From<Vec<Vec<i64>>> for igraph_inclist_t

fn from(lists: Vec<Vec<igraph_int_t>>) -> Self

Builds the structure from nested vectors, one per vertex.

impl From<igraph_inclist_t> for Vec<Vec<igraph_int_t>>

fn from(list: igraph_inclist_t) -> Self

Converts to this type from the input type.

impl FromIterator<Vec<i64>> for igraph_inclist_t

fn from_iter<I: IntoIterator<Item = Vec<igraph_int_t>>>(iter: I) -> Self

Creates a value from an iterator.

impl Index<usize> for igraph_inclist_t

fn index(&self, v: usize) -> &[igraph_int_t]

The list of the given vertex as a slice.

Panics

If the vertex is out of range.

type Output = [i64]

The returned type after indexing.

impl IndexMut<usize> for igraph_inclist_t

fn index_mut(&mut self, v: usize) -> &mut [igraph_int_t]

The list of the given vertex as a mutable slice (its length cannot change: use igraph_inclist_t::get_mut for that).

Panics

If the vertex is out of range.

impl<'a> IntoIterator for &'a igraph_inclist_t

type Item = &'a [i64]

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.

impl PartialEq for igraph_inclist_t

fn eq(&self, other: &Self) -> bool

Equal when both have the same number of vertices and the same lists, in the same order.

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 Send for igraph_inclist_t

impl Sync for igraph_inclist_t