Enum StringValue 

pub enum StringValue<T: StringValueData> {
    Raw(String),
    Parsed(T),
}

A string value that can either be stored as a raw unparsed string or as a parsed value of type T.

The type T must implement the StringValueData trait, which defines how to parse and serialize the value. This type is used whenever an EML_NL document element or attribute contains a string value that could be parsed, but where strict parsing is not always desired.

Depending on the parsing mode used when parsing a document, StringValue instances may either contain the raw string or the parsed value. When EMLParsingMode::Strict is used, all StringValue instances will contain the parsed value. When EMLParsingMode::StrictFallback is used, the library will attempt to parse values but will fall back to storing the raw string if parsing fails. When EMLParsingMode::Loose is used, the library will not even attempt to parse values and will store all values as raw strings.

In most cases you will want to use the parsed value by using one of the value retrieving methods:

• StringValue::value: Get a Cow containing either a borrowed reference to the parsed value or an owned parsed value if the StringValue contains a raw string. If the StringValue contains a raw string and parsing fails, the error from the parsing attempt will be returned as an error.
• StringValue::copied_value: Same as value, but only available for types that implement Copy and returns a copy of the value instead.
• StringValue::cloned_value: Same as value, but returns a cloned copy of the value instead of a reference. Only available for types that implement Clone.

Variants

Raw(String)

A raw unparsed string value that potentially can be parsed into a value of type T.

Parsed(T)

Parsed value of type T.

Implementations

impl<T: StringValueData> StringValue<T>

pub fn from_raw_parsed(s: impl AsRef<str>) -> Result<Self, T::Error>

Try to create a StringValue from the given raw string by parsing it.

pub fn from_raw(s: impl Into<String>) -> Self

Create a StringValue from a raw string.

pub fn from_value(v: T) -> Self

Create a StringValue from a parsed value.

pub fn raw(&self) -> Cow<'_, str>

Get the raw string value.

pub fn value_err(&self) -> Result<Cow<'_, T>, T::Error>

Get the parsed value, returning any possible parsing errors.

pub fn cloned_value_err(&self) -> Result<T, T::Error>

Get the parsed value, returning a cloned copy of it.

If there is an error, the original parsing error will be returned.

pub fn cloned_value(&self) -> Result<T, EMLError>

Get the parsed value, returning a cloned copy of it.

If there is an error, it will be wrapped in an EMLError.

pub fn value(&self) -> Result<Cow<'_, T>, EMLError>

Get the parsed value, returning any possible parsing errors as an EMLError.

The element_name and span parameters are used to provide context in the error if parsing fails.

impl<T: StringValueData + Copy> StringValue<T>

pub fn copied_value_err(&self) -> Result<T, T::Error>

Get the parsed value, returning a copy of it.

This is only available for types that implement Copy.

pub fn copied_value(&self) -> Result<T, EMLError>

Get the parsed value, returning a copy of it.

If there is an error, it will be wrapped in an EMLError. This is only available for types that implement Copy.

Trait Implementations

impl<T: Clone + StringValueData> Clone for StringValue<T>

fn clone(&self) -> StringValue<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + StringValueData> Debug for StringValue<T>

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

Formats the value using the given formatter.

impl<T: Hash + StringValueData> Hash for StringValue<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + StringValueData> PartialEq for StringValue<T>

fn eq(&self, other: &StringValue<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + StringValueData> Eq for StringValue<T>

impl<T: StringValueData> StructuralPartialEq for StringValue<T>