Struct jomini::text::Property

pub struct Property<T> { /* private fields */ }

Represents the field value that contains an operator

A Property is a specially marked type that signals to the deserializer to preserve operators.

use jomini::{
    text::{Operator, Property},
    JominiDeserialize, TextDeserializer,
};
use serde::Deserialize;

let data = b"modifier = { abc=yes factor=2 num > 2 }";
let actual: MyStruct = jomini::text::de::from_windows1252_slice(&data[..])?;
assert_eq!(
    actual,
    MyStruct {
        modifier: Modifier {
            abc: true,
            factor: Property::new(Operator::Equal, 2),
            num: Property::new(Operator::GreaterThan, 2)
        }
    }
);

#[derive(Deserialize, Debug, PartialEq)]
struct Modifier {
    abc: bool,
    factor: Property<u8>,
    num: Property<u8>,
}

#[derive(Deserialize, Debug, PartialEq)]
struct MyStruct {
    modifier: Modifier,
}

Implementations

impl<T> Property<T>

pub fn new(operator: Operator, value: T) -> Self

Creates a new property

pub fn operator(&self) -> Operator

Return the present operator in the property

pub fn value(&self) -> &T

Return a reference to the value

pub fn into_value(self) -> T

Convert the property into the value

Trait Implementations

impl<T> Clone for Property<T>

where T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Property<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Property<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> PartialEq for Property<T>

where T: PartialEq,

fn eq(&self, other: &Self) -> 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<T> Copy for Property<T>

where T: Copy,

impl<T> Eq for Property<T>

where T: Eq,