adapter/darwin: simplify sync routines

Author: Will

devel/include/detail/wtr/watcher/adapter/darwin/watch.hpp

@@ -7,6 +7,7 @@
 #include <CoreServices/CoreServices.h>
 #include <dispatch/dispatch.h>
 #include <filesystem>
+#include <mutex>
 #include <string>
 #include <unordered_set>
 
@@ -68,7 +69,7 @@ struct ContextData {
   ::wtr::watcher::event::callback const& callback{};
   pathset* seen_created_paths{nullptr};
   fspath* last_rename_path{nullptr};
-  Mutex* in_use{nullptr};
+  std::mutex* mtx{nullptr};
 };
 
 /*  We make a path from a C string...
@@ -244,13 +245,13 @@ inline auto event_recv(
               && maybe_ctx; /*  Once in a blue moon, this doesn't exist */
   if (! data_ok) return;
   auto ctx = *static_cast<ContextData*>(maybe_ctx);
-  auto synced = ctx.in_use->try_sync();
-  if (! synced) return;
+  if (! ctx.mtx->try_lock()) return;
   for (unsigned long i = 0; i < count; i++) {
     auto path = path_from_event_at(paths, i);
     auto flag = flags[i];
     event_recv_one(ctx, path, flag);
   }
+  ctx.mtx->unlock();
 }
 
 static_assert(event_recv == FSEventStreamCallback{event_recv});
@@ -381,11 +382,11 @@ inline auto wait(semabin const& sb)
     produces a warning. Releasing seems safer than not, so
     we'll do that.
 */
-inline auto close_event_stream(FSEventStreamRef stream, ContextData& ctx)
-  -> bool
+inline auto
+close_event_stream(FSEventStreamRef stream, ContextData& ctx) -> bool
 {
   if (! stream) return false;
-  auto _ = ctx.in_use->eventually_sync();
+  auto _ = std::scoped_lock{*ctx.mtx};
   FSEventStreamFlushSync(stream);
   FSEventStreamStop(stream);
   FSEventStreamInvalidate(stream);
@@ -413,8 +414,8 @@ inline auto watch(
   static auto queue = dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0);
   auto seen_created_paths = ContextData::pathset{};
   auto last_rename_path = ContextData::fspath{};
-  auto in_use = Mutex{};
-  auto ctx = ContextData{cb, &seen_created_paths, &last_rename_path, &in_use};
+  auto mtx = std::mutex{};
+  auto ctx = ContextData{cb, &seen_created_paths, &last_rename_path, &mtx};
 
   auto fsevs = open_event_stream(path, queue, &ctx);
 

devel/include/detail/wtr/watcher/adapter/linux/fanotify/watch.hpp

@@ -141,8 +141,8 @@ inline auto make_sysres = [](
     character string to the event's directory entry
     after the file handle to the directory.
     Confusing, right? */
-inline auto pathof(fanotify_event_metadata const* const mtd, int* ec)
-  -> std::string
+inline auto
+pathof(fanotify_event_metadata const* const mtd, int* ec) -> std::string
 {
   constexpr size_t path_ulim = PATH_MAX - sizeof('\0');
   auto dir_info = (fanotify_event_info_fid*)(mtd + 1);
@@ -213,9 +213,8 @@ parse_ev(fanotify_event_metadata const* const m, size_t read_len, int* ec)
                                  : ev_et::other;
   auto isfromto = [et](unsigned a, unsigned b) -> bool
   { return et == ev_et::rename && a & FAN_MOVED_FROM && b & FAN_MOVED_TO; };
-  auto one = [&](auto* m) -> Parsed {
-    return {ev(pathof(m, ec), et, pt), n, m->event_len};
-  };
+  auto one = [&](auto* m) -> Parsed
+  { return {ev(pathof(m, ec), et, pt), n, m->event_len}; };
   auto assoc = [&](auto* m, auto* n) -> Parsed
   {
     auto nn = peek(n, read_len);

devel/include/detail/wtr/watcher/adapter/linux/inotify/watch.hpp

@@ -164,9 +164,9 @@ inline auto make_sysres = [](
   };
 };
 
-inline auto
-peek(inotify_event const* const in_ev, inotify_event const* const ev_tail)
-  -> inotify_event*
+inline auto peek(
+  inotify_event const* const in_ev,
+  inotify_event const* const ev_tail) -> inotify_event*
 {
   auto len_to_next = sizeof(inotify_event) + (in_ev ? in_ev->len : 0);
   auto next = (inotify_event*)((char*)in_ev + len_to_next);
@@ -198,12 +198,10 @@ inline auto parse_ev(
   { return b && b->cookie && b->cookie == a->cookie && et == ev_et::rename; };
   auto isfromto = [](auto* a, auto* b) -> bool
   { return (a->mask & IN_MOVED_FROM) && (b->mask & IN_MOVED_TO); };
-  auto one = [&](auto* a, auto* next) -> parsed {
-    return {ev(pathof(a), et, pt), next};
-  };
-  auto assoc = [&](auto* a, auto* b) -> parsed {
-    return {ev(ev(pathof(a), et, pt), ev(pathof(b), et, pt)), peek(b, tail)};
-  };
+  auto one = [&](auto* a, auto* next) -> parsed
+  { return {ev(pathof(a), et, pt), next}; };
+  auto assoc = [&](auto* a, auto* b) -> parsed
+  { return {ev(ev(pathof(a), et, pt), ev(pathof(b), et, pt)), peek(b, tail)}; };
   auto next = peek(in, tail);
 
   return ! isassoc(in, next) ? one(in, next)

devel/include/test_watcher/event.hpp

@@ -28,9 +28,8 @@ template<class T>
 inline auto to(::wtr::watcher::event_without_time const& from) noexcept -> T;
 
 template<>
-inline auto
-to<std::string>(::wtr::watcher::event_without_time const& from) noexcept
-  -> std::string
+inline auto to<std::string>(
+  ::wtr::watcher::event_without_time const& from) noexcept -> std::string
 {
   using wtr::to, std::string;
   auto&& fields = "\n  path_name:    " + to<string>(from.path_name)
@@ -43,9 +42,8 @@ to<std::string>(::wtr::watcher::event_without_time const& from) noexcept
 
 template<>
 struct std::hash<wtr::watcher::event_without_time> {
-  inline auto
-  operator()(wtr::watcher::event_without_time const& ev) const noexcept
-    -> std::size_t
+  inline auto operator()(
+    wtr::watcher::event_without_time const& ev) const noexcept -> std::size_t
   {
     return std::hash<decltype(ev.path_name.string())>{}(ev.path_name.string())
 #ifdef _WIN32
@@ -141,20 +139,20 @@ check_event_lists_eq(auto const& event_sent_list, auto const& event_recv_list)
     if (event_sent_list[i].path_type != wtr::event::path_type::watcher) {
       if (event_sent_list[i].path_name != event_recv_list[i].path_name)
         std::cerr << "Bad .path_name field... (" << event_sent_list[i].path_name
-                  << " vs " << event_recv_list[i].path_name << "):"
-                  << "\n Sent:\n " << event_sent_list[i] << "\n Received:\n "
-                  << event_recv_list[i] << "\n";
+                  << " vs " << event_recv_list[i].path_name
+                  << "):" << "\n Sent:\n " << event_sent_list[i]
+                  << "\n Received:\n " << event_recv_list[i] << "\n";
       if (event_sent_list[i].effect_type != event_recv_list[i].effect_type)
         std::cerr << "Bad .effect_type field... ("
                   << event_sent_list[i].effect_type << " vs "
-                  << event_recv_list[i].effect_type << "):"
-                  << "\n Sent:\n " << event_sent_list[i] << "\n Received:\n "
+                  << event_recv_list[i].effect_type << "):" << "\n Sent:\n "
+                  << event_sent_list[i] << "\n Received:\n "
                   << event_recv_list[i] << "\n";
       if (event_sent_list[i].path_type != event_recv_list[i].path_type)
         std::cerr << "Bad .path_type field... (" << event_sent_list[i].path_type
-                  << " vs " << event_recv_list[i].path_type << "):"
-                  << "\n Sent:\n " << event_sent_list[i] << "\n Received:\n "
-                  << event_recv_list[i] << "\n";
+                  << " vs " << event_recv_list[i].path_type
+                  << "):" << "\n Sent:\n " << event_sent_list[i]
+                  << "\n Received:\n " << event_recv_list[i] << "\n";
       CHECK(event_sent_list[i].path_name == event_recv_list[i].path_name);
       CHECK(event_sent_list[i].effect_type == event_recv_list[i].effect_type);
       CHECK(event_sent_list[i].path_type == event_recv_list[i].path_type);

devel/include/wtr/watcher-/watch.hpp

@@ -61,30 +61,35 @@ class watch {
     std::filesystem::path const& path,
     event::callback const& callback) noexcept
       : watching{std::async(
-        std::launch::async,
-        [this, path, callback]
-        {
-          using ::detail::wtr::watcher::adapter::watch;
-
-          auto ec = std::error_code{};
-          auto abs_path = std::filesystem::absolute(path, ec);
-          auto pre_ok = ! ec && std::filesystem::is_directory(abs_path, ec)
-                     && ! ec && this->is_living.state() == sb::state::pending;
-
-          auto live_msg =
-            (pre_ok ? "s/self/live@" : "e/self/live@") + abs_path.string();
-          callback(
-            {live_msg, event::effect_type::create, event::path_type::watcher});
-
-          auto post_ok = ! pre_ok || watch(abs_path, callback, this->is_living);
-
-          auto die_msg =
-            (post_ok ? "s/self/die@" : "e/self/die@") + abs_path.string();
-          callback(
-            {die_msg, event::effect_type::destroy, event::path_type::watcher});
-
-          return pre_ok && post_ok;
-        })}
+          std::launch::async,
+          [this, path, callback]
+          {
+            using ::detail::wtr::watcher::adapter::watch;
+
+            auto ec = std::error_code{};
+            auto abs_path = std::filesystem::absolute(path, ec);
+            auto pre_ok = ! ec && std::filesystem::is_directory(abs_path, ec)
+                       && ! ec && this->is_living.state() == sb::state::pending;
+
+            auto live_msg =
+              (pre_ok ? "s/self/live@" : "e/self/live@") + abs_path.string();
+            callback(
+              {live_msg,
+               event::effect_type::create,
+               event::path_type::watcher});
+
+            auto post_ok =
+              ! pre_ok || watch(abs_path, callback, this->is_living);
+
+            auto die_msg =
+              (post_ok ? "s/self/die@" : "e/self/die@") + abs_path.string();
+            callback(
+              {die_msg,
+               event::effect_type::destroy,
+               event::path_type::watcher});
+
+            return pre_ok && post_ok;
+          })}
   {}
 
   inline auto close() noexcept -> bool

devel/include/wtr/watcher.hpp

@@ -6,7 +6,6 @@
 // clang-format off
 #include "wtr/watcher-/event.hpp"
 #include "detail/wtr/watcher/semabin.hpp"
-#include "detail/wtr/watcher/synchronized.hpp"
 #include "detail/wtr/watcher/adapter/darwin/watch.hpp"
 #include "detail/wtr/watcher/adapter/linux/sysres.hpp"
 #include "detail/wtr/watcher/adapter/linux/fanotify/watch.hpp"