Enum minecraft_assets::schemas::blockstates::multipart::StateValue

pub enum StateValue {
    Bool(bool),
    String(String),
}

The right-hand side of a Condition requirement.

"when": {"north": "side|up", "east": false }
                  ^^^^^^^^^          ^^^^^

Variants

Bool(bool)

Tuple Fields

0: bool

Unquoted bool value.

String(String)

Tuple Fields

0: String

String value (possibly boolean-like, i.e., "true" or "false").

Implementations

impl StateValue

pub fn as_bool(&self) -> Option<bool>

Returns the value interpreted as a bool, or None if this is not possible.

Example

let value = StateValue::from(true);
assert_eq!(value.as_bool(), Some(true));

let value = StateValue::from(false);
assert_eq!(value.as_bool(), Some(false));

let value = StateValue::from("true");
assert_eq!(value.as_bool(), Some(true));

let value = StateValue::from("false");
assert_eq!(value.as_bool(), Some(false));

let value = StateValue::from("not_a_bool");
assert_eq!(value.as_bool(), None);

Trait Implementations

impl Clone for StateValue

fn clone(&self) -> StateValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StateValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StateValue

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a str> for StateValue

fn from(source: &'a str) -> Self

Performs the conversion.

impl From<String> for StateValue

fn from(source: String) -> Self

Performs the conversion.

impl From<bool> for StateValue

fn from(source: bool) -> Self

Performs the conversion.

impl PartialEq<StateValue> for StateValue

Examples

Comparing to an unquoted boolean value:

let left = StateValue::from(true);

let right = StateValue::from(true);
assert!(left == right);

let right = StateValue::from(false);
assert!(left != right);

let right = StateValue::from("true");
assert!(left == right);

let right = StateValue::from("false");
assert!(left != right);

let right = StateValue::from("not_a_bool");
assert!(left != right);

Comparing to a quoted boolean value:

let left = StateValue::from("true");

let right = StateValue::from(true);
assert!(left == right);

let right = StateValue::from(false);
assert!(left != right);

Comparing to a single string value:

let left = StateValue::from("foo");

let right = StateValue::from("foo");
assert!(left == right);

let right = StateValue::from("bar");
assert!(left != right);

let right = StateValue::from(true);
assert!(left != right);

Comparing to a multi-string value with | bars:

let left = StateValue::from("foo|bar");

let right = StateValue::from("foo");
assert!(left == right);

let right = StateValue::from("bar");
assert!(left == right);

let right = StateValue::from("not_foo_or_bar");
assert!(left != right);

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 !=.

impl Serialize for StateValue

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

Serialize this value into the given Serde serializer.