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.

Implementations

impl NbtCompound

pub fn new() -> Self

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

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, K: ?Sized, T>(
    &'a self,
    name: &K
) -> Result<T, NbtReprError<T::Error>> where
    String: Borrow<K>,
    K: Hash + Eq,
    T: TryFrom<&'a NbtTag>, 

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_eq!(compound.get::<_, f64>("test"), Ok(1.0f64));
assert_eq!(
    compound.get::<_, i32>("test"),
    Err(NbtReprError::Conversion(NbtStructureError::TypeMismatch))
);
assert_eq!(
    compound.get::<_, f64>("foo"),
    Err(NbtReprError::Structure(NbtStructureError::MissingTag))
);

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

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_eq!(compound.get::<_, f64>("test"), Ok(2.0f64));
assert_eq!(
    compound.get::<_, i32>("test"),
    Err(NbtReprError::Conversion(NbtStructureError::TypeMismatch))
);
assert_eq!(
    compound.get::<_, f64>("foo"),
    Err(NbtReprError::Structure(NbtStructureError::MissingTag))
);

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_eq!(compound.get::<_, f64>("test"), Ok(1.0f64));

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

Parses a nbt compound from snbt

Example

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

Trait Implementations

impl AsMut<HashMap<String, NbtTag, RandomState>> for NbtCompound

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

Performs the conversion.

impl AsRef<HashMap<String, NbtTag, RandomState>> for NbtCompound

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

Performs the conversion.

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 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 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<'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