Stroika Library 3.0d25
 
Loading...
Searching...
No Matches
RequestHandler.inl
1/*
2 * Copyright(c) Sophist Solutions, Inc. 1990-2026. All rights reserved
3 */
4#include "Stroika/Foundation/Debug/Assertions.h"
5
6namespace Stroika::Frameworks::WebServer {
7
8 /*
9 ********************************************************************************
10 ************************** WebServer::RequestHandler ***************************
11 ********************************************************************************
12 */
13#if qCompilerAndStdLib_template_ConstraintDiffersInTemplateRedeclaration_Buggy
14 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const Sequence<String>&, bool&>) HANDLER_FUNCTION>
15 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
16 : inherited{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, [[maybe_unused]] bool& handled) {
17 if constexpr (invocable<HANDLER_FUNCTION, Message&, const Sequence<String>&, bool&>) {
18 messageHandler (m, matchedArgs, handled);
19 }
20 else if constexpr (invocable<HANDLER_FUNCTION, Message&, const Sequence<String>&>) {
21 messageHandler (m, matchedArgs);
22 handled = true;
23 }
24 else if constexpr (invocable<HANDLER_FUNCTION, Message&>) {
25 messageHandler (m);
26 handled = true;
27 }
28 else if constexpr (invocable<HANDLER_FUNCTION, Request&, Response&>) {
29 messageHandler (m.rwRequest (), m.rwResponse ());
30 handled = true;
31 }
32 else if constexpr (invocable<HANDLER_FUNCTION, Request&, Response&, const Sequence<String>&>) {
33 messageHandler (m.rwRequest (), m.rwResponse (), matchedArgs);
34 handled = true;
35 }
36 else if constexpr (invocable<HANDLER_FUNCTION, Request&, Response&, const Sequence<String>&, bool&>) {
37 messageHandler (m.rwRequest (), m.rwResponse (), matchedArgs, handled);
38 }
39 else if constexpr (invocable<HANDLER_FUNCTION, Message&, const String&>) {
40 Require (matchedArgs.size () == 1);
41 messageHandler (m, matchedArgs[0]);
42 handled = true;
43 }
44 else if constexpr (invocable<HANDLER_FUNCTION, Message&, const String&, const String&>) {
45 Require (matchedArgs.size () == 2);
46 messageHandler (m, matchedArgs[0], matchedArgs[1]);
47 handled = true;
48 }
49 else if constexpr (invocable<HANDLER_FUNCTION, Message&, const String&, const String&, const String&>) {
50 Require (matchedArgs.size () == 3);
51 messageHandler (m, matchedArgs[0], matchedArgs[1], matchedArgs[2]);
52 handled = true;
53 }
54 }}
55 {
56 }
57#else
58 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const Sequence<String>&, bool&>) HANDLER_FUNCTION>
59 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
60 : inherited{messageHandler}
61 {
62 }
63 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const Sequence<String>&>) HANDLER_FUNCTION>
64 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
65 : RequestHandler{[=] (Message& m, const Sequence<String>& matchedArgs, bool& handled) {
66 messageHandler (m, matchedArgs);
67 handled = true;
68 }}
69 {
70 }
71 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&>) HANDLER_FUNCTION>
72 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
73 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
74 messageHandler (m);
75 handled = true;
76 }}
77 {
78 }
79 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Request&, Response&>) HANDLER_FUNCTION>
80 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
81 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
82 messageHandler (m.rwRequest (), m.rwResponse ());
83 handled = true;
84 }}
85 {
86 }
87 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Request&, Response&, const Sequence<String>&>) HANDLER_FUNCTION>
88 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
89 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
90 messageHandler (m.rwRequest (), m.rwResponse (), matchedArgs);
91 handled = true;
92 }}
93 {
94 }
95 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Request&, Response&, const Sequence<String>&, bool&>) HANDLER_FUNCTION>
96 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
97 : RequestHandler{[=] (Message& m, const Sequence<String>& matchedArgs, bool& handled) {
98 messageHandler (m.rwRequest (), m.rwResponse (), matchedArgs, handled);
99 }}
100 {
101 }
102 // not sure (yet) how to do this with variadic templates
103 // explode Sequence<String> - caller bug/assertion of invoked with wrong # of arguments (since based solely on route regexp)
104 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const String&>) HANDLER_FUNCTION>
105 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
106 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
107 Require (matchedArgs.size () == 1);
108 messageHandler (m, matchedArgs[0]);
109 handled = true;
110 }}
111 {
112 }
113 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const String&, const String&>) HANDLER_FUNCTION>
114 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
115 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
116 Require (matchedArgs.size () == 2);
117 messageHandler (m, matchedArgs[0], matchedArgs[1]);
118 handled = true;
119 }}
120 {
121 }
122 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const String&, const String&, const String&>) HANDLER_FUNCTION>
123 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
124 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
125 Require (matchedArgs.size () == 3);
126 messageHandler (m, matchedArgs[0], matchedArgs[1], matchedArgs[2]);
127 handled = true;
128 }}
129 {
130 }
131#endif
132
133 // DEPRECATED....
134 inline RequestHandler::RequestHandler (const function<void (Message*, const Sequence<String>&, bool*)>& f)
135 : RequestHandler{[f] (Message& m, const Sequence<String>& a, bool& h) { f (&m, a, &h); }}
136 {
137 }
138 inline RequestHandler::RequestHandler (const function<void (Message*, const Sequence<String>&)>& f)
139 : RequestHandler{[f] (Message& m, const Sequence<String>& matches, bool& completed) {
140 f (&m, matches);
141 completed = true;
142 }}
143 {
144 }
145 inline RequestHandler::RequestHandler (const function<void (Message*)>& f)
146 : RequestHandler{[f] (Message& m, const Sequence<String>&, bool& completed) {
147 f (&m);
148 completed = true;
149 }}
150 {
151 }
152 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*)>>>*>
153 RequestHandler::RequestHandler (_Fx _Func)
154 : RequestHandler{[_Func] (Message& m, const Sequence<String>&, bool& completed) {
155 _Func (&m);
156 completed = true;
157 }}
158 {
159 }
160 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*, const Sequence<String>&)>>>*>
161 RequestHandler::RequestHandler (_Fx _Func, int*)
162 : RequestHandler{[_Func] (Message& m, const Sequence<String>& args, bool& completed) {
163 _Func (&m, args);
164 completed = true;
165 }}
166 {
167 }
168 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*, const String& arg0)>>>*>
169 RequestHandler::RequestHandler (_Fx _Func, short*)
170 : RequestHandler{[_Func] (Message& msg, const Sequence<String>& matches) {
171 Require (matches.length () >= 1);
172 _Func (&msg, matches[0]);
173 }}
174 {
175 }
176 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*, const String& arg0, const String& arg1)>>>*>
177 RequestHandler::RequestHandler (_Fx _Func, char*)
178 : RequestHandler{[_Func] (Message& msg, const Sequence<String>& matches) {
179 Require (matches.length () >= 2);
180 _Func (&msg, matches[0], matches[1]);
181 }}
182 {
183 }
184 template <class _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Request*, Response*)>>>*>
185 RequestHandler::RequestHandler (_Fx _Func, void*)
186 : RequestHandler{[_Func] (Message& message) { _Func (&message.rwRequest (), &message.rwResponse ()); }}
187 {
188 }
189
190}
Stroika::Foundation::Characters::String
String is like std::u32string, except it is much easier to use, often much more space efficient,...
Definition String.h:201
Stroika::Foundation::Containers::Sequence
A generalization of a vector: a container whose elements are keyed by the natural numbers.
Definition Library/Sources/Stroika/Foundation/Containers/Sequence.h:144
Stroika::Frameworks::WebServer::RequestHandler::RequestHandler
RequestHandler(HANDLER_FUNCTION &&messageHandler)
Definition RequestHandler.inl:59