Struct net_ensembles::watts_strogatz::WSContainer

pub struct WSContainer<T> { /* private fields */ }

Used for accessing neighbor information from a graph

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

Trait Implementations

impl<T> AdjContainer<T> for WSContainer<T>

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

fn sort_adj(&mut self)

Sorting adjacency lists

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

shuffle adjacency list

impl<T: Clone> Clone for WSContainer<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for WSContainer<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for WSContainer<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, R> GraphIterators<T, GenericGraph<T, WSContainer<T>>, WSContainer<T>> for SmallWorldWS<T, R>where
    T: Node + SerdeStateConform,
    R: Rng,

fn contained_iter(&self) -> ContainedIter<'_, T, WSContainer<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, WSContainer<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, WSContainer<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 container_iter(&self) -> Iter<'_, WSContainer<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, WSContainer<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 dfs(&self, index: usize) -> Dfs<'_, T, WSContainer<T>>

returns Iterator

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

returns Iterator

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

returns Iterator

impl<T, R> GraphIteratorsMut<T, GenericGraph<T, WSContainer<T>>, WSContainer<T>> for SmallWorldWS<T, R>where
    T: Node + SerdeStateConform,
    R: Rng,

fn contained_iter_neighbors_mut(
    &mut self,
    index: usize
) -> NContainedIterMut<'_, T, WSContainer<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, WSContainer<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, WSContainer<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> Serialize for WSContainer<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.