ceph/src/boost/boost/asio/windows/overlapped_ptr.hpp

   1 //
   2 // windows/overlapped_ptr.hpp
   3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 #ifndef BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP
  12 #define BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP
  13
  14 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  15 # pragma once
  16 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  17
  18 #include <boost/asio/detail/config.hpp>
  19
  20 #if defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR) \
  21   || defined(GENERATING_DOCUMENTATION)
  22
  23 #include <boost/asio/detail/noncopyable.hpp>
  24 #include <boost/asio/detail/win_iocp_overlapped_ptr.hpp>
  25 #include <boost/asio/io_context.hpp>
  26
  27 #include <boost/asio/detail/push_options.hpp>
  28
  29 namespace boost {
  30 namespace asio {
  31 namespace windows {
  32
  33 /// Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
  34 /**
  35  * A special-purpose smart pointer used to wrap an application handler so that
  36  * it can be passed as the LPOVERLAPPED argument to overlapped I/O functions.
  37  *
  38  * @par Thread Safety
  39  * @e Distinct @e objects: Safe.@n
  40  * @e Shared @e objects: Unsafe.
  41  */
  42 class overlapped_ptr
  43   : private noncopyable
  44 {
  45 public:
  46   /// Construct an empty overlapped_ptr.
  47   overlapped_ptr()
  48     : impl_()
  49   {
  50   }
  51
  52   /// Construct an overlapped_ptr to contain the specified handler.
  53   template <typename ExecutionContext, typename Handler>
  54   explicit overlapped_ptr(ExecutionContext& context,
  55       BOOST_ASIO_MOVE_ARG(Handler) handler,
  56       typename enable_if<
  57         is_convertible<ExecutionContext&, execution_context&>::value
  58       >::type* = 0)
  59     : impl_(context.get_executor(), BOOST_ASIO_MOVE_CAST(Handler)(handler))
  60   {
  61   }
  62
  63   /// Construct an overlapped_ptr to contain the specified handler.
  64   template <typename Executor, typename Handler>
  65   explicit overlapped_ptr(const Executor& ex,
  66       BOOST_ASIO_MOVE_ARG(Handler) handler,
  67       typename enable_if<
  68         execution::is_executor<Executor>::value
  69           || is_executor<Executor>::value
  70       >::type* = 0)
  71     : impl_(ex, BOOST_ASIO_MOVE_CAST(Handler)(handler))
  72   {
  73   }
  74
  75   /// Destructor automatically frees the OVERLAPPED object unless released.
  76   ~overlapped_ptr()
  77   {
  78   }
  79
  80   /// Reset to empty.
  81   void reset()
  82   {
  83     impl_.reset();
  84   }
  85
  86   /// Reset to contain the specified handler, freeing any current OVERLAPPED
  87   /// object.
  88   template <typename ExecutionContext, typename Handler>
  89   void reset(ExecutionContext& context, BOOST_ASIO_MOVE_ARG(Handler) handler,
  90       typename enable_if<
  91         is_convertible<ExecutionContext&, execution_context&>::value
  92       >::type* = 0)
  93   {
  94     impl_.reset(context.get_executor(), BOOST_ASIO_MOVE_CAST(Handler)(handler));
  95   }
  96
  97   /// Reset to contain the specified handler, freeing any current OVERLAPPED
  98   /// object.
  99   template <typename Executor, typename Handler>
 100   void reset(const Executor& ex, BOOST_ASIO_MOVE_ARG(Handler) handler,
 101       typename enable_if<
 102         execution::is_executor<Executor>::value
 103           || is_executor<Executor>::value
 104       >::type* = 0)
 105   {
 106     impl_.reset(ex, BOOST_ASIO_MOVE_CAST(Handler)(handler));
 107   }
 108
 109   /// Get the contained OVERLAPPED object.
 110   OVERLAPPED* get()
 111   {
 112     return impl_.get();
 113   }
 114
 115   /// Get the contained OVERLAPPED object.
 116   const OVERLAPPED* get() const
 117   {
 118     return impl_.get();
 119   }
 120
 121   /// Release ownership of the OVERLAPPED object.
 122   OVERLAPPED* release()
 123   {
 124     return impl_.release();
 125   }
 126
 127   /// Post completion notification for overlapped operation. Releases ownership.
 128   void complete(const boost::system::error_code& ec,
 129       std::size_t bytes_transferred)
 130   {
 131     impl_.complete(ec, bytes_transferred);
 132   }
 133
 134 private:
 135   detail::win_iocp_overlapped_ptr impl_;
 136 };
 137
 138 } // namespace windows
 139 } // namespace asio
 140 } // namespace boost
 141
 142 #include <boost/asio/detail/pop_options.hpp>
 143
 144 #endif // defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
 145        //   || defined(GENERATING_DOCUMENTATION)
 146
 147 #endif // BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP