Struct AllowedEdgeTypes 

pub struct AllowedEdgeTypes {
    pub loops: bool,
    pub multi: bool,
}

Which kinds of edges a graph may contain, as a set of flags (igraph_edge_type_sw_t, including the combination IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW).

This is the single crate-wide type for igraph’s edge-type switches: it is taken by the random generators of games (e.g. Graph::erdos_renyi_game_gnm), by the graphicality tests of mixing (e.g. is_graphical) and by the deterministic realizations of constructors (e.g. Graph::realize_degree_sequence). It is re-exported as games::AllowedEdgeTypes, mixing::AllowedEdgeTypes and constructors::AllowedEdgeTypes, and all these paths name the very same type.

Unlike EdgeTypeSw, which lists the three basic flags, this type can express their combination: build it with the associated constants (SIMPLE, LOOPS, MULTI, ALL), with a struct literal, or by or-ing flags together. Every function taking it accepts impl Into<AllowedEdgeTypes>, so an EdgeTypeSw can be passed directly.

use igraph::{ffi, prelude::*};

let both = AllowedEdgeTypes::LOOPS | AllowedEdgeTypes::MULTI;
assert_eq!(both, AllowedEdgeTypes::ALL);
assert_eq!(AllowedEdgeTypes::from(EdgeTypeSw::Multi), AllowedEdgeTypes::MULTI);
assert_eq!(EdgeTypeSw::Loops | EdgeTypeSw::Multi, AllowedEdgeTypes::ALL);

// Raw C flags, both ways.
let raw = ffi::igraph_edge_type_sw_t::from(AllowedEdgeTypes::ALL);
assert_eq!(raw, ffi::IGRAPH_LOOPS_SW | ffi::IGRAPH_MULTI_SW);
assert_eq!(AllowedEdgeTypes::try_from(raw).unwrap(), AllowedEdgeTypes::ALL);

// One name, one type, whatever the module path.
let t: igraph::games::AllowedEdgeTypes = igraph::constructors::AllowedEdgeTypes::MULTI;
assert_eq!(t, igraph::mixing::AllowedEdgeTypes::MULTI);

Fields

loops: bool

Whether self-loops are allowed.

multi: bool

Whether multi-edges (parallel edges) are allowed.

Implementations

impl AllowedEdgeTypes

pub const SIMPLE: Self

Simple graphs only: neither self-loops nor multi-edges (IGRAPH_SIMPLE_SW).

pub const LOOPS: Self

Self-loops allowed, but no multi-edges (IGRAPH_LOOPS_SW); at most one self-loop per vertex.

pub const MULTI: Self

Multi-edges allowed, but no self-loops (IGRAPH_MULTI_SW).

pub const ALL: Self

Both self-loops and multi-edges allowed (IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW).

pub const fn to_raw(self) -> igraph_edge_type_sw_t

The raw igraph bit flags.

Trait Implementations

impl BitOr for AllowedEdgeTypes

type Output = AllowedEdgeTypes

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl BitOr<EdgeTypeSw> for AllowedEdgeTypes

type Output = AllowedEdgeTypes

The resulting type after applying the | operator.

fn bitor(self, rhs: EdgeTypeSw) -> Self

Performs the | operation.

impl Clone for AllowedEdgeTypes

fn clone(&self) -> AllowedEdgeTypes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AllowedEdgeTypes

impl Debug for AllowedEdgeTypes

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

Formats the value using the given formatter.

impl Default for AllowedEdgeTypes

fn default() -> AllowedEdgeTypes

Returns the “default value” for a type.

impl Eq for AllowedEdgeTypes

impl From<AllowedEdgeTypes> for igraph_edge_type_sw_t

fn from(types: AllowedEdgeTypes) -> Self

Converts to this type from the input type.

impl From<EdgeTypeSw> for AllowedEdgeTypes

fn from(sw: EdgeTypeSw) -> Self

Converts to this type from the input type.

impl Hash for AllowedEdgeTypes

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AllowedEdgeTypes

fn eq(&self, other: &AllowedEdgeTypes) -> 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 StructuralPartialEq for AllowedEdgeTypes

impl TryFrom<u32> for AllowedEdgeTypes

fn try_from(raw: igraph_edge_type_sw_t) -> Result<Self>

Accepts exactly the four valid flag combinations; any other bit pattern is an ErrorKind::InvalidValue.

type Error = Error

The type returned in the event of a conversion error.