Enum Message 

#[non_exhaustive]
pub enum Message<I, A> {
    Ping(Ping<I, A>),
    IndirectPing(IndirectPing<I, A>),
    Ack(Ack),
    Suspect(Suspect<I>),
    Alive(Alive<I, A>),
    Dead(Dead<I>),
    PushPull(PushPull<I, A>),
    UserData(Bytes),
    Nack(Nack),
    ErrorResponse(ErrorResponse),
}

Request to be sent to the Raft node.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Ping(Ping<I, A>)

Ping message

IndirectPing(IndirectPing<I, A>)

Indirect ping message

Ack(Ack)

Ack response message

Suspect(Suspect<I>)

Suspect message

Alive(Alive<I, A>)

Alive message

Dead(Dead<I>)

Dead message

PushPull(PushPull<I, A>)

PushPull message

UserData(Bytes)

User mesg, not handled by us

Nack(Nack)

Nack response message

ErrorResponse(ErrorResponse)

Error response message

Implementations

impl<I, A> Message<I, A>

pub const PING_TAG: u8 = 1u8

The tag of Ping message.

pub const INDIRECTPING_TAG: u8 = 2u8

The tag of IndirectPing message.

pub const ACK_TAG: u8 = 3u8

The tag of Ack message.

pub const SUSPECT_TAG: u8 = 4u8

The tag of Suspect message.

pub const ALIVE_TAG: u8 = 5u8

The tag of Alive message.

pub const DEAD_TAG: u8 = 6u8

The tag of Dead message.

pub const PUSHPULL_TAG: u8 = 7u8

The tag of PushPull message.

pub const USERDATA_TAG: u8 = 8u8

The tag of Bytes message.

pub const NACK_TAG: u8 = 9u8

The tag of Nack message.

pub const ERRORRESPONSE_TAG: u8 = 10u8

The tag of ErrorResponse message.

pub const fn tag(&self) -> u8

Returns the tag of this message type for encoding/decoding.

pub const fn kind(&self) -> &'static str

Returns the kind of this message.

pub fn unwrap_ping(self) -> Ping<I, A>

Returns the contained Ping message, consuming the self value. Panics if the value is not Ping.

pub fn try_unwrap_ping(self) -> Option<Ping<I, A>>

Returns the contained Ping message, consuming the self value. Returns None if the value is not Ping.

pub const fn ping(val: Ping<I, A>) -> Self

Construct a Message from Ping.

pub fn unwrap_indirect_ping(self) -> IndirectPing<I, A>

Returns the contained IndirectPing message, consuming the self value. Panics if the value is not IndirectPing.

pub fn try_unwrap_indirect_ping(self) -> Option<IndirectPing<I, A>>

Returns the contained IndirectPing message, consuming the self value. Returns None if the value is not IndirectPing.

pub const fn indirect_ping(val: IndirectPing<I, A>) -> Self

Construct a Message from IndirectPing.

pub fn unwrap_ack(self) -> Ack

Returns the contained Ack message, consuming the self value. Panics if the value is not Ack.

pub fn try_unwrap_ack(self) -> Option<Ack>

Returns the contained Ack message, consuming the self value. Returns None if the value is not Ack.

pub const fn ack(val: Ack) -> Self

Construct a Message from Ack.

pub fn unwrap_suspect(self) -> Suspect<I>

Returns the contained Suspect message, consuming the self value. Panics if the value is not Suspect.

pub fn try_unwrap_suspect(self) -> Option<Suspect<I>>

Returns the contained Suspect message, consuming the self value. Returns None if the value is not Suspect.

pub const fn suspect(val: Suspect<I>) -> Self

Construct a Message from Suspect.

pub fn unwrap_alive(self) -> Alive<I, A>

Returns the contained Alive message, consuming the self value. Panics if the value is not Alive.

pub fn try_unwrap_alive(self) -> Option<Alive<I, A>>

Returns the contained Alive message, consuming the self value. Returns None if the value is not Alive.

pub const fn alive(val: Alive<I, A>) -> Self

Construct a Message from Alive.

pub fn unwrap_dead(self) -> Dead<I>

Returns the contained Dead message, consuming the self value. Panics if the value is not Dead.

pub fn try_unwrap_dead(self) -> Option<Dead<I>>

Returns the contained Dead message, consuming the self value. Returns None if the value is not Dead.

pub const fn dead(val: Dead<I>) -> Self

Construct a Message from Dead.

pub fn unwrap_push_pull(self) -> PushPull<I, A>

Returns the contained PushPull message, consuming the self value. Panics if the value is not PushPull.

pub fn try_unwrap_push_pull(self) -> Option<PushPull<I, A>>

Returns the contained PushPull message, consuming the self value. Returns None if the value is not PushPull.

pub const fn push_pull(val: PushPull<I, A>) -> Self

Construct a Message from PushPull.

pub fn unwrap_user_data(self) -> Bytes

Returns the contained Bytes message, consuming the self value. Panics if the value is not Bytes.

pub fn try_unwrap_user_data(self) -> Option<Bytes>

Returns the contained Bytes message, consuming the self value. Returns None if the value is not Bytes.

pub const fn user_data(val: Bytes) -> Self

Construct a Message from Bytes.

pub fn unwrap_nack(self) -> Nack

Returns the contained Nack message, consuming the self value. Panics if the value is not Nack.

pub fn try_unwrap_nack(self) -> Option<Nack>

Returns the contained Nack message, consuming the self value. Returns None if the value is not Nack.

pub const fn nack(val: Nack) -> Self

Construct a Message from Nack.

pub fn unwrap_error_response(self) -> ErrorResponse

Returns the contained ErrorResponse message, consuming the self value. Panics if the value is not ErrorResponse.

pub fn try_unwrap_error_response(self) -> Option<ErrorResponse>

Returns the contained ErrorResponse message, consuming the self value. Returns None if the value is not ErrorResponse.

pub const fn error_response(val: ErrorResponse) -> Self

Construct a Message from ErrorResponse.

impl<I, A> Message<I, A>

pub const RESERVED_TAG_RANGE: RangeInclusive<u8>

Defines the range of reserved tags for message types.

This constant specifies a range of tag values that are reserved for internal use by the Message enum variants. When implementing custom with Wire or Transport, it is important to ensure that any custom header added to the message bytes does not start with a tag value within this reserved range.

The reserved range is 0..=128, meaning that the first byte of any custom message must not fall within this range to avoid conflicts with predefined message types.

Note

Adhering to this constraint is crucial for ensuring that custom messages are correctly distinguishable from the standard messages defined by the Message enum. Failing to do so may result in incorrect message parsing and handling.

pub const COMPOUND_TAG: u8 = 0u8

Returns the tag of the compound message type for encoding/decoding.

Trait Implementations

impl<I: Clone, A: Clone> Clone for Message<I, A>

fn clone(&self) -> Message<I, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, A: Debug> Debug for Message<I, A>

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

Formats the value using the given formatter.

impl<'de, I, A> Deserialize<'de> for Message<I, A>

where I: Deserialize<'de>, A: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I, A> From<Ack> for Message<I, A>

fn from(value: Ack) -> Self

Converts to this type from the input type.

impl<I, A> From<Alive<I, A>> for Message<I, A>

fn from(value: Alive<I, A>) -> Self

Converts to this type from the input type.

impl<I, A> From<Bytes> for Message<I, A>

fn from(value: Bytes) -> Self

Converts to this type from the input type.

impl<I, A> From<Dead<I>> for Message<I, A>

fn from(value: Dead<I>) -> Self

Converts to this type from the input type.

impl<I, A> From<ErrorResponse> for Message<I, A>

fn from(value: ErrorResponse) -> Self

Converts to this type from the input type.

impl<I, A> From<IndirectPing<I, A>> for Message<I, A>

fn from(value: IndirectPing<I, A>) -> Self

Converts to this type from the input type.

impl<I, A> From<Nack> for Message<I, A>

fn from(value: Nack) -> Self

Converts to this type from the input type.

impl<I, A> From<Ping<I, A>> for Message<I, A>

fn from(value: Ping<I, A>) -> Self

Converts to this type from the input type.

impl<I, A> From<PushPull<I, A>> for Message<I, A>

fn from(value: PushPull<I, A>) -> Self

Converts to this type from the input type.

impl<I, A> From<Suspect<I>> for Message<I, A>

fn from(value: Suspect<I>) -> Self

Converts to this type from the input type.

impl<I: Hash, A: Hash> Hash for Message<I, A>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I: PartialEq, A: PartialEq> PartialEq for Message<I, A>

fn eq(&self, other: &Message<I, 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<I, A> Serialize for Message<I, A>

where I: Serialize, A: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I, A> Transformable for Message<I, A>

where I: Transformable + Debug, A: Transformable + Debug,

type Error = MessageTransformError<I, A>

The error type returned when encoding or decoding fails.

fn encode(&self, dst: &mut [u8]) -> Result<usize, Self::Error>

Encodes the value into the given buffer for transmission.

fn encoded_len(&self) -> usize

Returns the encoded length of the value. This is used to pre-allocate a buffer for encoding.

fn decode(src: &[u8]) -> Result<(usize, Self), Self::Error>

where Self: Sized,

Decodes the value from the given buffer received over the wire.

fn decode_from_reader<R: Read>(reader: &mut R) -> Result<(usize, Self)>

where Self: Sized,

Available on crate feature std only.

Decodes the value from the given reader received over the wire.

async fn decode_from_async_reader<R: AsyncRead + Send + Unpin>( reader: &mut R, ) -> Result<(usize, Self)>

where Self: Sized,

Available on crate feature async only.

Decodes the value from the given async reader received over the wire.

fn encode_to_vec(&self) -> Result<Vec<u8>, Self::Error>

Available on crate features alloc or std only.

Encodes the value into a vec for transmission.

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

Available on crate feature std only.

Encodes the value into the given writer for transmission.

fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> impl Future<Output = Result<usize, Error>> + Send

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

Encodes the value into the given async writer for transmission.

impl<I: Eq, A: Eq> Eq for Message<I, A>

impl<I, A> StructuralPartialEq for Message<I, A>