Struct SetValueList

pub struct SetValueList<V, S>(/* private fields */);

A list containing unique values.

This list is based on SetList. See documentation of it for more information.

Implementations

impl<V, S> SetValueList<V, S>

where S: BuildHasher + Default,

pub fn new(dummy: V) -> Self

Creates a new empty list.

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

Examples

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

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

impl<V, S> SetValueList<V, S>

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

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

Appends the given value to the end of the list.

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

Examples

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

let mut list = SetValueList::<_, RandomState>::default();
list.push_back("alpha");
assert!(!list.push_back("alpha"));

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

Appends the given value to the beginning of the list.

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

Examples

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

let mut list = SetValueList::<_, RandomState>::default();
list.push_front("alpha");
assert!(!list.push_front("alpha"));

Methods from Deref<Target = SetList<V, 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 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");

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")));

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

Creates Vec from this list.

Trait Implementations

impl<V, S> Clone for SetValueList<V, S>

where 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<V: Debug, S: Debug> Debug for SetValueList<V, S>

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

Formats the value using the given formatter.

impl<V, S> Default for SetValueList<V, S>

where V: Default, S: BuildHasher + Default,

fn default() -> Self

Creates a new empty list.

Examples

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

let list = SetValueList::<&'static str, RandomState>::default();

impl<V, S> Deref for SetValueList<V, S>

type Target = SetList<V, V, S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<V, S> DerefMut for SetValueList<V, S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<V, S> Display for SetValueList<V, S>

where V: Display, S: BuildHasher,

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

Formats the value using the given formatter.

impl<V, S> From<&[V]> for SetValueList<V, S>

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

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

Converts to this type from the input type.

impl<V, S> From<SetValueList<V, S>> for Vec<V>

where S: BuildHasher,

fn from(value: SetValueList<V, S>) -> Self

Converts to this type from the input type.

impl<V, S> IntoIterator for SetValueList<V, S>

where S: BuildHasher,

type Item = V

The type of the elements being iterated over.

type IntoIter = IntoValues<V, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V, S> Resource for SetValueList<V, S>

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