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 valid token characters.
87    pub fn is_valid(&self) -> bool {
88        match &self.0 {
89            KnownHeader(_) => true,
90            UnknownHeader(uh) => uh.is_valid(),
91        }
92    }
93}
94
95impl PartialEq<KnownHeaderName> for HeaderName<'_> {
96    fn eq(&self, other: &KnownHeaderName) -> bool {
97        match &self.0 {
98            KnownHeader(k) => other == k,
99            UnknownHeader(_) => false,
100        }
101    }
102}
103
104impl PartialEq<KnownHeaderName> for &HeaderName<'_> {
105    fn eq(&self, other: &KnownHeaderName) -> bool {
106        match &self.0 {
107            KnownHeader(k) => other == k,
108            UnknownHeader(_) => false,
109        }
110    }
111}
112
113impl PartialEq<str> for HeaderName<'_> {
114    fn eq(&self, other: &str) -> bool {
115        self.as_ref() == other
116    }
117}
118
119impl PartialEq<&str> for HeaderName<'_> {
120    fn eq(&self, other: &&str) -> bool {
121        self.as_ref() == *other
122    }
123}
124
125impl From<String> for HeaderName<'static> {
126    fn from(s: String) -> Self {
127        Self(match s.parse::<KnownHeaderName>() {
128            Ok(khn) => KnownHeader(khn),
129            Err(()) => UnknownHeader(UnknownHeaderName::from(s)),
130        })
131    }
132}
133
134impl<'a> From<&'a str> for HeaderName<'a> {
135    fn from(s: &'a str) -> Self {
136        Self(match s.parse::<KnownHeaderName>() {
137            Ok(khn) => KnownHeader(khn),
138            Err(_e) => UnknownHeader(UnknownHeaderName::from(s)),
139        })
140    }
141}
142
143impl<'a> From<&'a HeaderName<'_>> for HeaderName<'a> {
144    fn from(value: &'a HeaderName<'_>) -> Self {
145        value.reborrow()
146    }
147}
148
149impl FromStr for HeaderName<'static> {
150    type Err = Error;
151
152    fn from_str(s: &str) -> Result<Self, Self::Err> {
153        if let Ok(known) = s.parse::<KnownHeaderName>() {
154            return Ok(known.into());
155        }
156        let uhn = UnknownHeaderName::from(s.to_string());
157        if uhn.is_valid() {
158            Ok(uhn.into())
159        } else {
160            Err(Error::InvalidHeaderName)
161        }
162    }
163}
164
165impl AsRef<str> for HeaderName<'_> {
166    fn as_ref(&self) -> &str {
167        match &self.0 {
168            KnownHeader(khn) => khn.as_ref(),
169            UnknownHeader(u) => u.as_ref(),
170        }
171    }
172}
173
174impl Display for HeaderName<'_> {
175    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
176        f.write_str(self.as_ref())
177    }
178}
trillium_http/headers/header_name.rs

trillium_http/headers/
header_name.rs
