Improve external HTTP method integration

Author: willmmiles

src/AsyncJson.cpp

@@ -124,7 +124,7 @@ AsyncCallbackJsonWebHandler::AsyncCallbackJsonWebHandler(AsyncURIMatcher uri, Ar
 #endif
 
 bool AsyncCallbackJsonWebHandler::canHandle(AsyncWebServerRequest *request) const {
-  if (!_onRequest || !request->isHTTP() || !asyncsrv::methodMatches(_method, request->method())) {
+  if (!_onRequest || !request->isHTTP() || !_method.matches(request->method())) {
     return false;
   }
 

src/ESPAsyncWebServer.h

@@ -66,16 +66,9 @@
 #define ASYNCWEBSERVER_WIFI_SUPPORTED 0
 #endif
 
-// HTTP_ANY is commonly defined as a macro in Arduino core HTTP client libraries (e.g., ESP8266 HTTPClient.h).
-// Macros are expanded by the preprocessor before C++ namespace resolution, so even a namespace-qualified
-// reference like AsyncWebRequestMethod::HTTP_ANY would be incorrectly expanded to AsyncWebRequestMethod::0.
-// In these cases, other HTTP_METHOD symbols will likely also become ambiguous if put in the global namespace.
-// To avoid these conflicts, AsyncWebRequestMethod::HTTP_ANY will only be provided if no conflicting definition
-// is present; and we will disable putting our definitions in the global namespace.
-// If the user explicitly defined ASYNCWEBSERVER_NO_GLOBAL_HTTP_METHODS, we assume they are using safely
-// namespaced references and AsyncWebServerMethod::HTTP_ALL.
-#if defined(HTTP_ANY) && !defined(ASYNCWEBSERVER_NO_GLOBAL_HTTP_METHODS)
-#warning HTTP_ANY definition collision detected - AsyncWebServer HTTP_ methods will not be defined in the global namespace.  Make sure to use AsyncWebRequestMethod::HTTP_ALL instead, and define ASYNCWEBSERVER_NO_GLOBAL_HTTP_METHODS to disable this warning.
+// Enable integration with other HTTP libraries
+#if defined(HTTP_ANY) || defined(http_parser_h)
+#define ASYNCWEBSERVER_HTTP_METHOD_INTEGRATION
 #define ASYNCWEBSERVER_NO_GLOBAL_HTTP_METHODS
 #endif
 
@@ -150,13 +143,80 @@ enum AsyncWebRequestMethodType {
 
   HTTP_INVALID = 1 << 31  // Sentinel
 };
+
 };  // namespace AsyncWebRequestMethod
 
 typedef AsyncWebRequestMethod::AsyncWebRequestMethodType WebRequestMethod;
-typedef uint32_t WebRequestMethodComposite;
+class WebRequestMethodComposite {
+  uint32_t mask;
+
+private:
+  constexpr WebRequestMethodComposite(uint32_t m) : mask(m){};
+
+public:
+  // Constructor: allows implicit conversion from WebRequestMethod
+  constexpr WebRequestMethodComposite(WebRequestMethod m) : mask(static_cast<uint32_t>(m)){};
+
+  // Combine composites
+  constexpr inline WebRequestMethodComposite operator|(WebRequestMethodComposite r) {
+    return mask | r.mask;
+  };
+
+  // Check for a match
+  constexpr inline bool matches(WebRequestMethod m) const {
+    return mask & static_cast<uint32_t>(m);
+  };
+
+  constexpr inline bool operator&(WebRequestMethod m) const {
+    return matches(m);
+  }
+
+  // Super cool feature: integration with platform `http_method` enum
+#ifdef ASYNCWEBSERVER_HTTP_METHOD_INTEGRATION
+
+// Conversion function for integration with external libraries.
+// Horrible ternary implementation for C++11 compatibility.
+#define MAP_EXTERNAL_TERNARY(x) (t == http_method::x) ? static_cast<uint32_t>(WebRequestMethod::x)
+  constexpr static inline uint32_t map_http_method(http_method t) {
+    return MAP_EXTERNAL_TERNARY(HTTP_DELETE)
+      : MAP_EXTERNAL_TERNARY(HTTP_GET)
+      : MAP_EXTERNAL_TERNARY(HTTP_HEAD)
+      : MAP_EXTERNAL_TERNARY(HTTP_POST)
+      : MAP_EXTERNAL_TERNARY(HTTP_PUT)
+      : MAP_EXTERNAL_TERNARY(HTTP_CONNECT)
+      : MAP_EXTERNAL_TERNARY(HTTP_OPTIONS)
+      : MAP_EXTERNAL_TERNARY(HTTP_TRACE)
+      : MAP_EXTERNAL_TERNARY(HTTP_COPY)
+      : MAP_EXTERNAL_TERNARY(HTTP_LOCK)
+      : MAP_EXTERNAL_TERNARY(HTTP_MKCOL)
+      : MAP_EXTERNAL_TERNARY(HTTP_MOVE)
+      : MAP_EXTERNAL_TERNARY(HTTP_PROPFIND)
+      : MAP_EXTERNAL_TERNARY(HTTP_PROPPATCH)
+      : MAP_EXTERNAL_TERNARY(HTTP_SEARCH)
+      : MAP_EXTERNAL_TERNARY(HTTP_UNLOCK)
+      : MAP_EXTERNAL_TERNARY(HTTP_BIND)
+      : MAP_EXTERNAL_TERNARY(HTTP_REBIND)
+      : MAP_EXTERNAL_TERNARY(HTTP_UNBIND)
+      : MAP_EXTERNAL_TERNARY(HTTP_ACL)
+      : MAP_EXTERNAL_TERNARY(HTTP_PATCH)
+      : MAP_EXTERNAL_TERNARY(HTTP_PURGE)
+      : MAP_EXTERNAL_TERNARY(HTTP_LINK)
+      : MAP_EXTERNAL_TERNARY(HTTP_UNLINK)
+      : (t == HTTP_ANY) ? static_cast<uint32_t>(WebRequestMethod::HTTP_INVALID) - 1 : static_cast<uint32_t>(WebRequestMethod::HTTP_INVALID);
+  }
+#undef MAP_EXTERNAL_TERNARY
+
+  constexpr WebRequestMethodComposite(http_method m) : mask(map_http_method(m)){};
+#endif
+};  // WebRequestMethodComposite
+
+// Operator| for WebRequestMethod: combine to a WebRequestMethodComposite
+constexpr inline WebRequestMethodComposite operator|(WebRequestMethod l, WebRequestMethod r) {
+  return static_cast<WebRequestMethodComposite>(l) | r;
+};
 
 namespace AsyncWebRequestMethod {
-constexpr WebRequestMethodComposite HTTP_ALL = static_cast<WebRequestMethodComposite>(HTTP_INVALID) - 1;
+constexpr WebRequestMethodComposite HTTP_ALL = static_cast<WebRequestMethod>(static_cast<uint32_t>(HTTP_INVALID) - 1);
 
 // We used to use HTTP_ANY but some libraries squat on this name with a macro.  Transition to HTTP_ALL instead.
 #ifndef HTTP_ANY
@@ -165,24 +225,11 @@ __attribute__((deprecated("HTTP_ANY is used as a macro by other libraries - use
 #endif
 }  // namespace AsyncWebRequestMethod
 
-// Type-safe helper functions for composite methods
-constexpr inline WebRequestMethodComposite operator|(WebRequestMethodComposite l, WebRequestMethod r) {
-  return l | static_cast<WebRequestMethodComposite>(r);
-};
-constexpr inline WebRequestMethodComposite operator|(WebRequestMethod l, WebRequestMethod r) {
-  return static_cast<WebRequestMethodComposite>(l) | r;
-};
-
-namespace asyncsrv {
-// utility method to check if a WebRequestMethod matches a WebRequestMethodComposite
-constexpr inline bool methodMatches(WebRequestMethodComposite c, WebRequestMethod m) {
-  return c & static_cast<WebRequestMethodComposite>(m);
-};
-
 // WebRequestMethod string conversion functions
+namespace asyncsrv {
 WebRequestMethod stringToMethod(const String &);
 const char *methodToString(WebRequestMethod);
-} // namespace asyncsrv
+}  // namespace asyncsrv
 
 #if !defined(ASYNCWEBSERVER_NO_GLOBAL_HTTP_METHODS)
 // Import the method enum values to the global namespace

src/WebHandlers.cpp

@@ -300,7 +300,7 @@ void AsyncCallbackWebHandler::setUri(AsyncURIMatcher uri) {
 }
 
 bool AsyncCallbackWebHandler::canHandle(AsyncWebServerRequest *request) const {
-  if (!_onRequest || !request->isHTTP() || !asyncsrv::methodMatches(_method, request->method())) {
+  if (!_onRequest || !request->isHTTP() || !_method.matches(request->method())) {
     return false;
   }
   return _uri.matches(request);