Enum EntryKind 

pub enum EntryKind {
    Normal,
    Config,
}

What a LogEntry carries.

Most entries are Normal application commands. A Config entry instead carries a cluster configuration — the voting membership — and drives a membership change; its command bytes encode the new member set rather than an application command, so the protocol interprets them and the application does not apply them.

Examples

use raft_io::{EntryKind, LogEntry};

assert_eq!(LogEntry::new(1, 1, vec![]).kind, EntryKind::Normal);
assert_eq!(LogEntry::config(1, 2, &[1, 2, 3]).kind, EntryKind::Config);

Variants

Normal

An ordinary application command, applied to the state machine.

Config

A cluster-configuration change. The command bytes encode the new voting membership; the protocol adopts it and never applies it to the state machine.

Trait Implementations

impl Clone for EntryKind

fn clone(&self) -> EntryKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EntryKind

impl Debug for EntryKind

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

Formats the value using the given formatter.

impl Default for EntryKind

fn default() -> EntryKind

Returns the “default value” for a type.

impl Deserialize for EntryKind

fn deserialize<__D: Decode + ?Sized>(__decoder: &mut __D) -> Result<Self>

Read a value of Self from the decoder, advancing its cursor.

fn deserialize_many<D>( decoder: &mut D, count: usize, ) -> Result<Vec<Self>, SerialError>

where D: Decode + ?Sized,

Read count consecutive Self values into a freshly-allocated Vec.

impl Eq for EntryKind

impl Hash for EntryKind

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 PartialEq for EntryKind

fn eq(&self, other: &EntryKind) -> 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 Serialize for EntryKind

fn serialize<__E: Encode + ?Sized>(&self, __encoder: &mut __E) -> Result<()>

Append the encoded bytes of self to encoder.

fn serialize_slice<E>( slice: &[Self], encoder: &mut E, ) -> Result<(), SerialError>

where E: Encode + ?Sized, Self: Sized,

Append the encoded bytes of every element of slice to encoder.

impl StructuralPartialEq for EntryKind