1 use {Buf, BufMut};
2 use iovec::IoVec;
3 
4 /// A `Chain` sequences two buffers.
5 ///
6 /// `Chain` is an adapter that links two underlying buffers and provides a
7 /// continous view across both buffers. It is able to sequence either immutable
8 /// buffers ([`Buf`] values) or mutable buffers ([`BufMut`] values).
9 ///
10 /// This struct is generally created by calling [`Buf::chain`]. Please see that
11 /// function's documentation for more detail.
12 ///
13 /// # Examples
14 ///
15 /// ```
16 /// use bytes::{Bytes, Buf, IntoBuf};
17 /// use bytes::buf::Chain;
18 ///
19 /// let buf = Bytes::from(&b"hello "[..]).into_buf()
20 ///             .chain(Bytes::from(&b"world"[..]));
21 ///
22 /// let full: Bytes = buf.collect();
23 /// assert_eq!(full[..], b"hello world"[..]);
24 /// ```
25 ///
26 /// [`Buf::chain`]: trait.Buf.html#method.chain
27 /// [`Buf`]: trait.Buf.html
28 /// [`BufMut`]: trait.BufMut.html
29 #[derive(Debug)]
30 pub struct Chain<T, U> {
31     a: T,
32     b: U,
33 }
34 
35 impl<T, U> Chain<T, U> {
36     /// Creates a new `Chain` sequencing the provided values.
37     ///
38     /// # Examples
39     ///
40     /// ```
41     /// use bytes::BytesMut;
42     /// use bytes::buf::Chain;
43     ///
44     /// let buf = Chain::new(
45     ///     BytesMut::with_capacity(1024),
46     ///     BytesMut::with_capacity(1024));
47     ///
48     /// // Use the chained buffer
49     /// ```
new(a: T, b: U) -> Chain<T, U>50     pub fn new(a: T, b: U) -> Chain<T, U> {
51         Chain {
52             a: a,
53             b: b,
54         }
55     }
56 
57     /// Gets a reference to the first underlying `Buf`.
58     ///
59     /// # Examples
60     ///
61     /// ```
62     /// use bytes::{Bytes, Buf, IntoBuf};
63     ///
64     /// let buf = Bytes::from(&b"hello"[..]).into_buf()
65     ///             .chain(Bytes::from(&b"world"[..]));
66     ///
67     /// assert_eq!(buf.first_ref().get_ref()[..], b"hello"[..]);
68     /// ```
first_ref(&self) -> &T69     pub fn first_ref(&self) -> &T {
70         &self.a
71     }
72 
73     /// Gets a mutable reference to the first underlying `Buf`.
74     ///
75     /// # Examples
76     ///
77     /// ```
78     /// use bytes::{Bytes, Buf, IntoBuf};
79     ///
80     /// let mut buf = Bytes::from(&b"hello "[..]).into_buf()
81     ///                 .chain(Bytes::from(&b"world"[..]));
82     ///
83     /// buf.first_mut().set_position(1);
84     ///
85     /// let full: Bytes = buf.collect();
86     /// assert_eq!(full[..], b"ello world"[..]);
87     /// ```
first_mut(&mut self) -> &mut T88     pub fn first_mut(&mut self) -> &mut T {
89         &mut self.a
90     }
91 
92     /// Gets a reference to the last underlying `Buf`.
93     ///
94     /// # Examples
95     ///
96     /// ```
97     /// use bytes::{Bytes, Buf, IntoBuf};
98     ///
99     /// let buf = Bytes::from(&b"hello"[..]).into_buf()
100     ///             .chain(Bytes::from(&b"world"[..]));
101     ///
102     /// assert_eq!(buf.last_ref().get_ref()[..], b"world"[..]);
103     /// ```
last_ref(&self) -> &U104     pub fn last_ref(&self) -> &U {
105         &self.b
106     }
107 
108     /// Gets a mutable reference to the last underlying `Buf`.
109     ///
110     /// # Examples
111     ///
112     /// ```
113     /// use bytes::{Bytes, Buf, IntoBuf};
114     ///
115     /// let mut buf = Bytes::from(&b"hello "[..]).into_buf()
116     ///                 .chain(Bytes::from(&b"world"[..]));
117     ///
118     /// buf.last_mut().set_position(1);
119     ///
120     /// let full: Bytes = buf.collect();
121     /// assert_eq!(full[..], b"hello orld"[..]);
122     /// ```
last_mut(&mut self) -> &mut U123     pub fn last_mut(&mut self) -> &mut U {
124         &mut self.b
125     }
126 
127     /// Consumes this `Chain`, returning the underlying values.
128     ///
129     /// # Examples
130     ///
131     /// ```
132     /// use bytes::{Bytes, Buf, IntoBuf};
133     ///
134     /// let buf = Bytes::from(&b"hello"[..]).into_buf()
135     ///             .chain(Bytes::from(&b"world"[..]));
136     ///
137     /// let (first, last) = buf.into_inner();
138     /// assert_eq!(first.get_ref()[..], b"hello"[..]);
139     /// assert_eq!(last.get_ref()[..], b"world"[..]);
140     /// ```
into_inner(self) -> (T, U)141     pub fn into_inner(self) -> (T, U) {
142         (self.a, self.b)
143     }
144 }
145 
146 impl<T, U> Buf for Chain<T, U>
147     where T: Buf,
148           U: Buf,
149 {
remaining(&self) -> usize150     fn remaining(&self) -> usize {
151         self.a.remaining() + self.b.remaining()
152     }
153 
bytes(&self) -> &[u8]154     fn bytes(&self) -> &[u8] {
155         if self.a.has_remaining() {
156             self.a.bytes()
157         } else {
158             self.b.bytes()
159         }
160     }
161 
advance(&mut self, mut cnt: usize)162     fn advance(&mut self, mut cnt: usize) {
163         let a_rem = self.a.remaining();
164 
165         if a_rem != 0 {
166             if a_rem >= cnt {
167                 self.a.advance(cnt);
168                 return;
169             }
170 
171             // Consume what is left of a
172             self.a.advance(a_rem);
173 
174             cnt -= a_rem;
175         }
176 
177         self.b.advance(cnt);
178     }
179 
bytes_vec<'a>(&'a self, dst: &mut [&'a IoVec]) -> usize180     fn bytes_vec<'a>(&'a self, dst: &mut [&'a IoVec]) -> usize {
181         let mut n = self.a.bytes_vec(dst);
182         n += self.b.bytes_vec(&mut dst[n..]);
183         n
184     }
185 }
186 
187 impl<T, U> BufMut for Chain<T, U>
188     where T: BufMut,
189           U: BufMut,
190 {
remaining_mut(&self) -> usize191     fn remaining_mut(&self) -> usize {
192         self.a.remaining_mut() + self.b.remaining_mut()
193     }
194 
bytes_mut(&mut self) -> &mut [u8]195     unsafe fn bytes_mut(&mut self) -> &mut [u8] {
196         if self.a.has_remaining_mut() {
197             self.a.bytes_mut()
198         } else {
199             self.b.bytes_mut()
200         }
201     }
202 
advance_mut(&mut self, mut cnt: usize)203     unsafe fn advance_mut(&mut self, mut cnt: usize) {
204         let a_rem = self.a.remaining_mut();
205 
206         if a_rem != 0 {
207             if a_rem >= cnt {
208                 self.a.advance_mut(cnt);
209                 return;
210             }
211 
212             // Consume what is left of a
213             self.a.advance_mut(a_rem);
214 
215             cnt -= a_rem;
216         }
217 
218         self.b.advance_mut(cnt);
219     }
220 
bytes_vec_mut<'a>(&'a mut self, dst: &mut [&'a mut IoVec]) -> usize221     unsafe fn bytes_vec_mut<'a>(&'a mut self, dst: &mut [&'a mut IoVec]) -> usize {
222         let mut n = self.a.bytes_vec_mut(dst);
223         n += self.b.bytes_vec_mut(&mut dst[n..]);
224         n
225     }
226 }
227