Enum Value 

pub enum Value<'a, Spec: Specification = Raw> {
    SingleLine {
        inner: Option<Cow<'a, str>>,
        _spec: PhantomData<Spec>,
    },
    MultiLine {
        inner: Vec<Option<Cow<'a, str>>>,
        _spec: PhantomData<Spec>,
    },
}

The value of an Attribute. Since only some values contain multiple lines and single line values do not require additional heap allocation, an Enum is used to represent both variants.

Variants

SingleLine

A single line value.

Example

let object = parse_object("
name:           ACME Company

")?;
let value = Value::new_single("ACME Company");
assert_eq!(object[0].value, value);

Fields

inner: Option<Cow<'a, str>>

The value.

_spec: PhantomData<Spec>

The values specification.

MultiLine

A value spanning over multiple lines.

Example

let object = parse_object("
remarks:        Packet Street 6
                128 Series of Tubes
                Internet

")?;
let value: Value = vec!["Packet Street 6", "128 Series of Tubes", "Internet"].into();
assert_eq!(object[0].value, value);

Fields

inner: Vec<Option<Cow<'a, str>>>

The value.

_spec: PhantomData<Spec>

The values specification.

Implementations

impl<'a, Spec: Specification> Value<'a, Spec>

pub fn lines(&self) -> usize

The number of lines contained.

Examples

A value with a single line.

let value = Value::new_single("ACME Company");
assert_eq!(value.lines(), 1);

A value with multiple lines.

let value: Value = vec!["Packet Street 6", "128 Series of Tubes", "Internet"].into();
assert_eq!(value.lines(), 3);

pub fn with_content(&self) -> Vec<&str>

The lines that contain content and are non empty.

Example

let remarks = parse_object("
remarks:        I have lots
                 
                to say.

")?;
assert_eq!(remarks[0].value.with_content(), vec!["I have lots", "to say."]);

pub fn is_empty(&self) -> bool

Returns true if the value is empty.

Example

let remarks = parse_object("
remarks:

")?;
assert_eq!(remarks[0].value.is_empty(), true);

pub fn into_owned(self) -> Value<'static, Spec>

Convert this value into an owned ('static) version.

impl Value<'static, Raw>

pub fn new_single<V>(value: V) -> Self

where V: Into<String>,

Create a single line value. Empty values are coerced to None.

pub fn new_multi<I, V>(values: I) -> Self

where I: IntoIterator<Item = V>, V: Into<String>,

Create a multi line value. Empty values are coerced to None.

Panics

If the given iterator contains less than two values.

Trait Implementations

impl<'a, Spec: Clone + Specification> Clone for Value<'a, Spec>

fn clone(&self) -> Value<'a, Spec>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, Spec: Debug + Specification> Debug for Value<'a, Spec>

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

Formats the value using the given formatter.

impl From<&str> for Value<'static, Raw>

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<String> for Value<'static, Raw>

fn from(value: String) -> Self

Converts to this type from the input type.

impl<'a, Spec: Specification> From<Value<'a, Spec>> for Vec<Option<String>>

fn from(value: Value<'a, Spec>) -> Self

Converts to this type from the input type.

impl<S> From<Vec<S>> for Value<'static, Raw>

where S: Into<String>,

fn from(values: Vec<S>) -> Self

Create a new value from an iterator of value lines.

Example

let value: Value = vec!["Packet Street 6", "128 Series of Tubes", "Internet"].into();
assert_eq!(value.lines(), 3);

impl FromStr for Value<'static, Raw>

fn from_str(value: &str) -> Result<Self, Self::Err>

Create a new single line value from a string slice.

type Err = Infallible

The associated error which can be returned from parsing.

impl<Spec: Specification> PartialEq<&str> for Value<'_, Spec>

fn eq(&self, other: &&str) -> 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<Spec: Specification> PartialEq<Vec<&str>> for Value<'_, Spec>

fn eq(&self, other: &Vec<&str>) -> 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<Spec: Specification> PartialEq<Vec<Option<&str>>> for Value<'_, Spec>

fn eq(&self, other: &Vec<Option<&str>>) -> 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<'a, Spec: PartialEq + Specification> PartialEq for Value<'a, Spec>

fn eq(&self, other: &Value<'a, Spec>) -> 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<'a, Spec: Specification> Serialize for Value<'a, Spec>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, Spec: Eq + Specification> Eq for Value<'a, Spec>

impl<'a, Spec: Specification> StructuralPartialEq for Value<'a, Spec>