Struct ate::dio::DaoEthereal

pub struct DaoEthereal<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.

The ethereal version represents all operations that can be performed before the obejct is actually saved

Implementations

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

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

pub fn detach(&mut self)

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

pub fn attach_orphaned(&mut self, parent: &PrimaryKey)

pub fn take(self) -> D

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

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

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

Trait Implementations

impl<D> DaoObjEthereal for DaoEthereal<D> where
    Self: Send + Sync,
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

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 cancel(&mut self)

impl<D: Debug> Debug for DaoEthereal<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 DaoEthereal<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 DaoEthereal<D> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

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

Mutably dereferences the value.