Trait DataIterator 

pub trait DataIterator<'store>: Iterator<Item = ResultItem<'store, AnnotationData>>
where
    Self: Sized,
{
    // Provided methods
    fn parallel(self) -> IntoIter<ResultItem<'store, AnnotationData>> { ... }
    fn annotations(
        self,
    ) -> ResultIter<<Vec<ResultItem<'store, Annotation>> as IntoIterator>::IntoIter>  { ... }
    fn annotations_as_metadata(
        self,
    ) -> ResultIter<<Vec<ResultItem<'store, Annotation>> as IntoIterator>::IntoIter>  { ... }
    fn keys(
        self,
    ) -> ResultIter<<Vec<ResultItem<'store, DataKey>> as IntoIterator>::IntoIter>  { ... }
    fn filter_handle(
        self,
        set: AnnotationDataSetHandle,
        data: AnnotationDataHandle,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_key(
        self,
        key: &ResultItem<'store, DataKey>,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_key_handle(
        self,
        set: AnnotationDataSetHandle,
        key: DataKeyHandle,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_set(
        self,
        set: &ResultItem<'store, AnnotationDataSet>,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_set_handle(
        self,
        set: AnnotationDataSetHandle,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_key_handle_value(
        self,
        set: AnnotationDataSetHandle,
        key: DataKeyHandle,
        value: DataOperator<'store>,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_value(
        self,
        operator: DataOperator<'store>,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_any(self, data: Data<'store>) -> FilteredData<'store, Self>  { ... }
    fn filter_any_byref(
        self,
        data: &'store Data<'store>,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_all(
        self,
        data: Data<'store>,
        store: &'store AnnotationStore,
    ) -> FilterAllIter<'store, AnnotationData, Self>  { ... }
    fn filter_one(
        self,
        data: &ResultItem<'store, AnnotationData>,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_data_handle(
        self,
        set: AnnotationDataSetHandle,
        data: AnnotationDataHandle,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_annotation(
        self,
        annotation: &ResultItem<'store, Annotation>,
    ) -> FilteredData<'store, Self>  { ... }
    fn filter_annotation_handle(
        self,
        annotation: AnnotationHandle,
    ) -> FilteredData<'store, Self>  { ... }
}

Trait for iteration over annotation data (ResultItem<AnnotationData>; encapsulation over AnnotationData). Implements numerous filter methods to further constrain the iterator, as well as methods to map from annotation data to other items.

Provided Methods

fn parallel(self) -> IntoIter<ResultItem<'store, AnnotationData>>

fn annotations( self, ) -> ResultIter<<Vec<ResultItem<'store, Annotation>> as IntoIterator>::IntoIter>

Iterate over the annotations that make use of data in this iterator. Annotations will be returned chronologically (add .textual_order() to sort textually) and contain no duplicates.

fn annotations_as_metadata( self, ) -> ResultIter<<Vec<ResultItem<'store, Annotation>> as IntoIterator>::IntoIter>

Iterates over all the annotations for all data in this iterator. This only returns annotations that target the data via an AnnotationDataSelection, i.e. the annotations provide metadata for the data.

The iterator will be consumed and an extra buffer is allocated. Annotations will be returned sorted chronologically and returned without duplicates

fn keys( self, ) -> ResultIter<<Vec<ResultItem<'store, DataKey>> as IntoIterator>::IntoIter>

Iterate over the keys used in this data Keys will be returned chronologically without duplicates.

fn filter_handle( self, set: AnnotationDataSetHandle, data: AnnotationDataHandle, ) -> FilteredData<'store, Self>

fn filter_key( self, key: &ResultItem<'store, DataKey>, ) -> FilteredData<'store, Self>

fn filter_key_handle( self, set: AnnotationDataSetHandle, key: DataKeyHandle, ) -> FilteredData<'store, Self>

fn filter_set( self, set: &ResultItem<'store, AnnotationDataSet>, ) -> FilteredData<'store, Self>

fn filter_set_handle( self, set: AnnotationDataSetHandle, ) -> FilteredData<'store, Self>

fn filter_key_handle_value( self, set: AnnotationDataSetHandle, key: DataKeyHandle, value: DataOperator<'store>, ) -> FilteredData<'store, Self>

fn filter_value( self, operator: DataOperator<'store>, ) -> FilteredData<'store, Self>

fn filter_any(self, data: Data<'store>) -> FilteredData<'store, Self>

fn filter_any_byref( self, data: &'store Data<'store>, ) -> FilteredData<'store, Self>

fn filter_all( self, data: Data<'store>, store: &'store AnnotationStore, ) -> FilterAllIter<'store, AnnotationData, Self>

Constrain this iterator to filter on all of the mentioned data, that is. If not all of the items in the parameter exist in the iterator, the iterator returns nothing.

fn filter_one( self, data: &ResultItem<'store, AnnotationData>, ) -> FilteredData<'store, Self>

fn filter_data_handle( self, set: AnnotationDataSetHandle, data: AnnotationDataHandle, ) -> FilteredData<'store, Self>

fn filter_annotation( self, annotation: &ResultItem<'store, Annotation>, ) -> FilteredData<'store, Self>

fn filter_annotation_handle( self, annotation: AnnotationHandle, ) -> FilteredData<'store, Self>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'store, I> DataIterator<'store> for I

where I: Iterator<Item = ResultItem<'store, AnnotationData>>,