Struct net_ensembles::sw_graph::SwContainer

pub struct SwContainer<T: Node> { /* private fields */ }

Used for accessing neighbor information from graph

• contains Adjacency list and internal id (normally the index in the graph).
• also contains user specified data, i.e, T from SwContainer<T>
• see trait AdjContainer

Implementations

impl<T: Node + SerdeStateConform> SwContainer<T>

pub fn neighbors_sw(&self) -> SwEdgeIterNeighbors<'_>

returns iterator over indices of neighbors

• Iterator returns the same items as self.neigbors(), though it might be more efficient. It will never be less efficient

pub fn count_root(&self) -> usize

Count how many root edges are contained

pub fn iter_raw_edges(&self) -> Iter<'_, SwEdge>

Iterate over the actual edges used underneath. You will probably need neighbors_sw more often

Trait Implementations

impl<T> AdjContainer<T> for SwContainer<T>where
    T: Node + SerdeStateConform,

fn new(id: usize, node: T) -> Self

Create new instance with id

fn contained(&self) -> &T

return reference to what the AdjContainer contains

fn contained_mut(&mut self) -> &mut T

return mut reference to what the AdjContainer contains

fn neighbors(&self) -> IterWrapper<'_>

returns iterator over indices of neighbors

fn degree(&self) -> usize

count number of neighbors, i.e. number of edges incident to self

fn id(&self) -> usize

returns id of container

fn get_adj_first(&self) -> Option<&usize>

returns Some(first element from the adjecency List) or None

fn is_adjacent(&self, other_id: usize) -> bool

check if vertex with other_id is adjacent to self

Note:

(in GenericGraph<T>: id equals the index corresponding to self)

fn sort_adj(&mut self)

Sorting adjacency lists

• worst case: O(edges log(edges))

fn shuffle_adj<R: Rng>(&mut self, rng: &mut R)

Shuffles adjacency list

impl<T> AdjList<SwEdge> for SwContainer<T>where
    T: Node,

fn edges(&self) -> &[SwEdge]

Intended for all AdjContainer, which store all their edges in a continouse slice/vector. This will return a reference to the edge slice, which you can use to iterate or do other stuff

impl<T: Clone + Node> Clone for SwContainer<T>

fn clone(&self) -> SwContainer<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Node> Debug for SwContainer<T>

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

Formats the value using the given formatter.

impl<'de, T: Node> Deserialize<'de> for SwContainer<T>where
    T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, E> GraphIterators<T, GenericGraph<T, SwContainer<T>>, SwContainer<T>> for Ewhere
    T: Node,
    E: WithGraph<T, GenericGraph<T, SwContainer<T>>>,

fn contained_iter(&self) -> ContainedIter<'_, T, SwContainer<T>>

get iterator over additional information stored at each vertex in order of the indices

iterator returns a Node (for example EmptyNode or whatever you used)

similar to self.container_iter().map(|container| container.contained())

fn contained_iter_neighbors(
    &self,
    index: usize
) -> NContainedIter<'_, T, SwContainer<T>, IterWrapper<'_>>

iterate over additional information of neighbors of vertex index

iterator returns &T

sort_adj will affect the order

panics if index out of bounds

fn container_iter(&self) -> Iter<'_, SwContainer<T>>

get iterator over AdjContainer in order of the indices

iterator returns AdjContainer<Node>, i.e., A

fn container_iter_neighbors(
    &self,
    index: usize
) -> NContainerIter<'_, T, SwContainer<T>, IterWrapper<'_>>

iterate over additional information of neighbors of vertex index

iterator returns &T

sort_adj will affect the order

panics if index out of bounds

fn contained_iter_neighbors_with_index(
    &self,
    index: usize
) -> NIContainedIter<'_, T, SwContainer<T>>

iterate over additional information of neighbors of vertex index

iterator returns (index_neighbor,&T)

sort_adj will affect the order

panics if index out of bounds

fn dfs(&self, index: usize) -> Dfs<'_, T, SwContainer<T>>

returns Iterator

fn dfs_with_index(&self, index: usize) -> DfsWithIndex<'_, T, SwContainer<T>>

returns Iterator

fn bfs_index_depth(&self, index: usize) -> Bfs<'_, T, SwContainer<T>>

returns Iterator

impl<T, R> GraphIteratorsMut<T, GenericGraph<T, SwContainer<T>>, SwContainer<T>> for SwEnsemble<T, R>where
    T: Node + SerdeStateConform,
    R: Rng,

fn contained_iter_neighbors_mut(
    &mut self,
    index: usize
) -> NContainedIterMut<'_, T, SwContainer<T>, IterWrapper<'_>>

iterate over mutable additional information of neighbors of vertex index

iterator returns &mut T

sort_adj will affect the order

panics if index out of bounds

fn contained_iter_neighbors_mut_with_index(
    &mut self,
    index: usize
) -> INContainedIterMut<'_, T, SwContainer<T>>

iterate over mutable additional information of neighbors of vertex index

iterator returns (index_neighbor: usize, neighbor: &mut T)

sort_adj will affect the order

panics if index out of bounds

fn contained_iter_mut(&mut self) -> ContainedIterMut<'_, T, SwContainer<T>>

get iterator over mutable additional information stored at each vertex in order of the indices

iterator returns a Node (for example EmptyNode or whatever you used)

impl<T: Node> Serialize for SwContainer<T>where
    T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.