Task.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2024, EPFL/Blue Brain Project
 *
 * Responsible Author: Daniel.Nachbaur@epfl.ch
 *
 * This file is part of Blue Brain BioExplorer <https://github.com/BlueBrain/BioExplorer>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#pragma once
 
#include <platform/core/common/Progress.h>
#include <platform/core/common/tasks/TaskFunctor.h>
#include <platform/core/common/Types.h>
 
namespace core
{
class AbstractTask
{
public:
    virtual ~AbstractTask() = default;
 
    void cancel(std::function<void()> done = {})
    {
        if (_cancelled)
            return;
        _cancelDone = done;
        _cancelled = true;
        _cancelToken.cancel();
        _cancel();
    }
 
    void finishCancel()
    {
        if (_cancelDone)
            _cancelDone();
    }
 
    bool canceled() const { return _cancelled; }
    virtual void schedule() = 0;
 
    Progress progress{"Scheduling task ..."};
 
protected:
    async::cancellation_token _cancelToken;
    std::function<void()> _cancelDone;
    std::atomic_bool _cancelled{false};
 
private:
    virtual void _cancel() {}
};
 
template <typename T>
class Task : public AbstractTask
{
public:
    using Type = async::task<T>;
 
    Task() = default;
 
    template <typename F>
    Task(F&& functor)
    {
        _task = async::spawn(_setupFunctor(std::move(functor)));
    }
 
    void schedule() override
    { /* task is already running after construction */
    }
 
    T result() { return _task.get(); }
    auto& get() { return _task; }
 
protected:
    Type _task;
 
    template <typename F>
    auto&& _setupFunctor(F&& functor)
    {
        if (std::is_base_of<TaskFunctor, F>::value)
        {
            auto& taskFunctor = static_cast<TaskFunctor&>(functor);
            taskFunctor.setProgressFunc(
                std::bind(&Progress::update, std::ref(progress), std::placeholders::_1, std::placeholders::_3));
            taskFunctor.setCancelToken(_cancelToken);
        }
        return std::move(functor);
    }
};
 
template <typename T>
class DeferredTask : public Task<T>
{
public:
    template <typename F>
    DeferredTask(F&& functor)
    {
        Task<T>::_task = _e.get_task().then(Task<T>::template _setupFunctor(std::move(functor)));
    }
 
    void schedule() final { _e.set(); }
 
private:
    async::event_task<void> _e;
};
} // namespace core