1#[repr(C)]
5#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
6pub struct GlobalHeader {
7 pub magic: u32,
8 pub version: u16,
9 pub context_type: u8,
10 pub primary_entity_type: u8,
11 pub input_entity_count: u32,
12 pub entities_offset: u32,
13 pub strings_pool_offset: u32,
14 pub strings_pool_size: u32,
15 pub output_offset: u32,
16 pub output_size: u32,
17 pub primary_entity_idx: u32,
18 pub reserved: [u8; 28],
19}
20
21pub const GLOBAL_HEADER_SIZE: usize = 64;
22
23#[repr(C)]
24#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
25pub struct EntityHeader {
26 pub entity_type: u8,
27 pub operation: u8,
28 pub flags: u8,
29 pub reserved: [u8; 1],
30 pub id: [u8; 16],
31 pub parent_idx: i32,
32 pub data_offset: u32,
33 pub data_size: u32,
34}
35
36pub const ENTITY_HEADER_SIZE: usize = 32;
37
38#[repr(C)]
39#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
40pub struct TransactionData {
41 pub post_date: i64,
42 pub enter_date: i64,
43 pub split_count: u32,
44 pub tag_count: u32,
45 pub is_multi_currency: u8,
46 pub reserved: [u8; 23],
47}
48
49pub const TRANSACTION_DATA_SIZE: usize = 48;
50
51#[repr(C)]
52#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
53pub struct SplitData {
54 pub account_id: [u8; 16],
55 pub commodity_id: [u8; 16],
56 pub value_num: i64,
57 pub value_denom: i64,
58 pub reconcile_state: u8,
59 pub reserved: [u8; 7],
60 pub reconcile_date: i64,
61 pub account_name_offset: u32,
62 pub account_name_len: u32,
63}
64
65pub const SPLIT_DATA_SIZE: usize = 72;
66
67#[repr(C)]
68#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
69pub struct TagData {
70 pub name_offset: u32,
71 pub value_offset: u32,
72 pub name_len: u16,
73 pub value_len: u16,
74 pub reserved: [u8; 4],
75}
76
77pub const TAG_DATA_SIZE: usize = 16;
78
79#[repr(C)]
80#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
81pub struct AccountData {
82 pub parent_account_id: [u8; 16],
83 pub name_offset: u32,
84 pub path_offset: u32,
85 pub tag_count: u32,
86 pub name_len: u16,
87 pub path_len: u16,
88 pub reserved: [u8; 16],
89}
90
91pub const ACCOUNT_DATA_SIZE: usize = 48;
92
93#[repr(C)]
94#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
95pub struct CommodityData {
96 pub symbol_offset: u32,
97 pub name_offset: u32,
98 pub tag_count: u32,
99 pub symbol_len: u16,
100 pub name_len: u16,
101 pub reserved: [u8; 16],
102}
103
104pub const COMMODITY_DATA_SIZE: usize = 32;
105
106#[repr(C)]
107#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
108pub struct OutputHeader {
109 pub magic: u32,
110 pub output_entity_count: u32,
111 pub output_start_idx: u32,
112 pub strings_offset: u32,
113 pub next_write_pos: u32,
114 pub reserved: [u8; 4],
115}
116
117pub const OUTPUT_HEADER_SIZE: usize = 24;
118
119#[repr(C)]
120#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
121pub struct DebugValueData {
122 pub value_type: u8,
123 pub reserved: [u8; 7],
124 pub data1: i64,
125 pub data2: i64,
126}
127
128pub const DEBUG_VALUE_DATA_SIZE: usize = 24;
129
130impl GlobalHeader {
131 pub fn to_bytes(&self) -> [u8; GLOBAL_HEADER_SIZE] {
132 let mut buf = [0u8; GLOBAL_HEADER_SIZE];
133 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
134 buf
135 }
136
137 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
138 let v = Self::read_from_prefix(bytes).ok().map(|(v, _)| v)?;
139 (v.magic == MAGIC_NOMI).then_some(v)
140 }
141}
142
143impl EntityHeader {
144 pub fn to_bytes(&self) -> [u8; ENTITY_HEADER_SIZE] {
145 let mut buf = [0u8; ENTITY_HEADER_SIZE];
146 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
147 buf
148 }
149
150 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
151 Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
152 }
153}
154
155impl TransactionData {
156 pub fn to_bytes(&self) -> [u8; TRANSACTION_DATA_SIZE] {
157 let mut buf = [0u8; TRANSACTION_DATA_SIZE];
158 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
159 buf
160 }
161
162 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
163 Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
164 }
165}
166
167impl SplitData {
168 pub fn to_bytes(&self) -> [u8; SPLIT_DATA_SIZE] {
169 let mut buf = [0u8; SPLIT_DATA_SIZE];
170 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
171 buf
172 }
173
174 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
175 Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
176 }
177}
178
179impl TagData {
180 pub fn to_bytes(&self) -> [u8; TAG_DATA_SIZE] {
181 let mut buf = [0u8; TAG_DATA_SIZE];
182 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
183 buf
184 }
185
186 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
187 Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
188 }
189}
190
191impl AccountData {
192 pub fn to_bytes(&self) -> [u8; ACCOUNT_DATA_SIZE] {
193 let mut buf = [0u8; ACCOUNT_DATA_SIZE];
194 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
195 buf
196 }
197
198 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
199 Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
200 }
201}
202
203impl CommodityData {
204 pub fn to_bytes(&self) -> [u8; COMMODITY_DATA_SIZE] {
205 let mut buf = [0u8; COMMODITY_DATA_SIZE];
206 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
207 buf
208 }
209
210 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
211 Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
212 }
213}
214
215impl OutputHeader {
216 pub fn to_bytes(&self) -> [u8; OUTPUT_HEADER_SIZE] {
217 let mut buf = [0u8; OUTPUT_HEADER_SIZE];
218 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
219 buf
220 }
221
222 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
223 let v = Self::read_from_prefix(bytes).ok().map(|(v, _)| v)?;
224 (v.magic == MAGIC_OUTP).then_some(v)
225 }
226}
227
228impl DebugValueData {
229 pub fn to_bytes(&self) -> [u8; DEBUG_VALUE_DATA_SIZE] {
230 let mut buf = [0u8; DEBUG_VALUE_DATA_SIZE];
231 buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
232 buf
233 }
234
235 pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
236 Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
237 }
238}
239