Skip to content

Commit 93c0c06

Browse files
cowlickscowlicks
committed
dedupe macros
1 parent 1d5226b commit 93c0c06

File tree

3 files changed

+71
-77
lines changed

3 files changed

+71
-77
lines changed

‎src/encoding.rs‎

Lines changed: 26 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -3,50 +3,20 @@ use crate::{
33
crypto::{Manifest, ManifestSigner},
44
DataBlock, DataHash, DataSeek, DataUpgrade, Node, RequestBlock, RequestSeek, RequestUpgrade,
55
};
6-
use compact_encoding::encoded_size_usize;
6+
use compact_encoding::{as_array, encoded_size_usize, map_encode, sum_encoded_size};
77
pub use compact_encoding::{
88
bytes_fixed_from_vec, encode_bytes_fixed, take_array, take_array_mut, write_array, write_slice,
99
CompactEncoding, EncodingError, EncodingErrorKind, VecEncodable,
1010
};
1111

12-
#[macro_export]
13-
/// Used for defining CompactEncoding::encoded_size.
14-
/// Pass self and a list of fields to call encoded_size on
15-
macro_rules! sum_encoded_size {
16-
// Base case: single field
17-
($self:ident, $field:ident) => {
18-
$self.$field.encoded_size()?
19-
};
20-
// Recursive case: first field + rest
21-
($self: ident, $first:ident, $($rest:ident),+) => {
22-
$self.$first.encoded_size()? + sum_encoded_size!($self, $($rest),+)
23-
};
24-
}
25-
26-
#[macro_export]
27-
// TODO is this exported from the crate?
28-
/// Used for defining CompactEncoding::encode.
29-
/// Pass self, the buffer and a list of fields to call encoded_size on
30-
macro_rules! chain_encoded_bytes {
31-
// Base case: single field
32-
($self:ident, $buffer:ident, $field:ident) => {
33-
$self.$field.encode($buffer)?
34-
};
35-
// Recursive case: first field + rest
36-
($self: ident, $buffer:ident, $first:ident, $($rest:ident),+) => {{
37-
let rest = $self.$first.encode($buffer)?;
38-
chain_encoded_bytes!($self, rest, $($rest),+)
39-
}};
40-
}
41-
4212
impl CompactEncoding for Node {
4313
fn encoded_size(&self) -> Result<usize, EncodingError> {
44-
Ok(sum_encoded_size!(self, index, length) + 32)
14+
Ok(sum_encoded_size!(self.index, self.length) + 32)
4515
}
4616

4717
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
48-
let rest = chain_encoded_bytes!(self, buffer, index, length);
49-
bytes_fixed_from_vec::<32>(&self.hash)?.encode(rest)
18+
let hash = as_array::<32>(&self.hash)?;
19+
Ok(map_encode!(buffer, self.index, self.length, hash))
5020
}
5121

5222
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>
@@ -56,6 +26,7 @@ impl CompactEncoding for Node {
5626
let (index, rest) = u64::decode(buffer)?;
5727
let (length, rest) = u64::decode(rest)?;
5828
let (hash, rest) = <[u8; 32]>::decode(rest)?;
29+
5930
Ok((Node::new(index, hash.to_vec(), length), rest))
6031
}
6132
}
@@ -75,11 +46,11 @@ impl VecEncodable for Node {
7546

7647
impl CompactEncoding for RequestBlock {
7748
fn encoded_size(&self) -> Result<usize, EncodingError> {
78-
Ok(sum_encoded_size!(self, index, nodes))
49+
Ok(sum_encoded_size!(self.index, self.nodes))
7950
}
8051

8152
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
82-
Ok(chain_encoded_bytes!(self, buffer, index, nodes))
53+
Ok(map_encode!(buffer, self.index, self.nodes))
8354
}
8455

8556
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>
@@ -112,11 +83,11 @@ impl CompactEncoding for RequestSeek {
11283

11384
impl CompactEncoding for RequestUpgrade {
11485
fn encoded_size(&self) -> Result<usize, EncodingError> {
115-
Ok(sum_encoded_size!(self, start, length))
86+
Ok(sum_encoded_size!(self.start, self.length))
11687
}
11788

11889
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
119-
Ok(chain_encoded_bytes!(self, buffer, start, length))
90+
Ok(map_encode!(buffer, self.start, self.length))
12091
}
12192

12293
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>
@@ -131,11 +102,11 @@ impl CompactEncoding for RequestUpgrade {
131102

132103
impl CompactEncoding for DataBlock {
133104
fn encoded_size(&self) -> Result<usize, EncodingError> {
134-
Ok(sum_encoded_size!(self, index, value, nodes))
105+
Ok(sum_encoded_size!(self.index, self.value, self.nodes))
135106
}
136107

137108
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
138-
Ok(chain_encoded_bytes!(self, buffer, index, value, nodes))
109+
Ok(map_encode!(buffer, self.index, self.value, self.nodes))
139110
}
140111

141112
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>
@@ -158,11 +129,11 @@ impl CompactEncoding for DataBlock {
158129

159130
impl CompactEncoding for DataHash {
160131
fn encoded_size(&self) -> Result<usize, EncodingError> {
161-
Ok(sum_encoded_size!(self, index, nodes))
132+
Ok(sum_encoded_size!(self.index, self.nodes))
162133
}
163134

164135
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
165-
Ok(chain_encoded_bytes!(self, buffer, index, nodes))
136+
Ok(map_encode!(buffer, self.index, self.nodes))
166137
}
167138

168139
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>
@@ -177,11 +148,11 @@ impl CompactEncoding for DataHash {
177148

178149
impl CompactEncoding for DataSeek {
179150
fn encoded_size(&self) -> Result<usize, EncodingError> {
180-
Ok(sum_encoded_size!(self, bytes, nodes))
151+
Ok(sum_encoded_size!(self.bytes, self.nodes))
181152
}
182153

183154
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
184-
Ok(chain_encoded_bytes!(self, buffer, bytes, nodes))
155+
Ok(map_encode!(buffer, self.bytes, self.nodes))
185156
}
186157

187158
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>
@@ -197,24 +168,22 @@ impl CompactEncoding for DataSeek {
197168
impl CompactEncoding for DataUpgrade {
198169
fn encoded_size(&self) -> Result<usize, EncodingError> {
199170
Ok(sum_encoded_size!(
200-
self,
201-
start,
202-
length,
203-
nodes,
204-
additional_nodes,
205-
signature
171+
self.start,
172+
self.length,
173+
self.nodes,
174+
self.additional_nodes,
175+
self.signature
206176
))
207177
}
208178

209179
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
210-
Ok(chain_encoded_bytes!(
211-
self,
180+
Ok(map_encode!(
212181
buffer,
213-
start,
214-
length,
215-
nodes,
216-
additional_nodes,
217-
signature
182+
self.start,
183+
self.length,
184+
self.nodes,
185+
self.additional_nodes,
186+
self.signature
218187
))
219188
}
220189

‎src/oplog/entry.rs‎

Lines changed: 19 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,9 @@
1-
use compact_encoding::{take_array, take_array_mut, write_array, CompactEncoding, EncodingError};
1+
use compact_encoding::{
2+
map_encode, sum_encoded_size, take_array, take_array_mut, write_array, CompactEncoding,
3+
EncodingError,
4+
};
25

3-
use crate::{chain_encoded_bytes, decode, sum_encoded_size};
6+
use crate::decode;
47
use crate::{common::BitfieldUpdate, Node};
58

69
/// Entry tree upgrade
@@ -14,12 +17,21 @@ pub(crate) struct EntryTreeUpgrade {
1417

1518
impl CompactEncoding for EntryTreeUpgrade {
1619
fn encoded_size(&self) -> Result<usize, EncodingError> {
17-
Ok(sum_encoded_size!(self, fork, ancestors, length, signature))
20+
Ok(sum_encoded_size!(
21+
self.fork,
22+
self.ancestors,
23+
self.length,
24+
self.signature
25+
))
1826
}
1927

2028
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
21-
Ok(chain_encoded_bytes!(
22-
self, buffer, fork, ancestors, length, signature
29+
Ok(map_encode!(
30+
buffer,
31+
self.fork,
32+
self.ancestors,
33+
self.length,
34+
self.signature
2335
))
2436
}
2537

@@ -33,13 +45,13 @@ impl CompactEncoding for EntryTreeUpgrade {
3345

3446
impl CompactEncoding for BitfieldUpdate {
3547
fn encoded_size(&self) -> Result<usize, EncodingError> {
36-
Ok(1 + sum_encoded_size!(self, start, length))
48+
Ok(1 + sum_encoded_size!(self.start, self.length))
3749
}
3850

3951
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
4052
let drop = if self.drop { 1 } else { 0 };
4153
let rest = write_array(&[drop], buffer)?;
42-
Ok(chain_encoded_bytes!(self, rest, start, length))
54+
Ok(map_encode!(rest, self.start, self.length))
4355
}
4456

4557
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>

‎src/oplog/header.rs‎

Lines changed: 26 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,11 @@
11
use compact_encoding::{decode_usize, take_array, write_array, CompactEncoding, EncodingError};
2+
use compact_encoding::{map_encode, sum_encoded_size};
23
use ed25519_dalek::{SigningKey, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH};
34

45
use crate::crypto::default_signer_manifest;
56
use crate::crypto::Manifest;
6-
use crate::{chain_encoded_bytes, VerifyingKey};
7-
use crate::{sum_encoded_size, PartialKeypair};
7+
use crate::PartialKeypair;
8+
use crate::VerifyingKey;
89

910
/// Oplog header.
1011
#[derive(Debug, Clone)]
@@ -110,12 +111,21 @@ macro_rules! decode {
110111

111112
impl CompactEncoding for HeaderTree {
112113
fn encoded_size(&self) -> Result<usize, EncodingError> {
113-
Ok(sum_encoded_size!(self, fork, length, root_hash, signature))
114+
Ok(sum_encoded_size!(
115+
self.fork,
116+
self.length,
117+
self.root_hash,
118+
self.signature
119+
))
114120
}
115121

116122
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
117-
Ok(chain_encoded_bytes!(
118-
self, buffer, fork, length, root_hash, signature
123+
Ok(map_encode!(
124+
buffer,
125+
self.fork,
126+
self.length,
127+
self.root_hash,
128+
self.signature
119129
))
120130
}
121131

@@ -203,16 +213,11 @@ pub(crate) struct HeaderHints {
203213

204214
impl CompactEncoding for HeaderHints {
205215
fn encoded_size(&self) -> Result<usize, EncodingError> {
206-
Ok(sum_encoded_size!(self, reorgs, contiguous_length))
216+
Ok(sum_encoded_size!(self.reorgs, self.contiguous_length))
207217
}
208218

209219
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {
210-
Ok(chain_encoded_bytes!(
211-
self,
212-
buffer,
213-
reorgs,
214-
contiguous_length
215-
))
220+
Ok(map_encode!(buffer, self.reorgs, self.contiguous_length))
216221
}
217222

218223
fn decode(buffer: &[u8]) -> Result<(Self, &[u8]), EncodingError>
@@ -225,7 +230,15 @@ impl CompactEncoding for HeaderHints {
225230

226231
impl CompactEncoding for Header {
227232
fn encoded_size(&self) -> Result<usize, EncodingError> {
228-
Ok(1 + 1 + 32 + sum_encoded_size!(self, manifest, key_pair, user_data, tree, hints))
233+
Ok(1 + 1
234+
+ 32
235+
+ sum_encoded_size!(
236+
self.manifest,
237+
self.key_pair,
238+
self.user_data,
239+
self.tree,
240+
self.hints
241+
))
229242
}
230243

231244
fn encode<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8], EncodingError> {

0 commit comments

Comments
 (0)