Struct Record 

pub struct Record<'a> { /* private fields */ }

A single audited event in the chain.

A record is intentionally borrowed: its string fields point at caller memory. This keeps the append hot path allocation-free. Sinks that need to persist a record across the lifetime of the borrow must encode it before returning.

Example

use audit_trail::{Action, Actor, Digest, Outcome, Record, RecordId, Target, Timestamp};

let record = Record::new(
    RecordId::GENESIS,
    Timestamp::from_nanos(0),
    Actor::new("system"),
    Action::new("chain.init"),
    Target::new("chain:0"),
    Outcome::Success,
    Digest::ZERO,
    Digest::ZERO,
);
assert_eq!(record.actor().as_str(), "system");

Implementations

impl<'a> Record<'a>

pub const fn new( id: RecordId, timestamp: Timestamp, actor: Actor<'a>, action: Action<'a>, target: Target<'a>, outcome: Outcome, prev_hash: Digest, hash: Digest, ) -> Self

Construct a record from its constituent parts.

The crate’s crate::Chain is normally responsible for producing records. This constructor is exposed so that custom storage layers and verifiers can reconstruct records when reading them back.

pub const fn with_hash(self, hash: Digest) -> Self

Return a copy of this record with hash replaced.

Useful when constructing a record in two steps: build a draft with a placeholder hash (typically Digest::ZERO), feed it through a hasher to derive its real digest, then swap the hash in.

pub const fn id(&self) -> RecordId

Record identifier.

pub const fn timestamp(&self) -> Timestamp

Record timestamp.

pub const fn actor(&self) -> Actor<'a>

The actor (who).

pub const fn action(&self) -> Action<'a>

The action (what).

pub const fn target(&self) -> Target<'a>

The target (where).

pub const fn outcome(&self) -> Outcome

The outcome (result).

pub const fn prev_hash(&self) -> Digest

Hash of the immediately preceding record in the chain.

For the genesis record this is Digest::ZERO.

pub const fn hash(&self) -> Digest

Hash of this record, computed over all other fields.

Trait Implementations

impl<'a> Clone for Record<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Record<'a>

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

Formats the value using the given formatter.

impl From<&Record<'_>> for OwnedRecord

Available on crate feature alloc only.

fn from(record: &Record<'_>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for Record<'a>

fn eq(&self, other: &Record<'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 Record<'a>

impl<'a> Eq for Record<'a>

impl<'a> StructuralPartialEq for Record<'a>