use core::{convert::Infallible, marker::PhantomData};
use crate::init::{Init, InitDefault, InitMode, InitReceipt, InitSlot, PinInitMode};
pub struct MapInitError<I, F, E, Mode = InitMode> {
initializer: I,
map: F,
_error: PhantomData<fn(E)>,
_mode: PhantomData<fn() -> Mode>,
}
impl<I, F, E, Mode> MapInitError<I, F, E, Mode> {
pub(crate) fn new(initializer: I, map: F) -> Self {
Self {
initializer,
map,
_error: PhantomData,
_mode: PhantomData,
}
}
}
unsafe impl<T, E1, E2, I, F, Mode> Init<T, E2, Mode> for MapInitError<I, F, E1, Mode>
where
I: Init<T, E1, Mode>,
F: FnOnce(E1) -> E2,
{
fn initialize<'slot>(
self,
slot: InitSlot<'slot, T, Mode>,
) -> Result<InitReceipt<'slot, T, Mode>, E2> {
let MapInitError {
initializer, map, ..
} = self;
match initializer.initialize(slot) {
Ok(receipt) => {
drop(map);
Ok(receipt)
}
Err(error) => Err(map(error)),
}
}
}
struct InitFnMarker<T, E, Mode> {
_value: PhantomData<fn() -> T>,
_error: PhantomData<fn() -> E>,
_mode: PhantomData<fn() -> Mode>,
}
pub struct InitFn<T, E, F> {
initialize: F,
_marker: InitFnMarker<T, E, InitMode>,
}
impl<T, E, F> InitFn<T, E, F> {
pub fn new(initialize: F) -> Self
where
F: FnOnce() -> Result<T, E>,
{
Self {
initialize,
_marker: InitFnMarker {
_value: PhantomData,
_error: PhantomData,
_mode: PhantomData,
},
}
}
}
unsafe impl<T, E, F> Init<T, E, InitMode> for InitFn<T, E, F>
where
F: FnOnce() -> Result<T, E>,
{
fn initialize<'slot>(
self,
slot: InitSlot<'slot, T, InitMode>,
) -> Result<InitReceipt<'slot, T, InitMode>, E> {
let value = (self.initialize)()?;
Ok(slot.write(value))
}
}
pub struct InitFnRaw<T, E, F, Mode = InitMode> {
initialize: F,
_marker: InitFnMarker<T, E, Mode>,
}
impl<T, E, F, Mode> InitFnRaw<T, E, F, Mode> {
pub unsafe fn new(initialize: F) -> Self
where
F: for<'slot> FnOnce(InitSlot<'slot, T, Mode>) -> Result<InitReceipt<'slot, T, Mode>, E>,
{
Self {
initialize,
_marker: InitFnMarker {
_value: PhantomData,
_error: PhantomData,
_mode: PhantomData,
},
}
}
}
unsafe impl<T, E, F, Mode> Init<T, E, Mode> for InitFnRaw<T, E, F, Mode>
where
F: for<'slot> FnOnce(InitSlot<'slot, T, Mode>) -> Result<InitReceipt<'slot, T, Mode>, E>,
{
fn initialize<'slot>(
self,
slot: InitSlot<'slot, T, Mode>,
) -> Result<InitReceipt<'slot, T, Mode>, E> {
(self.initialize)(slot)
}
}
macro_rules! const_init {
($name:ident, $value_type:ty, $default:expr) => {
#[doc = concat!("使用编译期 `", stringify!($value_type), "` 常量构造值的初始化器。 / An initializer that constructs a value from a compile-time `", stringify!($value_type), "` constant.")]
pub struct $name<const VALUE: $value_type>;
unsafe impl<Mode> InitDefault<$value_type, Mode> for $value_type {
fn initialize_default<'slot>(
slot: InitSlot<'slot, $value_type, Mode>,
) -> InitReceipt<'slot, $value_type, Mode> {
slot.write($default)
}
}
unsafe impl<const VALUE: $value_type, Mode> InitDefault<$value_type, Mode>
for $name<VALUE>
{
fn initialize_default<'slot>(
slot: InitSlot<'slot, $value_type, Mode>,
) -> InitReceipt<'slot, $value_type, Mode> {
slot.write(VALUE)
}
}
unsafe impl<const VALUE: $value_type> Init<$value_type> for $name<VALUE> {
fn initialize<'slot>(
self,
slot: InitSlot<'slot, $value_type>,
) -> Result<InitReceipt<'slot, $value_type>, Infallible> {
Ok(slot.write(VALUE))
}
}
unsafe impl<const VALUE: $value_type> Init<$value_type, Infallible, PinInitMode> for $name<VALUE> {
fn initialize<'slot>(
self,
slot: InitSlot<'slot, $value_type, PinInitMode>,
) -> Result<InitReceipt<'slot, $value_type, PinInitMode>, Infallible> {
Ok(slot.write(VALUE))
}
}
};
}
const_init!(InitTyBool, bool, false);
const_init!(InitTyChar, char, '\0');
const_init!(InitTyI8, i8, 0);
const_init!(InitTyI16, i16, 0);
const_init!(InitTyI32, i32, 0);
const_init!(InitTyI64, i64, 0);
const_init!(InitTyI128, i128, 0);
const_init!(InitTyIsize, isize, 0);
const_init!(InitTyU8, u8, 0);
const_init!(InitTyU16, u16, 0);
const_init!(InitTyU32, u32, 0);
const_init!(InitTyU64, u64, 0);
const_init!(InitTyU128, u128, 0);
const_init!(InitTyUsize, usize, 0);