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
22impl<'a> HeaderName<'a> {
23    pub(crate) fn parse(bytes: &'a [u8]) -> Result<Self, Error> {
24        std::str::from_utf8(bytes)
25            .map_err(|_| Error::InvalidHeaderName)
26            .map(HeaderName::from)
27    }
28
29    pub(crate) fn as_known(&self) -> Option<KnownHeaderName> {
30        match self.0 {
31            KnownHeader(k) => Some(k),
32            UnknownHeader(_) => None,
33        }
34    }
35}
36
37#[cfg(feature = "serde")]
38impl serde::Serialize for HeaderName<'_> {
39    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
40    where
41        S: serde::Serializer,
42    {
43        serializer.serialize_str(self.as_ref())
44    }
45}
46
47#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
48pub(super) enum HeaderNameInner<'a> {
49    /// A `KnownHeaderName`
50    KnownHeader(KnownHeaderName),
51    UnknownHeader(UnknownHeaderName<'a>),
52}
53
54impl Debug for HeaderNameInner<'_> {
55    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
56        match self {
57            Self::KnownHeader(known) => Debug::fmt(known, f),
58            Self::UnknownHeader(unknown) => Debug::fmt(unknown, f),
59        }
60    }
61}
62
63impl<'a> HeaderName<'a> {
64    /// Convert a potentially-borrowed headername to a static
65    /// headername _by value_.
66    #[must_use]
67    pub fn into_owned(self) -> HeaderName<'static> {
68        HeaderName(match self.0 {
69            KnownHeader(known) => KnownHeader(known),
70            UnknownHeader(uhn) => UnknownHeader(uhn.into_owned()),
71        })
72    }
73
74    /// Turn a `&'b HeaderName<'a>` into a `HeaderName<'b>`
75    pub fn reborrow<'b: 'a>(&'b self) -> HeaderName<'b> {
76        match self.0 {
77            KnownHeader(khn) => khn.into(),
78            UnknownHeader(ref uhn) => uhn.reborrow().into(),
79        }
80    }
81
82    /// Convert a potentially-borrowed headername to a static
83    /// headername _by cloning if needed from a borrow_. If you have
84    /// ownership of a headername with a non-static lifetime, it is
85    /// preferable to use `into_owned`. This is the equivalent of
86    /// `self.clone().into_owned()`.
87    #[must_use]
88    pub fn to_owned(&self) -> HeaderName<'static> {
89        self.clone().into_owned()
90    }
91
92    /// Determine if this header name contains only the appropriate characters
93    ///
94    /// since 0.3.12
95    pub fn is_valid(&self) -> bool {
96        match &self.0 {
97            KnownHeader(_) => true,
98            UnknownHeader(uh) => uh.is_valid(),
99        }
100    }
101}
102
103impl PartialEq<KnownHeaderName> for HeaderName<'_> {
104    fn eq(&self, other: &KnownHeaderName) -> bool {
105        match &self.0 {
106            KnownHeader(k) => other == k,
107            UnknownHeader(_) => false,
108        }
109    }
110}
111
112impl PartialEq<KnownHeaderName> for &HeaderName<'_> {
113    fn eq(&self, other: &KnownHeaderName) -> bool {
114        match &self.0 {
115            KnownHeader(k) => other == k,
116            UnknownHeader(_) => false,
117        }
118    }
119}
120
121impl PartialEq<str> for HeaderName<'_> {
122    fn eq(&self, other: &str) -> bool {
123        self.as_ref() == other
124    }
125}
126
127impl PartialEq<&str> for HeaderName<'_> {
128    fn eq(&self, other: &&str) -> bool {
129        self.as_ref() == *other
130    }
131}
132
133impl From<String> for HeaderName<'static> {
134    fn from(s: String) -> Self {
135        Self(match s.parse::<KnownHeaderName>() {
136            Ok(khn) => KnownHeader(khn),
137            Err(()) => UnknownHeader(UnknownHeaderName::from(s)),
138        })
139    }
140}
141
142impl<'a> From<&'a str> for HeaderName<'a> {
143    fn from(s: &'a str) -> Self {
144        Self(match s.parse::<KnownHeaderName>() {
145            Ok(khn) => KnownHeader(khn),
146            Err(_e) => UnknownHeader(UnknownHeaderName::from(s)),
147        })
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
