Struct Claim 

pub struct Claim {
    pub id: Option<ContentId>,
    pub subject: Ref,
    pub predicate: Symbol,
    pub object: Ref,
    pub kind: ClaimKind,
    pub evidence: Vec<Ref>,
    pub requires: Vec<CapabilityName>,
    pub visibility: Visibility,
}

An asserted fact about a runtime subject: a subject/predicate/object triple plus kind, evidence, required capabilities, and visibility.

The kernel defines the record and its canonical datum form; libraries supply the claims and the FactStores that hold them.

Examples

let claim = Claim::new(
    Ref::Symbol(Symbol::qualified("core", "List")),
    Symbol::new("kind"),
    Ref::Symbol(Symbol::qualified("core", "class")),
);
assert_eq!(claim.kind, ClaimKind::Asserted);
// The claim has a deterministic content datum.
let _ = claim.canonical_datum();

Fields

id: Option<ContentId>

Content id of the claim once interned; None before insertion.

subject: Ref

The subject the claim is about.

predicate: Symbol

The predicate relating subject to object.

object: Ref

The object of the claim.

kind: ClaimKind

How the claim was established.

evidence: Vec<Ref>

Supporting references for the claim.

requires: Vec<CapabilityName>

Capabilities required to see the claim under gated or private visibility.

visibility: Visibility

Read visibility policy for the claim.

Implementations

impl Claim

pub fn new(subject: Ref, predicate: Symbol, object: Ref) -> Self

Creates an asserted, public claim with no evidence or requirements.

pub fn public(subject: Ref, predicate: Symbol, object: Ref) -> Self

Creates a public claim; alias for Claim::new.

pub fn content_object( store: &mut dyn DatumStore, subject: Ref, predicate: Symbol, object: Datum, ) -> Result<Self>

Builds a claim whose object is a Datum interned into store and referenced by content.

pub fn intern_object(store: &mut dyn DatumStore, object: Datum) -> Result<Ref>

Interns object into store and returns a content Ref to it.

pub fn with_kind(self, kind: ClaimKind) -> Self

Returns the claim with its ClaimKind set.

pub fn with_visibility(self, visibility: Visibility) -> Self

Returns the claim with its Visibility set.

pub fn with_evidence(self, evidence: Vec<Ref>) -> Self

Returns the claim with its evidence references replaced.

pub fn requiring(self, capability: CapabilityName) -> Self

Returns the claim with one required capability appended.

pub fn with_requirements(self, requires: Vec<CapabilityName>) -> Self

Returns the claim with its required capabilities replaced.

pub fn canonical_datum(&self) -> Datum

Returns the deterministic Datum form used to derive the content id.

pub fn content_id(&self, store: &mut dyn DatumStore) -> Result<ContentId>

Interns the claim’s canonical datum and returns its content id.

Trait Implementations

impl Clone for Claim

fn clone(&self) -> Claim

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Claim

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

Formats the value using the given formatter.

impl Eq for Claim

impl PartialEq for Claim

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