Sequencer.h

Go to the documentation of this file.

#pragma once

#pragma warning(push)
#pragma warning(disable : 4100)
#include <functional>
#include <map>
#include <set>
#include <string>
#pragma warning(pop)

#include <Base/String.h>
#include <Base/Timer.h>
#include <Base/base_defines.h>

#include <QString>

namespace Base
{
class BASE_EXPORT ProgressInfo
{
public:
    enum ProgressObserverInfoID
    {
        ACIS_PROGRESS,

    };


    ProgressInfo(ProgressObserverInfoID id, std::string de, int percent) : m_id(id), m_desc(de), m_percent(percent) {}


    int m_percent;
    std::string m_desc;
    ProgressObserverInfoID m_id;
};

class BASE_EXPORT ProgressObserver
{
public:
    ProgressObserver(){};
    virtual ~ProgressObserver(){};
    virtual void notify(ProgressInfo info) = 0;
};


typedef std::function<void(ProgressInfo)> ProgressHandler;

class BASE_EXPORT Progress
{
public:
    void notify(ProgressInfo info)
    {
        for (auto o : m_observer)
            o->notify(info);
        for (auto o : m_handlers)
            o.second(info);
    }

    std::set<ProgressObserver*> m_observer;
    std::map<std::string, ProgressHandler> m_handlers;

    void attach(std::string key, ProgressHandler hd) { m_handlers[key] = hd; }

    void attach(ProgressObserver* o) { m_observer.insert(o); }

    void detach(ProgressObserver* o) { m_observer.erase(o); }

    void detach(std::string key)
    {
        auto it = m_handlers.find(key);
        if (it != m_handlers.end())
            m_handlers.erase(it);
    }

    void detachAll()
    {
        m_observer.clear();
        m_handlers.clear();
    }
};

BASE_EXPORT Progress& ProgressSingleton();


typedef std::function<void(int)> SequencerCallBackFunc;
BASE_EXPORT void SequencerCallBackFunc_Default(int);


class BASE_EXPORT SequencerBase
{
public:
    static SequencerBase& instance(void);
    static void setInstance(SequencerBase* p);

    virtual bool startbusy(const std::string& caption, const std::string& message, bool forceShow);
    virtual bool startbusy(const Base::String& caption, const Base::String& message, bool forceShow);
    virtual bool start(const std::string& caption, const std::string& message, int steps, int from, int to, bool /*forceShow*/);
    virtual bool start(const Base::String& caption, const Base::String& message, int steps, int from, int to, bool /*forceShow*/);
    virtual void stop();
    virtual void setStep(int step, bool canAbort = true);
    virtual void setStepContinuous(int step, bool canAbort = true);
    virtual void setMessage(const std::string& message);
    virtual void setMessage(const Base::String& message);
    virtual void setMinimumDuration(int milliseconds);
    virtual int getMinimumDuration() const;
    virtual void busy1();
    virtual void busy10();
    virtual void busy100();
    virtual void busy1000();
    virtual void busy10000();


    virtual Base::String getMessage();
    virtual void setHidden(bool hidden);
    virtual void show(bool onoff);

    void abort();

    bool isRunning() const;
    int getCurrentStep() const;
    int getSteps() const;
    void setNextBlock(int from, int to);
    void getNextBlock(int& from, int& to);
    void setThisBlock(int from, int to);
    int getFrom();
    int getTo();

    void setNoWindowModeInfoFlag(bool aValue);
    bool getNoWindowModeInfoFlag();

    bool setWriteStepToStdout(bool aEnabled, std::string aOutputStepPrefixString);



protected:
    SequencerBase();
    virtual ~SequencerBase();

    bool _isRunning;
    bool _canAbort;
    int _currentStep;
    int _steps;

    int _thisBlockFrom;
    int _thisBlockTo;
    int _nextBlockFrom;
    int _nextBlockTo;
    int _minimumDuration;
    Base::String _message;

    bool _windowModeActiveFlag;
    bool _writeStepToStdout;
    std::string _writeStepToStdcoutPrefixString;

private:
    SequencerBase(const SequencerBase&){};
    static SequencerBase* _instance;
};



inline BASE_EXPORT Base::SequencerBase& Sequencer(void)
{
    return Base::SequencerBase::instance();
}

class BASE_EXPORT WaitingSpinner
{
public:
    static WaitingSpinner& instance(void);
    static void setInstance(WaitingSpinner* p);

public:
    virtual void start();
    virtual void stop();
    virtual void setText(Base::String txt);

public:
private:
    static WaitingSpinner* _instance;
};

class BASE_EXPORT ScopedWaitingSpinner
{
public:
    ScopedWaitingSpinner() { Base::WaitingSpinner::instance().start(); }
    ScopedWaitingSpinner(QString txt)
    {
        Base::WaitingSpinner::instance().setText(txt);
        Base::WaitingSpinner::instance().start();
    }
    ~ScopedWaitingSpinner() { Base::WaitingSpinner::instance().stop(); }
};


}  // namespace Base