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

   1 //
   2 // windows/overlapped_ptr.hpp
   3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2019 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         is_executor<Executor>::value
  69       >::type* = 0)
  70     : impl_(ex, BOOST_ASIO_MOVE_CAST(Handler)(handler))
  71   {
  72   }
  73
  74   /// Destructor automatically frees the OVERLAPPED object unless released.
  75   ~overlapped_ptr()
  76   {
  77   }
  78
  79   /// Reset to empty.
  80   void reset()
  81   {
  82     impl_.reset();
  83   }
  84
  85   /// Reset to contain the specified handler, freeing any current OVERLAPPED
  86   /// object.
  87   template <typename ExecutionContext, typename Handler>
  88   void reset(ExecutionContext& context, BOOST_ASIO_MOVE_ARG(Handler) handler,
  89       typename enable_if<
  90         is_convertible<ExecutionContext&, execution_context&>::value
  91       >::type* = 0)
  92   {
  93     impl_.reset(context.get_executor(), BOOST_ASIO_MOVE_CAST(Handler)(handler));
  94   }
  95
  96   /// Reset to contain the specified handler, freeing any current OVERLAPPED
  97   /// object.
  98   template <typename Executor, typename Handler>
  99   void reset(const Executor& ex, BOOST_ASIO_MOVE_ARG(Handler) handler,
 100       typename enable_if<
 101         is_executor<Executor>::value
 102       >::type* = 0)
 103   {
 104     impl_.reset(ex, BOOST_ASIO_MOVE_CAST(Handler)(handler));
 105   }
 106
 107   /// Get the contained OVERLAPPED object.
 108   OVERLAPPED* get()
 109   {
 110     return impl_.get();
 111   }
 112
 113   /// Get the contained OVERLAPPED object.
 114   const OVERLAPPED* get() const
 115   {
 116     return impl_.get();
 117   }
 118
 119   /// Release ownership of the OVERLAPPED object.
 120   OVERLAPPED* release()
 121   {
 122     return impl_.release();
 123   }
 124
 125   /// Post completion notification for overlapped operation. Releases ownership.
 126   void complete(const boost::system::error_code& ec,
 127       std::size_t bytes_transferred)
 128   {
 129     impl_.complete(ec, bytes_transferred);
 130   }
 131
 132 private:
 133   detail::win_iocp_overlapped_ptr impl_;
 134 };
 135
 136 } // namespace windows
 137 } // namespace asio
 138 } // namespace boost
 139
 140 #include <boost/asio/detail/pop_options.hpp>
 141
 142 #endif // defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
 143        //   || defined(GENERATING_DOCUMENTATION)
 144
 145 #endif // BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP