Allow removing std::function type middlewares.

Signed-off-by: pvogt09 <[email protected]>

Author: pvogt09

src/HTTPMiddlewareFunction.hpp

@@ -9,6 +9,7 @@
 
 namespace httpsserver {
   class HTTPRequest;
+  using HTTPSMiddlewareFunctionType = void(HTTPRequest * req, HTTPResponse * res, std::function<void()> next);
   /**
    * \brief A middleware function that can be registered at the server.
    *
@@ -21,8 +22,6 @@ namespace httpsserver {
    * handling in case of missing authentication. Don't forget to call next in case you want to access your
    * resources, though.
    */
-  typedef std::function<void(HTTPRequest * req, HTTPResponse * res, std::function<void()> next)> HTTPSMiddlewareFunction;
-
-  bool operator==(const HTTPSMiddlewareFunction& lhs, const HTTPSMiddlewareFunction& rhs);
+  typedef std::function<HTTPSMiddlewareFunctionType> HTTPSMiddlewareFunction;
 }
  #endif /* SRC_HTTPMIDDLEWAREFUNCTION_HPP_ */

src/ResourceResolver.cpp

@@ -2,6 +2,21 @@
 
 namespace httpsserver {
 
+ResourceResolver::HTTPSMiddlewareFunctionCallback::HTTPSMiddlewareFunctionCallback(const HTTPSMiddlewareFunction callback, const HTTPSMiddlewareFunction* callback_std_function, const HTTPSMiddlewareFunctionType* callback_raw_pointer) : _callback(callback), _callback_std_function(callback_std_function), _callback_raw_pointer(callback_raw_pointer) {
+};
+
+HTTPSMiddlewareFunction ResourceResolver::HTTPSMiddlewareFunctionCallback::getCallback() {
+  return _callback;
+};
+
+const HTTPSMiddlewareFunction* ResourceResolver::HTTPSMiddlewareFunctionCallback::getStdFunctionPointer() {
+  return _callback_std_function;
+};
+
+const HTTPSMiddlewareFunctionType* ResourceResolver::HTTPSMiddlewareFunctionCallback::getRawFunctionPointer() {
+  return _callback_raw_pointer;
+};
+
 ResourceResolver::ResourceResolver() {
   _nodes = new std::vector<HTTPNode *>();
   _defaultNode = NULL;
@@ -160,20 +175,68 @@ void ResourceResolver::resolveNode(const std::string &method, const std::string
   }
 }
 
-void ResourceResolver::addMiddleware(const HTTPSMiddlewareFunction mwFunction) {
+void ResourceResolver::updateMiddlewareList() {
+  _middleware.clear();
+  _middleware.reserve(_middleware_callback.size());
+  for (auto& callback : _middleware_callback) {
+    _middleware.push_back(callback.getCallback());
+  }
+}
+
+void ResourceResolver::addMiddleware(const HTTPSMiddlewareFunction &mwFunction) {
+  const HTTPSMiddlewareFunctionCallback callback{
+    mwFunction,
+    &mwFunction,
+    nullptr
+  };
   _middleware.push_back(mwFunction);
+  _middleware_callback.push_back(callback);
 }
 
 void ResourceResolver::addMiddleware(void (*mwFunction)(HTTPRequest * req, HTTPResponse * res, std::function<void()> next)) {
-  _middleware.push_back(HTTPSMiddlewareFunction(mwFunction));
+  auto mwFunction_callback = HTTPSMiddlewareFunction(mwFunction);
+  const HTTPSMiddlewareFunctionCallback callback{
+    mwFunction_callback,
+    &mwFunction_callback,
+    mwFunction
+  };
+  _middleware.push_back(mwFunction_callback);
+  _middleware_callback.push_back(callback);
 }
 
-void ResourceResolver::removeMiddleware(const HTTPSMiddlewareFunction mwFunction) {
-  _middleware.erase(std::remove(_middleware.begin(), _middleware.end(), mwFunction), _middleware.end());
+void ResourceResolver::removeMiddleware(const HTTPSMiddlewareFunction &mwFunction) {
+  bool found = false;
+  for (auto it = _middleware_callback.begin(); it != _middleware_callback.end();) {
+    auto element = *it;
+    const auto callback = element.getStdFunctionPointer();
+    const auto callback_supplied = &mwFunction;
+    if (callback != nullptr && callback == callback_supplied) {
+      it = _middleware_callback.erase(it);
+      found = true;
+    } else {
+      ++it;
+    }
+  }
+  if (found) {
+    updateMiddlewareList();
+  }
 }
 
 void ResourceResolver::removeMiddleware(void (*mwFunction)(HTTPRequest * req, HTTPResponse * res, std::function<void()> next)) {
-  _middleware.erase(std::remove(_middleware.begin(), _middleware.end(), mwFunction), _middleware.end());
+  bool found = false;
+  for (auto it = _middleware_callback.begin(); it != _middleware_callback.end();) {
+    auto element = *it;
+    auto callback = element.getRawFunctionPointer();
+    if (callback != nullptr && callback == mwFunction) {
+      it = _middleware_callback.erase(it);
+      found = true;
+    } else {
+      ++it;
+    }
+  }
+  if (found) {
+    updateMiddlewareList();
+  }
 }
 
 const std::vector<HTTPSMiddlewareFunction> ResourceResolver::getMiddleware() {

src/ResourceResolver.hpp

@@ -30,22 +30,36 @@ class ResourceResolver {
   void resolveNode(const std::string &method, const std::string &url, ResolvedResource &resolvedResource, HTTPNodeType nodeType);
 
   /** Add a middleware function to the end of the middleware function chain. See HTTPSMiddlewareFunction.hpp for details. */
-  void addMiddleware(const HTTPSMiddlewareFunction mwFunction);
+  void addMiddleware(const HTTPSMiddlewareFunction &mwFunction);
   void addMiddleware(void (*mwFunction)(HTTPRequest *req, HTTPResponse *res, std::function<void()> next));
   /** Remove a specific function from the middleware function chain. */
-  void removeMiddleware(const HTTPSMiddlewareFunction mwFunction);
+  void removeMiddleware(const HTTPSMiddlewareFunction &mwFunction);
   void removeMiddleware(void (*mwFunction)(HTTPRequest * req, HTTPResponse * res, std::function<void()> next));
   /** Get the current middleware chain with a resource function at the end */
   const std::vector<HTTPSMiddlewareFunction> getMiddleware();
 
 private:
+  class HTTPSMiddlewareFunctionCallback {
+    private:
+      HTTPSMiddlewareFunction _callback;
+      const HTTPSMiddlewareFunction* _callback_std_function;
+      const HTTPSMiddlewareFunctionType* _callback_raw_pointer;
+    public:
+      HTTPSMiddlewareFunctionCallback(HTTPSMiddlewareFunction callback, const HTTPSMiddlewareFunction* const callback_std_function, const HTTPSMiddlewareFunctionType* callback_raw_pointer);
+      HTTPSMiddlewareFunction getCallback();
+      const HTTPSMiddlewareFunction* getStdFunctionPointer();
+      const HTTPSMiddlewareFunctionType* getRawFunctionPointer();
+  };
 
   // This vector holds all nodes (with callbacks) that are registered
   std::vector<HTTPNode*> * _nodes;
   HTTPNode * _defaultNode;
 
   // Middleware functions, if any are registered. Will be called in order of the vector.
   std::vector<HTTPSMiddlewareFunction> _middleware;
+  std::vector<HTTPSMiddlewareFunctionCallback> _middleware_callback;
+
+  void updateMiddlewareList();
 };
 
 } /* namespace httpsserver */