Skip to content

Commit 79fe68a

Browse files
caseycasey
authored
Borrow decoder input (#245)
1 parent 7390ee4 commit 79fe68a

15 files changed

Lines changed: 48 additions & 48 deletions

‎src/archive.rs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -23,12 +23,12 @@ impl Archive {
2323

2424
loose.remove(&hash);
2525

26-
Directory::decode_from_vec(file.clone()).context(archive_error::DirectoryDecode)
26+
Directory::decode_from_slice(file).context(archive_error::DirectoryDecode)
2727
}
2828

2929
pub(crate) fn fingerprint(&self) -> Fingerprint {
3030
let root = &self.files[&self.root];
31-
let root = Directory::decode_from_vec(root.clone()).unwrap();
31+
let root = Directory::decode_from_slice(root).unwrap();
3232
Fingerprint(root.entries[&Self::PACKAGE.parse::<Component>().unwrap()].hash)
3333
}
3434

@@ -258,7 +258,7 @@ mod tests {
258258
};
259259
let archive = Archive::pack(&manifest);
260260
let bytes = archive.encode_to_vec();
261-
let decoded = Archive::decode_from_vec(bytes).unwrap();
261+
let decoded = Archive::decode_from_slice(&bytes).unwrap();
262262
assert_eq!(decoded.unpack().unwrap(), manifest);
263263
}
264264

@@ -274,7 +274,7 @@ mod tests {
274274

275275
let archive = Archive::pack(&manifest);
276276
let bytes = archive.encode_to_vec();
277-
let decoded = Archive::decode_from_vec(bytes).unwrap();
277+
let decoded = Archive::decode_from_slice(&bytes).unwrap();
278278
assert_eq!(decoded.unpack().unwrap(), manifest);
279279
}
280280

@@ -283,7 +283,7 @@ mod tests {
283283
let manifest = manifest();
284284
let archive = Archive::pack(&manifest);
285285
let bytes = archive.encode_to_vec();
286-
let decoded = Archive::decode_from_vec(bytes).unwrap();
286+
let decoded = Archive::decode_from_slice(&bytes).unwrap();
287287
assert_eq!(decoded.unpack().unwrap(), manifest);
288288
}
289289

@@ -304,7 +304,7 @@ mod tests {
304304

305305
let archive = Archive::pack(&manifest);
306306
let bytes = archive.encode_to_vec();
307-
let decoded = Archive::decode_from_vec(bytes).unwrap();
307+
let decoded = Archive::decode_from_slice(&bytes).unwrap();
308308
assert_eq!(decoded.unpack().unwrap(), manifest);
309309
}
310310

@@ -327,7 +327,7 @@ mod tests {
327327

328328
let archive = Archive::pack(&manifest);
329329
let bytes = archive.encode_to_vec();
330-
let decoded = Archive::decode_from_vec(bytes).unwrap();
330+
let decoded = Archive::decode_from_slice(&bytes).unwrap();
331331
assert_eq!(decoded.unpack().unwrap(), manifest);
332332
}
333333

@@ -359,7 +359,7 @@ mod tests {
359359

360360
let archive = Archive::pack(&manifest);
361361
let bytes = archive.encode_to_vec();
362-
let decoded = Archive::decode_from_vec(bytes).unwrap();
362+
let decoded = Archive::decode_from_slice(&bytes).unwrap();
363363
assert_eq!(decoded.unpack().unwrap(), manifest);
364364
}
365365

‎src/component.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,7 @@ mod tests {
130130
&[0x63, 0x66, 0x6f, 0x6f],
131131
);
132132
let empty = "".encode_to_vec();
133-
let mut decoder = Decoder::new(empty);
133+
let mut decoder = Decoder::new(&empty);
134134
assert_matches!(
135135
Component::decode(&mut decoder),
136136
Err(DecodeError::Component {

‎src/date_time.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ mod tests {
6969
#[test]
7070
fn decode_error() {
7171
assert_matches!(
72-
DateTime::decode(&mut Decoder::new("foo".encode_to_vec())),
72+
DateTime::decode(&mut Decoder::new(&"foo".encode_to_vec())),
7373
Err(DecodeError::DateTime { .. }),
7474
);
7575
}

‎src/decode.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@ use super::*;
33
pub(crate) trait Decode: Sized {
44
fn decode(decoder: &mut Decoder) -> Result<Self, DecodeError>;
55

6-
fn decode_from_vec(buffer: Vec<u8>) -> Result<Self, DecodeError> {
6+
fn decode_from_slice(buffer: &[u8]) -> Result<Self, DecodeError> {
77
let mut decoder = Decoder::new(buffer);
88
let value = Self::decode(&mut decoder)?;
99
decoder.finish()?;
@@ -73,7 +73,7 @@ mod tests {
7373
#[test]
7474
fn decode_from_vec_errors_on_trailing_bytes() {
7575
assert_matches!(
76-
u8::decode_from_vec(vec![0x00, 0x00]),
76+
u8::decode_from_slice(&[0x00, 0x00]),
7777
Err(DecodeError::TrailingBytes),
7878
);
7979
}

‎src/decoder.rs‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
11
use super::*;
22

3-
pub(crate) struct Decoder {
4-
buffer: Vec<u8>,
3+
pub(crate) struct Decoder<'a> {
4+
buffer: &'a [u8],
55
position: usize,
66
stack: Vec<usize>,
77
}
88

9-
impl Decoder {
9+
impl<'a> Decoder<'a> {
1010
fn array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError> {
1111
Ok(self.slice(N)?.try_into().unwrap())
1212
}
@@ -82,12 +82,12 @@ impl Decoder {
8282
self.expect(MajorType::UnsignedInteger)
8383
}
8484

85-
pub(crate) fn map<K>(&mut self) -> Result<MapDecoder<K>, DecodeError> {
85+
pub(crate) fn map<'b, K>(&'b mut self) -> Result<MapDecoder<'b, 'a, K>, DecodeError> {
8686
let len = self.expect(MajorType::Map)?;
8787
Ok(MapDecoder::new(self, len))
8888
}
8989

90-
pub(crate) fn new(buffer: Vec<u8>) -> Self {
90+
pub(crate) fn new(buffer: &'a [u8]) -> Self {
9191
Self {
9292
buffer,
9393
position: 0,
@@ -133,15 +133,15 @@ mod tests {
133133

134134
#[test]
135135
fn finish_errors_on_trailing_bytes() {
136-
let mut decoder = Decoder::new(vec![0x00, 0x00]);
136+
let mut decoder = Decoder::new(&[0x00, 0x00]);
137137
u8::decode(&mut decoder).unwrap();
138138
assert_matches!(decoder.finish(), Err(DecodeError::TrailingBytes));
139139
}
140140

141141
#[test]
142142
fn integer_range() {
143143
assert!(matches!(
144-
u8::decode(&mut Decoder::new(256u64.encode_to_vec())),
144+
u8::decode(&mut Decoder::new(&256u64.encode_to_vec())),
145145
Err(DecodeError::IntegerRange { .. }),
146146
));
147147
}
@@ -151,7 +151,7 @@ mod tests {
151151
#[track_caller]
152152
fn case(bytes: &[u8]) {
153153
assert_matches!(
154-
Decoder::new(bytes.to_vec()).head(),
154+
Decoder::new(bytes).head(),
155155
Err(DecodeError::OverlongInteger),
156156
);
157157
}
@@ -164,7 +164,7 @@ mod tests {
164164

165165
#[test]
166166
fn position_stack() {
167-
let mut decoder = Decoder::new(vec![0x01, 0x02]);
167+
let mut decoder = Decoder::new(&[0x01, 0x02]);
168168
decoder.push_position();
169169
assert_eq!(decoder.integer().unwrap(), 1);
170170
decoder.pop_position();
@@ -174,20 +174,20 @@ mod tests {
174174
#[test]
175175
fn reserved_additional_information() {
176176
assert_matches!(
177-
Decoder::new(vec![0x1c]).head(),
177+
Decoder::new(&[0x1c]).head(),
178178
Err(DecodeError::ReservedAdditionalInformation { value }) if value == 28,
179179
);
180180
}
181181

182182
#[test]
183183
fn truncated() {
184-
assert_matches!(Decoder::new(vec![]).head(), Err(DecodeError::Truncated));
184+
assert_matches!(Decoder::new(&[]).head(), Err(DecodeError::Truncated));
185185
}
186186

187187
#[test]
188188
fn type_mismatch() {
189189
assert_matches!(
190-
Decoder::new(vec![0x60]).integer(),
190+
Decoder::new(&[0x60]).integer(),
191191
Err(DecodeError::UnexpectedType {
192192
expected: MajorType::UnsignedInteger,
193193
actual: MajorType::Text
@@ -198,15 +198,15 @@ mod tests {
198198
#[test]
199199
fn unicode() {
200200
assert_matches!(
201-
Decoder::new(vec![0x62, 0xff, 0xfe]).text().map(drop),
201+
Decoder::new(&[0x62, 0xff, 0xfe]).text().map(drop),
202202
Err(DecodeError::Unicode { .. }),
203203
);
204204
}
205205

206206
#[test]
207207
fn unsupported_additional_information() {
208208
assert_matches!(
209-
Decoder::new(vec![0x1f]).head(),
209+
Decoder::new(&[0x1f]).head(),
210210
Err(DecodeError::UnsupportedAdditionalInformation { value }) if value == 31,
211211
);
212212
}

‎src/filename.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ mod tests {
7979
#[test]
8080
fn decode_error() {
8181
assert_matches!(
82-
Png::decode(&mut Decoder::new("cover.jpg".encode_to_vec())),
82+
Png::decode(&mut Decoder::new(&"cover.jpg".encode_to_vec())),
8383
Err(DecodeError::Component {
8484
source: ComponentError::Extension { extension: "png" },
8585
}),

‎src/language.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -229,7 +229,7 @@ mod tests {
229229
#[test]
230230
fn decode_error() {
231231
assert_matches!(
232-
Language::decode(&mut Decoder::new("xx".encode_to_vec())),
232+
Language::decode(&mut Decoder::new(&"xx".encode_to_vec())),
233233
Err(DecodeError::Language { source: LanguageError::Code { code }, }) if code == "xx",
234234
);
235235
}

‎src/lib.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,7 @@ fn tempdir() -> tempfile::TempDir {
138138
fn assert_cbor<T: Debug + Decode + Encode + PartialEq>(value: T, cbor: &[u8]) {
139139
let buffer = value.encode_to_vec();
140140
assert_eq!(buffer, cbor);
141-
let mut decoder = Decoder::new(buffer);
141+
let mut decoder = Decoder::new(&buffer);
142142
let decoded = T::decode(&mut decoder).unwrap();
143143
decoder.finish().unwrap();
144144
assert_eq!(decoded, value);
@@ -148,7 +148,7 @@ fn assert_cbor<T: Debug + Decode + Encode + PartialEq>(value: T, cbor: &[u8]) {
148148
#[track_caller]
149149
fn assert_encoding<T: Debug + Decode + Encode + PartialEq>(value: T) {
150150
let buffer = value.encode_to_vec();
151-
let mut decoder = Decoder::new(buffer);
151+
let mut decoder = Decoder::new(&buffer);
152152
let decoded = T::decode(&mut decoder).unwrap();
153153
decoder.finish().unwrap();
154154
assert_eq!(decoded, value);

‎src/manifest.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -81,7 +81,7 @@ impl Manifest {
8181
.ok_or_else(|| error::ManifestNotFound { path: display_path }.build())?;
8282

8383
let archive =
84-
Archive::decode_from_vec(cbor).context(error::DecodeManifest { path: display_path })?;
84+
Archive::decode_from_slice(&cbor).context(error::DecodeManifest { path: display_path })?;
8585

8686
let manifest = archive
8787
.unpack()

‎src/map_decoder.rs‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
use super::*;
22

3-
pub(crate) struct MapDecoder<'a, K> {
4-
decoder: &'a mut Decoder,
3+
pub(crate) struct MapDecoder<'a, 'b, K> {
4+
decoder: &'a mut Decoder<'b>,
55
last: Option<K>,
66
remaining: u64,
77
}
88

9-
impl<'a, K> MapDecoder<'a, K> {
10-
pub(crate) fn new(decoder: &'a mut Decoder, len: u64) -> Self {
9+
impl<'a, 'b, K> MapDecoder<'a, 'b, K> {
10+
pub(crate) fn new(decoder: &'a mut Decoder<'b>, len: u64) -> Self {
1111
Self {
1212
decoder,
1313
last: None,
@@ -16,7 +16,7 @@ impl<'a, K> MapDecoder<'a, K> {
1616
}
1717
}
1818

19-
impl<K: Clone + Decode + Debug + PartialOrd> MapDecoder<'_, K> {
19+
impl<K: Clone + Decode + Debug + PartialOrd> MapDecoder<'_, '_, K> {
2020
pub(crate) fn finish(&mut self) -> Result<(), DecodeError> {
2121
ensure!(self.remaining == 0, decode_error::UnconsumedEntries);
2222
Ok(())
@@ -96,21 +96,21 @@ mod tests {
9696

9797
#[test]
9898
fn key_mismatch() {
99-
let mut decoder = Decoder::new(vec![0xa1, 0x01, 0x00]);
99+
let mut decoder = Decoder::new(&[0xa1, 0x01, 0x00]);
100100
let mut map = decoder.map::<u64>().unwrap();
101101
assert_matches!(map.key::<u64>(0), Err(DecodeError::UnexpectedKey));
102102
}
103103

104104
#[test]
105105
fn missing_field() {
106-
let mut decoder = Decoder::new(vec![0xa0]);
106+
let mut decoder = Decoder::new(&[0xa0]);
107107
let mut map = decoder.map::<u64>().unwrap();
108108
assert_matches!(map.required_key::<u64>(0), Err(DecodeError::MissingField { key }) if key == "0");
109109
}
110110

111111
#[test]
112112
fn optional_key_missing() {
113-
let mut decoder = Decoder::new(vec![0xa1, 0x01, 0x18, 0x2a]);
113+
let mut decoder = Decoder::new(&[0xa1, 0x01, 0x18, 0x2a]);
114114
let mut map = decoder.map::<u64>().unwrap();
115115
assert_matches!(map.optional_key::<u64>(0), Ok(None));
116116
map.next::<u64>().unwrap();
@@ -119,23 +119,23 @@ mod tests {
119119

120120
#[test]
121121
fn optional_key_present() {
122-
let mut decoder = Decoder::new(vec![0xa1, 0x00, 0x18, 0x2a]);
122+
let mut decoder = Decoder::new(&[0xa1, 0x00, 0x18, 0x2a]);
123123
let mut map = decoder.map::<u64>().unwrap();
124124
assert_matches!(map.optional_key::<u64>(0), Ok(Some(42)));
125125
map.finish().unwrap();
126126
}
127127

128128
#[test]
129129
fn out_of_order() {
130-
let mut decoder = Decoder::new(vec![0xa2, 0x02, 0x00, 0x01, 0x00]);
130+
let mut decoder = Decoder::new(&[0xa2, 0x02, 0x00, 0x01, 0x00]);
131131
let mut map = decoder.map::<u64>().unwrap();
132132
map.next::<u64>().unwrap();
133133
assert_matches!(map.next::<u64>(), Err(DecodeError::KeyOrder));
134134
}
135135

136136
#[test]
137137
fn unconsumed_entries() {
138-
let mut decoder = Decoder::new(vec![0xa2, 0x00, 0x00, 0x01, 0x01]);
138+
let mut decoder = Decoder::new(&[0xa2, 0x00, 0x00, 0x01, 0x01]);
139139
let mut map = decoder.map::<u64>().unwrap();
140140
map.next::<u64>().unwrap();
141141
assert_matches!(map.finish(), Err(DecodeError::UnconsumedEntries));

0 commit comments

Comments
 (0)