Trait bonsaidb::core::schema::Key

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

    const LENGTH: Option<usize>;

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

A trait that enables a type to convert itself to a big-endian/network byte order.

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.

Required methods

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

Convert self into a Cow<[u8]> containing bytes ordered in big-endian/network byte order.

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

Convert a slice of bytes into Self by interpretting bytes in big-endian/network byte order.

Implementations on Foreign Types

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

type Error = FromUtf8Error

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <String as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<String, <String as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <i128 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<i128, <i128 as Key<'a>>::Error>

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

type Error = Infallible

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'k self
) -> Result<Cow<'k, [u8]>, <Cow<'k, [u8]> as Key<'k>>::Error>

pub fn from_big_endian_bytes(
    bytes: &[u8]
) -> Result<Cow<'k, [u8]>, <Cow<'k, [u8]> as Key<'k>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <i8 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<i8, <i8 as Key<'a>>::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

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <(T1, T2, T3, T4) as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<(T1, T2, T3, T4), <(T1, T2, T3, T4) as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <u8 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<u8, <u8 as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <u64 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<u64, <u64 as Key<'a>>::Error>

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

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <Option<T> as Key<'a>>::Error>

Panics

Panics if T::into_big_endian_bytes returns an empty IVec.

type Error = <T as Key<'a>>::Error

pub const LENGTH: Option<usize>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<Option<T>, <Option<T> as Key<'a>>::Error>

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

type Error = CompositeKeyError

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <(T1, T2) as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<(T1, T2), <(T1, T2) as Key<'a>>::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

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <(T1, T2, T3, T4, T5, T6, T7, T8) as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8), <(T1, T2, T3, T4, T5, T6, T7, T8) as Key<'a>>::Error>

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

type Error = Infallible

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <() as Key<'a>>::Error>

pub fn from_big_endian_bytes(&'a [u8]) -> Result<(), <() as Key<'a>>::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

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <(T1, T2, T3) as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<(T1, T2, T3), <(T1, T2, T3) as Key<'a>>::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

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <(T1, T2, T3, T4, T5, T6) as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<(T1, T2, T3, T4, T5, T6), <(T1, T2, T3, T4, T5, T6) as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <i16 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<i16, <i16 as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <u128 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<u128, <u128 as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <u32 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<u32, <u32 as Key<'a>>::Error>

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

type Error = Infallible

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <Vec<u8, Global> as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<Vec<u8, Global>, <Vec<u8, Global> as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <i32 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<i32, <i32 as Key<'a>>::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

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <(T1, T2, T3, T4, T5, T6, T7) as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<(T1, T2, T3, T4, T5, T6, T7), <(T1, T2, T3, T4, T5, T6, T7) as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <u16 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<u16, <u16 as Key<'a>>::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

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <(T1, T2, T3, T4, T5) as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<(T1, T2, T3, T4, T5), <(T1, T2, T3, T4, T5) as Key<'a>>::Error>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

pub fn as_big_endian_bytes(
    &'a self
) -> Result<Cow<'a, [u8]>, <i64 as Key<'a>>::Error>

pub fn from_big_endian_bytes(
    bytes: &'a [u8]
) -> Result<i64, <i64 as Key<'a>>::Error>

Implementors

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

type Error = Infallible

pub const LENGTH: Option<usize>

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

type Error = Infallible

pub const LENGTH: Option<usize>

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

type Error = Infallible

pub const LENGTH: Option<usize>

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

type Error = IncorrectByteLength

pub const LENGTH: Option<usize>

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

type Error = Error

pub const LENGTH: Option<usize>

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

type Error = Error

pub const LENGTH: Option<usize>

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

type Error = Error

pub const LENGTH: Option<usize>