Enum BytePageSize 

#[non_exhaustive]
pub enum BytePageSize {
    Size4 = 0,
    Size8 = 1,
    Size16 = 2,
    Size24 = 3,
    Size32 = 4,
    Size48 = 5,
    Size64 = 6,
    Size128 = 7,
    Size256 = 8,
    Unset = 9,
}

Capacity category used when allocating crate::BytePage storage.

Buffers with a page size are returned to a per-thread cache of their category when the last reference is dropped, see crate::set_page_cache_size.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Size4 = 0

A 4 KiB page.

Size8 = 1

An 8 KiB page.

Size16 = 2

A 16 KiB page.

Size24 = 3

A 24 KiB page.

Size32 = 4

A 32 KiB page.

Size48 = 5

A 48 KiB page.

Size64 = 6

A 64 KiB page.

Size128 = 7

A 128 KiB page.

Size256 = 8

A 256 KiB page.

Unset = 9

No fixed page category.

Buffers of this category are sized on demand and never returned to the page cache. A buffer whose allocation is exactly a page size belongs to that page category, whichever way it was created. It cannot be used as the page size of crate::BytePages.

Implementations

impl BytePageSize

pub const fn for_capacity(capacity: usize) -> BytePageSize

Returns the smallest page category with a capacity of at least capacity bytes.

Returns BytePageSize::Unset if capacity is larger than the capacity of the largest category.

Examples

use ntex_bytes::BytePageSize;

assert_eq!(BytePageSize::for_capacity(100), BytePageSize::Size4);
assert_eq!(BytePageSize::for_capacity(5000), BytePageSize::Size8);
assert_eq!(BytePageSize::for_capacity(1024 * 1024), BytePageSize::Unset);

pub const fn next(self) -> BytePageSize

Returns the next larger page category.

The largest category returns BytePageSize::Unset, Unset returns itself.

pub const fn prev(self) -> BytePageSize

Returns the next smaller page category.

The smallest category returns itself, BytePageSize::Unset returns the largest category.

pub const fn capacity(self) -> usize

Returns the page capacity in bytes.

A page is allocated together with its header, the capacity is the category size minus the header, so the allocation is exactly the category size and fits the allocator’s size classes.

pub const fn half_capacity(self) -> usize

Returns the recommended write-buffer threshold for this page size.

This is half of the category size, but at most 16 KiB.

pub const fn low(self) -> usize

Returns the low free-capacity threshold for this page size.

This is 2/32 of the category size: 256 bytes for Size4, 1 KiB for Size16, 16 KiB for Size256 and 4 KiB for BytePageSize::Unset. crate::BytesMut::reserve_more grows a buffer once its remaining capacity falls below it.

Examples

use ntex_bytes::BytePageSize;

assert_eq!(BytePageSize::Size4.low(), 256);
assert_eq!(BytePageSize::Size8.low(), 512);
assert_eq!(BytePageSize::Size16.low(), 1024);
assert_eq!(BytePageSize::Unset.low(), 4096);

Trait Implementations

impl Clone for BytePageSize

fn clone(&self) -> BytePageSize

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BytePageSize

impl Debug for BytePageSize

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

Formats the value using the given formatter.

impl Default for BytePageSize

fn default() -> BytePageSize

Returns the “default value” for a type.

impl Eq for BytePageSize

impl PartialEq for BytePageSize

fn eq(&self, other: &BytePageSize) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BytePageSize