Struct quartz_nbt::NbtCompound

#[repr(transparent)]
pub struct NbtCompound(_);

The NBT tag compound type which is essentially just a wrapper for a hash map of string keys to tag values.

This type will implement both Serialize and Deserialize when the serde feature is enabled, however this type should still be read and written with the utilities in the io module when possible if speed is the main priority. See NbtTag for more details.

Implementations

impl NbtCompound

pub fn new() -> Self

Returns a new NBT tag compound with an empty internal hash map.

pub fn inner(&self) -> &HashMap<String, NbtTag>

Returns a reference to the internal hash map of this compound.

pub fn inner_mut(&mut self) -> &mut HashMap<String, NbtTag>

Returns a mutable reference to the internal hash map of this compound.

pub fn into_inner(self) -> HashMap<String, NbtTag>

Returns the internal hash map of this NBT compound.

pub fn with_capacity(capacity: usize) -> Self

Returns a new NBT tag compound with the given initial capacity.

pub fn clone_from<'a, K, V, M>(map: &'a M) -> Self where
    K: Clone + Into<String> + 'a,
    V: Clone + Into<NbtTag> + 'a,
    &'a M: IntoIterator<Item = (&'a K, &'a V)>, 

Clones the data in the given map and converts it into an NbtCompound.

Examples

let mut map = HashMap::new();
map.insert("foo", 10i32);
map.insert("bar", -5i32);

let compound = NbtCompound::clone_from(&map);
assert_eq!(
    compound.get::<_, i32>("foo").unwrap() + compound.get::<_, i32>("bar").unwrap(),
    5i32
);

pub fn clone_repr_from<'a, K, V, M>(map: &'a M) -> Self where
    K: Clone + Into<String> + 'a,
    V: NbtRepr + 'a,
    &'a M: IntoIterator<Item = (&'a K, &'a V)>, 

Creates an NbtCompound of NbtCompounds by mapping each element in the given map to its NBT representation.

pub fn iter_map<'a, T: TryFrom<&'a NbtTag>>(
    &'a self
) -> impl Iterator<Item = (&'a str, Result<T, <T as TryFrom<&'a NbtTag>>::Error>)> + 'a

Iterates over this tag compound, converting each tag reference into the specified type. Each key is paired with the result of the attempted conversion into the specified type. The iterator will not terminate even if some conversions fail.

pub fn iter_mut_map<'a, T: TryFrom<&'a mut NbtTag>>(
    &'a mut self
) -> impl Iterator<Item = (&'a str, Result<T, <T as TryFrom<&'a mut NbtTag>>::Error>)> + 'a

Iterates over this tag compound, converting each mutable tag reference into the specified type. See iter_map for details.

pub fn to_snbt(&self) -> String

Converts this tag compound into a valid SNBT string.

pub fn len(&self) -> usize

Returns the number of tags in this compound.

pub fn is_empty(&self) -> bool

Returns true if the length of this compound is zero, false otherwise.

pub fn get<'a, 'b, K: ?Sized, T>(
    &'a self,
    name: &'b K
) -> Result<T, NbtReprError> where
    String: Borrow<K>,
    K: Hash + Eq,
    &'b K: Into<String>,
    T: TryFrom<&'a NbtTag>,
    T::Error: Into<Error>, 

Returns the value of the tag with the given name, or an error if no tag exists with the given name or specified type. This method should be used to obtain primitives as well as shared references to lists and compounds.

let mut compound = NbtCompound::new();
compound.insert("test", 1.0f64);

assert!((compound.get::<_, f64>("test").unwrap() - 1.0f64).abs() < 1e-5);
assert!(compound.get::<_, i32>("test").is_err()); // Type mismatch
assert!(compound.get::<_, f64>("foo").is_err()); // Missing tag

pub fn get_mut<'a, 'b, K: ?Sized, T>(
    &'a mut self,
    name: &'b K
) -> Result<T, NbtReprError> where
    String: Borrow<K>,
    K: Hash + Eq,
    &'b K: Into<String>,
    T: TryFrom<&'a mut NbtTag>,
    T::Error: Into<Error>, 

Returns the value of the tag with the given name, or an error if no tag exists with the given name or specified type. This method should be used to obtain mutable references to lists and compounds.

let mut compound = NbtCompound::new();
compound.insert("test", 1.0f64);

*compound.get_mut::<_, &mut f64>("test").unwrap() *= 2.0;

assert!((compound.get::<_, f64>("test").unwrap() - 2.0f64).abs() < 1e-5);
assert!(compound.get::<_, i32>("test").is_err()); // Type mismatch
assert!(compound.get::<_, f64>("foo").is_err()); // Missing tag

pub fn contains_key<K: ?Sized>(&self, key: &K) -> bool where
    String: Borrow<K>,
    K: Hash + Eq, 

Returns whether or not this compound has a tag with the given name.

let mut compound = NbtCompound::new();
compound.insert("test", 1.0f64);

assert!(compound.contains_key("test"));
assert!(!compound.contains_key("foo"));

pub fn insert<K: Into<String>, T: Into<NbtTag>>(&mut self, name: K, value: T)

Adds the given value to this compound with the given name after wrapping that value in an NbtTag.

let mut compound = NbtCompound::new();
compound.insert("test", 1.0f64);

assert!((compound.get::<_, f64>("test").unwrap() - 1.0f64).abs() < 1e-5);

pub fn from_snbt(input: &str) -> Result<Self, SnbtError>

Parses a nbt compound from snbt

Example

let tag = NbtCompound::from_snbt(r#"{string:Stuff, list:[I;1,2,3,4,5]}"#).unwrap();
assert!(matches!(tag.get::<_, &str>("string"), Ok("Stuff")));
assert_eq!(tag.get::<_, &[i32]>("list").unwrap(), vec![1,2,3,4,5].as_slice());

Trait Implementations

impl Clone for NbtCompound

fn clone(&self) -> NbtCompound

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NbtCompound

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NbtCompound

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

Deserialize this value from the given Serde deserializer.

impl Display for NbtCompound

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

Formats the value using the given formatter.

impl From<NbtCompound> for NbtTag

fn from(value: NbtCompound) -> NbtTag

Performs the conversion.

impl FromStr for NbtCompound

type Err = SnbtError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl PartialEq<NbtCompound> for NbtCompound

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

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

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

This method tests for !=.

impl Serialize for NbtCompound

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

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<&'a NbtTag> for &'a NbtCompound

type Error = NbtStructureError

The type returned in the event of a conversion error.

fn try_from(tag: &'a NbtTag) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a mut NbtTag> for &'a mut NbtCompound

type Error = NbtStructureError

The type returned in the event of a conversion error.

fn try_from(tag: &'a mut NbtTag) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<NbtTag> for NbtCompound

type Error = NbtStructureError

The type returned in the event of a conversion error.

fn try_from(tag: NbtTag) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for NbtCompound