static_init 1.0.4

#![allow(unused)] //functions that are usefull for extension

use crate::{
    Finaly, Generator, LazySequentializer, LockNature, LockResult, Phase, Phased, Sequential,
    Sequentializer, StaticInfo, Uninit, UniqueLazySequentializer,
};
use core::cell::UnsafeCell;
use core::fmt::{self, Debug, Display, Formatter};
use core::hint::unreachable_unchecked;
use core::marker::PhantomData;
use core::mem::MaybeUninit;
use core::ops::{Deref, DerefMut};

#[cfg(debug_mode)]
use crate::CyclicPanic;

#[cfg(any(feature = "parking_lot_core", debug_mode))]
use std::panic::RefUnwindSafe;

/// Policy for lazy initialization
pub(crate) trait LazyPolicy {
    /// shall the initialization be performed (tested at each access)
    fn shall_init(_: Phase) -> bool;
    /// Is the object accessible in phase `p`
    fn is_accessible(p: Phase) -> bool;
    /// Is the object accessible in phase `p`
    fn post_init_is_accessible(p: Phase) -> bool;
    /// If the object is known to already be initialized, is the object accessible in phase `p`
    fn initialized_is_accessible(p: Phase) -> bool;
}

/// Generic lazy interior data storage, uninitialized with interior mutability data storage
/// that call T::finaly when finalized
pub(crate) struct UnInited<T>(UnsafeCell<MaybeUninit<T>>);

impl<T: Finaly> Finaly for UnInited<T> {
    #[inline(always)]
    fn finaly(&self) {
        //SAFETY: UnInited is only used as part of GenericLazy, that gives access
        //only if the Sequentializer is a Lazy Sequentializer
        //
        //So the lazy Sequentializer should only execute finaly if the object initialization
        //succeeded
        unsafe { &*self.get() }.finaly();
    }
}

impl<T> UnInited<T> {
    #[allow(clippy::declare_interior_mutable_const)] // this is intentianaly used for
    pub const INIT: Self = Self(UnsafeCell::new(MaybeUninit::uninit()));
}

/// Generic lazy interior data storage, initialized with interior mutability data storage
/// that call T::finaly when finalized
pub(crate) struct Primed<T>(UnsafeCell<T>);

impl<T: Uninit> Finaly for Primed<T> {
    #[inline(always)]
    fn finaly(&self) {
        //SAFETY: UnInited is only used as part of GenericLazy, that gives access
        //only if the Sequentializer is a Lazy Sequentializer
        //
        //So the lazy Sequentializer should only execute finaly if the object initialization
        //succeeded
        unsafe { &mut *self.0.get() }.uninit();
    }
}

impl<T> Primed<T> {
    pub const fn prime(v: T) -> Self {
        Self(UnsafeCell::new(v))
    }
}

/// Generic lazy interior data storage, uninitialized with interior mutability data storage
/// that call drop when finalized
pub(crate) struct DropedUnInited<T>(UnsafeCell<MaybeUninit<T>>);

impl<T> Finaly for DropedUnInited<T> {
    #[inline(always)]
    fn finaly(&self) {
        //SAFETY: UnInited is only used as part of GenericLazy, that gives access
        //only if the Sequentializer is a Lazy Sequentializer
        //
        //So the lazy Sequentializer should only execute finaly if the object initialization
        //succeeded
        unsafe { self.get().drop_in_place() };
    }
}

impl<T> DropedUnInited<T> {
    #[allow(clippy::declare_interior_mutable_const)]
    pub const INIT: Self = Self(UnsafeCell::new(MaybeUninit::uninit()));
}

/// Trait implemented by generic lazy inner data.
///
/// Dereferencement of generic lazy will return a reference to
/// the inner data returned by the get method
pub(crate) trait LazyData {
    type Target;
    fn get(&self) -> *mut Self::Target;
    /// # Safety
    ///
    /// The reference to self should be unique
    unsafe fn init(&self, v: Self::Target);
    fn init_mut(&mut self, v: Self::Target);
}

impl<T> LazyData for UnInited<T> {
    type Target = T;
    #[inline(always)]
    fn get(&self) -> *mut T {
        self.0.get() as *mut T
    }
    #[inline(always)]
    unsafe fn init(&self, v: T) {
        self.get().write(v)
    }
    #[inline(always)]
    fn init_mut(&mut self, v: T) {
        *self.0.get_mut() = MaybeUninit::new(v)
    }
}

impl<T> LazyData for DropedUnInited<T> {
    type Target = T;
    #[inline(always)]
    fn get(&self) -> *mut T {
        self.0.get() as *mut T
    }
    #[inline(always)]
    unsafe fn init(&self, v: T) {
        self.get().write(v)
    }
    #[inline(always)]
    fn init_mut(&mut self, v: T) {
        *self.0.get_mut() = MaybeUninit::new(v)
    }
}

impl<T> LazyData for Primed<T> {
    type Target = T;
    #[inline(always)]
    fn get(&self) -> *mut T {
        self.0.get()
    }
    #[inline(always)]
    unsafe fn init(&self, v: T) {
        *self.get() = v
    }
    #[inline(always)]
    fn init_mut(&mut self, v: T) {
        *self.0.get_mut() = v
    }
}

/// Lazy access error
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
pub struct AccessError {
    pub phase: Phase,
}

impl Display for AccessError {
    fn fmt(&self, ft: &mut Formatter<'_>) -> fmt::Result {
        write!(ft, "Error: inaccessible lazy in {}", self.phase)
    }
}

#[cfg(feature = "parking_lot_core")]
impl std::error::Error for AccessError {}

pub(crate) struct GenericLazySeq<T, M> {
    value: T,
    sequentializer: M,
}

pub(crate) struct GenericLockedLazySeq<T, M> {
    value: T,
    sequentializer: M,
}

/// A type that wrap a Sequentializer and a raw data, and that may
/// initialize the data, at each access depending on the LazyPolicy
/// provided as generic argument.
pub(crate) struct GenericLazy<T, F, M, S> {
    seq: GenericLazySeq<T, M>,
    generator: F,
    phantom: PhantomData<S>,
    #[cfg(debug_mode)]
    _info: Option<StaticInfo>,
}

// SAFETY: The synchronization is ensured by the Sequentializer
//  1. GenericLazy fullfill the requirement that its sequentializer is a field
//  of itself as is its target data.
//  2. The sequentializer ensure that the initialization is atomic
unsafe impl<T: LazyData, M: Sync> Sync for GenericLazySeq<T, M> where <T as LazyData>::Target: Sync {}
unsafe impl<T: LazyData, M: Sync> Send for GenericLazySeq<T, M> where <T as LazyData>::Target: Send {}

#[cfg(any(feature = "parking_lot_core", debug_mode))]
impl<T: LazyData, M: RefUnwindSafe> RefUnwindSafe for GenericLazySeq<T, M> where
    <T as LazyData>::Target: RefUnwindSafe
{
}

// SAFETY: The synchronization is ensured by the Sequentializer
//  1. GenericLazy fullfill the requirement that its sequentializer is a field
//  of itself as is its target data.
//  2. The sequentializer ensure that the initialization is atomic
unsafe impl<T: LazyData, M: Sync> Sync for GenericLockedLazySeq<T, M> where
    <T as LazyData>::Target: Send
{
}
unsafe impl<T: LazyData, M: Sync> Send for GenericLockedLazySeq<T, M> where
    <T as LazyData>::Target: Send
{
}

#[cfg(any(feature = "parking_lot_core", debug_mode))]
impl<T: LazyData, M: RefUnwindSafe> RefUnwindSafe for GenericLockedLazySeq<T, M> where
    <T as LazyData>::Target: RefUnwindSafe
{
}

impl<T, F, M, S> GenericLazy<T, F, M, S> {
    #[inline(always)]
    /// const initialize the lazy, the inner data may be in an uninitialized state
    ///
    /// # Safety
    ///
    /// ## Constraint on T
    ///
    /// Should initialize the object when init is called and the method get should
    /// return a pointer without UB if the object is not initialized
    ///
    /// ## Constraint on P
    ///
    /// The parameter M should be a lazy sequentializer that ensure that:
    ///  1. When finalize is called, no other shared reference to the inner data exist
    ///  2. The finalization is run only if the object was previously initialized
    ///
    /// ## Constraint on F
    ///
    /// The parameter F should be a Generator that ensured that the object
    /// is accessble after a call to generate succeeds
    ///
    /// ## Constraint on S
    ///
    /// S should be a lazy policy that report correctly when the object
    /// is accessbile, this in adequation with M and F.
    pub const unsafe fn new(generator: F, sequentializer: M, value: T) -> Self {
        Self {
            seq: GenericLazySeq {
                value,
                sequentializer,
            },
            generator,
            phantom: PhantomData,
            #[cfg(debug_mode)]
            _info: None,
        }
    }
    #[inline(always)]
    /// const initialize the lazy, the inner data may be in an uninitialized state
    ///
    /// # Safety
    ///
    /// ## Constraint on T
    ///
    /// Should initialize the object when init is called and the method get should
    /// return a pointer without UB if the object is not initialized
    ///
    /// ## Constraint on P
    ///
    /// The parameter M should be a lazy sequentializer that ensure that:
    ///  1. When finalize is called, no other shared reference to the inner data exist
    ///  2. The finalization is run only if the object was previously initialized
    ///
    /// ## Constraint on F
    ///
    /// The parameter F should be a Generator that ensured that the object
    /// is accessble after a call to generate succeeds
    ///
    /// ## Constraint on S
    ///
    /// S should be a lazy policy that report correctly when the object
    /// is accessbile, this in adequation with M and F.
    pub const unsafe fn new_with_info(
        generator: F,
        sequentializer: M,
        value: T,
        _info: StaticInfo,
    ) -> Self {
        Self {
            seq: GenericLazySeq {
                value,
                sequentializer,
            },
            generator,
            phantom: PhantomData,
            #[cfg(debug_mode)]
            _info: Some(_info),
        }
    }
    #[inline(always)]
    ///get access to the sequentializer
    pub fn sequentializer(this: &Self) -> &M {
        &this.seq.sequentializer
    }
    #[inline(always)]
    ///get a pointer to the raw data
    pub fn get_raw_data(this: &Self) -> &T {
        &this.seq.value
    }
}
impl<'a, T, F, M, S> GenericLazy<T, F, M, S>
where
    T: 'a + LazyData,
    M: 'a,
    M: LazySequentializer<'a, GenericLazySeq<T, M>>,
    F: 'a + Generator<T::Target>,
    S: 'a + LazyPolicy,
{
    /// Get a reference to the target
    ///
    /// # Safety
    ///
    /// Undefined behaviour if the referenced value has not been initialized
    #[inline(always)]
    pub unsafe fn get_unchecked(&'a self) -> &'a T::Target {
        &*self.seq.value.get()
    }

    /// Get a reference to the target, returning an error if the
    /// target is not in the correct phase.
    #[inline(always)]
    pub fn try_get(&'a self) -> Result<&'a T::Target, AccessError> {
        check_access::<*mut T::Target, S>(
            self.seq.value.get(),
            Phased::phase(&self.seq.sequentializer),
        )
        .map(|ptr| unsafe { &*ptr })
    }

    /// Get a reference to the target
    ///
    /// # Panics
    ///
    /// Panic if the target is not in the correct phase
    #[inline(always)]
    pub fn get(&'a self) -> &'a T::Target {
        self.try_get().unwrap()
    }

    /// Get a mutable reference to the target
    ///
    /// # Safety
    ///
    /// Undefined behaviour if the referenced value has not been initialized
    #[inline(always)]
    pub unsafe fn get_mut_unchecked(&'a mut self) -> &'a mut T::Target {
        &mut *self.seq.value.get()
    }

    /// Get a mutable reference to the target, returning an error if the
    /// target is not in the correct phase.
    #[inline(always)]
    pub fn try_get_mut(&'a mut self) -> Result<&'a mut T::Target, AccessError> {
        check_access::<*mut T::Target, S>(
            self.seq.value.get(),
            Phased::phase(&self.seq.sequentializer),
        )
        .map(|ptr| unsafe { &mut *ptr })
    }

    /// Get a reference to the target
    ///
    /// # Panics
    ///
    /// Panic if the target is not in the correct phase
    #[inline(always)]
    pub fn get_mut(&'a mut self) -> &'a mut T::Target {
        self.try_get_mut().unwrap()
    }

    /// Attempt initialization then get a reference to the target
    ///
    /// # Safety
    ///
    /// Undefined behaviour if the referenced value has not been initialized
    #[inline(always)]
    pub unsafe fn init_then_get_unchecked(&'a self) -> &'a T::Target {
        self.init();
        self.get_unchecked()
    }
    /// Attempt initialization then get a reference to the target, returning an error if the
    /// target is not in the correct phase.
    #[inline(always)]
    pub fn init_then_try_get(&'a self) -> Result<&'a T::Target, AccessError> {
        let phase = self.init();
        post_init_check_access::<*mut T::Target, S>(self.seq.value.get(), phase)
            .map(|ptr| unsafe { &*ptr })
    }
    /// Attempt initialization then get a reference to the target, returning an error if the
    /// target is not in the correct phase.
    #[inline(always)]
    pub fn init_then_get(&'a self) -> &'a T::Target {
        Self::init_then_try_get(self).unwrap()
    }
    #[inline(always)]
    /// Potentialy initialize the inner data, returning the
    /// phase reached at the end of the initialization attempt
    pub fn init(&'a self) -> Phase {
        may_debug(
            || {
                <M as LazySequentializer<'a, GenericLazySeq<T, M>>>::init(
                    &self.seq,
                    S::shall_init,
                    |data: &T| {
                        // SAFETY
                        // This function is called only once within the init function
                        // Only one thread can ever get this mutable access
                        let d = Generator::generate(&self.generator);
                        unsafe { data.init(d) };
                    },
                )
            },
            #[cfg(debug_mode)]
            &self._info,
        )
    }
}

impl<T, F, M, S> GenericLazy<T, F, M, S>
where
    M: UniqueLazySequentializer<GenericLazySeq<T, M>>,
    T: LazyData,
    S: LazyPolicy,
    F: Generator<T::Target>,
{
    #[inline(always)]
    /// Attempt initialization then get a mutable reference to the target
    ///
    /// # Safety
    ///
    /// Undefined behaviour if the referenced value has not been initialized
    pub unsafe fn only_init_then_get_mut_unchecked(&mut self) -> &mut T::Target {
        self.only_init_unique();
        &mut *self.seq.value.get()
    }

    #[inline(always)]
    /// Attempt initialization then get a mutable reference to the target, returning an error if the
    /// target is not in the correct phase.
    pub fn only_init_then_try_get_mut(&mut self) -> Result<&mut T::Target, AccessError> {
        let phase = self.only_init_unique();
        post_init_check_access::<*mut T::Target, S>(self.seq.value.get(), phase)
            .map(|ptr| unsafe { &mut *ptr })
    }

    #[inline(always)]
    /// Attempt initialization then get a mutable reference to the target, returning an error if the
    /// target is not in the correct phase.
    pub fn only_init_then_get_mut(&mut self) -> &mut T::Target {
        Self::only_init_then_try_get_mut(self).unwrap()
    }

    #[inline(always)]
    /// Potentialy initialize the inner data, returning the
    /// phase reached at the end of the initialization attempt
    pub fn only_init_unique(&mut self) -> Phase {
        let generator = &self.generator;
        let seq = &mut self.seq;
        <M as UniqueLazySequentializer<GenericLazySeq<T, M>>>::init_unique(
            seq,
            S::shall_init,
            |data: &mut T| {
                // SAFETY
                // This function is called only once within the init function
                // Only one thread can ever get this mutable access
                let d = Generator::generate(generator);
                unsafe { data.init_mut(d) };
            },
        )
    }
}

//SAFETY: data and sequentialize are two fields of Self.
unsafe impl<T: LazyData, M> Sequential for GenericLazySeq<T, M> {
    type Data = T;
    type Sequentializer = M;
    #[inline(always)]
    fn sequentializer(this: &Self) -> &Self::Sequentializer {
        &this.sequentializer
    }
    #[inline(always)]
    fn sequentializer_data_mut(this: &mut Self) -> (&mut Self::Sequentializer, &mut Self::Data) {
        (&mut this.sequentializer, &mut this.value)
    }
    #[inline(always)]
    fn data(this: &Self) -> &Self::Data {
        &this.value
    }
}

#[must_use = "If unused the write lock is immediatly released"]
pub(crate) struct WriteGuard<T>(T);

impl<T> Deref for WriteGuard<T>
where
    T: Deref,
    <T as Deref>::Target: LazyData,
{
    type Target = <<T as Deref>::Target as LazyData>::Target;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*(*self.0).get() }
    }
}
impl<T> DerefMut for WriteGuard<T>
where
    T: Deref,
    <T as Deref>::Target: LazyData,
{
    #[inline(always)]
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *(*self.0).get() }
    }
}

impl<T> Phased for WriteGuard<T>
where
    T: Phased,
{
    #[inline(always)]
    fn phase(this: &Self) -> Phase {
        Phased::phase(&this.0)
    }
}

impl<T> Debug for WriteGuard<T>
where
    T: Deref,
    <T as Deref>::Target: LazyData,
    <<T as Deref>::Target as LazyData>::Target: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.debug_tuple("WriteGuard").field(&**self).finish()
    }
}

#[must_use = "If unused the read lock is immediatly released"]
#[derive(Clone)]
pub(crate) struct ReadGuard<T>(T);

impl<T> Deref for ReadGuard<T>
where
    T: Deref,
    <T as Deref>::Target: LazyData,
{
    type Target = <<T as Deref>::Target as LazyData>::Target;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        unsafe { &*(*self.0).get() }
    }
}

impl<T> Debug for ReadGuard<T>
where
    T: Deref,
    <T as Deref>::Target: LazyData,
    <<T as Deref>::Target as LazyData>::Target: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.debug_tuple("ReadGuard").field(&**self).finish()
    }
}

impl<T, U> From<WriteGuard<T>> for ReadGuard<U>
where
    U: From<T>,
{
    #[inline(always)]
    fn from(v: WriteGuard<T>) -> Self {
        Self(v.0.into())
    }
}

impl<T> Phased for ReadGuard<T>
where
    T: Phased,
{
    #[inline(always)]
    fn phase(this: &Self) -> Phase {
        Phased::phase(&this.0)
    }
}

#[cfg(any(feature = "parking_lot_core", debug_mode))]
impl<T: LazyData> RefUnwindSafe for ReadGuard<T> where <T as LazyData>::Target: RefUnwindSafe {}

#[cfg(any(feature = "parking_lot_core", debug_mode))]
impl<T: LazyData> RefUnwindSafe for WriteGuard<T> where <T as LazyData>::Target: RefUnwindSafe {}

/// A type that wrap a Sequentializer and a raw data, and that may
/// initialize the data, at each access depending on the LazyPolicy
/// provided as generic argument.
pub(crate) struct GenericLockedLazy<T, F, M, S> {
    seq: GenericLockedLazySeq<T, M>,
    generator: F,
    phantom: PhantomData<S>,
    #[cfg(debug_mode)]
    _info: Option<StaticInfo>,
}

impl<T, F, M, S> GenericLockedLazy<T, F, M, S> {
    #[inline(always)]
    /// const initialize the lazy, the inner data may be in an uninitialized state
    ///
    /// # Safety
    ///
    /// ## Constraint on T
    ///
    /// Should initialize the object when init is called and the method get should
    /// return a pointer without UB if the object is not initialized
    ///
    /// ## Constraint on P
    ///
    /// The parameter M should be a lazy sequentializer that ensure that:
    ///  1. When finalize is called, no other shared reference to the inner data exist
    ///  2. The finalization is run only if the object was previously initialized
    ///
    /// ## Constraint on F
    ///
    /// The parameter F should be a Generator that ensured that the object
    /// is accessble after a call to generate succeeds
    ///
    /// ## Constraint on S
    ///
    /// S should be a lazy policy that report correctly when the object
    /// is accessbile, this in adequation with M and F.
    pub const unsafe fn new(generator: F, sequentializer: M, value: T) -> Self {
        Self {
            seq: GenericLockedLazySeq {
                value,
                sequentializer,
            },
            generator,
            phantom: PhantomData,
            #[cfg(debug_mode)]
            _info: None,
        }
    }
    #[inline(always)]
    /// const initialize the lazy, the inner data may be in an uninitialized state
    ///
    /// # Safety
    ///
    /// ## Constraint on T
    ///
    /// Should initialize the object when init is called and the method get should
    /// return a pointer without UB if the object is not initialized
    ///
    /// ## Constraint on P
    ///
    /// The parameter M should be a lazy sequentializer that ensure that:
    ///  1. When finalize is called, no other shared reference to the inner data exist
    ///  2. The finalization is run only if the object was previously initialized
    ///
    /// ## Constraint on F
    ///
    /// The parameter F should be a Generator that ensured that the object
    /// is accessble after a call to generate succeeds
    ///
    /// ## Constraint on S
    ///
    /// S should be a lazy policy that report correctly when the object
    /// is accessbile, this in adequation with M and F.
    pub const unsafe fn new_with_info(
        generator: F,
        sequentializer: M,
        value: T,
        _info: StaticInfo,
    ) -> Self {
        Self {
            seq: GenericLockedLazySeq {
                value,
                sequentializer,
            },
            generator,
            phantom: PhantomData,
            #[cfg(debug_mode)]
            _info: Some(_info),
        }
    }
    #[inline(always)]
    ///get access to the sequentializer
    pub fn sequentializer(this: &Self) -> &M {
        &this.seq.sequentializer
    }
}
impl<'a, T, F, M, S> GenericLockedLazy<T, F, M, S>
where
    T: 'a + LazyData,
    M: 'a,
    M: LazySequentializer<'a, GenericLockedLazySeq<T, M>>,
    F: 'a + Generator<T::Target>,
    S: 'a + LazyPolicy,
    M::ReadGuard: Phased,
    M::WriteGuard: Phased,
{
    /// Get a mutable reference to the target
    ///
    /// # Safety
    ///
    /// Undefined behaviour if the referenced value has not been initialized
    #[inline(always)]
    pub unsafe fn get_mut_unchecked(&'a mut self) -> &'a mut T::Target {
        &mut *self.seq.value.get()
    }

    /// Get a mutable reference to the target, returning an error if the
    /// target is not in the correct phase.
    #[inline(always)]
    pub fn try_get_mut(&'a mut self) -> Result<&'a mut T::Target, AccessError> {
        check_access::<*mut T::Target, S>(
            self.seq.value.get(),
            Phased::phase(&self.seq.sequentializer),
        )
        .map(|ptr| unsafe { &mut *ptr })
    }

    /// Get a reference to the target
    ///
    /// # Panics
    ///
    /// Panic if the target is not in the correct phase
    #[inline(always)]
    pub fn get_mut(&'a mut self) -> &'a mut T::Target {
        self.try_get_mut().unwrap()
    }
    /// Attempt to get a read lock the LazyData object (not the target), returning None
    /// if a unique lock is already held or in high contention cases.
    ///
    /// # Safety
    ///
    /// The obtained [ReadGuard] may reference an uninitialized target.
    #[inline(always)]
    pub unsafe fn fast_read_lock_unchecked(this: &'a Self) -> Option<ReadGuard<M::ReadGuard>> {
        <M as Sequentializer<'a, GenericLockedLazySeq<T, M>>>::try_lock(
            &this.seq,
            |_| LockNature::Read,
            M::INITIALIZED_HINT,
        )
        .map(|l| {
            if let LockResult::Read(l) = l {
                ReadGuard(l)
            } else {
                unreachable_unchecked()
            }
        })
    }
    /// Attempt to get a read lock the LazyData object (not the target), returning None
    /// if a unique lock is already held or in high contention cases.
    ///
    /// If the lock succeeds and the object is not in an accessible phase, some error is returned
    #[inline(always)]
    pub fn fast_try_read_lock(
        this: &'a Self,
    ) -> Option<Result<ReadGuard<M::ReadGuard>, AccessError>> {
        unsafe { Self::fast_read_lock_unchecked(this) }
            .map(checked_access::<ReadGuard<M::ReadGuard>, S>)
    }

    /// Attempt to get a read lock the LazyData object (not the target), returning None
    /// if a unique lock is already held or in high contention cases.
    ///
    /// # Panics
    ///
    /// Panics if the lock succeeds and the object is not in an accessible phase.
    #[inline(always)]
    pub fn fast_read_lock(this: &'a Self) -> Option<ReadGuard<M::ReadGuard>> {
        Self::fast_try_read_lock(this).map(|r| r.unwrap())
    }

    /// Get a read lock the LazyData object (not the target)
    ///
    /// # Safety
    ///
    /// The obtained [ReadGuard] may reference an uninitialized target.
    #[inline(always)]
    pub unsafe fn read_lock_unchecked(this: &'a Self) -> ReadGuard<M::ReadGuard> {
        if let LockResult::Read(l) = <M as Sequentializer<'a, GenericLockedLazySeq<T, M>>>::lock(
            &this.seq,
            |_| LockNature::Read,
            M::INITIALIZED_HINT,
        ) {
            ReadGuard(l)
        } else {
            unreachable_unchecked()
        }
    }

    /// Get a read lock the LazyData object (not the target)
    ///
    /// If the object is not in an accessible phase, some error is returned
    #[inline(always)]
    pub fn try_read_lock(this: &'a Self) -> Result<ReadGuard<M::ReadGuard>, AccessError> {
        checked_access::<ReadGuard<M::ReadGuard>, S>(unsafe { Self::read_lock_unchecked(this) })
    }

    /// Get a read lock the LazyData object (not the target).
    ///
    /// # Panics
    ///
    /// Panics if the lock succeeds and the object is not in an accessible phase.
    #[inline(always)]
    pub fn read_lock(this: &'a Self) -> ReadGuard<M::ReadGuard> {
        Self::try_read_lock(this).unwrap()
    }

    /// Attempt to get a write lock the LazyData object (not the target), returning None
    /// if a lock is already held or in high contention cases.
    ///
    /// # Safety
    ///
    /// The obtained [ReadGuard] may reference an uninitialized target.
    #[inline(always)]
    pub unsafe fn fast_write_lock_unchecked(this: &'a Self) -> Option<WriteGuard<M::WriteGuard>> {
        <M as Sequentializer<'a, GenericLockedLazySeq<T, M>>>::try_lock(
            &this.seq,
            |_| LockNature::Write,
            M::INITIALIZED_HINT,
        )
        .map(|l| {
            if let LockResult::Write(l) = l {
                WriteGuard(l)
            } else {
                unreachable_unchecked()
            }
        })
    }

    /// Attempt to get a write lock the LazyData object (not the target), returning None
    /// if a lock is already held or in high contention cases.
    ///
    /// If the lock succeeds and the object is not in an accessible phase, some error is returned
    #[inline(always)]
    pub fn fast_try_write_lock(
        this: &'a Self,
    ) -> Option<Result<WriteGuard<M::WriteGuard>, AccessError>> {
        unsafe { Self::fast_write_lock_unchecked(this) }
            .map(checked_access::<WriteGuard<M::WriteGuard>, S>)
    }

    /// Attempt to get a write lock the LazyData object (not the target), returning None
    /// if a lock is already held or in high contention cases.
    ///
    /// # Panics
    ///
    /// Panics if the lock succeeds and the object is not in an accessible phase.
    #[inline(always)]
    pub fn fast_write_lock(this: &'a Self) -> Option<WriteGuard<M::WriteGuard>> {
        Self::fast_try_write_lock(this).map(|r| r.unwrap())
    }

    /// Get a write lock the LazyData object (not the target)
    ///
    /// # Safety
    ///
    /// The obtained [ReadGuard] may reference an uninitialized target.
    #[inline(always)]
    pub unsafe fn write_lock_unchecked(this: &'a Self) -> WriteGuard<M::WriteGuard> {
        if let LockResult::Write(l) = <M as Sequentializer<'a, GenericLockedLazySeq<T, M>>>::lock(
            &this.seq,
            |_| LockNature::Write,
            M::INITIALIZED_HINT,
        ) {
            WriteGuard(l)
        } else {
            unreachable_unchecked()
        }
    }

    /// Get a read lock the LazyData object (not the target)
    ///
    /// If the object is not in an accessible phase, an error is returned
    #[inline(always)]
    pub fn try_write_lock(this: &'a Self) -> Result<WriteGuard<M::WriteGuard>, AccessError> {
        checked_access::<WriteGuard<M::WriteGuard>, S>(unsafe { Self::write_lock_unchecked(this) })
    }

    /// Get a write lock the LazyData object (not the target).
    ///
    /// # Panics
    ///
    /// Panics if the lock succeeds and the object is not in an accessible phase.
    #[inline(always)]
    pub fn write_lock(this: &'a Self) -> WriteGuard<M::WriteGuard> {
        Self::try_write_lock(this).unwrap()
    }

    #[inline(always)]
    /// Initialize if necessary then return a read lock
    ///
    /// # Safety
    ///
    /// Undefined behaviour if after initialization the return object is not in an accessible
    /// state.
    pub unsafe fn init_then_read_lock_unchecked(this: &'a Self) -> ReadGuard<M::ReadGuard> {
        let r = may_debug(
            || {
                <M as LazySequentializer<'a, GenericLockedLazySeq<T, M>>>::init_then_read_guard(
                    &this.seq,
                    S::shall_init,
                    |data: &T| {
                        // SAFETY
                        // This function is called only once within the init function
                        // Only one thread can ever get this mutable access
                        let d = Generator::generate(&this.generator);
                        #[allow(unused_unsafe)]
                        unsafe {
                            data.init(d)
                        };
                    },
                )
            },
            #[cfg(debug_mode)]
            &this._info,
        );
        ReadGuard(r)
    }

    /// Initialize if necessary then return a read lock
    ///
    /// Returns an error if after initialization the return object is not in an accessible
    /// state.
    #[inline(always)]
    pub fn init_then_try_read_lock(this: &'a Self) -> Result<ReadGuard<M::ReadGuard>, AccessError> {
        post_init_checked_access::<ReadGuard<M::ReadGuard>, S>(unsafe {
            Self::init_then_read_lock_unchecked(this)
        })
    }

    /// Initialize if necessary then return a read lock
    ///
    /// # Panics
    ///
    /// Panics if after initialization the return object is not in an accessible
    /// state.
    #[inline(always)]
    pub fn init_then_read_lock(this: &'a Self) -> ReadGuard<M::ReadGuard> {
        Self::init_then_try_read_lock(this).unwrap()
    }

    /// If necessary attempt to get a write_lock initilialize the object then turn the write
    /// lock into a read lock, otherwise attempt to get directly a read_lock. Attempt to take
    /// a lock may fail because other locks are held or because of contention.
    ///
    /// # Safety
    ///
    /// If the target is not accessible this may cause undefined behaviour.
    #[inline(always)]
    pub unsafe fn fast_init_then_read_lock_unchecked(
        this: &'a Self,
    ) -> Option<ReadGuard<M::ReadGuard>> {
        may_debug(
            || {
                <M as LazySequentializer<'a, GenericLockedLazySeq<T, M>>>::try_init_then_read_guard(
                    &this.seq,
                    S::shall_init,
                    |data: &T| {
                        // SAFETY
                        // This function is called only once within the init function
                        // Only one thread can ever get this mutable access
                        let d = Generator::generate(&this.generator);
                        #[allow(unused_unsafe)]
                        unsafe {
                            data.init(d)
                        };
                    },
                )
            },
            #[cfg(debug_mode)]
            &this._info,
        )
        .map(ReadGuard)
    }

    #[inline(always)]
    /// If necessary attempt to get a write_lock initilialize the object then turn the write
    /// lock into a read lock, otherwise attempt to get directly a read_lock. Attempt to take
    /// a lock may fail because other locks are held or because of contention.
    ///
    /// If the target is not accessible some error is returned.
    pub fn fast_init_then_try_read_lock(
        this: &'a Self,
    ) -> Option<Result<ReadGuard<M::ReadGuard>, AccessError>> {
        unsafe { Self::fast_init_then_read_lock_unchecked(this) }
            .map(post_init_checked_access::<ReadGuard<M::ReadGuard>, S>)
    }

    #[inline(always)]
    /// If necessary attempt to get a write_lock initilialize the object then turn the write
    /// lock into a read lock, otherwise attempt to get directly a read_lock. Attempt to take
    /// a lock may fail because other locks are held or because of contention.
    ///
    /// # Panics
    ///
    /// If the target is not accessible some error is returned.
    pub fn fast_init_then_read_lock(this: &'a Self) -> Option<ReadGuard<M::ReadGuard>> {
        Self::fast_init_then_try_read_lock(this).map(|r| r.unwrap())
    }

    #[inline(always)]
    /// Get a write locks, initialize the target if necessary then returns a readlock.
    ///
    /// # Safety
    ///
    /// If the target object is not accessible, this will cause undefined behaviour
    pub unsafe fn init_then_write_lock_unchecked(this: &'a Self) -> WriteGuard<M::WriteGuard> {
        let r = may_debug(
            || {
                <M as LazySequentializer<'a, GenericLockedLazySeq<T, M>>>::init_then_write_guard(
                    &this.seq,
                    S::shall_init,
                    |data: &T| {
                        // SAFETY
                        // This function is called only once within the init function
                        // Only one thread can ever get this mutable access
                        let d = Generator::generate(&this.generator);
                        #[allow(unused_unsafe)]
                        unsafe {
                            data.init(d)
                        };
                    },
                )
            },
            #[cfg(debug_mode)]
            &this._info,
        );
        WriteGuard(r)
    }

    #[inline(always)]
    /// Get a write locks, initialize the target if necessary then returns the write lock.
    ///
    /// If the target object is not accessible an error is returned.
    pub fn init_then_try_write_lock(
        this: &'a Self,
    ) -> Result<WriteGuard<M::WriteGuard>, AccessError> {
        post_init_checked_access::<WriteGuard<M::WriteGuard>, S>(unsafe {
            Self::init_then_write_lock_unchecked(this)
        })
    }
    #[inline(always)]
    /// Get a write locks, initialize the target if necessary then returns a write lock.
    ///
    /// Panics if the target object is not accessible.
    #[inline(always)]
    pub fn init_then_write_lock(this: &'a Self) -> WriteGuard<M::WriteGuard> {
        Self::init_then_try_write_lock(this).unwrap()
    }

    #[inline(always)]
    /// Attempt to get a write locks then initialize the target if necessary and returns the
    /// writelock.
    ///
    /// # Safety
    ///
    /// Undefined behavior if the target object is not accessible.
    pub unsafe fn fast_init_then_write_lock_unchecked(
        this: &'a Self,
    ) -> Option<WriteGuard<M::WriteGuard>> {
        may_debug(
            || {
                <M as LazySequentializer<'a, GenericLockedLazySeq<T, M>>>::try_init_then_write_guard(
                    &this.seq,
                    S::shall_init,
                    |data: &T| {
                        // SAFETY
                        // This function is called only once within the init function
                        // Only one thread can ever get this mutable access
                        let d = Generator::generate(&this.generator);
                        #[allow(unused_unsafe)]
                        unsafe { data.init(d) };
                    },
                )
            },
            #[cfg(debug_mode)]
            &this._info,
        )
        .map(WriteGuard)
    }
    /// Attempt to get a write locks then initialize the target if necessary and returns the
    /// writelock.
    ///
    /// Returns an error if the target object is not accessible.
    #[inline(always)]
    pub fn fast_init_then_try_write_lock(
        this: &'a Self,
    ) -> Option<Result<WriteGuard<M::WriteGuard>, AccessError>> {
        unsafe { Self::fast_init_then_write_lock_unchecked(this) }
            .map(post_init_checked_access::<WriteGuard<M::WriteGuard>, S>)
    }
    /// Attempt to get a write locks then initialize the target if necessary and returns the
    /// writelock.
    ///
    /// # Panics
    ///
    /// Panics if the target object is not accessible.
    #[inline(always)]
    pub fn fast_init_then_write_lock(this: &'a Self) -> Option<WriteGuard<M::WriteGuard>> {
        Self::fast_init_then_try_write_lock(this).map(|r| r.unwrap())
    }
}

impl<T, F, M, S> GenericLockedLazy<T, F, M, S>
where
    M: UniqueLazySequentializer<GenericLockedLazySeq<T, M>>,
    T: LazyData,
    S: LazyPolicy,
    F: Generator<T::Target>,
{
    #[inline(always)]
    /// Attempt initialization then get a mutable reference to the target
    ///
    /// # Safety
    ///
    /// Undefined behaviour if the referenced value has not been initialized
    pub unsafe fn only_init_then_get_mut_unchecked(&mut self) -> &mut T::Target {
        self.only_init_unique();
        &mut *self.seq.value.get()
    }
    #[inline(always)]
    /// Attempt initialization then get a mutable reference to the target, returning an error if the
    /// target is not in the correct phase.
    pub fn only_init_then_try_get_mut(&mut self) -> Result<&mut T::Target, AccessError> {
        let phase = self.only_init_unique();
        check_access::<*mut T::Target, S>(self.seq.value.get(), phase)
            .map(|ptr| unsafe { &mut *ptr })
    }
    #[inline(always)]
    /// Attempt initialization then get a mutable reference to the target, returning an error if the
    /// target is not in the correct phase.
    pub fn only_init_then_get_mut(&mut self) -> &mut T::Target {
        Self::only_init_then_try_get_mut(self).unwrap()
    }
    #[inline(always)]
    /// Potentialy initialize the inner data, returning the
    /// phase reached at the end of the initialization attempt
    pub fn only_init_unique(&mut self) -> Phase {
        let generator = &self.generator;
        let seq = &mut self.seq;
        <M as UniqueLazySequentializer<GenericLockedLazySeq<T, M>>>::init_unique(
            seq,
            S::shall_init,
            |data: &mut T| {
                // SAFETY
                // This function is called only once within the init function
                // Only one thread can ever get this mutable access
                let d = Generator::generate(generator);
                unsafe { data.init_mut(d) };
            },
        )
    }
}

//SAFETY: data and sequentialize are two fields of Self.
unsafe impl<T: LazyData, M> Sequential for GenericLockedLazySeq<T, M> {
    type Data = T;
    type Sequentializer = M;
    #[inline(always)]
    fn sequentializer(this: &Self) -> &Self::Sequentializer {
        &this.sequentializer
    }
    #[inline(always)]
    fn sequentializer_data_mut(this: &mut Self) -> (&mut Self::Sequentializer, &mut Self::Data) {
        (&mut this.sequentializer, &mut this.value)
    }
    #[inline(always)]
    fn data(this: &Self) -> &Self::Data {
        &this.value
    }
}
impl<F, T, M, S> Deref for GenericLockedLazy<T, F, M, S> {
    type Target = T;
    #[inline(always)]
    ///get a pointer to the raw data
    fn deref(&self) -> &T {
        &self.seq.value
    }
}
impl<T, M> Deref for GenericLockedLazySeq<T, M> {
    type Target = T;
    #[inline(always)]
    ///get a pointer to the raw data
    fn deref(&self) -> &T {
        &self.value
    }
}

impl<F, T, M: Phased, S> Phased for GenericLockedLazy<T, F, M, S> {
    #[inline(always)]
    fn phase(this: &Self) -> Phase {
        Phased::phase(&this.seq.sequentializer)
    }
}
impl<F, T, M: Phased, S> Phased for GenericLazy<T, F, M, S> {
    #[inline(always)]
    fn phase(this: &Self) -> Phase {
        Phased::phase(&this.seq.sequentializer)
    }
}

#[inline(always)]
fn may_debug<R, F: FnOnce() -> R>(f: F, #[cfg(debug_mode)] info: &Option<StaticInfo>) -> R {
    #[cfg(not(debug_mode))]
    {
        f()
    }
    #[cfg(debug_mode)]
    {
        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) {
            Ok(r) => r,
            Err(x) => {
                if x.is::<CyclicPanic>() {
                    match info {
                        Some(info) => panic!("Circular initialization of {:#?}", info),
                        None => panic!("Circular lazy initialization detected"),
                    }
                } else {
                    std::panic::resume_unwind(x)
                }
            }
        }
    }
}

#[inline(always)]
fn check_access<T, S: LazyPolicy>(l: T, phase: Phase) -> Result<T, AccessError> {
    if S::is_accessible(phase) {
        Ok(l)
    } else {
        Err(AccessError { phase })
    }
}

#[inline(always)]
fn checked_access<T: Phased, S: LazyPolicy>(l: T) -> Result<T, AccessError> {
    let phase = Phased::phase(&l);
    check_access::<T, S>(l, phase)
}
#[inline(always)]
fn post_init_check_access<T, S: LazyPolicy>(l: T, phase: Phase) -> Result<T, AccessError> {
    if S::post_init_is_accessible(phase) {
        Ok(l)
    } else {
        Err(AccessError { phase })
    }
}

#[inline(always)]
fn post_init_checked_access<T: Phased, S: LazyPolicy>(l: T) -> Result<T, AccessError> {
    let phase = Phased::phase(&l);
    post_init_check_access::<T, S>(l, phase)
}