Trait swim_mem::alloc::Stow

pub trait Stow<'b, T: ?Sized = Self> {
    unsafe fn stow(
        src: *mut Self, 
        dst: *mut T, 
        hold: &dyn Hold<'b>
    ) -> Result<(), HoldError>;
    unsafe fn unstow(src: *mut Self, dst: *mut T);
}

A type that can be recursively moved into a Hold.

Required methods

unsafe fn stow(
    src: *mut Self,
    dst: *mut T,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

Moves the value at the src pointer to the dst pointer, recursively moving all child values into the hold. If a child stow operation fails, then any already completed child stow operations get reverted by calling unstow on the child.

unsafe fn unstow(src: *mut Self, dst: *mut T)

Reverts the most recent stow operation by moving the value at the dst pointer back to the src pointer from whence it came. The memory at the src address will be in the same state the stow operation left it in.

Safety

The src and dst pointers must not be aliased outside the current call stack.

Loading content...

Implementations on Foreign Types

impl<'b> Stow<'b, f16> for f16

unsafe fn stow(
    src: *mut f16,
    dst: *mut f16,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut f16, _dts: *mut f16)

impl<'b> Stow<'b, Murmur3> for Murmur3

unsafe fn stow(
    src: *mut Murmur3,
    dst: *mut Murmur3,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut Murmur3, _dts: *mut Murmur3)

Loading content...

Implementors

impl<'a, 'b, R: ResidentStow<'b, Hard<'a, R>, Hard<'b, R>>> Stow<'b, Hard<'b, R>> for Hard<'a, R>

unsafe fn stow(
    src: *mut Hard<'a, R>,
    dst: *mut Hard<'b, R>,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(src: *mut Hard<'a, R>, dst: *mut Hard<'b, R>)

impl<'a, 'b, R: ResidentStow<'b, Hard<'a, R>, Hard<'b, R>>> Stow<'b, Soft<'b, R>> for Soft<'a, R>

unsafe fn stow(
    src: *mut Soft<'a, R>,
    dst: *mut Soft<'b, R>,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(src: *mut Soft<'a, R>, dst: *mut Soft<'b, R>)

impl<'a, 'b, R: ResidentStow<'b, Ptr<'a, R>, Ptr<'b, R>>> Stow<'b, Ptr<'b, R>> for Ptr<'a, R>

unsafe fn stow(
    src: *mut Ptr<'a, R>,
    dst: *mut Ptr<'b, R>,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut Ptr<'a, R>, _dst: *mut Ptr<'b, R>)

impl<'a, 'b, R: ResidentStow<'b, Raw<'a, R>, Raw<'b, R>>> Stow<'b, Raw<'b, R>> for Raw<'a, R>

unsafe fn stow(
    src: *mut Raw<'a, R>,
    dst: *mut Raw<'b, R>,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut Raw<'a, R>, _dst: *mut Raw<'b, R>)

impl<'b> Stow<'b, ()> for ()

unsafe fn stow(
    src: *mut (),
    dst: *mut (),
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut (), _dts: *mut ())

impl<'b> Stow<'b, bool> for bool

unsafe fn stow(
    src: *mut bool,
    dst: *mut bool,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut bool, _dts: *mut bool)

impl<'b> Stow<'b, char> for char

unsafe fn stow(
    src: *mut char,
    dst: *mut char,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut char, _dts: *mut char)

impl<'b> Stow<'b, f32> for f32

unsafe fn stow(
    src: *mut f32,
    dst: *mut f32,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut f32, _dts: *mut f32)

impl<'b> Stow<'b, f64> for f64

unsafe fn stow(
    src: *mut f64,
    dst: *mut f64,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut f64, _dts: *mut f64)

impl<'b> Stow<'b, i16> for i16

unsafe fn stow(
    src: *mut i16,
    dst: *mut i16,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut i16, _dts: *mut i16)

impl<'b> Stow<'b, i32> for i32

unsafe fn stow(
    src: *mut i32,
    dst: *mut i32,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut i32, _dts: *mut i32)

impl<'b> Stow<'b, i64> for i64

unsafe fn stow(
    src: *mut i64,
    dst: *mut i64,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut i64, _dts: *mut i64)

impl<'b> Stow<'b, i8> for i8

unsafe fn stow(
    src: *mut i8,
    dst: *mut i8,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut i8, _dts: *mut i8)

impl<'b> Stow<'b, isize> for isize

unsafe fn stow(
    src: *mut isize,
    dst: *mut isize,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut isize, _dts: *mut isize)

impl<'b> Stow<'b, str> for str

unsafe fn stow(
    src: *mut str,
    dst: *mut str,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut str, _dst: *mut str)

impl<'b> Stow<'b, u16> for u16

unsafe fn stow(
    src: *mut u16,
    dst: *mut u16,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut u16, _dts: *mut u16)

impl<'b> Stow<'b, u32> for u32

unsafe fn stow(
    src: *mut u32,
    dst: *mut u32,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut u32, _dts: *mut u32)

impl<'b> Stow<'b, u64> for u64

unsafe fn stow(
    src: *mut u64,
    dst: *mut u64,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut u64, _dts: *mut u64)

impl<'b> Stow<'b, u8> for u8

unsafe fn stow(
    src: *mut u8,
    dst: *mut u8,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut u8, _dts: *mut u8)

impl<'b> Stow<'b, usize> for usize

unsafe fn stow(
    src: *mut usize,
    dst: *mut usize,
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut usize, _dts: *mut usize)

impl<'b, T0: Stow<'b>, T1: Stow<'b>> Stow<'b, (T0, T1)> for (T0, T1)

unsafe fn stow(
    src: *mut (T0, T1),
    dst: *mut (T0, T1),
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(src: *mut (T0, T1), dst: *mut (T0, T1))

impl<'b, T0: Stow<'b>, T1: Stow<'b>, T2: Stow<'b>> Stow<'b, (T0, T1, T2)> for (T0, T1, T2)

unsafe fn stow(
    src: *mut (T0, T1, T2),
    dst: *mut (T0, T1, T2),
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(src: *mut (T0, T1, T2), dst: *mut (T0, T1, T2))

impl<'b, T0: Stow<'b>, T1: Stow<'b>, T2: Stow<'b>, T3: Stow<'b>> Stow<'b, (T0, T1, T2, T3)> for (T0, T1, T2, T3)

unsafe fn stow(
    src: *mut (T0, T1, T2, T3),
    dst: *mut (T0, T1, T2, T3),
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(src: *mut (T0, T1, T2, T3), dst: *mut (T0, T1, T2, T3))

impl<'b, T: Stow<'b>> Stow<'b, [T]> for [T]

unsafe default fn stow(
    src: *mut [T],
    dst: *mut [T],
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe default fn unstow(src: *mut [T], dst: *mut [T])

impl<'b, T: Copy + Stow<'b>> Stow<'b, [T]> for [T]

unsafe fn stow(
    src: *mut [T],
    dst: *mut [T],
    _hold: &dyn Hold<'b>
) -> Result<(), HoldError>

unsafe fn unstow(_src: *mut [T], _dst: *mut [T])

Loading content...