Trait bonsaidb_core::key::KeyEncoding

pub trait KeyEncoding<'k, K>: Send + Syncwhere
    K: Key<'k>,{
    type Error: AnyError;

    const LENGTH: Option<usize>;

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

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

Required Associated Types

type Error: AnyError

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

Required 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.

Implementations on Foreign Types

impl<'a> KeyEncoding<'a, Duration> for Duration

type Error = TimeError

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, SystemTime> for SystemTime

type Error = TimeError

const LENGTH: Option<usize> = None

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

impl<'a, 'k, K, KE> KeyEncoding<'k, K> for &'a KEwhere
    KE: KeyEncoding<'k, K> + ?Sized + PartialEq,
    K: Key<'k> + PartialEq<KE>,

type Error = <KE as KeyEncoding<'k, K>>::Error

const LENGTH: Option<usize> = K::LENGTH

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

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

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a, 'k> KeyEncoding<'k, Cow<'k, [u8]>> for &'a [u8]

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, Vec<u8, Global>> for Vec<u8>

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a, 'k> KeyEncoding<'k, Vec<u8, Global>> for &'a [u8]

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a, const N: usize> KeyEncoding<'a, [u8; N]> for [u8; N]

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, ArcBytes<'a>> for ArcBytes<'a>

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a, 'k> KeyEncoding<'k, ArcBytes<'k>> for &'a [u8]

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, CowBytes<'a>> for CowBytes<'a>

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a, 'k> KeyEncoding<'k, CowBytes<'k>> for &'a [u8]

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, Bytes> for Bytes

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a, 'k> KeyEncoding<'k, Bytes> for &'a [u8]

type Error = Infallible

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, String> for String

type Error = FromUtf8Error

const LENGTH: Option<usize> = None

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

impl<'k> KeyEncoding<'k, String> for str

type Error = FromUtf8Error

const LENGTH: Option<usize> = None

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

impl<'k> KeyEncoding<'k, Cow<'k, str>> for Cow<'k, str>

type Error = Utf8Error

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, ()> for ()

type Error = Infallible

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, bool> for bool

type Error = Infallible

const LENGTH: Option<usize> = _

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

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

type Error = CompositeKeyError

const LENGTH: Option<usize> = _

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

impl<'a, T1, T2> KeyEncoding<'a, (T1, T2)> 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>

impl<'a, T1, T2, T3> KeyEncoding<'a, (T1, T2, T3)> 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>

impl<'a, T1, T2, T3, T4> KeyEncoding<'a, (T1, T2, T3, T4)> 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>

impl<'a, T1, T2, T3, T4, T5> KeyEncoding<'a, (T1, T2, T3, T4, T5)> 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>

impl<'a, T1, T2, T3, T4, T5, T6> KeyEncoding<'a, (T1, T2, T3, T4, T5, T6)> 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>

impl<'a, T1, T2, T3, T4, T5, T6, T7> KeyEncoding<'a, (T1, T2, T3, T4, T5, T6, T7)> 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>

impl<'a, T1, T2, T3, T4, T5, T6, T7, T8> KeyEncoding<'a, (T1, T2, T3, T4, T5, T6, T7, T8)> 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>

impl<'a> KeyEncoding<'a, Signed> for Signed

type Error = Error

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, Unsigned> for Unsigned

type Error = Error

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, isize> for isize

type Error = Error

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, usize> for usize

type Error = Error

const LENGTH: Option<Self> = None

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

impl<'k> KeyEncoding<'k, Uuid> for Uuid

type Error = TryFromSliceError

const LENGTH: Option<usize> = _

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

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

type Error = <T as KeyEncoding<'a, K>>::Error

const LENGTH: Option<usize> = _

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

impl<'a, T, E, TBorrowed, EBorrowed> KeyEncoding<'a, Result<T, E>> for Result<TBorrowed, EBorrowed>where
    TBorrowed: KeyEncoding<'a, T>,
    T: Key<'a, Error = TBorrowed::Error>,
    EBorrowed: KeyEncoding<'a, E, Error = TBorrowed::Error>,
    E: Key<'a, Error = TBorrowed::Error>,

type Error = <TBorrowed as KeyEncoding<'a, T>>::Error

const LENGTH: Option<usize> = None

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

impl<'a> KeyEncoding<'a, i8> for i8

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, u8> for u8

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, i16> for i16

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, u16> for u16

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, i32> for i32

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, u32> for u32

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, i64> for i64

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, u64> for u64

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, i128> for i128

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

impl<'a> KeyEncoding<'a, u128> for u128

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

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

Implementors

impl<'a> KeyEncoding<'a, Timestamp> for Timestamp

type Error = IncorrectByteLength

const LENGTH: Option<usize> = _

impl<'a, 'k, TOwned, TBorrowed> KeyEncoding<'k, MaybeOwned<'a, TOwned, TBorrowed>> for MaybeOwned<'a, TOwned, TBorrowed>where
    TBorrowed: KeyEncoding<'k, TOwned, Error = TOwned::Error> + PartialEq + ?Sized,
    TOwned: Key<'k> + PartialEq<TBorrowed>,

type Error = <TOwned as KeyEncoding<'k, TOwned>>::Error

const LENGTH: Option<usize> = TBorrowed::LENGTH

impl<'a, K, T> KeyEncoding<'a, OptionKeyV1<K>> for OptionKeyV1<T>where
    T: KeyEncoding<'a, K>,
    K: for<'k> Key<'k>,

type Error = <T as KeyEncoding<'a, K>>::Error

const LENGTH: Option<usize> = T::LENGTH

impl<'a, Resolution> KeyEncoding<'a, LimitedResolutionDuration<Resolution>> for LimitedResolutionDuration<Resolution>where
    Resolution: TimeResolution,

type Error = TimeError

const LENGTH: Option<usize> = None

impl<'a, Resolution, Epoch> KeyEncoding<'a, LimitedResolutionTimestamp<Resolution, Epoch>> for LimitedResolutionTimestamp<Resolution, Epoch>where
    Resolution: TimeResolution,
    Epoch: TimeEpoch,

type Error = TimeError

const LENGTH: Option<usize> = None

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

type Error = CompositeKeyError

const LENGTH: Option<usize> = _

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

type Error = CompositeKeyError

const LENGTH: Option<usize> = _

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

type Error = CompositeKeyError

const LENGTH: Option<usize> = _

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

type Error = CompositeKeyError

const LENGTH: Option<usize> = _

impl<'a, T1, T2, T3, T4, T5> KeyEncoding<'a, TupleEncodingV1<(T1, T2, T3, T4, T5)>> for TupleEncodingV1<(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> = _

impl<'a, T1, T2, T3, T4, T5, T6> KeyEncoding<'a, TupleEncodingV1<(T1, T2, T3, T4, T5, T6)>> for TupleEncodingV1<(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> = _

impl<'a, T1, T2, T3, T4, T5, T6, T7> KeyEncoding<'a, TupleEncodingV1<(T1, T2, T3, T4, T5, T6, T7)>> for TupleEncodingV1<(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> = _

impl<'a, T1, T2, T3, T4, T5, T6, T7, T8> KeyEncoding<'a, TupleEncodingV1<(T1, T2, T3, T4, T5, T6, T7, T8)>> for TupleEncodingV1<(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> = _

impl<'a, T> KeyEncoding<'a, EnumKey<T>> for EnumKey<T>where
    T: ToPrimitive + FromPrimitive + Clone + Eq + Ord + Debug + Send + Sync,

type Error = Error

const LENGTH: Option<usize> = None

impl<'k> KeyEncoding<'k, SensitiveBytes> for SensitiveBytes

type Error = Infallible

const LENGTH: Option<usize> = None

impl<'k> KeyEncoding<'k, SensitiveString> for SensitiveString

type Error = FromUtf8Error

const LENGTH: Option<usize> = None

impl<'k, PrimaryKey> KeyEncoding<'k, PrimaryKey> for DocumentIdwhere
    PrimaryKey: for<'a> Key<'a>,

type Error = Error

const LENGTH: Option<usize> = None