Struct raftbare::LogEntries

pub struct LogEntries { /* private fields */ }

Log entries.

This representation is compact and only requires O(|terms|) + O(|configs|) memory, where |terms| is the number of LogEntry::Term entries and |configs| is the number of LogEntry::ClusterConfig entries.

Implementations

impl LogEntries

pub const fn new(prev_position: LogPosition) -> Self

Makes a new empty LogEntries instance at the given position.

Examples

use raftbare::{LogEntries, LogEntry, LogPosition};

let entries = LogEntries::new(LogPosition::ZERO);
assert!(entries.is_empty());
assert_eq!(entries.len(), 0);
assert_eq!(entries.iter().count(), 0);
assert_eq!(entries.prev_position(), LogPosition::ZERO);
assert_eq!(entries.last_position(), LogPosition::ZERO);

pub fn from_iter<I>(prev_position: LogPosition, entries: I) -> Self

where I: IntoIterator<Item = LogEntry>,

Makes a new LogEntries instance with the given entries.

Examples

use raftbare::{LogEntries, LogEntry, LogIndex, LogPosition, Term};

let entries = LogEntries::from_iter(
    LogPosition::ZERO,
    vec![
        LogEntry::Term(Term::ZERO),
        LogEntry::Command,
        LogEntry::Command,
    ],
);
assert!(!entries.is_empty());
assert_eq!(entries.len(), 3);
assert_eq!(entries.iter().count(), 3);
assert_eq!(entries.prev_position(), LogPosition::ZERO);
assert_eq!(entries.last_position(), LogPosition { term: Term::ZERO, index: LogIndex::new(3) });

pub fn len(&self) -> usize

Returns the number of entries in this LogEntries instance.

pub fn is_empty(&self) -> bool

Returns true if the log entries is empty (i.e., the previous and last positions are the same).

pub fn prev_position(&self) -> LogPosition

Returns the position immediately before the first entry in this LogEntries instance.

pub fn last_position(&self) -> LogPosition

Returns the position of the last entry in this LogEntries instance.

pub fn iter(&self) -> impl '_ + Iterator<Item = LogEntry>

Returns an iterator over the entries in this LogEntries instance.

pub fn iter_with_positions( &self, ) -> impl '_ + Iterator<Item = (LogPosition, LogEntry)>

Returns an iterator over the entries in this LogEntries instance with their positions.

Examples

use raftbare::{LogEntries, LogEntry, LogIndex, LogPosition, Term};

let mut entries = LogEntries::new(LogPosition::ZERO);
entries.push(LogEntry::Command);
entries.push(LogEntry::Term(Term::new(1)));
entries.push(LogEntry::Command);

fn pos(term: u64, index: u64) -> LogPosition {
    LogPosition { term: Term::new(term), index: LogIndex::new(index) }
}

let mut iter = entries.iter_with_positions();
assert_eq!(iter.next(), Some((pos(0, 1), LogEntry::Command)));
assert_eq!(iter.next(), Some((pos(1, 2), LogEntry::Term(Term::new(1)))));
assert_eq!(iter.next(), Some((pos(1, 3), LogEntry::Command)));
assert_eq!(iter.next(), None);

pub fn contains(&self, position: LogPosition) -> bool

Returns true if the given position is within the range of this entries.

Examples

use raftbare::{LogEntries, LogEntry, LogIndex, LogPosition, Term};

fn pos(term: u64, index: u64) -> LogPosition {
    LogPosition { term: Term::new(term), index: LogIndex::new(index) }
}

let entries = LogEntries::from_iter(
    LogPosition::ZERO,
    vec![
        LogEntry::Term(Term::ZERO),
        LogEntry::Command,
        LogEntry::Term(Term::new(1)),
        LogEntry::Command,
    ],
);
assert!(entries.contains(pos(0, 0))); // Including the previous position
assert!(entries.contains(pos(1, 4))); // Including the last position
assert!(!entries.contains(pos(0, 4))); // Index is within the range but term is different
assert!(!entries.contains(pos(1, 5))); // Index is out of range

pub fn contains_index(&self, index: LogIndex) -> bool

Returns true if the given index is within the range of this entries.

Unlike LogEntries::contains(), this method does not check the term of the given index.

Examples

use raftbare::{LogEntries, LogEntry, LogIndex, LogPosition, Term};

let entries = LogEntries::from_iter(
    LogPosition::ZERO,
    vec![
        LogEntry::Term(Term::ZERO),
        LogEntry::Command,
        LogEntry::Term(Term::new(1)),
        LogEntry::Command,
    ],
);
assert!(entries.contains_index(LogIndex::ZERO)); // Including the previous index
assert!(entries.contains_index(LogIndex::new(1)));
assert!(entries.contains_index(LogIndex::new(4))); // Including the last index
assert!(!entries.contains_index(LogIndex::new(5)));

pub fn get_term(&self, index: LogIndex) -> Option<Term>

Returns the term of the given index if it is within the range of this entries.

pub fn get_entry(&self, index: LogIndex) -> Option<LogEntry>

Returns the entry at the given index if it is within the range of this entries.

Note that if the index is equal to the previous index, this method returns None.

Examples

use raftbare::{LogEntries, LogEntry, LogIndex, LogPosition, Term};

let entries = LogEntries::from_iter(
    LogPosition::ZERO,
    vec![
        LogEntry::Term(Term::ZERO),
        LogEntry::Command,
        LogEntry::Term(Term::new(1)),
    ],
);
assert_eq!(entries.get_entry(LogIndex::ZERO), None);
assert_eq!(entries.get_entry(LogIndex::new(1)), Some(LogEntry::Term(Term::ZERO)));
assert_eq!(entries.get_entry(LogIndex::new(2)), Some(LogEntry::Command));
assert_eq!(entries.get_entry(LogIndex::new(3)), Some(LogEntry::Term(Term::new(1))));
assert_eq!(entries.get_entry(LogIndex::new(4)), None);

pub fn push(&mut self, entry: LogEntry)

Appends an entry to the back of this entries.

Examples

use raftbare::{LogEntries, LogEntry, LogIndex, LogPosition, Term};

let mut entries = LogEntries::new(LogPosition::ZERO);
entries.push(LogEntry::Term(Term::ZERO));
entries.push(LogEntry::Command);

assert_eq!(entries.get_entry(LogIndex::new(1)), Some(LogEntry::Term(Term::ZERO)));
assert_eq!(entries.last_position(), LogPosition { term: Term::ZERO, index: LogIndex::new(2) });

pub fn truncate(&mut self, len: usize)

Shortens the entries, keeping the first len entries and dropping the rest. If len is greater or equal to LogEntries::len(), this has no effect.

Examples

use raftbare::{LogEntries, LogEntry, LogIndex, LogPosition, Term};

let mut entries = LogEntries::new(LogPosition::ZERO);
entries.push(LogEntry::Term(Term::ZERO));
entries.push(LogEntry::Command);
entries.push(LogEntry::Term(Term::new(1)));
assert_eq!(entries.len(), 3);

// No effect.
entries.truncate(3);
assert_eq!(entries.len(), 3);

// Drop the last two entries.
entries.truncate(1);
assert_eq!(entries.len(), 1);
assert_eq!(entries.get_entry(LogIndex::new(1)), Some(LogEntry::Term(Term::ZERO)));
assert_eq!(entries.get_entry(LogIndex::new(2)), None);

// Drop all entries.
entries.truncate(0);
assert_eq!(entries.len(), 0);
assert_eq!(entries.get_entry(LogIndex::new(1)), None);

Trait Implementations

impl Clone for LogEntries

fn clone(&self) -> LogEntries

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogEntries

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

Formats the value using the given formatter.

impl Extend<LogEntry> for LogEntries

fn extend<T: IntoIterator<Item = LogEntry>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Hash for LogEntries

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 LogEntries

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

impl StructuralPartialEq for LogEntries