compact binary serialization format with built-in compression
kokirigla.de
1pub mod de;
2pub mod ser;
3
4use std::io::{Read, Write};
5
6use hateno::{CompressionMethod, Tag, TagKind, reader::Reader, writer::Writer};
7use serde::{Deserialize, Serialize};
8
9/// Errors that can occur during `serde` operations.
10#[derive(Debug, thiserror::Error)]
11pub enum Error {
12 #[error("Hateno error: {0}")]
13 Hateno(#[from] hateno::Error),
14 #[error("Serde error: {0}")]
15 Custom(String),
16 #[error(
17 "Invalid tag kind for deserialization: expected {expected:?}, found {found:?}"
18 )]
19 InvalidTagKind { expected: String, found: TagKind },
20 #[error("Io Error: {0}")]
21 Io(#[from] std::io::Error),
22}
23
24impl serde::ser::Error for Error {
25 fn custom<T>(msg: T) -> Self
26 where
27 T: std::fmt::Display,
28 {
29 Error::Custom(msg.to_string())
30 }
31}
32
33impl serde::de::Error for Error {
34 fn custom<T>(msg: T) -> Self
35 where
36 T: std::fmt::Display,
37 {
38 Error::Custom(msg.to_string())
39 }
40}
41
42pub type Result<T> = core::result::Result<T, Error>;
43
44pub fn to_tag<T>(value: &T) -> Result<Tag>
45where
46 T: Serialize,
47{
48 let mut serializer = ser::TagSerializer;
49 value.serialize(&mut serializer)
50}
51
52pub fn from_tag<T>(tag: Tag) -> Result<T>
53where
54 T: for<'de> Deserialize<'de>,
55{
56 let mut deserializer = de::TagDeserializer::new(tag);
57 T::deserialize(&mut deserializer)
58}
59
60pub fn to_writer<W, T>(
61 writer: W,
62 value: &T,
63 compression: CompressionMethod,
64) -> Result<W>
65where
66 W: Write,
67 T: Serialize,
68{
69 let tag = to_tag(value)?;
70 let mut nbt_writer = Writer::new(writer, compression)?;
71 nbt_writer.write_tag(&tag)?;
72 nbt_writer.finish().map_err(Error::Hateno)
73}
74
75pub fn from_reader<R, T>(reader: R) -> Result<T>
76where
77 R: Read,
78 T: for<'de> Deserialize<'de>,
79{
80 let mut nbt_reader = Reader::new(reader)?;
81 let tag = nbt_reader.read_tag()?;
82 from_tag(tag)
83}