SEESMode.h

#ifndef SEESMode_H_
#define SEESMode_H_
// -----------------------------------------------------------------------------
#include <string>
#include <sstream>
#include <UniSetObject.h>
#include <ObjectsManager.h>
#include <UniversalInterface.h>
#include <MessageType.h>
#include "ObjectMode.h"
#include "SEESMessages.h"
#include "AutomatMessages.h"
#include "QG/QG.h"
#include "Diesel/Diesel.h"
#include "Generator/Generator.h"
#include "SEESTypes.h"
// -----------------------------------------------------------------------------
class SEES;
class SEESControl;

class SEESMode
{
    public:
        static SEESMode* Instance();
        virtual ~SEESMode();
        void Destroy();

        virtual void step( SEES* sc ){}

        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc){}
        virtual void sysCommand( UniSetTypes::SystemMessage* sm, SEES* sc){}
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual void seesInfo( SEESMessage *sm, SEES* sc ){}

        virtual bool activate( SEES* sc){ return true; }
        virtual bool disactivate( SEES* sc){ return true; }
        
        virtual const string modeName(){ return "???Mode";}
        virtual std::ostringstream& modeInfo( std::ostringstream& os){ return os;}

        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::InitMode; }

        void protection();
        
    protected:
        SEESMode();
        void changeMode( SEESMode* m, SEES* sc );

        void askTimer( SEES* sc, short timerid, long timeMS, short ticks=-1 );
        void resetModeTimer( SEES* sc );
        void setMyControlMode( SEES* sc, unsigned int control_mode );
        void updateReservNeeded( SEES* sc );

    private:
        static SEESMode* inst;
};
// ---------------------------------------------------------------------------
class SEESOffMode:
    public SEESMode
{
    public:
        static SEESOffMode* Instance();
        void Destroy();
        virtual ~SEESOffMode();

        // --------
    
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual void sysCommand( UniSetTypes::SystemMessage* sm, SEES* sc);
//      virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc);
        
        virtual bool activate(SEES* sc);
        virtual const string modeName(){ return "SEESOffMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::OffMode; }
//      virtual std::ostringstream& modeInfo( std::ostringstream& os);


    protected:
        SEESOffMode();

    private:
        static SEESOffMode* inst;
};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
class SEESOnMode:
    public SEESMode
{
    public:
        static SEESOnMode* Instance();
        void Destroy();
        virtual ~SEESOnMode();

        // --------
    
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual void sysCommand( UniSetTypes::SystemMessage* sm, SEES* sc);
        
        virtual bool activate( SEES* sc );
        virtual const string modeName(){ return "SEESOnMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::OnMode; }

    protected:
        SEESOnMode();
        void init( SEES* sc );
        
    private:
        static SEESOnMode* inst;
};
// ---------------------------------------------------------------------------
class SEESRunningMode:
    public SEESMode
{
    public:
        static SEESRunningMode* Instance();
        void Destroy();
        virtual ~SEESRunningMode();

        // --------
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual bool activate( SEES* sc );
        virtual const string modeName(){ return "SEESRunningMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::RunningMode; }

    protected:
        SEESRunningMode();
        
    private:
        static SEESRunningMode* inst;
};

// ---------------------------------------------------------------------------
class SEESOnReservMode:
    public SEESOnMode
{
    public:
        static SEESOnReservMode* Instance();
        void Destroy();
        virtual ~SEESOnReservMode();

        // --------
        virtual bool activate( SEES* sc );
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual const string modeName(){ return "SEESOnReservMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::ReservMode; }

    protected:
        SEESOnReservMode();

        
    private:
        static SEESOnReservMode* inst;
};
// ---------------------------------------------------------------------------
class SEESOnAutoMode:
    public SEESOnReservMode
{
    public:
        static SEESOnAutoMode* Instance();
        void Destroy();
        virtual ~SEESOnAutoMode();

        // --------
        virtual bool activate( SEES* sc );
        virtual bool disactivate( SEES* sc );
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc);

        virtual const string modeName(){ return "SEESOnAutoMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::AutoMode; }

    protected:
        SEESOnAutoMode();

        
    private:
        static SEESOnAutoMode* inst;
};


// ---------------------------------------------------------------------------
class SEESReservMode:
    public SEESMode
{
    public:
        static SEESReservMode* Instance();
        void Destroy();
        virtual ~SEESReservMode();

        // --------
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc);

        virtual bool activate(SEES* sc);
        virtual bool disactivate(SEES* sc);
        virtual const string modeName(){ return "SEESReservMode";}

        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::ReservMode; }

    protected:
        SEESReservMode();

        
    private:
        static SEESReservMode* inst;
};

// ---------------------------------------------------------------------------
class SEESAutoMode:
    public SEESReservMode
{
    public:
        static SEESAutoMode* Instance();
        void Destroy();
        virtual ~SEESAutoMode();

        // --------
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc );

        virtual bool activate(SEES* sc);
        virtual bool disactivate(SEES* sc);
        virtual const string modeName(){ return "SEESAutoMode"; }

        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::AutoMode; }

    protected:
        SEESAutoMode();

        
    private:
        static SEESAutoMode* inst;
};


// ---------------------------------------------------------------------------
class SEESProtectionMode:
    public SEESMode
{
    public:
        static SEESProtectionMode* Instance();
        void Destroy();
        virtual ~SEESProtectionMode();

        // --------
    
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual void sysCommand( UniSetTypes::SystemMessage* sm, SEES* sc);
        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc);
        
        virtual bool activate(SEES* sc);
        virtual bool disactivate(SEES* sc);
        virtual const string modeName(){ return "SEESProtectionMode"; }
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::ProtectionMode; }

    protected:
        SEESProtectionMode();
        bool updateLamp( SEES* sc );

    
    private:
        static SEESProtectionMode* inst;
};

// ---------------------------------------------------------------------------
class SEESInitMode:
    public SEESMode
{
    public:
        static SEESInitMode* Instance();
        void Destroy();
        virtual ~SEESInitMode();

        // --------
    
        virtual bool activate(SEES* sc);
        virtual const string modeName(){ return "SEESInitMode"; }
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::InitMode; }
        
        bool checkMode( SEES* sc );

    protected:
        SEESInitMode();
    
    private:
        static SEESInitMode* inst;
};

// ---------------------------------------------------------------------------
class SEESWaitingMode:
    public SEESMode
{
    public:

        static SEESWaitingMode* Instance( SEES* sc,
                                            SEESMessage::SEESMode to, 
                                            SEESMode* back=SEESProtectionMode::Instance(), 
                                            int atempt=0 );

        void Destroy();
        virtual ~SEESWaitingMode();

        // --------
    
        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc);
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc );
        virtual void seesInfo( SEESMessage *sm, SEES* sc );

        virtual bool activate( SEES* sc);
        virtual bool disactivate( SEES* sc);
        virtual const string modeName(){ return "SEESWaitingMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::WaitingMode; }

    protected:
        SEESWaitingMode();
        void rollback( SEES* sc );
        void commandFailed( SEES* sc );

    private:
        static SEESWaitingMode* inst;
};
// ---------------------------------------------------------------------------
class SEESAutoWaitingMode:
    public SEESMode
{
    public:

        static SEESAutoWaitingMode* Instance( SEES* sc,
                                            SEESMessage::SEESMode to, 
                                            SEESMode* back=SEESProtectionMode::Instance(), 
                                            int atempt=0 );

        void Destroy();
        virtual ~SEESAutoWaitingMode();

        // --------
    
        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc);
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc );

        virtual bool activate( SEES* sc);
        virtual bool disactivate( SEES* sc);
        virtual const string modeName(){ return "SEESAutoWaitingMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::AutoWaitingMode; }

    protected:
        SEESAutoWaitingMode();
        void rollback( SEES* sc );

    private:
        static SEESAutoWaitingMode* inst;
};
// ---------------------------------------------------------------------------

class SEESSleepMode:
    public SEESMode
{
    public:
        static SEESSleepMode* Instance();
        void Destroy();
        virtual ~SEESSleepMode();

        // --------
        virtual void sensorInfo( UniSetTypes::SensorMessage* sm, SEES* sc);
        virtual void timerInfo( UniSetTypes::TimerMessage *tm, SEES* sc);
        virtual bool activate(SEES* sc);
        virtual bool disactivate( SEES* sc);
        
        virtual const string modeName(){ return "SEESSleepMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::SleepMode; }

    protected:
        SEESSleepMode();
        void checkState( SEES* sc );

    private:
        static SEESSleepMode* inst;
};
// ---------------------------------------------------------------------------
class SEESUndefinedMode:
    public SEESMode
{
    public:
        static SEESUndefinedMode* Instance();
        void Destroy();
        virtual ~SEESUndefinedMode();

        // --------
        virtual void sensorInfo( UniSetTypes::SensorMessage *sm, SEES* sc);
        virtual bool activate(SEES* sc);
        virtual const string modeName(){ return "SEESUndefinedMode";}
        virtual SEESMessage::SEESMode getMode(){ return SEESMessage::UdefinedMode; }


    protected:
        SEESUndefinedMode();

    private:
        static SEESUndefinedMode* inst;
};
// ---------------------------------------------------------------------------
#endif // SEESMode_H_