use std::ops::{Deref, DerefMut};
use crate::{LeaseId, Revision, Version};
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub struct Record<K = ::bytes::Bytes, V = ::bytes::Bytes, M = Metadata> {
metadata: M,
key: K,
value: V,
}
impl<K, V, M> Record<K, V, M> {
pub fn new(key: K, value: V, metadata: M) -> Self {
Self { metadata, key, value }
}
pub fn into_parts(self) -> (M, K, V) {
(self.metadata, self.key, self.value)
}
pub fn key(&self) -> &K {
&self.key
}
pub fn key_mut(&mut self) -> &mut K {
&mut self.key
}
pub fn take_key(self) -> K {
self.key
}
pub fn value(&self) -> &V {
&self.value
}
pub fn value_mut(&mut self) -> &mut V {
&mut self.value
}
pub fn take_value(self) -> V {
self.value
}
pub fn metadata(&self) -> &M {
&self.metadata
}
pub fn metadata_mut(&mut self) -> &mut M {
&mut self.metadata
}
pub fn take_metadata(self) -> M {
self.metadata
}
pub fn without_value(self) -> KeyWithMetadata<K, M> {
KeyWithMetadata::new(self.key, self.metadata)
}
pub fn map<RV>(self, f: impl FnOnce(V) -> RV) -> Record<K, RV, M> {
Record {
metadata: self.metadata,
key: self.key,
value: f(self.value),
}
}
pub fn map_checked<RV, E>(self, f: impl FnOnce(V) -> Result<RV, E>) -> Result<Record<K, RV, M>, E> {
Ok(Record {
metadata: self.metadata,
key: self.key,
value: f(self.value)?,
})
}
pub fn map_key<RK>(self, f: impl FnOnce(K) -> RK) -> Record<RK, V, M> {
Record {
metadata: self.metadata,
key: f(self.key),
value: self.value,
}
}
pub fn map_key_checked<RK, E>(self, f: impl FnOnce(K) -> Result<RK, E>) -> Result<Record<RK, V, M>, E> {
Ok(Record {
metadata: self.metadata,
key: f(self.key)?,
value: self.value,
})
}
pub fn map_metadata<RM>(self, f: impl FnOnce(M) -> RM) -> Record<K, V, RM> {
Record {
metadata: f(self.metadata),
key: self.key,
value: self.value,
}
}
pub fn map_metadata_checked<RM, E>(self, f: impl FnOnce(M) -> Result<RM, E>) -> Result<Record<K, V, RM>, E> {
Ok(Record {
metadata: f(self.metadata)?,
key: self.key,
value: self.value,
})
}
pub fn as_ref(&self) -> Record<&K, &V, &M> {
Record {
metadata: &self.metadata,
key: &self.key,
value: &self.value,
}
}
pub fn as_mut(&mut self) -> Record<&mut K, &mut V, &mut M> {
Record {
metadata: &mut self.metadata,
key: &mut self.key,
value: &mut self.value,
}
}
pub fn as_deref(&self) -> Record<&K, &V::Target, &M>
where
V: Deref,
{
self.as_ref().map(Deref::deref)
}
pub fn as_deref_mut(&mut self) -> Record<&mut K, &mut V::Target, &mut M>
where
V: DerefMut,
{
self.as_mut().map(DerefMut::deref_mut)
}
#[inline]
pub fn inspect(self, f: impl FnOnce(&Self)) -> Self {
f(&self);
self
}
}
impl<K, V, M, E> Record<K, Result<V, E>, M> {
pub fn transpose(self) -> Result<Record<K, V, M>, E> {
Ok(Record {
metadata: self.metadata,
key: self.key,
value: self.value?,
})
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub struct KeyWithMetadata<K = ::bytes::Bytes, M = Metadata> {
metadata: M,
key: K,
}
impl<K, M> KeyWithMetadata<K, M> {
pub fn new(key: K, metadata: M) -> Self {
Self { metadata, key }
}
pub fn into_parts(self) -> (M, K) {
(self.metadata, self.key)
}
pub fn key(&self) -> &K {
&self.key
}
pub fn key_mut(&mut self) -> &mut K {
&mut self.key
}
pub fn take_key(self) -> K {
self.key
}
pub fn metadata(&self) -> &M {
&self.metadata
}
pub fn metadata_mut(&mut self) -> &mut M {
&mut self.metadata
}
pub fn take_metadata(self) -> M {
self.metadata
}
pub fn with_value<V>(self, value: V) -> Record<K, V, M> {
Record::new(self.key, value, self.metadata)
}
pub fn map_key<RK>(self, f: impl FnOnce(K) -> RK) -> KeyWithMetadata<RK, M> {
KeyWithMetadata {
metadata: self.metadata,
key: f(self.key),
}
}
pub fn map_key_checked<RK, E>(self, f: impl FnOnce(K) -> Result<RK, E>) -> Result<KeyWithMetadata<RK, M>, E> {
Ok(KeyWithMetadata {
metadata: self.metadata,
key: f(self.key)?,
})
}
pub fn map_metadata<RM>(self, f: impl FnOnce(M) -> RM) -> KeyWithMetadata<K, RM> {
KeyWithMetadata {
metadata: f(self.metadata),
key: self.key,
}
}
pub fn map_metadata_checked<RM, E>(self, f: impl FnOnce(M) -> Result<RM, E>) -> Result<KeyWithMetadata<K, RM>, E> {
Ok(KeyWithMetadata {
metadata: f(self.metadata)?,
key: self.key,
})
}
pub fn as_ref(&self) -> KeyWithMetadata<&K, &M> {
KeyWithMetadata {
metadata: &self.metadata,
key: &self.key,
}
}
pub fn as_mut(&mut self) -> KeyWithMetadata<&mut K, &mut M> {
KeyWithMetadata {
metadata: &mut self.metadata,
key: &mut self.key,
}
}
#[inline]
pub fn inspect(self, f: impl FnOnce(&Self)) -> Self {
f(&self);
self
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Metadata {
pub create_revision: Revision,
pub modified_revision: Revision,
pub version: Version,
pub lease: Option<LeaseId>,
}
pub trait AsKey {
fn as_key(&self) -> &[u8];
}
impl<T: AsKey + ?Sized> AsKey for &'_ T {
fn as_key(&self) -> &[u8] {
T::as_key(self)
}
}
pub trait AsValue {
fn as_value(&self) -> &[u8];
}
macro_rules! impl_basic_as {
($trait_name:ident, $fn_name:ident) => {
impl $trait_name for &[u8] {
fn $fn_name(&self) -> &[u8] {
self
}
}
impl<const N: usize> $trait_name for &[u8; N] {
fn $fn_name(&self) -> &[u8] {
&self[..]
}
}
impl $trait_name for &mut [u8] {
fn $fn_name(&self) -> &[u8] {
self
}
}
impl<const N: usize> $trait_name for &mut [u8; N] {
fn $fn_name(&self) -> &[u8] {
&self[..]
}
}
impl $trait_name for Vec<u8> {
fn $fn_name(&self) -> &[u8] {
&self
}
}
impl $trait_name for ::bytes::Bytes {
fn $fn_name(&self) -> &[u8] {
self
}
}
impl $trait_name for &str {
fn $fn_name(&self) -> &[u8] {
self.as_bytes()
}
}
impl $trait_name for &mut str {
fn $fn_name(&self) -> &[u8] {
self.as_bytes()
}
}
impl $trait_name for String {
fn $fn_name(&self) -> &[u8] {
self.as_bytes()
}
}
impl<T: $trait_name + ?Sized> $trait_name for Box<T> {
fn $fn_name(&self) -> &[u8] {
T::$fn_name(&**self)
}
}
impl<T: $trait_name + ?Sized> $trait_name for std::rc::Rc<T> {
fn $fn_name(&self) -> &[u8] {
T::$fn_name(&**self)
}
}
impl<T: $trait_name + ?Sized> $trait_name for std::sync::Arc<T> {
fn $fn_name(&self) -> &[u8] {
T::$fn_name(&**self)
}
}
};
}
impl_basic_as!(AsKey, as_key);
impl_basic_as!(AsValue, as_value);