Enum OperatorEntry

#[non_exhaustive]
pub enum OperatorEntry {
    Init {
        hash_algorithm: HashAlgorithm,
        key: PublicKey,
    },
    GrantFlat {
        key: PublicKey,
        permissions: Vec<Permission>,
    },
    RevokeFlat {
        key_id: KeyID,
        permissions: Vec<Permission>,
    },
    DefineNamespace {
        namespace: String,
    },
    ImportNamespace {
        namespace: String,
        registry: String,
    },
}

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.

Init

Initializes a operator log. Must be the first entry of every log and not appear elsewhere.

Fields

hash_algorithm: HashAlgorithm

The hash algorithm this log will use for linking

key: PublicKey

The original operator key

GrantFlat

Grant the specified key a permission. The author of this entry must have the permission.

Fields

key: PublicKey

permissions: Vec<Permission>

RevokeFlat

Remove a permission from a key. The author of this entry must have the permission.

Fields

key_id: KeyID

permissions: Vec<Permission>

DefineNamespace

The registry defines a namespace to be used in its own package logs.

Fields

namespace: String

ImportNamespace

The registry defines a namespace as imported from another registry.

Fields

namespace: String

registry: String

Implementations

impl OperatorEntry

pub fn required_permission(&self) -> Option<Permission>

Check permission is required to submit this entry

Trait Implementations

impl Clone for OperatorEntry

fn clone(&self) -> OperatorEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OperatorEntry

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

Formats the value using the given formatter.

impl<'a> From<&'a OperatorEntry> for OperatorEntry

fn from(entry: &'a OperatorEntry) -> Self

Converts to this type from the input type.

impl PartialEq for OperatorEntry

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

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

const 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 TryFrom<OperatorEntry> for OperatorEntry

type Error = Error

The type returned in the event of a conversion error.

fn try_from(entry: OperatorEntry) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for OperatorEntry

impl StructuralPartialEq for OperatorEntry