typedef platform_specific native_handle_type;

Typedef for the native handle representation.

	Note
	This is the handle on the system, not the boost.asio class.

typedef platform_specific handle_type;

Typedef for the handle representation of boost.asio.

async_pipe(boost::asio::io_context & ios);

Construct a new async_pipe, does automatically open the pipe. Initializes source and sink with the same io_context.

	Note
	Windows creates a named pipe here, where the name is automatically generated.

async_pipe(boost::asio::io_context & ios_source, 
           boost::asio::io_context & ios_sink);

Construct a new async_pipe, does automatically open the pipe.

	Note
	Windows creates a named pipe here, where the name is automatically generated.

async_pipe(boost::asio::io_context & ios, const std::string & name);

Construct a new async_pipe, does automatically open. Initializes source and sink with the same io_context.

	Note
	Windows restricts possible names.

async_pipe(boost::asio::io_context & ios_source, 
           boost::asio::io_context & ios_sink, const std::string & name);

Construct a new async_pipe, does automatically open.

	Note
	Windows restricts possible names.

async_pipe(const async_pipe & lhs);

Copy-Constructor of the async pipe.

	Note
	Windows requires a named pipe for this, if a the wrong type is used an exception is thrown.

async_pipe(async_pipe && lhs);

Move-Constructor of the async pipe.

template<typename CharT, typename Traits = std::char_traits<CharT> > 
  explicit async_pipe(boost::asio::io_context & ios, 
                      const basic_pipe< CharT, Traits > & p);

Construct the async-pipe from a pipe.

	Note
	Windows requires a named pipe for this, if a the wrong type is used an exception is thrown.

template<typename CharT, typename Traits = std::char_traits<CharT> > 
  explicit async_pipe(boost::asio::io_context & ios_source, 
                      boost::asio::io_context & ios_sink, 
                      const basic_pipe< CharT, Traits > & p);

Construct the async-pipe from a pipe, with two different io_context objects.

	Note
	Windows requires a named pipe for this, if a the wrong type is used an exception is thrown.

template<typename CharT, typename Traits = std::char_traits<CharT> > 
  async_pipe & operator=(const basic_pipe< CharT, Traits > & p);

Assign a basic_pipe.

	Note
	Windows requires a named pipe for this, if a the wrong type is used an exception is thrown.

async_pipe & operator=(const async_pipe & lhs);

Copy Assign a pipe.

	Note
	Duplicates the handles.

async_pipe & operator=(async_pipe && lhs);

Move assign a pipe

~async_pipe();

Destructor. Closes the pipe handles.

template<typename CharT, typename Traits = std::char_traits<CharT> > 
  explicit operator basic_pipe< CharT, Traits >() const;

Explicit cast to basic_pipe.

void cancel();

Cancel the current asynchronous operations.

void close();

Close the pipe handles.

void close(std::error_code & ec);

Close the pipe handles. While passing an error_code

bool is_open() const;

Check if the pipes are open.

void async_close();

Async close, i.e. close after current operation is completed.

	Note
	There is no guarantee that this will indeed read the entire pipe-buffer

template<typename MutableBufferSequence> 
  std::size_t read_some(const MutableBufferSequence & buffers);

Read some data from the handle.

See the boost.asio documentation for more details.

template<typename MutableBufferSequence> 
  std::size_t write_some(const MutableBufferSequence & buffers);

Write some data to the handle.

See the boost.asio documentation for more details.

native_handle native_source() const;

Get the native handle of the source.

native_handle native_sink() const;

Get the native handle of the sink.

template<typename MutableBufferSequence, typename ReadHandler> 
  unspecified async_read_some(const MutableBufferSequence & buffers, 
                              ReadHandler && handler);

Start an asynchronous read.

See the boost.asio documentation for more details.

template<typename ConstBufferSequence, typename WriteHandler> 
  unspecified async_write_some(const ConstBufferSequence & buffers, 
                               WriteHandler && handler);

Start an asynchronous write.

See the boost.asio documentation for more details.

const handle_type & sink() const;

const handle_type & source() const;

handle_type && sink();

handle_type && source();

handle_type source(::boost::asio::io_context & ios);

	Note
	Will always move.

handle_type sink(::boost::asio::io_context & ios);

	Note
	Will always move

handle_type source(::boost::asio::io_context & ios) const;

	Note
	Will always copy.

handle_type sink(::boost::asio::io_context & ios) const;

	Note
	Will always copy