http_types/headers/
header_values.rs

1use crate::headers::{HeaderValue, Values};
2
3use std::fmt::{self, Debug, Display};
4use std::iter::FromIterator;
5use std::ops::{Deref, DerefMut, Index};
6use std::slice::SliceIndex;
7
8/// A list of `HeaderValue`s.
9///
10/// This always contains at least one header value.
11#[derive(Clone)]
12pub struct HeaderValues {
13    pub(crate) inner: Vec<HeaderValue>,
14}
15
16impl HeaderValues {
17    /// Move all values from `other` into `self`, leaving `other` empty.
18    pub fn append(&mut self, other: &mut Self) {
19        self.inner.append(&mut other.inner)
20    }
21
22    /// Returns a reference or a value depending on the type of index.
23    pub fn get(&self, index: usize) -> Option<&HeaderValue> {
24        self.inner.get(index)
25    }
26
27    /// Returns a mutable reference or a value depending on the type of index.
28    pub fn get_mut(&mut self, index: usize) -> Option<&mut HeaderValue> {
29        self.inner.get_mut(index)
30    }
31
32    /// Returns `true` if there is a value corresponding to the specified `HeaderValue` in the list,
33    /// `false` otherwise.
34    pub fn contains(&self, value: &HeaderValue) -> bool {
35        self.inner.contains(value)
36    }
37
38    /// Returns the last `HeaderValue`.
39    pub fn last(&self) -> &HeaderValue {
40        self.inner
41            .last()
42            .expect("HeaderValues must always contain at least one value")
43    }
44
45    /// An iterator visiting all header values in arbitrary order.
46    pub fn iter(&self) -> Values<'_> {
47        Values::new_values(self)
48    }
49
50    // /// An iterator visiting all header values in arbitrary order, with mutable
51    // /// references to the values.
52    // pub fn iter_mut(&mut self) -> ValuesMut<'_> {
53    //     ValuesMut {
54    //         inner: self.headers.iter_mut(),
55    //     }
56    // }
57}
58
59impl<I: SliceIndex<[HeaderValue]>> Index<I> for HeaderValues {
60    type Output = I::Output;
61
62    #[inline]
63    fn index(&self, index: I) -> &Self::Output {
64        Index::index(&self.inner, index)
65    }
66}
67
68impl FromIterator<HeaderValue> for HeaderValues {
69    fn from_iter<I>(iter: I) -> HeaderValues
70    where
71        I: IntoIterator<Item = HeaderValue>,
72    {
73        let iter = iter.into_iter();
74        let mut output = Vec::with_capacity(iter.size_hint().0);
75        for v in iter {
76            output.push(v);
77        }
78        HeaderValues { inner: output }
79    }
80}
81
82impl Debug for HeaderValues {
83    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
84        if self.inner.len() == 1 {
85            write!(f, "{:?}", self.inner[0])
86        } else {
87            f.debug_list().entries(self.inner.iter()).finish()
88        }
89    }
90}
91
92impl Display for HeaderValues {
93    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
94        let mut list = f.debug_list();
95        for v in &self.inner {
96            list.entry(&v);
97        }
98        list.finish()
99    }
100}
101
102impl PartialEq<str> for HeaderValues {
103    fn eq(&self, other: &str) -> bool {
104        self.inner.len() == 1 && self.inner[0] == other
105    }
106}
107
108impl<'a> PartialEq<&'a str> for HeaderValues {
109    fn eq(&self, other: &&'a str) -> bool {
110        self.inner.len() == 1 && &self.inner[0] == other
111    }
112}
113
114impl<'a> PartialEq<[&'a str]> for HeaderValues {
115    fn eq(&self, other: &[&'a str]) -> bool {
116        self.inner.iter().eq(other.iter())
117    }
118}
119
120impl PartialEq<String> for HeaderValues {
121    fn eq(&self, other: &String) -> bool {
122        self.inner.len() == 1 && self.inner[0] == *other
123    }
124}
125
126impl<'a> PartialEq<&String> for HeaderValues {
127    fn eq(&self, other: &&String) -> bool {
128        self.inner.len() == 1 && self.inner[0] == **other
129    }
130}
131
132impl From<HeaderValue> for HeaderValues {
133    fn from(other: HeaderValue) -> Self {
134        Self { inner: vec![other] }
135    }
136}
137
138impl AsRef<HeaderValue> for HeaderValues {
139    fn as_ref(&self) -> &HeaderValue {
140        &self.inner[0]
141    }
142}
143
144impl AsMut<HeaderValue> for HeaderValues {
145    fn as_mut(&mut self) -> &mut HeaderValue {
146        &mut self.inner[0]
147    }
148}
149
150impl Deref for HeaderValues {
151    type Target = HeaderValue;
152
153    fn deref(&self) -> &HeaderValue {
154        &self.inner[0]
155    }
156}
157
158impl DerefMut for HeaderValues {
159    fn deref_mut(&mut self) -> &mut HeaderValue {
160        &mut self.inner[0]
161    }
162}
163
164impl<'a> IntoIterator for &'a HeaderValues {
165    type Item = &'a HeaderValue;
166    type IntoIter = Values<'a>;
167
168    #[inline]
169    fn into_iter(self) -> Self::IntoIter {
170        self.iter()
171    }
172}
173
174impl From<Vec<HeaderValue>> for HeaderValues {
175    fn from(headers: Vec<HeaderValue>) -> Self {
176        Self { inner: headers }
177    }
178}
179
180impl IntoIterator for HeaderValues {
181    type Item = HeaderValue;
182    type IntoIter = std::vec::IntoIter<HeaderValue>;
183
184    #[inline]
185    fn into_iter(self) -> Self::IntoIter {
186        self.inner.into_iter()
187    }
188}
189
190#[cfg(test)]
191mod tests {
192    use super::*;
193
194    #[test]
195    fn test_debug_single() {
196        let header_values = HeaderValues {
197            inner: vec!["foo0".parse().unwrap()],
198        };
199        assert_eq!(format!("{:?}", header_values), "\"foo0\"");
200    }
201    #[test]
202    fn test_debug_multiple() {
203        let header_values = HeaderValues {
204            inner: vec!["foo0".parse().unwrap(), "foo1".parse().unwrap()],
205        };
206        assert_eq!(format!("{:?}", header_values), r#"["foo0", "foo1"]"#);
207    }
208}
http_types/headers/header_values.rs

http_types/headers/
header_values.rs
