na_nbt 0.2.1

High-performance NBT (Named Binary Tag) library with zero-copy parsing and serde support
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

mod array;
mod compound;
mod config;
mod document;
mod list;
mod mark;
mod read;
mod size;
mod string;
mod typed_list;
mod value;
mod write;

mod borrowed {
    use zerocopy::byteorder;

    use crate::{
        ByteOrder, ConfigRef, Result, TagID, cold_path,
        immutable::{config::ImmutableConfig, document::Document},
    };

    use super::*;

    pub type BorrowedValue<'s, O> = value::ReadonlyValue<'s, O, ()>;

    impl Document for () {
        fn empty() -> Self {}
    }

    pub fn read_borrowed<'s, O: ByteOrder>(source: &'s [u8]) -> Result<BorrowedDocument<'s, O>> {
        unsafe {
            read::read_unsafe::<O, _>(source.as_ptr(), source.len(), |mark| BorrowedDocument {
                mark,
                source: source.as_ptr(),
                _marker: core::marker::PhantomData::<(&'s (), O)>,
            })
        }
    }

    pub struct BorrowedDocument<'s, O: ByteOrder> {
        mark: Vec<mark::Mark>,
        source: *const u8,
        _marker: core::marker::PhantomData<(&'s (), O)>,
    }

    impl<'s, O: ByteOrder> BorrowedDocument<'s, O> {
        #[inline]
        pub fn root<'doc>(&'doc self) -> BorrowedValue<'doc, O> {
            let root_tag = unsafe { *self.source.cast() };

            if root_tag == TagID::End {
                cold_path();
                return BorrowedValue::End(());
            }

            let name_len =
                byteorder::U16::<O>::from_bytes(unsafe { *self.source.add(1).cast() }).get();

            unsafe {
                <ImmutableConfig<O, ()> as ConfigRef>::read_value(
                    root_tag,
                    (
                        self.source.add(3 + name_len as usize),
                        self.mark.as_ptr(),
                        &(),
                    ),
                )
            }
        }
    }

    unsafe impl<'s, O: ByteOrder> Send for BorrowedDocument<'s, O> {}
    unsafe impl<'s, O: ByteOrder> Sync for BorrowedDocument<'s, O> {}
}

pub use borrowed::read_borrowed;

#[cfg(feature = "shared")]
mod shared {
    use std::sync::Arc;

    use bytes::Bytes;
    use zerocopy::byteorder;

    use crate::{
        ByteOrder, ConfigRef, Result, TagID, cold_path,
        immutable::{config::ImmutableConfig, document::Document},
    };

    use super::*;

    pub type SharedValue<O> = value::ReadonlyValue<'static, O, Arc<SharedDocument>>;

    impl Document for Arc<SharedDocument> {
        fn empty() -> Self {
            Arc::new(SharedDocument {
                mark: Vec::new(),
                source: Bytes::new(),
            })
        }
    }

    pub fn read_shared<O: ByteOrder>(source: Bytes) -> Result<SharedValue<O>> {
        Ok(unsafe {
            read::read_unsafe::<O, _>(source.as_ptr(), source.len(), |mark| {
                Arc::new(SharedDocument { mark, source })
            })?
            .root()
        })
    }

    /// A parsed NBT document with shared ownership.
    ///
    /// This type holds the source data and parsing metadata for [`SharedValue`]s.
    /// It is managed through `Arc` and should not typically be used directly.
    pub struct SharedDocument {
        mark: Vec<mark::Mark>,
        source: Bytes,
    }

    impl SharedDocument {
        /// Returns the root value of the document.
        #[inline]
        pub fn root<O: ByteOrder>(self: Arc<Self>) -> SharedValue<O> {
            let root_tag = unsafe { TagID::from_u8_unchecked(*self.source.get_unchecked(0)) };

            if root_tag == TagID::End {
                cold_path();
                return SharedValue::End(());
            }

            let name_len =
                byteorder::U16::<O>::from_bytes(unsafe { *self.source.as_ptr().add(1).cast() })
                    .get();

            unsafe {
                <ImmutableConfig<O, Arc<SharedDocument>> as ConfigRef>::read_value(
                    root_tag,
                    (
                        self.source.as_ptr().add(3 + name_len as usize),
                        self.mark.as_ptr(),
                        &self,
                    ),
                )
            }
        }
    }
}

#[cfg(feature = "shared")]
pub use shared::read_shared;