progress_tracker.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2025 Oğuz Toraman <oguz.toraman@tutanota.com> */
/* SPDX-License-Identifier: LGPL-3.0-only */
 
#ifndef PROGRESS_TRACKER_HPP
#define PROGRESS_TRACKER_HPP
 
#include <chrono>
#include <condition_variable>
#include <mutex>
 
#include "percentage.hpp"
 
namespace recognition {
 
namespace utility {
 
class progress_tracker {
public:
    explicit progress_tracker(std::uint64_t total_steps = 1u) noexcept
      : m_total_steps{std::max<std::uint64_t>(total_steps, 1u)}
    { }
 
    void advance(std::uint64_t step_count = 1u) noexcept
    {
        std::lock_guard lock{m_mutex};
        m_completed_steps = std::min(
            m_completed_steps + step_count,
            m_total_steps
        );
        m_condition_variable.notify_all();
    }
 
    [[nodiscard]] std::uint64_t get_completed_steps() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_completed_steps;
    }
 
    [[nodiscard]] percentage get_completion_percentage() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return percentage{m_completed_steps, m_total_steps};
    }
 
    [[nodiscard]] std::uint64_t get_incompleted_steps() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_total_steps - m_completed_steps;
    }
 
    [[nodiscard]] std::uint64_t get_total_steps() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_total_steps;
    }
 
    [[nodiscard]] bool is_completed() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_completed_steps >= m_total_steps;
    }
 
    void mark_as_completed() noexcept
    {
        std::lock_guard lock{m_mutex};
        m_completed_steps = m_total_steps;
        m_condition_variable.notify_all();
    }
 
    void reset(std::uint64_t total_steps) noexcept
    {
        std::lock_guard lock{m_mutex};
        m_total_steps     = std::max<std::uint64_t>(total_steps, 1u);
        m_completed_steps = 0u;
        m_condition_variable.notify_all();
    }
 
    template <typename RepresentationType, typename PeriodType>
    [[nodiscard]] bool try_wait_for_completion(
        std::chrono::duration<RepresentationType, PeriodType> timeout
    ) const
    {
        std::unique_lock lock{m_mutex};
        return m_condition_variable.wait_for(lock, timeout, [this] {
            return m_completed_steps >= m_total_steps;
        });
    }
 
    template <typename ClockType, typename DurationType>
    [[nodiscard]] bool try_wait_for_completion_until(
        std::chrono::time_point<ClockType, DurationType> deadline
    ) const
    {
        std::unique_lock lock{m_mutex};
        return m_condition_variable.wait_until(lock, deadline, [this] {
            return m_completed_steps >= m_total_steps;
        });
    }
 
    void wait_for_completion() const
    {
        std::unique_lock lock{m_mutex};
        m_condition_variable.wait(lock, [this] {
            return m_completed_steps >= m_total_steps;
        });
    }
 
private:
    mutable std::mutex              m_mutex{};
    mutable std::condition_variable m_condition_variable{};
    std::uint64_t                   m_total_steps;
    std::uint64_t                   m_completed_steps{0u};
};
 
using shared_progress_tracker_t = std::shared_ptr<progress_tracker>;
 
inline shared_progress_tracker_t make_shared_progress_tracker(
    std::uint64_t total_steps = 1u
) noexcept
{
    return std::make_shared<progress_tracker>(total_steps);
}
 
class mark_tracker_as_completed {
public:
    explicit mark_tracker_as_completed(shared_progress_tracker_t shared_tracker
    ) noexcept
      : m_shared_tracker(shared_tracker)
    { }
 
    ~mark_tracker_as_completed()
    {
        if (!m_shared_tracker) {
            return;
        }
        m_shared_tracker->mark_as_completed();
    }
 
private:
    shared_progress_tracker_t m_shared_tracker;
};
 
class advance_tracker {
public:
    explicit advance_tracker(
        shared_progress_tracker_t shared_tracker,
        std::uint64_t             step_count = 1u
    ) noexcept
      : m_shared_tracker(shared_tracker)
      , m_step_count(step_count)
    { }
 
    ~advance_tracker()
    {
        if (!m_shared_tracker) {
            return;
        }
        m_shared_tracker->advance(m_step_count);
    }
 
private:
    shared_progress_tracker_t m_shared_tracker;
    std::uint64_t             m_step_count;
};
 
} /* namespace utility */
 
} /* namespace recognition */
 
#endif /* PROGRESS_TRACKER_HPP */