Struct Machine 

pub struct Machine<L: Law, P: Phase, D: Data> {
    pub _law: PhantomData<L>,
    pub phase: P,
    pub data: D,
}

The zero-cost typestate machine container.

Fields

_law: PhantomData<L>

phase: P

data: D

Implementations

impl Machine<AccessAdmissionLaw, Uninitialized, EmptyData>

pub fn admit_initialize( self, client_caps: Value, ) -> Machine<AccessAdmissionLaw, Initializing, InitializingData>

Transitions from Uninitialized to Initializing using the client parameters.

impl Machine<AccessAdmissionLaw, Initializing, InitializingData>

pub fn admit_initialized( self, server_caps: Value, ) -> Machine<AccessAdmissionLaw, Initialized, InitializedData>

Transitions from Initializing to Initialized once server capabilities are registered.

impl Machine<AccessAdmissionLaw, Initialized, InitializedData>

pub fn admit_shutdown(self) -> Machine<AccessAdmissionLaw, ShutDown, EmptyData>

Transitions from Initialized to ShutDown.

impl Machine<AccessAdmissionLaw, ShutDown, EmptyData>

pub fn admit_exit(self) -> Machine<AccessAdmissionLaw, Exited, EmptyData>

Transitions from ShutDown to Exited.

impl<L: Law, P: Phase, D: Data> Machine<L, P, D>

pub const fn new(phase: P, data: D) -> Self

Create a new typestate machine.

impl Machine<GraphAdmissionLaw, RAW, RawData>

pub fn admit_candidate( self, snapshot_id: &str, ) -> Result<Machine<GraphAdmissionLaw, CANDIDATE, CandidateData>, GraphAdmissionError>

impl Machine<GraphAdmissionLaw, CANDIDATE, CandidateData>

pub fn admit_admitted( self, _store: &Store, graph_name: GraphName, receipt: CryptographicReceipt, ) -> Result<Machine<GraphAdmissionLaw, ADMITTED, AdmittedData>, GraphAdmissionError>

pub fn admit_refuse( self, report: VerificationReport, ) -> Machine<GraphAdmissionLaw, REFUSED, RefusedData>

pub fn admit_quarantine( self, missing_dependencies: Vec<String>, ) -> Machine<GraphAdmissionLaw, QUARANTINED, QuarantinedData>

pub fn admit_replay( self, graph_name: GraphName, receipt: CryptographicReceipt, ) -> Machine<GraphAdmissionLaw, REPLAYED, ReplayedData>

impl Machine<GraphAdmissionLaw, ADMITTED, AdmittedData>

pub fn admit_supersede( self, superseded_by: GraphName, ) -> Machine<GraphAdmissionLaw, SUPERSEDED, SupersededData>

impl Machine<GraphAdmissionLaw, QUARANTINED, QuarantinedData>

pub fn into_candidate( self, graph_hash: String, ) -> Machine<GraphAdmissionLaw, CANDIDATE, CandidateData>

Trait Implementations

impl<L: Law, P: Phase + Clone, D: Data + Clone> Clone for Machine<L, P, D>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Law, P: Phase + Debug, D: Data + Debug> Debug for Machine<L, P, D>

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

Formats the value using the given formatter.

impl GraduateToWasm4pm for Machine<GraphAdmissionLaw, RAW, RawData>

fn candidate(&self) -> GraduationCandidate

Produce the graduation case for self.

fn is_grounded(&self) -> bool

impl GraduateToWasm4pm for Machine<GraphAdmissionLaw, CANDIDATE, CandidateData>

fn candidate(&self) -> GraduationCandidate

Produce the graduation case for self.

fn is_grounded(&self) -> bool

impl GraduateToWasm4pm for Machine<GraphAdmissionLaw, ADMITTED, AdmittedData>

fn candidate(&self) -> GraduationCandidate

Produce the graduation case for self.

fn is_grounded(&self) -> bool

impl GraduateToWasm4pm for Machine<GraphAdmissionLaw, REFUSED, RefusedData>

fn candidate(&self) -> GraduationCandidate

Produce the graduation case for self.

fn is_grounded(&self) -> bool

impl GraduateToWasm4pm for Machine<GraphAdmissionLaw, QUARANTINED, QuarantinedData>

fn candidate(&self) -> GraduationCandidate

Produce the graduation case for self.

fn is_grounded(&self) -> bool

impl GraduateToWasm4pm for Machine<GraphAdmissionLaw, SUPERSEDED, SupersededData>

fn candidate(&self) -> GraduationCandidate

Produce the graduation case for self.

fn is_grounded(&self) -> bool

impl GraduateToWasm4pm for Machine<GraphAdmissionLaw, REPLAYED, ReplayedData>

fn candidate(&self) -> GraduationCandidate

Produce the graduation case for self.

fn is_grounded(&self) -> bool

impl TypestateKernel<AccessAdmissionLaw, Exited, EmptyData> for Machine<AccessAdmissionLaw, Exited, EmptyData>

type Input = ()

type OutputPhase = Exited

type OutputData = EmptyData

type Receipt = Receipt

fn validate( &self, _input: &Self::Input, ) -> Result<(), <AccessAdmissionLaw as Law>::Error>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, _input: Self::Input, ) -> Result<Machine<AccessAdmissionLaw, Self::OutputPhase, Self::OutputData>, <AccessAdmissionLaw as Law>::Error>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> EmptyData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<AccessAdmissionLaw, Initialized, InitializedData> for Machine<AccessAdmissionLaw, Initialized, InitializedData>

type Input = ()

type OutputPhase = ShutDown

type OutputData = EmptyData

type Receipt = Receipt

fn validate( &self, _input: &Self::Input, ) -> Result<(), <AccessAdmissionLaw as Law>::Error>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<AccessAdmissionLaw, Self::OutputPhase, Self::OutputData>, <AccessAdmissionLaw as Law>::Error>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> InitializedData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<AccessAdmissionLaw, Initializing, InitializingData> for Machine<AccessAdmissionLaw, Initializing, InitializingData>

type Input = Value

type OutputPhase = Initialized

type OutputData = InitializedData

type Receipt = Receipt

fn validate( &self, _input: &Self::Input, ) -> Result<(), <AccessAdmissionLaw as Law>::Error>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<AccessAdmissionLaw, Self::OutputPhase, Self::OutputData>, <AccessAdmissionLaw as Law>::Error>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> InitializingData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<AccessAdmissionLaw, ShutDown, EmptyData> for Machine<AccessAdmissionLaw, ShutDown, EmptyData>

type Input = ()

type OutputPhase = Exited

type OutputData = EmptyData

type Receipt = Receipt

fn validate( &self, _input: &Self::Input, ) -> Result<(), <AccessAdmissionLaw as Law>::Error>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<AccessAdmissionLaw, Self::OutputPhase, Self::OutputData>, <AccessAdmissionLaw as Law>::Error>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> EmptyData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<AccessAdmissionLaw, Uninitialized, EmptyData> for Machine<AccessAdmissionLaw, Uninitialized, EmptyData>

type Input = Value

type OutputPhase = Initializing

type OutputData = InitializingData

type Receipt = Receipt

fn validate( &self, _input: &Self::Input, ) -> Result<(), <AccessAdmissionLaw as Law>::Error>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<AccessAdmissionLaw, Self::OutputPhase, Self::OutputData>, <AccessAdmissionLaw as Law>::Error>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> EmptyData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<GraphAdmissionLaw, ADMITTED, AdmittedData> for Machine<GraphAdmissionLaw, ADMITTED, AdmittedData>

type Input = GraphName

type OutputPhase = SUPERSEDED

type OutputData = SupersededData

type Receipt = CryptographicReceipt

fn validate(&self, _input: &Self::Input) -> Result<(), GraphAdmissionError>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<GraphAdmissionLaw, Self::OutputPhase, Self::OutputData>, GraphAdmissionError>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> AdmittedData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<GraphAdmissionLaw, CANDIDATE, CandidateData> for Machine<GraphAdmissionLaw, CANDIDATE, CandidateData>

type Input = CandidateAdmitInput

type OutputPhase = ADMITTED

type OutputData = AdmittedData

type Receipt = CryptographicReceipt

fn validate(&self, input: &Self::Input) -> Result<(), GraphAdmissionError>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<GraphAdmissionLaw, Self::OutputPhase, Self::OutputData>, GraphAdmissionError>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> CandidateData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<GraphAdmissionLaw, QUARANTINED, QuarantinedData> for Machine<GraphAdmissionLaw, QUARANTINED, QuarantinedData>

type Input = String

type OutputPhase = CANDIDATE

type OutputData = CandidateData

type Receipt = CryptographicReceipt

fn validate(&self, _input: &Self::Input) -> Result<(), GraphAdmissionError>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<GraphAdmissionLaw, Self::OutputPhase, Self::OutputData>, GraphAdmissionError>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> QuarantinedData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<GraphAdmissionLaw, RAW, RawData> for Machine<GraphAdmissionLaw, RAW, RawData>

type Input = String

type OutputPhase = CANDIDATE

type OutputData = CandidateData

type Receipt = CryptographicReceipt

fn validate(&self, _input: &Self::Input) -> Result<(), GraphAdmissionError>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<GraphAdmissionLaw, Self::OutputPhase, Self::OutputData>, GraphAdmissionError>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> RawData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<GraphAdmissionLaw, REFUSED, RefusedData> for Machine<GraphAdmissionLaw, REFUSED, RefusedData>

type Input = ()

type OutputPhase = REFUSED

type OutputData = RefusedData

type Receipt = CryptographicReceipt

fn validate(&self, _input: &Self::Input) -> Result<(), GraphAdmissionError>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<GraphAdmissionLaw, Self::OutputPhase, Self::OutputData>, GraphAdmissionError>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> RefusedData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<GraphAdmissionLaw, REPLAYED, ReplayedData> for Machine<GraphAdmissionLaw, REPLAYED, ReplayedData>

type Input = ()

type OutputPhase = REPLAYED

type OutputData = ReplayedData

type Receipt = CryptographicReceipt

fn validate(&self, _input: &Self::Input) -> Result<(), GraphAdmissionError>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<GraphAdmissionLaw, Self::OutputPhase, Self::OutputData>, GraphAdmissionError>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> ReplayedData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.

impl TypestateKernel<GraphAdmissionLaw, SUPERSEDED, SupersededData> for Machine<GraphAdmissionLaw, SUPERSEDED, SupersededData>

type Input = ()

type OutputPhase = SUPERSEDED

type OutputData = SupersededData

type Receipt = CryptographicReceipt

fn validate(&self, _input: &Self::Input) -> Result<(), GraphAdmissionError>

Validate the input message or action against the Law.

fn select(&self, _input: &Self::Input) -> Self::OutputPhase

Select the next state phase depending on the input.

fn admit( self, input: Self::Input, ) -> Result<Machine<GraphAdmissionLaw, Self::OutputPhase, Self::OutputData>, GraphAdmissionError>

Admit the input message and transition the machine into the target typestate.

fn receipt(&self) -> Self::Receipt

Produce a deterministic execution receipt containing the transition metadata.

fn exit(self) -> SupersededData

Destroy/Exit the current phase and yield the underlying data.

fn replay(history: Vec<Self::Receipt>) -> Result<Self, ChainError>

Reconstruct the machine state by replaying a ledger of historic receipts. Returns Err(ChainError) when the history is corrupted, malformed, or insufficient.