Struct EntityIndex 

pub struct EntityIndex<CS, PS>
where
    CS: ChainStore,
    PS: PendingStore,
{ /* private fields */ }

Manages and index entities and their traits stored in the chain and pending store of the chain layer. The index accepts mutations from the chain layer through its event stream, and manages both indices to be consistent.

The chain index is persisted on disk, while the pending store index is an in-memory index. Since the persistence in the chain is not definitive until blocks and their operations (entity mutations) are stored at a certain depth, a part of the chain is actually indexed in the in-memory index. Once they reach a certain depth, they are persisted in the chain index.

Implementations

impl<CS, PS> EntityIndex<CS, PS>

where CS: ChainStore, PS: PendingStore,

pub fn open_or_create( cell: FullCell, config: EntityIndexConfig, chain_handle: EngineHandle<CS, PS>, clock: Clock, ) -> Result<EntityIndex<CS, PS>, Error>

Opens or create an entities index

pub fn handle_chain_engine_event( &mut self, event: Event, ) -> Result<(Vec<OperationId>, usize), Error>

pub fn handle_chain_engine_events<E>( &mut self, events: E, ) -> Result<(Vec<OperationId>, usize), Error>

where E: Iterator<Item = Event>,

Handles events coming from the chain layer. These events allow keeping the index consistent with the chain layer, up to the consistency guarantees that the layer offers. Returns operations that have been involved and the number of index operations applied.

Since the events stream is buffered, we may receive a discontinuity if the chain layer couldn’t send us an event. In that case, we re-index the pending index since we can’t guarantee that we didn’t lose an event.

pub fn maybe_index_chain_blocks(&mut self) -> Result<Vec<OperationId>, Error>

pub fn search<Q: Borrow<EntityQuery>>( &self, query: Q, ) -> Result<EntityResults, Error>

pub fn run_garbage_collector(&self) -> Result<Vec<EntityMutation>, Error>

Calls the garbage collector to run a pass on entities that got flagged and generates deletion mutations.