#![deny(unsafe_op_in_unsafe_fn, clippy::undocumented_unsafe_blocks)]
use std::ops::Deref;
use std::ptr::NonNull;
use crate::guard::GuardHandle;
use crate::versioned::node::{VersionNode, VersionedLeaf};
use crate::versioned::tree::{find_le, VersionedTree};
pub struct VersionedEntryRef<'a, K, V> {
pub(crate) leaf: NonNull<VersionedLeaf<K, V>>,
pub(crate) node: NonNull<VersionNode<V>>,
pub(crate) tree: &'a VersionedTree<K, V>,
pub(crate) guard: GuardHandle<'a>,
}
impl<'a, K, V> VersionedEntryRef<'a, K, V> {
#[inline]
pub(crate) fn new(
leaf: NonNull<VersionedLeaf<K, V>>,
node: &VersionNode<V>,
tree: &'a VersionedTree<K, V>,
guard: GuardHandle<'a>,
) -> Option<Self> {
if node.is_tombstone() {
return None;
}
Some(Self {
leaf,
node: NonNull::from(node),
tree,
guard,
})
}
#[inline]
fn leaf(&self) -> &VersionedLeaf<K, V> {
unsafe { self.leaf.as_ref() }
}
#[inline]
fn node(&self) -> &VersionNode<V> {
unsafe { self.node.as_ref() }
}
#[inline]
pub fn key(&self) -> &K {
&self.leaf().key
}
#[inline]
pub fn value(&self) -> &V {
self.node()
.value()
.expect("a VersionedEntryRef never captures a tombstone")
}
#[inline]
pub fn version(&self) -> u64 {
self.node().version
}
#[inline]
pub fn is_removed(&self) -> bool {
false
}
#[inline]
pub fn is_superseded(&self) -> bool {
self.node().is_superseded() || self.leaf().chain_latch.is_dead()
}
pub fn latest(&self) -> Option<VersionedEntryRef<'_, K, V>> {
let head = self.leaf().head();
VersionedEntryRef::new(self.leaf, head, self.tree, self.borrowed())
}
pub fn get_version_le(&self, max_version: u64) -> Option<(u64, &V)> {
let n = find_le(self.leaf().head(), max_version)?;
n.value().map(|v| (n.version, v))
}
#[inline]
fn borrowed(&self) -> GuardHandle<'_> {
GuardHandle::Borrowed(self.guard.guard())
}
}
impl<K, V> Clone for VersionedEntryRef<'_, K, V> {
fn clone(&self) -> Self {
Self {
leaf: self.leaf,
node: self.node,
tree: self.tree,
guard: self.guard.duplicate(),
}
}
}
impl<K, V> Deref for VersionedEntryRef<'_, K, V> {
type Target = V;
#[inline]
fn deref(&self) -> &V {
self.value()
}
}
impl<K: std::fmt::Debug, V: std::fmt::Debug> std::fmt::Debug for VersionedEntryRef<'_, K, V> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("VersionedEntryRef")
.field("key", self.key())
.field("version", &self.version())
.field("value", self.value())
.finish()
}
}
impl<K: PartialEq, V: PartialEq> PartialEq for VersionedEntryRef<'_, K, V> {
fn eq(&self, other: &Self) -> bool {
self.key() == other.key()
&& self.version() == other.version()
&& self.value() == other.value()
}
}