asio/detail/completion_payload.hpp

0001 //
0002 // detail/completion_payload.hpp
0003 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
0004 //
0005 // Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
0006 //
0007 // Distributed under the Boost Software License, Version 1.0. (See accompanying
0008 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0009 //
0010
0011 #ifndef BOOST_ASIO_DETAIL_COMPLETION_PAYLOAD_HPP
0012 #define BOOST_ASIO_DETAIL_COMPLETION_PAYLOAD_HPP
0013
0014 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
0015 # pragma once
0016 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
0017
0018 #include <boost/asio/detail/config.hpp>
0019 #include <boost/asio/detail/type_traits.hpp>
0020 #include <boost/system/error_code.hpp>
0021 #include <boost/asio/detail/completion_message.hpp>
0022
0023 #if defined(BOOST_ASIO_HAS_STD_VARIANT)
0024 # include <variant>
0025 #else // defined(BOOST_ASIO_HAS_STD_VARIANT)
0026 # include <new>
0027 #endif // defined(BOOST_ASIO_HAS_STD_VARIANT)
0028
0029 #include <boost/asio/detail/push_options.hpp>
0030
0031 namespace boost {
0032 namespace asio {
0033 namespace detail {
0034
0035 template <typename... Signatures>
0036 class completion_payload;
0037
0038 template <typename R>
0039 class completion_payload<R()>
0040 {
0041 public:
0042   explicit completion_payload(completion_message<R()>)
0043   {
0044   }
0045
0046   template <typename Handler>
0047   void receive(Handler& handler)
0048   {
0049     static_cast<Handler&&>(handler)();
0050   }
0051 };
0052
0053 template <typename Signature>
0054 class completion_payload<Signature>
0055 {
0056 public:
0057   completion_payload(completion_message<Signature>&& m)
0058     : message_(static_cast<completion_message<Signature>&&>(m))
0059   {
0060   }
0061
0062   template <typename Handler>
0063   void receive(Handler& handler)
0064   {
0065     message_.receive(handler);
0066   }
0067
0068 private:
0069   completion_message<Signature> message_;
0070 };
0071
0072 #if defined(BOOST_ASIO_HAS_STD_VARIANT)
0073
0074 template <typename... Signatures>
0075 class completion_payload
0076 {
0077 public:
0078   template <typename Signature>
0079   completion_payload(completion_message<Signature>&& m)
0080     : message_(static_cast<completion_message<Signature>&&>(m))
0081   {
0082   }
0083
0084   template <typename Handler>
0085   void receive(Handler& handler)
0086   {
0087     std::visit(
0088         [&](auto& message)
0089         {
0090           message.receive(handler);
0091         }, message_);
0092   }
0093
0094 private:
0095   std::variant<completion_message<Signatures>...> message_;
0096 };
0097
0098 #else // defined(BOOST_ASIO_HAS_STD_VARIANT)
0099
0100 template <typename R1, typename R2>
0101 class completion_payload<R1(), R2(boost::system::error_code)>
0102 {
0103 public:
0104   typedef completion_message<R1()> void_message_type;
0105   typedef completion_message<R2(boost::system::error_code)> error_message_type;
0106
0107   completion_payload(void_message_type&&)
0108     : message_(0, boost::system::error_code()),
0109       empty_(true)
0110   {
0111   }
0112
0113   completion_payload(error_message_type&& m)
0114     : message_(static_cast<error_message_type&&>(m)),
0115       empty_(false)
0116   {
0117   }
0118
0119   template <typename Handler>
0120   void receive(Handler& handler)
0121   {
0122     if (empty_)
0123       completion_message<R1()>(0).receive(handler);
0124     else
0125       message_.receive(handler);
0126   }
0127
0128 private:
0129   error_message_type message_;
0130   bool empty_;
0131 };
0132
0133 template <typename Sig1, typename Sig2>
0134 class completion_payload<Sig1, Sig2>
0135 {
0136 public:
0137   typedef completion_message<Sig1> message_1_type;
0138   typedef completion_message<Sig2> message_2_type;
0139
0140   completion_payload(message_1_type&& m)
0141     : index_(1)
0142   {
0143     new (&storage_.message_1_) message_1_type(static_cast<message_1_type&&>(m));
0144   }
0145
0146   completion_payload(message_2_type&& m)
0147     : index_(2)
0148   {
0149     new (&storage_.message_2_) message_2_type(static_cast<message_2_type&&>(m));
0150   }
0151
0152   completion_payload(completion_payload&& other)
0153     : index_(other.index_)
0154   {
0155     switch (index_)
0156     {
0157     case 1:
0158       new (&storage_.message_1_) message_1_type(
0159           static_cast<message_1_type&&>(other.storage_.message_1_));
0160       break;
0161     case 2:
0162       new (&storage_.message_2_) message_2_type(
0163           static_cast<message_2_type&&>(other.storage_.message_2_));
0164       break;
0165     default:
0166       break;
0167     }
0168   }
0169
0170   ~completion_payload()
0171   {
0172     switch (index_)
0173     {
0174     case 1:
0175       storage_.message_1_.~message_1_type();
0176       break;
0177     case 2:
0178       storage_.message_2_.~message_2_type();
0179       break;
0180     default:
0181       break;
0182     }
0183   }
0184
0185   template <typename Handler>
0186   void receive(Handler& handler)
0187   {
0188     switch (index_)
0189     {
0190     case 1:
0191       storage_.message_1_.receive(handler);
0192       break;
0193     case 2:
0194       storage_.message_2_.receive(handler);
0195       break;
0196     default:
0197       break;
0198     }
0199   }
0200
0201 private:
0202   union storage
0203   {
0204     storage() {}
0205     ~storage() {}
0206
0207     char dummy_;
0208     message_1_type message_1_;
0209     message_2_type message_2_;
0210   } storage_;
0211   unsigned char index_;
0212 };
0213
0214 #endif // defined(BOOST_ASIO_HAS_STD_VARIANT)
0215
0216 } // namespace detail
0217 } // namespace asio
0218 } // namespace boost
0219
0220 #include <boost/asio/detail/pop_options.hpp>
0221
0222 #endif // BOOST_ASIO_DETAIL_COMPLETION_PAYLOAD_HPP