Trait broccoli::query::Queries

source · [−]
pub trait Queries<'a> {
    type A: Axis;
    type T: Aabb<Num = Self::Num> + 'a;
    type Num: Num;
    fn vistr_mut(&mut self) -> VistrMut<'_, NodeMut<'a, Self::T>>;

    fn vistr(&self) -> Vistr<'_, NodeMut<'a, Self::T>>;

    fn axis(&self) -> Self::A;

    fn new_colfind_builder(
        &mut self
    ) -> QueryBuilder<'_, Self::A, NodeMut<'a, Self::T>> { ... }

    fn draw_divider(
        &self, 
        drawer: &mut impl DividerDrawer<N = Self::Num>, 
        rect: &Rect<Self::Num>
    ) { ... }

    fn find_intersections_pmut(
        &mut self, 
        func: impl FnMut(PMut<'_, Self::T>, PMut<'_, Self::T>)
    ) { ... }

    fn multi_rect(&mut self) -> MultiRectMut<'_, Self::A, NodeMut<'a, Self::T>> { ... }

    fn for_all_intersect_rect<'b>(
        &'b self, 
        rect: &Rect<Self::Num>, 
        func: impl FnMut(&'b Self::T)
    )
    where
        'a: 'b,
    { ... }

    fn for_all_in_rect<'b>(
        &'b self, 
        rect: &Rect<Self::Num>, 
        func: impl FnMut(&'b Self::T)
    )
    where
        'a: 'b,
    { ... }

    fn nbody_mut<X: NodeMassTrait<Num = Self::Num, Item = Self::T> + Send + Sync>(
        &mut self, 
        ncontext: &X, 
        rect: Rect<Self::Num>
    )
    where
        X::No: Send,
        Self::T: HasInner + Send + Sync,
    { ... }

    fn nbody_mut_par<X: NodeMassTrait<Num = Self::Num, Item = Self::T> + Sync + Send>(
        &mut self, 
        ncontext: &X, 
        rect: Rect<Self::Num>
    )
    where
        X::No: Send,
        Self::T: HasInner + Send + Sync,
    { ... }
}

Associated Types

Required methods

Examples
use dinotree_alg::*;
let mut bots = [bbox(axgeom::rect(0,10,0,10),0)];
let mut tree = DinoTree::new(&mut bots);

use compt::Visitor;
for mut b in tree.vistr_mut().dfs_preorder_iter().flat_map(|n|n.get_mut().bots.iter_mut()){
    *b.inner_mut()+=1;    
}
assert_eq!(bots[0].inner,1);
Examples
use dinotree_alg::*;
let mut bots = [axgeom::rect(0,10,0,10)];
let mut tree = DinoTree::new(&mut bots);

use compt::Visitor;
let mut test = Vec::new();
for b in tree.vistr().dfs_preorder_iter().flat_map(|n|n.get().bots.iter()){
    test.push(b);
}
assert_eq!(test[0],&axgeom::rect(0,10,0,10));
Examples
use dinotree_alg::*;
let mut bots = [axgeom::rect(0,10,0,10)];
let mut tree = DinoTree::new(&mut bots);

use axgeom::Axis;
assert!(tree.axis().is_equal_to(default_axis()));

Provided methods

Examples
use dinotree_alg::*;
use axgeom::*;

struct Drawer;
impl dinotree_alg::query::DividerDrawer for Drawer{
    type N=i32;
    fn draw_divider<A:Axis>(
            &mut self,
            axis:A,
            div:Self::N,
            cont:[Self::N;2],
            length:[Self::N;2],
            depth:usize)
    {
        if axis.is_xaxis(){
            //draw vertical line
        }else{
            //draw horizontal line
        }
    }
}

let border=rect(0,100,0,100);
let mut bots =[rect(0,10,0,10)];
let tree=DinoTree::new(&mut bots);
tree.draw_divider(&mut Drawer,&border);

Find all aabb intersections and return a PMut of it. Unlike the regular find_intersections_mut, this allows the user to access a read only reference of the AABB.

Examples
use dinotree_alg::*;
let mut bots = [bbox(axgeom::rect(0,10,0,10),0u8),bbox(axgeom::rect(5,15,5,15),0u8)];
let mut tree = DinoTree::new(&mut bots);
tree.find_intersections_pmut(|mut a,mut b|{
    *a.inner_mut()+=1;
    *b.inner_mut()+=1;
});

assert_eq!(bots[0].inner,1);
assert_eq!(bots[1].inner,1);
Examples
use dinotree_alg::*;
let mut bots1 = [bbox(axgeom::rect(0,10,0,10),0u8)];
let mut tree = DinoTree::new(&mut bots1);
let mut multi = tree.multi_rect();

multi.for_all_in_rect_mut(axgeom::rect(0,10,0,10),|a|{}).unwrap();
let res = multi.for_all_in_rect_mut(axgeom::rect(5,15,5,15),|a|{});
assert_eq!(res,Err(dinotree_alg::query::RectIntersectErr));
Examples
use dinotree_alg::*;
let mut bots = [axgeom::rect(0,10,0,10),axgeom::rect(20,30,20,30)];
let mut tree = DinoTree::new(&mut bots);
let mut test = Vec::new();
tree.for_all_intersect_rect(&axgeom::rect(9,20,9,20),|a|{
    test.push(a);
});

assert_eq!(test[0],&axgeom::rect(0,10,0,10));
Examples
use dinotree_alg::*;
let mut bots = [axgeom::rect(0,10,0,10),axgeom::rect(20,30,20,30)];
let mut tree = DinoTree::new(&mut bots);
let mut test = Vec::new();
tree.for_all_in_rect(&axgeom::rect(0,20,0,20),|a|{
    test.push(a);
});

assert_eq!(test[0],&axgeom::rect(0,10,0,10));

Implementors

TODO use this insead