[wpiutil] uv: use move for std::function (#3653)

Also use function_ref for Loop::Walk().

wpiutil/src/main/native/cpp/EventLoopRunner.cpp

@@ -65,7 +65,7 @@ void EventLoopRunner::Stop() {
 void EventLoopRunner::ExecAsync(LoopFunc func) {
   if (auto thr = m_owner.GetThread()) {
     if (auto doExec = thr->m_doExec.lock()) {
-      doExec->Call(func);
+      doExec->Call(std::move(func));
     }
   }
 }
@@ -74,7 +74,7 @@ void EventLoopRunner::ExecSync(LoopFunc func) {
   wpi::future<void> f;
   if (auto thr = m_owner.GetThread()) {
     if (auto doExec = thr->m_doExec.lock()) {
-      f = doExec->Call(func);
+      f = doExec->Call(std::move(func));
     }
   }
   if (f.valid()) {

wpiutil/src/main/native/cpp/uv/GetAddrInfo.cpp

@@ -44,7 +44,7 @@ void GetAddrInfo(Loop& loop, std::function<void(const addrinfo&)> callback,
                  std::string_view node, std::string_view service,
                  const addrinfo* hints) {
   auto req = std::make_shared<GetAddrInfoReq>();
-  req->resolved.connect(callback);
+  req->resolved.connect(std::move(callback));
   GetAddrInfo(loop, req, node, service, hints);
 }
 

wpiutil/src/main/native/cpp/uv/GetNameInfo.cpp

@@ -39,7 +39,7 @@ void GetNameInfo(Loop& loop,
                  std::function<void(const char*, const char*)> callback,
                  const sockaddr& addr, int flags) {
   auto req = std::make_shared<GetNameInfoReq>();
-  req->resolved.connect(callback);
+  req->resolved.connect(std::move(callback));
   GetNameInfo(loop, req, addr, flags);
 }
 
@@ -62,7 +62,8 @@ void GetNameInfo4(Loop& loop,
   if (err < 0) {
     loop.ReportError(err);
   } else {
-    GetNameInfo(loop, callback, reinterpret_cast<const sockaddr&>(addr), flags);
+    GetNameInfo(loop, std::move(callback),
+                reinterpret_cast<const sockaddr&>(addr), flags);
   }
 }
 
@@ -85,7 +86,8 @@ void GetNameInfo6(Loop& loop,
   if (err < 0) {
     loop.ReportError(err);
   } else {
-    GetNameInfo(loop, callback, reinterpret_cast<const sockaddr&>(addr), flags);
+    GetNameInfo(loop, std::move(callback),
+                reinterpret_cast<const sockaddr&>(addr), flags);
   }
 }
 

wpiutil/src/main/native/cpp/uv/Loop.cpp

@@ -51,12 +51,12 @@ void Loop::Close() {
   }
 }
 
-void Loop::Walk(std::function<void(Handle&)> callback) {
+void Loop::Walk(function_ref<void(Handle&)> callback) {
   uv_walk(
       m_loop,
       [](uv_handle_t* handle, void* func) {
         auto& h = *static_cast<Handle*>(handle->data);
-        auto& f = *static_cast<std::function<void(Handle&)>*>(func);
+        auto& f = *static_cast<function_ref<void(Handle&)>*>(func);
         f(h);
       },
       &callback);

wpiutil/src/main/native/cpp/uv/NetworkStream.cpp

@@ -23,7 +23,7 @@ void NetworkStream::Listen(int backlog) {
 }
 
 void NetworkStream::Listen(std::function<void()> callback, int backlog) {
-  connection.connect(callback);
+  connection.connect(std::move(callback));
   Listen(backlog);
 }
 

wpiutil/src/main/native/cpp/uv/Pipe.cpp

@@ -28,7 +28,7 @@ void Pipe::Reuse(std::function<void()> callback, bool ipc) {
   if (!m_reuseData) {
     m_reuseData = std::make_unique<ReuseData>();
   }
-  m_reuseData->callback = callback;
+  m_reuseData->callback = std::move(callback);
   m_reuseData->ipc = ipc;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {
     Pipe& h = *static_cast<Pipe*>(handle->data);
@@ -85,7 +85,7 @@ void Pipe::Connect(std::string_view name,
 
 void Pipe::Connect(std::string_view name, std::function<void()> callback) {
   auto req = std::make_shared<PipeConnectReq>();
-  req->connected.connect(callback);
+  req->connected.connect(std::move(callback));
   Connect(name, req);
 }
 

wpiutil/src/main/native/cpp/uv/Poll.cpp

@@ -37,7 +37,7 @@ void Poll::Reuse(int fd, std::function<void()> callback) {
   if (!m_reuseData) {
     m_reuseData = std::make_unique<ReuseData>();
   }
-  m_reuseData->callback = callback;
+  m_reuseData->callback = std::move(callback);
   m_reuseData->isSocket = false;
   m_reuseData->fd = fd;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {
@@ -62,7 +62,7 @@ void Poll::ReuseSocket(uv_os_sock_t sock, std::function<void()> callback) {
   if (!m_reuseData) {
     m_reuseData = std::make_unique<ReuseData>();
   }
-  m_reuseData->callback = callback;
+  m_reuseData->callback = std::move(callback);
   m_reuseData->isSocket = true;
   m_reuseData->sock = sock;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {

wpiutil/src/main/native/cpp/uv/Stream.cpp

@@ -15,7 +15,8 @@ class CallbackWriteReq : public WriteReq {
   CallbackWriteReq(span<const Buffer> bufs,
                    std::function<void(span<Buffer>, Error)> callback)
       : m_bufs{bufs.begin(), bufs.end()} {
-    finish.connect([=](Error err) { callback(m_bufs, err); });
+    finish.connect(
+        [this, f = std::move(callback)](Error err) { f(m_bufs, err); });
   }
 
  private:
@@ -51,7 +52,7 @@ void Stream::Shutdown(const std::shared_ptr<ShutdownReq>& req) {
 void Stream::Shutdown(std::function<void()> callback) {
   auto req = std::make_shared<ShutdownReq>();
   if (callback) {
-    req->complete.connect(callback);
+    req->complete.connect(std::move(callback));
   }
   Shutdown(req);
 }
@@ -93,7 +94,7 @@ void Stream::Write(span<const Buffer> bufs,
 
 void Stream::Write(span<const Buffer> bufs,
                    std::function<void(span<Buffer>, Error)> callback) {
-  Write(bufs, std::make_shared<CallbackWriteReq>(bufs, callback));
+  Write(bufs, std::make_shared<CallbackWriteReq>(bufs, std::move(callback)));
 }
 
 int Stream::TryWrite(span<const Buffer> bufs) {

wpiutil/src/main/native/cpp/uv/Tcp.cpp

@@ -28,7 +28,7 @@ void Tcp::Reuse(std::function<void()> callback, unsigned int flags) {
   if (!m_reuseData) {
     m_reuseData = std::make_unique<ReuseData>();
   }
-  m_reuseData->callback = callback;
+  m_reuseData->callback = std::move(callback);
   m_reuseData->flags = flags;
   uv_close(GetRawHandle(), [](uv_handle_t* handle) {
     Tcp& h = *static_cast<Tcp*>(handle->data);
@@ -119,7 +119,7 @@ void Tcp::Connect(const sockaddr& addr,
 
 void Tcp::Connect(const sockaddr& addr, std::function<void()> callback) {
   auto req = std::make_shared<TcpConnectReq>();
-  req->connected.connect(callback);
+  req->connected.connect(std::move(callback));
   Connect(addr, req);
 }
 
@@ -141,7 +141,7 @@ void Tcp::Connect(std::string_view ip, unsigned int port,
   if (err < 0) {
     ReportError(err);
   } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr), callback);
+    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
   }
 }
 
@@ -163,7 +163,7 @@ void Tcp::Connect6(std::string_view ip, unsigned int port,
   if (err < 0) {
     ReportError(err);
   } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr), callback);
+    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
   }
 }
 

wpiutil/src/main/native/cpp/uv/Timer.cpp

@@ -24,8 +24,8 @@ void Timer::SingleShot(Loop& loop, Time timeout, std::function<void()> func) {
   if (!h) {
     return;
   }
-  h->timeout.connect([theTimer = h.get(), func]() {
-    func();
+  h->timeout.connect([theTimer = h.get(), f = std::move(func)]() {
+    f();
     theTimer->Close();
   });
   h->Start(timeout);

wpiutil/src/main/native/cpp/uv/Udp.cpp

@@ -20,7 +20,8 @@ class CallbackUdpSendReq : public UdpSendReq {
   CallbackUdpSendReq(span<const Buffer> bufs,
                      std::function<void(span<Buffer>, Error)> callback)
       : m_bufs{bufs.begin(), bufs.end()} {
-    complete.connect([=](Error err) { callback(m_bufs, err); });
+    complete.connect(
+        [this, f = std::move(callback)](Error err) { f(m_bufs, err); });
   }
 
  private:
@@ -137,7 +138,8 @@ void Udp::Send(const sockaddr& addr, span<const Buffer> bufs,
 
 void Udp::Send(const sockaddr& addr, span<const Buffer> bufs,
                std::function<void(span<Buffer>, Error)> callback) {
-  Send(addr, bufs, std::make_shared<CallbackUdpSendReq>(bufs, callback));
+  Send(addr, bufs,
+       std::make_shared<CallbackUdpSendReq>(bufs, std::move(callback)));
 }
 
 void Udp::Send(span<const Buffer> bufs,
@@ -157,7 +159,7 @@ void Udp::Send(span<const Buffer> bufs,
 
 void Udp::Send(span<const Buffer> bufs,
                std::function<void(span<Buffer>, Error)> callback) {
-  Send(bufs, std::make_shared<CallbackUdpSendReq>(bufs, callback));
+  Send(bufs, std::make_shared<CallbackUdpSendReq>(bufs, std::move(callback)));
 }
 
 void Udp::StartRecv() {

wpiutil/src/main/native/cpp/uv/Work.cpp

@@ -39,10 +39,10 @@ void QueueWork(Loop& loop, std::function<void()> work,
                std::function<void()> afterWork) {
   auto req = std::make_shared<WorkReq>();
   if (work) {
-    req->work.connect(work);
+    req->work.connect(std::move(work));
   }
   if (afterWork) {
-    req->afterWork.connect(afterWork);
+    req->afterWork.connect(std::move(afterWork));
   }
   QueueWork(loop, req);
 }

wpiutil/src/main/native/include/wpi/uv/AsyncFunction.h

@@ -38,7 +38,7 @@ class AsyncFunction<R(T...)> final
  public:
   AsyncFunction(const std::shared_ptr<Loop>& loop,
                 std::function<void(promise<R>, T...)> func, const private_init&)
-      : wakeup{func}, m_loop{loop} {}
+      : wakeup{std::move(func)}, m_loop{loop} {}
   ~AsyncFunction() noexcept override {
     if (auto loop = m_loop.lock()) {
       this->Close();

wpiutil/src/main/native/include/wpi/uv/GetAddrInfo.h

@@ -10,6 +10,7 @@
 #include <functional>
 #include <memory>
 #include <string_view>
+#include <utility>
 
 #include "wpi/Signal.h"
 #include "wpi/uv/Request.h"
@@ -110,7 +111,7 @@ inline void GetAddrInfo(const std::shared_ptr<Loop>& loop,
                         std::function<void(const addrinfo&)> callback,
                         std::string_view node, std::string_view service = {},
                         const addrinfo* hints = nullptr) {
-  GetAddrInfo(*loop, callback, node, service, hints);
+  GetAddrInfo(*loop, std::move(callback), node, service, hints);
 }
 
 }  // namespace wpi::uv

wpiutil/src/main/native/include/wpi/uv/GetNameInfo.h

@@ -10,6 +10,7 @@
 #include <functional>
 #include <memory>
 #include <string_view>
+#include <utility>
 
 #include "wpi/Signal.h"
 #include "wpi/uv/Request.h"
@@ -90,7 +91,7 @@ void GetNameInfo(Loop& loop,
 inline void GetNameInfo(const std::shared_ptr<Loop>& loop,
                         std::function<void(const char*, const char*)> callback,
                         const sockaddr& addr, int flags = 0) {
-  GetNameInfo(*loop, callback, addr, flags);
+  GetNameInfo(*loop, std::move(callback), addr, flags);
 }
 
 /**
@@ -154,7 +155,7 @@ inline void GetNameInfo4(const std::shared_ptr<Loop>& loop,
                          std::function<void(const char*, const char*)> callback,
                          std::string_view ip, unsigned int port,
                          int flags = 0) {
-  return GetNameInfo4(*loop, callback, ip, port, flags);
+  return GetNameInfo4(*loop, std::move(callback), ip, port, flags);
 }
 
 /**
@@ -219,7 +220,7 @@ inline void GetNameInfo6(const std::shared_ptr<Loop>& loop,
                          std::function<void(const char*, const char*)> callback,
                          std::string_view ip, unsigned int port,
                          int flags = 0) {
-  return GetNameInfo6(*loop, callback, ip, port, flags);
+  return GetNameInfo6(*loop, std::move(callback), ip, port, flags);
 }
 
 }  // namespace wpi::uv

wpiutil/src/main/native/include/wpi/uv/Handle.h

@@ -191,8 +191,8 @@ class Handle : public std::enable_shared_from_this<Handle> {
    */
   void SetBufferAllocator(std::function<Buffer(size_t)> alloc,
                           std::function<void(Buffer&)> dealloc) {
-    m_allocBuf = alloc;
-    m_freeBuf = dealloc;
+    m_allocBuf = std::move(alloc);
+    m_freeBuf = std::move(dealloc);
   }
 
   /**

wpiutil/src/main/native/include/wpi/uv/Loop.h

@@ -15,6 +15,7 @@
 #include <utility>
 
 #include "wpi/Signal.h"
+#include "wpi/function_ref.h"
 #include "wpi/uv/Error.h"
 
 namespace wpi::uv {
@@ -171,7 +172,7 @@ class Loop final : public std::enable_shared_from_this<Loop> {
    *
    * @param callback A function to be invoked once for each active handle.
    */
-  void Walk(std::function<void(Handle&)> callback);
+  void Walk(function_ref<void(Handle&)> callback);
 
   /**
    * Reinitialize any kernel state necessary in the child process after

wpiutil/src/main/native/include/wpi/uv/Stream.h

@@ -11,6 +11,7 @@
 #include <functional>
 #include <initializer_list>
 #include <memory>
+#include <utility>
 
 #include "wpi/Signal.h"
 #include "wpi/span.h"
@@ -180,7 +181,7 @@ class Stream : public Handle {
    */
   void Write(std::initializer_list<Buffer> bufs,
              std::function<void(span<Buffer>, Error)> callback) {
-    Write({bufs.begin(), bufs.end()}, callback);
+    Write({bufs.begin(), bufs.end()}, std::move(callback));
   }
 
   /**

wpiutil/src/main/native/include/wpi/uv/Tcp.h

@@ -11,6 +11,7 @@
 #include <functional>
 #include <memory>
 #include <string_view>
+#include <utility>
 
 #include "wpi/uv/NetworkStream.h"
 
@@ -258,11 +259,11 @@ class Tcp final : public NetworkStreamImpl<Tcp, uv_tcp_t> {
   void Connect(const sockaddr& addr, std::function<void()> callback);
 
   void Connect(const sockaddr_in& addr, std::function<void()> callback) {
-    Connect(reinterpret_cast<const sockaddr&>(addr), callback);
+    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
   }
 
   void Connect(const sockaddr_in6& addr, std::function<void()> callback) {
-    Connect(reinterpret_cast<const sockaddr&>(addr), callback);
+    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
   }
 
   /**

wpiutil/src/main/native/include/wpi/uv/Timer.h

@@ -10,6 +10,7 @@
 #include <chrono>
 #include <functional>
 #include <memory>
+#include <utility>
 
 #include "wpi/Signal.h"
 #include "wpi/uv/Handle.h"
@@ -65,7 +66,7 @@ class Timer final : public HandleImpl<Timer, uv_timer_t> {
    */
   static void SingleShot(const std::shared_ptr<Loop>& loop, Time timeout,
                          std::function<void()> func) {
-    return SingleShot(*loop, timeout, func);
+    return SingleShot(*loop, timeout, std::move(func));
   }
 
   /**

wpiutil/src/main/native/include/wpi/uv/Udp.h

@@ -10,6 +10,7 @@
 #include <functional>
 #include <memory>
 #include <string_view>
+#include <utility>
 
 #include "wpi/Signal.h"
 #include "wpi/span.h"
@@ -274,12 +275,12 @@ class Udp final : public HandleImpl<Udp, uv_udp_t> {
 
   void Send(const sockaddr_in& addr, span<const Buffer> bufs,
             std::function<void(span<Buffer>, Error)> callback) {
-    Send(reinterpret_cast<const sockaddr&>(addr), bufs, callback);
+    Send(reinterpret_cast<const sockaddr&>(addr), bufs, std::move(callback));
   }
 
   void Send(const sockaddr_in6& addr, span<const Buffer> bufs,
             std::function<void(span<Buffer>, Error)> callback) {
-    Send(reinterpret_cast<const sockaddr&>(addr), bufs, callback);
+    Send(reinterpret_cast<const sockaddr&>(addr), bufs, std::move(callback));
   }
 
   /**

wpiutil/src/main/native/include/wpi/uv/Work.h

@@ -9,6 +9,7 @@
 
 #include <functional>
 #include <memory>
+#include <utility>
 
 #include "wpi/Signal.h"
 #include "wpi/uv/Request.h"
@@ -84,7 +85,7 @@ void QueueWork(Loop& loop, std::function<void()> work,
 inline void QueueWork(const std::shared_ptr<Loop>& loop,
                       std::function<void()> work,
                       std::function<void()> afterWork) {
-  QueueWork(*loop, work, afterWork);
+  QueueWork(*loop, std::move(work), std::move(afterWork));
 }
 
 }  // namespace wpi::uv