router: use vector instead of list

Author: mmd-osm

include/cgimap/router.hpp

@@ -12,10 +12,10 @@
 
 #include "cgimap/types.hpp"
 
-#include <string>
-#include <list>
-#include <stdexcept>
 #include <iostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
 
 #include <boost/fusion/container/generation/make_cons.hpp>
 #include <boost/fusion/include/make_cons.hpp>
@@ -43,7 +43,7 @@ using boost::fusion::as_list;
 namespace result_of = boost::fusion::result_of;
 
 // iterates over the split up parts of the item being matched.
-using part_iterator = std::list<std::string>::const_iterator;
+using part_iterator = std::vector<std::string>::const_iterator;
 
 /**
  * thrown when a match error occurs, giving some information about the

src/routes.cpp

@@ -52,16 +52,14 @@
 #include "cgimap/http.hpp"
 #include "cgimap/mime_types.hpp"
 
+#include <memory>
 #include <optional>
+#include <string>
+#include <vector>
 
 #include <boost/algorithm/string.hpp>
 #include <fmt/core.h>
 
-using std::list;
-using std::string;
-using std::pair;
-using std::unique_ptr;
-
 using boost::fusion::make_cons;
 using boost::fusion::invoke;
 
@@ -76,7 +74,7 @@ struct router {
   // interface through which all matches and constructions are performed.
   struct rule_base {
     virtual ~rule_base() = default;
-    virtual bool invoke_if(const list<string> &, request &, handler_ptr_t &) = 0;
+    virtual bool invoke_if(const std::vector<std::string> &, request &, handler_ptr_t &) = 0;
   };
 
   using rule_ptr = std::unique_ptr<rule_base>;
@@ -97,7 +95,7 @@ struct router {
 
     // try to match the expression. if it succeeds, call the provided function
     // with the provided params and the matched DSL arguments.
-    bool invoke_if(const list<string> &parts, 
+    bool invoke_if(const std::vector<std::string> &parts,
                    request &params,
                    handler_ptr_t &ptr) override {
       try {
@@ -164,7 +162,7 @@ struct router {
    * params.
    */
 
-  handler_ptr_t match(const list<string> &p, request &params) {
+  handler_ptr_t match(const std::vector<std::string> &p, request &params) {
 
     handler_ptr_t hptr;
 
@@ -223,9 +221,9 @@ struct router {
   }
 
 private:
-  list<rule_ptr> rules_get;
-  list<rule_ptr> rules_post;
-  list<rule_ptr> rules_put;
+  std::vector<rule_ptr> rules_get;
+  std::vector<rule_ptr> rules_post;
+  std::vector<rule_ptr> rules_put;
 };
 
 routes::routes()
@@ -290,36 +288,36 @@ namespace {
  * figures out the mime type from the path specification, e.g: a resource ending
  * in .xml should be application/xml, .json should be application/json, etc...
  */
-  pair<string, mime::type> resource_mime_type(const string &path) {
+  std::pair<std::string, mime::type> resource_mime_type(const std::string &path) {
 
 #if HAVE_YAJL
     {
       std::size_t json_found = path.rfind(".json");
 
-      if (json_found != string::npos && json_found == path.length() - 5) {
-	  return make_pair(path.substr(0, json_found), mime::type::application_json);
+      if (json_found != std::string::npos && json_found == path.length() - 5) {
+	  return std::make_pair(path.substr(0, json_found), mime::type::application_json);
       }
     }
 #endif
 
     {
       std::size_t xml_found = path.rfind(".xml");
 
-      if (xml_found != string::npos && xml_found == path.length() - 4) {
+      if (xml_found != std::string::npos && xml_found == path.length() - 4) {
 	  return make_pair(path.substr(0, xml_found), mime::type::application_xml);
       }
     }
 
     return make_pair(path, mime::type::unspecified_type);
 }
 
-handler_ptr_t route_resource(request &req, const string &path,
-                             const unique_ptr<router> &r) {
+handler_ptr_t route_resource(request &req, const std::string &path,
+                             const std::unique_ptr<router> &r) {
   // strip off the format-spec, if there is one
-  pair<string, mime::type> resource = resource_mime_type(path);
+  std::pair<std::string, mime::type> resource = resource_mime_type(path);
 
   // split the URL into bits to be matched.
-  list<string> path_components;
+  std::vector<std::string> path_components;
   al::split(path_components, resource.first, al::is_any_of("/"));
 
   handler_ptr_t hptr(r->match(path_components, req));
@@ -338,16 +336,16 @@ handler_ptr_t route_resource(request &req, const string &path,
 
 handler_ptr_t routes::operator()(request &req) const {
   // full path from request handler
-  string path = get_request_path(req);
+  auto path = get_request_path(req);
   handler_ptr_t hptr;
   // check the prefix
   if (path.compare(0, common_prefix.size(), common_prefix) == 0) {
-    hptr = route_resource(req, string(path, common_prefix.size()), r);
+    hptr = route_resource(req, std::string(path, common_prefix.size()), r);
 
 #ifdef ENABLE_API07
   } else if (path.compare(0, experimental_prefix.size(), experimental_prefix) ==
              0) {
-    hptr = route_resource(req, string(path, experimental_prefix.size()),
+    hptr = route_resource(req, std::string(path, experimental_prefix.size()),
                           r_experimental);
 #endif /* ENABLE_API07 */
   }