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 Annotation

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

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

pub fn raw_data(&self) -> &[(AnnotationDataSetHandle, AnnotationDataHandle)]

Provides access to the raw underlying data

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

Low-level method that returns raw data (handles) at specified index

pub fn has_data( &self, set: AnnotationDataSetHandle, handle: AnnotationDataHandle ) -> bool

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

const IS_DYNAMIC: bool = true

If true, the type has a heap size that can vary at runtime, depending on the actual value.

const STATIC_HEAP_SIZE: usize = 8usize

The amount of space a value of the type always occupies. If IS_DYNAMIC is false, this is the total amount of heap memory occupied by the value. Otherwise this is a lower bound.

fn estimate_heap_size(&self) -> usize

Estimates the size of heap memory taken up by this value.

impl Debug for Annotation

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

Formats the value using the given formatter.

impl<'bytes, Ctx> Decode<'bytes, Ctx> for Annotation

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx ) -> Result<Annotation, Error>

Decode a value using the given Decoder.

fn nil() -> Option<Self>

If possible, return a nil value of Self.

impl<Ctx> Encode<Ctx> for Annotation

fn encode<__W777>( &self, __e777: &mut Encoder<__W777>, __ctx777: &mut Ctx ) -> Result<(), Error<__W777::Error>>

where __W777: Write,

Encode a value of this type using the given Encoder.

fn is_nil(&self) -> bool

Is this value of Self a nil value?

impl PartialEq 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<'a> Request<Annotation> for AnnotationHandle

fn to_handle<'store, S>(&self, _store: &'store S) -> Option<AnnotationHandle>

where S: StoreFor<Annotation>,

Returns the handle for this item, looking it up in the store

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

If this type encapsulates an Id, this returns it (borrowed)

fn requested_id_owned(self) -> Option<String>

If this type encapsulates an Id, this returns it (oened)

fn requested_handle(&self) -> Option<T::HandleType>

If this type encapsulates a handle, this returns it

fn any(&self) -> bool

Represents a request for any value in certain contexts

impl SelfSelector for Annotation

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

Returns a selector to this resource

impl Storable for Annotation

type HandleType = AnnotationHandle

type StoreHandleType = ()

type FullHandleType = <Annotation as Storable>::HandleType

type StoreType = AnnotationStore

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

Get the public identifier

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

Retrieve the internal (numeric) id. For any type T in StoreFor<T>, this may return None only in the initial stage when it is still unbounded to a store, so this is almost always safe to unwrap when used in the public API.

fn with_handle(self, handle: Self::HandleType) -> Self

Set the internal ID for an item. May only be called once just after instantiation. This is a low-level API method that can not be used publicly due to ownership restrictions.

fn carries_id() -> bool

Does this type support an ID?

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

Builder pattern to set the public ID

fn fullhandle( _parenthandle: Self::StoreHandleType, handle: Self::HandleType ) -> Self::FullHandleType

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 temp_id(&self) -> Result<String, StamError>

Generate a temporary public ID based on the internal handle.

fn as_resultitem<'store>( &'store self, store: &'store Self::StoreType, rootstore: &'store AnnotationStore ) -> ResultItem<'store, Self>

where Self: Sized,

Returns the item of type T as a ResultItem<T>, i.e. a wrapped reference that includes a reference to both this item as well as the store that owns it. All high-level API functions are implemented on such Result types. You should not need to invoke this yourself.

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

where Self: Sized,

Generate a random ID in a given idmap (adds it to the map and assigns it to the item) This is a low-level API method that can not be used publicly due to ownership restrictions.

impl StoreFor<Annotation> for AnnotationStore

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

Get a reference to the entire store for the associated type This is a low-level API method.

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

Get a mutable reference to the entire store for the associated type This is a low-level API method.

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

Get a reference to the id map for the associated type, mapping global ids to internal ids This is a low-level API method.

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 This is a low-level API method.

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 add(self, item: T) -> Result<Self, StamError>

where Self: Sized,

Inserts items into the store using a builder pattern

fn has(&self, item: impl Request<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(&self, item: impl Request<T>) -> Result<&T, StamError>

Get a reference to an item from the store This is a low-level API method, you usually want to use dedicated high-level methods like AnnotationStore::annotation() instead.

fn get_mut(&mut self, item: impl Request<T>) -> Result<&mut T, StamError>

Get a mutable reference to an item from the store by internal ID This is a low-level API method

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. Also works for temporary IDs if enabled. This is a low-level API method. You usually don’t want to call this directly.

fn iter(&self) -> StoreIter<'_, T>

where T: Storable<StoreType = Self>,

Iterate over all items in the store This is a low-level API method, use dedicated high-level iterators like annotations(), resources() instead.

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

Iterate over the store, mutably This is a low-level API method.

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

Return the internal id that will be assigned for the next item to the store This is a low-level API method.

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

Return the internal id that was assigned to last inserted item This is a low-level API method.

impl TypeInfo for Annotation

fn typeinfo() -> Type

Return the type (introspection).

fn temp_id_prefix() -> &'static str

Return the prefix for temporary identifiers of this type