Enum aper::sync::messages::MessageToClient

pub enum MessageToClient<S>
where
    S: StateMachine,
{
    SetState {
        state: S,
        version: StateVersionNumber,
    },
    PeerTransition {
        transition: S::Transition,
        version: StateVersionNumber,
    },
    ConfirmTransition {
        transition_number: ClientTransitionNumber,
        version: StateVersionNumber,
    },
    Conflict {
        transition_number: ClientTransitionNumber,
        conflict: S::Conflict,
    },
}

Variants

SetState

Set local state. Resets transition counter and empties local optimistic transitions.

Fields

state: S

version: StateVersionNumber

PeerTransition

Apply a transition made by a peer.

Fields

transition: S::Transition

version: StateVersionNumber

ConfirmTransition

Acknowledge a transition made by this replica.

Fields

transition_number: ClientTransitionNumber

version: StateVersionNumber

Conflict

State that a transition made by this replica caused a conflict and will not be processed.

Fields

transition_number: ClientTransitionNumber

conflict: S::Conflict

Trait Implementations

impl<S> Debug for MessageToClient<S>

where S: StateMachine + Debug, S::Transition: Debug, S::Conflict: Debug,

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for MessageToClient<S>

where S: StateMachine, S::Transition: Deserialize<'de>, S::Conflict: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> PartialEq for MessageToClient<S>

where S: StateMachine + PartialEq, S::Transition: PartialEq, S::Conflict: PartialEq,

fn eq(&self, other: &MessageToClient<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> Serialize for MessageToClient<S>

where S: StateMachine, S::Transition: Serialize, S::Conflict: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S> StructuralPartialEq for MessageToClient<S>

where S: StateMachine,