[−][src]Struct broccoli::container::TreeRefInd
A less general tree that providess collect
functions
and also derefs to a Tree
.
TreeRefInd
assumes there is a layer of indirection where
all the pointers point to the same slice.
It uses this assumption to provide collect
functions that allow
storing query results that can then be iterated through multiple times
quickly.
Implementations
impl<'a, A: Axis, N: Num + Send + Sync, T: Send + Sync> TreeRefInd<'a, A, N, T>
[src]
pub fn collect_colliding_pairs_par<D: Send + Sync>(
&mut self,
func: impl Fn(&mut T, &mut T) -> Option<D> + Send + Sync + Copy
) -> CollidingPairsPar<T, D>
[src]
&mut self,
func: impl Fn(&mut T, &mut T) -> Option<D> + Send + Sync + Copy
) -> CollidingPairsPar<T, D>
The parallel version of TreeRefInd::collect_colliding_pairs
that instead
returns a CollidingPairsPar
.
Examples
let mut aabbs = [ broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0), broccoli::bbox(broccoli::rect(15, 20, 15, 20), 1), broccoli::bbox(broccoli::rect(5, 15, 5, 15), 2), ]; let mut tree = broccoli::container::TreeRefInd::new_par(&mut aabbs,|a|{ a.rect }); //Find all colliding aabbs only once. let mut pairs=tree.collect_colliding_pairs_par(|a, b| { a.inner += 1; b.inner += 1; Some(()) }); //Iterate over the pairs multiple times for _ in 0..3{ //mutate every colliding pair. pairs.for_every_pair_mut_par(&mut aabbs,|a,b,()|{ a.inner+=1; b.inner+=1; }) }
impl<'a, A: Axis, N: Num, T> TreeRefInd<'a, A, N, T>
[src]
pub fn collect_all<D: Send + Sync>(
&mut self,
func: impl FnMut(&Rect<N>, &mut T) -> Option<D>
) -> FilteredElements<T, D>
[src]
&mut self,
func: impl FnMut(&Rect<N>, &mut T) -> Option<D>
) -> FilteredElements<T, D>
Collect all elements based off of a predicate and return a FilteredElements
.
Examples
let mut aabbs = [ broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0), broccoli::bbox(broccoli::rect(15, 20, 15, 20), 1), broccoli::bbox(broccoli::rect(5, 15, 5, 15), 2), ]; let mut tree = broccoli::container::TreeRefInd::new(&mut aabbs,|a|{ a.rect }); //Find a group of elements only once. let mut pairs=tree.collect_all(|_,b| { if b.inner % 2 ==0{ Some(()) }else{ None } }); //Iterate over that group multiple times for _ in 0..3{ //mutate every colliding pair. for (a,()) in pairs.get_mut(&mut aabbs){ a.inner+=1; } }
impl<'a, A: Axis, N: Num, T> TreeRefInd<'a, A, N, T>
[src]
pub fn collect_colliding_pairs<D: Send + Sync>(
&mut self,
func: impl FnMut(&mut T, &mut T) -> Option<D> + Send + Sync
) -> CollidingPairs<T, D>
[src]
&mut self,
func: impl FnMut(&mut T, &mut T) -> Option<D> + Send + Sync
) -> CollidingPairs<T, D>
Find all colliding pairs based on a predicate and return a CollidingPairs
.
Examples
let mut aabbs = [ broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0), broccoli::bbox(broccoli::rect(15, 20, 15, 20), 1), broccoli::bbox(broccoli::rect(5, 15, 5, 15), 2), ]; let mut tree = broccoli::container::TreeRefInd::new(&mut aabbs,|a|{ a.rect }); //Find all colliding aabbs only once. let mut pairs=tree.collect_colliding_pairs(|a, b| { a.inner += 1; b.inner += 1; Some(()) }); //Iterate over the pairs multiple times for _ in 0..3{ //mutate every colliding pair. pairs.for_every_pair_mut(&mut aabbs,|a,b,()|{ a.inner+=1; b.inner+=1; }) }
impl<'a, N: Num, T> TreeRefInd<'a, DefaultA, N, T>
[src]
pub fn new(
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, DefaultA, N, T>
[src]
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, DefaultA, N, T>
impl<'a, N: Num + Send + Sync, T: Send + Sync> TreeRefInd<'a, DefaultA, N, T>
[src]
pub fn new_par(
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, DefaultA, N, T>
[src]
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, DefaultA, N, T>
impl<'a, A: Axis, N: Num + Send + Sync, T: Send + Sync> TreeRefInd<'a, A, N, T>
[src]
pub fn with_axis_par(
axis: A,
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, A, N, T>
[src]
axis: A,
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, A, N, T>
impl<'a, A: Axis, N: Num, T> TreeRefInd<'a, A, N, T>
[src]
pub fn with_axis(
axis: A,
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, A, N, T>
[src]
axis: A,
arr: &'a mut [T],
func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, A, N, T>
pub fn get_elements(&self) -> &[T]ⓘ
[src]
use broccoli::{prelude::*,bbox,rect}; let mut k=[4]; let mut b=broccoli::container::TreeRefInd::new(&mut k,|&mut d|rect(d,d,d,d)); b.find_colliding_pairs_mut(|a,b|{}); assert_eq!(b.get_elements()[0],4); b.find_colliding_pairs_mut(|a,b|{});
pub fn get_elements_mut(&mut self) -> &'a mut [T]ⓘ
[src]
use broccoli::{prelude::*,bbox,rect}; let mut k=[0]; let mut b=broccoli::container::TreeRefInd::new(&mut k,|&mut d|rect(d,d,d,d)); b.find_colliding_pairs_mut(|a,b|{}); b.get_elements_mut()[0]=5; b.find_colliding_pairs_mut(|a,b|{});
Methods from Deref<Target = TreeRef<'a, A, BBox<N, &'a mut T>>>
pub fn get_bbox_elements(&self) -> &[T]ⓘ
[src]
use broccoli::{prelude::*,bbox,rect}; let mut k=[bbox(rect(0,10,0,10),8)]; let mut b=broccoli::container::TreeRef::new(&mut k); b.find_colliding_pairs_mut(|a,b|{}); assert_eq!(b.get_bbox_elements()[0].inner,8); b.find_colliding_pairs_mut(|a,b|{});
pub fn get_bbox_elements_mut(&mut self) -> PMut<'a, [T]>
[src]
use broccoli::{prelude::*,bbox,rect}; let mut k=[bbox(rect(0,10,0,10),8)]; let mut b=broccoli::container::TreeRef::new(&mut k); b.find_colliding_pairs_mut(|a,b|{}); *b.get_bbox_elements_mut().get_index_mut(0).unpack_inner()=5; b.find_colliding_pairs_mut(|a,b|{});
Trait Implementations
impl<'a, A: Axis, N: Num + 'a, T> Deref for TreeRefInd<'a, A, N, T>
[src]
type Target = TreeRef<'a, A, BBox<N, &'a mut T>>
The resulting type after dereferencing.
pub fn deref(&self) -> &Self::Target
[src]
impl<'a, A: Axis, N: Num + 'a, T> DerefMut for TreeRefInd<'a, A, N, T>
[src]
Auto Trait Implementations
impl<'a, A, N, T> RefUnwindSafe for TreeRefInd<'a, A, N, T> where
A: RefUnwindSafe,
N: RefUnwindSafe,
T: RefUnwindSafe,
[src]
A: RefUnwindSafe,
N: RefUnwindSafe,
T: RefUnwindSafe,
impl<'a, A, N, T> Send for TreeRefInd<'a, A, N, T> where
N: Send,
T: Send,
[src]
N: Send,
T: Send,
impl<'a, A, N, T> Sync for TreeRefInd<'a, A, N, T> where
N: Sync,
T: Sync,
[src]
N: Sync,
T: Sync,
impl<'a, A, N, T> Unpin for TreeRefInd<'a, A, N, T> where
A: Unpin,
[src]
A: Unpin,
impl<'a, A, N, T> !UnwindSafe for TreeRefInd<'a, A, N, T>
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,