nbt-rs 0.5.0

A simple rust library for dealing with NBT
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use core::fmt;
use std::collections::HashMap;

use crate::{
    traits::NbtSerialize,
    types::{NbtString, NbtTag},
};

/// A type for nbt compounds, makes sure the data is valid.
#[derive(Debug, PartialEq, Clone, PartialOrd)]
pub struct NbtCompound {
    pub(crate) data: Vec<(NbtString, NbtTag)>,
}

impl NbtCompound {
    /// Gets an element by name, if one exists.
    pub fn get(&self, str: &str) -> Option<&NbtTag> {
        self.data.iter().find(|e| e.0 == str).map(|e| &e.1)
    }
}

impl fmt::Display for NbtCompound {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{{{}}}",
            self.data
                .iter()
                .map(|(k, v)| format!("{:?}: {}", k.to_string(), v))
                .collect::<Vec<_>>()
                .join(", ")
        )
    }
}

impl NbtSerialize for NbtCompound {
    fn serialize_nbt_payload(&self, buf: &mut Vec<u8>) {
        for (key, tag) in &self.data {
            buf.push(tag.tag_id() as u8);
            key.serialize_nbt_payload(buf);
            tag.serialize_nbt_payload(buf);
        }
        buf.push(0x00);
    }
}

impl From<NbtCompound> for Vec<(NbtString, NbtTag)> {
    fn from(val: NbtCompound) -> Self {
        val.data
    }
}

impl From<NbtCompound> for HashMap<NbtString, NbtTag> {
    fn from(val: NbtCompound) -> Self {
        val.data.into_iter().collect()
    }
}

impl From<HashMap<NbtString, NbtTag>> for NbtCompound {
    fn from(map: HashMap<NbtString, NbtTag>) -> Self {
        let data = map.into_iter().collect();
        NbtCompound { data }
    }
}