use core::{
mem::MaybeUninit,
ops::{Deref, DerefMut},
};
use crate::{
init::{Init, InitDefault, InitDefaultInit, InitMode},
init_in,
};
#[cfg(feature = "alloc")]
use crate::{init::PinInitMode, pin_init_in};
#[cfg(feature = "alloc")]
use alloc::boxed::Box;
#[cfg(feature = "alloc")]
use core::{mem::forget, pin::Pin};
pub struct InitStorage<T> {
storage: MaybeUninit<T>,
}
impl<T> InitStorage<T> {
pub const fn uninit() -> Self {
Self {
storage: MaybeUninit::uninit(),
}
}
pub fn initialize<I, E>(mut self, initializer: I) -> Result<InitValue<T>, E>
where
I: Init<T, E>,
{
let receipt = init_in(&mut self.storage, initializer)?;
Ok(InitValue {
value: receipt.into_inner(),
})
}
pub fn initialize_default(self) -> InitValue<T>
where
T: InitDefault<T, InitMode>,
{
self.initialize_default_with::<T>()
}
pub fn initialize_default_with<I>(self) -> InitValue<T>
where
I: InitDefault<T, InitMode>,
{
match self.initialize(InitDefaultInit::<T, I>::new()) {
Ok(value) => value,
Err(never) => match never {},
}
}
}
pub struct InitValue<T> {
value: T,
}
impl<T> InitValue<T> {
pub fn get(&self) -> &T {
&self.value
}
pub fn get_mut(&mut self) -> &mut T {
&mut self.value
}
pub fn into_inner(self) -> T {
self.value
}
}
impl<T> Deref for InitValue<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.value
}
}
impl<T> DerefMut for InitValue<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.value
}
}
#[cfg(feature = "alloc")]
pub trait InitBoxExt<T, E>: Init<T, E> {
fn init_box(self) -> Result<Box<T>, E>
where
Self: Sized,
{
let mut storage = Box::new(MaybeUninit::<T>::uninit());
let receipt = init_in(&mut storage, self)?;
forget(receipt);
Ok(unsafe { storage.assume_init() })
}
}
#[cfg(feature = "alloc")]
impl<T, E, I> InitBoxExt<T, E> for I where I: Init<T, E> {}
#[cfg(feature = "alloc")]
pub trait PinInitBoxExt<T, E>: Init<T, E, PinInitMode> {
fn pin_box(self) -> Result<Pin<Box<T>>, E>
where
Self: Sized,
{
let mut storage = Box::new(MaybeUninit::<T>::uninit());
let pinned_storage = unsafe { Pin::new_unchecked(&mut *storage) };
let receipt = unsafe { pin_init_in(pinned_storage, self)? };
forget(receipt);
let value = unsafe { storage.assume_init() };
Ok(Box::into_pin(value))
}
}
#[cfg(feature = "alloc")]
impl<T, E, I> PinInitBoxExt<T, E> for I where I: Init<T, E, PinInitMode> {}