signalmonitorvalue.h

Go to the documentation of this file.

// -*- Mode: c++ -*-
#ifndef SIGNALMONITORVALUES_H
#define SIGNALMONITORVALUES_H
 
#include <vector>
 
// Qt headers
#include <QStringList>
#include <QCoreApplication>
 
#include "libmythbase/mythchrono.h"
 
class SignalMonitorValue
{
    Q_DECLARE_TR_FUNCTIONS(SignalMonitorValue)
 
    using SignalMonitorList = std::vector<SignalMonitorValue>;
  public:
    SignalMonitorValue(QString _name, QString _noSpaceName,
                       int _threshold, bool _high_threshold,
                       int _min, int _max, std::chrono::milliseconds _timeout);
    virtual ~SignalMonitorValue() { ; } /* forces class to have vtable */
 
    // // // // // // // // // // // // // // // // // // // // // // // //
    // Gets  // // // // // // // // // // // // // // // // // // // // //
 
    QString GetName(void) const;
    QString GetShortName(void) const;
    QString GetStatus() const
    {
        QString str = m_noSpaceName.isNull() ? "(null)" : m_noSpaceName;
        return QString("%1 %2 %3 %4 %5 %6 %7 %8")
            .arg(str).arg(m_value).arg(m_threshold).arg(m_minVal).arg(m_maxVal)
            .arg(m_timeout.count()).arg((int)m_highThreshold).arg((int)m_set);
    }
    int GetValue() const { return m_value; }
    int GetMin() const { return m_minVal; }
    int GetMax() const { return m_maxVal; }
    int GetThreshold() const { return m_threshold; }
    bool IsHighThreshold() const { return m_highThreshold; }
    std::chrono::milliseconds GetTimeout() const { return m_timeout; }
 
    bool IsGood() const
    {
        return (m_highThreshold) ? m_value >= m_threshold : m_value <= m_threshold;
    }
    int GetNormalizedValue(int newmin, int newmax) const
    {
        float rangeconv = ((float) (newmax - newmin)) / (GetMax() - GetMin());
        int newval = (int) (((GetValue() - GetMin()) * rangeconv) + newmin);
        return std::clamp(newval, newmin, newmax);
    }
 
 
    // // // // // // // // // // // // // // // // // // // // // // // //
    // Sets  // // // // // // // // // // // // // // // // // // // // //
 
    void SetValue(int _value)
    {
        m_set = true;
        m_value = std::clamp(_value,m_minVal,m_maxVal);
    }
 
    void SetMin(int _min) { m_minVal = _min; }
 
    void SetMax(int _max) { m_maxVal = _max; }
 
    void SetThreshold(int _threshold) { m_threshold = _threshold; }
 
    void SetThreshold(int _threshold, bool _high_threshold) {
        m_threshold = _threshold;
        m_highThreshold = _high_threshold;
    }
 
    void SetRange(int _min, int _max) {
        m_minVal = _min;
        m_maxVal = _max;
    }
 
    void SetTimeout(std::chrono::milliseconds _timeout) { m_timeout = _timeout; }
 
    // // // // // // // // // // // // // // // // // // // // // // // //
    // Static Methods // // // // // // // // // // // // // // // // // //
 
    static void Init();
    static SignalMonitorValue*
        Create(const QString& _name, const QString& _longString);
    static SignalMonitorList Parse(const QStringList& slist);
    static bool AllGood(const SignalMonitorList& slist);
    static std::chrono::milliseconds MaxWait(const SignalMonitorList& slist);
 
 
    // // // // // // // // // // // // // // // // // // // // // // // //
    // Constants   // // // // // // // // // // // // // // // // // // //
 
    static QStringList ERROR_NO_CHANNEL;
    static QStringList ERROR_NO_LINK;
    static QStringList SIGNAL_LOCK;
    // variable for initializing constants after translator installed
    static bool run_static_init;
 
    QString toString() const
    {
        QString str = m_noSpaceName.isNull() ? "(null)" : m_noSpaceName;
        return QString("Name(%1) Val(%2) thr(%3%4) range(%5,%6) "
                       "timeout(%7 ms) %8 set. %9 good.")
            .arg(str).arg(m_value).arg( (m_highThreshold) ? ">=" : "<=" )
            .arg(m_threshold).arg(m_minVal).arg(m_maxVal)
            .arg(m_timeout.count())
            .arg(m_set    ? "is" : "is NOT",
                 IsGood() ? "Is" : "Is NOT" );
    }
  private:
    SignalMonitorValue() = default;
    SignalMonitorValue(QString  _name, QString  _noSpaceName,
                       int _value, int _threshold, bool _high_threshold,
                       int _min, int _max, std::chrono::milliseconds _timeout, bool _set);
    bool Set(const QString& _name, const QString& _longString);
 
    QString m_name;
    QString m_noSpaceName;
    int     m_value         {-1};
    int     m_threshold     {-1};
    int     m_minVal        {-1};
    int     m_maxVal        {-1};
    std::chrono::milliseconds m_timeout {-1ms};
    bool    m_highThreshold {true}; // false when we must be below threshold
    bool    m_set           {false}; // false until value initially set
};
 
using SignalMonitorList = std::vector<SignalMonitorValue>;
 
#endif // SIGNALMONITORVALUES_H