baseexperiment.h

/********************************************************************************
 *  FARSA                                                                       *
 *  Copyright (C) 2007-2012                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef BASEEXPERIMENT_H
#define BASEEXPERIMENT_H

#include "experimentsconfig.h"
#include "dataexchange.h"
#include "component.h"
#include "workerthread.h"
#include "parametersettable.h"
#include "parametersettableui.h"
#include "baseexception.h"
#include "configurationhelper.h"
#include "logger.h"
#include "flowcontrol.h"
#include <QMutex>
#include <QMutexLocker>
#include <QWaitCondition>
#include <QSignalMapper>
#include <QList>
#include <QVector>
#include <QAction>
#include <QMenu>
#include <QMenuBar>
#include <memory>
#include <QtGlobal>

namespace farsa {

class BaseExperimentGUI;

namespace __BaseExperiment_internal {
    class BaseExperimentUIManager;

    struct FARSA_EXPERIMENTS_TEMPLATE OperationStatus {
        enum Status {
            NewOperation, 
            OperationStarted, 
            OperationEnded, 
            OperationPaused, 
            OperationResumed, 
            OperationStepDelayChanged 
        };

        Status status;

        unsigned int operationID;

        unsigned long delay;
    };

    struct FARSA_EXPERIMENTS_TEMPLATE OperationControl {
        enum Action {
            StartOperation, 
            StartOperationPaused, 
            StopOperation, 
            PauseOperation, 
            StepOperation, 
            ResumeOperation, 
            ChangeInterval 
        };

        Action action;

        unsigned int operationID;

        unsigned long interval;
    };
}

class FARSA_EXPERIMENTS_API BaseExperiment : public Component, public ParameterSettableUI, public ThreadOperation, private FlowControlled
{
    Q_OBJECT

private:
    class Notifee : public NewDatumNotifiable<__BaseExperiment_internal::OperationControl>
    {
    public:
        Notifee(BaseExperiment& experiment);

        virtual ~Notifee();

        virtual void newDatumAvailable(DataDownloader<__BaseExperiment_internal::OperationControl>* downloader);

    private:
        BaseExperiment& m_experiment;
    };

    friend class Notifee;

    class BaseExperimentFlowController : public FlowController
    {
    public:
        BaseExperimentFlowController(BaseExperiment* baseExperiment);

        virtual bool stop();

        virtual void pause();

    private:
        BaseExperiment* m_baseExperiment;
    };

    friend class BaseExperimentFlowController;

public:
    class AbstractOperationWrapper
    {
    public:
        QString getName() const
        {
            return name;
        }

        bool getUseSeparateThread() const
        {
            return useSeparateThread;
        }

        bool getSteppable() const
        {
            return steppable;
        }

    private:
        virtual ~AbstractOperationWrapper()
        {
        }

        virtual void executeOperation() = 0;

        QString name;

        bool useSeparateThread;

        bool steppable;

        friend class BaseExperiment;

        template <class T>
        friend class std::auto_ptr;
    };

    template <class T>
    class OperationWrapper : public AbstractOperationWrapper
    {
    public:
        OperationWrapper(T* experiment, void (T::*operation)())
            : AbstractOperationWrapper()
            , m_experiment(experiment)
            , m_operation(operation)
        {
        }

    private:
        virtual ~OperationWrapper()
        {
        }

        virtual void executeOperation()
        {
            (m_experiment->*m_operation)();
        }

        T* const m_experiment;

        void (T::*m_operation)();
    };

    template <class T, class P0>
    class OperationWrapperOneParameter : public AbstractOperationWrapper
    {
    public:
        OperationWrapperOneParameter(T* experiment, void (T::*operation)(P0), P0 p0)
            : AbstractOperationWrapper()
            , m_experiment(experiment)
            , m_operation(operation)
            , m_p0(p0)
        {
        }

        const P0& p0() const
        {
            return m_p0;
        }

    private:
        virtual ~OperationWrapperOneParameter()
        {
        }

        virtual void executeOperation()
        {
            (m_experiment->*m_operation)(m_p0);
        }

        T* const m_experiment;

        void (T::*m_operation)(P0);

        const P0 m_p0;
    };

    template <class T, class P0, class P1>
    class OperationWrapperTwoParameters : public AbstractOperationWrapper
    {
    public:
        OperationWrapperTwoParameters(T* experiment, void (T::*operation)(P0, P1), P0 p0, P1 p1)
            : AbstractOperationWrapper()
            , m_experiment(experiment)
            , m_operation(operation)
            , m_p0(p0)
            , m_p1(p1)
        {
        }

        const P0& p0() const
        {
            return m_p0;
        }

        const P1& p1() const
        {
            return m_p1;
        }

    private:
        virtual ~OperationWrapperTwoParameters()
        {
        }

        virtual void executeOperation()
        {
            (m_experiment->*m_operation)(m_p0, m_p1);
        }

        T* const m_experiment;

        void (T::*m_operation)(P0, P1);

        const P0 m_p0;

        const P1 m_p1;
    };

    template <class T, class P0, class P1, class P2>
    class OperationWrapperThreeParameters : public AbstractOperationWrapper
    {
    public:
        OperationWrapperThreeParameters(T* experiment, void (T::*operation)(P0, P1, P2), P0 p0, P1 p1, P2 p2)
            : AbstractOperationWrapper()
            , m_experiment(experiment)
            , m_operation(operation)
            , m_p0(p0)
            , m_p1(p1)
            , m_p2(p2)
        {
        }

        const P0& p0() const
        {
            return m_p0;
        }

        const P1& p1() const
        {
            return m_p1;
        }

        const P2& p2() const
        {
            return m_p2;
        }

    private:
        virtual ~OperationWrapperThreeParameters()
        {
        }

        virtual void executeOperation()
        {
            (m_experiment->*m_operation)(m_p0, m_p1, m_p2);
        }

        T* const m_experiment;

        void (T::*m_operation)(P0, P1, P2);

        const P0 m_p0;

        const P1 m_p1;

        const P1 m_p2;
    };

public:
    BaseExperiment();

    virtual ~BaseExperiment();

    virtual void configure(ConfigurationParameters& params, QString prefix);

    virtual void save(ConfigurationParameters& params, QString prefix);

    static void describe(QString type);

    virtual void postConfigureInitialization();

    virtual ParameterSettableUI* getUIManager();

    virtual void fillActionsMenu(QMenu* actionsMenu);

    virtual QList<ParameterSettableUIViewer> getViewers(QWidget* parent, Qt::WindowFlags flags);

    virtual void addAdditionalMenus(QMenuBar* menuBar);

    virtual void run();

    virtual void stop();

    void pause();

    void step();

    void resume();

    void changeInterval(unsigned long interval);

    unsigned long currentInterval() const;

    const QVector<AbstractOperationWrapper*>& getOperations() const;

    DataUploaderDownloader<__BaseExperiment_internal::OperationStatus, __BaseExperiment_internal::OperationControl>* getUploaderDownloader();

    FlowController* flowController()
    {
        return &m_flowController;
    }

public slots:
    virtual void stopCurrentOperation(bool wait);

    virtual void stopCurrentOperation();

private slots:
    void exceptionDuringOperation(farsa::BaseException *e);

    void runOperation(int operationID);

protected:
    QList<QAction*> getActionsForOperations(QObject* actionsParent) const;

    template <class T>
    void addOperation(QString name, void (T::*func)(), bool useSeparateThread, bool steppable)
    {
        std::auto_ptr<AbstractOperationWrapper> newOp(new OperationWrapper<T>(static_cast<T*>(this), func));
        newOp->name = name;
        newOp->useSeparateThread = useSeparateThread;
        newOp->steppable = steppable;

        m_operationsVector.push_back(newOp.release());

        // Signalling a new operation has been added
        uploadNewOperationStatus(__BaseExperiment_internal::OperationStatus::NewOperation, m_operationsVector.size() - 1);
    }

    template <class T, class P0>
    void addOperation(QString name, void (T::*func)(P0), P0 p0, bool useSeparateThread, bool steppable)
    {
        std::auto_ptr<AbstractOperationWrapper> newOp(new OperationWrapperOneParameter<T, P0>(static_cast<T*>(this), func, p0));
        newOp->name = name;
        newOp->useSeparateThread = useSeparateThread;
        newOp->steppable = steppable;

        m_operationsVector.push_back(newOp.release());

        // Signalling a new operation has been added
        uploadNewOperationStatus(__BaseExperiment_internal::OperationStatus::NewOperation, m_operationsVector.size() - 1);
    }

    template <class T, class P0, class P1>
    void addOperation(QString name, void (T::*func)(P0, P1), P0 p0, P1 p1, bool useSeparateThread, bool steppable)
    {
        std::auto_ptr<AbstractOperationWrapper> newOp(new OperationWrapperTwoParameters<T, P0, P1>(static_cast<T*>(this), func, p0, p1));
        newOp->name = name;
        newOp->useSeparateThread = useSeparateThread;
        newOp->steppable = steppable;

        m_operationsVector.push_back(newOp.release());

        // Signalling a new operation has been added
        uploadNewOperationStatus(__BaseExperiment_internal::OperationStatus::NewOperation, m_operationsVector.size() - 1);
    }

    template <class T, class P0, class P1, class P2>
    void addOperation(QString name, void (T::*func)(P0, P1, P2), P0 p0, P1 p1, P2 p2, bool useSeparateThread, bool steppable)
    {
        std::auto_ptr<AbstractOperationWrapper> newOp(new OperationWrapperThreeParameters<T, P0, P1, P2>(static_cast<T*>(this), func, p0, p1, p2));
        newOp->name = name;
        newOp->useSeparateThread = useSeparateThread;
        newOp->steppable = steppable;

        m_operationsVector.push_back(newOp.release());

        // Signalling a new operation has been added
        uploadNewOperationStatus(__BaseExperiment_internal::OperationStatus::NewOperation, m_operationsVector.size() - 1);
    }

    bool batchRunning() const;

    using FlowControlled::stopFlow;

    using FlowControlled::pauseFlow;

private:
    bool stopSimulation();

    void checkPause();

    void resetStop();

    void uploadNewOperationStatus(__BaseExperiment_internal::OperationStatus::Status status, unsigned int operationID, unsigned long newDelay = 0);

    void changeInterval(unsigned long interval, bool sendNotificationToGUI);

    QVector<AbstractOperationWrapper*> m_operationsVector;

    std::auto_ptr<QSignalMapper> m_actionSignalsMapper;

    std::auto_ptr<WorkerThread> const m_workerThread;

    int m_runningOperationID;

    bool m_batchRunning;

    bool m_stop;

    QMutex m_mutex;

    QWaitCondition m_waitCondition;

    bool m_pause;

    bool m_previousPauseStatus;

    unsigned long m_delay;

    Notifee m_notifee;

    DataUploaderDownloader<__BaseExperiment_internal::OperationStatus, __BaseExperiment_internal::OperationControl> m_dataExchange;

    BaseExperimentFlowController m_flowController;
};

} // End namespace farsa

#define DECLARE_THREAD_OPERATION(classname, op) addOperation(#op, &classname::op, true, false);

#define DECLARE_STEPPABLE_THREAD_OPERATION(classname, op) addOperation(#op, &classname::op, true, true);

#define DECLARE_IMMEDIATE_OPERATION(classname, op) addOperation(#op, &classname::op, false, false);

#endif