ApplicationState.hpp

Go to the documentation of this file.

#ifndef SRC_CONFIGURATION_APPLICATIONSTATE_HPP_
#define SRC_CONFIGURATION_APPLICATIONSTATE_HPP_

#include <boost/atomic.hpp>
#include <boost/thread/mutex.hpp>

#include <configuration/PropertyTree.hpp>
#ifdef _WIN32
#include <system_utils/windows_extras.hpp> // extra windows stuff
#endif

namespace mic {

namespace application {

class Application;

class ApplicationState : public configuration::PropertyTree {
public:
    static ApplicationState* getInstance();

    // ---------------------- Quit flag MANAGEMENT.

    double Quit();

    void setQuit();

    void resetQuit();

    // ---------------------- Single step flag MANAGEMENT.

    double isPaused();

    void pressPause();

    // ---------------------- Single step mode MANAGEMENT.

    double isSingleStepModeOn();

    void pressSingleStep();

    // ---------------------- Learning mode MANAGEMENT.

    double isLearningModeOn();

    void pressLearning();

    void setLearningModeOn();

    void setLearningModeOff();

    // ---------------------- Using NCURSES mode MANAGEMENT.

    double usingNCURSES();

    void startUsingNCURSES();

    void stopUsingNCURSES();


    // ---------------------- Using OpenGL mode MANAGEMENT.

    double usingOpenGL();

    void startUsingOpenGL();

    void stopUsingOpenGL();


    // ---------------------- SLEEP INTERVAL MANAGEMENT.

    double getSleepInterval();

    void setSleepIntervalS(double sleep_interval_in_seconds);

    void setSleepIntervalMS(double sleep_interval_in_miliseconds);

    void setSleepIntervalUS(double sleep_interval_in_microseconds);

    void multiplySleepInterval(double m_ = 1.5);

    void divideSleepInterval(double d_ = 1.5);

    void displayStatus();

    boost::mutex & dataSynchronizationMutex() {
        return external_data_synchronization_mutex;
    }

    void setApplication(mic::application::Application *application_);

private:
    static boost::atomic<ApplicationState*> instance_;

    static boost::mutex instantiation_mutex;

    static boost::mutex internal_data_synchronization_mutex;

    static boost::mutex external_data_synchronization_mutex;


    bool quit_flag;

    mic::configuration::Property<bool> pause_mode;

    mic::configuration::Property<bool> single_step_mode;

    mic::configuration::Property<bool> learning_mode;

    bool using_ncurses;

    bool using_opengl;


    mic::configuration::Property<double> application_sleep_interval;

    ApplicationState();

    void setSleepInterval(double sleep_interval_);

    virtual void initializePropertyDependentVariables() { };

    mic::application::Application *application;

};

#define APP_STATE mic::application::ApplicationState::getInstance()


#define APP_SLEEP() usleep(APP_STATE->getSleepInterval())


#define APP_DATA_SYNCHRONIZATION_SCOPED_LOCK() boost::mutex::scoped_lock lock(APP_STATE->dataSynchronizationMutex())

} /* namespace application */
} /* namespace mic */




#endif /* SRC_CONFIGURATION_APPLICATIONSTATE_HPP_ */