Struct storages::boxed::Box

pub struct Box<T, B = AllocatedBuffer<T>, D = <B as Buffer<T>>::ExternalData> where
    T: ?Sized,
    B: Buffer<T, ExternalData = D>,  { /* fields omitted */ }

Implementations

impl<T> Box<T>

Construction of boxed values with a buffer backed by the global allocator.

pub fn new(value: T) -> Self

Allocates memory on the global heap and then places value into it.

This doesn't actually allocate if T is zero-sized.

Examples

use storages::boxed::Box;

let five = Box::new(5);

assert_eq!(*five, 5);

pub fn new_uninit() -> Box<MaybeUninit<T>, AllocatedBuffer<T>>

Constructs a new box with uninitialized contents.

Examples

use storages::boxed::Box;

let mut five = Box::<u32>::new_uninit();

let five = unsafe {
    // Deferred initialization:
    five.as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5);

pub fn new_zeroed() -> Box<MaybeUninit<T>, AllocatedBuffer<T>>

Constructs a new box with uninitialized contents, with the memory being filled with 0 bytes.

See MaybeUninit::zeroed for examples of correct and incorrect usage of this method.

Examples

use storages::boxed::Box;

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);

impl<T> Box<[T]>

Construction of boxed slices with a buffer backed by the global allocator.

pub fn new_uninit_slice(
    len: usize
) -> Box<[MaybeUninit<T>], AllocatedBuffer<[T]>>

Constructs a boxed slice with uninitialized contents.

Examples

use storages::boxed::Box;

let mut values = Box::<[u32]>::new_uninit_slice(3);

let values = unsafe {
    // Deferred initialization:
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(&*values, [1, 2, 3])

pub fn new_zeroed_slice(
    len: usize
) -> Box<[MaybeUninit<T>], AllocatedBuffer<[T]>>

Constructs a boxed with uninitialized contents with the memory being filled with 0 bytes.

See MaybeUninit::zeroed for examples of correct and incorrect usage of this method.

Examples

use storages::boxed::Box;

let values = Box::<[u32]>::new_zeroed_slice(3);
let values = unsafe { values.assume_init() };

assert_eq!(&*values, [0, 0, 0])

impl<T, B, D> Box<T, B, D> where
    B: Buffer<T, ExternalData = D>, 

Construction of boxed values in a provided buffer.

pub fn new_in(value: T, buffer: B, data: D) -> Self

Places the value in the provided buffer.

Examples

#![feature(allocator_api)]

use std::alloc::System;
use storages::{boxed::Box, buffer::AllocatedBuffer};

let buffer = AllocatedBuffer::new_in(&System)?;
let five = Box::new_in(5, buffer, System);

assert_eq!(*five, 5);

pub fn new_uninit_in(buffer: B, data: D) -> Box<MaybeUninit<T>, B, D> where
    B: Buffer<MaybeUninit<T>, ExternalData = D>, 

Constructs a new box with uninitialized contents in the provided buffer.

Examples

#![feature(allocator_api, maybe_uninit_extra)]

use std::alloc::System;
use storages::{boxed::Box, buffer::AllocatedBuffer};

let buffer = AllocatedBuffer::new_in(&System)?;
let mut five = Box::<u32, _>::new_uninit_in(buffer, System);

let five = unsafe {
    // Deferred initialization:
    five.as_mut_ptr().write(5);

    five.assume_init()
};

assert_eq!(*five, 5);

impl<T: ?Sized, B, D> Box<T, B, D> where
    B: Buffer<T, ExternalData = D>, 

pub unsafe fn from_buffer(buffer: B, data: D) -> Self

Creates a box from the provided buffer.

Safety

It is up to the caller to guarantee that the value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.

Examples

use storages::boxed::Box;

let values = unsafe { Box::from_buffer([0_u32; 3], ()) };

assert_eq!(*values, [0, 0, 0]);

impl<T, B, D> Box<[T], B, D> where
    B: Buffer<[T], ExternalData = D>, 

Construction of boxed slices in a provided buffer.

pub fn new_uninit_slice_in(buffer: B, data: D) -> Box<[MaybeUninit<T>], B, D> where
    B: Buffer<[MaybeUninit<T>], ExternalData = D>, 

Constructs a boxed with uninitialized contents in the provided buffer.

Examples

use std::mem;
use storages::boxed::Box;

let buffer = [mem::MaybeUninit::<u32>::uninit(); 3];
let mut values = Box::<[u32], _>::new_uninit_slice_in(buffer, ());

let values = unsafe {
    // Deferred initialization:
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])

impl<T, B, D> Box<MaybeUninit<T>, B, D> where
    B: Buffer<T, ExternalData = D> + Buffer<MaybeUninit<T>, ExternalData = D>, 

pub unsafe fn assume_init(self) -> Box<T, B, D>

Converts to Box<T, B>.

Safety

As with MaybeUninit::assume_init, it is up to the caller to guarantee that the value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.

Examples

use storages::boxed::Box;

let mut five = Box::<u32>::new_uninit();

let five = unsafe {
    // Deferred initialization:
    five.as_mut_ptr().write(5);

    five.assume_init()
};
assert_eq!(*five, 5);

impl<T, B, D> Box<[MaybeUninit<T>], B, D> where
    B: Buffer<[T], ExternalData = D> + Buffer<[MaybeUninit<T>], ExternalData = D>, 

pub unsafe fn assume_init(self) -> Box<[T], B, D>

Constructs a boxed with uninitialized contents in the provided buffer.

Safety

As with MaybeUninit::assume_init, it is up to the caller to guarantee that the value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.

Examples

use std::mem;
use storages::boxed::Box;

let buffer = [mem::MaybeUninit::<u32>::uninit(); 3];
let mut values = Box::new_uninit_slice_in(buffer, ());

let values = unsafe {
    // Deferred initialization:
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])

Trait Implementations

impl<T, U, D, BT, BU> CoerceUnsized<Box<U, BU, D>> for Box<T, BT, D> where
    T: ?Sized,
    U: ?Sized,
    BT: Buffer<T, ExternalData = D> + CoerceUnsized<BU>,
    BU: Buffer<U, ExternalData = D>, 

impl<T, B, D> Deref for Box<T, B, D> where
    T: ?Sized,
    B: Buffer<T, ExternalData = D>, 

type Target = T

The resulting type after dereferencing.

pub fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, B, D> DerefMut for Box<T, B, D> where
    T: ?Sized,
    B: Buffer<T, ExternalData = D>, 

pub fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, S, D> Drop for Box<T, S, D> where
    T: ?Sized,
    S: UnmanagedBuffer<T, ExternalData = D>, 

pub fn drop(&mut self)

Executes the destructor for this type.