_toFlags() and _fromFlags() to isolate the bitshift magic

Author: mathieucarbou

src/ESPAsyncWebServer.h

@@ -788,7 +788,7 @@ class AsyncURIMatcher {
   }
 
   AsyncURIMatcher(AsyncURIMatcher &&c) : _value(std::move(c._value)), _flags(c._flags) {
-    c._flags = intptr_t(Type::None);
+    c._flags = _toFlags(Type::None, None);
   }
 
   ~AsyncURIMatcher() {
@@ -824,7 +824,7 @@ class AsyncURIMatcher {
     _flags = r._flags;
     if (r._isRegex()) {
       // We have adopted it
-      r._flags = intptr_t(Type::None);
+      r._flags = _toFlags(Type::None, None);
     }
     return *this;
   }
@@ -854,9 +854,9 @@ class AsyncURIMatcher {
 #endif
 
     // extract matcher type from _flags
-    const intptr_t flags = _flags >> 1;                   // shift off disambiguation bit;
-    const Type type = static_cast<Type>(flags & 0xFFFF);  // Type is lower 16 bits
-    const uint16_t modifiers = flags >> 16;               // Modifiers are upper 16 bits
+    Type type;
+    uint16_t modifiers;
+    _fromFlags(_flags, type, modifiers);
 
     // apply modifiers
     String path = request->url();
@@ -1007,7 +1007,6 @@ class AsyncURIMatcher {
   }
 #endif
 
-  // Core private constructor
   AsyncURIMatcher(String uri, Type type, uint16_t modifiers) : _value(std::move(uri)) {
 #ifdef ASYNCWEBSERVER_REGEX
     if ((type == Type::Regex) || ((type == Type::Auto) && _value.startsWith("^") && _value.endsWith("$"))) {
@@ -1037,13 +1036,23 @@ class AsyncURIMatcher {
         type = Type::BackwardCompatible;
       }
     }
-    _flags = uint32_t(modifiers) << 16 | uint16_t(type);
+    _flags = _toFlags(type, modifiers);
+  }
+
+  static intptr_t _toFlags(Type type, uint16_t modifiers) {
+    intptr_t f = uint32_t(modifiers) << 16 | uint16_t(type);
     // Use lsb to disambiguate from regex pointer in the case where someone has regex activated but uses a non-regex type.
     // We always do this shift, even if regex is not enabled, to keep the layout identical and also catch programmatic errors earlier.
     // For example a mistake is to set a modifier flag to (1 << 15), which is the msb of the uint16_t.
     // This msb is discarded during this shift operation.
     // So pay attention to not have more than 15 modifier flags.
-    _flags = (_flags << 1) + 1;
+    return (f << 1) + 1;
+  }
+
+  static void _fromFlags(intptr_t in_flags, Type &out_type, uint16_t &out_modifiers) {
+    in_flags >>= 1;                                   // shift off disambiguation bit;
+    out_type = static_cast<Type>(in_flags & 0xFFFF);  // Type is lower 16 bits
+    out_modifiers = in_flags >> 16;                   // Modifiers are upper 16 bits
   }
 };