progress.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
#ifndef INKSCAPE_ASYNC_PROGRESS_H
#define INKSCAPE_ASYNC_PROGRESS_H
 
#include <chrono>
 
namespace Inkscape {
namespace Async {
 
class CancelledException {};
 
template <typename... T>
class Progress
{
public:
    bool report(T const &... progress) { return _report(progress...); }
 
    void report_or_throw(T const &... progress) { if (!_report(progress...)) throw CancelledException(); }
 
    bool keepgoing() const { return _keepgoing(); }
 
    void throw_if_cancelled() const { if (!_keepgoing()) throw CancelledException(); }
 
    operator bool() const { return _keepgoing(); }
 
protected:
    ~Progress() = default;
    virtual bool _keepgoing() const = 0;
    virtual bool _report(T const &... progress) = 0;
};
 
template <typename T, typename... S>
class SubProgress final
    : public Progress<T, S...>
{
public:
    SubProgress(Progress<T, S...> &parent, T from, T amount)
    {
        if (auto p = dynamic_cast<SubProgress*>(&parent)) {
            _root = p->_root;
            _from = p->_from + p->_amount * from;
            _amount = p->_amount * amount;
        } else {
            _root = &parent;
            _from = from;
            _amount = amount;
        }
    }
 
private:
    Progress<T, S...> *_root;
    T _from, _amount;
 
    bool _keepgoing() const override { return _root->keepgoing(); }
    bool _report(T const &progress, S const &... aux) override { return _root->report(_from + _amount * progress, aux...); }
};
 
template <typename T, typename... S>
class ProgressStepThrottler final
    : public Progress<T, S...>
{
public:
    ProgressStepThrottler(Progress<T, S...> &parent, T step)
        : parent(&parent), step(step) {}
 
private:
    Progress<T, S...> *parent;
    T step;
    T last = 0;
 
    bool _keepgoing() const override { return parent->keepgoing(); }
 
    bool _report(T const &progress, S const &... aux) override
    {
        if (progress - last < step) {
            return parent->keepgoing();
        } else {
            last = progress;
            return parent->report(progress, aux...);
        }
    }
};
 
template <typename... T>
class ProgressTimeThrottler final
    : public Progress<T...>
{
    using clock = std::chrono::steady_clock;
    using time_point = clock::time_point;
 
public:
    using duration = clock::duration;
 
    ProgressTimeThrottler(Progress<T...> &parent, duration interval)
        : parent(&parent), interval(interval) {}
 
private:
    Progress<T...> *parent;
    duration interval;
    time_point last = clock::now();
 
    bool _keepgoing() const override { return parent->keepgoing(); }
 
    bool _report(T const &... progress) override
    {
        auto now = clock::now();
        if (now - last < interval) {
            return parent->keepgoing();
        } else {
            last = now;
            return parent->report(progress...);
        }
    }
};
 
template <typename... T>
class ProgressAlways final
    : public Progress<T...>
{
private:
    bool _keepgoing() const override { return true; }
    bool _report(T const &...) override { return true; }
};
 
} // namespace Async
} // namespace Inkscape
 
#endif // INKSCAPE_ASYNC_PROGRESS_H