status.h

/*
 * GearBox Project: Peer-Reviewed Open-Source Libraries for Robotics
 *               http://gearbox.sf.net/
 * Copyright (c) 2004-2010 Alex Brooks, Alexei Makarenko, Tobias Kaupp
 *
 * This distribution is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */

#ifndef GBXUTILACFR_STATUS_H
#define GBXUTILACFR_STATUS_H

#if defined (WIN32)
    #if defined (GBXUTILACFR_STATIC)
        #define GBXUTILACFR_EXPORT
    #elif defined (GBXUTILACFR_EXPORTS)
        #define GBXUTILACFR_EXPORT       __declspec (dllexport)
    #else
        #define GBXUTILACFR_EXPORT       __declspec (dllimport)
    #endif
#else
    #define GBXUTILACFR_EXPORT
#endif

#include <string>
#include <vector>

namespace gbxutilacfr {

enum SubsystemState
{
    SubsystemIdle,
    SubsystemInitialising,
    SubsystemWorking,
    SubsystemFinalising,
    SubsystemShutdown,
    SubsystemFault
};

GBXUTILACFR_EXPORT std::string toString( SubsystemState state );

enum SubsystemHealth
{
    SubsystemOk,
    SubsystemWarning,
    SubsystemCritical
};

GBXUTILACFR_EXPORT std::string toString( SubsystemHealth health );

struct GBXUTILACFR_EXPORT SubsystemStatus
{
    SubsystemStatus( SubsystemState s=SubsystemIdle, SubsystemHealth h=SubsystemOk, const std::string& msg="",
                     bool stall=false, double beat=0.0 ) :
        state(s),
        health(h),
        message(msg),
        isStalled(stall),
        sinceHeartbeat(beat) {};

    SubsystemState state;

    SubsystemHealth health;

    std::string message;

    bool isStalled;

    double sinceHeartbeat;
};

GBXUTILACFR_EXPORT std::string toString( const SubsystemStatus& status );

enum SubsystemType
{
    SubsystemStandard,
    SubsystemEarlyExit,
    SubsystemInfrastructure
};

GBXUTILACFR_EXPORT std::string toString( SubsystemType type );

enum ComponentState
{
    CompStarting,
    CompOperational,
    CompStopping,
    CompFault
};

GBXUTILACFR_EXPORT std::string toString( ComponentState type );

enum ComponentHealth
{
    CompOk,
    CompWarning,
    CompCritical
};

GBXUTILACFR_EXPORT std::string toString( ComponentHealth type );

struct GBXUTILACFR_EXPORT ComponentStatus
{
    ComponentState state;
    ComponentHealth health;
    bool isStalled;
};

class GBXUTILACFR_EXPORT Status
{

public:

    virtual ~Status() {};

    virtual void addSubsystem( const std::string& subsystem,
            double maxHeartbeatIntervalSec=-1.0, SubsystemType type=SubsystemStandard )=0;

    virtual void removeSubsystem( const std::string& subsystem )=0;

    virtual std::vector<std::string> subsystems()=0;

    virtual SubsystemStatus subsystemStatus( const std::string& subsystem )=0;

//     virtual SubsystemState infrastructureState()=0;

    virtual ComponentStatus componentStatus()=0;

    virtual void setMaxHeartbeatInterval( const std::string& subsystem, double intervalSec )=0;

    virtual void setSubsystemType( const std::string& subsystem, SubsystemType type )=0;

    //
    // BOTH STATE AND HEALTH CHANGES
    //

    virtual void setSubsystemStatus( const std::string& subsystem, SubsystemState state, SubsystemHealth health, const std::string& message="" )=0;

    //
    // STATE CHANGES
    //

    virtual void initialising( const std::string& subsystem )=0;

    virtual void working( const std::string& subsystem )=0;

    virtual void finalising( const std::string& subsystem )=0;

    virtual void fault( const std::string& subsystem, const std::string& message )=0;

    //
    // HEALTH CHANGES
    //

    virtual void ok( const std::string& subsystem, const std::string& message="" )=0;

    virtual void warning( const std::string& subsystem, const std::string& message )=0;

    virtual void critical( const std::string& subsystem, const std::string& message )=0;

    //
    // NO CHANGE
    //

    virtual void heartbeat( const std::string& subsystem )=0;

    virtual void message( const std::string& subsystem, const std::string& message )=0;

    //
    // Utility
    //

    virtual void process()=0;
};

} // namespace

#endif