progress_tracker.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2026 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 ProgressTracker {
public:
    explicit ProgressTracker(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 GetCompletedSteps() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_completed_steps;
    }

    [[nodiscard]] Percentage GetCompletionPercentage() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return Percentage{m_completed_steps, m_total_steps};
    }

    [[nodiscard]] std::uint64_t GetIncompletedSteps() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_total_steps - m_completed_steps;
    }

    [[nodiscard]] std::uint64_t GetTotalSteps() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_total_steps;
    }

    [[nodiscard]] bool IsCompleted() const noexcept
    {
        std::lock_guard lock{m_mutex};
        return m_completed_steps >= m_total_steps;
    }

    void MarkAsCompleted() 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 RepresentationT, typename PeriodT>
    [[nodiscard]] bool TryWaitForCompletion(
        std::chrono::duration<RepresentationT, PeriodT> 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 ClockT, typename DurationT>
    [[nodiscard]] bool TryWaitForCompletionUntil(
        std::chrono::time_point<ClockT, DurationT> 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 WaitForCompletion() 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 SharedProgressTrackerT = std::shared_ptr<ProgressTracker>;

inline SharedProgressTrackerT MakeSharedProgressTracker(
    std::uint64_t total_steps = 1u
) noexcept
{
    return std::make_shared<ProgressTracker>(total_steps);
}

class MarkTrackerAsCompleted {
public:
    explicit MarkTrackerAsCompleted(
        SharedProgressTrackerT shared_progress_tracker
    ) noexcept
      : m_shared_progress_tracker(shared_progress_tracker)
    { }

    ~MarkTrackerAsCompleted()
    {
        if (!m_shared_progress_tracker) {
            return;
        }
        m_shared_progress_tracker->MarkAsCompleted();
    }
 
private:
    SharedProgressTrackerT
        m_shared_progress_tracker; 
};

class AdvanceTracker {
public:
    explicit AdvanceTracker(
        SharedProgressTrackerT shared_progress_tracker,
        std::uint64_t          step_count = 1u
    ) noexcept
      : m_shared_progress_tracker(shared_progress_tracker)
      , m_step_count(step_count)
    { }

    ~AdvanceTracker()
    {
        if (!m_shared_progress_tracker) {
            return;
        }
        m_shared_progress_tracker->Advance(m_step_count);
    }
 
private:
    SharedProgressTrackerT
        m_shared_progress_tracker; 
    std::uint64_t m_step_count;    
};
} /* namespace Utility */
} /* namespace Recognition */
 
#endif /* PROGRESS_TRACKER_HPP */