1pub fn decode_dynvec(data: &[u8]) -> Vec<Vec<u8>> {
2 assert!(data.len() >= 4);
3 assert!(data.len() as u32 == u32::from_le_bytes(data[0..4].try_into().unwrap()));
4 let nums = (u32::from_le_bytes(data[4..8].try_into().unwrap()) / 4 - 1) as usize;
5 let mut head: Vec<usize> = vec![];
6 for i in 0..nums {
7 head.push(u32::from_le_bytes(data[i * 4 + 4..i * 4 + 8].try_into().unwrap()) as usize);
8 }
9 head.push(data.len());
10 let mut body: Vec<Vec<u8>> = Vec::new();
11 for i in 0..nums {
12 body.push(data[head[i]..head[i + 1]].to_vec());
13 }
14 body
15}
16
17pub fn decode_fixvec(data: &[u8]) -> Vec<Vec<u8>> {
18 assert!(data.len() >= 4);
19 let icnt = u32::from_le_bytes(data[0..4].try_into().unwrap()) as usize;
20 let mut body: Vec<Vec<u8>> = vec![];
21 if icnt > 0 {
22 let size = data[4..].len() as usize / icnt;
23 for i in 0..icnt {
24 body.push(data[4 + i * size..4 + i * size + size].to_vec());
25 }
26 }
27 body
28}
29
30pub fn decode_seq(data: &[u8], size: &[usize]) -> Vec<Vec<u8>> {
31 let mut r: Vec<Vec<u8>> = vec![];
32 let mut s = 0;
33 for n in size {
34 r.push(data[s..s + n].to_vec());
35 s += n;
36 }
37 r
38}
39
40pub fn encode_dynvec(data: Vec<Vec<u8>>) -> Vec<u8> {
41 let mut head: Vec<u8> = vec![];
42 let mut body: Vec<u8> = vec![];
43 let head_size = 4 + 4 * data.len();
44 let mut body_size = 0;
45 for item in data {
46 let size = head_size + body_size;
47 let size = size as u32;
48 head.extend(&size.to_le_bytes());
49 body.extend(&item);
50 body_size += item.len();
51 }
52 let size = head_size + body_size;
53 let size = size as u32;
54 [size.to_le_bytes().to_vec(), head, body].concat()
55}
56
57pub fn encode_fixvec(data: Vec<Vec<u8>>) -> Vec<u8> {
58 let mut r = vec![];
59 r.extend(&(data.len() as u32).to_le_bytes());
60 for e in data {
61 r.extend(&e);
62 }
63 r
64}
65
66pub fn encode_seq(data: Vec<Vec<u8>>) -> Vec<u8> {
67 let mut r: Vec<u8> = vec![];
68 for e in data {
69 r.extend(&e)
70 }
71 r
72}
73
74pub struct Byte {
75 data: u8,
76}
77
78impl Byte {
79 pub fn new(data: u8) -> Self {
80 Self { data }
81 }
82
83 pub fn molecule(&self) -> Vec<u8> {
84 vec![self.data]
85 }
86
87 pub fn molecule_decode(data: &[u8]) -> u8 {
88 assert_eq!(data.len(), 1);
89 data[0]
90 }
91
92 pub fn molecule_size() -> usize {
93 1
94 }
95}
96
97pub struct Byte32 {
98 data: [u8; 32],
99}
100
101impl Byte32 {
102 pub fn new(data: [u8; 32]) -> Self {
103 Self { data }
104 }
105
106 pub fn molecule(&self) -> Vec<u8> {
107 self.data.to_vec()
108 }
109
110 pub fn molecule_decode(data: &[u8]) -> [u8; 32] {
111 assert_eq!(data.len(), 32);
112 let mut r = [0u8; 32];
113 r.copy_from_slice(&data);
114 r
115 }
116
117 pub fn molecule_size() -> usize {
118 32
119 }
120}
121
122pub struct Bytes {
123 data: Vec<u8>,
124}
125
126impl Bytes {
127 pub fn new(data: Vec<u8>) -> Self {
128 Self { data }
129 }
130
131 pub fn molecule(&self) -> Vec<u8> {
132 let mut r = vec![];
133 r.extend(&(self.data.len() as u32).to_le_bytes());
134 r.extend(&self.data);
135 r
136 }
137
138 pub fn molecule_decode(data: &[u8]) -> Vec<u8> {
139 assert!(data.len() >= 4);
140 let l = u32::from_le_bytes(data[0..4].try_into().unwrap());
141 assert_eq!(l as usize, data.len() - 4);
142 data[4..].to_vec()
143 }
144}
145
146pub struct U32 {
147 data: u32,
148}
149
150impl U32 {
151 pub fn new(data: u32) -> Self {
152 Self { data }
153 }
154
155 pub fn molecule(&self) -> Vec<u8> {
156 self.data.to_le_bytes().to_vec()
157 }
158
159 pub fn molecule_decode(data: &[u8]) -> u32 {
160 assert_eq!(data.len(), 4);
161 u32::from_le_bytes(data.try_into().unwrap())
162 }
163
164 pub fn molecule_size() -> usize {
165 4
166 }
167}
168
169pub struct U64 {
170 data: u64,
171}
172
173impl U64 {
174 pub fn new(data: u64) -> Self {
175 Self { data }
176 }
177
178 pub fn molecule(&self) -> Vec<u8> {
179 self.data.to_le_bytes().to_vec()
180 }
181
182 pub fn molecule_decode(data: &[u8]) -> u64 {
183 assert_eq!(data.len(), 8);
184 u64::from_le_bytes(data.try_into().unwrap())
185 }
186
187 pub fn molecule_size() -> usize {
188 8
189 }
190}
191
192pub struct U128 {
193 data: u128,
194}
195
196impl U128 {
197 pub fn new(data: u128) -> Self {
198 Self { data }
199 }
200
201 pub fn molecule(&self) -> Vec<u8> {
202 self.data.to_le_bytes().to_vec()
203 }
204
205 pub fn molecule_decode(data: &[u8]) -> u128 {
206 assert_eq!(data.len(), 16);
207 u128::from_le_bytes(data.try_into().unwrap())
208 }
209
210 pub fn molecule_size() -> usize {
211 16
212 }
213}