defaulted 0.1.0

use core::cell::{Cell, OnceCell, Ref, RefCell, RefMut};
use core::marker::PhantomPinned;
use core::num::Wrapping;
use core::sync::atomic::{
    AtomicBool, AtomicI8, AtomicI16, AtomicI32, AtomicI64, AtomicIsize, AtomicU8, AtomicU16,
    AtomicU32, AtomicU64, AtomicUsize, Ordering,
};
use core::time::Duration;

use crate::Defaulted;

// Primitives

impl Defaulted for bool
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        !self
    }
}

impl_defaulted_eq!(char, '\x00');

impl_defaulted_eq!(u8, 0);
impl_defaulted_eq!(u16, 0);
impl_defaulted_eq!(u32, 0);
impl_defaulted_eq!(u64, 0);
impl_defaulted_eq!(u128, 0);
impl_defaulted_eq!(usize, 0);

impl_defaulted_eq!(i8, 0);
impl_defaulted_eq!(i16, 0);
impl_defaulted_eq!(i32, 0);
impl_defaulted_eq!(i64, 0);
impl_defaulted_eq!(i128, 0);
impl_defaulted_eq!(isize, 0);

impl_defaulted_eq!(f32, 0.0);
impl_defaulted_eq!(f64, 0.0);

// ── Unit / marker types ─────────────────────────────────────────────

impl Defaulted for ()
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        true
    }
}

impl Defaulted for PhantomPinned
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        true
    }
}

// References

impl<T: Defaulted + ?Sized> Defaulted for &T
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        (**self).is_defaulted()
    }
}

impl<T: Defaulted + ?Sized> Defaulted for &mut T
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        (**self).is_defaulted()
    }
}

// Slices

impl_defaulted_empty!(str);

impl<T> Defaulted for [T]
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.is_empty()
    }
}

// Arrays

impl<T: Defaulted, const N: usize> Defaulted for [T; N]
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.iter().all(Defaulted::is_defaulted)
    }
}

// Option

impl<T> Defaulted for Option<T>
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.is_none()
    }
}

// Wrapping

impl<T: Defaulted> Defaulted for Wrapping<T>
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.0.is_defaulted()
    }
}

// Duration

impl Defaulted for Duration
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.is_zero()
    }
}

// Cell types

impl<T: Copy + Defaulted> Defaulted for Cell<T>
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.get().is_defaulted()
    }
}

impl<T: Defaulted + ?Sized> Defaulted for RefCell<T>
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.try_borrow().is_ok_and(|v| v.is_defaulted())
    }
}

impl<T> Defaulted for OnceCell<T>
{
    #[inline]
    fn is_defaulted(&self) -> bool
    {
        self.get().is_none()
    }
}

impl_defaulted_deref!(<T> for Ref<'_, T>);
impl_defaulted_deref!(<T> for RefMut<'_, T>);

// Atomics

macro_rules! impl_defaulted_atomic {
    ($type:ty, $val:expr) => {
        impl Defaulted for $type
        {
            #[inline]
            fn is_defaulted(&self) -> bool
            {
                self.load(Ordering::Relaxed) == $val
            }
        }
    };
}

impl_defaulted_atomic!(AtomicBool, false);

impl_defaulted_atomic!(AtomicI8, 0);
impl_defaulted_atomic!(AtomicI16, 0);
impl_defaulted_atomic!(AtomicI32, 0);
impl_defaulted_atomic!(AtomicI64, 0);
impl_defaulted_atomic!(AtomicIsize, 0);

impl_defaulted_atomic!(AtomicU8, 0);
impl_defaulted_atomic!(AtomicU16, 0);
impl_defaulted_atomic!(AtomicU32, 0);
impl_defaulted_atomic!(AtomicU64, 0);
impl_defaulted_atomic!(AtomicUsize, 0);

// Tuples

macro_rules! impl_defaulted_tuple {
    ($($T:ident),+) => {
        #[allow(non_snake_case)]
        impl<$($T: Defaulted),+> Defaulted for ($($T,)+)
        {
            #[inline]
            fn is_defaulted(&self) -> bool
            {
                let ($($T,)+) = self;
                $($T.is_defaulted())&&+
            }
        }
    };
}

impl_defaulted_tuple!(T0);
impl_defaulted_tuple!(T0, T1);
impl_defaulted_tuple!(T0, T1, T2);
impl_defaulted_tuple!(T0, T1, T2, T3);
impl_defaulted_tuple!(T0, T1, T2, T3, T4);
impl_defaulted_tuple!(T0, T1, T2, T3, T4, T5);
impl_defaulted_tuple!(T0, T1, T2, T3, T4, T5, T6);
impl_defaulted_tuple!(T0, T1, T2, T3, T4, T5, T6, T7);
impl_defaulted_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8);
impl_defaulted_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9);
impl_defaulted_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
impl_defaulted_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);