use core::{
convert::Infallible,
marker::PhantomData,
mem::ManuallyDrop,
ops::{Deref, DerefMut},
pin::Pin,
ptr,
};
mod defaults;
mod fields;
mod initializer;
pub use defaults::{InitDefault, InitDefaultInit, InitDefaultValue};
pub use fields::{
InitField, InitFieldInit, InitFields, InitState, InitTargetPointer, MovableField, PinnedField,
Set, Unset,
};
pub use initializer::{
InitFn, InitFnRaw, InitTyBool, InitTyChar, InitTyI8, InitTyI16, InitTyI32, InitTyI64,
InitTyI128, InitTyIsize, InitTyU8, InitTyU16, InitTyU32, InitTyU64, InitTyU128, InitTyUsize,
MapInitError,
};
pub struct InitMode;
pub struct PinInitMode;
pub struct InitSlot<'slot, T, Mode = InitMode> {
pointer: *mut T,
_borrow: PhantomData<&'slot mut T>,
_mode: PhantomData<fn() -> Mode>,
}
impl<'slot, T, Mode> InitSlot<'slot, T, Mode> {
pub fn write(self, value: T) -> InitReceipt<'slot, T, Mode> {
unsafe { self.pointer.write(value) };
unsafe { InitReceipt::new(self.pointer) }
}
pub fn initialize_default(self) -> InitReceipt<'slot, T, Mode>
where
T: InitDefault<T, Mode>,
{
T::initialize_default(self)
}
#[doc(hidden)]
pub fn __target_ptr(&self) -> *mut T {
self.pointer
}
#[doc(hidden)]
pub fn __raw_mut_ptr(&self) -> *mut T {
self.pointer
}
#[doc(hidden)]
pub unsafe fn __project<U>(&mut self, pointer: *mut U) -> InitSlot<'slot, U, Mode> {
InitSlot {
pointer,
_borrow: PhantomData,
_mode: PhantomData,
}
}
#[doc(hidden)]
pub unsafe fn __retag<Other>(self) -> InitSlot<'slot, T, Other> {
InitSlot {
pointer: self.pointer,
_borrow: PhantomData,
_mode: PhantomData,
}
}
#[doc(hidden)]
pub unsafe fn __assume_init(self) -> InitReceipt<'slot, T, Mode> {
unsafe { InitReceipt::new(self.pointer) }
}
#[doc(hidden)]
pub unsafe fn __from_raw(pointer: *mut T) -> Self {
Self {
pointer,
_borrow: PhantomData,
_mode: PhantomData,
}
}
}
pub struct InitReceipt<'slot, T, Mode = InitMode> {
pointer: *mut T,
_borrow: PhantomData<&'slot mut T>,
_mode: PhantomData<fn() -> Mode>,
}
impl<'slot, T, Mode> InitReceipt<'slot, T, Mode> {
pub(crate) unsafe fn new(pointer: *mut T) -> Self {
Self {
pointer,
_borrow: PhantomData,
_mode: PhantomData,
}
}
#[doc(hidden)]
pub unsafe fn __retag<Other>(self) -> InitReceipt<'slot, T, Other> {
let receipt = ManuallyDrop::new(self);
unsafe { InitReceipt::new(receipt.pointer) }
}
}
impl<T, Mode> Deref for InitReceipt<'_, T, Mode> {
type Target = T;
fn deref(&self) -> &Self::Target {
unsafe { &*self.pointer }
}
}
impl<T> DerefMut for InitReceipt<'_, T, InitMode> {
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { &mut *self.pointer }
}
}
impl<T> InitReceipt<'_, T, InitMode> {
pub fn into_inner(self) -> T {
let receipt = ManuallyDrop::new(self);
unsafe { receipt.pointer.read() }
}
}
impl<T> InitReceipt<'_, T, PinInitMode> {
pub fn as_pin_ref(&self) -> Pin<&T> {
unsafe { Pin::new_unchecked(&*self.pointer) }
}
pub fn as_pin_mut(&mut self) -> Pin<&mut T> {
unsafe { Pin::new_unchecked(&mut *self.pointer) }
}
}
impl<T, Mode> Drop for InitReceipt<'_, T, Mode> {
fn drop(&mut self) {
unsafe { ptr::drop_in_place(self.pointer) };
}
}
pub unsafe trait Init<T, E = Infallible, Mode = InitMode>: Sized {
fn initialize<'slot>(
self,
slot: InitSlot<'slot, T, Mode>,
) -> Result<InitReceipt<'slot, T, Mode>, E>;
fn map_err<F, E2>(self, map: F) -> MapInitError<Self, F, E, Mode>
where
Self: Sized,
F: FnOnce(E) -> E2,
{
MapInitError::<Self, F, E, Mode>::new(self, map)
}
}
pub unsafe trait InitRaw<T, E = Infallible, Mode = InitMode> {
unsafe fn init_raw(self, slot: *mut T) -> Result<(), E>;
}
pub struct RawInit<I> {
initializer: I,
}
impl<I> RawInit<I> {
pub const fn new(initializer: I) -> Self {
Self { initializer }
}
}
unsafe impl<T, E, Mode, I> Init<T, E, Mode> for RawInit<I>
where
I: InitRaw<T, E, Mode>,
{
fn initialize<'slot>(
self,
slot: InitSlot<'slot, T, Mode>,
) -> Result<InitReceipt<'slot, T, Mode>, E> {
unsafe { self.initializer.init_raw(slot.__raw_mut_ptr())? };
Ok(unsafe { slot.__assume_init() })
}
}