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)]
6
pub 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

            
21
pub const GLOBAL_HEADER_SIZE: usize = 64;
22

            
23
#[repr(C)]
24
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
25
pub 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

            
36
pub const ENTITY_HEADER_SIZE: usize = 32;
37

            
38
#[repr(C)]
39
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
40
pub 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

            
49
pub const TRANSACTION_DATA_SIZE: usize = 48;
50

            
51
#[repr(C)]
52
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
53
pub 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

            
65
pub const SPLIT_DATA_SIZE: usize = 72;
66

            
67
#[repr(C)]
68
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
69
pub 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

            
77
pub const TAG_DATA_SIZE: usize = 16;
78

            
79
#[repr(C)]
80
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
81
pub 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

            
91
pub const ACCOUNT_DATA_SIZE: usize = 48;
92

            
93
#[repr(C)]
94
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
95
pub 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

            
104
pub const COMMODITY_DATA_SIZE: usize = 32;
105

            
106
#[repr(C)]
107
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
108
pub 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

            
117
pub const OUTPUT_HEADER_SIZE: usize = 24;
118

            
119
#[repr(C)]
120
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
121
pub struct DebugValueData {
122
    pub value_type: u8,
123
    pub reserved: [u8; 7],
124
    pub data1: i64,
125
    pub data2: i64,
126
}
127

            
128
pub const DEBUG_VALUE_DATA_SIZE: usize = 24;
129

            
130
impl 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
24911
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
138
24911
        let v = Self::read_from_prefix(bytes).ok().map(|(v, _)| v)?;
139
24911
        (v.magic == MAGIC_NOMI).then_some(v)
140
24911
    }
141
}
142

            
143
impl EntityHeader {
144
13675
    pub fn to_bytes(&self) -> [u8; ENTITY_HEADER_SIZE] {
145
13675
        let mut buf = [0u8; ENTITY_HEADER_SIZE];
146
13675
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
147
13675
        buf
148
13675
    }
149

            
150
18869
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
151
18869
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
152
18869
    }
153
}
154

            
155
impl TransactionData {
156
7314
    pub fn to_bytes(&self) -> [u8; TRANSACTION_DATA_SIZE] {
157
7314
        let mut buf = [0u8; TRANSACTION_DATA_SIZE];
158
7314
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
159
7314
        buf
160
7314
    }
161

            
162
53
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
163
53
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
164
53
    }
165
}
166

            
167
impl SplitData {
168
13038
    pub fn to_bytes(&self) -> [u8; SPLIT_DATA_SIZE] {
169
13038
        let mut buf = [0u8; SPLIT_DATA_SIZE];
170
13038
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
171
13038
        buf
172
13038
    }
173

            
174
106
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
175
106
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
176
106
    }
177
}
178

            
179
impl TagData {
180
3658
    pub fn to_bytes(&self) -> [u8; TAG_DATA_SIZE] {
181
3658
        let mut buf = [0u8; TAG_DATA_SIZE];
182
3658
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
183
3658
        buf
184
3658
    }
185

            
186
2174
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
187
2174
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
188
2174
    }
189
}
190

            
191
impl AccountData {
192
265
    pub fn to_bytes(&self) -> [u8; ACCOUNT_DATA_SIZE] {
193
265
        let mut buf = [0u8; ACCOUNT_DATA_SIZE];
194
265
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
195
265
        buf
196
265
    }
197

            
198
106
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
199
106
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
200
106
    }
201
}
202

            
203
impl CommodityData {
204
159
    pub fn to_bytes(&self) -> [u8; COMMODITY_DATA_SIZE] {
205
159
        let mut buf = [0u8; COMMODITY_DATA_SIZE];
206
159
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
207
159
        buf
208
159
    }
209

            
210
106
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
211
106
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
212
106
    }
213
}
214

            
215
impl OutputHeader {
216
37790
    pub fn to_bytes(&self) -> [u8; OUTPUT_HEADER_SIZE] {
217
37790
        let mut buf = [0u8; OUTPUT_HEADER_SIZE];
218
37790
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
219
37790
        buf
220
37790
    }
221

            
222
20194
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
223
20194
        let v = Self::read_from_prefix(bytes).ok().map(|(v, _)| v)?;
224
20194
        (v.magic == MAGIC_OUTP).then_some(v)
225
20194
    }
226
}
227

            
228
impl DebugValueData {
229
1
    pub fn to_bytes(&self) -> [u8; DEBUG_VALUE_DATA_SIZE] {
230
1
        let mut buf = [0u8; DEBUG_VALUE_DATA_SIZE];
231
1
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
232
1
        buf
233
1
    }
234

            
235
15477
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
236
15477
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
237
15477
    }
238
}
239