Struct alloc_compose::Null

pub struct Null;

An emphatically empty implementation of AllocRef.

Although it has no direct use, it is useful as a "terminator" in composite allocators or for disabling the global allocator.

Examples

The Null will always return Err:

#![feature(allocator_api)]

use alloc_compose::Null;
use std::alloc::{AllocRef, Global, Layout};

let memory = Null.alloc(Layout::new::<u32>());
assert!(memory.is_err())

Even if a zero-sized allocation is requested:

let memory = Null.alloc(Layout::new::<()>());
assert!(memory.is_err())

Disabling the global allocator

use alloc_compose::Null;

#[global_allocator]
static A: Null = Null;

Trait Implementations

impl AllocRef for Null

pub fn alloc(&self, _layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Will always return Err(AllocErr).

pub fn alloc_zeroed(&self, _layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Will always return Err(AllocErr).

pub unsafe fn dealloc(&self, _ptr: NonNull<u8>, _layout: Layout)

🔬 This is a nightly-only experimental API. (allocator_api)

Must not be called, as allocation always fails.

pub unsafe fn grow(
    &self,
    _ptr: NonNull<u8>,
    _old_layout: Layout,
    _new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Must not be called, as allocation always fails.

pub unsafe fn grow_zeroed(
    &self,
    _ptr: NonNull<u8>,
    _old_layout: Layout,
    _new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Must not be called, as allocation always fails.

pub unsafe fn shrink(
    &self,
    _ptr: NonNull<u8>,
    _old_layout: Layout,
    _new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

🔬 This is a nightly-only experimental API. (allocator_api)

Must not be called, as allocation always fails.

pub fn by_ref(&self) -> &Self

🔬 This is a nightly-only experimental API. (allocator_api)

Creates a "by reference" adaptor for this instance of AllocRef.

impl AllocateAll for Null

pub fn allocate_all(&self) -> Result<NonNull<[u8]>, AllocError>

Attempts to allocate all of the memory the allocator can provide.

pub fn allocate_all_zeroed(&self) -> Result<NonNull<[u8]>, AllocError>

Behaves like alloc_all, but also ensures that the returned memory is zero-initialized.

pub fn deallocate_all(&self)

Deallocates all the memory the allocator had allocated.

pub fn capacity(&self) -> usize

Returns the total capacity available in this allocator.

pub fn capacity_left(&self) -> usize

Returns the free capacity left for allocating.

pub fn is_empty(&self) -> bool

Returns if the allocator is currently not holding memory.

pub fn is_full(&self) -> bool

Returns if the allocator has no more capacity left.

impl Clone for Null

pub fn clone(&self) -> Null

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Null

impl Debug for Null

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl GlobalAlloc for Null

pub unsafe fn alloc(&self, layout: Layout) -> *mut u8

Allocate memory as described by the given layout.

pub unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout)

Deallocate the block of memory at the given ptr pointer with the given layout.

pub unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8

Behaves like alloc, but also ensures that the contents are set to zero before being returned.

pub unsafe fn realloc(
    &self,
    ptr: *mut u8,
    layout: Layout,
    new_size: usize
) -> *mut u8

Shrink or grow a block of memory to the given new_size. The block is described by the given ptr pointer and layout.

impl Owns for Null

pub fn owns(&self, _memory: NonNull<[u8]>) -> bool

Will always return `false.

impl ReallocateInPlace for Null

pub unsafe fn grow_in_place(
    &self,
    _ptr: NonNull<u8>,
    _old_layout: Layout,
    _new_layout: Layout
) -> Result<usize, AllocError>

Must not be called, as allocation always fails.

pub unsafe fn grow_in_place_zeroed(
    &self,
    _ptr: NonNull<u8>,
    _old_layout: Layout,
    _new_layout: Layout
) -> Result<usize, AllocError>

Must not be called, as allocation always fails.

pub unsafe fn shrink_in_place(
    &self,
    _ptr: NonNull<u8>,
    _old_layout: Layout,
    _new_layout: Layout
) -> Result<usize, AllocError>

Must not be called, as allocation always fails.