Struct broccoli::container::TreeInd

#[repr(C)]pub struct TreeInd<'a, 'b, N: Num, T> { /* fields omitted */ }

A less general tree that providess collect functions and also derefs to a Tree.

TreeInd 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, 'b, N: Num, T> TreeInd<'a, 'b, N, T>

pub fn get_inner_elements_mut(&mut self) -> &mut [T]

Retrieve the underlying list of elements. Unlike Tree::get_elements_mut() which returns the aabbs of the tree, this returns the list of T that each aabb points to.

Examples

 let mut aabbs = [
    broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0),
 ];

 let mut base=broccoli::container::TreeIndBase::new(&mut aabbs,|a|a.rect); 
 let mut tree = base.build();
 let bots=tree.get_inner_elements_mut();

pub fn get_inner_elements(&self) -> &[T]

Retrieve the underlying list of elements. Unlike Tree::get_elements_mut() which returns the aabbs of the tree, this returns the list of T that each aabb points to.

Examples

 let mut aabbs = [
    broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0),
 ];

 let mut base=broccoli::container::TreeIndBase::new(&mut aabbs,|a|a.rect); 
 let mut tree = base.build();
 let bots=tree.get_inner_elements();

pub fn collect_all<D: Send + Sync>(
    &mut self,
    mut 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 base=broccoli::container::TreeIndBase::new(&mut aabbs,|a|a.rect); 
 let mut tree = base.build();

 //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;
     }
 }

pub fn collect_colliding_pairs<D: Send + Sync>(
    &mut self,
    mut 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 base=broccoli::container::TreeIndBase::new(&mut aabbs,|a|a.rect); 
 let mut tree = base.build();

 //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;
     })
 }

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> where
    N: Send + Sync,
    T: Send + Sync, 

The parallel version of TreeInd::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 base=broccoli::container::TreeIndBase::new(&mut aabbs,|a|a.rect); 
 let mut tree = base.build();

 //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;
     })
 }

Methods from Deref<Target = Tree<'b, BBox<N, &'a mut T>>>

#[must_use]pub fn get_height(&self) -> usize

Examples

 use broccoli::build;
 const NUM_ELEMENT:usize=40;
 let mut bots = [axgeom::rect(0,10,0,10);NUM_ELEMENT];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.get_height(),build::TreePreBuilder::new(NUM_ELEMENT).get_height());

#[must_use]pub fn num_aabbs(&self) -> usize

Examples

 use broccoli::build;
 const NUM_ELEMENT:usize=7;
 let mut bots = [axgeom::rect(0,10,0,10);NUM_ELEMENT];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.num_aabbs(),7);

#[must_use]pub fn num_nodes(&self) -> usize

Examples

 use broccoli::build;
 let mut bots = [axgeom::rect(0,10,0,10)];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.num_nodes(),build::TreePreBuilder::new(1).num_nodes());

#[must_use]pub fn get_nodes(&self) -> &[Node<'a, T>]

Examples

 let mut bots = [axgeom::rect(0,10,0,10)];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.get_nodes()[0].range[0], axgeom::rect(0,10,0,10));

#[must_use]pub fn get_nodes_mut(&mut self) -> PMut<'_, [Node<'a, T>]>

Examples

 let mut bots = [axgeom::rect(0,10,0,10)];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.get_nodes_mut().get_index_mut(0).range[0], axgeom::rect(0,10,0,10));

#[must_use]pub fn get_elements_mut(&mut self) -> PMut<'_, [T]>

Return the underlying slice of aabbs in the order sorted during tree construction.

Examples

 let mut bots = [axgeom::rect(0,10,0,10)];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(*tree.get_elements_mut().get_index_mut(0), axgeom::rect(0,10,0,10));

#[must_use]pub fn get_elements(&self) -> &[T]

Return the underlying slice of aabbs in the order sorted during tree construction.

Examples

 let mut bots = [axgeom::rect(0,10,0,10)];
 let tree = broccoli::new(&mut bots);

 assert_eq!(tree.get_elements()[0], axgeom::rect(0,10,0,10));

Trait Implementations

impl<'a, 'b, N: Num, T> Deref for TreeInd<'a, 'b, N, T>

type Target = Tree<'b, BBox<N, &'a mut T>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, 'b, N: Num, T> DerefMut for TreeInd<'a, 'b, N, T>

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

Mutably dereferences the value.

impl<'a, 'b, N: Num, T> From<TreeInd<'a, 'b, N, T>> for Tree<'b, BBox<N, &'a mut T>>

pub fn from(a: TreeInd<'a, 'b, N, T>) -> Self

Performs the conversion.