cuprate_database

Trait Storable

Source 
pub trait Storable: Debug {
    const BYTE_LENGTH: Option<usize>;

    // Required methods
    fn as_bytes(&self) -> &[u8] ⓘ;
    fn from_bytes(bytes: &[u8]) -> Self;
}
Expand description

A type that can be stored in the database.

All keys and values in the database must be able to be (de)serialized into/from raw bytes ([u8]).

This trait represents types that can be perfectly casted/represented as raw bytes.

§bytemuck

Any type that implements:

will automatically implement Storable.

See StorableVec & StorableBytes for storing slices of T: Storable.

let number: u64 = 0;

// Into bytes.
let into = Storable::as_bytes(&number);
assert_eq!(into, &[0; 8]);

// From bytes.
let from: u64 = Storable::from_bytes(&into);
assert_eq!(from, number);

§Invariants

No function in this trait is expected to panic.

The byte conversions must execute flawlessly.

§Endianness

This trait doesn’t currently care about endianness.

Bytes are (de)serialized as-is, and bytemuck types are architecture-dependant.

Most likely, the bytes are little-endian, however that cannot be relied upon when using this trait.

Required Associated Constants§

Source

const BYTE_LENGTH: Option<usize>

Is this type fixed width in byte length?

I.e., when converting Self to bytes, is it represented with a fixed length array of bytes?

§Some

This should be Some(usize) on types like:

  • u8
  • u64
  • i32

where the byte length is known.

§None

This should be None on any variable-length type like:

  • str
  • [u8]
  • Vec<u8>
§Examples
assert_eq!(<()>::BYTE_LENGTH, Some(0));
assert_eq!(u8::BYTE_LENGTH, Some(1));
assert_eq!(u16::BYTE_LENGTH, Some(2));
assert_eq!(u32::BYTE_LENGTH, Some(4));
assert_eq!(u64::BYTE_LENGTH, Some(8));
assert_eq!(i8::BYTE_LENGTH, Some(1));
assert_eq!(i16::BYTE_LENGTH, Some(2));
assert_eq!(i32::BYTE_LENGTH, Some(4));
assert_eq!(i64::BYTE_LENGTH, Some(8));
assert_eq!(StorableVec::<u8>::BYTE_LENGTH, None);
assert_eq!(StorableVec::<u64>::BYTE_LENGTH, None);

Required Methods§

Source

fn as_bytes(&self) -> &[u8] ⓘ

Return self in byte form.

Source

fn from_bytes(bytes: &[u8]) -> Self

Create an owned Self from bytes.

§Blanket implementation

The blanket implementation that covers all types used by cuprate_database will simply bitwise copy bytes into Self.

The bytes do not have be correctly aligned.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§