Struct Annotations

pub struct Annotations {
    pub created: Option<ResolveDateTime>,
    pub updated: Option<ResolveDateTime>,
    pub renderer: Option<Renderer>,
    pub template: Option<ByteString>,
    pub variables: FastHashMap<ByteString, Value>,
    pub headers: FastHashMap<ByteString, ByteString>,
    pub other: FastHashMap<ByteString, Value>,
}

Annotations.

Fields

created: Option<ResolveDateTime>

Created.

updated: Option<ResolveDateTime>

Last updated.

renderer: Option<Renderer>

Renderer.

template: Option<ByteString>

Template.

variables: FastHashMap<ByteString, Value>

Variables.

headers: FastHashMap<ByteString, ByteString>

Headers.

other: FastHashMap<ByteString, Value>

Other.

Implementations

impl Annotations

pub fn renderer(&self, configuration: &RenderConfiguration) -> Renderer

Renderer.

pub fn template<'own>( &'own self, configuration: &'own RenderConfiguration, ) -> &'own str

Template.

pub fn parse(identifier: &str, representation: &str, format: Format) -> Self

Parse.

pub fn traverse_variable(&self, keys: &RefValuePath<'_>) -> Option<&Value>

Traverse variable.

Trait Implementations

impl Clone for Annotations

fn clone(&self) -> Annotations

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Annotations

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

Formats the value using the given formatter.

impl Default for Annotations

fn default() -> Annotations

Returns the “default value” for a type.

impl<ContextT: ResolveContext, ErrorT: ResolveError> Resolve<Annotations, ContextT, ErrorT> for Value

fn resolve_for<'own, ErrorRecipientT>( &'own self, context: Option<&'own ContextT>, ancestor: Option<&'own Value>, errors: &mut ErrorRecipientT, ) -> ResolveResult<Annotations, ErrorT>

where ErrorRecipientT: ErrorRecipient<ErrorT>,

Resolve one type into another.

fn resolve_into<ErrorRecipientT>( &self, errors: &mut ErrorRecipientT, ) -> Result<Option<ResolvedT>, ErrorT>

where ErrorRecipientT: ErrorRecipient<ErrorT>,

Resolve one type into another with a provided ErrorRecipient.

fn resolve(&self) -> Result<Option<ResolvedT>, ErrorT>

Resolve one type into another while failing on the first encountered error.