Struct Entry

pub struct Entry<'a, K, V>
where
    K: ?Sized + Type,
    V: ?Sized + Type,
{ /* private fields */ }

Available on crate feature bounded only.

An entry in the Memtable.

Implementations

impl<'a, K, V> Entry<'a, K, V>

where K: ?Sized + Type, V: ?Sized + Type,

pub fn key(&self) -> &K::Ref<'a>

Returns the key of the entry.

pub fn value(&self) -> &V::Ref<'a>

Returns the value of the entry.

pub const fn version(&self) -> u64

Returns the version of the entry.

impl<K, V> Entry<'_, K, V>

where K: ?Sized + Type + 'static, for<'a> K::Ref<'a>: KeyRef<'a, K>, V: ?Sized + Type + 'static,

pub fn next(&self) -> Option<Self>

Returns the next entry in the Memtable.

use memorable::bounded::{generic::Memtable, Options};
use core::ops::Bound;

let memtable: Memtable<usize, str> = Options::new().alloc().unwrap();

memtable.insert(0, &1, "one").unwrap();
memtable.insert(0, &2, "two").unwrap();
memtable.insert(0, &3, "three").unwrap();
memtable.insert(0, &4, "four").unwrap();

memtable.remove_range::<usize, _>(1, (Bound::Excluded(&1), Bound::Unbounded)).unwrap();

memtable.update_range::<usize, _>(2, (Bound::Unbounded, Bound::Included(&2)), "updated").unwrap();

// At view 0, the memtable contains 4 entries.
let mut num = 0;
let mut ent = memtable.first(0);
while let Some(entry) = ent {
  assert_eq!(entry.key(), &(num + 1));
  num += 1;
  ent = entry.next();
}
assert_eq!(num, 4);

// At view 1, the memtable contains 1 entry because of remove_range..
let mut num = 0;
let mut ent = memtable.first(1);
while let Some(entry) = ent {
  assert_eq!(entry.key(), &(num + 1));
  assert_eq!(*entry.value(), "one");
  ent = entry.next();
  num += 1;
}
assert_eq!(num, 1);

// At view 2, the memtable contains 1 entry because of update_range, and the value is updated because of the update_range.
let mut num = 0;
let mut ent = memtable.first(2);
while let Some(entry) = ent {
  assert_eq!(entry.key(), &(num + 1));
  assert_eq!(*entry.value(), "updated");
  ent = entry.next();
  num += 1;
}
assert_eq!(num, 1);

pub fn prev(&self) -> Option<Self>

Returns the previous entry in the Memtable.

use memorable::bounded::{generic::Memtable, Options};
use core::ops::Bound;

let memtable: Memtable<usize, str> = Options::new().alloc().unwrap();

memtable.insert(0, &1, "one").unwrap();
memtable.insert(0, &2, "two").unwrap();
memtable.insert(0, &3, "three").unwrap();
memtable.insert(0, &4, "four").unwrap();

memtable.remove_range::<usize, _>(1, (Bound::Unbounded, Bound::Included(&3))).unwrap();

memtable.update_range::<usize, _>(2, (Bound::Included(&2), Bound::Unbounded), "updated").unwrap();

// At view 0, the memtable contains 4 entries.
let mut num = 4;
let mut ent = memtable.last(0);
while let Some(entry) = ent {
  assert_eq!(entry.key(), &num);
  ent = entry.prev();
  num -= 1;
}
assert_eq!(num, 0);

// At view 1, the memtable only contains 4 because of remove_range.
let mut num = 0;
let mut ent = memtable.last(1);
while let Some(entry) = ent {
  assert_eq!(entry.key(), &4);
  assert_eq!(*entry.value(), "four");
  ent = entry.prev();
  num += 1;
}
assert_eq!(num, 1);

// At view 2, the memtable only contains 4 because of update_range, and the value is updated because of the update_range.
let mut num = 0;
let mut ent = memtable.last(2);
while let Some(entry) = ent {
  assert_eq!(entry.key(), &4);
  assert_eq!(*entry.value(), "updated");
  ent = entry.prev();
  num += 1;
}
assert_eq!(num, 1);

Trait Implementations

impl<K, V> Clone for Entry<'_, K, V>

where K: ?Sized + Type, V: ?Sized + Type,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for Entry<'_, K, V>

where K: Debug + Type + ?Sized, V: Debug + Type + ?Sized,

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

Formats the value using the given formatter.