EntrylikeExt

willow_data_model::entry

Trait EntrylikeExt 

Source 
pub trait EntrylikeExt<const MCL: usize, const MCC: usize, const MPL: usize, N, S, PD>: Entrylike<MCL, MCC, MPL, N, S, PD> {
    // Provided methods
    fn entry_eq<OtherEntry>(&self, other: &OtherEntry) -> bool
       where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>,
             N: PartialEq,
             S: PartialEq,
             PD: PartialEq { ... }
    fn cmp_recency<OtherEntry>(&self, other: &OtherEntry) -> Ordering
       where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>,
             PD: Ord { ... }
    fn is_newer_than<OtherEntry>(&self, other: &OtherEntry) -> bool
       where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>,
             PD: Ord { ... }
    fn is_older_than<OtherEntry>(&self, other: &OtherEntry) -> bool
       where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>,
             PD: Ord { ... }
    fn prunes<OtherEntry>(&self, other: &OtherEntry) -> bool
       where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>,
             N: PartialEq,
             S: PartialEq,
             PD: Ord { ... }
    fn is_pruned_by<OtherEntry>(&self, other: &OtherEntry) -> bool
       where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>,
             N: PartialEq,
             S: PartialEq,
             PD: Ord,
             Self: Sized { ... }
}
Expand description

Methods for working with Entrylikes.

This trait is automatically implemented by all types implmenting Entrylikes.

Provided Methods§

Source

fn entry_eq<OtherEntry>(&self, other: &OtherEntry) -> bool
where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>, N: PartialEq, S: PartialEq, PD: PartialEq,

Returns whether self and other describe equal entries.

§Examples
use willow_data_model::prelude::*;
use willow_data_model::prelude::*;

let entry = Entry::builder()
    .namespace_id("family")
    .subspace_id("alfie")
    .path(Path::<4, 4, 4>::new())
    .timestamp(12345)
    .payload_digest("b")
    .payload_length(17)
    .build().unwrap();

assert!(entry.entry_eq(&entry));

let changed = Entry::prefilled_builder(&entry).timestamp(999999).build().unwrap();
assert!(!entry.entry_eq(&changed));
Source

fn cmp_recency<OtherEntry>(&self, other: &OtherEntry) -> Ordering
where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>, PD: Ord,

Compares self to another entry by timestamp, payload_digest (in case of a tie), and payload_length third (in case of yet another tie). See also EntrylikeExt::is_newer_than and EntrylikeExt::is_older_than.

Comparing recency is primarily important to determine which entries overwrite each other; the EntrylikeExt::prunes method checks for that directly.

§Examples
use core::cmp::Ordering;
use willow_data_model::prelude::*;

let entry = Entry::builder()
    .namespace_id("family")
    .subspace_id("alfie")
    .path(Path::<4, 4, 4>::new())
    .timestamp(12345)
    .payload_digest("b")
    .payload_length(17)
    .build().unwrap();

assert_eq!(entry.cmp_recency(&entry), Ordering::Equal);

let lesser_timestamp = Entry::prefilled_builder(&entry).timestamp(5).build().unwrap();
assert_eq!(entry.cmp_recency(&lesser_timestamp), Ordering::Greater);

let lesser_digest = Entry::prefilled_builder(&entry).payload_digest("a").build().unwrap();
assert_eq!(entry.cmp_recency(&lesser_digest), Ordering::Greater);

let lesser_length = Entry::prefilled_builder(&entry).payload_length(0).build().unwrap();
assert_eq!(entry.cmp_recency(&lesser_length), Ordering::Greater);

let greater_timestamp = Entry::prefilled_builder(&entry).timestamp(999999).build().unwrap();
assert_eq!(entry.cmp_recency(&greater_timestamp), Ordering::Less);

let greater_digest = Entry::prefilled_builder(&entry).payload_digest("c").build().unwrap();
assert_eq!(entry.cmp_recency(&greater_digest), Ordering::Less);

let greater_length = Entry::prefilled_builder(&entry).payload_length(99).build().unwrap();
assert_eq!(entry.cmp_recency(&greater_length), Ordering::Less);

Spec definition.

Source

fn is_newer_than<OtherEntry>(&self, other: &OtherEntry) -> bool
where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>, PD: Ord,

Returns whether this entry is strictly newer than another entry. See also EntrylikeExt::cmp_recency and EntrylikeExt::is_older_than.

Comparing recency is primarily important to determine which entries overwrite each other; the EntrylikeExt::prunes method checks for that directly.

§Examples
use willow_data_model::prelude::*;
use willow_data_model::prelude::*;

let entry = Entry::builder()
    .namespace_id("family")
    .subspace_id("alfie")
    .path(Path::<4, 4, 4>::new())
    .timestamp(12345)
    .payload_digest("b")
    .payload_length(17)
    .build().unwrap();

assert!(!entry.is_newer_than(&entry));

let lesser_timestamp = Entry::prefilled_builder(&entry).timestamp(5).build().unwrap();
assert!(entry.is_newer_than(&lesser_timestamp));

let lesser_digest = Entry::prefilled_builder(&entry).payload_digest("a").build().unwrap();
assert!(entry.is_newer_than(&lesser_digest));

let lesser_length = Entry::prefilled_builder(&entry).payload_length(0).build().unwrap();
assert!(entry.is_newer_than(&lesser_length));

let greater_timestamp = Entry::prefilled_builder(&entry).timestamp(999999).build().unwrap();
assert!(!entry.is_newer_than(&greater_timestamp));

let greater_digest = Entry::prefilled_builder(&entry).payload_digest("c").build().unwrap();
assert!(!entry.is_newer_than(&greater_digest));

let greater_length = Entry::prefilled_builder(&entry).payload_length(99).build().unwrap();
assert!(!entry.is_newer_than(&greater_length));
Source

fn is_older_than<OtherEntry>(&self, other: &OtherEntry) -> bool
where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>, PD: Ord,

Returns whether this entry is strictly older than another entry. See also EntrylikeExt::cmp_recency and EntrylikeExt::is_newer_than.

Comparing recency is primarily important to determine which entries overwrite each other; the EntrylikeExt::prunes method checks for that directly.

§Examples
use willow_data_model::prelude::*;
use willow_data_model::prelude::*;

let entry = Entry::builder()
    .namespace_id("family")
    .subspace_id("alfie")
    .path(Path::<4, 4, 4>::new())
    .timestamp(12345)
    .payload_digest("b")
    .payload_length(17)
    .build().unwrap();

assert!(!entry.is_older_than(&entry));

let lesser_timestamp = Entry::prefilled_builder(&entry).timestamp(5).build().unwrap();
assert!(!entry.is_older_than(&lesser_timestamp));

let lesser_digest = Entry::prefilled_builder(&entry).payload_digest("a").build().unwrap();
assert!(!entry.is_older_than(&lesser_digest));

let lesser_length = Entry::prefilled_builder(&entry).payload_length(0).build().unwrap();
assert!(!entry.is_older_than(&lesser_length));

let greater_timestamp = Entry::prefilled_builder(&entry).timestamp(999999).build().unwrap();
assert!(entry.is_older_than(&greater_timestamp));

let greater_digest = Entry::prefilled_builder(&entry).payload_digest("c").build().unwrap();
assert!(entry.is_older_than(&greater_digest));

let greater_length = Entry::prefilled_builder(&entry).payload_length(99).build().unwrap();
assert!(entry.is_older_than(&greater_length));
Source

fn prunes<OtherEntry>(&self, other: &OtherEntry) -> bool
where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>, N: PartialEq, S: PartialEq, PD: Ord,

Returns whether this entry would prefix prune another entry.

Prefix pruning powers deletion in Willow: whenever a data store would contain two entries, one of which pruens the other, the other is removed from the data store (or never inserted in the first place). Informally speaking, newer entries remove older entries, but only if they are in the same namespace and subspace, and only if the path of the newer entry is a prefix of the path of the older entry.

More precisely: an entry e1 prunes an entry e2 if and only if

  • e1.namespace_id() == e2.namespace_id(),
  • e1.subspace_id() == e2.subspace_id(),
  • e1.path().is_prefix_of(e2.path()), and
  • e1.is_newer_than(&e2).

This method is the reciprocal of EntrylikeExt::is_pruned_by.

§Examples
use willow_data_model::prelude::*;
use willow_data_model::prelude::*;

let entry = Entry::builder()
    .namespace_id("family")
    .subspace_id("alfie")
    .path(Path::<4, 4, 4>::from_slices(&[b"a", b"b"])?)
    .timestamp(12345)
    .payload_digest("b")
    .payload_length(17)
    .build().unwrap();

let newer = Entry::prefilled_builder(&entry).timestamp(99999).build().unwrap();
assert!(!entry.prunes(&newer));
assert!(newer.prunes(&entry));

let newer_and_prefix = Entry::prefilled_builder(&newer)
    .path(Path::<4, 4, 4>::from_slices(&[b"a"])?).build().unwrap();
assert!(!entry.prunes(&newer_and_prefix));
assert!(newer_and_prefix.prunes(&entry));

let newer_and_extension = Entry::prefilled_builder(&newer)
    .path(Path::<4, 4, 4>::from_slices(&[b"a", b"b", b"c"])?).build().unwrap();
assert!(!entry.prunes(&newer_and_extension));
assert!(!newer_and_extension.prunes(&entry));

let newer_but_unrelated_namespace = Entry::prefilled_builder(&newer)
    .namespace_id("bookclub").build().unwrap();
assert!(!entry.prunes(&newer_but_unrelated_namespace));
assert!(!newer_but_unrelated_namespace.prunes(&entry));

let newer_but_unrelated_subspace = Entry::prefilled_builder(&newer)
    .subspace_id("betty").build().unwrap();
assert!(!entry.prunes(&newer_but_unrelated_subspace));
assert!(!newer_but_unrelated_subspace.prunes(&entry));
Source

fn is_pruned_by<OtherEntry>(&self, other: &OtherEntry) -> bool
where OtherEntry: Entrylike<MCL, MCC, MPL, N, S, PD>, N: PartialEq, S: PartialEq, PD: Ord, Self: Sized,

Returns whether this entry would be prefix pruned by another entry.

Prefix pruning powers deletion in Willow: whenever a data store would contain two entries, one of which pruens the other, the other is removed from the data store (or never inserted in the first place). Informally speaking, newer entries remove older entries, but only if they are in the same namespace and subspace, and only if the path of the newer entry is a prefix of the path of the older entry.

More precisely: an entry e1 prunes an entry e2 if and only if

  • e1.namespace_id() == e2.namespace_id(),
  • e1.subspace_id() == e2.subspace_id(),
  • e1.path().is_prefix_of(e2.path()), and
  • e1.is_newer_than(&e2).

This method is the reciprocal of EntrylikeExt::prunes.

§Examples
use willow_data_model::prelude::*;
use willow_data_model::prelude::*;

let entry = Entry::builder()
    .namespace_id("family")
    .subspace_id("alfie")
    .path(Path::<4, 4, 4>::from_slices(&[b"a", b"b"])?)
    .timestamp(12345)
    .payload_digest("b")
    .payload_length(17)
    .build().unwrap();

let newer = Entry::prefilled_builder(&entry).timestamp(99999).build().unwrap();
assert!(entry.is_pruned_by(&newer));
assert!(!newer.is_pruned_by(&entry));

let newer_and_prefix = Entry::prefilled_builder(&newer)
    .path(Path::<4, 4, 4>::from_slices(&[b"a"])?).build().unwrap();
assert!(entry.is_pruned_by(&newer_and_prefix));
assert!(!newer_and_prefix.is_pruned_by(&entry));

let newer_and_extension = Entry::prefilled_builder(&newer)
    .path(Path::<4, 4, 4>::from_slices(&[b"a", b"b", b"c"])?).build().unwrap();
assert!(!entry.is_pruned_by(&newer_and_extension));
assert!(!newer_and_extension.is_pruned_by(&entry));

let newer_but_unrelated_namespace = Entry::prefilled_builder(&newer)
    .namespace_id("bookclub").build().unwrap();
assert!(!entry.is_pruned_by(&newer_but_unrelated_namespace));
assert!(!newer_but_unrelated_namespace.is_pruned_by(&entry));

let newer_but_unrelated_subspace = Entry::prefilled_builder(&newer)
    .subspace_id("betty").build().unwrap();
assert!(!entry.is_pruned_by(&newer_but_unrelated_subspace));
assert!(!newer_but_unrelated_subspace.is_pruned_by(&entry));

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§

Source§

impl<const MCL: usize, const MCC: usize, const MPL: usize, N, S, PD, E> EntrylikeExt<MCL, MCC, MPL, N, S, PD> for E
where E: Entrylike<MCL, MCC, MPL, N, S, PD>,