Struct stam::AnnotationData

pub struct AnnotationData { /* private fields */ }

AnnotationData holds the actual content of an annotation; a key/value pair. (the term feature is regularly seen for this in certain annotation paradigms). Annotation Data is deliberately decoupled from the actual Annotation instances so multiple annotation instances can point to the same content without causing any overhead in storage. Moreover, it facilitates indexing and searching. The annotation data is part of an AnnotationDataSet, which effectively defines a certain user-defined vocabulary.

Once instantiated, instances of this type are, by design, largely immutable. The key and value can not be changed. Create a new AnnotationData and new Annotation for edits.

Implementations

impl AnnotationData

pub fn key(&self) -> DataKeyHandle

pub fn value(&self) -> &DataValue

Get the value of this annotationdata. The value will be a DataValue instance. This will return an immutable reference. Note that there is no mutable variant nor a set_value(), values can deliberately only be set once at instantiation. Make a new AnnotationData if you want to change data.

pub fn to_json(&self, store: &AnnotationDataSet) -> Result<String, StamError>

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

Trait Implementations

impl Clone for AnnotationData

fn clone(&self) -> AnnotationData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DataSize for AnnotationData

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 AnnotationData

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

Formats the value using the given formatter.

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

fn decode( __d777: &mut Decoder<'bytes>, __ctx777: &mut Ctx ) -> Result<AnnotationData, 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 AnnotationData

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 AnnotationData

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

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

where S: StoreFor<AnnotationData>,

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 Storable for AnnotationData

type HandleType = AnnotationDataHandle

type StoreHandleType = AnnotationDataSetHandle

type FullHandleType = (AnnotationDataSetHandle, AnnotationDataHandle)

type StoreType = AnnotationDataSet

fn handle(&self) -> Option<AnnotationDataHandle>

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 id(&self) -> Option<&str>

Get the public identifier

fn with_handle(self, intid: AnnotationDataHandle) -> 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 with_id(self, id: impl Into<String>) -> Self

Builder pattern to set the public ID

fn carries_id() -> bool

Does this type support an ID?

fn fullhandle( storehandle: 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<AnnotationData> for AnnotationDataSet

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

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

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

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

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

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 AnnotationData

fn typeinfo() -> Type

Return the type (introspection).

fn temp_id_prefix() -> &'static str

Return the prefix for temporary identifiers of this type