Struct SubjectAttributes 

pub struct SubjectAttributes<'a> {
    pub kind: SubjectKind<'a>,
    pub handle: Option<&'a str>,
    pub depth: Option<u32>,
}

Attributes about the writing account a policy may need beyond its DID, explicit and extensible rather than a bag.

This is the contract between this crate, the write path that populates it, and the evaluators that read it: an evaluator names the attribute it needs from here, and the write path knows, from this same type, what it is obliged to fill in. Every attribute past kind is kind-dependent — a host has no model to report, the way it has no harness and no parent — so None here means “this kind does not have one, or the write path could not resolve it for this write”, never an error an evaluator needs to handle specially; it is a normal, expected value to see.

Adding an allowlist-shaped policy — “displayName may be set only to the account’s handle or a small fixed list of values” — does not reintroduce an allow: it is expressed as deny if the new value matches none of them, read off Change::after and this handle, which subtracts from what is permitted exactly like every other policy. Monotonicity does not distinguish an allowlist from a blocklist; both are deny rules, just aimed at different values.

Fields

kind: SubjectKind<'a>

What kind of account this subject is — one of the four this build recognizes, or a kind it does not. See SubjectKind.

handle: Option<&'a str>

This account’s current handle, if the write path resolved one for this write and this kind has one.

depth: Option<u32>

How many edges lie between this account and the deployment’s operator: 1 for an account the operator runs directly, 2 for one such an account created, and so on. None when the write path did not resolve it.

Trait Implementations

impl<'a> Clone for SubjectAttributes<'a>

fn clone(&self) -> SubjectAttributes<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SubjectAttributes<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for SubjectAttributes<'a>

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

impl<'a> Eq for SubjectAttributes<'a>

impl<'a> StructuralPartialEq for SubjectAttributes<'a>