uvco::anonymous_namespace{combinators.cc}::TaskSetImpl Class Reference

Inheritance diagram for uvco::anonymous_namespace{combinators.cc}::TaskSetImpl:

Collaboration diagram for uvco::anonymous_namespace{combinators.cc}::TaskSetImpl:

Public Member Functions
	TaskSetImpl ()=default
	TaskSetImpl (const TaskSetImpl &)=delete
	TaskSetImpl (TaskSetImpl &&)=delete
TaskSetImpl &	operator= (const TaskSetImpl &)=delete
TaskSetImpl &	operator= (TaskSetImpl &&)=delete
	~TaskSetImpl () override=default
Public Member Functions inherited from uvco::TaskSet
	TaskSet ()=default
	TaskSet (const TaskSet &)=delete
	TaskSet (TaskSet &&) noexcept=default
TaskSet &	operator= (const TaskSet &)=delete
TaskSet &	operator= (TaskSet &&) noexcept=default
virtual	~TaskSet ()=default

Private Member Functions
Id	add (Promise< void > task) override
bool	empty () override
	Check if there are any active tasks on the TaskSet.
Promise< void >	onEmpty () override
void	setOnError (ErrorCallback ecb) override
Promise< void >	wrap (Id taskId, Promise< void > task)

Private Attributes
Id	counter_ = 0
std::unordered_map< Id, Promise< void > >	tasks_ {}
ErrorCallback	errorCallback_
std::deque< Id >	doneTasks_ {}
WaitPoint	onEmpty_ {}

Additional Inherited Members
Public Types inherited from uvco::TaskSet
using	Id = size_t
using	ErrorCallback = std::function<void(Id, std::exception_ptr)>
Static Public Member Functions inherited from uvco::TaskSet
static std::unique_ptr< TaskSet >	create ()

Constructor & Destructor Documentation

TaskSetImpl() [1/3]

uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::TaskSetImpl ( )

default

TaskSetImpl() [2/3]

uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::TaskSetImpl ( const TaskSetImpl & )

delete

TaskSetImpl() [3/3]

uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::TaskSetImpl ( TaskSetImpl && )

delete

~TaskSetImpl()

uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::~TaskSetImpl ( )

overridedefault

Member Function Documentation

add()

Id uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::add ( Promise< void > task )

inlineoverrideprivatevirtual

Add a task to the TaskSet. It will be run to completion. If an exception is thrown, it is printed to stderr, or an ErrorCallback will be called if set before using setOnError().

Implements uvco::TaskSet.

                                      {
    const Id taskId = counter_++;
    tasks_.insert({taskId, wrap(taskId, std::move(task))});
    return taskId;
  }

empty()

bool uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::empty ( )

inlineoverrideprivatevirtual

Check if there are any active tasks on the TaskSet.

Implements uvco::TaskSet.

{ return 0 == tasks_.size() - doneTasks_.size(); }

onEmpty()

Promise< void > uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::onEmpty ( )

inlineoverrideprivatevirtual

Return a Promise which will be fulfilled when no tasks are left on the TaskSet. Multiple calls to this will return Promise instances which will become ready simultaneously; this means that depending on the scheduling order, by the time this Promise resolves, the TaskSet instance may not be empty anymore.

Implements uvco::TaskSet.

                                   {
    if (empty()) {
      co_return;
    }
    co_await onEmpty_.wait();
  }

operator=() [1/2]

TaskSetImpl & uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::operator= ( const TaskSetImpl & )

delete

operator=() [2/2]

TaskSetImpl & uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::operator= ( TaskSetImpl && )

delete

setOnError()

void uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::setOnError ( ErrorCallback callback )

inlineoverrideprivatevirtual

Register a callback which handles errors thrown by tasks. By default, errors are logged to stderr. The callback is called when a task finishes by throwing an exception.

Implements uvco::TaskSet.

                                              {
    errorCallback_ = std::move(ecb);
  }

wrap()

Promise< void > uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::wrap ( Id taskId, Promise< void > task )

inlineprivate

                                                    {
    // Wait for task to finish; do regular housekeeping; then mark current task
    // as ready for cleanup.
    try {
      Promise<void> shortlivedTask{std::move(task)};
      co_await shortlivedTask;
    } catch (const std::exception &e) {
      if (errorCallback_) {
        errorCallback_(taskId, std::current_exception());
      } else {
        fmt::print(stderr,
                   "TaskSet task {} failed with exception: {} (setOnError() to "
                   "suppress this message)\n",
                   taskId, e.what());
      }
    } catch (...) {
      if (errorCallback_) {
        errorCallback_(taskId, std::current_exception());
      } else {
        fmt::print(stderr,
                   "TaskSet task {} failed with unknown exception "
                   "(setOnError() to suppress this message)\n",
                   taskId);
      }
    }
 
    // Already trigger onEmpty if no more tasks are left. Otherwise this leads
    // to a deadlock-like problem, as no more tasks will run to trigger the
    // cleanup, and thus notify onEmpty.
    if (tasks_.size() - doneTasks_.size() - 1 == 0) {
      onEmpty_.releaseAll();
    }
 
    // Drop finished tasks.
    while (!doneTasks_.empty()) {
      tasks_.erase(doneTasks_.front());
      doneTasks_.pop_front();
    }
 
    // We cannot erase the task directly here, as the task in tasks_ refers to
    // this very coroutine. Therefore, mark it for cleanup and deal with it
    // later.
    doneTasks_.push_back(taskId);
  }

Member Data Documentation

counter_

Id uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::counter_ = 0

private

doneTasks_

std::deque<Id> uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::doneTasks_ {}

private

{};

errorCallback_

ErrorCallback uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::errorCallback_

private

onEmpty_

WaitPoint uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::onEmpty_ {}

private

{};

tasks_

std::unordered_map<Id, Promise<void> > uvco::anonymous_namespace{combinators.cc}::TaskSetImpl::tasks_ {}

private

{};

---

The documentation for this class was generated from the following file:

• uvco/combinators.cc