Progress.h

#ifndef ROSE_Progress_H
#define ROSE_Progress_H
 
#include <Rose/BasicTypes.h>
 
#include <Rose/Constants.h>
#include <ROSE_UNUSED.h>
 
#include <boost/chrono.hpp>
#include <boost/thread.hpp>
#include <rose_isnan.h>
#include <Sawyer/Stopwatch.h>
#include <Sawyer/Synchronization.h>
#include <string>
#include <vector>
 
namespace Rose {
 
class Progress: public Sawyer::SharedObject {
public:
    using Ptr = ProgressPtr;
 
    struct Report {
        std::string name;                               
        double completion;                              
        double maximum;                                 
        Report()
            : completion(0.0), maximum(1.0) {}
 
        explicit Report(double completion, double maximum = 1.0)
            : completion(completion), maximum(maximum) {}
 
        Report(const std::string &name, double completion, double maximum = 1.0)
            : name(name), completion(completion), maximum(maximum) {}
    };
 
private:
    static const size_t TERMINATING = INVALID_INDEX;
 
    // Synchronized data members
    mutable SAWYER_THREAD_TRAITS::Mutex mutex_;         // protects the following data members
#if SAWYER_MULTI_THREADED
    mutable SAWYER_THREAD_TRAITS::ConditionVariable cv_;// for signaling changes to the latestReport_
#endif
    std::vector<Report> reports_;                       // report stack, one elemet per nested phase
    size_t reportNumber_;                               // sequence number of latestReport_, or TERMINATING
    Sawyer::Stopwatch reportAge_;                       // time since last report arrived (or since construction)
 
protected:
    Progress(): reportNumber_(0) {}
 
public:
    static Ptr instance();
 
public:
    void update(double completion, double maximum = 1.0);
    void update(const Report&);
    Report push();
    Report push(double completion, double maximum = 1.0);
    Report push(const Report&);
    void pop();
    void pop(double completion, double maximum = 1.0);
    void pop(const Report&);
    void finished();
    void finished(double completion, double maximum = 1.0);
    void finished(const Report&);
    bool isFinished() const;
 
    std::pair<Report, double /*seconds*/> reportLatest(const std::string &nameSeparator = ".") const;
 
    template<class Functor>
    bool reportRegularly(boost::chrono::milliseconds interval, Functor f, const std::string &nameSeparator = ".") const {
        // Makes no sense for single threaded. Does not compile when ROSE is built with CMake
#if SAWYER_MULTI_THREADED && !defined(ROSE_USE_CMAKE)
        while (1) {
            std::pair<Report, double /*seconds*/> rpt = reportLatest(nameSeparator);
            if (!f(rpt.first, rpt.second))
                return false;
            if (isFinished())
                return true;
            boost::this_thread::sleep_for(interval);
        }
#else
        ROSE_UNUSED(interval);
        ROSE_UNUSED(f);
        ROSE_UNUSED(nameSeparator);
        return false;
#endif
    }
    
    template<class Functor>
    bool reportChanges(boost::chrono::milliseconds limit, Functor f, const std::string &nameSeparator = ".") const {
#if SAWYER_MULTI_THREADED && !defined(ROSE_USE_CMAKE)   // makes no sense for single threaded. Does not compile with cmake
        Sawyer::Stopwatch timer;
        size_t seen = TERMINATING - 1;
        while (1) {
            SAWYER_THREAD_TRAITS::UniqueLock lock(mutex_);
            while (reportNumber_ == seen)
                cv_.wait(lock);
            ASSERT_forbid(reports_.empty());
            Report report = reports_.back();
            report.name = reportNameNS(nameSeparator);
            seen = reportNumber_;
            lock.unlock();
 
            if (!f(report))
                return false;
            if (TERMINATING == seen)
                return true;
            boost::this_thread::sleep_for(limit);
        }
#else
        ROSE_UNUSED(limit);
        ROSE_UNUSED(f);
        ROSE_UNUSED(nameSeparator);
        return false;
#endif
    }
 
private:
    std::string reportNameNS(const std::string &nameSeparator) const;
};
 
class ProgressTask {
    Progress::Ptr progress_;
    Progress::Report after_;
 
public:
    ProgressTask(const Progress::Ptr &progress, const std::string &name, double afterCompletion = NAN)
        : progress_(progress) {
        if (progress_) {
            after_ = progress_->push(Progress::Report(name, 0.0));
            if (!rose_isnan(afterCompletion))
                after_.completion = afterCompletion;
        }
    }
 
    ProgressTask(const std::string &name, double afterCompletion = NAN)
        : progress_(Progress::instance()) {
        after_ = progress_->push(Progress::Report(name, 0.0));
        if (!rose_isnan(afterCompletion))
            after_.completion = afterCompletion;
    }
 
    ~ProgressTask() {
        if (progress_)
            progress_->pop(after_);
    }
 
public:
    Progress::Ptr progress() const {
        return progress_;
    }
 
    void cancel() {
        progress_ = Progress::Ptr();
    }
};
 
} // namespace
 
#endif