Merge topic 'uv-idle-ptr'

70d88a5361 cmUVHandlePtr: Add uv_idle_ptr
17690558c3 cmUVHandlePtr: Add explicit conversion to bool
cd2894a089 cmUVHandlePtr: Conversions to raw pointers are const

Acked-by: Kitware Robot <[email protected]>
Acked-by: buildbot <[email protected]>
Merge-request: !8980

Source/cmUVHandlePtr.cxx

@@ -44,7 +44,7 @@ void uv_loop_ptr::reset()
   this->loop.reset();
 }
 
-uv_loop_ptr::operator uv_loop_t*()
+uv_loop_ptr::operator uv_loop_t*() const
 {
   return this->loop.get();
 }
@@ -96,6 +96,12 @@ void uv_handle_ptr_base_<T>::allocate(void* data)
   this->handle->data = data;
 }
 
+template <typename T>
+uv_handle_ptr_base_<T>::operator bool() const
+{
+  return this->handle.get();
+}
+
 template <typename T>
 void uv_handle_ptr_base_<T>::reset()
 {
@@ -103,7 +109,7 @@ void uv_handle_ptr_base_<T>::reset()
 }
 
 template <typename T>
-uv_handle_ptr_base_<T>::operator uv_handle_t*()
+uv_handle_ptr_base_<T>::operator uv_handle_t*() const
 {
   return reinterpret_cast<uv_handle_t*>(this->handle.get());
 }
@@ -248,12 +254,20 @@ int uv_tty_ptr::init(uv_loop_t& loop, int fd, int readable, void* data)
 }
 #endif
 
+int uv_idle_ptr::init(uv_loop_t& loop, void* data)
+{
+  this->allocate(data);
+  return uv_idle_init(&loop, *this);
+}
+
 template class uv_handle_ptr_base_<uv_handle_t>;
 
 #define UV_HANDLE_PTR_INSTANTIATE_EXPLICIT(NAME)                              \
   template class uv_handle_ptr_base_<uv_##NAME##_t>;                          \
   template class uv_handle_ptr_<uv_##NAME##_t>;
 
+UV_HANDLE_PTR_INSTANTIATE_EXPLICIT(idle)
+
 UV_HANDLE_PTR_INSTANTIATE_EXPLICIT(signal)
 
 UV_HANDLE_PTR_INSTANTIATE_EXPLICIT(pipe)

Source/cmUVHandlePtr.h

@@ -61,7 +61,7 @@ public:
    * Allow less verbose calling of uv_loop_* functions
    * @return reinterpreted handle
    */
-  operator uv_loop_t*();
+  operator uv_loop_t*() const;
 
   uv_loop_t* get() const;
   uv_loop_t* operator->() const noexcept;
@@ -130,6 +130,8 @@ public:
   uv_handle_ptr_base_(std::nullptr_t) {}
   ~uv_handle_ptr_base_() { this->reset(); }
 
+  explicit operator bool() const;
+
   /**
    * Properly close the handle if needed and sets the inner handle to nullptr
    */
@@ -139,7 +141,7 @@ public:
    * Allow less verbose calling of uv_handle_* functions
    * @return reinterpreted handle
    */
-  operator uv_handle_t*();
+  operator uv_handle_t*() const;
 
   T* get() const;
   T* operator->() const noexcept;
@@ -194,6 +196,13 @@ public:
   void send();
 };
 
+struct uv_idle_ptr : public uv_handle_ptr_<uv_idle_t>
+{
+  CM_INHERIT_CTOR(uv_idle_ptr, uv_handle_ptr_, <uv_idle_t>);
+
+  int init(uv_loop_t& loop, void* data = nullptr);
+};
+
 struct uv_signal_ptr : public uv_handle_ptr_<uv_signal_t>
 {
   CM_INHERIT_CTOR(uv_signal_ptr, uv_handle_ptr_, <uv_signal_t>);
@@ -253,6 +262,8 @@ extern template class uv_handle_ptr_base_<uv_handle_t>;
 
 UV_HANDLE_PTR_INSTANTIATE_EXTERN(async)
 
+UV_HANDLE_PTR_INSTANTIATE_EXTERN(idle)
+
 UV_HANDLE_PTR_INSTANTIATE_EXTERN(signal)
 
 UV_HANDLE_PTR_INSTANTIATE_EXTERN(pipe)

Tests/CMakeLib/testUVRAII.cxx

@@ -37,7 +37,7 @@ static bool testAsyncShutdown()
       return false;
     }
 
-    if (signal.get()) {
+    if (signal) {
       std::cerr << "Loop exited with signal not being cleaned up" << std::endl;
       return false;
     }
@@ -125,13 +125,13 @@ static bool testCrossAssignment()
     pipe.init(Loop, 0);
 
     cm::uv_stream_ptr stream = std::move(pipe);
-    if (pipe.get()) {
+    if (pipe) {
       std::cerr << "Move should be sure to invalidate the previous ptr"
                 << std::endl;
       return false;
     }
     cm::uv_handle_ptr handle = std::move(stream);
-    if (stream.get()) {
+    if (stream) {
       std::cerr << "Move should be sure to invalidate the previous ptr"
                 << std::endl;
       return false;
@@ -162,6 +162,7 @@ static bool testAllMoves()
     uv_async_ptr _13;
     uv_signal_ptr _14;
     uv_handle_ptr _15;
+    uv_idle_ptr _16;
   };
 
   allTypes a;
@@ -218,6 +219,30 @@ static bool testLoopDestructor()
   return true;
 }
 
+static bool testIdle()
+{
+  bool idled = false;
+
+  cm::uv_loop_ptr loop;
+  loop.init();
+
+  cm::uv_idle_ptr idle;
+  idle.init(*loop, &idled);
+  uv_idle_start(idle, [](uv_idle_t* handle) {
+    auto idledPtr = static_cast<bool*>(handle->data);
+    *idledPtr = true;
+    uv_idle_stop(handle);
+  });
+  uv_run(loop, UV_RUN_DEFAULT);
+
+  if (!idled) {
+    std::cerr << "uv_idle_ptr did not trigger callback" << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
 int testUVRAII(int, char** const)
 {
   if (!testAsyncShutdown()) {
@@ -230,5 +255,6 @@ int testUVRAII(int, char** const)
   passed = testAllMoves() && passed;
   passed = testLoopReset() && passed;
   passed = testLoopDestructor() && passed;
+  passed = testIdle() && passed;
   return passed ? 0 : -1;
 }