Struct ate::prelude::Dio

pub struct Dio { /* private fields */ }

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 Dio

pub fn chain(&self) -> &Arc<Chain>

pub fn remote<'a>(&'a self) -> Option<&'a Url>

pub async fn load_raw(
    self: &Arc<Self>,
    key: &PrimaryKey
) -> Result<EventStrongData, LoadError>

pub async fn load<D>(
    self: &Arc<Self>,
    key: &PrimaryKey
) -> Result<Dao<D>, LoadError> where
    D: DeserializeOwned, 

pub async fn load_and_take<D>(
    self: &Arc<Self>,
    key: &PrimaryKey
) -> Result<D, LoadError> where
    D: DeserializeOwned, 

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

pub async fn children_keys(
    self: &Arc<Self>,
    parent_id: PrimaryKey,
    collection_id: u64
) -> Result<Vec<PrimaryKey>, LoadError>

pub async fn __children_keys(
    self: &Arc<Self>,
    parent_id: PrimaryKey,
    collection_id: u64
) -> Result<Vec<PrimaryKey>, LoadError>

pub async fn root_keys(self: &Arc<Self>) -> Vec<PrimaryKey>

pub async fn __root_keys(self: &Arc<Self>) -> Vec<PrimaryKey>

pub async fn all_keys(self: &Arc<Self>) -> Vec<PrimaryKey>

pub async fn __all_keys(self: &Arc<Self>) -> Vec<PrimaryKey>

pub async fn children<D>(
    self: &Arc<Self>,
    parent_id: PrimaryKey,
    collection_id: u64
) -> Result<Vec<Dao<D>>, LoadError> where
    D: DeserializeOwned, 

pub async fn children_ext<D>(
    self: &Arc<Self>,
    parent_id: PrimaryKey,
    collection_id: u64,
    allow_missing_keys: bool,
    allow_serialization_error: bool
) -> Result<Vec<Dao<D>>, LoadError> where
    D: DeserializeOwned, 

pub async fn roots<D>(self: &Arc<Self>) -> Result<Vec<Dao<D>>, LoadError> where
    D: DeserializeOwned, 

pub async fn roots_ext<D>(
    self: &Arc<Self>,
    allow_missing_keys: bool,
    allow_serialization_error: bool
) -> Result<Vec<Dao<D>>, LoadError> where
    D: DeserializeOwned, 

pub async fn load_many<D>(
    self: &Arc<Self>,
    keys: impl Iterator<Item = PrimaryKey>
) -> Result<Vec<Dao<D>>, LoadError> where
    D: DeserializeOwned, 

pub async fn load_many_ext<D>(
    self: &Arc<Self>,
    keys: impl Iterator<Item = PrimaryKey>,
    allow_missing_keys: bool,
    allow_serialization_error: bool
) -> Result<Vec<Dao<D>>, LoadError> where
    D: DeserializeOwned, 

pub fn session<'a>(&'a self) -> DioSessionGuard<'a>

pub fn session_mut<'a>(&'a self) -> DioSessionGuardMut<'a>

pub async fn wait_for_accurate_timing(&self)

impl Dio

pub async fn as_mut(self: &Arc<Self>) -> Arc<DioMut>

pub async fn trans(self: &Arc<Self>, scope: TransactionScope) -> Arc<DioMut>

Trait Implementations

impl Debug for Dio

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

Formats the value using the given formatter.