Struct rapier3d::data::arena::Arena [−][src]
pub struct Arena<T> { /* fields omitted */ }
Expand description
The Arena
allows inserting and removing elements that are referred to by
Index
.
See the module-level documentation for example usage and motivation.
Implementations
impl<T> Arena<T>
[src]
impl<T> Arena<T>
[src]pub fn new() -> Arena<T>
[src]
pub fn new() -> Arena<T>
[src]Constructs a new, empty Arena
.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::<usize>::new();
pub fn with_capacity(n: usize) -> Arena<T>
[src]
pub fn with_capacity(n: usize) -> Arena<T>
[src]Constructs a new, empty Arena<T>
with the specified capacity.
The Arena<T>
will be able to hold n
elements without further allocation.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::with_capacity(10); // These insertions will not require further allocation. for i in 0..10 { assert!(arena.try_insert(i).is_ok()); } // But now we are at capacity, and there is no more room. assert!(arena.try_insert(99).is_err());
pub fn clear(&mut self)
[src]
pub fn clear(&mut self)
[src]Clear all the items inside the arena, but keep its allocation.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::with_capacity(1); arena.insert(42); arena.insert(43); arena.clear(); assert_eq!(arena.capacity(), 2);
pub fn try_insert(&mut self, value: T) -> Result<Index, T>
[src]
pub fn try_insert(&mut self, value: T) -> Result<Index, T>
[src]Attempts to insert value
into the arena using existing capacity.
This method will never allocate new capacity in the arena.
If insertion succeeds, then the value
’s index is returned. If
insertion fails, then Err(value)
is returned to give ownership of
value
back to the caller.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); match arena.try_insert(42) { Ok(idx) => { // Insertion succeeded. assert_eq!(arena[idx], 42); } Err(x) => { // Insertion failed. assert_eq!(x, 42); } };
pub fn try_insert_with<F: FnOnce(Index) -> T>(
&mut self,
create: F
) -> Result<Index, F>
[src]
pub fn try_insert_with<F: FnOnce(Index) -> T>(
&mut self,
create: F
) -> Result<Index, F>
[src]Attempts to insert the value returned by create
into the arena using existing capacity.
create
is called with the new value’s associated index, allowing values that know their own index.
This method will never allocate new capacity in the arena.
If insertion succeeds, then the new index is returned. If
insertion fails, then Err(create)
is returned to give ownership of
create
back to the caller.
Examples
use rapier::data::arena::{Arena, Index}; let mut arena = Arena::new(); match arena.try_insert_with(|idx| (42, idx)) { Ok(idx) => { // Insertion succeeded. assert_eq!(arena[idx].0, 42); assert_eq!(arena[idx].1, idx); } Err(x) => { // Insertion failed. } };
pub fn insert(&mut self, value: T) -> Index
[src]
pub fn insert(&mut self, value: T) -> Index
[src]Insert value
into the arena, allocating more capacity if necessary.
The value
’s associated index in the arena is returned.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); let idx = arena.insert(42); assert_eq!(arena[idx], 42);
pub fn insert_with(&mut self, create: impl FnOnce(Index) -> T) -> Index
[src]
pub fn insert_with(&mut self, create: impl FnOnce(Index) -> T) -> Index
[src]Insert the value returned by create
into the arena, allocating more capacity if necessary.
create
is called with the new value’s associated index, allowing values that know their own index.
The new value’s associated index in the arena is returned.
Examples
use rapier::data::arena::{Arena, Index}; let mut arena = Arena::new(); let idx = arena.insert_with(|idx| (42, idx)); assert_eq!(arena[idx].0, 42); assert_eq!(arena[idx].1, idx);
pub fn remove(&mut self, i: Index) -> Option<T>
[src]
pub fn remove(&mut self, i: Index) -> Option<T>
[src]Remove the element at index i
from the arena.
If the element at index i
is still in the arena, then it is
returned. If it is not in the arena, then None
is returned.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); let idx = arena.insert(42); assert_eq!(arena.remove(idx), Some(42)); assert_eq!(arena.remove(idx), None);
pub fn retain(&mut self, predicate: impl FnMut(Index, &mut T) -> bool)
[src]
pub fn retain(&mut self, predicate: impl FnMut(Index, &mut T) -> bool)
[src]Retains only the elements specified by the predicate.
In other words, remove all indices such that predicate(index, &value)
returns false
.
Examples
use rapier::data::arena::Arena; let mut crew = Arena::new(); crew.extend(&["Jim Hawkins", "John Silver", "Alexander Smollett", "Israel Hands"]); let pirates = ["John Silver", "Israel Hands"]; // too dangerous to keep them around crew.retain(|_index, member| !pirates.contains(member)); let mut crew_members = crew.iter().map(|(_, member)| **member); assert_eq!(crew_members.next(), Some("Jim Hawkins")); assert_eq!(crew_members.next(), Some("Alexander Smollett")); assert!(crew_members.next().is_none());
pub fn contains(&self, i: Index) -> bool
[src]
pub fn contains(&self, i: Index) -> bool
[src]Is the element at index i
in the arena?
Returns true
if the element at i
is in the arena, false
otherwise.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); let idx = arena.insert(42); assert!(arena.contains(idx)); arena.remove(idx); assert!(!arena.contains(idx));
pub fn get(&self, i: Index) -> Option<&T>
[src]
pub fn get(&self, i: Index) -> Option<&T>
[src]Get a shared reference to the element at index i
if it is in the
arena.
If the element at index i
is not in the arena, then None
is returned.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); let idx = arena.insert(42); assert_eq!(arena.get(idx), Some(&42)); arena.remove(idx); assert!(arena.get(idx).is_none());
pub fn get_mut(&mut self, i: Index) -> Option<&mut T>
[src]
pub fn get_mut(&mut self, i: Index) -> Option<&mut T>
[src]Get an exclusive reference to the element at index i
if it is in the
arena.
If the element at index i
is not in the arena, then None
is returned.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); let idx = arena.insert(42); *arena.get_mut(idx).unwrap() += 1; assert_eq!(arena.remove(idx), Some(43)); assert!(arena.get_mut(idx).is_none());
pub fn get2_mut(
&mut self,
i1: Index,
i2: Index
) -> (Option<&mut T>, Option<&mut T>)
[src]
pub fn get2_mut(
&mut self,
i1: Index,
i2: Index
) -> (Option<&mut T>, Option<&mut T>)
[src]Get a pair of exclusive references to the elements at index i1
and i2
if it is in the
arena.
If the element at index i1
or i2
is not in the arena, then None
is returned for this
element.
Panics
Panics if i1
and i2
are pointing to the same item of the arena.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); let idx1 = arena.insert(0); let idx2 = arena.insert(1); { let (item1, item2) = arena.get2_mut(idx1, idx2); *item1.unwrap() = 3; *item2.unwrap() = 4; } assert_eq!(arena[idx1], 3); assert_eq!(arena[idx2], 4);
pub fn len(&self) -> usize
[src]
pub fn len(&self) -> usize
[src]Get the length of this arena.
The length is the number of elements the arena holds.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); assert_eq!(arena.len(), 0); let idx = arena.insert(42); assert_eq!(arena.len(), 1); let _ = arena.insert(0); assert_eq!(arena.len(), 2); assert_eq!(arena.remove(idx), Some(42)); assert_eq!(arena.len(), 1);
pub fn is_empty(&self) -> bool
[src]
pub fn is_empty(&self) -> bool
[src]Returns true if the arena contains no elements
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); assert!(arena.is_empty()); let idx = arena.insert(42); assert!(!arena.is_empty()); assert_eq!(arena.remove(idx), Some(42)); assert!(arena.is_empty());
pub fn capacity(&self) -> usize
[src]
pub fn capacity(&self) -> usize
[src]Get the capacity of this arena.
The capacity is the maximum number of elements the arena can hold without further allocation, including however many it currently contains.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::with_capacity(10); assert_eq!(arena.capacity(), 10); // `try_insert` does not allocate new capacity. for i in 0..10 { assert!(arena.try_insert(1).is_ok()); assert_eq!(arena.capacity(), 10); } // But `insert` will if the arena is already at capacity. arena.insert(0); assert!(arena.capacity() > 10);
pub fn iter(&self) -> Iter<'_, T>ⓘ
[src]
pub fn iter(&self) -> Iter<'_, T>ⓘ
[src]Iterate over shared references to the elements in this arena.
Yields pairs of (Index, &T)
items.
Order of iteration is not defined.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); for i in 0..10 { arena.insert(i * i); } for (idx, value) in arena.iter() { println!("{} is at index {:?}", value, idx); }
pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘ
[src]
pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘ
[src]Iterate over exclusive references to the elements in this arena.
Yields pairs of (Index, &mut T)
items.
Order of iteration is not defined.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); for i in 0..10 { arena.insert(i * i); } for (_idx, value) in arena.iter_mut() { *value += 5; }
pub fn drain(&mut self) -> Drain<'_, T>ⓘ
[src]
pub fn drain(&mut self) -> Drain<'_, T>ⓘ
[src]Iterate over elements of the arena and remove them.
Yields pairs of (Index, T)
items.
Order of iteration is not defined.
Note: All elements are removed even if the iterator is only partially consumed or not consumed at all.
Examples
use rapier::data::arena::Arena; let mut arena = Arena::new(); let idx_1 = arena.insert("hello"); let idx_2 = arena.insert("world"); assert!(arena.get(idx_1).is_some()); assert!(arena.get(idx_2).is_some()); for (idx, value) in arena.drain() { assert!((idx == idx_1 && value == "hello") || (idx == idx_2 && value == "world")); } assert!(arena.get(idx_1).is_none()); assert!(arena.get(idx_2).is_none());
pub fn get_unknown_gen(&self, i: u32) -> Option<(&T, Index)>
[src]
pub fn get_unknown_gen(&self, i: u32) -> Option<(&T, Index)>
[src]Given an i of usize
without a generation, get a shared reference
to the element and the matching Index
of the entry behind i
.
This method is useful when you know there might be an element at the position i, but don’t know its generation or precise Index.
Use cases include using indexing such as Hierarchical BitMap Indexing or other kinds of bit-efficient indexing.
You should use the get
method instead most of the time.
pub fn get_unknown_gen_mut(&mut self, i: u32) -> Option<(&mut T, Index)>
[src]
pub fn get_unknown_gen_mut(&mut self, i: u32) -> Option<(&mut T, Index)>
[src]Given an i of usize
without a generation, get an exclusive reference
to the element and the matching Index
of the entry behind i
.
This method is useful when you know there might be an element at the position i, but don’t know its generation or precise Index.
Use cases include using indexing such as Hierarchical BitMap Indexing or other kinds of bit-efficient indexing.
You should use the get_mut
method instead most of the time.
Trait Implementations
impl<T> Extend<T> for Arena<T>
[src]
impl<T> Extend<T> for Arena<T>
[src]fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
[src]
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
[src]Extends a collection with the contents of an iterator. Read more
fn extend_one(&mut self, item: A)
[src]
fn extend_one(&mut self, item: A)
[src]extend_one
)Extends a collection with exactly one element.
fn extend_reserve(&mut self, additional: usize)
[src]
fn extend_reserve(&mut self, additional: usize)
[src]extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<T> FromIterator<T> for Arena<T>
[src]
impl<T> FromIterator<T> for Arena<T>
[src]fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self
[src]
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self
[src]Creates a value from an iterator. Read more
impl<T> IntoIterator for Arena<T>
[src]
impl<T> IntoIterator for Arena<T>
[src]impl<'a, T> IntoIterator for &'a Arena<T>
[src]
impl<'a, T> IntoIterator for &'a Arena<T>
[src]Auto Trait Implementations
impl<T> RefUnwindSafe for Arena<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Arena<T> where
T: Send,
T: Send,
impl<T> Sync for Arena<T> where
T: Sync,
T: Sync,
impl<T> Unpin for Arena<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for Arena<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> Downcast for T where
T: Any,
[src]
impl<T> Downcast for T where
T: Any,
[src]pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
[src]
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
[src]Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
[src]
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
[src]Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn as_any(&self) -> &(dyn Any + 'static)
[src]
pub fn as_any(&self) -> &(dyn Any + 'static)
[src]Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
[src]
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
[src]Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<T> DowncastSync for T where
T: Any + Send + Sync,
[src]
impl<T> DowncastSync for T where
T: Any + Send + Sync,
[src]impl<T> Pointable for T
impl<T> Pointable for T
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]pub fn to_subset(&self) -> Option<SS>
[src]
pub fn to_subset(&self) -> Option<SS>
[src]The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
pub fn is_in_subset(&self) -> bool
[src]
pub fn is_in_subset(&self) -> bool
[src]Checks if self
is actually part of its subset T
(and can be converted to it).
pub fn to_subset_unchecked(&self) -> SS
[src]
pub fn to_subset_unchecked(&self) -> SS
[src]Use with care! Same as self.to_subset
but without any property checks. Always succeeds.
pub fn from_subset(element: &SS) -> SP
[src]
pub fn from_subset(element: &SS) -> SP
[src]The inclusion map: converts self
to the equivalent element of its superset.
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more