Enum Permission

pub enum Permission {
    Unique,
    SharedReadWrite,
    SharedReadOnly,
    Disabled,
}

Indicates which permission is granted (by this item to some pointers)

Variants

Unique

Grants unique mutable access.

SharedReadWrite

Grants shared mutable access.

SharedReadOnly

Grants shared read-only access.

Disabled

Grants no access, but separates two groups of SharedReadWrite so they are not all considered mutually compatible.

Implementations

impl Permission

const UNIQUE: u64 = 0u64

const SHARED_READ_WRITE: u64 = 1u64

const SHARED_READ_ONLY: u64 = 2u64

const DISABLED: u64 = 3u64

fn to_bits(self) -> u64

fn from_bits(perm: u64) -> Self

impl Permission

We need to make at least the following things true:

U1: After creating a Uniq, it is at the top. U2: If the top is Uniq, accesses must be through that Uniq or remove it. U3: If an access happens with a Uniq, it requires the Uniq to be in the stack.

F1: After creating a &, the parts outside UnsafeCell have our SharedReadOnly on top. F2: If a write access happens, it pops the SharedReadOnly. This has three pieces: F2a: If a write happens granted by an item below our SharedReadOnly, the SharedReadOnly gets popped. F2b: No SharedReadWrite or Unique will ever be added on top of our SharedReadOnly. F3: If an access happens with an & outside UnsafeCell, it requires the SharedReadOnly to still be in the stack.

Core relation on Permission to define which accesses are allowed

fn grants(self, access: AccessKind) -> bool

This defines for a given permission, whether it permits the given kind of access.

Trait Implementations

impl Clone for Permission

fn clone(&self) -> Permission

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Permission

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

Formats the value using the given formatter.

impl Hash for Permission

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 PartialEq for Permission

fn eq(&self, other: &Permission) -> 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 Copy for Permission

impl Eq for Permission

impl StructuralPartialEq for Permission

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• Unique: 0 bytes
• SharedReadWrite: 0 bytes
• SharedReadOnly: 0 bytes
• Disabled: 0 bytes