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
}
62

            
63
pub const SPLIT_DATA_SIZE: usize = 64;
64

            
65
#[repr(C)]
66
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
67
pub struct TagData {
68
    pub name_offset: u32,
69
    pub value_offset: u32,
70
    pub name_len: u16,
71
    pub value_len: u16,
72
    pub reserved: [u8; 4],
73
}
74

            
75
pub const TAG_DATA_SIZE: usize = 16;
76

            
77
#[repr(C)]
78
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
79
pub struct AccountData {
80
    pub parent_account_id: [u8; 16],
81
    pub name_offset: u32,
82
    pub path_offset: u32,
83
    pub tag_count: u32,
84
    pub name_len: u16,
85
    pub path_len: u16,
86
    pub reserved: [u8; 16],
87
}
88

            
89
pub const ACCOUNT_DATA_SIZE: usize = 48;
90

            
91
#[repr(C)]
92
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
93
pub struct CommodityData {
94
    pub symbol_offset: u32,
95
    pub name_offset: u32,
96
    pub tag_count: u32,
97
    pub symbol_len: u16,
98
    pub name_len: u16,
99
    pub reserved: [u8; 16],
100
}
101

            
102
pub const COMMODITY_DATA_SIZE: usize = 32;
103

            
104
#[repr(C)]
105
#[derive(Debug, Clone, Copy, FromBytes, IntoBytes, Immutable, KnownLayout)]
106
pub struct OutputHeader {
107
    pub magic: u32,
108
    pub output_entity_count: u32,
109
    pub output_start_idx: u32,
110
    pub strings_offset: u32,
111
    pub next_write_pos: u32,
112
    pub reserved: [u8; 4],
113
}
114

            
115
pub const OUTPUT_HEADER_SIZE: usize = 24;
116

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

            
126
pub const DEBUG_VALUE_DATA_SIZE: usize = 24;
127

            
128
impl GlobalHeader {
129
    pub fn to_bytes(&self) -> [u8; GLOBAL_HEADER_SIZE] {
130
        let mut buf = [0u8; GLOBAL_HEADER_SIZE];
131
        buf.copy_from_slice(<Self as IntoBytes>::as_bytes(self));
132
        buf
133
    }
134

            
135
3361
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
136
3361
        let v = Self::read_from_prefix(bytes).ok().map(|(v, _)| v)?;
137
3361
        (v.magic == MAGIC_NOMI).then_some(v)
138
3361
    }
139
}
140

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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