stam 0.18.7

STAM is a powerful library for dealing with stand-off annotations on text. This is the Rust library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

/*
    STAM Library (Stand-off Text Annotation Model)
        by Maarten van Gompel <proycon@anaproy.nl>
        Digital Infrastucture, KNAW Humanities Cluster

        Licensed under the GNU General Public License v3

        https://github.com/annotation/stam-rust
*/

//! This module contains the high-level API for [`AnnotationSubStore`]. This API is implemented on
//! [`ResultItem<AnnotationSubStore>`].

use crate::api::*;
use crate::resources::TextResource;
use crate::substore::{AnnotationSubStore, AnnotationSubStoreHandle};

impl<'store> FullHandle<AnnotationSubStore> for ResultItem<'store, AnnotationSubStore> {
    fn fullhandle(&self) -> <AnnotationSubStore as Storable>::FullHandleType {
        self.handle()
    }
}

impl<'store, I> FullHandleToResultItem<'store, AnnotationSubStore>
    for FromHandles<'store, AnnotationSubStore, I>
where
    I: Iterator<Item = AnnotationSubStoreHandle>,
{
    fn get_item(
        &self,
        handle: AnnotationSubStoreHandle,
    ) -> Option<ResultItem<'store, AnnotationSubStore>> {
        self.store.substore(handle)
    }
}

impl<'store, I> FullHandleToResultItem<'store, AnnotationSubStore>
    for FilterAllIter<'store, AnnotationSubStore, I>
where
    I: Iterator<Item = ResultItem<'store, AnnotationSubStore>>,
{
    fn get_item(
        &self,
        handle: AnnotationSubStoreHandle,
    ) -> Option<ResultItem<'store, AnnotationSubStore>> {
        self.store.substore(handle)
    }
}

/// This is the implementation of the high-level API for [`AnnotationSubStore`].
impl<'store> ResultItem<'store, AnnotationSubStore> {
    /// Returns an iterator over all annotations in this substore.
    /// Results will be in chronological order
    pub fn annotations(&self) -> ResultIter<impl Iterator<Item = ResultItem<'store, Annotation>>> {
        ResultIter::new_sorted(FromHandles::new(
            self.as_ref().annotations.iter().copied(),
            self.store(),
        ))
    }

    /// Returns an iterator over all resources in this substore.
    /// Results will be in chronological order
    pub fn resources(&self) -> ResultIter<impl Iterator<Item = ResultItem<'store, TextResource>>> {
        ResultIter::new_sorted(FromHandles::new(
            self.as_ref().resources.iter().copied(),
            self.store(),
        ))
    }

    /// Returns an iterator over all datasets in this substore.
    /// Results will be in chronological order
    pub fn datasets(
        &self,
    ) -> ResultIter<impl Iterator<Item = ResultItem<'store, AnnotationDataSet>>> {
        ResultIter::new_sorted(FromHandles::new(
            self.as_ref().annotationsets.iter().copied(),
            self.store(),
        ))
    }

    /// Returns an iterator over all substores ([`AnnotationSubStore`] instances) in under this substore.
    /// The resulting iterator yields items as a fat pointer [`ResultItem<AnnotationSubStore>`]),
    /// which exposes the high-level API. Note that each substore may itself consist of further substores!
    pub fn substores<'a>(
        &'a self,
    ) -> ResultIter<impl Iterator<Item = ResultItem<'a, AnnotationSubStore>>> {
        let handle = self.handle();
        let store = self.store();
        ResultIter::new_sorted(store.iter().filter_map(move |a: &'a AnnotationSubStore| {
            if a.parents.contains(&Some(handle)) {
                Some(a.as_resultitem(store, store))
            } else {
                None
            }
        }))
    }
}