apollo_configuration/types/
http.rs1use std::borrow::Cow;
4
5use derive_more::{Deref, Display, From, FromStr};
6use schemars::JsonSchema;
7use serde::de::Deserializer;
8use serde::{Deserialize, Serialize};
9
10use crate::Validate;
11
12#[derive(Debug, Clone, PartialEq, Eq, Hash, Deref, From, FromStr, Display)]
18pub struct HeaderName(http::HeaderName);
19
20impl<'de> Deserialize<'de> for HeaderName {
21 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
22 where
23 D: Deserializer<'de>,
24 {
25 let s = String::deserialize(deserializer)?;
26 s.parse().map_err(serde::de::Error::custom)
27 }
28}
29
30impl Serialize for HeaderName {
31 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
32 where
33 S: serde::Serializer,
34 {
35 self.0.as_str().serialize(serializer)
36 }
37}
38
39impl JsonSchema for HeaderName {
40 fn schema_name() -> Cow<'static, str> {
41 Cow::Borrowed("HeaderName")
42 }
43
44 fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
45 String::json_schema(generator)
46 }
47}
48
49impl Validate for HeaderName {}
50
51impl PartialEq<str> for HeaderName {
52 fn eq(&self, other: &str) -> bool {
53 self.0 == other
54 }
55}
56
57#[derive(Debug, Clone, PartialEq, Eq, Hash, Deref, From, FromStr)]
63pub struct HeaderValue(http::HeaderValue);
64
65impl<'de> Deserialize<'de> for HeaderValue {
66 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
67 where
68 D: Deserializer<'de>,
69 {
70 let s = String::deserialize(deserializer)?;
71 s.parse().map_err(serde::de::Error::custom)
72 }
73}
74
75impl Serialize for HeaderValue {
76 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
77 where
78 S: serde::Serializer,
79 {
80 self.0
81 .to_str()
82 .map_err(serde::ser::Error::custom)?
83 .serialize(serializer)
84 }
85}
86
87impl JsonSchema for HeaderValue {
88 fn schema_name() -> Cow<'static, str> {
89 Cow::Borrowed("HeaderValue")
90 }
91
92 fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
93 String::json_schema(generator)
94 }
95}
96
97impl Validate for HeaderValue {}
98
99#[derive(Debug, Clone, PartialEq, Eq, Hash, Deref, From, FromStr, Display)]
105pub struct Method(http::Method);
106
107impl<'de> Deserialize<'de> for Method {
108 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
109 where
110 D: Deserializer<'de>,
111 {
112 let s = String::deserialize(deserializer)?;
113 s.parse().map_err(serde::de::Error::custom)
114 }
115}
116
117impl Serialize for Method {
118 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
119 where
120 S: serde::Serializer,
121 {
122 self.0.as_str().serialize(serializer)
123 }
124}
125
126impl JsonSchema for Method {
127 fn schema_name() -> Cow<'static, str> {
128 Cow::Borrowed("Method")
129 }
130
131 fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
132 String::json_schema(generator)
133 }
134}
135
136impl Validate for Method {}
137
138impl PartialEq<str> for Method {
139 fn eq(&self, other: &str) -> bool {
140 self.0 == other
141 }
142}
143
144#[derive(Debug, Clone, PartialEq, Eq, Hash, Deref, From, FromStr, Display)]
150pub struct Uri(http::Uri);
151
152impl<'de> Deserialize<'de> for Uri {
153 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
154 where
155 D: Deserializer<'de>,
156 {
157 let s = String::deserialize(deserializer)?;
158 s.parse().map_err(serde::de::Error::custom)
159 }
160}
161
162impl Serialize for Uri {
163 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
164 where
165 S: serde::Serializer,
166 {
167 self.0.to_string().serialize(serializer)
168 }
169}
170
171impl JsonSchema for Uri {
172 fn schema_name() -> Cow<'static, str> {
173 Cow::Borrowed("Uri")
174 }
175
176 fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
177 String::json_schema(generator)
178 }
179}
180
181impl Validate for Uri {}