radiolimits.hh

 
#ifndef RADIOLIMITS_HH
#define RADIOLIMITS_HH
 
#include <QObject>
#include <QTextStream>
#include <QMetaType>
#include <QSet>
 
// Forward declaration
class Config;
class ConfigItem;
class ConfigObject;
class RadioLimits;
 
 
class RadioLimitIssue: public QTextStream
{
public:
  enum Severity {
    Silent,  
    Hint,    
    Warning, 
    Critical 
  };
 
public:
  RadioLimitIssue(Severity severity, const QStringList &stack);
  RadioLimitIssue(const RadioLimitIssue &other);
 
  RadioLimitIssue &operator =(const RadioLimitIssue &other);
  RadioLimitIssue &operator =(const QString &message);
 
  Severity severity() const;
  const QString &message() const;
  QString format() const;
 
protected:
  Severity _severity;
  QStringList _stack;
  QString _message;
};
 
 
class RadioLimitContext
{
public:
  explicit RadioLimitContext(bool ignoreFrequencyLimits=false);
 
  RadioLimitIssue &newMessage(RadioLimitIssue::Severity severity = RadioLimitIssue::Hint);
 
  int count() const;
  const RadioLimitIssue &message(int n) const;
 
  void push(const QString &element);
  void pop();
 
  bool ignoreFrequencyLimits() const;
  void enableIgnoreFrequencyLimits(bool enable=true);
 
  RadioLimitIssue::Severity maxSeverity() const;
 
protected:
  QStringList _stack;
  QList<RadioLimitIssue> _messages;
  bool _ignoreFrequencyLimits;
  RadioLimitIssue::Severity _maxSeverity;
};
 
 
class RadioLimitElement: public QObject
{
  Q_OBJECT
 
public:
  typedef std::initializer_list< std::pair<QString, RadioLimitElement *> > PropList;
 
protected:
  explicit RadioLimitElement(QObject *parent=nullptr);
 
public:
  virtual bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const = 0;
 
public:
  virtual ~RadioLimitElement();
};
 
 
class RadioLimitValue: public RadioLimitElement
{
  Q_OBJECT
 
protected:
  explicit RadioLimitValue(QObject *parent=nullptr);
};
 
 
class RadioLimitString: public RadioLimitValue
{
  Q_OBJECT
 
public:
  enum Encoding {
    ASCII,   
    Unicode  
  };
 
public:
  RadioLimitString(int minLen, int maxLen, Encoding enc, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  int _minLen;
  int _maxLen;
  Encoding _encoding;
};
 
 
class RadioLimitStringRegEx: public RadioLimitValue
{
  Q_OBJECT
 
public:
  RadioLimitStringRegEx(const QString &pattern, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  QRegExp _pattern;
};
 
 
class RadioLimitStringIgnored: public RadioLimitValue {
  Q_OBJECT
 
public:
  RadioLimitStringIgnored(RadioLimitIssue::Severity severity=RadioLimitIssue::Hint, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  RadioLimitIssue::Severity _severity;
};
 
 
class RadioLimitBool: public RadioLimitValue
{
  Q_OBJECT
 
public:
  explicit RadioLimitBool(QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
};
 
 
class RadioLimitIgnoredBool: public RadioLimitBool
{
  Q_OBJECT
 
public:
  explicit RadioLimitIgnoredBool(RadioLimitIssue::Severity notify=RadioLimitIssue::Hint,
                                 QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  RadioLimitIssue::Severity _severity;
};
 
 
class RadioLimitUInt: public RadioLimitValue
{
  Q_OBJECT
 
public:
  RadioLimitUInt(qint64 minValue=-1, qint64 maxValue=-1, qint64 defValue=-1, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  qint64 _minValue;
  qint64 _maxValue;
  qint64 _defValue;
};
 
 
class RadioLimitDMRId: public RadioLimitUInt
{
  Q_OBJECT
 
public:
  explicit RadioLimitDMRId(QObject *parent=nullptr);
};
 
 
class RadioLimitEnum: public RadioLimitValue
{
  Q_OBJECT
 
public:
  RadioLimitEnum(const std::initializer_list<unsigned> &values, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  QSet<unsigned> _values;
};
 
 
class RadioLimitFrequencies: public RadioLimitValue
{
  Q_OBJECT
 
public:
  typedef std::initializer_list<std::pair<double, double>> RangeList;
public:
  struct FrequencyRange {
    double min; 
    double max; 
    FrequencyRange(double lower, double upper);
    FrequencyRange(const std::pair<double, double> &limit);
    bool contains(double f) const;
  };
 
public:
  explicit RadioLimitFrequencies(QObject *parent=nullptr);
  RadioLimitFrequencies(const RangeList &ranges, bool warnOnly=false, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  QList<FrequencyRange> _frequencyRanges;
  bool _warnOnly;
};
 
 
class RadioLimitTransmitFrequencies: public RadioLimitFrequencies
{
  Q_OBJECT
 
public:
  explicit RadioLimitTransmitFrequencies(QObject *parent=nullptr);
  RadioLimitTransmitFrequencies(const RangeList &ranges, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
};
 
 
class RadioLimitItem: public RadioLimitElement
{
  Q_OBJECT
 
public:
  explicit RadioLimitItem(QObject *parent=nullptr);
  RadioLimitItem(const PropList &list, QObject *parent=nullptr);
 
  bool add(const QString &prop, RadioLimitElement *structure);
 
  virtual bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
  virtual bool verifyItem(const ConfigItem *item, RadioLimitContext &context) const;
 
protected:
  QHash<QString, RadioLimitElement *> _elements;
};
 
 
class RadioLimitObject: public RadioLimitItem
{
  Q_OBJECT
 
public:
  explicit RadioLimitObject(QObject *parent=nullptr);
  RadioLimitObject(const PropList &list, QObject *parent=nullptr);
 
  virtual bool verifyObject(const ConfigObject *item, RadioLimitContext &context) const;
};
 
 
class RadioLimitIgnored: public RadioLimitObject
{
  Q_OBJECT
 
public:
  RadioLimitIgnored(RadioLimitIssue::Severity notify=RadioLimitIssue::Hint, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
  bool verifyObject(const ConfigObject *item, RadioLimitContext &context) const;
 
protected:
  RadioLimitIssue::Severity _notification;
};
 
 
class RadioLimitObjects: public RadioLimitObject
{
  Q_OBJECT
 
public:
  typedef std::initializer_list<std::pair<const QMetaObject&, RadioLimitObject *> > TypeList;
 
public:
  RadioLimitObjects(const TypeList &list, QObject *parent=nullptr);
 
  bool verifyItem(const ConfigItem *item, RadioLimitContext &context) const;
 
protected:
  QHash<QString,  RadioLimitObject *> _types;
};
 
 
class RadioLimitObjRef: public RadioLimitElement
{
  Q_OBJECT
 
public:
  RadioLimitObjRef(const QMetaObject &type, bool allowNull=true, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  bool validType(const QMetaObject *type) const;
 
protected:
  bool _allowNull;
  QSet<QString> _types;
};
 
 
class RadioLimitObjRefIgnored: public RadioLimitObjRef
{
  Q_OBJECT
 
public:
  RadioLimitObjRefIgnored(
      ConfigObject *defObj=nullptr, RadioLimitIssue::Severity notify=RadioLimitIssue::Hint,
      QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  RadioLimitIssue::Severity _severity;
  ConfigObject *_default;
};
 
 
class RadioLimitList: public RadioLimitElement
{
  Q_OBJECT
 
public:
  struct ElementLimits {
    const QMetaObject &type;      
    int minCount;                 
    int maxCount;                 
    RadioLimitObject *structure;  
  };
 
public:
  RadioLimitList(const QMetaObject &type, int minSize, int maxSize, RadioLimitObject *element, QObject *parent=nullptr);
  RadioLimitList(const std::initializer_list<ElementLimits> &elements, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  QString findClassName(const QMetaObject &type) const;
 
protected:
  QHash<QString, RadioLimitObject *> _elements;
  QHash<QString, qint64> _minCount;
  QHash<QString, qint64> _maxCount;
};
 
 
class RadioLimitRefList: public RadioLimitElement
{
  Q_OBJECT
 
public:
  RadioLimitRefList(int minSize, int maxSize, const QMetaObject &type, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  bool validType(const QMetaObject *type) const;
 
protected:
  qint64 _minSize;
  qint64 _maxSize;
  QSet<QString> _types;
};
 
 
class RadioLimitGroupCallRefList: public RadioLimitElement
{
  Q_OBJECT
 
public:
  RadioLimitGroupCallRefList(int minSize, int maxSize, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  qint64 _minSize;
  qint64 _maxSize;
};
 
 
class RadioLimitSingleZone: public RadioLimitObject
{
  Q_OBJECT
 
public:
  RadioLimitSingleZone(qint64 maxSize, const PropList &list, QObject *parent=nullptr);
 
  bool verifyItem(const ConfigItem *item, RadioLimitContext &context) const;
};
 
 
class RadioLimits : public RadioLimitItem
{
  Q_OBJECT
 
public:
  explicit RadioLimits(bool betaWarning, QObject *parent = nullptr);
  RadioLimits(const std::initializer_list<std::pair<QString,RadioLimitElement *> > &list, QObject *parent=nullptr);
 
  virtual bool verifyConfig(const Config *config, RadioLimitContext &context) const;
 
  bool hasCallSignDB() const;
  bool callSignDBImplemented() const;
  unsigned numCallSignDBEntries() const;
 
protected:
  bool _betaWarning;
  bool _hasCallSignDB;
  bool _callSignDBImplemented;
  unsigned _numCallSignDBEntries;
};
 
#endif // RADIOLIMITS_HH