oak: Replace Boost shared_mutex, filesystem::path with std classes

This means we no longer need Boost for this library at all.

Author: cassava

oak/CMakeLists.txt

@@ -11,7 +11,6 @@ set(alias cloe::oak)
 
 find_package(cloe-runtime REQUIRED)
 find_package(oatpp REQUIRED)
-find_package(Boost COMPONENTS headers REQUIRED)
 
 file(GLOB ${target}_PUBLIC_HEADERS "include/**/*.hpp")
 add_library(${target}
@@ -41,7 +40,7 @@ target_link_libraries(${target}
   PUBLIC
     cloe::runtime
     oatpp::oatpp
-    Boost::headers
+    stdc++fs
 )
 
 # Testing ------------------------------------------------------------
@@ -66,7 +65,6 @@ if(BUILD_TESTING)
     target_link_libraries(test-oak
         GTest::gtest
         GTest::gtest_main
-        Boost::boost
         ${target}
     )
     gtest_add_tests(TARGET test-oak)

oak/conanfile.py

@@ -68,7 +68,6 @@ def package(self):
         cm.install()
 
     def package_id(self):
-        self.info.requires["boost"].full_package_mode()
         del self.info.options.pedantic
 
     def package_info(self):
@@ -77,6 +76,13 @@ def package_info(self):
         self.cpp_info.set_property("cmake_target_name", "cloe::oak")
         self.cpp_info.set_property("pkg_config_name", "cloe-oak")
 
+        # Linking to libstdc++fs is required on GCC < 9.
+        # (GCC compilers with version < 7 have no std::filesystem support.)
+        # No consideration has been made yet for other compilers,
+        # please add them here as necessary.
+        if self.settings.get_safe("compiler") == "gcc" and self.settings.get_safe("compiler.version") in ["7", "8"]:
+            self.cpp_info.system_libs = ["stdc++fs"]
+
         # Make sure we can find the library, both in editable mode and in the
         # normal package mode:
         if not self.in_local_cache:

oak/include/oak/registrar.hpp

@@ -25,12 +25,10 @@
 #include <functional>
 #include <initializer_list>
 #include <map>
+#include <mutex>
 #include <string>
 #include <utility>
 
-#include <boost/thread/locks.hpp>         // for unique_lock
-#include <boost/thread/shared_mutex.hpp>  // for shared_mutex
-
 #include <cloe/handler.hpp>  // for Handler
 
 #include "oak/route_muxer.hpp"  // for Muxer
@@ -194,12 +192,12 @@ class LockedRegistrar : public StaticRegistrar {
    *
    * On destruction, the lock is released.
    */
-  boost::unique_lock<boost::shared_mutex> lock() {
-    return boost::unique_lock<boost::shared_mutex>(access_);
+  std::unique_lock<std::shared_mutex> lock() {
+    return std::unique_lock(access_);
   }
 
  private:
-  mutable boost::shared_mutex access_;
+  mutable std::shared_mutex access_;
 };
 
 /**
@@ -248,7 +246,7 @@ class BufferRegistrar : public StaticRegistrar {
   void refresh_route(const std::string& key);
 
  protected:
-  mutable boost::shared_mutex access_;
+  mutable std::shared_mutex access_;
   Muxer<Response> buffer_;
   Muxer<Handler> handlers_;
 };

oak/include/oak/route_muxer.hpp

@@ -23,17 +23,15 @@
 #pragma once
 
 #include <algorithm>
+#include <filesystem>
 #include <map>
+#include <mutex>
+#include <shared_mutex>
 #include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/filesystem/path.hpp>
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
-
 namespace oak {
 
 using Parameters = std::map<std::string, std::string>;
@@ -76,11 +74,11 @@ class Muxer {
    */
   static std::string normalize(const std::string& route) {
     std::string s = route.substr(0, route.find("?"));
-    boost::filesystem::path p(s);
+    std::filesystem::path p(s);
     if (!p.is_absolute()) {
       return "";
     }
-    s = p.normalize().string();
+    s = p.lexically_normal().string();
     s = s.substr(0, s.find_last_not_of("/. \n\t\r") + 1);
     if (s.empty()) {
       return "/";
@@ -109,15 +107,18 @@ class Muxer {
    */
   std::string resolve(const std::string& route) const {
     auto key = normalize(route);
-    boost::shared_lock<boost::shared_mutex> read_lock(access_);
+    std::shared_lock read_lock(access_);
     if (!backtrack_) {
       if (routes_.count(key)) {
         return key;
       }
       return "";
     } else {
-      boost::filesystem::path p(key);
+      std::filesystem::path p(key);
       while (!routes_.count(p.string())) {
+        if (p.string() == "/") {
+          return "";
+        }
         p = p.parent_path();
       }
       return p.string();
@@ -128,7 +129,7 @@ class Muxer {
    * Set the backtracking behavior.
    */
   void set_backtrack(bool enabled) {
-    boost::unique_lock<boost::shared_mutex> write_lock(access_);
+    std::unique_lock write_lock(access_);
     backtrack_ = enabled;
   }
 
@@ -139,7 +140,7 @@ class Muxer {
 
   std::vector<std::string> routes() const {
     std::vector<std::string> vs;
-    boost::shared_lock<boost::shared_mutex> read_lock(access_);
+    std::shared_lock read_lock(access_);
     for (const auto& kv : routes_) {
       if (kv.first.empty()) {
         continue;
@@ -151,13 +152,13 @@ class Muxer {
 
   bool has(const std::string& route) const {
     auto key = normalize(route);
-    boost::shared_lock<boost::shared_mutex> read_lock(access_);
+    std::shared_lock read_lock(access_);
     return routes_.count(key) != 0;
   }
 
   void add(const std::string& route, T val) {
     auto key = normalize(route);
-    boost::unique_lock<boost::shared_mutex> write_lock(access_);
+    std::unique_lock write_lock(access_);
     if (routes_.count(key)) {
       throw std::runtime_error("route already exists");
     }
@@ -166,7 +167,7 @@ class Muxer {
 
   void set(const std::string& route, T val) {
     auto key = normalize(route);
-    boost::unique_lock<boost::shared_mutex> write_lock(access_);
+    std::unique_lock write_lock(access_);
     routes_[key] = val;
   }
 
@@ -179,18 +180,18 @@ class Muxer {
   std::pair<T, Parameters> get(const std::string& route) const {
     auto key = resolve(route);
     Parameters p{};
-    boost::shared_lock<boost::shared_mutex> read_lock(access_);
+    std::shared_lock read_lock(access_);
     return std::make_pair(routes_.at(key), p);
   }
 
   void set_unsafe(const std::string& key, T val) {
-    boost::unique_lock<boost::shared_mutex> write_lock(access_);
+    std::unique_lock write_lock(access_);
     routes_[key] = val;
   }
 
   std::pair<T, Parameters> get_unsafe(const std::string& key) const {
     Parameters p{};
-    boost::shared_lock<boost::shared_mutex> read_lock(access_);
+    std::shared_lock read_lock(access_);
     return std::make_pair(routes_.at(key), p);
   }
 
@@ -200,7 +201,7 @@ class Muxer {
 
   // State:
   std::map<std::string, T> routes_;
-  mutable boost::shared_mutex access_;
+  mutable std::shared_mutex access_;
 };
 
 }  // namespace oak

oak/src/oak/registrar.cpp

@@ -23,6 +23,8 @@
 #include "oak/registrar.hpp"
 
 #include <map>
+#include <mutex>
+#include <shared_mutex>
 #include <memory>
 #include <string>
 
@@ -93,7 +95,7 @@ void LockedRegistrar::register_handler(const std::string& route, Handler h) {
   assert(route.size() != 0 && route[0] == '/');
   assert(proxy_ == nullptr);
   h = [this, h](const cloe::Request& q, Response& r) {
-    boost::shared_lock<boost::shared_mutex> read_lock(this->access_);
+    std::shared_lock read_lock(this->access_);
     h(q, r);
   };
 
@@ -117,13 +119,13 @@ void BufferRegistrar::register_handler(const std::string& route, Handler h) {
   server_->add_handler(key, [this, key](const cloe::Request&, Response& r) {
     // Technically it's not necessary to lock, but when we are updating the
     // buffers, we do not want any requests to get through.
-    boost::shared_lock<boost::shared_mutex> read_lock(this->access_);
+    std::shared_lock read_lock(this->access_);
     r = this->buffer_.get(key).first;
   });
 }
 
 void BufferRegistrar::refresh_buffer() {
-  boost::unique_lock<boost::shared_mutex> write_lock(access_);
+  std::unique_lock write_lock(access_);
   // We don't delete handlers, so there will never be routes
   // that are in handlers_ but not in buffer_.
   for (auto key : handlers_.routes()) {

oak/src/oak/route_muxer_test.cpp

@@ -43,7 +43,7 @@ TEST(oak_muxer, normalize) {
       {"/abc?", "/abc"},
       {"/abc/?opt=/next", "/abc"},
       {"C:", ""},
-      {"//", ""},
+      {"//", "/"},
       {"/..", "/"},
       {"/abc//.", "/abc"},
       {"/index.html", "/index.html"},