Yet another Dasynq update

diff --git a/src/control.h b/src/control.h
index f76ee28531fc025bff0b49a6ffb07f027015ca20..a184039ffb3babea65c6f927487833c91ff41eee 100644 (file)
--- a/src/control.h
+++ b/src/control.h
@@ -47,7 +47,7 @@ extern int active_control_conns;
 class ServiceSet;
 class ServiceRecord;
 
-class ControlConnWatcher : public BidiFdWatcher<NullMutex>
+class ControlConnWatcher : public EventLoop_t::BidiFdWatcher
 {
     inline Rearm receiveEvent(EventLoop_t * loop, int fd, int flags) noexcept;
 
@@ -67,14 +67,14 @@ class ControlConnWatcher : public BidiFdWatcher<NullMutex>
     
     void setWatchFlags(int flags)
     {
-        BidiFdWatcher<NullMutex>::setWatchFlags(eventLoop, flags);
+        EventLoop_t::BidiFdWatcher::setWatchFlags(eventLoop, flags);
     }
     
     void registerWith(EventLoop_t *loop, int fd, int flags)
     {
         this->fd = fd;
         this->eventLoop = loop;
-        BidiFdWatcher<NullMutex>::registerWith(loop, fd, flags);
+        BidiFdWatcher<EventLoop_t>::registerWith(loop, fd, flags);
     }
 };
 

diff --git a/src/dasynq/dasynq.h b/src/dasynq/dasynq.h
index 93ded31d11ab4edd9e416a25ee508a414f63f174..d9b4b4a37037b015f4964d3fc742d275e48acc7e 100644 (file)
--- a/src/dasynq/dasynq.h
+++ b/src/dasynq/dasynq.h
@@ -74,22 +74,22 @@ enum class Rearm
 // TODO: add a REQUEUE option, which means, "I didn't complete input/output, run me again soon"
 };
 
-
-// Forward declarations:
-template <typename T_Mutex> class EventLoop;
-template <typename T_Mutex> class FdWatcher;
-template <typename T_Mutex> class BidiFdWatcher;
-template <typename T_Mutex> class SignalWatcher;
-template <typename T_Mutex> class ChildProcWatcher;
-
 // Information about a received signal.
 // This is essentially a wrapper for the POSIX siginfo_t; its existence allows for mechanisms that receive
 // equivalent signal information in a different format (eg signalfd on Linux).
 using SigInfo = LoopTraits::SigInfo;
 
+// Forward declarations:
+template <typename T_Mutex> class EventLoop;
+
 namespace dprivate {
     // (non-public API)
-
+    
+    template <typename T_Mutex> class FdWatcher;
+    template <typename T_Mutex> class BidiFdWatcher;
+    template <typename T_Mutex> class SignalWatcher;
+    template <typename T_Mutex> class ChildProcWatcher;
+    
     enum class WatchType
     {
         SIGNAL,
@@ -491,10 +491,10 @@ namespace dprivate {
 
 template <typename T_Mutex> class EventLoop
 {
-    friend class FdWatcher<T_Mutex>;
-    friend class BidiFdWatcher<T_Mutex>;
-    friend class SignalWatcher<T_Mutex>;
-    friend class ChildProcWatcher<T_Mutex>;
+    friend class dprivate::FdWatcher<EventLoop<T_Mutex>>;
+    friend class dprivate::BidiFdWatcher<EventLoop<T_Mutex>>;
+    friend class dprivate::SignalWatcher<EventLoop<T_Mutex>>;
+    friend class dprivate::ChildProcWatcher<EventLoop<T_Mutex>>;
     
     template <typename T, typename U> using EventDispatch = dprivate::EventDispatch<T,U>;
     template <typename T> using waitqueue = dprivate::waitqueue<T>;
@@ -949,6 +949,13 @@ template <typename T_Mutex> class EventLoop
 
     
     public:
+    using mutex_t = T_Mutex;
+    
+    using FdWatcher = dprivate::FdWatcher<EventLoop<T_Mutex>>;
+    using BidiFdWatcher = dprivate::BidiFdWatcher<EventLoop<T_Mutex>>;
+    using SignalWatcher = dprivate::SignalWatcher<EventLoop<T_Mutex>>;
+    using ChildProcWatcher = dprivate::ChildProcWatcher<EventLoop<T_Mutex>>;
+    
     void run() noexcept
     {
         while (! processEvents()) {
@@ -967,18 +974,20 @@ template <typename T_Mutex> class EventLoop
     }
 };
 
-
 typedef EventLoop<NullMutex> NEventLoop;
 typedef EventLoop<std::mutex> TEventLoop;
 
 // from dasync.cc:
 TEventLoop & getSystemLoop();
 
+namespace dprivate {
+
 // Posix signal event watcher
-template <typename T_Mutex>
-class SignalWatcher : private dprivate::BaseSignalWatcher<T_Mutex>
+template <typename EventLoop>
+class SignalWatcher : private dprivate::BaseSignalWatcher<typename EventLoop::mutex_t>
 {
     using BaseWatcher = dprivate::BaseWatcher;
+    using T_Mutex = typename EventLoop::mutex_t;
     
 public:
     using SigInfo_p = typename dprivate::BaseSignalWatcher<T_Mutex>::SigInfo_p;
@@ -986,14 +995,14 @@ public:
     // Register this watcher to watch the specified signal.
     // If an attempt is made to register with more than one event loop at
     // a time, behaviour is undefined.
-    inline void registerWatch(EventLoop<T_Mutex> *eloop, int signo)
+    inline void registerWatch(EventLoop *eloop, int signo)
     {
         BaseWatcher::init();
         this->siginfo.set_signo(signo);
         eloop->registerSignal(this, signo);
     }
     
-    inline void deregisterWatch(EventLoop<T_Mutex> *eloop) noexcept
+    inline void deregisterWatch(EventLoop *eloop) noexcept
     {
         eloop->deregister(this, this->siginfo.get_signo());
     }
@@ -1002,10 +1011,11 @@ public:
 };
 
 // Posix file descriptor event watcher
-template <typename T_Mutex>
-class FdWatcher : private dprivate::BaseFdWatcher<T_Mutex>
+template <typename EventLoop>
+class FdWatcher : private dprivate::BaseFdWatcher<typename EventLoop::mutex_t>
 {
     using BaseWatcher = dprivate::BaseWatcher;
+    using T_Mutex = typename EventLoop::mutex_t;
 
     protected:
     
@@ -1033,7 +1043,7 @@ class FdWatcher : private dprivate::BaseFdWatcher<T_Mutex>
     // causes undefined behavior.
     //
     // Can fail with std::bad_alloc or std::system_error.
-    void registerWith(EventLoop<T_Mutex> *eloop, int fd, int flags)
+    void registerWith(EventLoop *eloop, int fd, int flags)
     {
         BaseWatcher::init();
         this->watch_fd = fd;
@@ -1050,12 +1060,12 @@ class FdWatcher : private dprivate::BaseFdWatcher<T_Mutex>
     // calling this method as long as the handler (if it is active) accesses no
     // internal state and returns Rearm::REMOVED.
     //   TODO: implement REMOVED, or correct above statement.
-    void deregisterWatch(EventLoop<T_Mutex> *eloop) noexcept
+    void deregisterWatch(EventLoop *eloop) noexcept
     {
         eloop->deregister(this, this->watch_fd);
     }
     
-    void setEnabled(EventLoop<T_Mutex> *eloop, bool enable) noexcept
+    void setEnabled(EventLoop *eloop, bool enable) noexcept
     {
         std::lock_guard<T_Mutex> guard(eloop->getBaseLock());
         eloop->setFdEnabled_nolock(this, this->watch_fd, this->watch_flags, enable);
@@ -1070,12 +1080,13 @@ class FdWatcher : private dprivate::BaseFdWatcher<T_Mutex>
 // A Bi-directional file descriptor watcher with independent read- and write- channels.
 // This watcher type has two event notification methods which can both potentially be
 // active at the same time.
-template <typename T_Mutex>
-class BidiFdWatcher : private dprivate::BaseBidiFdWatcher<T_Mutex>
+template <typename EventLoop>
+class BidiFdWatcher : private dprivate::BaseBidiFdWatcher<typename EventLoop::mutex_t>
 {
     using BaseWatcher = dprivate::BaseWatcher;
+    using T_Mutex = typename EventLoop::mutex_t;
     
-    void setWatchEnabled(EventLoop<T_Mutex> *eloop, bool in, bool b)
+    void setWatchEnabled(EventLoop *eloop, bool in, bool b)
     {
         int events = in ? IN_EVENTS : OUT_EVENTS;
         
@@ -1107,14 +1118,14 @@ class BidiFdWatcher : private dprivate::BaseBidiFdWatcher<T_Mutex>
     
     // TODO if a watch is disabled and currently queued, we should de-queue it.
     
-    void setInWatchEnabled(EventLoop<T_Mutex> *eloop, bool b) noexcept
+    void setInWatchEnabled(EventLoop *eloop, bool b) noexcept
     {
         eloop->getBaseLock().lock();
         setWatchEnabled(eloop, true, b);
         eloop->getBaseLock().unlock();
     }
     
-    void setOutWatchEnabled(EventLoop<T_Mutex> *eloop, bool b) noexcept
+    void setOutWatchEnabled(EventLoop *eloop, bool b) noexcept
     {
         eloop->getBaseLock().lock();
         setWatchEnabled(eloop, false, b);
@@ -1128,7 +1139,7 @@ class BidiFdWatcher : private dprivate::BaseBidiFdWatcher<T_Mutex>
     ///   - unless the event loop will not be polled while the watcher is active.
     // (i.e. it is ok to call setWatchFlags from within the readReady/writeReady handlers if no other
     //  thread will poll the event loop; it is ok to *dis*able a watcher that might be active).
-    void setWatchFlags(EventLoop<T_Mutex> * eloop, int newFlags)
+    void setWatchFlags(EventLoop * eloop, int newFlags)
     {
         std::lock_guard<T_Mutex> guard(eloop->getBaseLock());
         if (LoopTraits::has_separate_rw_fd_watches) {
@@ -1147,7 +1158,7 @@ class BidiFdWatcher : private dprivate::BaseBidiFdWatcher<T_Mutex>
     // can be any combination of dasynq::IN_EVENTS / dasynq::OUT_EVENTS.
     //
     // Can fail with std::bad_alloc or std::system_error.
-    void registerWith(EventLoop<T_Mutex> *eloop, int fd, int flags)
+    void registerWith(EventLoop *eloop, int fd, int flags)
     {
         BaseWatcher::init();
         this->outWatcher.BaseWatcher::init();
@@ -1165,7 +1176,7 @@ class BidiFdWatcher : private dprivate::BaseBidiFdWatcher<T_Mutex>
     // calling this method as long as the handler (if it is active) accesses no
     // internal state and returns Rearm::REMOVED.
     //   TODO: implement REMOVED, or correct above statement.
-    void deregisterWatch(EventLoop<T_Mutex> *eloop) noexcept
+    void deregisterWatch(EventLoop *eloop) noexcept
     {
         eloop->deregister(this, this->watch_fd);
     }
@@ -1175,22 +1186,23 @@ class BidiFdWatcher : private dprivate::BaseBidiFdWatcher<T_Mutex>
 };
 
 // Child process event watcher
-template <typename T_Mutex>
-class ChildProcWatcher : private dprivate::BaseChildWatcher<T_Mutex>
+template <typename EventLoop>
+class ChildProcWatcher : private dprivate::BaseChildWatcher<typename EventLoop::mutex_t>
 {
     using BaseWatcher = dprivate::BaseWatcher;
+    using T_Mutex = typename EventLoop::mutex_t;
 
     public:
     // Reserve resources for a child watcher with the given event loop.
     // Reservation can fail with std::bad_alloc.
-    void reserveWith(EventLoop<T_Mutex> *eloop)
+    void reserveWith(EventLoop *eloop)
     {
         eloop->reserveChildWatch();
     }
     
     // Register a watcher for the given child process with an event loop.
     // Registration can fail with std::bad_alloc.
-    void registerWith(EventLoop<T_Mutex> *eloop, pid_t child)
+    void registerWith(EventLoop *eloop, pid_t child)
     {
         BaseWatcher::init();
         this->watch_pid = child;
@@ -1200,7 +1212,7 @@ class ChildProcWatcher : private dprivate::BaseChildWatcher<T_Mutex>
     // Register a watcher for the given child process with an event loop,
     // after having reserved resources previously (using reserveWith).
     // Registration cannot fail.
-    void registerReserved(EventLoop<T_Mutex> *eloop, pid_t child) noexcept
+    void registerReserved(EventLoop *eloop, pid_t child) noexcept
     {
         BaseWatcher::init();
         eloop->registerReservedChild(this, child);
@@ -1209,6 +1221,7 @@ class ChildProcWatcher : private dprivate::BaseChildWatcher<T_Mutex>
     // virtual void gotTermStat(EventLoop<T_Mutex> *, pid_t child, int status) = 0;
 };
 
+}  // namespace dasynq::dprivate
 }  // namespace dasynq
 
 #endif

diff --git a/src/dinit-log.cc b/src/dinit-log.cc
index 07cfed878c1ea468556fd8dce521aab0081e010f..43062f0f15a400ca938c7d188be6b9f9d5dcc28b 100644 (file)
--- a/src/dinit-log.cc
+++ b/src/dinit-log.cc
@@ -20,7 +20,7 @@ LogLevel log_level[2] = { LogLevel::WARN, LogLevel::WARN };
 static ServiceSet *service_set = nullptr;  // Reference to service set
 
 namespace {
-class BufferedLogStream : public FdWatcher<NullMutex>
+class BufferedLogStream : public EventLoop_t::FdWatcher
 {
     private:
 

diff --git a/src/dinit.cc b/src/dinit.cc
index a87b4f7bfa30bb66f57a896629a77edd8eca1d50..7027cca9f160693c67be4473f504f06519cb25ee 100644 (file)
--- a/src/dinit.cc
+++ b/src/dinit.cc
@@ -73,7 +73,7 @@ static void close_control_socket(EventLoop_t *loop) noexcept;
 
 static void control_socket_cb(EventLoop_t *loop, int fd);
 
-class ControlSocketWatcher : public FdWatcher<NullMutex>
+class ControlSocketWatcher : public EventLoop_t::FdWatcher
 {
     Rearm gotEvent(EventLoop_t * loop, int fd, int flags)
     {
@@ -88,7 +88,7 @@ class ControlSocketWatcher : public FdWatcher<NullMutex>
     void registerWith(EventLoop_t * loop, int fd, int flags)
     {
         this->fd = fd;
-        FdWatcher<NullMutex>::registerWith(loop, fd, flags);
+        EventLoop_t::FdWatcher::registerWith(loop, fd, flags);
     }
 };
 
@@ -133,7 +133,7 @@ const char * get_user_home()
 
 
 namespace {
-    class CallbackSignalHandler : public SignalWatcher<NullMutex>
+    class CallbackSignalHandler : public EventLoop_t::SignalWatcher
     {
         public:
         typedef void (*cb_func_t)(EventLoop_t *);
@@ -157,7 +157,7 @@ namespace {
         }
     };
 
-    class ControlSocketWatcher : public FdWatcher<NullMutex>
+    class ControlSocketWatcher : public EventLoop_t::FdWatcher
     {
         Rearm gotEvent(EventLoop_t * loop, int fd, int flags)
         {

diff --git a/src/service.h b/src/service.h
index f79658177a89784cf7552429c1680f8ff2b60d92..27c6a37deefd20a9e2edb9ad79fcd58c09679ca7 100644 (file)
--- a/src/service.h
+++ b/src/service.h
@@ -180,7 +180,7 @@ static std::vector<const char *> separate_args(std::string &s, std::list<std::pa
     return r;
 }
 
-class ServiceChildWatcher : public ChildProcWatcher<NullMutex>
+class ServiceChildWatcher : public EventLoop_t::ChildProcWatcher
 {
     public:
     // TODO resolve clunkiness of storing this field
@@ -190,7 +190,7 @@ class ServiceChildWatcher : public ChildProcWatcher<NullMutex>
     ServiceChildWatcher(ServiceRecord * sr) noexcept : service(sr) { }
 };
 
-class ServiceIoWatcher : public FdWatcher<NullMutex>
+class ServiceIoWatcher : public EventLoop_t::FdWatcher
 {
     public:
     // TODO resolve clunkiness of storing these fields
@@ -203,7 +203,7 @@ class ServiceIoWatcher : public FdWatcher<NullMutex>
     void registerWith(EventLoop_t *loop, int fd, int flags)
     {
         this->fd = fd;
-        FdWatcher<NullMutex>::registerWith(loop, fd, flags);
+        EventLoop_t::FdWatcher::registerWith(loop, fd, flags);
     }
 };