Trait bitvec::ptr::Mutability

pub trait Mutability: 'static + Copy + Sealed {
    const SELF: Self;
    const RENDER: &'static str;
    const CONTAINS_MUTABILITY: bool = false;
    const PEANO_NUMBER: usize = 0usize;

    fn freeze(self) -> Frozen<Self> { ... }
    fn thaw(Frozen<Self>) -> Self { ... }
}

Generalized mutability permissions.

This trait enables referent structures to be generic over the write permissions of their referent data. As an example, the standard library defines *const T and *mut T as two duplicate type families, that cannot share any logic at all.

An equivalent library implementation might be Ptr<T, M: Mutability>, where shared logic can be placed in an impl<T, M> Ptr<T, M> block, but unique logic (such as freezing a Mut pointer, or unfreezing a Frozen<Mut>) can be placed in specialized impl<T> Ptr<T, Mut> blocks.

Required Associated Constants

const SELF: Self

Allow instances to be constructed generically.

const RENDER: &'static str

One of *const or *mut.

Provided Associated Constants

const CONTAINS_MUTABILITY: bool = false

Marks whether this type contains mutability permissions within it.

This is false for Const and true for Mut. Frozen wrappers atop either of these types inherit their interior marker.

const PEANO_NUMBER: usize = 0usize

Counts the layers of Frozen<> wrapping around a base Const or Mut.

Provided Methods

fn freeze(self) -> Frozen<Self>

Freeze this type, wrapping it in a const marker that may later be removed to thaw it.

fn thaw(Frozen<Self>) -> Self

Thaw a previously-frozen type, removing its Frozen marker and restoring it to Self.

Implementors

impl Mutability for Const

const RENDER: &'static str = "*const"

const SELF: Const = Self

impl Mutability for Mut

const CONTAINS_MUTABILITY: bool = true

const RENDER: &'static str = "*mut"

const SELF: Mut = Self

impl<Inner> Mutability for Frozen<Inner> where
    Inner: Mutability, 

const CONTAINS_MUTABILITY: bool = Inner::CONTAINS_MUTABILITY

const PEANO_NUMBER: usize = 1 + Inner::PEANO_NUMBER

const RENDER: &'static str = Inner::RENDER

const SELF: Frozen<Inner> = Self{inner: Inner::SELF,}