104 lines
2.3 KiB
Rust
104 lines
2.3 KiB
Rust
use conduwuit::Result;
|
|
use serde::{Deserialize, Serialize};
|
|
use smallvec::SmallVec;
|
|
|
|
use crate::{de, ser};
|
|
|
|
pub type KeyVal<'a, K = &'a Slice, V = &'a Slice> = (Key<'a, K>, Val<'a, V>);
|
|
pub type Key<'a, T = &'a Slice> = T;
|
|
pub type Val<'a, T = &'a Slice> = T;
|
|
|
|
pub type KeyBuf = KeyBuffer;
|
|
pub type ValBuf = ValBuffer;
|
|
|
|
pub type KeyBuffer<const CAP: usize = KEY_STACK_CAP> = Buffer<CAP>;
|
|
pub type ValBuffer<const CAP: usize = VAL_STACK_CAP> = Buffer<CAP>;
|
|
pub type Buffer<const CAP: usize = DEF_STACK_CAP> = SmallVec<[Byte; CAP]>;
|
|
|
|
pub type Slice = [Byte];
|
|
pub type Byte = u8;
|
|
|
|
pub const KEY_STACK_CAP: usize = 128;
|
|
pub const VAL_STACK_CAP: usize = 512;
|
|
pub const DEF_STACK_CAP: usize = KEY_STACK_CAP;
|
|
|
|
#[inline]
|
|
pub fn serialize_key<T>(val: T) -> Result<KeyBuf>
|
|
where
|
|
T: Serialize,
|
|
{
|
|
ser::serialize_to::<KeyBuf, _>(val)
|
|
}
|
|
|
|
#[inline]
|
|
pub fn serialize_val<T>(val: T) -> Result<ValBuf>
|
|
where
|
|
T: Serialize,
|
|
{
|
|
ser::serialize_to::<ValBuf, _>(val)
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn _expect_deserialize<'a, K, V>(kv: Result<KeyVal<'a>>) -> KeyVal<'a, K, V>
|
|
where
|
|
K: Deserialize<'a>,
|
|
V: Deserialize<'a>,
|
|
{
|
|
result_deserialize(kv).expect("failed to deserialize result key/val")
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn _expect_deserialize_key<'a, K>(key: Result<Key<'a>>) -> Key<'a, K>
|
|
where
|
|
K: Deserialize<'a>,
|
|
{
|
|
result_deserialize_key(key).expect("failed to deserialize result key")
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn result_deserialize<'a, K, V>(kv: Result<KeyVal<'a>>) -> Result<KeyVal<'a, K, V>>
|
|
where
|
|
K: Deserialize<'a>,
|
|
V: Deserialize<'a>,
|
|
{
|
|
deserialize(kv?)
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn result_deserialize_key<'a, K>(key: Result<Key<'a>>) -> Result<Key<'a, K>>
|
|
where
|
|
K: Deserialize<'a>,
|
|
{
|
|
deserialize_key(key?)
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn deserialize<'a, K, V>(kv: KeyVal<'a>) -> Result<KeyVal<'a, K, V>>
|
|
where
|
|
K: Deserialize<'a>,
|
|
V: Deserialize<'a>,
|
|
{
|
|
Ok((deserialize_key::<K>(kv.0)?, deserialize_val::<V>(kv.1)?))
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn deserialize_key<'a, K>(key: Key<'a>) -> Result<Key<'a, K>>
|
|
where
|
|
K: Deserialize<'a>,
|
|
{
|
|
de::from_slice::<K>(key)
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn deserialize_val<'a, V>(val: Val<'a>) -> Result<Val<'a, V>>
|
|
where
|
|
V: Deserialize<'a>,
|
|
{
|
|
de::from_slice::<V>(val)
|
|
}
|
|
|
|
#[inline]
|
|
pub fn key<K, V>(kv: KeyVal<'_, K, V>) -> Key<'_, K> { kv.0 }
|
|
|
|
#[inline]
|
|
pub fn val<K, V>(kv: KeyVal<'_, K, V>) -> Val<'_, V> { kv.1 }
|