Enum ruserf_types::SerfMessageRef

pub enum SerfMessageRef<'a, I, A> {
    Leave(&'a LeaveMessage<I>),
    Join(&'a JoinMessage<I>),
    PushPull(PushPullMessageRef<'a, I>),
    UserEvent(&'a UserEventMessage),
    Query(&'a QueryMessage<I, A>),
    QueryResponse(&'a QueryResponseMessage<I, A>),
    ConflictResponse(&'a Member<I, A>),
    KeyRequest(&'a KeyRequestMessage),
    KeyResponse(&'a KeyResponseMessage),
}

The reference type of SerfMessage.

Variants

Leave(&'a LeaveMessage<I>)

Leave message reference

Join(&'a JoinMessage<I>)

Join message reference

PushPull(PushPullMessageRef<'a, I>)

PushPull message reference

UserEvent(&'a UserEventMessage)

UserEvent message reference

Query(&'a QueryMessage<I, A>)

Query message reference

QueryResponse(&'a QueryResponseMessage<I, A>)

QueryResponse message reference

ConflictResponse(&'a Member<I, A>)

ConflictResponse message reference

KeyRequest(&'a KeyRequestMessage)

KeyRequest message reference

KeyResponse(&'a KeyResponseMessage)

KeyResponse message reference

Trait Implementations

impl<'a, I, A> AsMessageRef<I, A> for SerfMessageRef<'a, I, A>

fn as_message_ref(&self) -> SerfMessageRef<'_, I, A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, I, A> Clone for SerfMessageRef<'a, I, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, I: Debug, A: Debug> Debug for SerfMessageRef<'a, I, A>

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

Formats the value using the given formatter.

impl<'a, I, A> Encodable for SerfMessageRef<'a, I, A>

where I: Transformable + Hash + Eq, A: Transformable + Hash + Eq,

type Error = SerfMessageTransformError<I, A>

The error type returned when encoding or decoding fails.

fn encoded_len(&self) -> usize

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

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

Encodes the value into the given buffer for transmission.

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

Encodes the value into a vec for transmission.

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

where W: Write,

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,

Encodes the value into the given async writer for transmission.

impl<'a, I, A> Copy for SerfMessageRef<'a, I, A>