Struct stam::Annotation

pub struct Annotation { /* private fields */ }

Annotation represents a particular instance of annotation and is the central concept of the model. They can be considered the primary nodes of the graph model. The instance of annotation is strictly decoupled from the data or key/value of the annotation (AnnotationData). After all, multiple instances can be annotated with the same label (multiple annotations may share the same annotation data). Moreover, an Annotation can have multiple annotation data associated. The result is that multiple annotations with the exact same content require less storage space, and searching and indexing is facilitated.

Implementations

impl Annotation

pub fn to_json_string( &self, store: &AnnotationStore ) -> Result<String, StamError>

Writes an Annotation to one big STAM JSON string, with appropriate formatting

impl<'a> Annotation

pub fn new( id: Option<String>, target: Selector, data: Vec<(AnnotationDataSetHandle, AnnotationDataHandle)> ) -> Self

Create a new unbounded Annotation instance, you will likely want to use BuildAnnotation::new() instead and pass it to AnnotationStore.build()

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

Returns an Annotation builder to build new annotations

pub fn data( &'a self ) -> Iter<'a, (AnnotationDataSetHandle, AnnotationDataHandle)>

Iterate over the annotation data, returns tuples of internal IDs for (annotationset,annotationdata) For a higher-level method, use WrappedItem<Annotation>::data() instead.

pub fn data_by_index( &self, index: usize ) -> Option<&(AnnotationDataSetHandle, AnnotationDataHandle)>

Returns data at specified index

pub fn len(&self) -> usize

Returns the number of annotation data items

pub fn target(&self) -> &Selector

Returns a reference to the selector that selects the target of this annotation

Trait Implementations

impl Clone for Annotation

fn clone(&self) -> Annotation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Annotation

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

Formats the value using the given formatter.

impl PartialEq<Annotation> for Annotation

fn eq(&self, other: &Annotation) -> 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 Annotation

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

Returns a selector to this resource

impl Storable for Annotation

type HandleType = AnnotationHandle

type StoreType = AnnotationStore

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

Get 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: Self::HandleType)

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

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

Builder pattern to set the public Id

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 bound(&mut self)

Callback function that is called after an item is bound to a store

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<Annotation> for AnnotationStore

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

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

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

Get a reference to the entire store for the associated type

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

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

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

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<AnnotationHandle>>

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

fn store_typeinfo() -> &'static str

fn inserted(&mut self, handle: AnnotationHandle) -> 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 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 TypeInfo for Annotation

fn typeinfo() -> Type