Struct StdAllocator 

pub struct StdAllocator<T>(/* private fields */);

Implemented only for T = c_char
std::allocator<T>::allocate
std::allocator<T>::deallocate

Implementations

impl<T> StdAllocator<T>

pub const fn new() -> Self

Create a new std::allocator<T> wrapper

Examples found in repository

examples/alloc-tester.rs (line 90)

fn main() {
    println!("{: <25}{: <20}{: <20}", "",          "thin::Alloc",   "fat::Alloc",   );
    println!("{: <25}{: <20}{: <20}", "Allocator", "Alignment",     "Alignment",    );
    println!("{:=<65}", "");
    #[cfg(feature = "alloc")]   Test::new("Global",                 || alloc::Global                    )       .fat().print();
    #[cfg(c89)]                 Test::new("Malloc",                 || c::Malloc                        ).thin().fat().print();
    #[cfg(c89)]                 Test::new("AlignedMalloc",          || c::AlignedMalloc                 )       .fat().print();
    #[cfg(cpp98)]               Test::new("NewDelete",              || cpp::NewDelete                   ).thin().fat().print();
    #[cfg(cpp98)]               Test::new("NewDeleteArray",         || cpp::NewDeleteArray              ).thin().fat().print();
    #[cfg(cpp17)]               Test::new("NewDeleteAligned",       || cpp::NewDeleteAligned            )       .fat().print();
    #[cfg(cpp17)]               Test::new("NewDeleteArrayAligned",  || cpp::NewDeleteArrayAligned       )       .fat().print();
    #[cfg(cpp98)]               Test::new("StdAllocator<char>",     || cpp::StdAllocator::<char>::new() )       .fat().print();
    #[cfg(all(windows, feature = "win32"))] {
        println!();
        println!("win32:");
        Test::new("ProcessHeap",        || win32::ProcessHeap               ).thin().fat().print();
        Test::new("Global",             || win32::Global                    ).thin().fat().print();
        Test::new("Local",              || win32::Local                     ).thin().fat().print();
        Test::new("CryptMem",           || win32::CryptMem                  ).thin().fat().print();
        Test::new("CoTaskMem",          || win32::CoTaskMem                 ).thin().fat().print();
        Test::new("VirtualCommit",      || win32::VirtualCommit             ).thin().fat().print();
    }
}

Trait Implementations

impl Alloc for StdAllocator<c_char>

Safety Item	Description
align	✔️ Validated via fat::test::alignment
size	✔️ Validated via fat::test::edge_case_sizes
pin	✔️ StdAllocator<c_char> is 'static - allocations by std::allocator<T>::allocate live until std::allocator<T>::deallocated.
compatible	✔️ StdAllocator<c_char> uses exclusively intercompatible std::allocator<char> functions
compatible	✔️ std::allocator<char> is stateless (see is_always_equal checks in ffi.cpp)
exclusive	✔️ std::allocator<T>::allocate allocations are exclusive/unique
exceptions	✔️ std::allocator<T>::allocate can throw std::bad_alloc - the FFI wrapper around it catches std::bad_alloc and returns nullptr instead.
threads	⚠️ thread-unsafe stdlibs existed once upon a time. I consider linking them in a multithreaded program defacto undefined behavior beyond the scope of this to guard against.
zeroed	✔️ Validated via fat::test::zeroed_alloc

fn alloc_uninit( &self, size: usize, ) -> Result<NonNull<MaybeUninit<u8>>, Self::Error>

Allocate at least size bytes of uninitialized memory.

fn alloc_zeroed(&self, size: usize) -> Result<NonNull<u8>, Self::Error>

Allocate at least size bytes of zeroed memory.

impl Alloc for StdAllocator<c_char>

fn alloc_uninit( &self, layout: Layout, ) -> Result<NonNull<MaybeUninit<u8>>, Self::Error>

Allocate at least layout.size() bytes of uninitialized memory aligned to layout.align().

fn alloc_zeroed(&self, layout: Layout) -> Result<NonNull<u8>, Self::Error>

Allocate at least layout.size() bytes of zeroed memory aligned to layout.align().

impl<T: Clone> Clone for StdAllocator<T>

fn clone(&self) -> StdAllocator<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for StdAllocator<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for StdAllocator<T>

fn default() -> StdAllocator<T>

Returns the “default value” for a type.

impl Free for StdAllocator<c_char>

Safety Item	Description
compatible	✔️ StdAllocator<c_char> uses exclusively intercompatible std::allocator<char> functions
compatible	✔️ std::allocator<char> is stateless (see is_always_equal checks in ffi.cpp)
exceptions	⚠️ std::allocator<T>::deallocate “Does not throw exceptions” (C++03 § 20.1.5 ¶ 2 Table 32), although it’s neither throw() nor noexcept.
threads	⚠️ thread-unsafe stdlibs existed once upon a time. I consider linking them in a multithreaded program defacto undefined behavior beyond the scope of this to guard against.

unsafe fn free(&self, ptr: NonNull<MaybeUninit<u8>>, layout: Layout)

Deallocate an allocation, ptr, belonging to self.

impl<T: Hash> Hash for StdAllocator<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Meta for StdAllocator<T>

const MAX_ALIGN: Alignment

Indicates the maximum alignment this allocator should be expected to succeed in allocating. Requesting an allocation with more alignment than this is almost certainly a bug.

const MAX_SIZE: usize = 18_446_744_073_709_551_615usize

Indicates the maximum size this allocator should be expected to succeed in allocating. Requesting an allocation larger than this is almost certainly a bug.

const ZST_SUPPORTED: bool = false

Indicates if this allocator supports zero-sized allocations. While this is nice and Rust-friendly, it may not be supported by C or C++ allocators.

type Error = ()

The error type returned from failed (re)allocation.

impl<T: Ord> Ord for StdAllocator<T>

fn cmp(&self, other: &StdAllocator<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for StdAllocator<T>

fn eq(&self, other: &StdAllocator<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for StdAllocator<T>

fn partial_cmp(&self, other: &StdAllocator<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Realloc for StdAllocator<c_char>

unsafe fn realloc_uninit( &self, ptr: NonNull<MaybeUninit<u8>>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<MaybeUninit<u8>>, Self::Error>

Reallocate an existing allocation, ptr, belonging to self.

unsafe fn realloc_zeroed( &self, ptr: NonNull<MaybeUninit<u8>>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<MaybeUninit<u8>>, Self::Error>

Reallocate an existing allocation, ptr, belonging to self.

impl<T: Copy> Copy for StdAllocator<T>

impl<T: Eq> Eq for StdAllocator<T>

impl Stateless for StdAllocator<c_char>

SAFETY: ✔️ std::allocator<char> is stateless (see is_always_equal checks in ffi.cpp)

impl<T> StructuralPartialEq for StdAllocator<T>