Struct broccoli::tree::aabb_pin::AabbPin

#[repr(transparent)]
pub struct AabbPin<T> where
    T: ?Sized,  { /* private fields */ }

A protected mutable reference that derefs to &T. See the AabbPin module documentation for more explanation.

Implementations

impl<'a, T> AabbPin<*mut T> where
    T: ?Sized, 

pub fn as_raw(&self) -> *mut T

impl<'a, 'b, T> AabbPin<&'a mut AabbPin<&'b mut T>> where
    T: ?Sized, 

pub fn flatten(self) -> AabbPin<&'a mut T>

impl<'a, T> AabbPin<&'a mut T>

pub fn into_slice(self) -> AabbPin<&'a mut [T]>

impl<'a, T> AabbPin<&'a mut T> where
    T: ?Sized, 

pub fn borrow_mut(&mut self) -> AabbPin<&mut T>

Start a new borrow lifetime

pub fn as_ptr_mut(&mut self) -> AabbPin<*mut T>

pub fn into_ref(self) -> &'a T

impl<'a, T> AabbPin<&'a mut T> where
    T: ?Sized, 

pub fn from_mut(inner: &'a mut T) -> AabbPin<&'a mut T>

Create a protected pointer.

impl<T> AabbPin<T>

pub fn new(inner: T) -> AabbPin<T>

Create a protected pointer.

impl<'a, 'b, T> AabbPin<&'a mut Node<'b, T>> where
    'b: 'a,
    T: Aabb, 

pub fn into_node_ref(self) -> NodeRef<'a, T>

Destructure a node into its three parts.

pub fn get_cont(&self) -> &Range<<T as Aabb>::Num>

pub fn into_range(self) -> AabbPin<&'a mut [T]>

Return a mutable list of elements in this node.

impl<'a, T> AabbPin<&'a mut T> where
    T: HasInner, 

pub fn destruct_mut(
    &mut self
) -> (&Rect<<T as Aabb>::Num>, &mut <T as HasInner>::Inner)

impl<'a, T> AabbPin<&'a mut T> where
    T: HasInner, 

pub fn unpack_inner(self) -> &'a mut <T as HasInner>::Inner

Unpack only the mutable innner component

impl<'a, T> AabbPin<&'a mut [T]>

pub fn get_index_mut(self, ind: usize) -> AabbPin<&'a mut T>

Return the element at the specified index. We can’t use the index trait because we don’t want to return a mutable reference.

pub fn split_at_mut(
    self,
    va: usize
) -> (AabbPin<&'a mut [T]>, AabbPin<&'a mut [T]>)

Split off the first element.

pub fn split_first_mut(
    self
) -> Option<(AabbPin<&'a mut T>, AabbPin<&'a mut [T]>)>

Split off the first element.

pub fn truncate_to(self, a: RangeTo<usize>) -> AabbPin<&'a mut [T]>

Return a smaller slice that ends with the specified index.

pub fn truncate_from(self, a: RangeFrom<usize>) -> AabbPin<&'a mut [T]>

Return a smaller slice that starts at the specified index.

pub fn truncate(self, a: Range<usize>) -> AabbPin<&'a mut [T]>

Return a smaller slice that starts and ends with the specified range.

pub fn iter_mut(self) -> AabbPinIter<'a, T>

Return a mutable iterator.

Trait Implementations

impl<'a, T> Clone for AabbPin<*mut T> where
    T: ?Sized, 

fn clone(&self) -> AabbPin<*mut T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T: Aabb> CollidingPairsApi<T> for AabbPin<&'a mut [T]>

fn colliding_pairs(
    &mut self,
    func: impl FnMut(AabbPin<&mut T>, AabbPin<&mut T>)
)

impl<T> Debug for AabbPin<T> where
    T: Debug + ?Sized, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Deref for AabbPin<T> where
    T: Deref, 

type Target = <T as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &<T as Deref>::Target

Dereferences the value.

impl<'a, T> From<&'a mut T> for AabbPin<&'a mut T>

fn from(a: &'a mut T) -> AabbPin<&'a mut T>

Converts to this type from the input type.

impl<'a, T> IntoIterator for AabbPin<&'a mut [T]>

type Item = AabbPin<&'a mut T>

The type of the elements being iterated over.

type IntoIter = AabbPinIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <AabbPin<&'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T: Aabb> KnearestApi<T> for AabbPin<&'a mut [T]>

fn k_nearest_mut(
    &mut self,
    point: Vec2<T::Num>,
    num: usize,
    ktrait: impl Knearest<T>
) -> KResult<'_, T>

fn k_nearest_mut_aabb(
    &mut self,
    point: Vec2<T::Num>,
    num: usize
) -> KResult<'_, T> where
    T::Num: Signed + Zero, 

Find knearest using aabb only.

fn k_nearest_mut_closure(
    &mut self,
    point: Vec2<T::Num>,
    num: usize,
    broad: impl FnMut(Vec2<T::Num>, AabbPin<&mut T>) -> Option<T::Num>,
    fine: impl FnMut(Vec2<T::Num>, AabbPin<&mut T>) -> T::Num,
    xline: impl FnMut(Vec2<T::Num>, T::Num) -> T::Num,
    yline: impl FnMut(Vec2<T::Num>, T::Num) -> T::Num
) -> KResult<'_, T>

impl<'a, N: Nbody> NbodyApi<N> for AabbPin<&mut [N::T]>

fn nbody(self, no: &mut N) -> Self

impl<'a, T: Aabb> RaycastApi<T> for AabbPin<&'a mut [T]>

fn raycast_mut<R: RayCast<T>>(
    &mut self,
    ray: Ray<T::Num>,
    ar: R
) -> CastResult<CastAnswer<'_, T>>

fn raycast_mut_aabb(
    &mut self,
    ray: Ray<T::Num>
) -> CastResult<CastAnswer<'_, T>> where
    T::Num: Debug + Signed, 

Create a handler that just casts directly to the axis aligned rectangle

fn raycast_mut_closure(
    &mut self,
    ray: Ray<T::Num>,
    broad: impl FnMut(&Ray<T::Num>, AabbPin<&mut T>) -> Option<CastResult<T::Num>>,
    fine: impl FnMut(&Ray<T::Num>, AabbPin<&mut T>) -> CastResult<T::Num>,
    xline: impl FnMut(&Ray<T::Num>, T::Num) -> CastResult<T::Num>,
    yline: impl FnMut(&Ray<T::Num>, T::Num) -> CastResult<T::Num>
) -> CastResult<CastAnswer<'_, T>>

impl<'a, T: Aabb> RectApi<'a, T> for AabbPin<&'a mut [T]>

fn for_all_not_in_rect_mut<K: Aabb<Num = T::Num>>(
    self,
    rect: AabbPin<&mut K>,
    closure: impl FnMut(AabbPin<&mut K>, AabbPin<&'a mut T>)
)

fn for_all_in_rect_mut<K: Aabb<Num = T::Num>>(
    self,
    rect: AabbPin<&mut K>,
    closure: impl FnMut(AabbPin<&mut K>, AabbPin<&'a mut T>)
)

fn for_all_intersect_rect_mut<K: Aabb<Num = T::Num>>(
    self,
    rect: AabbPin<&mut K>,
    closure: impl FnMut(AabbPin<&mut K>, AabbPin<&'a mut T>)
)