blob: 606a5d5e65e3a8a87eb93aebf4a877059acf1314 (
about) (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
module;
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
export module routemon:http.common;
namespace beast = boost::beast;
export namespace bhttp = beast::http;
namespace boost::beast {
namespace concepts {
template <class T>
concept buffers_generator = beast::is_buffers_generator<T>::value;
template <class T>
concept const_buffer_sequence = beast::is_const_buffer_sequence<T>::value;
} // namespace concepts
namespace http::concepts {
template <class T>
concept fields = is_fields<T>::value;
template <class T>
concept body = is_body<T>::value;
template <class T>
concept body_reader = is_body_reader<T>::value;
} // namespace http::concepts
} // namespace boost::beast
namespace routemon::http {
struct supported_verb
{
enum supported_verb_t : std::uint8_t
{
options,
delete_,
get,
head,
post,
put,
};
supported_verb_t value;
supported_verb(supported_verb_t value) : value{value} {}
static auto from(bhttp::verb v) -> std::optional<supported_verb>
{
switch (v)
{
case bhttp::verb::options:
return supported_verb::options;
case bhttp::verb::delete_:
return supported_verb::delete_;
case bhttp::verb::get:
return supported_verb::get;
case bhttp::verb::head:
return supported_verb::head;
case bhttp::verb::post:
return supported_verb::post;
case bhttp::verb::put:
return supported_verb::put;
default:
return std::nullopt;
}
}
operator bhttp::verb() const
{
switch (value)
{
case supported_verb::options:
return bhttp::verb::options;
case supported_verb::delete_:
return bhttp::verb::delete_;
case supported_verb::get:
return bhttp::verb::get;
case supported_verb::head:
return bhttp::verb::head;
case supported_verb::post:
return bhttp::verb::post;
case supported_verb::put:
return bhttp::verb::put;
}
}
};
export struct verb_set
{
bool delete_ : 1 = false;
bool get : 1 = false;
bool head : 1 = false;
bool post : 1 = false;
bool put : 1 = false;
bool options : 1 = false;
auto enable(supported_verb v) -> void
{
switch (v.value)
{
case supported_verb::delete_:
delete_ = true;
break;
case supported_verb::get:
get = true;
break;
case supported_verb::head:
head = true;
break;
case supported_verb::post:
post = true;
break;
case supported_verb::put:
put = true;
break;
case supported_verb::options:
options = true;
break;
default:;
}
}
auto operator==(verb_set const& rhs) const noexcept -> bool = default;
auto empty() const -> bool { return *this == verb_set{}; }
verb_set(std::initializer_list<supported_verb> vs)
{
for (auto const v : vs)
enable(v);
}
auto to_string() const -> std::string
{
std::ostringstream ss;
bool wrote = false;
auto write = [&](bhttp::verb v)
{
if (wrote)
ss << ", ";
ss << v;
wrote = true;
};
if (delete_)
write(bhttp::verb::delete_);
if (get)
write(bhttp::verb::get);
if (head)
write(bhttp::verb::head);
if (post)
write(bhttp::verb::post);
if (put)
write(bhttp::verb::put);
if (options)
write(bhttp::verb::options);
return ss.str();
}
};
} // namespace routemon::http
|
