async_delegate.hpp

Go to the documentation of this file.

// Copyright Take Vos 2023.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)

 
#pragma once
 
#include "../observer/observer.hpp"
#include "../utility/utility.hpp"
#include "../concurrency/concurrency.hpp"
#include "../dispatch/dispatch.hpp"
#include "../GUI/GUI.hpp"
#include "../macros.hpp"
#include <type_traits>
#include <memory>
 
hi_export_module(hikogui.widgets.async_delegate);
 
hi_export namespace hi {
inline namespace v1 {

class async_delegate {
public:
    virtual ~async_delegate() = default;
 
    virtual void init(widget_intf const& sender) noexcept {}
 
    virtual void deinit(widget_intf const& sender) noexcept {}

    virtual void activate(widget_intf const& sender) noexcept {}

    [[nodiscard]] virtual cancel_features_type features() const noexcept
    {
        return cancel_features_type::none;
    }

    [[nodiscard]] virtual widget_value state(widget_intf const& sender) const noexcept
    {
        return widget_value::off;
    }

    template<forward_of<void()> Func>
    [[nodiscard]] callback<void()> subscribe(Func&& func, callback_flags flags = callback_flags::synchronous) noexcept
    {
        return _notifier.subscribe(std::forward<Func>(func), flags);
    }
 
protected:
    notifier<void()> _notifier;
};

template<typename ResultType = void>
class default_async_delegate : public async_delegate {
public:
    using result_type = ResultType;

    template<typename Func, typename... Args>
    default_async_delegate(Func&& func, Args&&... args) noexcept :
        _task_controller(std::forward<Func>(func), std::forward<Args>(args)...)
    {
        _task_controller_cbt = _task_controller.subscribe([this] {
            this->_notifier();
        });
    }

    [[nodiscard]] widget_value state(widget_intf const& sender) const noexcept override
    {
        if (not _task_controller.runnable()) {
            return widget_value::other;
 
        } else if (_task_controller.running()) {
            return widget_value::on;
 
        } else {
            return widget_value::off;
        }
    }
 
    [[nodiscard]] cancel_features_type features() const noexcept override
    {
        return _task_controller.features();
    }
 
    void activate(widget_intf const& sender) noexcept override
    {
        if (not _task_controller.runnable()) {
            return;
 
        } else if (not _task_controller.running()) {
            _task_controller.run();
 
        } else if (
            _task_controller.features() == cancel_features_type::stop or
            _task_controller.features() == cancel_features_type::stop_and_progress) {
            _task_controller.request_stop();
        }
    }
private:
    task_controller<result_type> _task_controller;
    task_controller<result_type>::callback_type _task_controller_cbt;
};
 
template<typename FuncType, typename... ArgTypes>
using default_async_delegate_result_type =
    invoke_task_result_t<decltype(cancelable_async_task<FuncType, ArgTypes...>), FuncType, std::stop_token, progress_token, ArgTypes...>;
 
template<typename F, typename... Args>
default_async_delegate(F&& func, Args&&... args) -> default_async_delegate<default_async_delegate_result_type<F, Args...>>;
 
} // namespace v1
}