Struct scratchpad::MarkerBack

pub struct MarkerBack<'scratchpad, BufferT, TrackingT> where
    BufferT: 'scratchpad + Buffer,
    TrackingT: 'scratchpad + Tracking,  { /* fields omitted */ }

Scratchpad marker for allocations from the back of the allocation buffer.

A MarkerBack is created when calling the mark_back() method on a Scratchpad instance. Object allocations can only be made from the most recently created MarkerFront or MarkerBack that is still active.

Markers are statically bound to the lifetime of the Scratchpad from which they are created, ensuring that no dangling references are left when the Scratchpad is dropped.

This struct wraps Marker trait methods to avoid the need to import Marker into scope.

Methods

impl<'scratchpad, BufferT, TrackingT> MarkerBack<'scratchpad, BufferT, TrackingT> where
    BufferT: 'scratchpad + Buffer,
    TrackingT: 'scratchpad + Tracking, 

pub fn allocate<'marker, T>(
    &'marker self,
    value: T
) -> Result<Allocation<'marker, T>, Error<(T,)>>

Allocates space for the given value, moving it into the allocation.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 1], [usize; 1]>::new([0], [0]);
let marker = scratchpad.mark_back().unwrap();

let x = marker.allocate(3.14159).unwrap();
assert_eq!(*x, 3.14159);

pub fn allocate_default<'marker, T: Default>(
    &'marker self
) -> Result<Allocation<'marker, T>, Error<()>>

Allocates space for a value, initializing it to its default.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 1], [usize; 1]>::new([0], [0]);
let marker = scratchpad.mark_back().unwrap();

let x = marker.allocate_default::<f64>().unwrap();
assert_eq!(*x, 0.0);

pub unsafe fn allocate_uninitialized<'marker, T>(
    &'marker self
) -> Result<Allocation<'marker, T>, Error<()>>

Allocates uninitialized space for the given type.

Safety

Since memory for the allocated data is uninitialized, it can potentially be in an invalid state for a given type, leading to undefined program behavior. It is recommended that one of the safe allocate*() methods are used instead if possible.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 1], [usize; 1]>::new([0], [0]);
let marker = scratchpad.mark_back().unwrap();

let mut x = unsafe { marker.allocate_uninitialized().unwrap() };
*x = 3.14159;
assert_eq!(*x, 3.14159);

pub fn allocate_array<'marker, T: Clone>(
    &'marker self,
    len: usize,
    value: T
) -> Result<Allocation<'marker, [T]>, Error<(T,)>>

Allocates space for an array, initializing each element with the given value.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 3], [usize; 1]>::new([0; 3], [0]);
let marker = scratchpad.mark_back().unwrap();

let x = marker.allocate_array(3, 3.14159).unwrap();
assert_eq!(*x, [3.14159, 3.14159, 3.14159]);

pub fn allocate_array_default<'marker, T: Default>(
    &'marker self,
    len: usize
) -> Result<Allocation<'marker, [T]>, Error<()>>

Allocates space for an array, initializing each element to its default value.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 3], [usize; 1]>::new([0; 3], [0]);
let marker = scratchpad.mark_back().unwrap();

let x = marker.allocate_array_default::<f64>(3).unwrap();
assert_eq!(*x, [0.0, 0.0, 0.0]);

pub fn allocate_array_with<'marker, T, F: FnMut(usize) -> T>(
    &'marker self,
    len: usize,
    func: F
) -> Result<Allocation<'marker, [T]>, Error<()>>

Allocates space for an array, initializing each element with the result of a function.

The function func takes a single parameter containing the index of the element being initialized.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 3], [usize; 1]>::new([0; 3], [0]);
let marker = scratchpad.mark_back().unwrap();

let x = marker.allocate_array_with(3, |index| index as f64).unwrap();
assert_eq!(*x, [0.0, 1.0, 2.0]);

pub unsafe fn allocate_array_uninitialized<'marker, T>(
    &'marker self,
    len: usize
) -> Result<Allocation<'marker, [T]>, Error<()>>

Allocates uninitialized space for an array of the given type.

Safety

Since memory for the allocated data is uninitialized, it can potentially be in an invalid state for a given type, leading to undefined program behavior. It is recommended that one of the safe allocate*() methods are used instead if possible.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 3], [usize; 1]>::new([0; 3], [0]);
let marker = scratchpad.mark_back().unwrap();

let mut x = unsafe {
    marker.allocate_array_uninitialized(3).unwrap()
};
x[0] = 3.14159;
x[1] = 4.14159;
x[2] = 5.14159;
assert_eq!(*x, [3.14159, 4.14159, 5.14159]);

pub fn allocate_slice<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<(U,)>> where
    T: SliceLike,
    U: SliceMoveSource<T>, 

Allocates a slice, initializing its contents by moving the given values into the allocation.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u64; 3], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let values = [3.14159, 4.14159, 5.14159];
let allocation = marker.allocate_slice(values).unwrap();
let allocation_slice: &[f64] = &*allocation;
assert_eq!(*allocation_slice, [3.14159, 4.14159, 5.14159]);

pub fn allocate_slice_clone<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: SliceLike,
    <T as SliceLike>::Element: Clone,
    U: SliceSource<T>, 

Allocates a copy of a slice by cloning each individual element.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u8; 32], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let message = "foo";
let allocation = marker.allocate_slice_clone(message).unwrap();
assert_eq!(&*allocation, "foo");

pub fn allocate_slice_copy<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: SliceLike,
    <T as SliceLike>::Element: Copy,
    U: SliceSource<T>, 

Allocates a copy of a slice by performing a fast copy (equivalent to C's memcpy() function) into the new allocation.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u8; 32], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let message = "foo";
let allocation = marker.allocate_slice_copy(message).unwrap();
assert_eq!(&*allocation, "foo");

pub fn prepend<'marker, T: ?Sized, U, V>(
    &'marker self,
    allocation: Allocation<'marker, U>,
    values: V
) -> Result<Allocation<'marker, T>, Error<(Allocation<'marker, U>, V)>> where
    T: ConcatenateSlice,
    U: ?Sized,
    Allocation<'marker, U>: IntoSliceLikeAllocation<'marker, T>,
    V: SliceMoveSource<T>, 

Extends an allocation by moving values onto its start, converting the allocation to a slice if necessary.

The following requirements must be met to allow elements to be prepended:

• The marker must be the most recently created back marker from its scratchpad.
• The allocation must contain a scalar, array, or slice of the type being pushed.
• The data being pushed must be a scalar, array, boxed slice, or vector of the same type.
• The allocation must be the most recent allocation made from this marker, even if other, more recent allocations have been released.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u32; 5], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let a = marker.allocate([3.14159f32, 2.71828f32]).unwrap();

let ab = marker.prepend(a, [0.70711f32]).unwrap();
assert_eq!(*ab, [0.70711f32, 3.14159f32, 2.71828f32]);

let abc = marker.prepend(ab, vec![0.57722f32, 1.61803f32]).unwrap();
assert_eq!(
    *abc,
    [0.57722f32, 1.61803f32, 0.70711f32, 3.14159f32, 2.71828f32],
);

pub fn prepend_clone<'marker, T: ?Sized, U, V>(
    &'marker self,
    allocation: Allocation<'marker, U>,
    values: V
) -> Result<Allocation<'marker, T>, Error<(Allocation<'marker, U>,)>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Clone,
    U: ?Sized,
    Allocation<'marker, U>: IntoSliceLikeAllocation<'marker, T>,
    V: SliceSource<T>, 

Extends an allocation by cloning values onto its start, converting the allocation to a slice if necessary.

The following requirements must be met to allow elements to be prepended:

• The marker must be the most recently created back marker from its scratchpad.
• The allocation must contain a scalar, array, or slice of the type being pushed.
• The data being pushed must be a scalar, array, boxed slice, or vector of the same type.
• The allocation must be the most recent allocation made from this marker, even if other, more recent allocations have been released.

Note that the values parameter is consumed as part of the allocation process and cannot be returned on error.

Examples

use scratchpad::{Allocation, IntoSliceLikeAllocation, Scratchpad};

let scratchpad = Scratchpad::<[u32; 5], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let a: Allocation<[f32]> = marker.allocate([3.14159f32, 2.71828f32])
    .unwrap()
    .into_slice_like_allocation();

let ab = marker.prepend_clone(a, &[0.57722f32, 1.61803f32][..])
    .unwrap();
assert_eq!(*ab, [0.57722f32, 1.61803f32, 3.14159f32, 2.71828f32]);

pub fn prepend_copy<'marker, T: ?Sized, U, V>(
    &'marker self,
    allocation: Allocation<'marker, U>,
    values: V
) -> Result<Allocation<'marker, T>, Error<(Allocation<'marker, U>,)>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Copy,
    U: ?Sized,
    Allocation<'marker, U>: IntoSliceLikeAllocation<'marker, T>,
    V: SliceSource<T>, 

Extends an allocation by copying values onto its start, converting the allocation to a slice if necessary.

The following requirements must be met to allow elements to be prepended:

• The marker must be the most recently created back marker from its scratchpad.
• The allocation must contain a scalar, array, or slice of the type being pushed.
• The data being pushed must be a scalar, array, boxed slice, or vector of the same type.
• The allocation must be the most recent allocation made from this marker, even if other, more recent allocations have been released.

Note that the values parameter is consumed as part of the allocation process and cannot be returned on error.

Examples

use scratchpad::{Allocation, IntoSliceLikeAllocation, Scratchpad};

let scratchpad = Scratchpad::<[u32; 5], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let a: Allocation<[f32]> = marker.allocate([3.14159f32, 2.71828f32])
    .unwrap()
    .into_slice_like_allocation();

let ab = marker.prepend_copy(a, &[0.57722f32, 1.61803f32][..])
    .unwrap();
assert_eq!(*ab, [0.57722f32, 1.61803f32, 3.14159f32, 2.71828f32]);

pub fn concat_slices<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<(U,)>> where
    T: ConcatenateSlice,
    U: SliceMoveSourceCollection<T>, 

Combines each of the provided slices into a single slice allocated from this marker, moving the slice values into the new allocation.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u8; 16], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let combined = marker.concat_slices(("Hello,", " world", "!"))
    .unwrap();
assert_eq!(&*combined, "Hello, world!");

pub fn concat_slices_clone<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Clone,
    U: SliceSourceCollection<T>, 

Combines cloned copies of each of the provided slices into a single slice allocated from this marker.

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u8; 16], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let combined = marker.concat_slices_clone(("Hello,", " world", "!"))
    .unwrap();
assert_eq!(&*combined, "Hello, world!");

pub fn concat_slices_copy<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Copy,
    U: SliceSourceCollection<T>, 

Combines copies of each of the provided slices into a single slice allocated from this marker.

Slices are copied by performing a fast memory copy from each of the source slices (equivalent to C's memcpy() function).

Examples

use scratchpad::Scratchpad;

let scratchpad = Scratchpad::<[u8; 16], [usize; 1]>::static_new();
let marker = scratchpad.mark_back().unwrap();

let combined = marker.concat_slices_copy(("Hello,", " world", "!"))
    .unwrap();
assert_eq!(&*combined, "Hello, world!");

Trait Implementations

impl<'scratchpad, BufferT: Debug, TrackingT: Debug> Debug for MarkerBack<'scratchpad, BufferT, TrackingT> where
    BufferT: 'scratchpad + Buffer,
    TrackingT: 'scratchpad + Tracking, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'scratchpad, BufferT, TrackingT> Marker for MarkerBack<'scratchpad, BufferT, TrackingT> where
    BufferT: 'scratchpad + Buffer,
    TrackingT: 'scratchpad + Tracking, 

unsafe fn allocate_memory(
    &self,
    alignment: usize,
    size: usize,
    len: usize
) -> Result<*mut u8, Error<()>>

fn is_allocation_at_end<'marker, T, U: ?Sized>(
    &'marker self,
    allocation: &Allocation<'marker, T>
) -> bool where
    T: ?Sized,
    Allocation<'marker, T>: IntoSliceLikeAllocation<'marker, U>,
    U: SliceLike, 

unsafe fn concat_allocations_unchecked<'marker, T: ?Sized, U, V>(
    base: Allocation<'marker, U>,
    extension: Allocation<'marker, V>
) -> Allocation<'marker, T> where
    T: ConcatenateSlice,
    U: ?Sized,
    Allocation<'marker, U>: IntoSliceLikeAllocation<'marker, T>,
    V: ?Sized,
    Allocation<'marker, V>: IntoSliceLikeAllocation<'marker, T>, 

fn allocate<'marker, T>(
    &'marker self,
    value: T
) -> Result<Allocation<'marker, T>, Error<(T,)>>

Allocates space for the given value, moving it into the allocation.

fn allocate_default<'marker, T: Default>(
    &'marker self
) -> Result<Allocation<'marker, T>, Error<()>>

Allocates space for a value, initializing it to its default.

unsafe fn allocate_uninitialized<'marker, T>(
    &'marker self
) -> Result<Allocation<'marker, T>, Error<()>>

Allocates uninitialized space for the given type.

fn allocate_array<'marker, T: Clone>(
    &'marker self,
    len: usize,
    value: T
) -> Result<Allocation<'marker, [T]>, Error<(T,)>>

Allocates space for an array, initializing each element with the given value.

fn allocate_array_default<'marker, T: Default>(
    &'marker self,
    len: usize
) -> Result<Allocation<'marker, [T]>, Error<()>>

Allocates space for an array, initializing each element to its default value.

fn allocate_array_with<'marker, T, F: FnMut(usize) -> T>(
    &'marker self,
    len: usize,
    func: F
) -> Result<Allocation<'marker, [T]>, Error<()>>

Allocates space for an array, initializing each element with the result of a function.

unsafe fn allocate_array_uninitialized<'marker, T>(
    &'marker self,
    len: usize
) -> Result<Allocation<'marker, [T]>, Error<()>>

Allocates uninitialized space for an array of the given type.

fn allocate_slice<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<(U,)>> where
    T: SliceLike,
    U: SliceMoveSource<T>, 

Allocates a slice, initializing its contents by moving the given values into the allocation.

fn allocate_slice_clone<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: SliceLike,
    <T as SliceLike>::Element: Clone,
    U: SliceSource<T>, 

Allocates a copy of a slice by cloning each individual element.

fn allocate_slice_copy<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: SliceLike,
    <T as SliceLike>::Element: Copy,
    U: SliceSource<T>, 

Allocates a copy of a slice by performing a fast copy (equivalent to C's memcpy() function) into the new allocation.

fn extend<'marker, T: ?Sized, U, V>(
    &'marker self,
    allocation: Allocation<'marker, U>,
    values: V
) -> Result<Allocation<'marker, T>, Error<(Allocation<'marker, U>, V)>> where
    T: ConcatenateSlice,
    U: ?Sized,
    Allocation<'marker, U>: IntoSliceLikeAllocation<'marker, T>,
    V: SliceMoveSource<T>, 

Extends an allocation by moving values onto one of its ends, converting the allocation to a slice if necessary.

fn extend_clone<'marker, T: ?Sized, U, V>(
    &'marker self,
    allocation: Allocation<'marker, U>,
    values: V
) -> Result<Allocation<'marker, T>, Error<(Allocation<'marker, U>,)>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Clone,
    U: ?Sized,
    Allocation<'marker, U>: IntoSliceLikeAllocation<'marker, T>,
    V: SliceSource<T>, 

Extends an allocation by cloning values onto one of its ends, converting the allocation to a slice if necessary.

fn extend_copy<'marker, T: ?Sized, U, V>(
    &'marker self,
    allocation: Allocation<'marker, U>,
    values: V
) -> Result<Allocation<'marker, T>, Error<(Allocation<'marker, U>,)>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Copy,
    U: ?Sized,
    Allocation<'marker, U>: IntoSliceLikeAllocation<'marker, T>,
    V: SliceSource<T>, 

Extends an allocation by copying values onto one of its ends, converting the allocation to a slice if necessary.

fn concat_slices<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<(U,)>> where
    T: ConcatenateSlice,
    U: SliceMoveSourceCollection<T>, 

Combines each of the provided slices into a single slice allocated from this marker, moving the slice values into the new allocation.

fn concat_slices_clone<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Clone,
    U: SliceSourceCollection<T>, 

Combines cloned copies of each of the provided slices into a single slice allocated from this marker.

fn concat_slices_copy<'marker, T: ?Sized, U>(
    &'marker self,
    values: U
) -> Result<Allocation<'marker, T>, Error<()>> where
    T: ConcatenateSlice,
    <T as SliceLike>::Element: Copy,
    U: SliceSourceCollection<T>, 

Combines copies of each of the provided slices into a single slice allocated from this marker.

impl<'scratchpad, BufferT, TrackingT> Drop for MarkerBack<'scratchpad, BufferT, TrackingT> where
    BufferT: 'scratchpad + Buffer,
    TrackingT: 'scratchpad + Tracking, 

fn drop(&mut self)

Executes the destructor for this type.