Struct Record

pub struct Record<Data> {
    pub id: RecordId,
    pub idx: RecordIdx,
    pub host: Host,
    pub timestamp: u64,
    pub version: String,
    pub tag: String,
    pub data: Data,
}

A single record stored inside of our local database

Fields

id: RecordId

a unique ID

idx: RecordIdx

The integer record ID. This is only unique per (host, tag).

host: Host

The unique ID of the host.

timestamp: u64

The creation time in nanoseconds since unix epoch

version: String

The version the data in the entry conforms to

tag: String

The type of data we are storing here. Eg, “history”

data: Data

Some data. This can be anything you wish to store. Use the tag field to know how to handle it.

Implementations

impl<Data> Record<Data>

pub fn builder() -> RecordBuilder<Data, ((), (), (), (), (), (), ())>

Create a builder for building Record. On the builder, call .id(...)(optional), .idx(...), .host(...), .timestamp(...)(optional), .version(...), .tag(...), .data(...) to set the values of the fields. Finally, call .build() to create the instance of Record.

impl<Data> Record<Data>

pub fn append(&self, data: Vec<u8>) -> Record<DecryptedData>

impl Record<DecryptedData>

pub fn encrypt<E: Encryption>(self, key: &[u8; 32]) -> Record<EncryptedData>

impl Record<EncryptedData>

pub fn decrypt<E: Encryption>( self, key: &[u8; 32], ) -> Result<Record<DecryptedData>>

pub fn re_encrypt<E: Encryption>( self, old_key: &[u8; 32], new_key: &[u8; 32], ) -> Result<Record<EncryptedData>>

Trait Implementations

impl<Data: Clone> Clone for Record<Data>

fn clone(&self) -> Record<Data>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Data: Debug> Debug for Record<Data>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, Data> Deserialize<'de> for Record<Data>

where Data: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Data: PartialEq> PartialEq for Record<Data>

fn eq(&self, other: &Record<Data>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Data> Serialize for Record<Data>

where Data: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Data> StructuralPartialEq for Record<Data>