implements pathArgs method in analogy to the args method

This allows to use UriRegex with optional capture groups and therefore varying number of path arguments.

Author: Andreas Horn

libraries/ESP8266WebServer/src/ESP8266WebServer-impl.h

@@ -588,6 +588,13 @@ const String& ESP8266WebServerTemplate<ServerType>::pathArg(unsigned int i) cons
   return emptyString;
 }
 
+template <typename ServerType>
+const int ESP8266WebServerTemplate<ServerType>::pathArgs() const {
+  if (_currentHandler != nullptr)
+    return _currentHandler->pathArgs();
+  return 0;
+}
+
 template <typename ServerType>
 const String& ESP8266WebServerTemplate<ServerType>::arg(const String& name) const {
   for (int i = 0; i < _currentArgCount + _currentArgsHavePlain; ++i) {

libraries/ESP8266WebServer/src/ESP8266WebServer.h

@@ -136,6 +136,7 @@ class ESP8266WebServerTemplate
   ServerType &getServer() { return _server; }
 
   const String& pathArg(unsigned int i) const;    // get request path argument by number
+  const int pathArgs() const;                     // get path arguments count
   const String& arg(const String& name) const;    // get request argument value by name
   const String& arg(int i) const;                 // get request argument value by number
   const String& argName(int i) const;             // get request argument name by number

libraries/ESP8266WebServer/src/Uri.h

@@ -19,7 +19,7 @@ class Uri {
             return new Uri(_uri);
         };
 
-        virtual bool canHandle(const String &requestUri, __attribute__((unused)) std::vector<String> &pathArgs) {
+        virtual bool canHandle(const String &requestUri, __attribute__((unused)) std::vector<String> &currentPathArgs) {
             return _uri == requestUri;
         }
 };

libraries/ESP8266WebServer/src/detail/RequestHandler.h

@@ -24,12 +24,15 @@ class RequestHandler {
     RequestHandler<ServerType>* _next = nullptr;
 
 protected:
-    std::vector<String> pathArgs;
+    std::vector<String> currentPathArgs;
 
 public:
     const String& pathArg(unsigned int i) { 
-        assert(i < pathArgs.size());
-        return pathArgs[i];
+        assert(i < currentPathArgs.size());
+        return currentPathArgs[i];
+    }
+    const int pathArgs() {
+        return currentPathArgs.size();
     }
 };
 

libraries/ESP8266WebServer/src/detail/RequestHandlersImpl.h

@@ -49,7 +49,7 @@ class FunctionRequestHandler : public RequestHandler<ServerType> {
         if (_method != HTTP_ANY && _method != requestMethod)
             return false;
 
-        return _uri->canHandle(requestUri, RequestHandler<ServerType>::pathArgs);
+        return _uri->canHandle(requestUri, RequestHandler<ServerType>::currentPathArgs);
     }
 
     bool canUpload(const String& requestUri) override  {

libraries/ESP8266WebServer/src/uri/UriBraces.h

@@ -13,11 +13,11 @@ class UriBraces : public Uri {
             return new UriBraces(_uri);
         };
 
-        bool canHandle(const String &requestUri, std::vector<String> &pathArgs) override final {
-            if (Uri::canHandle(requestUri, pathArgs))
+        bool canHandle(const String &requestUri, std::vector<String> &currentPathArgs) override final {
+            if (Uri::canHandle(requestUri, currentPathArgs))
                 return true;
 
-            pathArgs.clear();
+            currentPathArgs.clear();
 
             size_t uriLength = _uri.length();
             unsigned int requestUriIndex = 0;
@@ -33,16 +33,16 @@ class UriBraces : public Uri {
                 i += 2; // index of char after '}'
                 if (i >= uriLength) {
                     // there is no char after '}'
-                    pathArgs.push_back(requestUri.substring(requestUriIndex));
-                    return pathArgs.back().indexOf("/") == -1; // path argument may not contain a '/'
+                    currentPathArgs.push_back(requestUri.substring(requestUriIndex));
+                    return currentPathArgs.back().indexOf("/") == -1; // path argument may not contain a '/'
                 }
                 else
                 {
                     char charEnd = _uri[i];
                     int uriIndex = requestUri.indexOf(charEnd, requestUriIndex);
                     if (uriIndex < 0)
                         return false;
-                    pathArgs.push_back(requestUri.substring(requestUriIndex, uriIndex));
+                    currentPathArgs.push_back(requestUri.substring(requestUriIndex, uriIndex));
                     requestUriIndex = (unsigned int) uriIndex;
                 }
             }

libraries/ESP8266WebServer/src/uri/UriGlob.h

@@ -14,7 +14,7 @@ class UriGlob : public Uri {
             return new UriGlob(_uri);
         };
 
-        bool canHandle(const String &requestUri, __attribute__((unused)) std::vector<String> &pathArgs) override final {
+        bool canHandle(const String &requestUri, __attribute__((unused)) std::vector<String> &currentPathArgs) override final {
             return fnmatch(_uri.c_str(), requestUri.c_str(), 0) == 0;
         }
 };

libraries/ESP8266WebServer/src/uri/UriRegex.h

@@ -28,21 +28,21 @@ class UriRegex : public Uri {
             return new UriRegex(_uri);
         };
 
-        bool canHandle(const String &requestUri, std::vector<String> &pathArgs) override final {
-            if (Uri::canHandle(requestUri, pathArgs))
+        bool canHandle(const String &requestUri, std::vector<String> &currentPathArgs) override final {
+            if (Uri::canHandle(requestUri, currentPathArgs))
                 return true;
 
             regmatch_t groupArray[REGEX_MAX_GROUPS];
             if (regexec(&_regexCompiled, requestUri.c_str(), REGEX_MAX_GROUPS, groupArray, 0) == 0) {
                 // matches
-                pathArgs.clear();
+                currentPathArgs.clear();
 
                 unsigned int g = 1; 
                 for (; g < REGEX_MAX_GROUPS; g++) {
                     if (groupArray[g].rm_so == (long int)-1)
                         break;  // No more groups
 
-                    pathArgs.push_back(requestUri.substring(groupArray[g].rm_so, groupArray[g].rm_eo));
+                    currentPathArgs.push_back(requestUri.substring(groupArray[g].rm_so, groupArray[g].rm_eo));
                 }
 
                 return true;