--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#pragma once
+
+// Based on bind_executor.h from Boost.Asio which is Copyright (c)
+// 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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)
+//
+
+#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/execution_context.hpp>
+
+#include "include/uses_allocator.h"
+
+namespace ceph::async {
+namespace detail {
+template<typename T>
+struct allocator_binder_check
+{
+ typedef void type;
+};
+
+// Helper to:
+// - Apply the empty base optimization to the allocator.
+// - Perform uses_allocator construction of the target type, if required.
+
+template<typename T, typename Allocator, bool UsesAllocator>
+class allocator_binder_base;
+
+template<typename T, typename Allocator>
+class allocator_binder_base<T, Allocator, true>
+ : protected Allocator
+{
+protected:
+ template<typename A, typename U>
+ allocator_binder_base(A&& a, U&& u)
+ : Allocator(std::forward<A>(a),
+ target(ceph::make_obj_using_allocator(*this,
+ std::forward<U>(u)))) {}
+
+ T target;
+};
+
+template <typename T, typename Allocator>
+class allocator_binder_base<T, Allocator, false>
+ : protected Allocator
+
+{
+protected:
+ template<typename A, typename U>
+ allocator_binder_base(A&& a, U&& u)
+ : Allocator(std::forward<A>(a)),
+ target(std::forward<U>(u)) {}
+
+ T target;
+};
+
+// Helper to enable SFINAE on zero-argument operator() below.
+
+template<typename T, typename = void>
+struct allocator_binder_result_of0
+{
+ using type = void;
+};
+
+template<typename T>
+struct allocator_binder_result_of0<
+ T, typename allocator_binder_check<std::result_of_t<T()>>::type>
+{
+ using type = typename std::result_of_t<T()>;
+};
+} // namespace detail
+
+/// A call wrapper type to bind an allocator of type @c Allocator to
+/// an object of type @c T.
+template<typename T, typename Allocator>
+class allocator_binder
+ : private detail::allocator_binder_base<T, Allocator,
+ std::uses_allocator<T, Allocator>
+ ::value>
+{
+public:
+ /// The type of the target object.
+ using target_type = T;
+
+ /// The type of the associated allocator.
+ using allocator_type = Allocator;
+
+ /// Construct an allocator wrapper for the specified object.
+ /**
+ * This constructor is only valid if the type @c T is constructible from type
+ * @c U.
+ */
+ template<typename U>
+ allocator_binder(std::allocator_arg_t, const allocator_type& a,
+ U&& u)
+ : base_type(a, std::forward<U>(u)) {}
+
+ /// Copy constructor.
+ allocator_binder(const allocator_binder& other)
+ : base_type(other.get_allocator(), other.get()) {}
+
+ /// Construct a copy, but specify a different allocator.
+ allocator_binder(std::allocator_arg_t, const allocator_type& e,
+ const allocator_binder& other)
+ : base_type(e, other.get()) {}
+
+ /// Construct a copy of a different allocator wrapper type.
+ /**
+ * This constructor is only valid if the @c Allocator type is
+ * constructible from type @c OtherAllocator, and the type @c T is
+ * constructible from type @c U.
+ */
+ template<typename U, typename OtherAllocator>
+ allocator_binder(const allocator_binder<U, OtherAllocator>& other)
+ : base_type(other.get_allocator(), other.get()) {}
+
+ /// Construct a copy of a different allocator wrapper type, but specify a
+ /// different allocator.
+ /**
+ * This constructor is only valid if the type @c T is constructible from type
+ * @c U.
+ */
+ template<typename U, typename OtherAllocator>
+ allocator_binder(std::allocator_arg_t, const allocator_type& a,
+ const allocator_binder<U, OtherAllocator>& other)
+ : base_type(a, other.get()) {}
+
+ /// Move constructor.
+ allocator_binder(allocator_binder&& other)
+ : base_type(std::move(other.get_allocator()),
+ std::move(other.get())) {}
+
+ /// Move construct the target object, but specify a different allocator.
+ allocator_binder(std::allocator_arg_t, const allocator_type& e,
+ allocator_binder&& other)
+ : base_type(e, std::move(other.get())) {}
+
+ /// Move construct from a different allocator wrapper type.
+ template<typename U, typename OtherAllocator>
+ allocator_binder(allocator_binder<U, OtherAllocator>&& other)
+ : base_type(std::move(other.get_allocator()), std::move(other.get())) {}
+
+ /// Move construct from a different allocator wrapper type, but specify a
+ /// different allocator.
+ template<typename U, typename OtherAllocator>
+ allocator_binder(std::allocator_arg_t, const allocator_type& a,
+ allocator_binder<U, OtherAllocator>&& other)
+ : base_type(a, std::move(other.get())) {}
+
+ /// Destructor.
+ ~allocator_binder() = default;
+
+ /// Obtain a reference to the target object.
+ target_type& get() noexcept
+ {
+ return this->target;
+ }
+
+ /// Obtain a reference to the target object.
+ const target_type& get() const noexcept
+ {
+ return this->target;
+ }
+
+ /// Obtain the associated allocator.
+ allocator_type get_allocator() const noexcept {
+ return static_cast<const Allocator&>(*this);
+ }
+
+ /// Forwarding function call operator.
+ template<typename... Args>
+ decltype(auto) operator()(Args&&... args) {
+ return this->target(std::forward<Args>(args)...);
+ }
+
+ /// Forwarding function call operator.
+ template<typename... Args>
+ decltype(auto) operator()(Args&&... args) const {
+ return this->target(std::forward<Args>(args)...);
+ }
+
+
+private:
+ using base_type =
+ detail::allocator_binder_base<T, Allocator,
+ std::uses_allocator_v<T, Allocator>>;
+};
+
+/// Associate an object of type @c T with an allocator of type @c Allocator.
+template<typename Allocator, typename T>
+inline allocator_binder<typename std::decay_t<T>, Allocator>
+bind_allocator(const Allocator& a, T&& t)
+{
+ return allocator_binder<std::decay_t<T>, Allocator>(std::allocator_arg_t(),
+ a, std::forward<T>(t));
+}
+} // namespace ceph::async
+
+// Since we have an allocator_type member we shouldn't need a
+// uses_allocator specialization.
+
+namespace boost::asio {
+template<typename T, typename Allocator, typename Signature>
+class async_result<ceph::async::allocator_binder<T, Allocator>, Signature>
+{
+public:
+ using completion_handler_type =
+ ceph::async::allocator_binder<
+ typename async_result<T, Signature>::completion_handler_type, Allocator>;
+
+ using return_type = typename async_result<T, Signature>::return_type;
+
+ explicit async_result(ceph::async::allocator_binder<T, Allocator>& b)
+ : target(b.get()) {}
+
+ return_type get() {
+ return target.get();
+ }
+
+private:
+ async_result(const async_result&) = delete;
+ async_result& operator=(const async_result&) = delete;
+
+ async_result<T, Signature> target;
+};
+
+template<typename T, typename Allocator, typename Executor>
+struct associated_executor<ceph::async::allocator_binder<T, Allocator>,
+ Executor>
+{
+ using type = typename associated_executor<T, Executor>::type;
+
+ static type get(const ceph::async::allocator_binder<T, Allocator>& b,
+ Executor ex = {}) noexcept {
+ return get_associated_executor(b.get(), ex);
+ }
+};
+} // namespace boost::asio
projects / ceph.git / commitdiff