Trait terminus_store::storage::LayerStore

pub trait LayerStore: 'static + Packable + Send + Sync {
    // Required methods
    fn layers<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<[u32; 5]>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_layer_with_cache<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5],
        cache: Arc<dyn LayerCache>
    ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<InternalLayer>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_layer_parent_name<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<[u32; 5]>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_node_dictionary<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<StringDict>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_predicate_dictionary<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<StringDict>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_value_dictionary<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<TypedDict>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_node_count<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_predicate_count<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_value_count<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_node_value_idmap<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<IdMap>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_predicate_idmap<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<IdMap>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_base_layer<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn LayerBuilder>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_child_layer_with_cache<'life0, 'async_trait>(
        &'life0 self,
        parent: [u32; 5],
        cache: Arc<dyn LayerCache>
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn LayerBuilder>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn perform_rollup<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn perform_rollup_upto_with_cache<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5],
        cache: Arc<dyn LayerCache>
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn perform_imprecise_rollup_upto_with_cache<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5],
        cache: Arc<dyn LayerCache>
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_rollup<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        rollup: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn squash<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn squash_upto<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn merge_base_layer<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        layers: &'life1 [[u32; 5]],
        temp_dir: &'life2 Path
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn layer_is_ancestor_of<'life0, 'async_trait>(
        &'life0 self,
        descendant: [u32; 5],
        ancestor: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_addition_exists<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        subject: u64,
        predicate: u64,
        object: u64
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_removal_exists<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        subject: u64,
        predicate: u64,
        object: u64
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_additions<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<OptInternalLayerTripleSubjectIterator>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_removals<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<OptInternalLayerTripleSubjectIterator>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_additions_s<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        subject: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_removals_s<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        subject: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_additions_sp<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        subject: u64,
        predicate: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_removals_sp<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        subject: u64,
        predicate: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_additions_p<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        predicate: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_removals_o<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        object: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_additions_o<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        object: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_removals_p<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5],
        predicate: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_layer_addition_count<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn triple_layer_removal_count<'life0, 'async_trait>(
        &'life0 self,
        layer: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn retrieve_layer_stack_names<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Vec<[u32; 5]>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn retrieve_layer_stack_names_upto<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5],
        upto: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Vec<[u32; 5]>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided methods
    fn get_layer<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<InternalLayer>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn finalize_layer<'life0, 'async_trait>(
        &'life0 self,
        _name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn create_child_layer<'life0, 'async_trait>(
        &'life0 self,
        parent: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn LayerBuilder>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn perform_rollup_upto<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn perform_imprecise_rollup_upto<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn rollup<'async_trait>(
        self: Arc<Self>,
        layer: Arc<InternalLayer>
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait { ... }
    fn rollup_upto_with_cache<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5],
        cache: Arc<dyn LayerCache>
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn rollup_upto<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn imprecise_rollup_upto_with_cache<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5],
        cache: Arc<dyn LayerCache>
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn imprecise_rollup_upto<'life0, 'async_trait>(
        &'life0 self,
        layer: Arc<InternalLayer>,
        upto: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn layer_changes<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<InternalTripleStackIterator>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn layer_changes_upto<'life0, 'async_trait>(
        &'life0 self,
        name: [u32; 5],
        upto: [u32; 5]
    ) -> Pin<Box<dyn Future<Output = Result<InternalTripleStackIterator>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
}

Required Methods

fn layers<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<[u32; 5]>>> + Send + 'async_trait>>

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

fn get_layer_with_cache<'life0, 'async_trait>( &'life0 self, name: [u32; 5], cache: Arc<dyn LayerCache> ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<InternalLayer>>>> + Send + 'async_trait>>

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

fn get_layer_parent_name<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<[u32; 5]>>> + Send + 'async_trait>>

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

fn get_node_dictionary<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<StringDict>>> + Send + 'async_trait>>

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

fn get_predicate_dictionary<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<StringDict>>> + Send + 'async_trait>>

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

fn get_value_dictionary<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<TypedDict>>> + Send + 'async_trait>>

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

fn get_node_count<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>

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

fn get_predicate_count<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>

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

fn get_value_count<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>

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

fn get_node_value_idmap<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<IdMap>>> + Send + 'async_trait>>

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

fn get_predicate_idmap<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<IdMap>>> + Send + 'async_trait>>

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

fn create_base_layer<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Box<dyn LayerBuilder>>> + Send + 'async_trait>>

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

fn create_child_layer_with_cache<'life0, 'async_trait>( &'life0 self, parent: [u32; 5], cache: Arc<dyn LayerCache> ) -> Pin<Box<dyn Future<Output = Result<Box<dyn LayerBuilder>>> + Send + 'async_trait>>

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

fn perform_rollup<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer> ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn perform_rollup_upto_with_cache<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5], cache: Arc<dyn LayerCache> ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn perform_imprecise_rollup_upto_with_cache<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5], cache: Arc<dyn LayerCache> ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn register_rollup<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], rollup: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

fn squash<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer> ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn squash_upto<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn merge_base_layer<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, layers: &'life1 [[u32; 5]], temp_dir: &'life2 Path ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn layer_is_ancestor_of<'life0, 'async_trait>( &'life0 self, descendant: [u32; 5], ancestor: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

fn triple_addition_exists<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], subject: u64, predicate: u64, object: u64 ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

fn triple_removal_exists<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], subject: u64, predicate: u64, object: u64 ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

fn triple_additions<'life0, 'async_trait>( &'life0 self, layer: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<OptInternalLayerTripleSubjectIterator>> + Send + 'async_trait>>

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

fn triple_removals<'life0, 'async_trait>( &'life0 self, layer: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<OptInternalLayerTripleSubjectIterator>> + Send + 'async_trait>>

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

fn triple_additions_s<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], subject: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_removals_s<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], subject: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_additions_sp<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], subject: u64, predicate: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_removals_sp<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], subject: u64, predicate: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_additions_p<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], predicate: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_removals_o<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], object: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_additions_o<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], object: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_removals_p<'life0, 'async_trait>( &'life0 self, layer: [u32; 5], predicate: u64 ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send + 'async_trait>>

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

fn triple_layer_addition_count<'life0, 'async_trait>( &'life0 self, layer: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

fn triple_layer_removal_count<'life0, 'async_trait>( &'life0 self, layer: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

fn retrieve_layer_stack_names<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Vec<[u32; 5]>>> + Send + 'async_trait>>

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

fn retrieve_layer_stack_names_upto<'life0, 'async_trait>( &'life0 self, name: [u32; 5], upto: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Vec<[u32; 5]>>> + Send + 'async_trait>>

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

Provided Methods

fn get_layer<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<InternalLayer>>>> + Send + 'async_trait>>

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

fn finalize_layer<'life0, 'async_trait>( &'life0 self, _name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

fn create_child_layer<'life0, 'async_trait>( &'life0 self, parent: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<Box<dyn LayerBuilder>>> + Send + 'async_trait>>

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

fn perform_rollup_upto<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn perform_imprecise_rollup_upto<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn rollup<'async_trait>( self: Arc<Self>, layer: Arc<InternalLayer> ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

where Self: 'async_trait,

Create a new rollup layer which rolls up all triples in the given layer, as well as all its ancestors.

It is a good idea to keep layer stacks small, meaning, to only have a handful of ancestors for a layer. The more layers there are, the longer queries take. Rollup is one approach of accomplishing this. Squash is another. Rollup is the better option if you need to retain history.

fn rollup_upto_with_cache<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5], cache: Arc<dyn LayerCache> ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn rollup_upto<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

Create a new rollup layer which rolls up all triples in the given layer, as well as all ancestors up to (but not including) the given ancestor.

It is a good idea to keep layer stacks small, meaning, to only have a handful of ancestors for a layer. The more layers there are, the longer queries take. Rollup is one approach of accomplishing this. Squash is another. Rollup is the better option if you need to retain history.

fn imprecise_rollup_upto_with_cache<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5], cache: Arc<dyn LayerCache> ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

fn imprecise_rollup_upto<'life0, 'async_trait>( &'life0 self, layer: Arc<InternalLayer>, upto: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<[u32; 5]>> + Send + 'async_trait>>

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

Create a new rollup layer which rolls up all triples in the given layer, as well as all ancestors up to (but not including) the given ancestor.

It is a good idea to keep layer stacks small, meaning, to only have a handful of ancestors for a layer. The more layers there are, the longer queries take. Rollup is one approach of accomplishing this. Squash is another. Rollup is the better option if you need to retain history.

fn layer_changes<'life0, 'async_trait>( &'life0 self, name: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<InternalTripleStackIterator>> + Send + 'async_trait>>

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

fn layer_changes_upto<'life0, 'async_trait>( &'life0 self, name: [u32; 5], upto: [u32; 5] ) -> Pin<Box<dyn Future<Output = Result<InternalTripleStackIterator>> + Send + 'async_trait>>

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

Implementors

impl LayerStore for CachedLayerStore

impl<F: 'static + FileLoad + FileStore + Clone, T: 'static + PersistentLayerStore<File = F>> LayerStore for T