boost/asio/detail/win_iocp_overlapped_ptr.hpp

   1 //
   2 // win_iocp_overlapped_ptr.hpp
   3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2008 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_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP
  12 #define BOOST_ASIO_DETAIL_WIN_IOCP_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/push_options.hpp>
  19
  20 #include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
  21
  22 #if defined(BOOST_ASIO_HAS_IOCP)
  23
  24 #include <boost/asio/detail/noncopyable.hpp>
  25 #include <boost/asio/detail/win_iocp_io_service.hpp>
  26
  27 namespace boost {
  28 namespace asio {
  29 namespace detail {
  30
  31 // Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
  32 class win_iocp_overlapped_ptr
  33   : private noncopyable
  34 {
  35 public:
  36   // Construct an empty win_iocp_overlapped_ptr.
  37   win_iocp_overlapped_ptr()
  38     : ptr_(0)
  39   {
  40   }
  41
  42   // Construct an win_iocp_overlapped_ptr to contain the specified handler.
  43   template <typename Handler>
  44   explicit win_iocp_overlapped_ptr(
  45       boost::asio::io_service& io_service, Handler handler)
  46     : ptr_(0)
  47   {
  48     this->reset(io_service, handler);
  49   }
  50
  51   // Destructor automatically frees the OVERLAPPED object unless released.
  52   ~win_iocp_overlapped_ptr()
  53   {
  54     reset();
  55   }
  56
  57   // Reset to empty.
  58   void reset()
  59   {
  60     if (ptr_)
  61     {
  62       ptr_->destroy();
  63       ptr_ = 0;
  64     }
  65   }
  66
  67   // Reset to contain the specified handler, freeing any current OVERLAPPED
  68   // object.
  69   template <typename Handler>
  70   void reset(boost::asio::io_service& io_service, Handler handler)
  71   {
  72     typedef overlapped_operation<Handler> value_type;
  73     typedef handler_alloc_traits<Handler, value_type> alloc_traits;
  74     raw_handler_ptr<alloc_traits> raw_ptr(handler);
  75     handler_ptr<alloc_traits> ptr(raw_ptr, io_service.impl_, handler);
  76     reset();
  77     ptr_ = ptr.release();
  78   }
  79
  80   // Get the contained OVERLAPPED object.
  81   OVERLAPPED* get()
  82   {
  83     return ptr_;
  84   }
  85
  86   // Get the contained OVERLAPPED object.
  87   const OVERLAPPED* get() const
  88   {
  89     return ptr_;
  90   }
  91
  92   // Release ownership of the OVERLAPPED object.
  93   OVERLAPPED* release()
  94   {
  95     OVERLAPPED* tmp = ptr_;
  96     ptr_ = 0;
  97     return tmp;
  98   }
  99
 100   // Post completion notification for overlapped operation. Releases ownership.
 101   void complete(const boost::system::error_code& ec,
 102       std::size_t bytes_transferred)
 103   {
 104     if (ptr_)
 105     {
 106       ptr_->ec_ = ec;
 107       ptr_->io_service_.post_completion(ptr_, 0,
 108           static_cast<DWORD>(bytes_transferred));
 109       ptr_ = 0;
 110     }
 111   }
 112
 113 private:
 114   struct overlapped_operation_base
 115     : public win_iocp_io_service::operation
 116   {
 117     overlapped_operation_base(win_iocp_io_service& io_service,
 118         invoke_func_type invoke_func, destroy_func_type destroy_func)
 119       : win_iocp_io_service::operation(io_service, invoke_func, destroy_func),
 120         io_service_(io_service)
 121     {
 122       io_service_.work_started();
 123     }
 124
 125     ~overlapped_operation_base()
 126     {
 127       io_service_.work_finished();
 128     }
 129
 130     win_iocp_io_service& io_service_;
 131     boost::system::error_code ec_;
 132   };
 133
 134   template <typename Handler>
 135   struct overlapped_operation
 136     : public overlapped_operation_base
 137   {
 138     overlapped_operation(win_iocp_io_service& io_service,
 139         Handler handler)
 140       : overlapped_operation_base(io_service,
 141           &overlapped_operation<Handler>::do_completion_impl,
 142           &overlapped_operation<Handler>::destroy_impl),
 143         handler_(handler)
 144     {
 145     }
 146
 147   private:
 148     // Prevent copying and assignment.
 149     overlapped_operation(const overlapped_operation&);
 150     void operator=(const overlapped_operation&);
 151
 152     static void do_completion_impl(win_iocp_io_service::operation* op,
 153         DWORD last_error, size_t bytes_transferred)
 154     {
 155       // Take ownership of the operation object.
 156       typedef overlapped_operation<Handler> op_type;
 157       op_type* handler_op(static_cast<op_type*>(op));
 158       typedef handler_alloc_traits<Handler, op_type> alloc_traits;
 159       handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
 160
 161       // Make a copy of the handler and error_code so that the memory can be
 162       // deallocated before the upcall is made.
 163       Handler handler(handler_op->handler_);
 164       boost::system::error_code ec(handler_op->ec_);
 165       if (last_error)
 166         ec = boost::system::error_code(last_error,
 167             boost::asio::error::get_system_category());
 168
 169       // Free the memory associated with the handler.
 170       ptr.reset();
 171
 172       // Make the upcall.
 173       boost_asio_handler_invoke_helpers::invoke(
 174           bind_handler(handler, ec, bytes_transferred), &handler);
 175     }
 176
 177     static void destroy_impl(win_iocp_io_service::operation* op)
 178     {
 179       // Take ownership of the operation object.
 180       typedef overlapped_operation<Handler> op_type;
 181       op_type* handler_op(static_cast<op_type*>(op));
 182       typedef handler_alloc_traits<Handler, op_type> alloc_traits;
 183       handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
 184
 185       // A sub-object of the handler may be the true owner of the memory
 186       // associated with the handler. Consequently, a local copy of the handler
 187       // is required to ensure that any owning sub-object remains valid until
 188       // after we have deallocated the memory here.
 189       Handler handler(handler_op->handler_);
 190       (void)handler;
 191
 192       // Free the memory associated with the handler.
 193       ptr.reset();
 194     }
 195
 196     Handler handler_;
 197   };
 198
 199   overlapped_operation_base* ptr_;
 200 };
 201
 202 } // namespace detail
 203 } // namespace asio
 204 } // namespace boost
 205
 206 #endif // defined(BOOST_ASIO_HAS_IOCP)
 207
 208 #include <boost/asio/detail/pop_options.hpp>
 209
 210 #endif // BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP