Struct ate::dio::Dao

pub struct Dao<D> where
    Self: Send + Sync,
    D: Serialize + DeserializeOwned + Clone + Sync + Send,  { /* fields omitted */ }

Represents a data object that will be represented as one or more events on the redo-log and validated in the chain-of-trust.

Reading this object using none-mutable behavior will incur no IO on the redo-log however if you edit the object you must commit it to the Dio before it goes out of scope or the data will be lost (in Debug mode this will even trigger an assert).

Metadata about the data object can also be accessed via this object which allows you to change the read/write access rights, etc.

If you change your mind on commiting the data to the redo-log then you can call the cancel function instead.

Implementations

impl<D> Dao<D> where
    Self: Send + Sync,
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub fn make(key: PrimaryKey, format: MessageFormat, data: D) -> Dao<D>

pub fn detach(&mut self)

pub fn attach(&mut self, parent: &dyn DaoObj, vec: DaoVec<D>)

pub fn take(self) -> D

pub async fn try_lock<'a>(
    &mut self,
    dio: &mut Dio<'a>
) -> Result<bool, LockError>

pub async fn try_lock_then_delete<'a>(
    &mut self,
    dio: &mut Dio<'a>
) -> Result<bool, LockError>

pub async fn unlock<'a>(&mut self, dio: &mut Dio<'a>) -> Result<bool, LockError>

impl<D> Dao<D> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub async fn iter<'a, C>(
    &self,
    dio: &mut Dio<'a>,
    vec: DaoVec<C>
) -> Result<Iter<C>, LoadError> where
    C: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub fn push<C>(
    &mut self,
    dio: &mut Dio<'_>,
    vec: DaoVec<C>,
    data: C
) -> Result<Dao<C>, SerializationError> where
    C: Serialize + DeserializeOwned + Clone + Send + Sync, 

impl<D> Dao<D> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub fn bus<'a, C>(&self, chain: &'a Chain, vec: DaoVec<C>) -> Bus<'a, C> where
    C: Serialize + DeserializeOwned + Clone + Send + Sync, 

Trait Implementations

impl<D> DaoObj for Dao<D> where
    Self: Send + Sync,
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

fn key(&self) -> &PrimaryKey

fn delete<'a>(self, dio: &mut Dio<'a>) -> Result<(), SerializationError>

fn auth(&self) -> &MetaAuthorization

fn auth_mut(&mut self) -> &mut MetaAuthorization

fn add_extra_metadata(&mut self, meta: CoreMetadata)

fn is_locked(&self) -> bool

fn is_dirty(&self) -> bool

fn when_created(&self) -> u64

fn when_updated(&self) -> u64

fn cancel(&mut self)

fn commit<'a>(&mut self, dio: &mut Dio<'a>) -> Result<(), SerializationError>

impl<D: Debug> Debug for Dao<D> where
    Self: Send + Sync,
    D: Serialize + DeserializeOwned + Clone + Sync + Send, 

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

Formats the value using the given formatter.

impl<D> Deref for Dao<D> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

type Target = D

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<D> DerefMut for Dao<D> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.