Struct NodeAndContext 

pub struct NodeAndContext<SE, PA>
where
    SE: StorageEngine + Send + Sync + 'static,
    PA: PolicyAgent + Send + Sync + 'static,
{
    pub node: Node<SE, PA>,
    pub cdata: PA::ContextData,
}

Fields

node: Node<SE, PA>

cdata: PA::ContextData

Implementations

impl<SE, PA> NodeAndContext<SE, PA>

where SE: StorageEngine + Send + Sync + 'static, PA: PolicyAgent + Send + Sync + 'static,

pub async fn fetch_entities( &self, collection_id: &CollectionId, args: MatchArgs, ) -> Result<Vec<Entity>, RetrievalError>

Fetch a list of entities based on a selection

pub async fn commit_local_trx( &self, trx: &Transaction, ) -> Result<(), MutationError>

Does all the things necessary to commit a local transaction notably, the application of events to Entities works differently versus remote transactions

Trait Implementations

impl<SE: StorageEngine + Send + Sync + 'static, PA: PolicyAgent + Send + Sync + 'static> TContext for NodeAndContext<SE, PA>

fn node_id(&self) -> EntityId

fn create_entity( &self, collection: CollectionId, trx_alive: Arc<AtomicBool>, ) -> Entity

Create a brand new entity for a transaction, and add it to the WeakEntitySet Note that this does not actually persist the entity to the storage engine It merely ensures that there are no duplicate entities with the same ID (except forked entities)

fn check_write(&self, entity: &Entity) -> Result<(), AccessDenied>

fn get_entity<'life0, 'life1, 'async_trait>( &'life0 self, id: EntityId, collection: &'life1 CollectionId, cached: bool, ) -> Pin<Box<dyn Future<Output = Result<Entity, RetrievalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_resident_entity(&self, id: EntityId) -> Option<Entity>

fn fetch_entities<'life0, 'life1, 'async_trait>( &'life0 self, collection: &'life1 CollectionId, args: MatchArgs, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entity>, RetrievalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn commit_local_trx<'life0, 'life1, 'async_trait>( &'life0 self, trx: &'life1 Transaction, ) -> Pin<Box<dyn Future<Output = Result<(), MutationError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn query( &self, collection_id: CollectionId, args: MatchArgs, ) -> Result<EntityLiveQuery, RetrievalError>

fn collection<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 CollectionId, ) -> Pin<Box<dyn Future<Output = Result<StorageCollectionWrapper, RetrievalError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,