Renaming

Author: mathieucarbou

src/ESPAsyncWebServer.h

@@ -732,8 +732,6 @@ class AsyncWebServerRequest {
 
 class AsyncURIMatcher {
 public:
-  // Modifier flags for AsyncURIMatcher behavior
-
   /**
    * @brief No special matching behavior (default)
    */
@@ -765,8 +763,8 @@ class AsyncURIMatcher {
 
   // public constructors
   AsyncURIMatcher() : _flags(All) {}
-  AsyncURIMatcher(String uri, uint16_t flags = None) : AsyncURIMatcher(std::move(uri), Auto, flags) {}
-  AsyncURIMatcher(const char *uri, uint16_t flags = None) : AsyncURIMatcher(String(uri), Auto, flags) {}
+  AsyncURIMatcher(String uri, uint16_t modifiers = None) : AsyncURIMatcher(std::move(uri), Auto, modifiers) {}
+  AsyncURIMatcher(const char *uri, uint16_t modifiers = None) : AsyncURIMatcher(String(uri), Auto, modifiers) {}
 
 #ifdef ASYNCWEBSERVER_REGEX
   AsyncURIMatcher(const AsyncURIMatcher &c) : _value(c._value), _flags(c._flags) {
@@ -890,36 +888,36 @@ class AsyncURIMatcher {
   /**
    * @brief Create an exact URI matcher
    * @param c The exact URI string to match (e.g., "/login", "/api/status")
-   * @param flags Optional modifier flags (CaseInsensitive, etc.)
+   * @param modifiers Optional modifiers (CaseInsensitive, etc.)
    * @return AsyncURIMatcher that matches only the exact URI
    *
    * Usage: server.on(AsyncURIMatcher::exact("/login"), handler);
    * Matches: "/login"
    * Doesn't match: "/login/", "/login-page"
    * Doesn't match: "/LOGIN" (unless CaseInsensitive flag used)
    */
-  static inline AsyncURIMatcher exact(String c, uint16_t flags = None) {
-    return AsyncURIMatcher{std::move(c), Exact, flags};
+  static inline AsyncURIMatcher exact(String c, uint16_t modifiers = None) {
+    return AsyncURIMatcher{std::move(c), Exact, modifiers};
   }
 
   /**
    * @brief Create a prefix URI matcher
    * @param c The URI prefix to match (e.g., "/api", "/static")
-   * @param flags Optional modifier flags (CaseInsensitive, etc.)
+   * @param modifiers Optional modifiers (CaseInsensitive, etc.)
    * @return AsyncURIMatcher that matches URIs starting with the prefix
    *
    * Usage: server.on(AsyncURIMatcher::prefix("/api"), handler);
    * Matches: "/api", "/api/users", "/api-v2", "/apitest"
    * Note: This is pure prefix matching - does NOT require folder separator
    */
-  static inline AsyncURIMatcher prefix(String c, uint16_t flags = None) {
-    return AsyncURIMatcher{std::move(c), Prefix, flags};
+  static inline AsyncURIMatcher prefix(String c, uint16_t modifiers = None) {
+    return AsyncURIMatcher{std::move(c), Prefix, modifiers};
   }
 
   /**
    * @brief Create a directory/folder URI matcher
    * @param c The directory path (trailing slash automatically added if missing)
-   * @param flags Optional modifier flags (CaseInsensitive, etc.)
+   * @param modifiers Optional modifiers (CaseInsensitive, etc.)
    * @return AsyncURIMatcher that matches URIs under the directory
    *
    * Usage: server.on(AsyncURIMatcher::dir("/admin"), handler);
@@ -928,21 +926,21 @@ class AsyncURIMatcher {
    *
    * The trailing slash is automatically added for convenience and efficiency.
    */
-  static inline AsyncURIMatcher dir(String c, uint16_t flags = None) {
+  static inline AsyncURIMatcher dir(String c, uint16_t modifiers = None) {
     // Pre-calculate folder for efficiency
     if (!c.length()) {
-      return AsyncURIMatcher{"/", Prefix, flags};
+      return AsyncURIMatcher{"/", Prefix, modifiers};
     }
     if (c[c.length() - 1] != '/') {
       c.concat('/');
     }
-    return AsyncURIMatcher{std::move(c), Prefix, flags};
+    return AsyncURIMatcher{std::move(c), Prefix, modifiers};
   }
 
   /**
    * @brief Create a file extension URI matcher
    * @param c The pattern with wildcard extension (e.g., "/images/\*.jpg", "/docs/\*.pdf")
-   * @param flags Optional modifier flags (CaseInsensitive, etc.)
+   * @param modifiers Optional modifiers (CaseInsensitive, etc.)
    * @return AsyncURIMatcher that matches files with specific extensions under a path
    *
    * Usage: server.on(AsyncURIMatcher::ext("/images/\*.jpg"), handler);
@@ -952,15 +950,15 @@ class AsyncURIMatcher {
    * Pattern format: "/path/\*.extension" where "*" is a literal wildcard placeholder.
    * The path before "/\*." must match exactly, and the URI must end with the extension.
    */
-  static inline AsyncURIMatcher ext(String c, uint16_t flags = None) {
-    return AsyncURIMatcher{std::move(c), Extension, flags};
+  static inline AsyncURIMatcher ext(String c, uint16_t modifiers = None) {
+    return AsyncURIMatcher{std::move(c), Extension, modifiers};
   }
 
 #ifdef ASYNCWEBSERVER_REGEX
   /**
    * @brief Create a regular expression URI matcher
    * @param c The regex pattern string (e.g., "^/user/([0-9]+)$", "^/blog/([0-9]{4})/([0-9]{2})$")
-   * @param flags Optional modifier flags (CaseInsensitive applies to regex compilation)
+   * @param modifiers Optional modifiers (CaseInsensitive applies to regex compilation)
    * @return AsyncURIMatcher that matches URIs using regex with capture groups
    *
    * Usage: server.on(AsyncURIMatcher::regex("^/user/([0-9]+)$"), handler);
@@ -971,19 +969,19 @@ class AsyncURIMatcher {
    * Requires ASYNCWEBSERVER_REGEX to be defined during compilation.
    * Performance note: Regex matching is slower than other match types.
    */
-  static inline AsyncURIMatcher regex(String c, uint16_t flags = None) {
-    return AsyncURIMatcher{std::move(c), Regex, flags};
+  static inline AsyncURIMatcher regex(String c, uint16_t modifiers = None) {
+    return AsyncURIMatcher{std::move(c), Regex, modifiers};
   }
 #endif
 
 private:
   // Matcher types
   enum Type : uint16_t {
-    // Meta flags - low bits
+    // Meta types - low bits
     Auto = (1 << 0),  // parse _uri at construct time and infer match type(s)
                       // (_uri may be transformed to remove wildcards)
 
-    All = (1 << 1),           // No flags set
+    All = (1 << 1),           // No type set
     Exact = (1 << 2),         // matches equivalent to regex: ^{_uri}$
     Prefix = (1 << 3),        // matches equivalent to regex: ^{_uri}.*
     PrefixFolder = (1 << 4),  // matches equivalent to regex: ^{_uri}/.*
@@ -1000,8 +998,8 @@ class AsyncURIMatcher {
   union {
     intptr_t _flags;
 #ifdef ASYNCWEBSERVER_REGEX
-    // Overlay the pattern pointer storage with the flags.  It is treated as a tagged pointer:
-    // if any of the LSBs are set, it stores flags, as a valid object must be aligned and so
+    // Overlay the pattern pointer storage with the type.  It is treated as a tagged pointer:
+    // if any of the LSBs are set, it stores type, as a valid object must be aligned and so
     // none of the LSBs can be set in a valid pointer.
     std::regex *pattern;
 #endif
@@ -1020,14 +1018,14 @@ class AsyncURIMatcher {
 #endif
 
   // Core private constructor
-  AsyncURIMatcher(String uri, Type type = Auto, uint16_t flags = None) : _value(std::move(uri)), _flags(uint32_t(flags) << 16 | type) {
+  AsyncURIMatcher(String uri, Type type = Auto, uint16_t modifiers = None) : _value(std::move(uri)), _flags(uint32_t(modifiers) << 16 | type) {
 #ifdef ASYNCWEBSERVER_REGEX
     if ((type & Regex) || ((type & Auto) && _value.startsWith("^") && _value.endsWith("$"))) {
-      pattern = new std::regex(_value.c_str(), (flags & CaseInsensitive) ? (std::regex::icase | std::regex::optimize) : (std::regex::optimize));
-      return;  // no additional processing - flags are overwritten
+      pattern = new std::regex(_value.c_str(), (modifiers & CaseInsensitive) ? (std::regex::icase | std::regex::optimize) : (std::regex::optimize));
+      return;  // no additional processing - modifiers are overwritten
     }
 #endif
-    if (flags & CaseInsensitive) {
+    if (modifiers & CaseInsensitive) {
       _value.toLowerCase();
     }
     if (type & Auto) {