git.sesse.net Git - casparcg/blob - dependencies64/boost/boost/asio/socket_acceptor_service.hpp

   1 //
   2 // socket_acceptor_service.hpp
   3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2011 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_SOCKET_ACCEPTOR_SERVICE_HPP
  12 #define BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_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 #include <boost/asio/basic_socket.hpp>
  20 #include <boost/asio/error.hpp>
  21 #include <boost/asio/io_service.hpp>
  22
  23 #if defined(BOOST_ASIO_HAS_IOCP)
  24 # include <boost/asio/detail/win_iocp_socket_service.hpp>
  25 #else
  26 # include <boost/asio/detail/reactive_socket_service.hpp>
  27 #endif
  28
  29 #include <boost/asio/detail/push_options.hpp>
  30
  31 namespace boost {
  32 namespace asio {
  33
  34 /// Default service implementation for a socket acceptor.
  35 template <typename Protocol>
  36 class socket_acceptor_service
  37 #if defined(GENERATING_DOCUMENTATION)
  38   : public boost::asio::io_service::service
  39 #else
  40   : public boost::asio::detail::service_base<socket_acceptor_service<Protocol> >
  41 #endif
  42 {
  43 public:
  44 #if defined(GENERATING_DOCUMENTATION)
  45   /// The unique service identifier.
  46   static boost::asio::io_service::id id;
  47 #endif
  48
  49   /// The protocol type.
  50   typedef Protocol protocol_type;
  51
  52   /// The endpoint type.
  53   typedef typename protocol_type::endpoint endpoint_type;
  54
  55 private:
  56   // The type of the platform-specific implementation.
  57 #if defined(BOOST_ASIO_HAS_IOCP)
  58   typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
  59 #else
  60   typedef detail::reactive_socket_service<Protocol> service_impl_type;
  61 #endif
  62
  63 public:
  64   /// The native type of the socket acceptor.
  65 #if defined(GENERATING_DOCUMENTATION)
  66   typedef implementation_defined implementation_type;
  67 #else
  68   typedef typename service_impl_type::implementation_type implementation_type;
  69 #endif
  70
  71   /// (Deprecated: Use native_handle_type.) The native acceptor type.
  72 #if defined(GENERATING_DOCUMENTATION)
  73   typedef implementation_defined native_type;
  74 #else
  75   typedef typename service_impl_type::native_handle_type native_type;
  76 #endif
  77
  78   /// The native acceptor type.
  79 #if defined(GENERATING_DOCUMENTATION)
  80   typedef implementation_defined native_handle_type;
  81 #else
  82   typedef typename service_impl_type::native_handle_type native_handle_type;
  83 #endif
  84
  85   /// Construct a new socket acceptor service for the specified io_service.
  86   explicit socket_acceptor_service(boost::asio::io_service& io_service)
  87     : boost::asio::detail::service_base<
  88         socket_acceptor_service<Protocol> >(io_service),
  89       service_impl_(io_service)
  90   {
  91   }
  92
  93   /// Construct a new socket acceptor implementation.
  94   void construct(implementation_type& impl)
  95   {
  96     service_impl_.construct(impl);
  97   }
  98
  99 #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 100   /// Move-construct a new socket acceptor implementation.
 101   void move_construct(implementation_type& impl,
 102       implementation_type& other_impl)
 103   {
 104     service_impl_.move_construct(impl, other_impl);
 105   }
 106
 107   /// Move-assign from another socket acceptor implementation.
 108   void move_assign(implementation_type& impl,
 109       socket_acceptor_service& other_service,
 110       implementation_type& other_impl)
 111   {
 112     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
 113   }
 114 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 115
 116   /// Destroy a socket acceptor implementation.
 117   void destroy(implementation_type& impl)
 118   {
 119     service_impl_.destroy(impl);
 120   }
 121
 122   /// Open a new socket acceptor implementation.
 123   boost::system::error_code open(implementation_type& impl,
 124       const protocol_type& protocol, boost::system::error_code& ec)
 125   {
 126     return service_impl_.open(impl, protocol, ec);
 127   }
 128
 129   /// Assign an existing native acceptor to a socket acceptor.
 130   boost::system::error_code assign(implementation_type& impl,
 131       const protocol_type& protocol, const native_handle_type& native_acceptor,
 132       boost::system::error_code& ec)
 133   {
 134     return service_impl_.assign(impl, protocol, native_acceptor, ec);
 135   }
 136
 137   /// Determine whether the acceptor is open.
 138   bool is_open(const implementation_type& impl) const
 139   {
 140     return service_impl_.is_open(impl);
 141   }
 142
 143   /// Cancel all asynchronous operations associated with the acceptor.
 144   boost::system::error_code cancel(implementation_type& impl,
 145       boost::system::error_code& ec)
 146   {
 147     return service_impl_.cancel(impl, ec);
 148   }
 149
 150   /// Bind the socket acceptor to the specified local endpoint.
 151   boost::system::error_code bind(implementation_type& impl,
 152       const endpoint_type& endpoint, boost::system::error_code& ec)
 153   {
 154     return service_impl_.bind(impl, endpoint, ec);
 155   }
 156
 157   /// Place the socket acceptor into the state where it will listen for new
 158   /// connections.
 159   boost::system::error_code listen(implementation_type& impl, int backlog,
 160       boost::system::error_code& ec)
 161   {
 162     return service_impl_.listen(impl, backlog, ec);
 163   }
 164
 165   /// Close a socket acceptor implementation.
 166   boost::system::error_code close(implementation_type& impl,
 167       boost::system::error_code& ec)
 168   {
 169     return service_impl_.close(impl, ec);
 170   }
 171
 172   /// (Deprecated: Use native_handle().) Get the native acceptor implementation.
 173   native_type native(implementation_type& impl)
 174   {
 175     return service_impl_.native_handle(impl);
 176   }
 177
 178   /// Get the native acceptor implementation.
 179   native_handle_type native_handle(implementation_type& impl)
 180   {
 181     return service_impl_.native_handle(impl);
 182   }
 183
 184   /// Set a socket option.
 185   template <typename SettableSocketOption>
 186   boost::system::error_code set_option(implementation_type& impl,
 187       const SettableSocketOption& option, boost::system::error_code& ec)
 188   {
 189     return service_impl_.set_option(impl, option, ec);
 190   }
 191
 192   /// Get a socket option.
 193   template <typename GettableSocketOption>
 194   boost::system::error_code get_option(const implementation_type& impl,
 195       GettableSocketOption& option, boost::system::error_code& ec) const
 196   {
 197     return service_impl_.get_option(impl, option, ec);
 198   }
 199
 200   /// Perform an IO control command on the socket.
 201   template <typename IoControlCommand>
 202   boost::system::error_code io_control(implementation_type& impl,
 203       IoControlCommand& command, boost::system::error_code& ec)
 204   {
 205     return service_impl_.io_control(impl, command, ec);
 206   }
 207
 208   /// Gets the non-blocking mode of the acceptor.
 209   bool non_blocking(const implementation_type& impl) const
 210   {
 211     return service_impl_.non_blocking(impl);
 212   }
 213
 214   /// Sets the non-blocking mode of the acceptor.
 215   boost::system::error_code non_blocking(implementation_type& impl,
 216       bool mode, boost::system::error_code& ec)
 217   {
 218     return service_impl_.non_blocking(impl, mode, ec);
 219   }
 220
 221   /// Gets the non-blocking mode of the native acceptor implementation.
 222   bool native_non_blocking(const implementation_type& impl) const
 223   {
 224     return service_impl_.native_non_blocking(impl);
 225   }
 226
 227   /// Sets the non-blocking mode of the native acceptor implementation.
 228   boost::system::error_code native_non_blocking(implementation_type& impl,
 229       bool mode, boost::system::error_code& ec)
 230   {
 231     return service_impl_.native_non_blocking(impl, mode, ec);
 232   }
 233
 234   /// Get the local endpoint.
 235   endpoint_type local_endpoint(const implementation_type& impl,
 236       boost::system::error_code& ec) const
 237   {
 238     return service_impl_.local_endpoint(impl, ec);
 239   }
 240
 241   /// Accept a new connection.
 242   template <typename SocketService>
 243   boost::system::error_code accept(implementation_type& impl,
 244       basic_socket<protocol_type, SocketService>& peer,
 245       endpoint_type* peer_endpoint, boost::system::error_code& ec)
 246   {
 247     return service_impl_.accept(impl, peer, peer_endpoint, ec);
 248   }
 249
 250   /// Start an asynchronous accept.
 251   template <typename SocketService, typename AcceptHandler>
 252   void async_accept(implementation_type& impl,
 253       basic_socket<protocol_type, SocketService>& peer,
 254       endpoint_type* peer_endpoint,
 255       BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
 256   {
 257     service_impl_.async_accept(impl, peer, peer_endpoint,
 258         BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
 259   }
 260
 261 private:
 262   // Destroy all user-defined handler objects owned by the service.
 263   void shutdown_service()
 264   {
 265     service_impl_.shutdown_service();
 266   }
 267
 268   // The platform-specific implementation.
 269   service_impl_type service_impl_;
 270 };
 271
 272 } // namespace asio
 273 } // namespace boost
 274
 275 #include <boost/asio/detail/pop_options.hpp>
 276
 277 #endif // BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP