Introduced move_only_function.

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "external/function2"]
+	path = external/function2
+	url = https://github.com/Naios/function2

include/mqtt/move_only_function.hpp

@@ -0,0 +1,21 @@
+// Copyright Takatoshi Kondo 2022
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(MQTT_MOVE_ONLY_FUNCTION_HPP)
+#define MQTT_MOVE_ONLY_FUNCTION_HPP
+
+#include <mqtt/external/function2.hpp>
+
+#include <mqtt/namespace.hpp>
+
+namespace MQTT_NS {
+
+template <typename... Params>
+using move_only_function = fu2::unique_function<Params...>;
+
+} // namespace MQTT_NS
+
+#endif // MQTT_MOVE_ONLY_FUNCTION_HPP

include/mqtt/null_strand.hpp

@@ -17,9 +17,77 @@ namespace MQTT_NS {
 
 namespace as = boost::asio;
 
-// Using standard executor style null_strand / simple executor
-using null_strand = as::io_context::executor_type;
+namespace detail {
+
+struct null_strand {
+    using inner_executor_type = as::io_context::executor_type;
+    template <typename Executor>
+    explicit null_strand(Executor e) noexcept
+        : exe_{force_move(e)}
+    {}
+
+    template <typename Func, typename Allocator>
+    void defer(Func&& f, Allocator) const {
+        as::defer(
+            exe_,
+            [f = std::forward<Func>(f)] () mutable {
+                std::move(f)();
+            }
+        );
+    }
+    template <typename Func, typename Allocator>
+    void dispatch(Func&& f, Allocator) const {
+        as::dispatch(
+            exe_,
+            [f = std::forward<Func>(f)] () mutable {
+                std::move(f)();
+            }
+        );
+    }
+    template <typename Func, typename Allocator>
+    void post(Func&& f, Allocator) const {
+        as::post(
+            exe_,
+            [f = std::forward<Func>(f)] () mutable {
+                std::move(f)();
+            }
+        );
+    }
+    as::any_io_executor get_inner_executor() const {
+        return exe_;
+    }
+    void on_work_started() const noexcept {}
+    void on_work_finished() const noexcept {}
+    bool running_in_this_thread() const noexcept { return true; }
+    operator as::any_io_executor() const {
+        return exe_;
+    }
+private:
+    as::io_context::executor_type exe_;
+};
+
+} // namespace detail
+
+using null_strand = detail::null_strand;
+
+inline bool operator==(null_strand const& lhs, null_strand const& rhs) {
+    return std::addressof(lhs) == std::addressof(rhs);
+}
+
+inline bool operator!=(null_strand const& lhs, null_strand const& rhs) {
+    return !(lhs == rhs);
+}
 
 } // namespace MQTT_NS
 
+namespace boost {
+namespace asio {
+
+template<>
+struct is_executor<MQTT_NS::null_strand> : std::true_type {
+};
+
+} // namespace asio
+} // namespace boost
+
 #endif // MQTT_NULL_STRAND_HPP