Struct stam::AnnotationDataSet

pub struct AnnotationDataSet { /* private fields */ }

An AnnotationDataSet stores the keys DataKey and values AnnotationData (which in turn encapsulates DataValue) that are used by annotations. It effectively defines a certain vocabulary, i.e. key/value pairs. The AnnotationDataSet does not store the crate::annotation::Annotation instances themselves, those are in the AnnotationStore. The datasets themselves are also held by the AnnotationStore.

Implementations

impl AnnotationDataSet

pub fn new(config: Config) -> Self

pub fn builder<'a>() -> AnnotationDataSetBuilder<'a>

Returns an Annotation dataset builder to build new annotation datasets

pub fn with_file( self, filename: &str, config: Config ) -> Result<Self, StamError>

Loads an AnnotationDataSet from file (STAM JSON or other supported format) and merges it into the current one. For STAM JSON, the file must contain a single object which has “@type”: “AnnotationDataSet” The ID will be ignored (existing one takes precendence).

pub fn from_file(filename: &str, config: Config) -> Result<Self, StamError>

Loads an AnnotationDataSet from file (STAM JSON or other supported format). For STAM JSON, the file must contain a single object which has “@type”: “AnnotationDataSet”

pub fn merge_from_builder( &mut self, builder: AnnotationDataSetBuilder<'_> ) -> Result<&mut Self, StamError>

Merge another AnnotationDataSet, represented by an AnnotationDataSetBuilder, into this one. It’s a fairly low-level function which you often don’t need directly, use AnnotationDataSet.with_file() instead.

pub fn with_data( self, id: Item<'_, AnnotationData>, key: Item<'_, DataKey>, value: DataValue ) -> Result<Self, StamError>

Adds new AnnotationData to the dataset, this should be Note: if you don’t want to set an ID (first argument), you can just just pass “”.into()

pub fn data_by_value( &self, key: Item<'_, DataKey>, value: &DataValue ) -> Option<&AnnotationData>

Finds the [AnnotationData'] in the annotation dataset. Returns one match. This is a low level method, use the similar [WrappedItem.find_data()`] for a higher level version.

pub fn insert_data<'a>( &mut self, id: Item<'a, AnnotationData>, key: Item<'a, DataKey>, value: DataValue, safety: bool ) -> Result<AnnotationDataHandle, StamError>

Adds new AnnotationData to the dataset. Use [Self.with_data()] instead if you are using a regular builder pattern. If the data already exists, this returns a handle to the existing data and inserts nothing new. If the data is new, it returns a handle to the new data.

Note: if you don’t want to set an ID (first argument), you can just pass AnyId::None or “”.into()

pub fn build_insert_data( &mut self, dataitem: AnnotationDataBuilder<'_>, safety: bool ) -> Result<AnnotationDataHandle, StamError>

Build and insert data into the dataset, similar to [Self.insert_data()] and [Self.with_data()], but takes a prepared AnnotationDataBuilder instead.

pub fn data(&self) -> StoreIter<'_, AnnotationData>

Returns an iterator over all the data (AnnotationData) in this set, the iterator returns references as [WrappedItem<AnnotationData].

pub fn keys(&self) -> StoreIter<'_, DataKey>

Returns an iterator over all the keys (DataKey) in this set, the iterator in returns references as WrappedItem<DataKey>

pub fn key(&self, key: &Item<'_, DataKey>) -> Option<WrappedItem<'_, DataKey>>

Retrieve a key in this set

pub fn annotationdata<'a>( &'a self, annotationdata: &Item<'_, AnnotationData> ) -> Option<WrappedItem<'a, AnnotationData>>

Retrieve a AnnotationData in this set

Returns a reference to AnnotationData that is wrapped in a fat pointer (WrappedItem<AnnotationData>) that also contains reference to the store and which is immediately implements various methods for working with the type. If you need a more performant low-level method, use StoreFor<T>::get() instead.

pub fn data_by_key( &self, key: &Item<'_, DataKey> ) -> Option<&Vec<AnnotationDataHandle>>

Returns data by key, does a lookup in the reverse index and returns a reference to it. This is a low-level method. use [WrappedItem<DataKey>.data()] instead.

pub fn with_id(self, id: String) -> Self

Sets the ID of the dataset in a builder pattern

pub fn keys_len(&self) -> usize

Writes a //Returns the number of keys in the store (deletions are not substracted)

pub fn data_len(&self) -> usize

Trait Implementations

impl AssociatedFile for AnnotationDataSet

fn filename(&self) -> Option<&str>

Get the filename for stand-off file specified using @include (if any)

fn set_filename(&mut self, filename: &str) -> &mut Self

Get the filename for stand-off file specified using @include (if any)

fn with_filename(self, filename: &str) -> Selfwhere Self: Sized,

fn filename_without_extension(&self) -> Option<&str>

Returns the filename without (known!) extension. The extension must be a known extension used by STAM for this to work.

fn filename_without_workdir(&self) -> Option<&str>

Serializes the filename ready for use with STAM JSON’s @include or STAM CSV. It basically only strips the workdir component, if any.

impl Clone for AnnotationDataSet

fn clone(&self) -> AnnotationDataSet

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Configurable for AnnotationDataSet

fn config(&self) -> &Config

fn config_mut(&mut self) -> &mut Config

fn set_config(&mut self, config: Config) -> &mut Self

Setter to associate a configuration

fn with_config(self, config: Config) -> Self

Builder pattern to associate a configuration

impl Debug for AnnotationDataSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AnnotationDataSet

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AnnotationDataSet

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'j> FromJson<'j> for AnnotationDataSet

fn from_json_file(filename: &str, config: Config) -> Result<Self, StamError>

Loads an AnnotationDataSet from a STAM JSON file The file must contain a single object which has “@type”: “AnnotationDataSet” If workdir is set, the file will be searched for in the workdir if needed

fn from_json_str(string: &str, config: Config) -> Result<Self, StamError>

Loads an AnnotationDataSet from a STAM JSON string The string must contain a single object which has “@type”: “AnnotationDataSet”

impl PartialEq<AnnotationDataSet> for AnnotationDataSet

fn eq(&self, other: &AnnotationDataSet) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SelfSelector for AnnotationDataSet

fn selector(&self) -> Result<Selector, StamError>

Returns a selector to this resource

impl Serialize for AnnotationDataSet

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl Storable for AnnotationDataSet

fn bound(&mut self)

Sets the ownership of all items in the store This ensure the part_of_set relation (backreference) is set right.

type HandleType = AnnotationDataSetHandle

type StoreType = AnnotationStore

fn id(&self) -> Option<&str>

Get the public ID

fn with_id(self, id: String) -> Self

Builder pattern to set the public Id

fn handle(&self) -> Option<Self::HandleType>

Retrieve the internal (numeric) id. For any type T uses in StoreFor<T>, this may be None only in the initial stage when it is still unbounded to a store.

fn set_handle(&mut self, handle: AnnotationDataSetHandle)

Set the internal ID. May only be called once (though currently not enforced).

fn carries_id() -> bool

Does this type support an ID?

fn handle_or_err(&self) -> Result<Self::HandleType, StamError>

Like Self::handle() but returns a StamError::Unbound error if there is no internal id.

fn id_or_err(&self) -> Result<&str, StamError>

Like Self::id() but returns a StamError::NoIdError error if there is no internal id.

fn wrap_in<'store>( &'store self, store: &'store Self::StoreType ) -> Result<WrappedItem<'store, Self>, StamError>where Self: Sized,

Returns a wrapped reference to this item and the store that owns it. This allows for some more introspection on the part of the item. reverse of StoreFor<T>::wrap()

fn wrap_owned_in<'store>( self, store: &'store Self::StoreType ) -> Result<WrappedItem<'store, Self>, StamError>where Self: Sized,

Returns a wrapped reference to this item and the store that owns it. This allows for some more introspection on the part of the item. reverse of StoreFor<T>::wrap_owned()

fn generate_id(self, idmap: Option<&mut IdMap<Self::HandleType>>) -> Selfwhere Self: Sized,

Generate a random ID in a given idmap (adds it to the map and assigns it to the item)

impl StoreFor<AnnotationData> for AnnotationDataSet

fn preremove(&mut self, handle: AnnotationDataHandle) -> Result<(), StamError>

called before the item is removed from the store updates the relation maps, no need to call manually

fn store(&self) -> &Store<AnnotationData>

Get a reference to the entire store for the associated type

fn store_mut(&mut self) -> &mut Store<AnnotationData>

Get a mutable reference to the entire store for the associated type

fn idmap(&self) -> Option<&IdMap<AnnotationDataHandle>>

Get a reference to the id map for the associated type, mapping global ids to internal ids

fn idmap_mut(&mut self) -> Option<&mut IdMap<AnnotationDataHandle>>

Get a mutable reference to the id map for the associated type, mapping global ids to internal ids

fn owns(&self, item: &AnnotationData) -> Option<bool>

Tests if the item is owner by the store, returns None if ownership is unknown

fn store_typeinfo() -> &'static str

fn inserted(&mut self, handle: AnnotationDataHandle) -> Result<(), StamError>

Called after an item was inserted to the store Allows the store to do further bookkeeping like updating relation maps

fn insert(&mut self, item: T) -> Result<T::HandleType, StamError>

Adds an item to the store. Returns a handle to it upon success.

fn preinsert(&self, item: &mut T) -> Result<(), StamError>

Called prior to inserting an item into to the store If it returns an error, the insert will be cancelled. Allows for bookkeeping such as inheriting configuration parameters from parent to the item

fn add(self, item: T) -> Result<Self, StamError>where Self: Sized,

fn has<'a, 'b>(&'a self, item: &Item<'b, T>) -> bool

Returns true if the store has the item

unsafe fn get_unchecked(&self, handle: T::HandleType) -> Option<&T>

Get a reference to an item from the store, by handle, without checking validity.

fn get<'a, 'b>(&'a self, item: &Item<'b, T>) -> Result<&'a T, StamError>

Get a reference to an item from the store

fn get_mut<'a, 'b>(&mut self, item: &Item<'b, T>) -> Result<&mut T, StamError>

Get a mutable reference to an item from the store by internal ID

fn remove(&mut self, handle: T::HandleType) -> Result<(), StamError>

Removes an item by handle, returns an error if the item has dependencies and can’t be removed

fn resolve_id(&self, id: &str) -> Result<T::HandleType, StamError>

Resolves an ID to a handle You usually don’t want to call this directly

fn iter<'a>(&'a self) -> StoreIter<'a, T> where T: Storable<StoreType = Self>,

Iterate over the store

fn iter_mut<'a>(&'a mut self) -> StoreIterMut<'a, T>

Iterate over the store, mutably

fn next_handle(&self) -> T::HandleType

Return the internal id that will be assigned for the next item to the store

fn last_handle(&self) -> T::HandleType

Return the internal id that was assigned to last inserted item

fn bind(&mut self, item: T) -> Result<T, StamError>

This binds an item to the store PRIOR to it being actually added You should never need to call this directly (it can only be called once per item anyway).

fn wrap<'a>(&'a self, item: &'a T) -> Result<WrappedItem<'_, T>, StamError>where T: Storable<StoreType = Self>,

Wraps the item in a smart pointer that also holds a reference to this store This method performs some extra checks to verify if the item is indeed owned by the store and returns an error if not.

fn wrap_owned<'a>(&'a self, item: T) -> Result<WrappedItem<'_, T>, StamError>where T: Storable<StoreType = Self>,

Wraps the item in a smart pointer that also holds a reference to this store Ownership is retained with this method, i.e. the store does NOT own the item.

fn wrap_store<'a>(&'a self) -> WrappedStore<'_, T, Self>where Self: Sized,

Wraps the entire store along with a reference to self Low-level method that you won’t need

impl StoreFor<AnnotationDataSet> for AnnotationStore

fn preinsert(&self, item: &mut AnnotationDataSet) -> Result<(), StamError>

Called prior to inserting an item into to the store If it returns an error, the insert will be cancelled. Allows for bookkeeping such as inheriting configuration parameters from parent to the item

fn preremove( &mut self, handle: AnnotationDataSetHandle ) -> Result<(), StamError>

called before the item is removed from the store updates the relation maps, no need to call manually

fn store(&self) -> &Store<AnnotationDataSet>

Get a reference to the entire store for the associated type

fn store_mut(&mut self) -> &mut Store<AnnotationDataSet>

Get a mutable reference to the entire store for the associated type

fn idmap(&self) -> Option<&IdMap<AnnotationDataSetHandle>>

Get a reference to the id map for the associated type, mapping global ids to internal ids

fn idmap_mut(&mut self) -> Option<&mut IdMap<AnnotationDataSetHandle>>

Get a mutable reference to the id map for the associated type, mapping global ids to internal ids

fn store_typeinfo() -> &'static str

fn insert(&mut self, item: T) -> Result<T::HandleType, StamError>

Adds an item to the store. Returns a handle to it upon success.

fn inserted(&mut self, handle: T::HandleType) -> Result<(), StamError>

Called after an item was inserted to the store Allows the store to do further bookkeeping like updating relation maps

fn add(self, item: T) -> Result<Self, StamError>where Self: Sized,

fn has<'a, 'b>(&'a self, item: &Item<'b, T>) -> bool

Returns true if the store has the item

unsafe fn get_unchecked(&self, handle: T::HandleType) -> Option<&T>

Get a reference to an item from the store, by handle, without checking validity.

fn get<'a, 'b>(&'a self, item: &Item<'b, T>) -> Result<&'a T, StamError>

Get a reference to an item from the store

fn get_mut<'a, 'b>(&mut self, item: &Item<'b, T>) -> Result<&mut T, StamError>

Get a mutable reference to an item from the store by internal ID

fn remove(&mut self, handle: T::HandleType) -> Result<(), StamError>

Removes an item by handle, returns an error if the item has dependencies and can’t be removed

fn resolve_id(&self, id: &str) -> Result<T::HandleType, StamError>

Resolves an ID to a handle You usually don’t want to call this directly

fn owns(&self, item: &T) -> Option<bool>

Tests if the item is owner by the store, returns None if ownership is unknown

fn iter<'a>(&'a self) -> StoreIter<'a, T> where T: Storable<StoreType = Self>,

Iterate over the store

fn iter_mut<'a>(&'a mut self) -> StoreIterMut<'a, T>

Iterate over the store, mutably

fn next_handle(&self) -> T::HandleType

Return the internal id that will be assigned for the next item to the store

fn last_handle(&self) -> T::HandleType

Return the internal id that was assigned to last inserted item

fn bind(&mut self, item: T) -> Result<T, StamError>

This binds an item to the store PRIOR to it being actually added You should never need to call this directly (it can only be called once per item anyway).

fn wrap<'a>(&'a self, item: &'a T) -> Result<WrappedItem<'_, T>, StamError>where T: Storable<StoreType = Self>,

Wraps the item in a smart pointer that also holds a reference to this store This method performs some extra checks to verify if the item is indeed owned by the store and returns an error if not.

fn wrap_owned<'a>(&'a self, item: T) -> Result<WrappedItem<'_, T>, StamError>where T: Storable<StoreType = Self>,

Wraps the item in a smart pointer that also holds a reference to this store Ownership is retained with this method, i.e. the store does NOT own the item.

fn wrap_store<'a>(&'a self) -> WrappedStore<'_, T, Self>where Self: Sized,

Wraps the entire store along with a reference to self Low-level method that you won’t need

impl StoreFor<DataKey> for AnnotationDataSet

fn preremove(&mut self, handle: DataKeyHandle) -> Result<(), StamError>

called before the item is removed from the store updates the relation maps, no need to call manually

fn store(&self) -> &Store<DataKey>

Get a reference to the entire store for the associated type

fn store_mut(&mut self) -> &mut Store<DataKey>

Get a mutable reference to the entire store for the associated type

fn idmap(&self) -> Option<&IdMap<DataKeyHandle>>

Get a reference to the id map for the associated type, mapping global ids to internal ids

fn idmap_mut(&mut self) -> Option<&mut IdMap<DataKeyHandle>>

Get a mutable reference to the id map for the associated type, mapping global ids to internal ids

fn owns(&self, item: &DataKey) -> Option<bool>

Tests if the item is owner by the store, returns None if ownership is unknown

fn store_typeinfo() -> &'static str

fn inserted(&mut self, handle: DataKeyHandle) -> Result<(), StamError>

Called after an item was inserted to the store Allows the store to do further bookkeeping like updating relation maps

fn insert(&mut self, item: T) -> Result<T::HandleType, StamError>

Adds an item to the store. Returns a handle to it upon success.

fn preinsert(&self, item: &mut T) -> Result<(), StamError>

Called prior to inserting an item into to the store If it returns an error, the insert will be cancelled. Allows for bookkeeping such as inheriting configuration parameters from parent to the item

fn add(self, item: T) -> Result<Self, StamError>where Self: Sized,

fn has<'a, 'b>(&'a self, item: &Item<'b, T>) -> bool

Returns true if the store has the item

unsafe fn get_unchecked(&self, handle: T::HandleType) -> Option<&T>

Get a reference to an item from the store, by handle, without checking validity.

fn get<'a, 'b>(&'a self, item: &Item<'b, T>) -> Result<&'a T, StamError>

Get a reference to an item from the store

fn get_mut<'a, 'b>(&mut self, item: &Item<'b, T>) -> Result<&mut T, StamError>

Get a mutable reference to an item from the store by internal ID

fn remove(&mut self, handle: T::HandleType) -> Result<(), StamError>

Removes an item by handle, returns an error if the item has dependencies and can’t be removed

fn resolve_id(&self, id: &str) -> Result<T::HandleType, StamError>

Resolves an ID to a handle You usually don’t want to call this directly

fn iter<'a>(&'a self) -> StoreIter<'a, T> where T: Storable<StoreType = Self>,

Iterate over the store

fn iter_mut<'a>(&'a mut self) -> StoreIterMut<'a, T>

Iterate over the store, mutably

fn next_handle(&self) -> T::HandleType

Return the internal id that will be assigned for the next item to the store

fn last_handle(&self) -> T::HandleType

Return the internal id that was assigned to last inserted item

fn bind(&mut self, item: T) -> Result<T, StamError>

This binds an item to the store PRIOR to it being actually added You should never need to call this directly (it can only be called once per item anyway).

fn wrap<'a>(&'a self, item: &'a T) -> Result<WrappedItem<'_, T>, StamError>where T: Storable<StoreType = Self>,

Wraps the item in a smart pointer that also holds a reference to this store This method performs some extra checks to verify if the item is indeed owned by the store and returns an error if not.

fn wrap_owned<'a>(&'a self, item: T) -> Result<WrappedItem<'_, T>, StamError>where T: Storable<StoreType = Self>,

Wraps the item in a smart pointer that also holds a reference to this store Ownership is retained with this method, i.e. the store does NOT own the item.

fn wrap_store<'a>(&'a self) -> WrappedStore<'_, T, Self>where Self: Sized,

Wraps the entire store along with a reference to self Low-level method that you won’t need

impl ToCsv for AnnotationDataSet

fn to_csv_writer<W>(&self, writer: W, _table: CsvTable) -> Result<(), StamError>where W: Write,

Writes CSV output, for the specified table, to the writer

fn to_csv_file( &self, filename: &str, config: &Config, table: CsvTable ) -> Result<(), StamError>

Writes this structure to a file The actual dataformat can be set via config, the default is STAM JSON. Note: This only writes a single table! Just use [AnnotationStore.save()] to write everything.

fn to_csv_string(&self, table: Option<CsvTable>) -> Result<String, StamError>

impl ToJson for AnnotationDataSet

fn to_json_writer<W>(&self, writer: W, compact: bool) -> Result<(), StamError>where W: Write,

Writes a serialisation (choose a dataformat) to any writer Lower-level function

fn to_json_file(&self, filename: &str, config: &Config) -> Result<(), StamError>

Writes this structure to a file The actual dataformat can be set via config, the default is STAM JSON.

fn to_json_string(&self, config: &Config) -> Result<String, StamError>

Serializes this structure to one string. The actual dataformat can be set via config, the default is STAM JSON. If config not not specified, an attempt to fetch the AnnotationStore’s initial config is made

impl<'a> TryFrom<AnnotationDataSetBuilder<'a>> for AnnotationDataSet

type Error = StamError

The type returned in the event of a conversion error.

fn try_from(builder: AnnotationDataSetBuilder<'a>) -> Result<Self, StamError>

Performs the conversion.

impl TypeInfo for AnnotationDataSet

fn typeinfo() -> Type