trillium_http/headers/
header_name.rs

1use super::{KnownHeaderName, UnknownHeaderName};
2use crate::Error;
3use HeaderNameInner::{KnownHeader, UnknownHeader};
4use std::{
5    fmt::{self, Debug, Display, Formatter},
6    hash::Hash,
7    str::FromStr,
8};
9
10/// The name of a http header. This can be either a
11/// [`KnownHeaderName`] or a string representation of an unknown
12/// header.
13#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
14pub struct HeaderName<'a>(pub(super) HeaderNameInner<'a>);
15
16impl Debug for HeaderName<'_> {
17    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
18        Debug::fmt(&self.0, f)
19    }
20}
21
22#[cfg(feature = "parse")]
23impl<'a> HeaderName<'a> {
24    pub(crate) fn parse(bytes: &'a [u8]) -> Result<Self, Error> {
25        std::str::from_utf8(bytes)
26            .map_err(|_| Error::InvalidHeaderName)
27            .map(HeaderName::from)
28    }
29}
30
31#[cfg(feature = "serde")]
32impl serde::Serialize for HeaderName<'_> {
33    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
34    where
35        S: serde::Serializer,
36    {
37        serializer.serialize_str(self.as_ref())
38    }
39}
40
41#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
42pub(super) enum HeaderNameInner<'a> {
43    /// A `KnownHeaderName`
44    KnownHeader(KnownHeaderName),
45    UnknownHeader(UnknownHeaderName<'a>),
46}
47
48impl Debug for HeaderNameInner<'_> {
49    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
50        match self {
51            Self::KnownHeader(known) => Debug::fmt(known, f),
52            Self::UnknownHeader(unknown) => Debug::fmt(unknown, f),
53        }
54    }
55}
56
57impl<'a> HeaderName<'a> {
58    /// Convert a potentially-borrowed headername to a static
59    /// headername _by value_.
60    #[must_use]
61    pub fn into_owned(self) -> HeaderName<'static> {
62        HeaderName(match self.0 {
63            KnownHeader(known) => KnownHeader(known),
64            UnknownHeader(uhn) => UnknownHeader(uhn.into_owned()),
65        })
66    }
67
68    /// Turn a `&'b HeaderName<'a>` into a `HeaderName<'b>`
69    pub fn reborrow<'b: 'a>(&'b self) -> HeaderName<'b> {
70        match self.0 {
71            KnownHeader(khn) => khn.into(),
72            UnknownHeader(ref uhn) => uhn.reborrow().into(),
73        }
74    }
75
76    /// Convert a potentially-borrowed headername to a static
77    /// headername _by cloning if needed from a borrow_. If you have
78    /// ownership of a headername with a non-static lifetime, it is
79    /// preferable to use `into_owned`. This is the equivalent of
80    /// `self.clone().into_owned()`.
81    #[must_use]
82    pub fn to_owned(&self) -> HeaderName<'static> {
83        self.clone().into_owned()
84    }
85
86    /// Determine if this header name contains only the appropriate characters
87    ///
88    /// since 0.3.12
89    pub fn is_valid(&self) -> bool {
90        match &self.0 {
91            KnownHeader(_) => true,
92            UnknownHeader(uh) => uh.is_valid(),
93        }
94    }
95}
96
97impl PartialEq<KnownHeaderName> for HeaderName<'_> {
98    fn eq(&self, other: &KnownHeaderName) -> bool {
99        match &self.0 {
100            KnownHeader(k) => other == k,
101            UnknownHeader(_) => false,
102        }
103    }
104}
105
106impl PartialEq<KnownHeaderName> for &HeaderName<'_> {
107    fn eq(&self, other: &KnownHeaderName) -> bool {
108        match &self.0 {
109            KnownHeader(k) => other == k,
110            UnknownHeader(_) => false,
111        }
112    }
113}
114
115impl PartialEq<str> for HeaderName<'_> {
116    fn eq(&self, other: &str) -> bool {
117        self.as_ref() == other
118    }
119}
120
121impl PartialEq<&str> for HeaderName<'_> {
122    fn eq(&self, other: &&str) -> bool {
123        self.as_ref() == *other
124    }
125}
126
127impl From<String> for HeaderName<'static> {
128    fn from(s: String) -> Self {
129        Self(match s.parse::<KnownHeaderName>() {
130            Ok(khn) => KnownHeader(khn),
131            Err(()) => UnknownHeader(UnknownHeaderName::from(s)),
132        })
133    }
134}
135
136impl<'a> From<&'a str> for HeaderName<'a> {
137    fn from(s: &'a str) -> Self {
138        Self(match s.parse::<KnownHeaderName>() {
139            Ok(khn) => KnownHeader(khn),
140            Err(_e) => UnknownHeader(UnknownHeaderName::from(s)),
141        })
142    }
143}
144
145impl<'a> From<&'a HeaderName<'_>> for HeaderName<'a> {
146    fn from(value: &'a HeaderName<'_>) -> Self {
147        value.reborrow()
148    }
149}
150
151impl FromStr for HeaderName<'static> {
152    type Err = Error;
153
154    fn from_str(s: &str) -> Result<Self, Self::Err> {
155        if let Ok(known) = s.parse::<KnownHeaderName>() {
156            return Ok(known.into());
157        }
158        let uhn = UnknownHeaderName::from(s.to_string());
159        if uhn.is_valid() {
160            Ok(uhn.into())
161        } else {
162            Err(Error::InvalidHeaderName)
163        }
164    }
165}
166
167impl AsRef<str> for HeaderName<'_> {
168    fn as_ref(&self) -> &str {
169        match &self.0 {
170            KnownHeader(khn) => khn.as_ref(),
171            UnknownHeader(u) => u.as_ref(),
172        }
173    }
174}
175
176impl Display for HeaderName<'_> {
177    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
178        f.write_str(self.as_ref())
179    }
180}
trillium_http/headers/header_name.rs

trillium_http/headers/
header_name.rs
