1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
//! A container of bytes, corresponding to the [Value::Bytes] type.
//!
//! [Value::Bytes]: crate::Value::Bytes.
use std::fmt;
use std::ops;
/// A vector of bytes.
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Bytes {
pub(crate) bytes: Vec<u8>,
}
impl Bytes {
/// Construct a new bytes container.
pub const fn new() -> Self {
Bytes { bytes: Vec::new() }
}
/// Construct a new bytes container with the specified capacity.
pub fn with_capacity(cap: usize) -> Self {
Bytes {
bytes: Vec::with_capacity(cap),
}
}
/// Convert into vector.
pub fn into_vec(self) -> Vec<u8> {
self.bytes
}
/// Construct from a byte vector.
pub fn from_vec(bytes: Vec<u8>) -> Self {
Self { bytes }
}
/// Do something with the bytes.
pub fn extend(&mut self, other: &Self) {
self.bytes.extend(other.bytes.iter().copied());
}
/// Do something with the bytes.
pub fn extend_str(&mut self, s: &str) {
self.bytes.extend(s.as_bytes());
}
/// Test if the collection is empty.
pub fn is_empty(&self) -> bool {
self.bytes.is_empty()
}
/// Get the length of the bytes collection.
pub fn len(&self) -> usize {
self.bytes.len()
}
/// Get the capacity of the bytes collection.
pub fn capacity(&self) -> usize {
self.bytes.capacity()
}
/// Get the bytes collection.
pub fn clear(&mut self) {
self.bytes.clear();
}
/// Reserve additional space.
///
/// The exact amount is unspecified.
pub fn reserve(&mut self, additional: usize) {
self.bytes.reserve(additional);
}
/// Resever additional space to the exact amount specified.
pub fn reserve_exact(&mut self, additional: usize) {
self.bytes.reserve_exact(additional);
}
/// Shrink to fit the amount of bytes in the container.
pub fn shrink_to_fit(&mut self) {
self.bytes.shrink_to_fit();
}
/// Pop the last byte.
pub fn pop(&mut self) -> Option<u8> {
self.bytes.pop()
}
/// Access the last byte.
pub fn last(&mut self) -> Option<u8> {
self.bytes.last().copied()
}
}
impl fmt::Debug for Bytes {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_list().entries(&self.bytes).finish()
}
}
impl ops::Deref for Bytes {
type Target = [u8];
fn deref(&self) -> &Self::Target {
&self.bytes
}
}
impl ops::DerefMut for Bytes {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.bytes
}
}