//------------------------------------------------------------------------------ /* This file is part of Beast: https://github.com/vinniefalco/Beast Copyright 2013, Vinnie Falco Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ //============================================================================== #ifndef BEAST_SOCKETWRAPPER_H_INCLUDED #define BEAST_SOCKETWRAPPER_H_INCLUDED /** Wraps a reference to any object and exports all availble interfaces. If the object does not support an interface, calling those member functions will behave as if a pure virtual was called. Note that only a reference to the underlying is stored. Management of the lifetime of the object is controlled by the caller. Examples of the type of Object: asio::ip::tcp::socket arg must be an io_context SocketWrapper will create and take ownership of the tcp::socket this_layer_type will be tcp::socket next_layer () returns a asio::ip::tcp::socket& lowest_layer () returns a asio::ip::tcp::socket& asio::ip::tcp::socket& arg must be an existing socket& The caller owns the underlying socket object this_layer_type will be tcp::socket next_layer () returns a asio::ip::tcp::socket& lowest_layer () returns a asio::ip::tcp::socket& asio::ssl::stream arg must be an io_context SocketWrapper creates and takes ownership of the ssl::stream WrappedObjecType will be asio::ssl::stream next_layer () returns a asio::ip::tcp::socket& lowest_layer () returns a asio::ip::tcp::socket& asio::ssl::stream arg must be an existing socket& The caller owns the socket, but SocketWrapper owns the ssl::stream this_layer_type will be asio::ssl::stream next_layer () returns a asio::ip::tcp::socket& lowest_layer () returns a asio::ip::tcp::socket& asio::ssl::stream > > This makes my head explode */ //------------------------------------------------------------------------------ namespace SocketWrapperMemberChecks { template struct EnableIf : boost::false_type { }; template <> struct EnableIf : boost::true_type { }; BEAST_DEFINE_IS_CALL_POSSIBLE(has_get_io_service, get_io_service); BEAST_DEFINE_IS_CALL_POSSIBLE(has_lowest_layer, lowest_layer); BEAST_DEFINE_IS_CALL_POSSIBLE(has_cancel, cancel); BEAST_DEFINE_IS_CALL_POSSIBLE(has_shutdown, shutdown); BEAST_DEFINE_IS_CALL_POSSIBLE(has_close, close); BEAST_DEFINE_IS_CALL_POSSIBLE(has_accept, accept); BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_accept, async_accept); BEAST_DEFINE_IS_CALL_POSSIBLE(has_read_some, read_some); BEAST_DEFINE_IS_CALL_POSSIBLE(has_write_some, write_some); BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_read_some, async_read_some); BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_write_some, async_write_some); BEAST_DEFINE_IS_CALL_POSSIBLE(has_handshake, handshake); BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_handshake, async_handshake); BEAST_DEFINE_IS_CALL_POSSIBLE(has_async_shutdown, async_shutdown); // Extracts the underlying socket type from the protocol of another asio object template struct native_socket { typedef void* socket_type; inline native_socket (Socket&) : m_socket (nullptr) { SocketBase::pure_virtual (); } inline socket_type& get () { SocketBase::pure_virtual (); return m_socket; } inline socket_type& operator-> () { return get (); } private: socket_type m_socket; }; // Enabled if T::protocol_type::socket exists as a type template struct native_socket >::type> { typedef typename T::protocol_type::socket socket_type; inline native_socket (Socket& peer) : m_socket_ptr (&peer.native_handle ()) { } inline socket_type& get () noexcept { return *m_socket_ptr; } inline socket_type& operator-> () noexcept { return get (); } private: socket_type* m_socket_ptr; }; }; //------------------------------------------------------------------------------ template class SocketWrapper : public Socket , public Uncopyable { public: template explicit SocketWrapper (Arg& arg) : m_object (arg) { } template SocketWrapper (Arg1& arg1, Arg2& arg2) : m_object (arg1, arg2) { } //-------------------------------------------------------------------------- // // accessors // // If you have access to the SocketWrapper itself instead of the Socket, // then these types and functions become available to you. If you want // to access things like next_layer() and lowest_layer() directly on the // underlying object, you might write: // // wrapper->this_layer().next_layer() // // We can't expose native versions of next_layer_type or next_layer() // because they may not exist in the underlying object and would cause // a compile error if we tried. // /** The type of the object being wrapped. */ typedef typename boost::remove_reference