?????????? ?????????

?????????? ????????? - ??????????????? - /usr/include/boost/asio/posix/basic_descriptor.hpp

???????
// // posix/basic_descriptor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_HPP #define BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \ \|\| defined(GENERATING_DOCUMENTATION) #include <boost/asio/any_io_executor.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/detail/handler_type_requirements.hpp> #include <boost/asio/detail/io_object_impl.hpp> #include <boost/asio/detail/non_const_lvalue.hpp> #include <boost/asio/detail/reactive_descriptor_service.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/posix/descriptor_base.hpp> #if defined(BOOST_ASIO_HAS_MOVE) # include <utility> #endif // defined(BOOST_ASIO_HAS_MOVE) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace posix { /// Provides POSIX descriptor functionality. /** * The posix::basic_descriptor class template provides the ability to wrap a * POSIX descriptor. * * @par Thread Safety * @e Distinct @e objects: Safe.@n * @e Shared @e objects: Unsafe. / template <typename Executor = any_io_executor> class basic_descriptor : public descriptor_base { public: /// The type of the executor associated with the object. typedef Executor executor_type; /// Rebinds the descriptor type to another executor. template <typename Executor1> struct rebind_executor { /// The descriptor type when rebound to the specified executor. typedef basic_descriptor<Executor1> other; }; /// The native representation of a descriptor. #if defined(GENERATING_DOCUMENTATION) typedef implementation_defined native_handle_type; #else typedef detail::reactive_descriptor_service::native_handle_type native_handle_type; #endif /// A descriptor is always the lowest layer. typedef basic_descriptor lowest_layer_type; /// Construct a descriptor without opening it. /* * This constructor creates a descriptor without opening it. * * @param ex The I/O executor that the descriptor will use, by default, to * dispatch handlers for any asynchronous operations performed on the * descriptor. / explicit basic_descriptor(const executor_type& ex) : impl_(ex) { } /// Construct a descriptor without opening it. /* * This constructor creates a descriptor without opening it. * * @param context An execution context which provides the I/O executor that * the descriptor will use, by default, to dispatch handlers for any * asynchronous operations performed on the descriptor. / template <typename ExecutionContext> explicit basic_descriptor(ExecutionContext& context, typename enable_if< is_convertible<ExecutionContext&, execution_context&>::value >::type = 0) : impl_(context) { } /// Construct a descriptor on an existing native descriptor. /** * This constructor creates a descriptor object to hold an existing native * descriptor. * * @param ex The I/O executor that the descriptor will use, by default, to * dispatch handlers for any asynchronous operations performed on the * descriptor. * * @param native_descriptor A native descriptor. * * @throws boost::system::system_error Thrown on failure. / basic_descriptor(const executor_type& ex, const native_handle_type& native_descriptor) : impl_(ex) { boost::system::error_code ec; impl_.get_service().assign(impl_.get_implementation(), native_descriptor, ec); boost::asio::detail::throw_error(ec, "assign"); } /// Construct a descriptor on an existing native descriptor. /* * This constructor creates a descriptor object to hold an existing native * descriptor. * * @param context An execution context which provides the I/O executor that * the descriptor will use, by default, to dispatch handlers for any * asynchronous operations performed on the descriptor. * * @param native_descriptor A native descriptor. * * @throws boost::system::system_error Thrown on failure. / template <typename ExecutionContext> basic_descriptor(ExecutionContext& context, const native_handle_type& native_descriptor, typename enable_if< is_convertible<ExecutionContext&, execution_context&>::value >::type = 0) : impl_(context) { boost::system::error_code ec; impl_.get_service().assign(impl_.get_implementation(), native_descriptor, ec); boost::asio::detail::throw_error(ec, "assign"); } #if defined(BOOST_ASIO_HAS_MOVE) \|\| defined(GENERATING_DOCUMENTATION) /// Move-construct a descriptor from another. /** * This constructor moves a descriptor from one object to another. * * @param other The other descriptor object from which the move will * occur. * * @note Following the move, the moved-from object is in the same state as if * constructed using the @c basic_descriptor(const executor_type&) * constructor. / basic_descriptor(basic_descriptor&& other) BOOST_ASIO_NOEXCEPT : impl_(std::move(other.impl_)) { } /// Move-assign a descriptor from another. /* * This assignment operator moves a descriptor from one object to another. * * @param other The other descriptor object from which the move will * occur. * * @note Following the move, the moved-from object is in the same state as if * constructed using the @c basic_descriptor(const executor_type&) * constructor. / basic_descriptor& operator=(basic_descriptor&& other) { impl_ = std::move(other.impl_); return this; } #endif // defined(BOOST_ASIO_HAS_MOVE) \|\| defined(GENERATING_DOCUMENTATION) /// Get the executor associated with the object. executor_type get_executor() BOOST_ASIO_NOEXCEPT { return impl_.get_executor(); } /// Get a reference to the lowest layer. /** * This function returns a reference to the lowest layer in a stack of * layers. Since a descriptor cannot contain any further layers, it * simply returns a reference to itself. * * @return A reference to the lowest layer in the stack of layers. Ownership * is not transferred to the caller. / lowest_layer_type& lowest_layer() { return this; } /// Get a const reference to the lowest layer. /** * This function returns a const reference to the lowest layer in a stack of * layers. Since a descriptor cannot contain any further layers, it * simply returns a reference to itself. * * @return A const reference to the lowest layer in the stack of layers. * Ownership is not transferred to the caller. / const lowest_layer_type& lowest_layer() const { return this; } /// Assign an existing native descriptor to the descriptor. /* * This function opens the descriptor to hold an existing native descriptor. * * @param native_descriptor A native descriptor. * * @throws boost::system::system_error Thrown on failure. / void assign(const native_handle_type& native_descriptor) { boost::system::error_code ec; impl_.get_service().assign(impl_.get_implementation(), native_descriptor, ec); boost::asio::detail::throw_error(ec, "assign"); } /// Assign an existing native descriptor to the descriptor. / * This function opens the descriptor to hold an existing native descriptor. * * @param native_descriptor A native descriptor. * * @param ec Set to indicate what error occurred, if any. / BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_descriptor, boost::system::error_code& ec) { impl_.get_service().assign( impl_.get_implementation(), native_descriptor, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } /// Determine whether the descriptor is open. bool is_open() const { return impl_.get_service().is_open(impl_.get_implementation()); } /// Close the descriptor. /* * This function is used to close the descriptor. Any asynchronous read or * write operations will be cancelled immediately, and will complete with the * boost::asio::error::operation_aborted error. * * @throws boost::system::system_error Thrown on failure. Note that, even if * the function indicates an error, the underlying descriptor is closed. / void close() { boost::system::error_code ec; impl_.get_service().close(impl_.get_implementation(), ec); boost::asio::detail::throw_error(ec, "close"); } /// Close the descriptor. /* * This function is used to close the descriptor. Any asynchronous read or * write operations will be cancelled immediately, and will complete with the * boost::asio::error::operation_aborted error. * * @param ec Set to indicate what error occurred, if any. Note that, even if * the function indicates an error, the underlying descriptor is closed. / BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec) { impl_.get_service().close(impl_.get_implementation(), ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } /// Get the native descriptor representation. /* * This function may be used to obtain the underlying representation of the * descriptor. This is intended to allow access to native descriptor * functionality that is not otherwise provided. / native_handle_type native_handle() { return impl_.get_service().native_handle(impl_.get_implementation()); } /// Release ownership of the native descriptor implementation. /* * This function may be used to obtain the underlying representation of the * descriptor. After calling this function, @c is_open() returns false. The * caller is responsible for closing the descriptor. * * All outstanding asynchronous read or write operations will finish * immediately, and the handlers for cancelled operations will be passed the * boost::asio::error::operation_aborted error. / native_handle_type release() { return impl_.get_service().release(impl_.get_implementation()); } /// Cancel all asynchronous operations associated with the descriptor. /* * This function causes all outstanding asynchronous read or write operations * to finish immediately, and the handlers for cancelled operations will be * passed the boost::asio::error::operation_aborted error. * * @throws boost::system::system_error Thrown on failure. / void cancel() { boost::system::error_code ec; impl_.get_service().cancel(impl_.get_implementation(), ec); boost::asio::detail::throw_error(ec, "cancel"); } /// Cancel all asynchronous operations associated with the descriptor. /* * This function causes all outstanding asynchronous read or write operations * to finish immediately, and the handlers for cancelled operations will be * passed the boost::asio::error::operation_aborted error. * * @param ec Set to indicate what error occurred, if any. / BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec) { impl_.get_service().cancel(impl_.get_implementation(), ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } /// Perform an IO control command on the descriptor. /* * This function is used to execute an IO control command on the descriptor. * * @param command The IO control command to be performed on the descriptor. * * @throws boost::system::system_error Thrown on failure. * * @sa IoControlCommand @n * boost::asio::posix::descriptor_base::bytes_readable @n * boost::asio::posix::descriptor_base::non_blocking_io * * @par Example * Getting the number of bytes ready to read: * @code * boost::asio::posix::stream_descriptor descriptor(my_context); * ... * boost::asio::posix::stream_descriptor::bytes_readable command; * descriptor.io_control(command); * std::size_t bytes_readable = command.get(); * @endcode / template <typename IoControlCommand> void io_control(IoControlCommand& command) { boost::system::error_code ec; impl_.get_service().io_control(impl_.get_implementation(), command, ec); boost::asio::detail::throw_error(ec, "io_control"); } /// Perform an IO control command on the descriptor. /* * This function is used to execute an IO control command on the descriptor. * * @param command The IO control command to be performed on the descriptor. * * @param ec Set to indicate what error occurred, if any. * * @sa IoControlCommand @n * boost::asio::posix::descriptor_base::bytes_readable @n * boost::asio::posix::descriptor_base::non_blocking_io * * @par Example * Getting the number of bytes ready to read: * @code * boost::asio::posix::stream_descriptor descriptor(my_context); * ... * boost::asio::posix::stream_descriptor::bytes_readable command; * boost::system::error_code ec; * descriptor.io_control(command, ec); * if (ec) * { * // An error occurred. * } * std::size_t bytes_readable = command.get(); * @endcode / template <typename IoControlCommand> BOOST_ASIO_SYNC_OP_VOID io_control(IoControlCommand& command, boost::system::error_code& ec) { impl_.get_service().io_control(impl_.get_implementation(), command, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } /// Gets the non-blocking mode of the descriptor. /* * @returns @c true if the descriptor's synchronous operations will fail with * boost::asio::error::would_block if they are unable to perform the requested * operation immediately. If @c false, synchronous operations will block * until complete. * * @note The non-blocking mode has no effect on the behaviour of asynchronous * operations. Asynchronous operations will never fail with the error * boost::asio::error::would_block. / bool non_blocking() const { return impl_.get_service().non_blocking(impl_.get_implementation()); } /// Sets the non-blocking mode of the descriptor. /* * @param mode If @c true, the descriptor's synchronous operations will fail * with boost::asio::error::would_block if they are unable to perform the * requested operation immediately. If @c false, synchronous operations will * block until complete. * * @throws boost::system::system_error Thrown on failure. * * @note The non-blocking mode has no effect on the behaviour of asynchronous * operations. Asynchronous operations will never fail with the error * boost::asio::error::would_block. / void non_blocking(bool mode) { boost::system::error_code ec; impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec); boost::asio::detail::throw_error(ec, "non_blocking"); } /// Sets the non-blocking mode of the descriptor. /* * @param mode If @c true, the descriptor's synchronous operations will fail * with boost::asio::error::would_block if they are unable to perform the * requested operation immediately. If @c false, synchronous operations will * block until complete. * * @param ec Set to indicate what error occurred, if any. * * @note The non-blocking mode has no effect on the behaviour of asynchronous * operations. Asynchronous operations will never fail with the error * boost::asio::error::would_block. / BOOST_ASIO_SYNC_OP_VOID non_blocking( bool mode, boost::system::error_code& ec) { impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } /// Gets the non-blocking mode of the native descriptor implementation. /* * This function is used to retrieve the non-blocking mode of the underlying * native descriptor. This mode has no effect on the behaviour of the * descriptor object's synchronous operations. * * @returns @c true if the underlying descriptor is in non-blocking mode and * direct system calls may fail with boost::asio::error::would_block (or the * equivalent system error). * * @note The current non-blocking mode is cached by the descriptor object. * Consequently, the return value may be incorrect if the non-blocking mode * was set directly on the native descriptor. / bool native_non_blocking() const { return impl_.get_service().native_non_blocking( impl_.get_implementation()); } /// Sets the non-blocking mode of the native descriptor implementation. /* * This function is used to modify the non-blocking mode of the underlying * native descriptor. It has no effect on the behaviour of the descriptor * object's synchronous operations. * * @param mode If @c true, the underlying descriptor is put into non-blocking * mode and direct system calls may fail with boost::asio::error::would_block * (or the equivalent system error). * * @throws boost::system::system_error Thrown on failure. If the @c mode is * @c false, but the current value of @c non_blocking() is @c true, this * function fails with boost::asio::error::invalid_argument, as the * combination does not make sense. / void native_non_blocking(bool mode) { boost::system::error_code ec; impl_.get_service().native_non_blocking( impl_.get_implementation(), mode, ec); boost::asio::detail::throw_error(ec, "native_non_blocking"); } /// Sets the non-blocking mode of the native descriptor implementation. /* * This function is used to modify the non-blocking mode of the underlying * native descriptor. It has no effect on the behaviour of the descriptor * object's synchronous operations. * * @param mode If @c true, the underlying descriptor is put into non-blocking * mode and direct system calls may fail with boost::asio::error::would_block * (or the equivalent system error). * * @param ec Set to indicate what error occurred, if any. If the @c mode is * @c false, but the current value of @c non_blocking() is @c true, this * function fails with boost::asio::error::invalid_argument, as the * combination does not make sense. / BOOST_ASIO_SYNC_OP_VOID native_non_blocking( bool mode, boost::system::error_code& ec) { impl_.get_service().native_non_blocking( impl_.get_implementation(), mode, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } /// Wait for the descriptor to become ready to read, ready to write, or to /// have pending error conditions. /* * This function is used to perform a blocking wait for a descriptor to enter * a ready to read, write or error condition state. * * @param w Specifies the desired descriptor state. * * @par Example * Waiting for a descriptor to become readable. * @code * boost::asio::posix::stream_descriptor descriptor(my_context); * ... * descriptor.wait(boost::asio::posix::stream_descriptor::wait_read); * @endcode / void wait(wait_type w) { boost::system::error_code ec; impl_.get_service().wait(impl_.get_implementation(), w, ec); boost::asio::detail::throw_error(ec, "wait"); } /// Wait for the descriptor to become ready to read, ready to write, or to /// have pending error conditions. /* * This function is used to perform a blocking wait for a descriptor to enter * a ready to read, write or error condition state. * * @param w Specifies the desired descriptor state. * * @param ec Set to indicate what error occurred, if any. * * @par Example * Waiting for a descriptor to become readable. * @code * boost::asio::posix::stream_descriptor descriptor(my_context); * ... * boost::system::error_code ec; * descriptor.wait(boost::asio::posix::stream_descriptor::wait_read, ec); * @endcode / BOOST_ASIO_SYNC_OP_VOID wait(wait_type w, boost::system::error_code& ec) { impl_.get_service().wait(impl_.get_implementation(), w, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } /// Asynchronously wait for the descriptor to become ready to read, ready to /// write, or to have pending error conditions. /* * This function is used to perform an asynchronous wait for a descriptor to * enter a ready to read, write or error condition state. * * @param w Specifies the desired descriptor state. * * @param handler The handler to be called when the wait operation completes. * Copies will be made of the handler as required. The function signature of * the handler must be: * @code void handler( * const boost::system::error_code& error // Result of operation * ); @endcode * Regardless of whether the asynchronous operation completes immediately or * not, the handler will not be invoked from within this function. On * immediate completion, invocation of the handler will be performed in a * manner equivalent to using boost::asio::post(). * * @par Example * @code * void wait_handler(const boost::system::error_code& error) * { * if (!error) * { * // Wait succeeded. * } * } * * ... * * boost::asio::posix::stream_descriptor descriptor(my_context); * ... * descriptor.async_wait( * boost::asio::posix::stream_descriptor::wait_read, * wait_handler); * @endcode / template < BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code)) WaitHandler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (boost::system::error_code)) async_wait(wait_type w, BOOST_ASIO_MOVE_ARG(WaitHandler) handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) { return async_initiate<WaitHandler, void (boost::system::error_code)>( initiate_async_wait(this), handler, w); } protected: /// Protected destructor to prevent deletion through this type. /* * This function destroys the descriptor, cancelling any outstanding * asynchronous wait operations associated with the descriptor as if by * calling @c cancel. / ~basic_descriptor() { } detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_; private: // Disallow copying and assignment. basic_descriptor(const basic_descriptor&) BOOST_ASIO_DELETED; basic_descriptor& operator=(const basic_descriptor&) BOOST_ASIO_DELETED; class initiate_async_wait { public: typedef Executor executor_type; explicit initiate_async_wait(basic_descriptor self) : self_(self) { } executor_type get_executor() const BOOST_ASIO_NOEXCEPT { return self_->get_executor(); } template <typename WaitHandler> void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler, wait_type w) const { // If you get an error on the following line it means that your handler // does not meet the documented type requirements for a WaitHandler. BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check; detail::non_const_lvalue<WaitHandler> handler2(handler); self_->impl_.get_service().async_wait( self_->impl_.get_implementation(), w, handler2.value, self_->impl_.get_executor()); } private: basic_descriptor* self_; }; }; } // namespace posix } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) // \|\| defined(GENERATING_DOCUMENTATION) #endif // BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_HPP

| ver. 1.6 | Github | . | PHP 8.2.30 | ??????????? ?????????: 0 | proxy | phpinfo | ???????????