Struct broccoli::container::TreeInd

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

A less general tree that provides 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.

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.

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

Dereferences the value.

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

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>>

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

Performs the conversion.

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

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

The tree must be filled with T, which must have a pointer to Self::Inner.

type Inner = T

The type that the pointers are pointing to. The original slice is composed of this.

type Num = N

The number type of the aabb.

fn get_inner_elements(&self) -> &[Self::Inner]

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.

fn get_inner_elements_mut(&mut self) -> &mut [Self::Inner]

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.

fn get_tree_mut(&mut self) -> &mut Tree<'b, BBox<N, &'a mut T>>

Return a reference to the underlying tree.

fn collect_all<D: Send + Sync>(
    &mut self,
    mut func: impl FnMut(&Rect<Self::Num>, &mut Self::Inner) -> Option<D>
) -> FilteredElements<Self::Inner, D>

Collect all elements based off of a predicate and return a FilteredElements.

fn collect_colliding_pairs<D: Send + Sync>(
    &mut self,
    mut func: impl FnMut(&mut Self::Inner, &mut Self::Inner) -> Option<D> + Send + Sync
) -> CollidingPairs<Self::Inner, D>

Find all colliding pairs based on a predicate and return a CollidingPairs.

fn collect_colliding_pairs_par<D: Send + Sync>(
    &mut self,
    joiner: impl Joinable,
    func: impl Fn(&mut Self::Inner, &mut Self::Inner) -> Option<D> + Send + Sync + Copy
) -> CollidingPairsPar<Self::Inner, D> where
    Self::T: Send + Sync,
    Self::Num: Send + Sync, 

The parallel version of FromSlice::collect_colliding_pairs that instead returns a CollidingPairsPar.