A channel to use for asynchronous communication of data in a queued manner. More...
#include "Channel.h"
Collaboration diagram for scl::async::Channel< T, Lock, Guard, Container >:
Public Types | |
| using | lock_type = Lock |
| lock_type The type of locks used in the channel More... | |
| template<class L > | |
| using | guard_type = Guard< L > |
| using | queue_type = std::queue< T, Container > |
| queue_type The type of the channel's queue More... | |
| using | value_type = typename queue_type::value_type |
| The type of values exposed through the channel. More... | |
| using | size_type = typename queue_type::size_type |
| The type used to quantize the size of the queue. More... | |
| using | sender_type = details::ChannelSender< Channel > |
| The type of senders for the channel. More... | |
| using | receiver_type = details::ChannelReceiver< Channel > |
| The type of receivers for the channel. More... | |
| using | transport_traits = details::channel_transport_traits< Channel > |
| The type of the transport traits for the channel. More... | |
| using | transport_type = typename transport_traits::type |
| The type of the transport payload. More... | |
Public Member Functions | |
| Channel () | |
| Construct a channel. More... | |
| Channel (const Channel &)=delete | |
| Channel (Channel &&)=delete | |
| Channel & | operator= (const Channel &)=delete |
| Channel & | operator= (Channel &&)=delete |
| size_type | size () const |
| Retrieve the size of the queue. More... | |
| size_type | length () const |
| Alias for Channel::size. More... | |
| bool | isEmpty () const |
| Determine whether or not the channel is currently empty. More... | |
| receiver_type & | receiver () |
| Get a receiver for this channel. More... | |
| sender_type & | sender () |
| Get a sender for this channel. More... | |
| template<class U = value_type> | |
| sender_type & | operator<< (U &&value) |
| Forward a value into the channel. More... | |
| template<class U = value_type> | |
| receiver_type & | operator>> (U &value) |
| Extract a value from the channel. More... | |
Public Attributes | |
| friend | sender_type |
| friend | receiver_type |
Protected Member Functions | |
| transport_type | interface () |
| Implementation details to get a receiver and sender for this channel. More... | |
Protected Attributes | |
| lock_type | lock |
| The lock being used for the channel's queue. More... | |
| std::condition_variable_any | condition |
| The condition used to wait for the channel's queue. More... | |
| queue_type | queue |
| The underlying queue used to store data. More... | |
| sender_type | sender_ |
| The sender for this channel. More... | |
| receiver_type | receiver_ |
| The receiver for this channel. More... | |
Friends | |
| template<size_t I, class U , class L , template< class > class G, class C > | |
| auto | std::get (Channel< U, L, G, C > &chan) -> scl::tools::meta ::tuple_element_t< I, typename Channel< U, L, G, C >::transport_type > |
Detailed Description
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
class scl::async::Channel< T, Lock, Guard, Container >
A channel to use for asynchronous communication of data in a queued manner.
- Template Parameters
-
T being the type of values Lock being the type of lock to use Guard being the type of guard to use Container being the container to use for the queue
Member Typedef Documentation
◆ guard_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
template<class L >
| scl::async::Channel< T, Lock, Guard, Container >::guard_type |
◆ lock_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| using scl::async::Channel< T, Lock, Guard, Container >::lock_type = Lock |
◆ queue_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| using scl::async::Channel< T, Lock, Guard, Container >::queue_type = std::queue<T, Container> |
◆ receiver_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| scl::async::Channel< T, Lock, Guard, Container >::receiver_type |
◆ sender_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| scl::async::Channel< T, Lock, Guard, Container >::sender_type |
◆ size_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| scl::async::Channel< T, Lock, Guard, Container >::size_type |
◆ transport_traits
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| scl::async::Channel< T, Lock, Guard, Container >::transport_traits |
◆ transport_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| scl::async::Channel< T, Lock, Guard, Container >::transport_type |
◆ value_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| scl::async::Channel< T, Lock, Guard, Container >::value_type |
Constructor & Destructor Documentation
◆ Channel() [1/3]
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
inline |
◆ Channel() [2/3]
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
delete |
◆ Channel() [3/3]
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
delete |
Member Function Documentation
◆ interface()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
inlineprotected |
◆ isEmpty()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
inline |
◆ length()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
inline |
Alias for Channel::size.
◆ operator<<()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
template<class U = value_type>
|
inline |
Forward a value into the channel.
- Template Parameters
-
U being the type of data to forward (defaults to Channel::value_type)
- Parameters
-
value being the value to forward
- Returns
- a reference to this Channel's ChannelSender
◆ operator=() [1/2]
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
delete |
◆ operator=() [2/2]
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
delete |
◆ operator>>()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
template<class U = value_type>
|
inline |
Extract a value from the channel.
- Template Parameters
-
U being the type to store the data into (defaults to Channel::value_type)
- Parameters
-
value being where to store the data
- Returns
- a reference to this Channel's ChannelReceiver
◆ receiver()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
inline |
◆ sender()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
inline |
◆ size()
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
inline |
Friends And Related Function Documentation
◆ std::get
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
template<size_t I, class U , class L , template< class > class G, class C >
|
friend |
Member Data Documentation
◆ condition
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
mutableprotected |
◆ lock
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
mutableprotected |
◆ queue
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
protected |
◆ receiver_
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
protected |
◆ receiver_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| friend scl::async::Channel< T, Lock, Guard, Container >::receiver_type |
◆ sender_
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
|
protected |
◆ sender_type
template<class T, class Lock = std::mutex, template< class > class Guard = std::lock_guard, class Container = std::deque<T>>
| friend scl::async::Channel< T, Lock, Guard, Container >::sender_type |
The documentation for this class was generated from the following file:
- include/scl/async/Channel.h
