Struct gen_indices::GenIndexEntitySet

pub struct GenIndexEntitySet<I: Num + AddAssign + Copy, G: Num + AddAssign + Copy> { /* fields omitted */ }

GenIndexEntitySet This maintains the "state" for your entities. It is designed with a Mutex, so that it is rendered thread safe.

Example:

extern crate gen_indices;
extern crate num;
 
use gen_indices::*;
use num::{Num, zero, one};

let gi = GenIndexEntitySet::<u64, u64>::new();

// first index
let idx1 = gi.lock().unwrap().next_index();
println!("first: {:?}", idx1);

// second index
let idx2 = gi.lock().unwrap().next_index();
println!("first: {:?}", idx2);

// delete first index and then get next index
if let Err(e) = gi.lock().unwrap().delete_index(idx1) {
    println!("Error: {}", e);
}
let idx3 = gi.lock().unwrap().next_index();
println!("first: {:?}", idx3);

Implementations

impl<I: Num + AddAssign + Copy, G: Num + AddAssign + Copy> GenIndexEntitySet<I, G>

pub fn new() -> Arc<Mutex<GenIndexEntitySet<I, G>>>

Create a new GenIndexEntitySet object, wrapped with a Mutex to allow for thread safety.

pub fn next_index(&mut self) -> GenIndex<I, G>

allocate and provide a "new" index. If an old index was deleted, that index is reused, with the generation number incremented, so that references to the deleted entity are not found.

You are responsible for the corresponding maitenence in your ECS.

pub fn delete_index(&mut self, gi: GenIndex<I, G>) -> Result<(), &'static str>

Delete an entity's index. You will be responsible for the cleanup in the corresponding ECS.

Trait Implementations

impl<I: Clone + Num + AddAssign + Copy, G: Clone + Num + AddAssign + Copy> Clone for GenIndexEntitySet<I, G>

fn clone(&self) -> GenIndexEntitySet<I, G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Num + AddAssign + Copy, G: Debug + Num + AddAssign + Copy> Debug for GenIndexEntitySet<I, G>

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

Formats the value using the given formatter.

impl<I: Hash + Num + AddAssign + Copy, G: Hash + Num + AddAssign + Copy> Hash for GenIndexEntitySet<I, G>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<I: PartialEq + Num + AddAssign + Copy, G: PartialEq + Num + AddAssign + Copy> PartialEq<GenIndexEntitySet<I, G>> for GenIndexEntitySet<I, G>

fn eq(&self, other: &GenIndexEntitySet<I, G>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &GenIndexEntitySet<I, G>) -> bool

This method tests for !=.

impl<I: Num + AddAssign + Copy, G: Num + AddAssign + Copy> StructuralPartialEq for GenIndexEntitySet<I, G>