Struct ate::prelude::DaoMut

pub struct DaoMut<D> where
    D: Serialize, { /* private fields */ }

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 real version represents all operations that can be performed before the obejct is actually saved and all those after

Implementations

impl<D> DaoMut<D> where
    D: Serialize, 

pub fn trans(&self) -> Arc<DioMut>

pub fn set_trans(&mut self, dio: &Arc<DioMut>)

pub fn delete(self) -> Result<(), SerializationError>

pub fn detach(&mut self) -> Result<(), SerializationError>

pub fn attach_ext(
    &mut self,
    parent: PrimaryKey,
    collection_id: u64
) -> Result<(), SerializationError>

pub fn attach_orphaned(
    &mut self,
    parent: &PrimaryKey
) -> Result<(), SerializationError>

pub fn attach_orphaned_ext(
    &mut self,
    parent: &PrimaryKey,
    collection_id: u64
) -> Result<(), SerializationError>

pub fn add_extra_metadata(
    &mut self,
    meta: CoreMetadata
) -> Result<(), SerializationError>

pub fn is_locked(&self) -> bool

pub fn dio_mut(&self) -> Arc<DioMut>

pub fn attach(
    &mut self,
    parent: &dyn DaoObj,
    vec: &DaoVec<D>
) -> Result<(), SerializationError> where
    D: Serialize, 

pub async fn try_lock(&mut self) -> Result<bool, LockError>

pub async fn try_lock_with_timeout(
    &mut self,
    timeout: Duration
) -> Result<bool, LockError>

pub async fn unlock(&mut self) -> Result<bool, LockError>

pub async fn try_lock_then_delete(&mut self) -> Result<bool, LockError>

pub fn auth_mut<'a>(&'a mut self) -> DaoAuthGuard<'a>

pub fn take(self) -> D

pub fn parent(&self) -> Option<MetaCollection>

pub fn parent_id(&self) -> Option<PrimaryKey>

pub fn as_mut<'a>(&'a mut self) -> DaoMutGuard<'a, D>

pub fn as_ref<'a>(&'a self) -> &'a D

pub fn as_immutable(&self) -> &Dao<D>

pub fn to_immutable(self) -> Dao<D>

pub fn as_mut_owned(self) -> DaoMutGuardOwned<D>

Trait Implementations

impl<D> Clone for DaoMut<D> where
    D: Serialize + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D> DaoObj for DaoMut<D> where
    D: Serialize, 

fn key(&self) -> &PrimaryKey

fn auth(&self) -> &MetaAuthorization

fn dio(&self) -> &Arc<Dio>

fn when_created(&self) -> u64

fn when_updated(&self) -> u64

impl<D> Debug for DaoMut<D> where
    D: Serialize + Debug, 

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

Formats the value using the given formatter.

impl<D> Deref for DaoMut<D> where
    D: Serialize, 

type Target = D

The resulting type after dereferencing.

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

Dereferences the value.

impl<D> From<DaoMut<D>> for Dao<D> where
    D: Serialize, 

fn from(a: DaoMut<D>) -> Self

Converts to this type from the input type.