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

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

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

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

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

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

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

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

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

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

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

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

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

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

            
222
24067
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
223
24067
        let v = Self::read_from_prefix(bytes).ok().map(|(v, _)| v)?;
224
24067
        (v.magic == MAGIC_OUTP).then_some(v)
225
24067
    }
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
18460
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
236
18460
        Self::read_from_prefix(bytes).ok().map(|(v, _)| v)
237
18460
    }
238
}
239