Struct stam::DataKey

pub struct DataKey { /* private fields */ }

The DataKey structure defines a vocabulary field or feature, as it is called in some annotation paradigms. it belongs to a certain AnnotationDataSet. An AnnotationData instance in turn makes reference to a DataKey and assigns it a value, producing a full key/value pair.

Implementations

impl DataKey

pub fn new(id: impl Into<String>) -> Self

Creates a new DataKey which you can add to an AnnotationDataSet using its [StoreFor<DataKey>.add()] method.

pub fn as_str(&self) -> &str

Returns the global id that identifies the key.

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

Writes a datakey to a STAM JSON string, with appropriate formatting

pub fn to_json_compact(&self) -> Result<String, StamError>

Writes a datakey to a STAM JSON string, without any indentation

Trait Implementations

impl Clone for DataKey

fn clone(&self) -> DataKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DataSize for DataKey

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 = 0usize

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 DataKey

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

Formats the value using the given formatter.

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

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

Decode a value using the given Decoder.

fn nil() -> Option<Self>

If possible, return a nil value of Self.

impl<'de> Deserialize<'de> for DataKey

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DataKey

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

Formats the value using the given formatter.

impl<Ctx> Encode<Ctx> for DataKey

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<DataKey> for str

fn eq(&self, other: &DataKey) -> 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 PartialEq<str> for DataKey

fn eq(&self, other: &str) -> 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 PartialEq for DataKey

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

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

where S: StoreFor<DataKey>,

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<'a> Request<DataKey> for Option<DataKeyHandle>

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

where S: StoreFor<DataKey>,

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

fn any(&self) -> bool

Represents a request for any value in certain contexts

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

impl Serialize for DataKey

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 DataKey

type HandleType = DataKeyHandle

type StoreHandleType = AnnotationDataSetHandle

type FullHandleType = (AnnotationDataSetHandle, DataKeyHandle)

type StoreType = AnnotationDataSet

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

Get the public identifier

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

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, intid: DataKeyHandle) -> 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<DataKey> for AnnotationDataSet

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

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

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

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

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

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 DataKey

fn typeinfo() -> Type

Return the type (introspection).

fn temp_id_prefix() -> &'static str

Return the prefix for temporary identifiers of this type