Add duration template for all function using std::chrono::milliseconds

Author: cacharle

zmq.hpp

@@ -351,16 +351,19 @@ inline int poll(std::vector<zmq_pollitem_t> const &items, long timeout_ = -1)
     return detail::poll(const_cast<zmq_pollitem_t *>(items.data()), items.size(), timeout_);
 }
 
-inline int
-poll(zmq_pollitem_t *items, size_t nitems, std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
+template<typename Duration = std::chrono::milliseconds>
+int
+poll(zmq_pollitem_t *items, size_t nitems, Duration timeout = std::chrono::milliseconds{-1})
 {
-    return detail::poll(items, nitems, static_cast<long>(timeout.count()));
+    auto timeout_ms = std::chrono::duration_cast<std::chrono::milliseconds>(timeout);
+    return detail::poll(items, nitems, static_cast<long>(timeout_ms.count()));
 }
 
-inline int poll(std::vector<zmq_pollitem_t> &items,
-                std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
+template<typename Duration = std::chrono::milliseconds>
+int poll(std::vector<zmq_pollitem_t> &items, Duration timeout = std::chrono::milliseconds{-1})
 {
-    return detail::poll(items.data(), items.size(), static_cast<long>(timeout.count()));
+    auto timeout_ms = std::chrono::duration_cast<std::chrono::milliseconds>(timeout);
+    return detail::poll(items.data(), items.size(), static_cast<long>(timeout_ms.count()));
 }
 
 ZMQ_DEPRECATED("from 4.3.1, use poll taking std::chrono::duration instead of long")
@@ -369,11 +372,11 @@ inline int poll(std::vector<zmq_pollitem_t> &items, long timeout_)
     return detail::poll(items.data(), items.size(), timeout_);
 }
 
-template<std::size_t SIZE>
-inline int poll(std::array<zmq_pollitem_t, SIZE> &items,
-                std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
+template<std::size_t SIZE, typename Duration>
+int poll(std::array<zmq_pollitem_t, SIZE> &items, Duration timeout = std::chrono::milliseconds{-1})
 {
-    return detail::poll(items.data(), items.size(), static_cast<long>(timeout.count()));
+    auto timeout_ms = std::chrono::duration_cast<std::chrono::milliseconds>(timeout);
+    return detail::poll(items.data(), items.size(), static_cast<long>(timeout_ms.count()));
 }
 #endif
 
@@ -2366,6 +2369,14 @@ class monitor_t
         on_monitor_started();
     }
 
+#ifdef ZMQ_CPP11
+    template<typename Duration = std::chrono::milliseconds>
+    bool check_event(Duration timeout = std::chrono::milliseconds{0})
+    {
+        return check_event(std::chrono::duration_cast<std::chrono::milliseconds>(timeout).count());
+    }
+#endif
+
     bool check_event(int timeout = 0)
     {
         assert(_monitor_socket);
@@ -2725,17 +2736,17 @@ template<typename T = no_user_data> class poller_t
         }
     }
 
-    template <typename Sequence>
+    template <typename Sequence, typename Duration = std::chrono::milliseconds>
     size_t wait_all(Sequence &poller_events,
-                    const std::chrono::milliseconds timeout)
+                    const Duration timeout)
     {
         static_assert(std::is_same<typename Sequence::value_type, event_type>::value,
                       "Sequence::value_type must be of poller_t::event_type");
         int rc = zmq_poller_wait_all(
           poller_ptr.get(),
           reinterpret_cast<zmq_poller_event_t *>(poller_events.data()),
           static_cast<int>(poller_events.size()),
-          static_cast<long>(timeout.count()));
+          static_cast<long>(std::chrono::duration_cast<std::chrono::milliseconds>(timeout).count()));
         if (rc > 0)
             return static_cast<size_t>(rc);
 
@@ -2804,9 +2815,11 @@ class timers
     using fn_t = zmq_timer_fn;
 
 #if CPPZMQ_HAS_OPTIONAL
-    using timeout_result_t = std::optional<std::chrono::milliseconds>;
+    template<typename Duration = std::chrono::milliseconds>
+    using timeout_result_t = std::optional<Duration>;
 #else
-    using timeout_result_t = detail::trivial_optional<std::chrono::milliseconds>;
+    template<typename Duration = std::chrono::milliseconds>
+    using timeout_result_t = detail::trivial_optional<Duration>;
 #endif
 
     timers() : _timers(zmq_timers_new())
@@ -2824,9 +2837,11 @@ class timers
         ZMQ_ASSERT(rc == 0);
     }
 
-    id_t add(std::chrono::milliseconds interval, zmq_timer_fn handler, void *arg)
+    template<typename Duration = std::chrono::milliseconds>
+    id_t add(Duration interval, zmq_timer_fn handler, void *arg)
     {
-        id_t timer_id = zmq_timers_add(_timers, interval.count(), handler, arg);
+        auto interval_ms = std::chrono::duration_cast<std::chrono::milliseconds>(interval);
+        id_t timer_id = zmq_timers_add(_timers, interval_ms.count(), handler, arg);
         if (timer_id == -1)
             throw zmq::error_t();
         return timer_id;
@@ -2839,9 +2854,11 @@ class timers
             throw zmq::error_t();
     }
 
-    void set_interval(id_t timer_id, std::chrono::milliseconds interval)
+    template<typename Duration = std::chrono::milliseconds>
+    void set_interval(id_t timer_id, Duration interval)
     {
-        int rc = zmq_timers_set_interval(_timers, timer_id, interval.count());
+        auto interval_ms = std::chrono::duration_cast<std::chrono::milliseconds>(interval);
+        int rc = zmq_timers_set_interval(_timers, timer_id, interval_ms.count());
         if (rc == -1)
             throw zmq::error_t();
     }
@@ -2853,12 +2870,13 @@ class timers
             throw zmq::error_t();
     }
 
-    timeout_result_t timeout() const
+    template<typename Duration = std::chrono::milliseconds>
+    timeout_result_t<Duration> timeout() const
     {
         int timeout = zmq_timers_timeout(_timers);
         if (timeout == -1)
-            return timeout_result_t{};
-        return std::chrono::milliseconds{timeout};
+            return timeout_result_t<Duration>{};
+        return std::chrono::duration_cast<Duration>(std::chrono::milliseconds{timeout});
     }
 
     void execute()

zmq_addon.hpp

@@ -805,7 +805,8 @@ class active_poller_t
         base_poller.modify(fd, events);
     }
 
-    size_t wait(std::chrono::milliseconds timeout)
+    template<typename Duration = std::chrono::milliseconds>
+    size_t wait(Duration timeout)
     {
         if (need_rebuild) {
             poller_events.resize(handlers.size());
@@ -816,7 +817,8 @@ class active_poller_t
             }
             need_rebuild = false;
         }
-        const auto count = base_poller.wait_all(poller_events, timeout);
+        auto timeout_ms = std::chrono::duration_cast<Duration>(timeout);
+        const auto count = base_poller.wait_all(poller_events, timeout_ms);
         std::for_each(poller_events.begin(),
                       poller_events.begin() + static_cast<ptrdiff_t>(count),
                       [](decltype(base_poller)::event_type &event) {