Skip to main content

scripting_format/
generated.rs

1// Auto-generated from doc/nomisync-script-format.org
2// Do not edit manually - regenerate from the org document.
3
4#[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