Struct atuin_common::record::Record

pub struct Record<Data> {
    pub id: RecordId,
    pub host: HostId,
    pub parent: Option<RecordId>,
    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

host: HostId

The unique ID of the host.

parent: Option<RecordId>

The ID of the parent entry

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), .host(...), .parent(...)(optional), .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 new_child(&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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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>