Loading...
Searching...
No Matches
receiver.hpp
Go to the documentation of this file.
// Copyright 2020 Arthur Sonzogni. All rights reserved.
// Use of this source code is governed by the MIT license that can be found in
// the LICENSE file.
#ifndef FTXUI_COMPONENT_RECEIVER_HPP_
#define FTXUI_COMPONENT_RECEIVER_HPP_
#include <algorithm> // for copy, max
#include <atomic> // for atomic, __atomic_base
#include <condition_variable> // for condition_variable
#include <memory> // for unique_ptr, make_unique
#include <mutex> // for mutex, unique_lock
#include <queue> // for queue
#include <utility> // for move
namespace ftxui {
// Usage:
//
// Initialization:
// ---------------
//
// auto receiver = MakeReceiver<std:string>();
// auto sender_1= receiver->MakeSender();
// auto sender_2 = receiver->MakeSender();
//
// Then move the senders elsewhere, potentially in a different thread.
//
// On the producer side:
// ----------------------
// [thread 1] sender_1->Send("hello");
// [thread 2] sender_2->Send("world");
//
// On the consumer side:
// ---------------------
// char c;
// while(receiver->Receive(&c)) // Return true as long as there is a producer.
// print(c)
//
// Receiver::Receive() returns true when there are no more senders.
// clang-format off
template<class T> class SenderImpl;
template<class T> class ReceiverImpl;
template<class T> using Sender = std::unique_ptr<SenderImpl<T>>;
template<class T> using Receiver = std::unique_ptr<ReceiverImpl<T>>;
template<class T> Receiver<T> MakeReceiver();
// clang-format on
// ---- Implementation part ----
template <class T>
class SenderImpl {
public:
SenderImpl(const SenderImpl&) = delete;
SenderImpl(SenderImpl&&) = delete;
SenderImpl& operator=(const SenderImpl&) = delete;
SenderImpl& operator=(SenderImpl&&) = delete;
void Send(T t) { receiver_->Receive(std::move(t)); }
~SenderImpl() { receiver_->ReleaseSender(); }
Sender<T> Clone() { return receiver_->MakeSender(); }
private:
friend class ReceiverImpl<T>;
explicit SenderImpl(ReceiverImpl<T>* consumer) : receiver_(consumer) {}
ReceiverImpl<T>* receiver_;
};
template <class T>
class ReceiverImpl {
public:
Sender<T> MakeSender() {
std::unique_lock<std::mutex> lock(mutex_);
senders_++;
return std::unique_ptr<SenderImpl<T>>(new SenderImpl<T>(this));
}
ReceiverImpl() = default;
bool Receive(T* t) {
while (senders_ || !queue_.empty()) {
std::unique_lock<std::mutex> lock(mutex_);
if (queue_.empty()) {
notifier_.wait(lock);
}
if (queue_.empty()) {
continue;
}
*t = std::move(queue_.front());
queue_.pop();
return true;
}
return false;
}
bool ReceiveNonBlocking(T* t) {
std::unique_lock<std::mutex> lock(mutex_);
if (queue_.empty()) {
return false;
}
*t = queue_.front();
queue_.pop();
return true;
}
bool HasPending() {
std::unique_lock<std::mutex> lock(mutex_);
return !queue_.empty();
}
bool HasQuitted() {
std::unique_lock<std::mutex> lock(mutex_);
return queue_.empty() && !senders_;
}
private:
friend class SenderImpl<T>;
void Receive(T t) {
{
std::unique_lock<std::mutex> lock(mutex_);
queue_.push(std::move(t));
}
notifier_.notify_one();
}
void ReleaseSender() {
senders_--;
notifier_.notify_one();
}
std::mutex mutex_;
std::queue<T> queue_;
std::condition_variable notifier_;
std::atomic<int> senders_{0};
};
template <class T>
Receiver<T> MakeReceiver() {
return std::make_unique<ReceiverImpl<T>>();
}
} // namespace ftxui
#endif // FTXUI_COMPONENT_RECEIVER_HPP_
ftxui::ReceiverImpl
Definition receiver.hpp:71
ftxui::ReceiverImpl::ReceiverImpl
ReceiverImpl()=default
ftxui::ReceiverImpl::HasQuitted
bool HasQuitted()
Definition receiver.hpp:111
ftxui::ReceiverImpl::Receive
bool Receive(T *t)
Definition receiver.hpp:80
ftxui::ReceiverImpl::ReceiveNonBlocking
bool ReceiveNonBlocking(T *t)
Definition receiver.hpp:96
ftxui::ReceiverImpl::HasPending
bool HasPending()
Definition receiver.hpp:106
ftxui::ReceiverImpl::SenderImpl< T >
friend class SenderImpl< T >
Definition receiver.hpp:117
ftxui::ReceiverImpl::MakeSender
Sender< T > MakeSender()
Definition receiver.hpp:73
ftxui::SenderImpl
Definition receiver.hpp:53
ftxui::SenderImpl::ReceiverImpl< T >
friend class ReceiverImpl< T >
Definition receiver.hpp:65
ftxui::SenderImpl::operator=
SenderImpl & operator=(const SenderImpl &)=delete
ftxui::SenderImpl::Clone
Sender< T > Clone()
Definition receiver.hpp:62
ftxui::SenderImpl::SenderImpl
SenderImpl(SenderImpl &&)=delete
ftxui::SenderImpl::SenderImpl
SenderImpl(const SenderImpl &)=delete
ftxui::SenderImpl::~SenderImpl
~SenderImpl()
Definition receiver.hpp:60
ftxui::SenderImpl::operator=
SenderImpl & operator=(SenderImpl &&)=delete
ftxui::SenderImpl::Send
void Send(T t)
Definition receiver.hpp:59
ftxui
Definition animation.hpp:10
ftxui::Make
std::shared_ptr< T > Make(Args &&... args)
Definition component.hpp:26
ftxui::MakeReceiver
Receiver< T > MakeReceiver()
Definition receiver.hpp:139
ftxui::Receiver
std::unique_ptr< ReceiverImpl< T > > Receiver
Definition receiver.hpp:46
ftxui::Sender
std::unique_ptr< SenderImpl< T > > Sender
Definition receiver.hpp:45