States.h

Go to the documentation of this file.

/* Copyright (C) 2015 Infron Ltd. - All Rights Reserved
 *
 * Redistribution of this file without permission is prohibited.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#ifndef STATE_H
#define STATE_H

#include <QObject>
#include "microCORLabGlobal.h"

class QString;

class MICROCORLABSHARED_EXPORT State : public QObject
{
    Q_OBJECT
public:
    explicit State() {}

    virtual QString getCurrentStatus() const = 0;
    virtual QString getClassName() const = 0;
};



class MICROCORLABSHARED_EXPORT BatteryState : public State
{
    Q_OBJECT

public:
    enum BatteryStateEnum { Reliable, Unreliable };

private:
    enum BatteryStateEnum state, prev_state;
    void setState(enum BatteryStateEnum _state)
    {
        if(state != _state){
            prev_state = state;
            state = _state;
            emit stateChanged();
            if(isUnreliable())
                emit unreliable();
        }
    }

signals:
    void stateChanged();
    void unreliable();

public slots:
    void setReliable() { setState(Reliable); }
    void setUnreliable() { setState(Unreliable); }

public:
    explicit BatteryState()  : state(Unreliable) {}

    static QString getStateName(int id) {
        BatteryStateEnum s = (BatteryStateEnum) id;
        if(s == Reliable)
            return QString("Reliable");
        else if(s == Unreliable)
            return QString("Unreliable");
        else
            return QString("Unknown");
    }
    QString getCurrentStatus() const {
        return getClassName() + "=" + getStateName(state);
    }
    QString getClassName() const { return QString("BatteryState"); }
    const enum BatteryStateEnum & getCurrentState() const { return state; }

    bool isReliable() const { return state == Reliable; }
    bool isUnreliable() const { return state == Unreliable; }
};



class MICROCORLABSHARED_EXPORT UsbDevState : public State
{
    Q_OBJECT

public:
    enum UsbDevStateEnum { Available, Unavailable};

private:
    enum UsbDevStateEnum state, prev_state;
    void setState(enum UsbDevStateEnum _state)
    {
        if(state != _state){
            prev_state = state;
            state = _state;
            emit stateChanged();
            if(isUnavailable())
                emit unavailable();
        }
    }

signals:
    void stateChanged();
    void unavailable();

public slots:
    void setAvailable() { setState(Available); }
    void setUnavailable() { setState(Unavailable); }

public:
    explicit UsbDevState() : state(Unavailable) {}

    static QString getStateName(int id) {
        UsbDevStateEnum s = (UsbDevStateEnum) id;
        if(s == Available)
            return QString("Available");
        else if(s == Unavailable)
            return QString("Unavailable");
        else
            return QString("Unknown");
    }
    QString getCurrentStatus() const {
        return getClassName() + "=" + getStateName(state);
    }
    QString getClassName() const { return QString("UsbDevState"); }
    const enum UsbDevStateEnum & getCurrentState() const { return state; }

    bool isAvailable() const { return state == Available; }
    bool isUnavailable() const { return state == Unavailable; }
};



class MICROCORLABSHARED_EXPORT ConnectionBaseState : public State
{
    Q_OBJECT

public:
    enum ConnectionBaseStateEnum { Connecting, ConnectionLoosing, Connected, NotConnected };

private:
    enum ConnectionBaseStateEnum state, prev_state;
    void setState(enum ConnectionBaseStateEnum _state)
    {
        if(state != _state){
            prev_state = state;
            state = _state;
            emit stateChanged();
            if(isNotConnected())
                emit notConnected();
            if(isConnected())
                emit connected();
        }
    }

signals:
    void stateChanged();
    void connected();
    void notConnected();

public slots:
    void setConnecting() { setState(Connecting); }
    void setConnectionLoosing() { setState(ConnectionLoosing); }
    void setConnected() { setState(Connected); }
    void setNotConnected() { setState(NotConnected); }

public:
    explicit ConnectionBaseState() : state(NotConnected) {}

    static QString getStateName(int id) {
        ConnectionBaseStateEnum s = (ConnectionBaseStateEnum) id;
        if(s == Connecting)
            return QString("Connecting");
        else if(s == ConnectionLoosing)
            return QString("ConnectionLoosing");
        else if(s == Connected)
            return QString("Connected");
        else if(s == NotConnected)
            return QString("NotConnected");
        else
            return QString("Unknown");
    }
    QString getCurrentStatus() const {
        return getClassName() + "=" + getStateName(state);
    }
    const enum ConnectionBaseStateEnum & getCurrentState() const { return state; }

    bool isConnecting() const { return state == Connecting; }
    bool isConnectionLoosing() const { return state == ConnectionLoosing; }
    bool isConnected() const { return state == Connected; }
    bool isNotConnected() const { return state == NotConnected; }
};



class MICROCORLABSHARED_EXPORT GatewayState : public ConnectionBaseState
{
    Q_OBJECT
public:
    explicit GatewayState() : ConnectionBaseState() {}
    QString getClassName() const { return QString("Gateway"); }
};



class MICROCORLABSHARED_EXPORT TerminalState : public ConnectionBaseState
{
    Q_OBJECT
public:
    explicit TerminalState() : ConnectionBaseState() {}
    QString getClassName() const { return QString("Terminal"); }
};



class MICROCORLABSHARED_EXPORT SamplingState : public State
{
    Q_OBJECT

public:
    enum SamplingStateEnum { Starting, Started, Stopping, Stopped, Restarting};

private:
    enum SamplingStateEnum state, prev_state;
    void setState(enum SamplingStateEnum _state)
    {
        if(state != _state){
            prev_state = state;
            state = _state;
            emit stateChanged();
            if(isStopped())
                emit stopped();
        }
    }

signals:
    void stateChanged();
    void stopped();

public slots:
    void setStarting() { setState(Starting); }
    void setStarted() { setState(Started); }
    void setStopping() { setState(Stopping); }
    void setStopped() { setState(Stopped); }
    void setRestarting() { setState(Restarting); }

public:
    explicit SamplingState() : state(Stopped) {}

    static QString getStateName(int id) {
        SamplingStateEnum s = (SamplingStateEnum) id;
        if(s == Starting)
            return QString("Starting");
        else if(s == Started)
            return QString("Started");
        else if(s == Stopping)
            return QString("Stopping");
        else if(s == Stopped)
            return QString("Stopped");
        else if(s == Restarting)
            return QString("Restarting");
        else
            return QString("Unknown");
    }
    QString getCurrentStatus() const {
        return getClassName() + "=" + getStateName(state);
    }
    QString getClassName() const { return QString("SamplingState"); }
    const enum SamplingStateEnum & getCurrentState() const { return state; }

    bool isStarting() const { return state == Starting; }
    bool isStarted() const { return state == Started; }
    bool isStopping() const { return state == Stopping; }
    bool isStopped() const { return state == Stopped; }
    bool isRestarting() const { return state == Restarting; }
};



class MICROCORLABSHARED_EXPORT TerminalRunningState : public State
{
    Q_OBJECT

public:
    enum RunningStateEnum {
        Unknown,
        Firmware,
        BootLoader
    };

private:
    enum RunningStateEnum state, prev_state;
    void setState(enum RunningStateEnum _state)
    {
        if(state != _state){
            prev_state = state;
            state = _state;
            emit stateChanged();
            if(isUnknown())
                emit unknown();
            else if(isFirmware())
                emit firmware();
            else if(isBootLoader())
                emit bootLoader();
        }
    }

signals:
    void stateChanged();
    void unknown();
    void firmware();
    void bootLoader();


public slots:
    void setUnknown() { setState(Unknown); }
    void setFirmware() { setState(Firmware); }
    void setBootLoader() { setState(BootLoader); }

public:
    explicit TerminalRunningState() : state(Unknown), prev_state(BootLoader) {}

    static QString getStateName(int id) {
        RunningStateEnum s = (RunningStateEnum) id;
        if(s == Unknown)
            return QString("Unknown");
        else if(s == Firmware)
            return QString("Firmware");
        else if(s == BootLoader)
            return QString("BootLoader");
        else
            return QString("Unknown");
    }
    QString getCurrentStatus() const {
        return getClassName() + "=" + getStateName(state);
    }
    QString getClassName() const { return QString("TerminalRunningState"); }
    const enum RunningStateEnum & getCurrentState() const { return state; }

    bool isUnknown() const { return state == Unknown; }
    bool isFirmware() const { return state == Firmware; }
    bool isBootLoader() const { return state == BootLoader; }

};
 // end of States Group

#endif // STATE_H
 // end of microCORLabCPPApi