Stroika Library 3.0d16
 
Loading...
Searching...
No Matches
RequestHandler.inl
1/*
2 * Copyright(c) Sophist Solutions, Inc. 1990-2025. 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);
38 handled = true;
39 }
40 else if constexpr (invocable<HANDLER_FUNCTION, Message&, const String&>) {
41 Require (matchedArgs.size () == 1);
42 messageHandler (m, matchedArgs[0]);
43 handled = true;
44 }
45 else if constexpr (invocable<HANDLER_FUNCTION, Message&, const String&, const String&>) {
46 Require (matchedArgs.size () == 2);
47 messageHandler (m, matchedArgs[0], matchedArgs[1]);
48 handled = true;
49 }
50 else if constexpr (invocable<HANDLER_FUNCTION, Message&, const String&, const String&, const String&>) {
51 Require (matchedArgs.size () == 3);
52 messageHandler (m, matchedArgs[0], matchedArgs[1], matchedArgs[2]);
53 handled = true;
54 }
55 }}
56 {
57 }
58#else
59 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const Sequence<String>&, bool&>) HANDLER_FUNCTION>
60 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
61 : inherited{messageHandler}
62 {
63 }
64 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const Sequence<String>&>) HANDLER_FUNCTION>
65 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
66 : RequestHandler{[=] (Message& m, const Sequence<String>& matchedArgs, bool& handled) {
67 messageHandler (m, matchedArgs);
68 handled = true;
69 }}
70 {
71 }
72 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&>) HANDLER_FUNCTION>
73 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
74 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
75 messageHandler (m);
76 handled = true;
77 }}
78 {
79 }
80 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Request&, Response&>) HANDLER_FUNCTION>
81 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
82 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
83 messageHandler (m.rwRequest (), m.rwResponse ());
84 handled = true;
85 }}
86 {
87 }
88 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Request&, Response&, const Sequence<String>&>) HANDLER_FUNCTION>
89 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
90 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
91 messageHandler (m.rwRequest (), m.rwResponse (), matchedArgs);
92 handled = true;
93 }}
94 {
95 }
96 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Request&, Response&, const Sequence<String>&, bool&>) HANDLER_FUNCTION>
97 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
98 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
99 messageHandler (m);
100 handled = true;
101 }}
102 {
103 }
104 // not sure (yet) how to do this with variadic templates
105 // explode Sequence<String> - caller bug/assertion of invoked with wrong # of arguments (since based solely on route regexp)
106 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const String&>) HANDLER_FUNCTION>
107 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
108 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
109 Require (matchedArgs.size () == 1);
110 messageHandler (m, matchedArgs[0]);
111 handled = true;
112 }}
113 {
114 }
115 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const String&, const String&>) HANDLER_FUNCTION>
116 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
117 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
118 Require (matchedArgs.size () == 2);
119 messageHandler (m, matchedArgs[0], matchedArgs[1]);
120 handled = true;
121 }}
122 {
123 }
124 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (invocable<Message&, const String&, const String&, const String&>) HANDLER_FUNCTION>
125 inline RequestHandler::RequestHandler (HANDLER_FUNCTION&& messageHandler)
126 : RequestHandler{[=] (Message& m, [[maybe_unused]] const Sequence<String>& matchedArgs, bool& handled) {
127 Require (matchedArgs.size () == 3);
128 messageHandler (m, matchedArgs[0], matchedArgs[1], matchedArgs[2]);
129 handled = true;
130 }}
131 {
132 }
133#endif
134
135 // DEPRECATED....
136 inline RequestHandler::RequestHandler (const function<void (Message*, const Sequence<String>&, bool*)>& f)
137 : RequestHandler{[f] (Message& m, const Sequence<String>& a, bool& h) { f (&m, a, &h); }}
138 {
139 }
140 inline RequestHandler::RequestHandler (const function<void (Message*, const Sequence<String>&)>& f)
141 : RequestHandler{[f] (Message& m, const Sequence<String>& matches, bool& completed) {
142 f (&m, matches);
143 completed = true;
144 }}
145 {
146 }
147 inline RequestHandler::RequestHandler (const function<void (Message*)>& f)
148 : RequestHandler{[f] (Message& m, const Sequence<String>&, bool& completed) {
149 f (&m);
150 completed = true;
151 }}
152 {
153 }
154 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*)>>>*>
155 RequestHandler::RequestHandler (_Fx _Func)
156 : RequestHandler{[_Func] (Message& m, const Sequence<String>&, bool& completed) {
157 _Func (&m);
158 completed = true;
159 }}
160 {
161 }
162 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*, const Sequence<String>&)>>>*>
163 RequestHandler::RequestHandler (_Fx _Func, int*)
164 : RequestHandler{[_Func] (Message& m, const Sequence<String>& args, bool& completed) {
165 _Func (&m, args);
166 completed = true;
167 }}
168 {
169 }
170 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*, const String& arg0)>>>*>
171 RequestHandler::RequestHandler (_Fx _Func, short*)
172 : RequestHandler{[_Func] (Message& msg, const Sequence<String>& matches) {
173 Require (matches.length () >= 1);
174 _Func (&msg, matches[0]);
175 }}
176 {
177 }
178 template <typename _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Message*, const String& arg0, const String& arg1)>>>*>
179 RequestHandler::RequestHandler (_Fx _Func, char*)
180 : RequestHandler{[_Func] (Message& msg, const Sequence<String>& matches) {
181 Require (matches.length () >= 2);
182 _Func (&msg, matches[0], matches[1]);
183 }}
184 {
185 }
186 template <class _Fx, enable_if_t<is_convertible_v<_Fx, function<void (Request*, Response*)>>>*>
187 RequestHandler::RequestHandler (_Fx _Func, void*)
188 : RequestHandler{[_Func] (Message& message) { _Func (&message.rwRequest (), &message.rwResponse ()); }}
189 {
190 }
191
192}
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 Sequence.h:187
Stroika::Frameworks::WebServer::RequestHandler::RequestHandler
RequestHandler(HANDLER_FUNCTION &&messageHandler)
Definition RequestHandler.inl:60