Struct minecraft_assets::schemas::blockstates::multipart::Condition

pub struct Condition {
    pub and: HashMap<String, StateValue>,
}

A set of conditions that all have to match the block to return true.

The condition is structured as a map from state to value, so for instance:

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

Fields

and: HashMap<String, StateValue>

Map from state name to state value that forms the list of conditions.

Implementations

impl Condition

pub fn applies<'a, I>(&self, state_values: I) -> bool where
    I: IntoIterator<Item = (&'a str, &'a StateValue)>, 

Returns true if

Example

use maplit::hashmap;

let condition = Condition {
    and: hashmap! {
        String::from("var1") => StateValue::from("foo|bar"),
        String::from("var2") => StateValue::from(false),
    },
};

let foo_string = StateValue::from("foo");
let other_string = StateValue::from("other");
let true_string = StateValue::from("true");
let false_string = StateValue::from("false");

let state_values = vec![
    ("var1", &foo_string),
    ("var2", &false_string),
    ("var3", &true_string),
];
assert!(condition.applies(state_values.into_iter()));

let state_values = vec![
    ("var2", &false_string),
];
assert!(!condition.applies(state_values.into_iter()));

let state_values = vec![
    ("var1", &other_string),
    ("var2", &false_string),
];
assert!(!condition.applies(state_values.into_iter()));

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl Default for Condition

fn default() -> Condition

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Condition

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<Condition> for Condition

fn eq(&self, other: &Condition) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for Condition

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Condition