radiolimits.hh

#ifndef RADIOLIMITS_HH
#define RADIOLIMITS_HH
 
#include <QObject>
#include <QRegularExpression>
#include <QTextStream>
#include <QMetaType>
#include <QSet>
 
#include "frequency.hh"
#include "ranges.hh"
 
// 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;
  const QStringList &stack() 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(RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Hint,
                           QObject *parent=nullptr);
 
protected:
  RadioLimitIssue::Severity _severity;
};
 

class RadioLimitString: public RadioLimitValue
{
  Q_OBJECT
 
public:
  enum Encoding {
    DTMF,    
    ASCII,   
    Unicode  
  };
 
public:
  RadioLimitString(int minLen, int maxLen, Encoding enc,
                   RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Hint,
                   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,
                        RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                        QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  QRegularExpression _pattern;
};
 

class RadioLimitPin: public RadioLimitStringRegEx
{
  Q_OBJECT
 
public:  
  RadioLimitPin(int length = -1,
                RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                QObject *parent=nullptr);
};
 

class RadioLimitStringIgnored: public RadioLimitValue {
  Q_OBJECT
 
public:
  RadioLimitStringIgnored(RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Hint, QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
};
 

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,
                 RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Hint,
                 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(RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Hint,
                           QObject *parent=nullptr);
};
 

class RadioLimitEnum: public RadioLimitValue
{
  Q_OBJECT
 
public:
  RadioLimitEnum(const std::initializer_list<unsigned> &values,
                 RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Hint,
                 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<Frequency, Frequency>> RangeList;
 
public:
  explicit RadioLimitFrequencies(RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                                 QObject *parent=nullptr);
  RadioLimitFrequencies(const RangeList &ranges,
                        RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                        QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  QList<FrequencyRange> _frequencyRanges;
};
 

class RadioLimitFrequencyRaster: public RadioLimitFrequencies
{
  Q_OBJECT
 
public:
  explicit RadioLimitFrequencyRaster(RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                                     QObject *parent=nullptr);
  RadioLimitFrequencyRaster(const RangeList &ranges,
                            const Frequency &raster,
                            RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                            QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const override;
 
protected:
  Frequency _raster;
};
 

class RadioLimitTransmitFrequencies: public RadioLimitFrequencies
{
  Q_OBJECT
 
public:
  explicit RadioLimitTransmitFrequencies(RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                                         QObject *parent=nullptr);
  RadioLimitTransmitFrequencies(const RangeList &ranges,
                                RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                                QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
};
 

class RadioLimitInterval: public RadioLimitValue
{
  Q_OBJECT
 
public:
  explicit RadioLimitInterval(RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                              QObject *parent=nullptr);
  RadioLimitInterval(const Range<Interval> &range,
                     RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                     QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  Range<Interval> _durations;
};
 

class RadioLimitLevel: public RadioLimitValue
{
  Q_OBJECT
 
public:
  explicit RadioLimitLevel(const Range<unsigned int> &range = {0, 10}, bool allowInvalid=true,
                           RadioLimitIssue::Severity severity=RadioLimitIssue::Severity::Warning,
                           QObject *parent=nullptr);
 
  bool verify(const ConfigItem *item, const QMetaProperty &prop, RadioLimitContext &context) const;
 
protected:
  Range<unsigned int> _range;
  bool _allowInvalid;
};
 

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:
  typedef std::initializer_list<QMetaObject> MetaObjectList;
 
public:
  RadioLimitObjRef(const QMetaObject &type, bool allowNull=true, QObject *parent=nullptr);

  RadioLimitObjRef(const MetaObjectList &types, 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;

  bool hasSatelliteConfig() const;
  bool satelliteConfigImplemented() const;
  unsigned numSatellites() const;
 
protected:
  bool _betaWarning;
  bool _hasCallSignDB;
  bool _callSignDBImplemented;
  unsigned _numCallSignDBEntries;
  bool _hasSatelliteConfig;
  bool _satelliteConfigImplemented;
  unsigned _numSatellites;
};
 
#endif // RADIOLIMITS_HH