Struct ate::dio::Dio

pub struct Dio<'a> where
    Self: Send + Sync,  { /* fields omitted */ }

Represents a series of mutations that the user is making on a particular chain-of-trust with a specific set of facts attached to a session. All changes are stored in memory until the commit function is invoked which will feed them into the chain.

If you decide to abort the transaction then call the cancel function before it goes out of scope however if you mutate data and do not call commit then the data will be lost (or an assert will be triggerd when in Debug mode).

These objects are multi-thread safe and allow for very high concurrency through async operations.

When setting the scope for the DIO it will behave differently when the commit function is invoked based on what scope you set for the transaction.

Implementations

impl<'a> Dio<'a>

pub fn store<D>(&mut self, data: D) -> Result<Dao<D>, SerializationError> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub fn make<D>(&mut self, data: D) -> Result<DaoEthereal<D>, SerializationError> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub fn make_ext<D>(
    &mut self,
    data: D,
    format: Option<MessageFormat>,
    key: Option<PrimaryKey>
) -> Result<DaoEthereal<D>, SerializationError> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub fn store_ext<D>(
    &mut self,
    data: D,
    format: Option<MessageFormat>,
    key: Option<PrimaryKey>
) -> Result<Dao<D>, SerializationError> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub async fn delete<D>(&mut self, key: &PrimaryKey) -> Result<(), LoadError> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub async fn load<D>(&mut self, key: &PrimaryKey) -> Result<Dao<D>, LoadError> where
    D: Serialize + DeserializeOwned + Clone + Send + Sync, 

pub async fn exists(&mut self, key: &PrimaryKey) -> bool

impl<'a> Dio<'a>

pub fn has_uncommitted(&self) -> bool

pub fn cancel(&mut self)

pub async fn commit(&mut self) -> Result<(), CommitError>

Trait Implementations

impl<'a> Drop for Dio<'a>

fn drop(&mut self)

Executes the destructor for this type.