use core::{
convert::Infallible,
marker::{PhantomData, PhantomPinned},
mem::forget,
ptr,
};
use crate::init::{Init, InitMode, InitReceipt, InitSlot};
#[cfg(feature = "alloc")]
use core::mem::MaybeUninit;
#[cfg(feature = "alloc")]
use alloc::{
collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque},
rc::Rc,
string::String,
sync::Arc,
vec::Vec,
};
#[cfg(feature = "std")]
use std::collections::{HashMap, HashSet};
pub unsafe trait InitDefault<T = Self, Mode = InitMode>: Sized {
fn initialize_default<'slot>(slot: InitSlot<'slot, T, Mode>) -> InitReceipt<'slot, T, Mode>;
}
#[doc(hidden)]
pub struct InitDefaultInit<T, Provider = T> {
_types: PhantomData<fn() -> (T, Provider)>,
}
impl<T, Provider> InitDefaultInit<T, Provider> {
pub const fn new() -> Self {
Self {
_types: PhantomData,
}
}
}
impl<T, Provider> Default for InitDefaultInit<T, Provider> {
fn default() -> Self {
Self::new()
}
}
unsafe impl<T, Provider, Mode> Init<T, Infallible, Mode> for InitDefaultInit<T, Provider>
where
Provider: InitDefault<T, Mode>,
{
fn initialize<'slot>(
self,
slot: InitSlot<'slot, T, Mode>,
) -> Result<InitReceipt<'slot, T, Mode>, Infallible> {
Ok(Provider::initialize_default(slot))
}
}
pub struct InitDefaultValue<T> {
_type: PhantomData<fn() -> T>,
}
impl<T> InitDefaultValue<T> {
pub const fn new() -> Self {
Self { _type: PhantomData }
}
}
impl<T> Default for InitDefaultValue<T> {
fn default() -> Self {
Self::new()
}
}
unsafe impl<T> InitDefault<T, InitMode> for InitDefaultValue<T>
where
T: Default,
{
fn initialize_default<'slot>(
slot: InitSlot<'slot, T, InitMode>,
) -> InitReceipt<'slot, T, InitMode> {
slot.write(T::default())
}
}
unsafe impl<Mode> InitDefault<(), Mode> for () {
fn initialize_default<'slot>(slot: InitSlot<'slot, (), Mode>) -> InitReceipt<'slot, (), Mode> {
slot.write(())
}
}
unsafe impl<T, Mode> InitDefault<Option<T>, Mode> for Option<T> {
fn initialize_default<'slot>(
slot: InitSlot<'slot, Option<T>, Mode>,
) -> InitReceipt<'slot, Option<T>, Mode> {
slot.write(None)
}
}
unsafe impl<T, Mode> InitDefault<PhantomData<T>, Mode> for PhantomData<T> {
fn initialize_default<'slot>(
slot: InitSlot<'slot, PhantomData<T>, Mode>,
) -> InitReceipt<'slot, PhantomData<T>, Mode> {
slot.write(PhantomData)
}
}
unsafe impl<Mode> InitDefault<PhantomPinned, Mode> for PhantomPinned {
fn initialize_default<'slot>(
slot: InitSlot<'slot, PhantomPinned, Mode>,
) -> InitReceipt<'slot, PhantomPinned, Mode> {
slot.write(PhantomPinned)
}
}
struct ArrayInitGuard<T> {
pointer: *mut T,
initialized: usize,
}
impl<T> Drop for ArrayInitGuard<T> {
fn drop(&mut self) {
while self.initialized > 0 {
self.initialized -= 1;
unsafe { ptr::drop_in_place(self.pointer.add(self.initialized)) };
}
}
}
unsafe impl<T, Mode, const N: usize> InitDefault<[T; N], Mode> for [T; N]
where
T: InitDefault<T, Mode>,
{
fn initialize_default<'slot>(
mut slot: InitSlot<'slot, [T; N], Mode>,
) -> InitReceipt<'slot, [T; N], Mode> {
let pointer = slot.__target_ptr().cast::<T>();
let mut guard = ArrayInitGuard {
pointer,
initialized: 0,
};
for index in 0..N {
let element_pointer = unsafe { pointer.add(index) };
let element_slot = unsafe { slot.__project(element_pointer) };
let receipt = T::initialize_default(element_slot);
forget(receipt);
guard.initialized += 1;
}
guard.initialized = 0;
unsafe { slot.__assume_init() }
}
}
unsafe impl<A, B, Mode> InitDefault<(A, B), Mode> for (A, B)
where
A: InitDefault<A, Mode>,
B: InitDefault<B, Mode>,
{
fn initialize_default<'slot>(
mut slot: InitSlot<'slot, (A, B), Mode>,
) -> InitReceipt<'slot, (A, B), Mode> {
let pointer = slot.__target_ptr();
let first_pointer = unsafe { ptr::addr_of_mut!((*pointer).0) };
let first_slot = unsafe { slot.__project(first_pointer) };
let first = A::initialize_default(first_slot);
let second_pointer = unsafe { ptr::addr_of_mut!((*pointer).1) };
let second_slot = unsafe { slot.__project(second_pointer) };
let second = B::initialize_default(second_slot);
forget(first);
forget(second);
unsafe { slot.__assume_init() }
}
}
#[cfg(feature = "alloc")]
macro_rules! empty_collection_default {
($($generic:ident),*; $type:ty, $value:expr) => {
unsafe impl<$($generic,)* Mode> InitDefault<$type, Mode> for $type {
fn initialize_default<'slot>(
slot: InitSlot<'slot, $type, Mode>,
) -> InitReceipt<'slot, $type, Mode> {
slot.write($value)
}
}
};
}
#[cfg(feature = "alloc")]
empty_collection_default!(; String, String::new());
#[cfg(feature = "alloc")]
empty_collection_default!(T; Vec<T>, Vec::new());
#[cfg(feature = "alloc")]
empty_collection_default!(T; VecDeque<T>, VecDeque::new());
#[cfg(feature = "alloc")]
empty_collection_default!(T; BinaryHeap<T>, BinaryHeap::new());
#[cfg(feature = "alloc")]
empty_collection_default!(T; LinkedList<T>, LinkedList::new());
#[cfg(feature = "alloc")]
empty_collection_default!(K, V; BTreeMap<K, V>, BTreeMap::new());
#[cfg(feature = "alloc")]
empty_collection_default!(T; BTreeSet<T>, BTreeSet::new());
#[cfg(feature = "alloc")]
unsafe impl<T, Mode> InitDefault<Rc<T>, Mode> for Rc<T>
where
T: InitDefault<T, Mode>,
{
fn initialize_default<'slot>(
slot: InitSlot<'slot, Rc<T>, Mode>,
) -> InitReceipt<'slot, Rc<T>, Mode> {
let mut value = Rc::<T>::new_uninit();
let pointer = match Rc::get_mut(&mut value) {
Some(storage) => storage.as_mut_ptr(),
None => unreachable!("A newly allocated `Rc` must have only one owner"),
};
let pointee_slot = unsafe { InitSlot::__from_raw(pointer) };
let receipt = T::initialize_default(pointee_slot);
forget(receipt);
let value = unsafe { Rc::<MaybeUninit<T>>::assume_init(value) };
slot.write(value)
}
}
#[cfg(feature = "alloc")]
unsafe impl<T, Mode> InitDefault<Arc<T>, Mode> for Arc<T>
where
T: InitDefault<T, Mode>,
{
fn initialize_default<'slot>(
slot: InitSlot<'slot, Arc<T>, Mode>,
) -> InitReceipt<'slot, Arc<T>, Mode> {
let mut value = Arc::<T>::new_uninit();
let pointer = match Arc::get_mut(&mut value) {
Some(storage) => storage.as_mut_ptr(),
None => unreachable!("A newly allocated `Arc` must have only one owner"),
};
let pointee_slot = unsafe { InitSlot::__from_raw(pointer) };
let receipt = T::initialize_default(pointee_slot);
forget(receipt);
let value = unsafe { Arc::<MaybeUninit<T>>::assume_init(value) };
slot.write(value)
}
}
#[cfg(feature = "std")]
unsafe impl<K, V, Mode> InitDefault<HashMap<K, V>, Mode> for HashMap<K, V> {
fn initialize_default<'slot>(
slot: InitSlot<'slot, HashMap<K, V>, Mode>,
) -> InitReceipt<'slot, HashMap<K, V>, Mode> {
slot.write(HashMap::new())
}
}
#[cfg(feature = "std")]
unsafe impl<T, Mode> InitDefault<HashSet<T>, Mode> for HashSet<T> {
fn initialize_default<'slot>(
slot: InitSlot<'slot, HashSet<T>, Mode>,
) -> InitReceipt<'slot, HashSet<T>, Mode> {
slot.write(HashSet::new())
}
}