Struct SetList

pub struct SetList<K, V, S> { /* private fields */ }

A list containg unique key-value pairs.

This is a list, but all items are laid on a single sequential memory block. Therefore, we can expect more speed in terms of iteration than standard linked list, LinkedList, but it requires more memory footprint.

NOTE

Current implementation doesn’t concern about ZST.

Implementations

impl<K, V, S> SetList<K, V, S>

where S: BuildHasher + Default,

pub fn new(dummy: V) -> Self

Creates a new empty list.

SetList requires dummy head node for now, so you can put in any values.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let list = SetList::<char, &'static str, RandomState>::new("");

impl<K, V, S> SetList<K, V, S>

pub fn len(&self) -> usize

Returns number of items.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
assert_eq!(list.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the list is empty.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<char, &'static str, RandomState>::default();
assert!(list.is_empty());

pub fn front(&self) -> Option<&V>

Returns a shared reference to the front item.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");
assert_eq!(list.front(), Some(&"alpha"));

pub fn front_mut(&mut self) -> Option<&mut V>

Returns a mutable reference to the front item.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");
assert_eq!(list.front_mut(), Some(&mut "alpha"));

pub fn back(&self) -> Option<&V>

Returns a shared reference to the last item.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");
assert_eq!(list.back(), Some(&"beta"));

pub fn back_mut(&mut self) -> Option<&mut V>

Returns a mutable reference to the last item.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");
assert_eq!(list.back_mut(), Some(&mut "beta"));

pub fn values(&self) -> Values<'_, V, S>

Returns an iterator visiting all values in order.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");

for v in list.values() {
    println!("{v}"); // Prints out "alpha" and "beta".
}

pub fn values_mut(&mut self) -> ValuesMut<'_, V, S>

Returns a mutable iterator visiting all values in order.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha".to_owned());
list.push_back('b', "beta".to_owned());

for v in list.values_mut() {
    v.push('*');
    println!("{v}"); // Prints out "alpha*" and "beta*".
}

pub fn values_from(&self, cur: ListPos) -> Values<'_, V, S>

Returns an iterator visiting values from the given position.

Panics

Panics if the position is not valid one for the list.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");
list.push_back('g', "gamma");

let pos = list.get_position(&'b').unwrap();
for v in list.values_from(pos) {
    println!("{v}"); // Prints out "beta" and "gamma".
}

pub fn values_mut_from(&mut self, cur: ListPos) -> ValuesMut<'_, V, S>

Returns a mutable iterator visiting values from the given position.

Panics

Panics if the position is not valid one for the list.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha".to_owned());
list.push_back('b', "beta".to_owned());
list.push_back('g', "gamma".to_owned());

let pos = list.get_position(&'b').unwrap();
for v in list.values_mut_from(pos) {
    v.push('*');
    println!("{v}"); // Prints out "beta*" and "gamma*".
}

pub fn into_values(self) -> IntoValues<V, S>

Creates an iterator visiting all values in order by consuming the list.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");

for v in list.into_values() {
    println!("{v}");
}

pub fn into_values_from(self, cur: ListPos) -> IntoValues<V, S>

Creates an iterator visiting values from the given position by consuming the list.

Panics

Panics if the position is not valid one for the list.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");
list.push_back('g', "gamma");

let pos = list.get_position(&'b').unwrap();
for v in list.into_values_from(pos) {
    println!("{v}"); // Prints out "beta" and "gamma".
}

pub fn iter_next(&self, cur: ListPos) -> Option<(ListPos, &V)>

Returns a shared reference to a value at the given position with the next position.

If the given position is not valid one for the list, returns None.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");

let pos = list.get_position(&'b').unwrap();
let (_, v) = list.iter_next(pos).unwrap();
assert_eq!(v, &"beta");

pub fn iter_next_mut(&mut self, cur: ListPos) -> Option<(ListPos, &mut V)>

Returns a mutable reference to a value at the given position with the next position.

If the given position is not valid one for the list, returns None.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");

let pos = list.get_position(&'b').unwrap();
let (_, v) = list.iter_next_mut(pos).unwrap();
assert_eq!(v, &mut "beta");

pub fn first_position(&self) -> ListPos

Returns the first position of the list.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('b', "beta");

let pos = list.first_position();
let (_, v) = list.iter_next(pos).unwrap();
assert_eq!(v, &"alpha");

impl<K, V, S> SetList<K, V, S>

where K: Hash + Eq, S: BuildHasher,

pub fn contains_key<Q>(&self, key: &Q) -> bool

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the vector contains the given key.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
assert!(list.contains_key(&'a'));

pub fn get_position<Q>(&self, key: &Q) -> Option<ListPos>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a position of a value corresponding to the given key.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
let pos = list.get_position(&'a').unwrap();

pub fn get<Q>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a shared reference to a value corresponding to the given key.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
assert_eq!(list.get(&'a'), Some(&"alpha"));

pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a mutable reference to a value corresponding to the given key.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
assert_eq!(list.get_mut(&'a'), Some(&mut "alpha"));

pub fn push_back(&mut self, key: K, value: V) -> bool

Appends the given key-value pair to the end of the list.

However, if the list already contains the key, nothing takes place and returns false.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
assert!(!list.push_back('a', "beta"));
assert_eq!(list.back(), Some(&"alpha"));

pub fn push_front(&mut self, key: K, value: V) -> bool

Inserts the given key-value pair to the beginning of the list.

However, if the list already contains the key, nothing takes place and returns false.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_front('a', "alpha");
assert!(!list.push_front('a', "beta"));
assert_eq!(list.front(), Some(&"alpha"));

pub fn insert<Q>(&mut self, key: K, value: V, after: &Q) -> bool

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Inserts the given key-value pair after a node corresponding to after.

However, if the list already contains the key or doesn’t contain after, nothing takes place and returns false.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
list.push_back('g', "gamma");
list.insert('b', "beta", &'a');

pub fn remove<Q>(&mut self, key: &Q) -> Option<V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes an item corresponding to the given key.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
assert_eq!(list.remove(&'a'), Some("alpha"));

pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes an item corresponding to the given key then resturns key-value pair.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let mut list = SetList::<_, _, RandomState>::default();
list.push_back('a', "alpha");
assert_eq!(list.remove_entry(&'a'), Some(('a', "alpha")));

impl<K, V, S> SetList<K, V, S>

where V: Clone, S: BuildHasher,

pub fn values_as_vec(&self) -> Vec<V>

Creates Vec from this list.

Trait Implementations

impl<K, V, S> Clone for SetList<K, V, S>

where K: Clone, V: Clone, S: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, S: Debug> Debug for SetList<K, V, S>

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

Formats the value using the given formatter.

impl<K, V, S> Default for SetList<K, V, S>

where V: Default, S: BuildHasher + Default,

fn default() -> Self

Creates a new empty list.

Examples

use my_ecs::ds::SetList;
use std::hash::RandomState;

let list = SetList::<char, String, RandomState>::default();

impl<K, V, S> Display for SetList<K, V, S>

where V: Display, S: BuildHasher,

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

Formats the value using the given formatter.

impl<K, V, S> From<&[(K, V)]> for SetList<K, V, S>

where K: Hash + Eq + Clone, V: Default + Clone, S: BuildHasher + Default,

fn from(value: &[(K, V)]) -> Self

Converts to this type from the input type.

impl<K, V, S> IntoIterator for SetList<K, V, S>

where S: BuildHasher,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, S> Resource for SetList<K, V, S>

where K: Send + 'static, V: Send + 'static, S: Send + 'static,