pub fn new_uninit(journal: &Journal<A>) -> Prc<MaybeUninit<T>, A> {
        unsafe {
            Prc::from_inner(Ptr::from_mut(A::new(
                PrcBox {
                    counter: Counter {
                        strong: 1,
                        weak: 1,

                        #[cfg(not(any(
                            feature = "no_log_rc",
                            feature = "use_pspd",
                            feature = "use_vspd"
                        )))]
                        has_log: 0,

                        #[cfg(any(feature = "use_pspd", feature = "use_vspd"))]
                        temp: TCell::new_invalid(None),

                        phantom: PhantomData
                    },

                    #[cfg(not(feature = "no_volatile_pointers"))]
                    vlist: VCell::new(VWeakList::default()),

                    dummy: [],
                    value: MaybeUninit::<T>::uninit(),
                },
                journal,
            )))
        }
    }
/// Constructs a new `Prc` with uninitialized contents.
///
/// A `DropOnFailure` log is taken for the allocation.
///
/// # Examples
///
/// ```
/// # use corundum::alloc::heap::*;
/// # type P = Heap;
/// use corundum::prc::Prc;
///
/// P::transaction(|j| {
///     let mut five = Prc::<u32,Heap>::new_uninit(j);
///
///     let five = unsafe {
///         // Deferred initialization:
///         Prc::get_mut_unchecked(&mut five).as_mut_ptr().write(5);
///
///         five.assume_init()
///     };
///
///     assert_eq!(*five, 5)
/// }).unwrap();
/// ```
Constructs a new `Prc` with uninitialized contents.
A `DropOnFailure` log is taken for the allocation.
Constructs a new ` Prc ` with uninitialized contents . A ` DropOnFailure ` log is taken for the allocation .
pub fn new_uninit(journal: &Journal<A>) -> Prc<MaybeUninit<T>, A> {
        unsafe {
            Prc::from_inner(Ptr::from_mut(A::new(
                PrcBox {
                    counter: Counter {
                        strong: 1,
                        weak: 1,
                        #[cfg(not(any(
                            feature = "no_log_rc",
                            feature = "use_pspd",
                            feature = "use_vspd"
                        )))]
                        has_log: 0,
                        #[cfg(any(feature = "use_pspd", feature = "use_vspd"))]
                        temp: TCell::new_invalid(None),
                        phantom: PhantomData
                    },
                    #[cfg(not(feature = "no_volatile_pointers"))]
                    vlist: VCell::new(VWeakList::default()),
                    dummy: [],
                    value: MaybeUninit::<T>::uninit(),
                },
                journal,
            )))
        }
    }
pub fn new_uninit ( journal : & Journal < A > ) -> Prc < MaybeUninit < T > , A > { unsafe { Prc :: from_inner ( Ptr :: from_mut ( A :: new ( PrcBox { counter : Counter { strong : 1 , weak : 1 , # [ cfg ( not ( any ( feature " " feature " " feature " " ) ) ) ] has_log : 0 , # [ cfg ( any ( feature " " feature " " ) ) ] temp : TCell :: new_invalid ( None ) , phantom : PhantomData } , # [ cfg ( not ( feature " " ) ) ] vlist : VCell :: new ( VWeakList :: default ( ) ) , dummy : [ ] , value : MaybeUninit :: < T > :: uninit ( ) , } , journal , ) ) ) } }
Constructs a new `Prc` with uninitialized contents.
Constructs a new ` Prc ` with uninitialized contents .
journal
&Journal<A>
examples
None
use corundum::alloc::heap::*;
None
type p = heap;
use corundum::prc::Prc.

:transaction(|j| {
let mut five = Prc::::new_uninit(j).

let five = unsafe {
Deferred initialization:
Prc::get_mut_unchecked(&mut five).as_mut_ptr().write(5).

five.assume_init()
}.


use corundum :: prc :: Prc . : transaction ( |j| { let mut five = Prc :::: new_uninit ( j ) . let five = unsafe { Deferred initialization : Prc :: get_mut_unchecked ( &mut five ) . as_mut_ptr () . write ( 5 ) . five . assume_init () } .