use super::*;
pub trait HasInner: Aabb {
type Inner;
#[inline(always)]
fn get_inner_mut(&mut self) -> &mut Self::Inner {
self.destruct_mut().1
}
fn destruct_mut(&mut self) -> (&Rect<Self::Num>, &mut Self::Inner);
}
#[repr(transparent)]
#[derive(Debug)]
pub struct AabbPin<T: ?Sized> {
inner: T,
}
impl<T: std::ops::Deref> core::ops::Deref for AabbPin<T> {
type Target = T::Target;
#[inline(always)]
fn deref(&self) -> &T::Target {
&self.inner
}
}
impl<'a, T> From<&'a mut T> for AabbPin<&'a mut T> {
#[inline(always)]
fn from(a: &'a mut T) -> Self {
AabbPin::new(a)
}
}
impl<T: ?Sized> Clone for AabbPin<*mut T> {
#[inline(always)]
fn clone(&self) -> Self {
AabbPin { inner: self.inner }
}
}
impl<T: ?Sized> AabbPin<*mut T> {
#[inline(always)]
pub fn as_raw(&self) -> *mut T {
self.inner
}
}
impl<'a, 'b, T: ?Sized> AabbPin<&'a mut AabbPin<&'b mut T>> {
#[inline(always)]
pub fn flatten(self) -> AabbPin<&'a mut T> {
AabbPin {
inner: self.inner.inner,
}
}
}
impl<'a, T> AabbPin<&'a mut T> {
pub fn into_slice(self) -> AabbPin<&'a mut [T]> {
AabbPin {
inner: std::slice::from_mut(self.inner),
}
}
}
impl<'a, T: ?Sized> AabbPin<&'a mut T> {
#[inline(always)]
pub fn borrow_mut(&mut self) -> AabbPin<&mut T> {
AabbPin { inner: self.inner }
}
#[inline(always)]
pub fn as_ptr_mut(&mut self) -> AabbPin<*mut T> {
AabbPin {
inner: self.inner as *mut _,
}
}
#[inline(always)]
pub fn into_ref(self) -> &'a T {
self.inner
}
}
impl<'a, T: ?Sized> AabbPin<&'a mut T> {
#[inline(always)]
pub fn from_mut(inner: &'a mut T) -> AabbPin<&'a mut T> {
AabbPin { inner }
}
}
impl<T> AabbPin<T> {
#[inline(always)]
pub fn new(inner: T) -> AabbPin<T> {
AabbPin { inner }
}
}
pub struct NodeRef<'a, T, N> {
pub div: &'a Option<N>,
pub cont: &'a Range<N>,
pub range: AabbPin<&'a mut [T]>,
}
impl<'a, 'b: 'a, T, N> AabbPin<&'a mut Node<'b, T, N>> {
#[inline(always)]
pub fn into_node_ref(self) -> NodeRef<'a, T, N> {
NodeRef {
div: &self.inner.div,
cont: &self.inner.cont,
range: self.inner.range.borrow_mut(),
}
}
#[inline(always)]
pub fn get_cont(&self) -> &Range<N> {
&self.cont
}
#[inline(always)]
pub fn into_range(self) -> AabbPin<&'a mut [T]> {
self.inner.range.borrow_mut()
}
}
impl<'a, T: HasInner> AabbPin<&'a mut T> {
#[inline(always)]
pub fn destruct_mut(&mut self) -> (&Rect<T::Num>, &mut T::Inner) {
self.inner.destruct_mut()
}
}
impl<'a, T: HasInner> AabbPin<&'a mut T> {
#[inline(always)]
pub fn unpack_inner(self) -> &'a mut T::Inner {
self.inner.get_inner_mut()
}
}
impl<'a, T> AabbPin<&'a mut [T]> {
#[inline(always)]
pub fn get_index_mut(self, ind: usize) -> AabbPin<&'a mut T> {
AabbPin::new(&mut self.inner[ind])
}
#[inline(always)]
pub fn split_at_mut(self, va: usize) -> (AabbPin<&'a mut [T]>, AabbPin<&'a mut [T]>) {
let (left, right) = self.inner.split_at_mut(va);
(AabbPin::new(left), AabbPin::new(right))
}
#[inline(always)]
pub fn split_first_mut(self) -> Option<(AabbPin<&'a mut T>, AabbPin<&'a mut [T]>)> {
self.inner
.split_first_mut()
.map(|(first, inner)| (AabbPin { inner: first }, AabbPin { inner }))
}
#[inline(always)]
pub fn truncate_to(self, a: core::ops::RangeTo<usize>) -> Self {
AabbPin {
inner: &mut self.inner[a],
}
}
#[inline(always)]
pub fn truncate_from(self, a: core::ops::RangeFrom<usize>) -> Self {
AabbPin {
inner: &mut self.inner[a],
}
}
#[inline(always)]
pub fn truncate(self, a: core::ops::Range<usize>) -> Self {
AabbPin {
inner: &mut self.inner[a],
}
}
#[inline(always)]
pub fn iter_mut(self) -> AabbPinIter<'a, T> {
AabbPinIter {
inner: self.inner.iter_mut(),
}
}
}
impl<'a, T> core::iter::IntoIterator for AabbPin<&'a mut [T]> {
type Item = AabbPin<&'a mut T>;
type IntoIter = AabbPinIter<'a, T>;
#[inline(always)]
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
pub struct AabbPinIter<'a, T> {
inner: core::slice::IterMut<'a, T>,
}
impl<'a, T> Iterator for AabbPinIter<'a, T> {
type Item = AabbPin<&'a mut T>;
#[inline(always)]
fn next(&mut self) -> Option<AabbPin<&'a mut T>> {
self.inner.next().map(|inner| AabbPin { inner })
}
#[inline(always)]
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
impl<'a, T> core::iter::FusedIterator for AabbPinIter<'a, T> {}
impl<'a, T> core::iter::ExactSizeIterator for AabbPinIter<'a, T> {}
impl<'a, T> DoubleEndedIterator for AabbPinIter<'a, T> {
#[inline(always)]
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back().map(|inner| AabbPin { inner })
}
}