Trait bonsaidb_core::key::Key

source · [−]

pub trait Key<'k>: Clone + Debug + Send + Sync {
    type Error: AnyError;

    const LENGTH: Option<usize>;

    fn as_ord_bytes(&'k self) -> Result<Cow<'k, [u8]>, Self::Error>;
    fn from_ord_bytes(bytes: &'k [u8]) -> Result<Self, Self::Error>;

    fn first_value() -> Result<Self, NextValueError> { ... }
    fn next_value(&self) -> Result<Self, NextValueError> { ... }
}

Expand description

A trait that enables a type to convert itself into a memcmp-compatible sequence of bytes.

Associated Types

type Error: AnyError

The error type that can be produced by either serialization or deserialization.

Associated Constants

const LENGTH: Option<usize>

The size of the key, if constant. If this type doesn’t produce the same number of bytes for each value, this should be None.

Required methods

fn as_ord_bytes(&'k self) -> Result<Cow<'k, [u8 ]>, Self::Error>

Convert self into a Cow<[u8]> containing bytes that are able to be compared via memcmp in a way that is comptaible with its own Ord implementation.

fn from_ord_bytes(bytes: &'k [u8 ]) -> Result<Self, Self::Error>

Deserialize a sequence of bytes previously encoded with Self::as_ord_bytes.

Provided methods

fn first_value() -> Result<Self, NextValueError>

Return the first value in sequence for this type. Not all types implement this.

fn next_value(&self) -> Result<Self, NextValueError>

Return the next value in sequence for this type. Not all types implement this. Instead of wrapping/overflowing, None should be returned.

Implementations on Foreign Types

impl<'k> Key<'k> for Cow<'k, [u8 ]>

type Error = Infallible

const LENGTH: Option<usize>

fn as_ord_bytes(&'k self) -> Result<Cow<'k, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &[u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for Vec<u8>

type Error = Infallible

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for ArcBytes<'a>

type Error = Infallible

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for CowBytes<'a>

type Error = Infallible

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for Bytes

type Error = Infallible

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for String

type Error = FromUtf8Error

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for ()

type Error = Infallible

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(_: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for bool

type Error = Infallible

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a, T1, T2> Key<'a> for (T1, T2) where
T1: Key<'a>,
T2: Key<'a>,

type Error = CompositeKeyError

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a, T1, T2, T3> Key<'a> for (T1, T2, T3) where
    T1: Key<'a>,
    T2: Key<'a>,
    T3: Key<'a>,

type Error = CompositeKeyError

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a, T1, T2, T3, T4> Key<'a> for (T1, T2, T3, T4) where
    T1: Key<'a>,
    T2: Key<'a>,
    T3: Key<'a>,
    T4: Key<'a>,

type Error = CompositeKeyError

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a, T1, T2, T3, T4, T5> Key<'a> for (T1, T2, T3, T4, T5) where
    T1: Key<'a>,
    T2: Key<'a>,
    T3: Key<'a>,
    T4: Key<'a>,
    T5: Key<'a>,

type Error = CompositeKeyError

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a, T1, T2, T3, T4, T5, T6> Key<'a> for (T1, T2, T3, T4, T5, T6) where
    T1: Key<'a>,
    T2: Key<'a>,
    T3: Key<'a>,
    T4: Key<'a>,
    T5: Key<'a>,
    T6: Key<'a>,

type Error = CompositeKeyError

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a, T1, T2, T3, T4, T5, T6, T7> Key<'a> for (T1, T2, T3, T4, T5, T6, T7) where
    T1: Key<'a>,
    T2: Key<'a>,
    T3: Key<'a>,
    T4: Key<'a>,
    T5: Key<'a>,
    T6: Key<'a>,
    T7: Key<'a>,

type Error = CompositeKeyError

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a, T1, T2, T3, T4, T5, T6, T7, T8> Key<'a> for (T1, T2, T3, T4, T5, T6, T7, T8) where
    T1: Key<'a>,
    T2: Key<'a>,
    T3: Key<'a>,
    T4: Key<'a>,
    T5: Key<'a>,
    T6: Key<'a>,
    T7: Key<'a>,
    T8: Key<'a>,

type Error = CompositeKeyError

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

impl<'a> Key<'a> for Signed

type Error = Error

const LENGTH: Option<usize>

fn as_ord_bytes(&self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for Unsigned

type Error = Error

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a, T> Key<'a> for Option<T> where
T: Key<'a>,

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

Panics

Panics if T::into_big_endian_bytes returns an empty IVec.

type Error = T::Error

const LENGTH: Option<usize>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for i8

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for u8

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for i16

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for u16

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for i32

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for u32

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for i64

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for u64

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for i128

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

impl<'a> Key<'a> for u128

type Error = IncorrectByteLength

const LENGTH: Option<usize>

fn as_ord_bytes(&'a self) -> Result<Cow<'a, [u8 ]>, Self::Error>

fn from_ord_bytes(bytes: &'a [u8 ]) -> Result<Self, Self::Error>

fn first_value() -> Result<Self, NextValueError>

fn next_value(&self) -> Result<Self, NextValueError>

Implementors

impl<'a> Key<'a> for Timestamp

type Error = IncorrectByteLength

const LENGTH: Option<usize>

impl<'a, T> Key<'a> for T where
T: EnumKey,

type Error = Error

const LENGTH: Option<usize>