msf_rtsp/
request.rs

1//! Request types.
2
3use bytes::{Bytes, BytesMut};
4use tokio_util::codec::{Decoder, Encoder};
5
6use crate::{
7    CodecError, Method, Protocol, Version,
8    header::{FieldIter, HeaderField, HeaderFieldValue, Iter},
9    ttpkit::request::{
10        RequestHeader as GenericRequestHeader, RequestHeaderBuilder as GenericRequestHeaderBuilder,
11        RequestHeaderDecoder as GenericRequestHeaderDecoder,
12        RequestHeaderEncoder as GenericRequestHeaderEncoder,
13    },
14};
15
16pub use crate::ttpkit::request::{RequestHeaderDecoderOptions, RequestPath};
17
18/// RTSP request header.
19#[derive(Clone)]
20pub struct RequestHeader {
21    inner: GenericRequestHeader<Protocol, Version, Method>,
22}
23
24impl RequestHeader {
25    /// Create a new request header.
26    #[inline]
27    pub(crate) const fn new(header: GenericRequestHeader<Protocol, Version, Method>) -> Self {
28        Self { inner: header }
29    }
30
31    /// Get the request method.
32    #[inline]
33    pub fn method(&self) -> Method {
34        *self.inner.method()
35    }
36
37    /// Get the request protocol version.
38    #[inline]
39    pub fn version(&self) -> Version {
40        *self.inner.version()
41    }
42
43    /// Get the request path.
44    #[inline]
45    pub fn path(&self) -> &RequestPath {
46        self.inner.path()
47    }
48
49    /// Get all header fields.
50    #[inline]
51    pub fn get_all_header_fields(&self) -> Iter<'_> {
52        self.inner.get_all_header_fields()
53    }
54
55    /// Get header fields corresponding to a given name.
56    pub fn get_header_fields<'a, N>(&'a self, name: &'a N) -> FieldIter<'a>
57    where
58        N: AsRef<[u8]> + ?Sized,
59    {
60        self.inner.get_header_fields(name)
61    }
62
63    /// Get the last header field of a given name.
64    pub fn get_header_field<'a, N>(&'a self, name: &'a N) -> Option<&'a HeaderField>
65    where
66        N: AsRef<[u8]> + ?Sized,
67    {
68        self.inner.get_header_field(name)
69    }
70
71    /// Get value of the last header field with a given name.
72    pub fn get_header_field_value<'a, N>(&'a self, name: &'a N) -> Option<&'a HeaderFieldValue>
73    where
74        N: AsRef<[u8]> + ?Sized,
75    {
76        self.inner.get_header_field_value(name)
77    }
78}
79
80/// RTSP request builder.
81#[derive(Clone)]
82pub struct RequestBuilder {
83    inner: GenericRequestHeaderBuilder<Protocol, Version, Method>,
84}
85
86impl RequestBuilder {
87    /// Create a new builder.
88    #[inline]
89    const fn new(version: Version, method: Method, path: RequestPath) -> Self {
90        Self {
91            inner: GenericRequestHeader::builder(Protocol, version, method, path),
92        }
93    }
94
95    /// Set the protocol version.
96    #[inline]
97    pub fn set_version(mut self, version: Version) -> Self {
98        self.inner = self.inner.set_version(version);
99        self
100    }
101
102    /// Set the request method.
103    #[inline]
104    pub fn set_method(mut self, method: Method) -> Self {
105        self.inner = self.inner.set_method(method);
106        self
107    }
108
109    /// Set the request path.
110    #[inline]
111    pub fn set_path(mut self, path: RequestPath) -> Self {
112        self.inner = self.inner.set_path(path);
113        self
114    }
115
116    /// Replace the current header fields having the same name (if any).
117    pub fn set_header_field<T>(mut self, field: T) -> Self
118    where
119        T: Into<HeaderField>,
120    {
121        self.inner = self.inner.set_header_field(field);
122        self
123    }
124
125    /// Add a given header field.
126    pub fn add_header_field<T>(mut self, field: T) -> Self
127    where
128        T: Into<HeaderField>,
129    {
130        self.inner = self.inner.add_header_field(field);
131        self
132    }
133
134    /// Remove all header fields with a given name.
135    pub fn remove_header_fields<N>(mut self, name: &N) -> Self
136    where
137        N: AsRef<[u8]> + ?Sized,
138    {
139        self.inner = self.inner.remove_header_fields(name);
140        self
141    }
142
143    /// Build just the request header.
144    #[inline]
145    pub fn header(self) -> RequestHeader {
146        RequestHeader::new(self.inner.build())
147    }
148
149    /// Build the request.
150    pub fn body(self, body: Bytes) -> Request {
151        Request::new(self.header(), body)
152    }
153}
154
155impl From<RequestHeader> for RequestBuilder {
156    #[inline]
157    fn from(header: RequestHeader) -> Self {
158        Self {
159            inner: header.inner.into(),
160        }
161    }
162}
163
164/// HTTP request.
165#[derive(Clone)]
166pub struct Request {
167    header: RequestHeader,
168    body: Bytes,
169}
170
171impl Request {
172    /// Get a request builder.
173    #[inline]
174    pub const fn builder(version: Version, method: Method, path: RequestPath) -> RequestBuilder {
175        RequestBuilder::new(version, method, path)
176    }
177
178    /// Create a new request.
179    pub(crate) const fn new(header: RequestHeader, body: Bytes) -> Self {
180        Self { header, body }
181    }
182
183    /// Get the request header.
184    #[inline]
185    pub fn header(&self) -> &RequestHeader {
186        &self.header
187    }
188
189    /// Get the request method.
190    #[inline]
191    pub fn method(&self) -> Method {
192        self.header.method()
193    }
194
195    /// Get the request protocol version.
196    #[inline]
197    pub fn version(&self) -> Version {
198        self.header.version()
199    }
200
201    /// Get the request path.
202    #[inline]
203    pub fn path(&self) -> &RequestPath {
204        self.header.path()
205    }
206
207    /// Get all header fields.
208    #[inline]
209    pub fn get_all_header_fields(&self) -> Iter<'_> {
210        self.header.get_all_header_fields()
211    }
212
213    /// Get header fields corresponding to a given name.
214    pub fn get_header_fields<'a, N>(&'a self, name: &'a N) -> FieldIter<'a>
215    where
216        N: AsRef<[u8]> + ?Sized,
217    {
218        self.header.get_header_fields(name)
219    }
220
221    /// Get the last header field of a given name.
222    pub fn get_header_field<'a, N>(&'a self, name: &'a N) -> Option<&'a HeaderField>
223    where
224        N: AsRef<[u8]> + ?Sized,
225    {
226        self.header.get_header_field(name)
227    }
228
229    /// Get value of the last header field with a given name.
230    pub fn get_header_field_value<'a, N>(&'a self, name: &'a N) -> Option<&'a HeaderFieldValue>
231    where
232        N: AsRef<[u8]> + ?Sized,
233    {
234        self.header.get_header_field_value(name)
235    }
236
237    /// Get the request body.
238    #[inline]
239    pub fn body(&self) -> &Bytes {
240        &self.body
241    }
242
243    /// Split the request into its header and body.
244    #[inline]
245    pub fn deconstruct(self) -> (RequestHeader, Bytes) {
246        (self.header, self.body)
247    }
248}
249
250/// Request header decoder.
251pub struct RequestHeaderDecoder {
252    inner: GenericRequestHeaderDecoder<Protocol, Version, Method>,
253}
254
255impl RequestHeaderDecoder {
256    /// Create a new decoder.
257    #[inline]
258    pub fn new(options: RequestHeaderDecoderOptions) -> Self {
259        Self {
260            inner: GenericRequestHeaderDecoder::new(options),
261        }
262    }
263
264    /// Reset the decoder and make it ready for parsing a new request header.
265    #[inline]
266    pub fn reset(&mut self) {
267        self.inner.reset();
268    }
269
270    /// Decode a given request header chunk.
271    pub fn decode(&mut self, data: &mut BytesMut) -> Result<Option<RequestHeader>, CodecError> {
272        let res = self.inner.decode(data)?.map(RequestHeader::new);
273
274        Ok(res)
275    }
276
277    /// Decode a given request header chunk at the end of the stream.
278    pub fn decode_eof(&mut self, data: &mut BytesMut) -> Result<Option<RequestHeader>, CodecError> {
279        let res = self.inner.decode_eof(data)?.map(RequestHeader::new);
280
281        Ok(res)
282    }
283}
284
285impl Decoder for RequestHeaderDecoder {
286    type Item = RequestHeader;
287    type Error = CodecError;
288
289    #[inline]
290    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
291        Self::decode(self, buf)
292    }
293
294    #[inline]
295    fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
296        Self::decode_eof(self, buf)
297    }
298}
299
300/// Request header encoder.
301pub struct RequestHeaderEncoder {
302    inner: GenericRequestHeaderEncoder,
303}
304
305impl RequestHeaderEncoder {
306    /// Create a new encoder.
307    #[inline]
308    pub const fn new() -> Self {
309        Self {
310            inner: GenericRequestHeaderEncoder::new(),
311        }
312    }
313
314    /// Encode a given request header into a given buffer.
315    #[inline]
316    pub fn encode(&mut self, header: &RequestHeader, dst: &mut BytesMut) {
317        self.inner.encode(&header.inner, dst);
318    }
319}
320
321impl Default for RequestHeaderEncoder {
322    #[inline]
323    fn default() -> Self {
324        Self::new()
325    }
326}
327
328impl Encoder<&RequestHeader> for RequestHeaderEncoder {
329    type Error = CodecError;
330
331    #[inline]
332    fn encode(&mut self, header: &RequestHeader, dst: &mut BytesMut) -> Result<(), Self::Error> {
333        Self::encode(self, header, dst);
334
335        Ok(())
336    }
337}
msf_rtsp/request.rs

msf_rtsp/
request.rs
