bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update boost on linux

Browse Source
This commit is contained in:
Bassem Girgis
2019-08-10 16:06:25 -05:00
parent 76ad52be58
commit 861b918727
5363 changed files with 483306 additions and 116507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

328
linx64/include/boost/asio/posix/basic_descriptor.hpp
View File

@@ -2,7 +2,7 @@
// posix/basic_descriptor.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2003-2019 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)
@@ -20,11 +20,21 @@
#if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
|| defined(GENERATING_DOCUMENTATION)
#include <boost/asio/basic_io_object.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/executor.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 {
@@ -40,41 +50,61 @@ namespace posix {
* @e Distinct @e objects: Safe.@n
* @e Shared @e objects: Unsafe.
*/
template <typename DescriptorService>
template <typename Executor = executor>
class basic_descriptor
: public basic_io_object<DescriptorService>,
public descriptor_base
: public descriptor_base
{
public:
/// (Deprecated: Use native_handle_type.) The native representation of a
/// descriptor.
typedef typename DescriptorService::native_handle_type native_type;
/// The type of the executor associated with the object.
typedef Executor executor_type;
/// The native representation of a descriptor.
typedef typename DescriptorService::native_handle_type native_handle_type;
#if defined(GENERATING_DOCUMENTATION)
typedef implementation_defined native_handle_type;
#else
typedef detail::reactive_descriptor_service::native_handle_type
native_handle_type;
#endif
/// A basic_descriptor is always the lowest layer.
typedef basic_descriptor<DescriptorService> lowest_layer_type;
/// A descriptor is always the lowest layer.
typedef basic_descriptor lowest_layer_type;
/// Construct a basic_descriptor without opening it.
/// Construct a descriptor without opening it.
/**
* This constructor creates a descriptor without opening it.
*
* @param io_service The io_service object that the descriptor will use to
* @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(boost::asio::io_service& io_service)
: basic_io_object<DescriptorService>(io_service)
explicit basic_descriptor(const executor_type& ex)
: impl_(ex)
{
}
/// Construct a basic_descriptor on an existing native descriptor.
/// 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 io_service The io_service object that the descriptor will use to
* @param ex The I/O executor that the descriptor will use, by default, to
* dispatch handlers for any asynchronous operations performed on the
* descriptor.
*
@@ -82,55 +112,88 @@ public:
*
* @throws boost::system::system_error Thrown on failure.
*/
basic_descriptor(boost::asio::io_service& io_service,
basic_descriptor(const executor_type& ex,
const native_handle_type& native_descriptor)
: basic_io_object<DescriptorService>(io_service)
: impl_(ex)
{
boost::system::error_code ec;
this->get_service().assign(this->get_implementation(),
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 basic_descriptor from another.
/// Move-construct a descriptor from another.
/**
* This constructor moves a descriptor from one object to another.
*
* @param other The other basic_descriptor object from which the move will
* @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(io_service&) constructor.
* constructed using the @c basic_descriptor(const executor_type&)
* constructor.
*/
basic_descriptor(basic_descriptor&& other)
: basic_io_object<DescriptorService>(
BOOST_ASIO_MOVE_CAST(basic_descriptor)(other))
: impl_(std::move(other.impl_))
{
}
/// Move-assign a basic_descriptor from another.
/// Move-assign a descriptor from another.
/**
* This assignment operator moves a descriptor from one object to another.
*
* @param other The other basic_descriptor object from which the move will
* @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(io_service&) constructor.
* constructed using the @c basic_descriptor(const executor_type&)
* constructor.
*/
basic_descriptor& operator=(basic_descriptor&& other)
{
basic_io_object<DescriptorService>::operator=(
BOOST_ASIO_MOVE_CAST(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 basic_descriptor cannot contain any further layers, it
* 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
@@ -144,7 +207,7 @@ public:
/// 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 basic_descriptor cannot contain any further layers, it
* 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.
@@ -166,7 +229,7 @@ public:
void assign(const native_handle_type& native_descriptor)
{
boost::system::error_code ec;
this->get_service().assign(this->get_implementation(),
impl_.get_service().assign(impl_.get_implementation(),
native_descriptor, ec);
boost::asio::detail::throw_error(ec, "assign");
}
@@ -179,17 +242,18 @@ public:
*
* @param ec Set to indicate what error occurred, if any.
*/
boost::system::error_code assign(const native_handle_type& native_descriptor,
BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& native_descriptor,
boost::system::error_code& ec)
{
return this->get_service().assign(
this->get_implementation(), native_descriptor, 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 this->get_service().is_open(this->implementation);
return impl_.get_service().is_open(impl_.get_implementation());
}
/// Close the descriptor.
@@ -204,7 +268,7 @@ public:
void close()
{
boost::system::error_code ec;
this->get_service().close(this->get_implementation(), ec);
impl_.get_service().close(impl_.get_implementation(), ec);
boost::asio::detail::throw_error(ec, "close");
}
@@ -217,21 +281,10 @@ public:
* @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::system::error_code close(boost::system::error_code& ec)
BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
{
return this->get_service().close(this->get_implementation(), ec);
}
/// (Deprecated: Use native_handle().) 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_type native()
{
return this->get_service().native_handle(this->implementation);
impl_.get_service().close(impl_.get_implementation(), ec);
BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
}
/// Get the native descriptor representation.
@@ -242,7 +295,7 @@ public:
*/
native_handle_type native_handle()
{
return this->get_service().native_handle(this->implementation);
return impl_.get_service().native_handle(impl_.get_implementation());
}
/// Release ownership of the native descriptor implementation.
@@ -257,7 +310,7 @@ public:
*/
native_handle_type release()
{
return this->get_service().release(this->implementation);
return impl_.get_service().release(impl_.get_implementation());
}
/// Cancel all asynchronous operations associated with the descriptor.
@@ -271,7 +324,7 @@ public:
void cancel()
{
boost::system::error_code ec;
this->get_service().cancel(this->get_implementation(), ec);
impl_.get_service().cancel(impl_.get_implementation(), ec);
boost::asio::detail::throw_error(ec, "cancel");
}
@@ -283,9 +336,10 @@ public:
*
* @param ec Set to indicate what error occurred, if any.
*/
boost::system::error_code cancel(boost::system::error_code& ec)
BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec)
{
return this->get_service().cancel(this->get_implementation(), ec);
impl_.get_service().cancel(impl_.get_implementation(), ec);
BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
}
/// Perform an IO control command on the descriptor.
@@ -303,7 +357,7 @@ public:
* @par Example
* Getting the number of bytes ready to read:
* @code
* boost::asio::posix::stream_descriptor descriptor(io_service);
* boost::asio::posix::stream_descriptor descriptor(my_context);
* ...
* boost::asio::posix::stream_descriptor::bytes_readable command;
* descriptor.io_control(command);
@@ -314,7 +368,7 @@ public:
void io_control(IoControlCommand& command)
{
boost::system::error_code ec;
this->get_service().io_control(this->get_implementation(), command, ec);
impl_.get_service().io_control(impl_.get_implementation(), command, ec);
boost::asio::detail::throw_error(ec, "io_control");
}
@@ -333,7 +387,7 @@ public:
* @par Example
* Getting the number of bytes ready to read:
* @code
* boost::asio::posix::stream_descriptor descriptor(io_service);
* boost::asio::posix::stream_descriptor descriptor(my_context);
* ...
* boost::asio::posix::stream_descriptor::bytes_readable command;
* boost::system::error_code ec;
@@ -346,11 +400,11 @@ public:
* @endcode
*/
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
BOOST_ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
boost::system::error_code& ec)
{
return this->get_service().io_control(
this->get_implementation(), command, 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.
@@ -366,7 +420,7 @@ public:
*/
bool non_blocking() const
{
return this->get_service().non_blocking(this->implementation);
return impl_.get_service().non_blocking(impl_.get_implementation());
}
/// Sets the non-blocking mode of the descriptor.
@@ -385,7 +439,7 @@ public:
void non_blocking(bool mode)
{
boost::system::error_code ec;
this->get_service().non_blocking(this->get_implementation(), mode, ec);
impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
boost::asio::detail::throw_error(ec, "non_blocking");
}
@@ -402,11 +456,11 @@ public:
* operations. Asynchronous operations will never fail with the error
* boost::asio::error::would_block.
*/
boost::system::error_code non_blocking(
BOOST_ASIO_SYNC_OP_VOID non_blocking(
bool mode, boost::system::error_code& ec)
{
return this->get_service().non_blocking(
this->get_implementation(), mode, 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.
@@ -425,7 +479,8 @@ public:
*/
bool native_non_blocking() const
{
return this->get_service().native_non_blocking(this->implementation);
return impl_.get_service().native_non_blocking(
impl_.get_implementation());
}
/// Sets the non-blocking mode of the native descriptor implementation.
@@ -446,8 +501,8 @@ public:
void native_non_blocking(bool mode)
{
boost::system::error_code ec;
this->get_service().native_non_blocking(
this->get_implementation(), mode, ec);
impl_.get_service().native_non_blocking(
impl_.get_implementation(), mode, ec);
boost::asio::detail::throw_error(ec, "native_non_blocking");
}
@@ -466,18 +521,143 @@ public:
* function fails with boost::asio::error::invalid_argument, as the
* combination does not make sense.
*/
boost::system::error_code native_non_blocking(
BOOST_ASIO_SYNC_OP_VOID native_non_blocking(
bool mode, boost::system::error_code& ec)
{
return this->get_service().native_non_blocking(
this->get_implementation(), mode, 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 <typename WaitHandler>
BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
void (boost::system::error_code))
async_wait(wait_type w, BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
{
return async_initiate<WaitHandler, void (boost::system::error_code)>(
initiate_async_wait(), handler, this, 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;
struct initiate_async_wait
{
template <typename WaitHandler>
void operator()(BOOST_ASIO_MOVE_ARG(WaitHandler) handler,
basic_descriptor* self, 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_implementation_executor());
}
};
};
} // namespace posix

190
linx64/include/boost/asio/posix/basic_stream_descriptor.hpp
View File

@@ -2,7 +2,7 @@
// posix/basic_stream_descriptor.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2003-2019 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)
@@ -16,19 +16,11 @@
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include <boost/asio/detail/config.hpp>
#include <boost/asio/posix/descriptor.hpp>
#if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
|| defined(GENERATING_DOCUMENTATION)
#include <cstddef>
#include <boost/asio/detail/handler_type_requirements.hpp>
#include <boost/asio/detail/throw_error.hpp>
#include <boost/asio/error.hpp>
#include <boost/asio/posix/basic_descriptor.hpp>
#include <boost/asio/posix/stream_descriptor_service.hpp>
#include <boost/asio/detail/push_options.hpp>
namespace boost {
namespace asio {
namespace posix {
@@ -45,85 +37,126 @@ namespace posix {
* @par Concepts:
* AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
*/
template <typename StreamDescriptorService = stream_descriptor_service>
template <typename Executor = executor>
class basic_stream_descriptor
: public basic_descriptor<StreamDescriptorService>
: public basic_descriptor<Executor>
{
public:
/// (Deprecated: Use native_handle_type.) The native representation of a
/// descriptor.
typedef typename StreamDescriptorService::native_handle_type native_type;
/// The type of the executor associated with the object.
typedef Executor executor_type;
/// The native representation of a descriptor.
typedef typename StreamDescriptorService::native_handle_type
typedef typename basic_descriptor<Executor>::native_handle_type
native_handle_type;
/// Construct a basic_stream_descriptor without opening it.
/// Construct a stream descriptor without opening it.
/**
* This constructor creates a stream descriptor without opening it. The
* descriptor needs to be opened and then connected or accepted before data
* can be sent or received on it.
*
* @param io_service The io_service object that the stream descriptor will
* use to dispatch handlers for any asynchronous operations performed on the
* @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_stream_descriptor(boost::asio::io_service& io_service)
: basic_descriptor<StreamDescriptorService>(io_service)
explicit basic_stream_descriptor(const executor_type& ex)
: basic_descriptor<Executor>(ex)
{
}
/// Construct a basic_stream_descriptor on an existing native descriptor.
/// Construct a stream descriptor without opening it.
/**
* This constructor creates a stream descriptor without opening it. The
* descriptor needs to be opened and then connected or accepted before data
* can be sent or received on 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_stream_descriptor(ExecutionContext& context,
typename enable_if<
is_convertible<ExecutionContext&, execution_context&>::value
>::type* = 0)
: basic_descriptor<Executor>(context)
{
}
/// Construct a stream descriptor on an existing native descriptor.
/**
* This constructor creates a stream descriptor object to hold an existing
* native descriptor.
*
* @param io_service The io_service object that the stream descriptor will
* use to dispatch handlers for any asynchronous operations performed on the
* @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 The new underlying descriptor implementation.
*
* @throws boost::system::system_error Thrown on failure.
*/
basic_stream_descriptor(boost::asio::io_service& io_service,
basic_stream_descriptor(const executor_type& ex,
const native_handle_type& native_descriptor)
: basic_descriptor<StreamDescriptorService>(io_service, native_descriptor)
: basic_descriptor<Executor>(ex, native_descriptor)
{
}
/// Construct a stream descriptor on an existing native descriptor.
/**
* This constructor creates a stream 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 The new underlying descriptor implementation.
*
* @throws boost::system::system_error Thrown on failure.
*/
template <typename ExecutionContext>
basic_stream_descriptor(ExecutionContext& context,
const native_handle_type& native_descriptor,
typename enable_if<
is_convertible<ExecutionContext&, execution_context&>::value
>::type* = 0)
: basic_descriptor<Executor>(context, native_descriptor)
{
}
#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
/// Move-construct a basic_stream_descriptor from another.
/// Move-construct a stream descriptor from another.
/**
* This constructor moves a stream descriptor from one object to another.
*
* @param other The other basic_stream_descriptor object from which the move
* @param other The other stream 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_stream_descriptor(io_service&) constructor.
* constructed using the @c basic_stream_descriptor(const executor_type&)
* constructor.
*/
basic_stream_descriptor(basic_stream_descriptor&& other)
: basic_descriptor<StreamDescriptorService>(
BOOST_ASIO_MOVE_CAST(basic_stream_descriptor)(other))
: descriptor(std::move(other))
{
}
/// Move-assign a basic_stream_descriptor from another.
/// Move-assign a stream descriptor from another.
/**
* This assignment operator moves a stream descriptor from one object to
* another.
*
* @param other The other basic_stream_descriptor object from which the move
* @param other The other stream 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_stream_descriptor(io_service&) constructor.
* constructed using the @c basic_stream_descriptor(const executor_type&)
* constructor.
*/
basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
{
basic_descriptor<StreamDescriptorService>::operator=(
BOOST_ASIO_MOVE_CAST(basic_stream_descriptor)(other));
descriptor::operator=(std::move(other));
return *this;
}
#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
@@ -159,8 +192,8 @@ public:
std::size_t write_some(const ConstBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().write_some(
this->get_implementation(), buffers, ec);
std::size_t s = this->impl_.get_service().write_some(
this->impl_.get_implementation(), buffers, ec);
boost::asio::detail::throw_error(ec, "write_some");
return s;
}
@@ -185,8 +218,8 @@ public:
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().write_some(
this->get_implementation(), buffers, ec);
return this->impl_.get_service().write_some(
this->impl_.get_implementation(), buffers, ec);
}
/// Start an asynchronous write.
@@ -207,9 +240,9 @@ public:
* std::size_t bytes_transferred // Number of bytes written.
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* boost::asio::io_service::post().
* 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().
*
* @note The write operation may not transmit all of the data to the peer.
* Consider using the @ref async_write function if you need to ensure that all
@@ -230,12 +263,9 @@ public:
async_write_some(const ConstBufferSequence& buffers,
BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a WriteHandler.
BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
return this->get_service().async_write_some(this->get_implementation(),
buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
return async_initiate<WriteHandler,
void (boost::system::error_code, std::size_t)>(
initiate_async_write_some(), handler, this, buffers);
}
/// Read some data from the descriptor.
@@ -270,8 +300,8 @@ public:
std::size_t read_some(const MutableBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().read_some(
this->get_implementation(), buffers, ec);
std::size_t s = this->impl_.get_service().read_some(
this->impl_.get_implementation(), buffers, ec);
boost::asio::detail::throw_error(ec, "read_some");
return s;
}
@@ -297,8 +327,8 @@ public:
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().read_some(
this->get_implementation(), buffers, ec);
return this->impl_.get_service().read_some(
this->impl_.get_implementation(), buffers, ec);
}
/// Start an asynchronous read.
@@ -319,9 +349,9 @@ public:
* std::size_t bytes_transferred // Number of bytes read.
* ); @endcode
* Regardless of whether the asynchronous operation completes immediately or
* not, the handler will not be invoked from within this function. Invocation
* of the handler will be performed in a manner equivalent to using
* boost::asio::io_service::post().
* 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().
*
* @note The read operation may not read all of the requested number of bytes.
* Consider using the @ref async_read function if you need to ensure that the
@@ -343,21 +373,53 @@ public:
async_read_some(const MutableBufferSequence& buffers,
BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
{
// If you get an error on the following line it means that your handler does
// not meet the documented type requirements for a ReadHandler.
BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
return this->get_service().async_read_some(this->get_implementation(),
buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
return async_initiate<ReadHandler,
void (boost::system::error_code, std::size_t)>(
initiate_async_read_some(), handler, this, buffers);
}
private:
struct initiate_async_write_some
{
template <typename WriteHandler, typename ConstBufferSequence>
void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler,
basic_stream_descriptor* self,
const ConstBufferSequence& buffers) const
{
// If you get an error on the following line it means that your handler
// does not meet the documented type requirements for a WriteHandler.
BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
detail::non_const_lvalue<WriteHandler> handler2(handler);
self->impl_.get_service().async_write_some(
self->impl_.get_implementation(), buffers, handler2.value,
self->impl_.get_implementation_executor());
}
};
struct initiate_async_read_some
{
template <typename ReadHandler, typename MutableBufferSequence>
void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
basic_stream_descriptor* self,
const MutableBufferSequence& buffers) const
{
// If you get an error on the following line it means that your handler
// does not meet the documented type requirements for a ReadHandler.
BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
detail::non_const_lvalue<ReadHandler> handler2(handler);
self->impl_.get_service().async_read_some(
self->impl_.get_implementation(), buffers, handler2.value,
self->impl_.get_implementation_executor());
}
};
};
} // namespace posix
} // namespace asio
} // namespace boost
#include <boost/asio/detail/pop_options.hpp>
#endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
// || defined(GENERATING_DOCUMENTATION)

39
linx64/include/boost/asio/posix/descriptor.hpp Normal file
View File

@@ -0,0 +1,39 @@
//
// posix/descriptor.hpp
// ~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2019 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_DESCRIPTOR_HPP
#define BOOST_ASIO_POSIX_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/posix/basic_descriptor.hpp>
namespace boost {
namespace asio {
namespace posix {
/// Typedef for the typical usage of basic_descriptor.
typedef basic_descriptor<> descriptor;
} // namespace posix
} // namespace asio
} // namespace boost
#endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
// || defined(GENERATING_DOCUMENTATION)
#endif // BOOST_ASIO_POSIX_DESCRIPTOR_HPP

41
linx64/include/boost/asio/posix/descriptor_base.hpp
View File

@@ -2,7 +2,7 @@
// posix/descriptor_base.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2003-2019 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)
@@ -29,33 +29,26 @@ namespace boost {
namespace asio {
namespace posix {
/// The descriptor_base class is used as a base for the basic_stream_descriptor
/// class template so that we have a common place to define the associated
/// IO control commands.
/// The descriptor_base class is used as a base for the descriptor class as a
/// place to define the associated IO control commands.
class descriptor_base
{
public:
/// (Deprecated: Use non_blocking().) IO control command to set the blocking
/// mode of the descriptor.
/// Wait types.
/**
* Implements the FIONBIO IO control command.
*
* @par Example
* @code
* boost::asio::posix::stream_descriptor descriptor(io_service);
* ...
* boost::asio::descriptor_base::non_blocking_io command(true);
* descriptor.io_control(command);
* @endcode
*
* @par Concepts:
* IoControlCommand.
* For use with descriptor::wait() and descriptor::async_wait().
*/
#if defined(GENERATING_DOCUMENTATION)
typedef implementation_defined non_blocking_io;
#else
typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
#endif
enum wait_type
{
/// Wait for a descriptor to become ready to read.
wait_read,
/// Wait for a descriptor to become ready to write.
wait_write,
/// Wait for a descriptor to have error conditions pending.
wait_error
};
/// IO control command to get the amount of data that can be read without
/// blocking.
@@ -64,7 +57,7 @@ public:
*
* @par Example
* @code
* boost::asio::posix::stream_descriptor descriptor(io_service);
* boost::asio::posix::stream_descriptor descriptor(my_context);
* ...
* boost::asio::descriptor_base::bytes_readable command(true);
* descriptor.io_control(command);

2
linx64/include/boost/asio/posix/stream_descriptor.hpp
View File

@@ -2,7 +2,7 @@
// posix/stream_descriptor.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2003-2019 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)

262
linx64/include/boost/asio/posix/stream_descriptor_service.hpp
View File

@@ -1,262 +0,0 @@
//
// posix/stream_descriptor_service.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2017 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_STREAM_DESCRIPTOR_SERVICE_HPP
#define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_SERVICE_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 <cstddef>
#include <boost/asio/async_result.hpp>
#include <boost/asio/error.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/asio/detail/reactive_descriptor_service.hpp>
#include <boost/asio/detail/push_options.hpp>
namespace boost {
namespace asio {
namespace posix {
/// Default service implementation for a stream descriptor.
class stream_descriptor_service
#if defined(GENERATING_DOCUMENTATION)
: public boost::asio::io_service::service
#else
: public boost::asio::detail::service_base<stream_descriptor_service>
#endif
{
public:
#if defined(GENERATING_DOCUMENTATION)
/// The unique service identifier.
static boost::asio::io_service::id id;
#endif
private:
// The type of the platform-specific implementation.
typedef detail::reactive_descriptor_service service_impl_type;
public:
/// The type of a stream descriptor implementation.
#if defined(GENERATING_DOCUMENTATION)
typedef implementation_defined implementation_type;
#else
typedef service_impl_type::implementation_type implementation_type;
#endif
/// (Deprecated: Use native_handle_type.) The native descriptor type.
#if defined(GENERATING_DOCUMENTATION)
typedef implementation_defined native_type;
#else
typedef service_impl_type::native_handle_type native_type;
#endif
/// The native descriptor type.
#if defined(GENERATING_DOCUMENTATION)
typedef implementation_defined native_handle_type;
#else
typedef service_impl_type::native_handle_type native_handle_type;
#endif
/// Construct a new stream descriptor service for the specified io_service.
explicit stream_descriptor_service(boost::asio::io_service& io_service)
: boost::asio::detail::service_base<stream_descriptor_service>(io_service),
service_impl_(io_service)
{
}
/// Construct a new stream descriptor implementation.
void construct(implementation_type& impl)
{
service_impl_.construct(impl);
}
#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
/// Move-construct a new stream descriptor implementation.
void move_construct(implementation_type& impl,
implementation_type& other_impl)
{
service_impl_.move_construct(impl, other_impl);
}
/// Move-assign from another stream descriptor implementation.
void move_assign(implementation_type& impl,
stream_descriptor_service& other_service,
implementation_type& other_impl)
{
service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
}
#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
/// Destroy a stream descriptor implementation.
void destroy(implementation_type& impl)
{
service_impl_.destroy(impl);
}
/// Assign an existing native descriptor to a stream descriptor.
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec)
{
return service_impl_.assign(impl, native_descriptor, ec);
}
/// Determine whether the descriptor is open.
bool is_open(const implementation_type& impl) const
{
return service_impl_.is_open(impl);
}
/// Close a stream descriptor implementation.
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
{
return service_impl_.close(impl, ec);
}
/// (Deprecated: Use native_handle().) Get the native descriptor
/// implementation.
native_type native(implementation_type& impl)
{
return service_impl_.native_handle(impl);
}
/// Get the native descriptor implementation.
native_handle_type native_handle(implementation_type& impl)
{
return service_impl_.native_handle(impl);
}
/// Release ownership of the native descriptor implementation.
native_handle_type release(implementation_type& impl)
{
return service_impl_.release(impl);
}
/// Cancel all asynchronous operations associated with the descriptor.
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
{
return service_impl_.cancel(impl, ec);
}
/// Perform an IO control command on the descriptor.
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
{
return service_impl_.io_control(impl, command, ec);
}
/// Gets the non-blocking mode of the descriptor.
bool non_blocking(const implementation_type& impl) const
{
return service_impl_.non_blocking(impl);
}
/// Sets the non-blocking mode of the descriptor.
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
{
return service_impl_.non_blocking(impl, mode, ec);
}
/// Gets the non-blocking mode of the native descriptor implementation.
bool native_non_blocking(const implementation_type& impl) const
{
return service_impl_.native_non_blocking(impl);
}
/// Sets the non-blocking mode of the native descriptor implementation.
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
{
return service_impl_.native_non_blocking(impl, mode, ec);
}
/// Write the given data to the stream.
template <typename ConstBufferSequence>
std::size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
{
return service_impl_.write_some(impl, buffers, ec);
}
/// Start an asynchronous write.
template <typename ConstBufferSequence, typename WriteHandler>
BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
void (boost::system::error_code, std::size_t))
async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers,
BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
{
boost::asio::detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
service_impl_.async_write_some(impl, buffers, init.handler);
return init.result.get();
}
/// Read some data from the stream.
template <typename MutableBufferSequence>
std::size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
{
return service_impl_.read_some(impl, buffers, ec);
}
/// Start an asynchronous read.
template <typename MutableBufferSequence, typename ReadHandler>
BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
void (boost::system::error_code, std::size_t))
async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers,
BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
{
boost::asio::detail::async_result_init<
ReadHandler, void (boost::system::error_code, std::size_t)> init(
BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
service_impl_.async_read_some(impl, buffers, init.handler);
return init.result.get();
}
private:
// Destroy all user-defined handler objects owned by the service.
void shutdown_service()
{
service_impl_.shutdown_service();
}
// The platform-specific implementation.
service_impl_type service_impl_;
};
} // 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_STREAM_DESCRIPTOR_SERVICE_HPP