Removed std::optional in favor of operator bool()

Author: mathieucarbou

src/AsyncWebHeader.cpp

@@ -3,24 +3,24 @@
 
 #include <ESPAsyncWebServer.h>
 
-std::optional<AsyncWebHeader> AsyncWebHeader::parse(const char *data) {
+const AsyncWebHeader AsyncWebHeader::parse(const char *data) {
   // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers
   // In HTTP/1.X, a header is a case-insensitive name followed by a colon, then optional whitespace which will be ignored, and finally by its value
   if (!data) {
-    return std::nullopt;  // nullptr
+    return AsyncWebHeader();  // nullptr
   }
   if (data[0] == '\0') {
-    return std::nullopt;  // empty string
+    return AsyncWebHeader();  // empty string
   }
   if (strchr(data, '\n') || strchr(data, '\r')) {
-    return std::nullopt;  // Invalid header format
+    return AsyncWebHeader();  // Invalid header format
   }
   char *colon = strchr(data, ':');
   if (!colon) {
-    return std::nullopt;  // separator not found
+    return AsyncWebHeader();  // separator not found
   }
   if (colon == data) {
-    return std::nullopt;  // Header name cannot be empty
+    return AsyncWebHeader();  // Header name cannot be empty
   }
   char *startOfValue = colon + 1;  // Skip the colon
   // skip one optional whitespace after the colon

src/ESPAsyncWebServer.h

@@ -12,7 +12,6 @@
 #include <deque>
 #include <functional>
 #include <list>
-#include <optional>
 #include <unordered_map>
 #include <vector>
 
@@ -136,6 +135,7 @@ class AsyncWebHeader {
   String _value;
 
 public:
+  AsyncWebHeader() {}
   AsyncWebHeader(const AsyncWebHeader &) = default;
   AsyncWebHeader(AsyncWebHeader &&) = default;
   AsyncWebHeader(const char *name, const char *value) : _name(name), _value(value) {}
@@ -145,7 +145,7 @@ class AsyncWebHeader {
   [[deprecated("Use AsyncWebHeader::parse(data) instead")]]
 #endif
   AsyncWebHeader(const String &data)
-    : AsyncWebHeader(parse(data).value_or(AsyncWebHeader(emptyString, emptyString))){};
+    : AsyncWebHeader(parse(data)) {};
 
   AsyncWebHeader &operator=(const AsyncWebHeader &) = default;
 
@@ -158,10 +158,15 @@ class AsyncWebHeader {
 
   String toString() const;
 
-  static std::optional<AsyncWebHeader> parse(const String &data) {
+  // returns true if the header is valid
+  operator bool() const {
+    return _name.length();
+  }
+
+  static const AsyncWebHeader parse(const String &data) {
     return parse(data.c_str());
   }
-  static std::optional<AsyncWebHeader> parse(const char *data);
+  static const AsyncWebHeader parse(const char *data);
 };
 
 /*
@@ -306,8 +311,9 @@ class AsyncWebServerRequest {
   RequestedConnectionType requestedConnType() const {
     return _reqconntype;
   }
-  bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED)
-    const;
+  bool isExpectedRequestedConnType(
+    RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED
+  ) const;
   bool isWebSocketUpgrade() const {
     return _method == HTTP_GET && isExpectedRequestedConnType(RCT_WS);
   }
@@ -495,7 +501,8 @@ class AsyncWebServerRequest {
     return beginResponse(code, contentType.c_str(), content, len, callback);
   }
 #ifndef ESP8266
-  [[deprecated("Replaced by beginResponse(int code, const String& contentType, const char* content = asyncsrv::empty, AwsTemplateProcessor callback = nullptr)"
+  [[deprecated(
+    "Replaced by beginResponse(int code, const String& contentType, const char* content = asyncsrv::empty, AwsTemplateProcessor callback = nullptr)"
   )]]
 #endif
   AsyncWebServerResponse *beginResponse_P(int code, const String &contentType, PGM_P content, AwsTemplateProcessor callback = nullptr);

src/WebRequest.cpp

@@ -341,30 +341,28 @@ bool AsyncWebServerRequest::_parseReqHead() {
 }
 
 bool AsyncWebServerRequest::_parseReqHeader() {
-  std::optional<AsyncWebHeader> header = AsyncWebHeader::parse(_temp);
+  AsyncWebHeader header = AsyncWebHeader::parse(_temp);
   if (header) {
-    const String &name = header.value().name();
-    const String &value = header.value().value();
-    if (name.equalsIgnoreCase(T_Host)) {
-      _host = value;
-    } else if (name.equalsIgnoreCase(T_Content_Type)) {
-      _contentType = value.substring(0, value.indexOf(';'));
-      if (value.startsWith(T_MULTIPART_)) {
-        _boundary = value.substring(value.indexOf('=') + 1);
+    if (header.name().equalsIgnoreCase(T_Host)) {
+      _host = header.value();
+    } else if (header.name().equalsIgnoreCase(T_Content_Type)) {
+      _contentType = header.value().substring(0, header.value().indexOf(';'));
+      if (header.value().startsWith(T_MULTIPART_)) {
+        _boundary = header.value().substring(header.value().indexOf('=') + 1);
         _boundary.replace(String('"'), String());
         _isMultipart = true;
       }
-    } else if (name.equalsIgnoreCase(T_Content_Length)) {
-      _contentLength = atoi(value.c_str());
-    } else if (name.equalsIgnoreCase(T_EXPECT) && value.equalsIgnoreCase(T_100_CONTINUE)) {
+    } else if (header.name().equalsIgnoreCase(T_Content_Length)) {
+      _contentLength = atoi(header.value().c_str());
+    } else if (header.name().equalsIgnoreCase(T_EXPECT) && header.value().equalsIgnoreCase(T_100_CONTINUE)) {
       _expectingContinue = true;
-    } else if (name.equalsIgnoreCase(T_AUTH)) {
-      int space = value.indexOf(' ');
+    } else if (header.name().equalsIgnoreCase(T_AUTH)) {
+      int space = header.value().indexOf(' ');
       if (space == -1) {
-        _authorization = value;
+        _authorization = header.value();
         _authMethod = AsyncAuthType::AUTH_OTHER;
       } else {
-        String method = value.substring(0, space);
+        String method = header.value().substring(0, space);
         if (method.equalsIgnoreCase(T_BASIC)) {
           _authMethod = AsyncAuthType::AUTH_BASIC;
         } else if (method.equalsIgnoreCase(T_DIGEST)) {
@@ -374,13 +372,13 @@ bool AsyncWebServerRequest::_parseReqHeader() {
         } else {
           _authMethod = AsyncAuthType::AUTH_OTHER;
         }
-        _authorization = value.substring(space + 1);
+        _authorization = header.value().substring(space + 1);
       }
-    } else if (name.equalsIgnoreCase(T_UPGRADE) && value.equalsIgnoreCase(T_WS)) {
+    } else if (header.name().equalsIgnoreCase(T_UPGRADE) && header.value().equalsIgnoreCase(T_WS)) {
       // WebSocket request can be uniquely identified by header: [Upgrade: websocket]
       _reqconntype = RCT_WS;
-    } else if (name.equalsIgnoreCase(T_ACCEPT)) {
-      String lowcase(value);
+    } else if (header.name().equalsIgnoreCase(T_ACCEPT)) {
+      String lowcase(header.value());
       lowcase.toLowerCase();
 #ifndef ESP8266
       const char *substr = std::strstr(lowcase.c_str(), T_text_event_stream);
@@ -392,7 +390,7 @@ bool AsyncWebServerRequest::_parseReqHeader() {
         _reqconntype = RCT_EVENT;
       }
     }
-    _headers.emplace_back(std::move(header.value()));
+    _headers.emplace_back(std::move(header));
   }
 #if defined(TARGET_RP2040) || defined(TARGET_RP2350) || defined(PICO_RP2040) || defined(PICO_RP2350) || defined(LIBRETINY)
   // Ancient PRI core does not have String::clear() method 8-()