Struct EntitySet

pub struct EntitySet<K>
where
    K: EntityRef,
{ /* private fields */ }

A set of K for densely indexed entity references.

The EntitySet data structure uses the dense index space to implement a set with a bitvector. Like SecondaryMap, an EntitySet is used to associate secondary information with entities.

Implementations

impl<K> EntitySet<K>

where K: EntityRef,

Shared EntitySet implementation for all value types.

pub fn new() -> EntitySet<K>

Create a new empty set.

pub fn with_capacity(capacity: usize) -> EntitySet<K>

Creates a new empty set with the specified capacity.

pub fn ensure_capacity(&mut self, capacity: usize)

Ensure that the set has enough capacity to hold capacity total elements.

pub fn contains(&self, k: K) -> bool

Get the element at k if it exists.

pub fn is_empty(&self) -> bool

Is this set completely empty?

pub fn clear(&mut self)

Remove all entries from this set.

pub fn keys(&self) -> Keys<K>

Iterate over all the keys up to the maximum in this set.

This will yield intermediate keys on the way up to the max key, even if they are not contained within the set.

use cranelift_entity::{entity_impl, EntityRef, EntitySet};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
struct Entity(u32);
entity_impl!(Entity);

let mut set = EntitySet::new();
set.insert(Entity::new(2));

let mut keys = set.keys();
assert_eq!(keys.next(), Some(Entity::new(0)));
assert_eq!(keys.next(), Some(Entity::new(1)));
assert_eq!(keys.next(), Some(Entity::new(2)));
assert!(keys.next().is_none());

pub fn iter(&self) -> SetIter<'_, K>

Iterate over the elements of this set.

use cranelift_entity::{entity_impl, EntityRef, EntitySet};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
struct Entity(u32);
entity_impl!(Entity);

let mut set = EntitySet::new();
set.insert(Entity::new(2));
set.insert(Entity::new(3));

let mut iter = set.iter();
assert_eq!(iter.next(), Some(Entity::new(2)));
assert_eq!(iter.next(), Some(Entity::new(3)));
assert!(iter.next().is_none());

pub fn insert(&mut self, k: K) -> bool

Insert the element at k.

Returns true if k was not present in the set, i.e. this is a newly-added element. Returns false otherwise.

pub fn remove(&mut self, k: K) -> bool

Remove k from this bitset.

Returns whether k was previously in this set or not.

pub fn pop(&mut self) -> Option<K>

Removes and returns the entity from the set if it exists.

Trait Implementations

impl<K> Clone for EntitySet<K>

where K: Clone + EntityRef,

fn clone(&self) -> EntitySet<K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K> Debug for EntitySet<K>

where K: Debug + EntityRef,

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

Formats the value using the given formatter.

impl<K> Default for EntitySet<K>

where K: EntityRef,

fn default() -> EntitySet<K>

Returns the “default value” for a type.

impl<'de, K> Deserialize<'de> for EntitySet<K>

where K: EntityRef,

fn deserialize<__D>( __deserializer: __D, ) -> Result<EntitySet<K>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K> Extend<K> for EntitySet<K>

where K: EntityRef,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = K>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K> PartialEq for EntitySet<K>

where K: PartialEq + EntityRef,

fn eq(&self, other: &EntitySet<K>) -> 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<K> Serialize for EntitySet<K>

where K: EntityRef,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K> Eq for EntitySet<K>

where K: Eq + EntityRef,

impl<K> StructuralPartialEq for EntitySet<K>

where K: EntityRef,