Struct VcState 

pub struct VcState<const N: usize, const G: usize, const P: usize> {

    pub configured: bool,
    pub epoch: b32,
    pub n: b5,
    pub me: b5,
    pub q: b5,
    pub session: b64,
    pub view: b32,
    pub rec: [[Record<P>; G]; N],
    pub sealed_from: b16,
    pub seal_hi: [b32; N],
    pub p_view: b32,
    pub p_open: b16,
    pub p_busy: bool,
    pub p_subject: b5,
    pub p_rec: [Record<P>; G],
    pub p_j: b4,
    pub p_sent: bool,
    pub p_acc: [b64; 4],
    pub p_have: bool,
    pub p_sign_out: bool,
    pub p_signed: bool,
    pub p_sig: [b64; 8],
    pub p_key_out: bool,
    pub p_keyed: bool,
    pub p_own_given: bool,
    pub p_shared: bool,
    pub skip_pending: bool,
    pub in_skipped: bool,
    pub late_done: bool,
    pub prev_open_done: b16,
    pub dirty: b16,
    pub tainted: b16,
    pub sealing: bool,
    pub seal_sent: bool,
    pub chain_busy: bool,
    pub chain_subject: b5,
    pub chain_j: b4,
    pub chain_sent: bool,
    pub chain_acc: [b64; 4],
    pub hdone: b16,
    pub hdigest: [[b64; 4]; N],
    pub opened: b16,
    pub open_done: b16,
    pub sign_sent: b16,
    pub signed: b16,
    pub hsig: [[b64; 8]; N],
    pub own_given: b16,
    pub shared: b16,
    pub nv_sent: bool,
    pub clock: b32,
    pub seal_at: b32,
    pub nv_deadline: b32,
    pub installed_next: bool,
    pub h_ctb: ConsMsg<P>,
    pub h_dig: VcDigestReq,
    pub h_sign: VcSignReq,
    pub h_open: VcKey,
    pub h_own: VcKey,
    pub h_share: VcKey,
    pub h_inst: Install<G, P>,
    pub refused: b32,
}

State.

Fields

configured: bool

epoch: b32

n: b5

me: b5

q: b5

session: b64

view: b32

rec: [[Record<P>; G]; N]

sealed_from: b16

SEALVIEW(view) seen from these replicas (a seal of a later view counts: that replica has left this view, R-28).

seal_hi: [b32; N]

Per replica, one plus the highest view it sealed (0: none). Kept across views so a replica that ran ahead still counts (R-28).

p_view: b32

R-28: the view we left, for subjects that seal it after we did. Each such subject’s view-p_view history is complete exactly at its own SEALVIEW(p_view) (CTB is FIFO): its records are copied that cycle into p_rec and chained and shared from the copy only.

p_open: b16

p_busy: bool

p_subject: b5

p_rec: [Record<P>; G]

p_j: b4

p_sent: bool

p_acc: [b64; 4]

p_have: bool

p_sign_out: bool

p_signed: bool

p_sig: [b64; 8]

p_key_out: bool

Our own key and share for the late subject go into our own history collector too (so a late NEWVIEW naming it can be judged here).

p_keyed: bool

p_own_given: bool

p_shared: bool

skip_pending: bool

R-28 late install: we issued a skip; we entered this view by skip; a late NEWVIEW for it was taken; the previous view’s opened keys.

in_skipped: bool

late_done: bool

prev_open_done: b16

dirty: b16

R-31: subjects whose records changed since their history digest was taken (set on every record write; cleared when a chain or a late copy starts from the current records).

tainted: b16

Subjects with a gap in their CTB stream here: never vouched for.

sealing: bool

seal_sent: bool

chain_busy: bool

History digests: chain progress per subject, and done flags.

chain_subject: b5

chain_j: b4

chain_sent: bool

chain_acc: [b64; 4]

hdone: b16

hdigest: [[b64; 4]; N]

opened: b16

open_done: b16

The history collector took our key for this view (only then does its status speak for this view, not a previous one).

sign_sent: b16

signed: b16

hsig: [[b64; 8]; N]

own_given: b16

shared: b16

nv_sent: bool

clock: b32

seal_at: b32

nv_deadline: b32

installed_next: bool

The next view’s NEWVIEW was accepted.

h_ctb: ConsMsg<P>

h_dig: VcDigestReq

h_sign: VcSignReq

h_open: VcKey

h_own: VcKey

h_share: VcKey

h_inst: Install<G, P>

refused: b32

Implementations

impl<const N: usize, const G: usize, const P: usize> VcState<N, G, P>

pub fn idle() -> Self

Trait Implementations

impl<const N: usize, const G: usize, const P: usize> Clone for VcState<N, G, P>

fn clone(&self) -> VcState<N, G, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, const G: usize, const P: usize> Debug for VcState<N, G, P>

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

Formats the value using the given formatter.

impl<const N: usize, const G: usize, const P: usize> Default for VcState<N, G, P>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize, const G: usize, const P: usize> Digital for VcState<N, G, P>

const BITS: usize

Associated constant that gives the total number of bits needed to represent the value.

fn static_kind() -> Kind

Returns the [Kind] (run time type descriptor) of the value as a static method

fn bin(self) -> Box<[BitX]>

Returns the binary representation of the value as a vector of [BitX].

fn dont_care() -> Self

Returns a “don’t care” value for the type.

fn bits() -> usize

Returns the number of bits needed to represent the value.

fn kind(&self) -> Kind

Returns the [Kind] (run time type descriptor) of the value.

fn typed_bits(self) -> TypedBits

Returns the value as a [TypedBits], which includes both the bits and the kind.

fn discriminant(self) -> TypedBits

Returns the discriminant of the value as a [TypedBits].

fn variant_kind(self) -> Kind

Returns the [Kind] of the variant if the value is an enum with variants.

fn binary_string(self) -> String

Returns the binary representation of the value as a string of ‘0’, ‘1’, and ‘X’.

impl<const N: usize, const G: usize, const P: usize> PartialEq for VcState<N, G, P>

fn eq(&self, other: &VcState<N, G, P>) -> 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<const N: usize, const G: usize, const P: usize> Copy for VcState<N, G, P>

impl<const N: usize, const G: usize, const P: usize> StructuralPartialEq for VcState<N, G, P>