|  | 
The channel type when rebound to the specified executor.
typedef basic_channel< Executor1, Traits, Signatures... > other;
| Name | Description | 
|---|---|
| Rebinds the channel type to another executor. | |
| The type of the executor associated with the channel. | |
| The traits type associated with the channel. | 
| Name | Description | 
|---|---|
| Asynchronously receive a message. | |
| Asynchronously send a message. | |
| basic_channel [constructor] | 
                    Construct a basic_channel.  | 
| Cancel all asynchronous operations waiting on the channel. | |
| Get the capacity of the channel's buffer. | |
| Close the channel. | |
| Get the executor associated with the object. | |
| Determine whether the channel is open. | |
| Move-assign a basic_channel from another. | |
| Determine whether a message can be received without blocking. | |
| Reset the channel to its initial state. | |
| Try to receive a message without blocking. | |
| Try to send a message without blocking. | |
| Try to send a number of messages without blocking. | |
| Try to send a number of messages without blocking, using dispatch semantics to call the receive operations' completion handlers. | |
| Try to send a message without blocking, using dispatch semantics to call the receive operation's completion handler. | |
| ~basic_channel [destructor] | Destructor. | 
          The experimental::basic_channel class template is
          used for sending messages between different parts of the same application.
          A message is defined as a collection of arguments
          to be passed to a completion handler, and the set of messages supported
          by a channel is specified by its Traits
          and Signatures...
          template parameters. Messages may be sent and received using asynchronous
          or non-blocking synchronous operations.
        
          Unless customising the traits, applications will typically use the experimental::channel alias template. For example:
        
void send_loop(int i, steady_timer& timer, channel<void(error_code, int)>& ch) { if (i < 10) { timer.expires_after(chrono::seconds(1)); timer.async_wait( [i, &timer, &ch](error_code error) { if (!error) { ch.async_send(error_code(), i, [i, &timer, &ch](error_code error) { if (!error) { send_loop(i + 1, timer, ch); } }); } }); } else { ch.close(); } } void receive_loop(channel<void(error_code, int)>& ch) { ch.async_receive( [&ch](error_code error, int i) { if (!error) { std::cout << "Received " << i << "\n"; receive_loop(ch); } }); }
Distinct objects: Safe.
Shared objects: Unsafe.
          The experimental::basic_channel class template is
          not thread-safe, and would typically be used for passing messages between
          application code that runs on the same thread or in the same strand. Consider
          using experimental::basic_concurrent_channel, and
          its alias template experimental::concurrent_channel,
          to pass messages between code running in different threads.
        
          Header: asio/experimental/basic_channel.hpp
        
Convenience header: None