signaling.hh

#ifndef SIGNALING_HH
#define SIGNALING_HH
 
#include <yaml-cpp/yaml.h>
#include <QString>
#include <QObject>
 

struct SelectiveCall
{
protected:
  enum class Type {
    None, CTCSS, DCS
  };
 
public:
  SelectiveCall();
  SelectiveCall(double ctcssFreq);
  SelectiveCall(unsigned int octalDSCCode, bool inverted);

  bool operator==(const SelectiveCall &other) const;
  bool operator!=(const SelectiveCall &other) const;

  bool isInvalid() const;
  bool isValid() const;
  bool isCTCSS() const;
  bool isDCS() const;

  double Hz() const;
  unsigned int mHz() const;

  unsigned int binCode() const;
  unsigned int octalCode() const;
  bool isInverted() const;

  QString format() const;
 
public:
  static SelectiveCall parseCTCSS(const QString &text);
  static SelectiveCall parseDCS(const QString &text);
  static SelectiveCall fromBinaryDCS(unsigned int code, bool inverted);
  static const QVector<SelectiveCall> &standard();
 
protected:
  Type type;
  union {
    uint16_t ctcss;
    struct {
      uint16_t code;
      bool inverted;
    } dcs;
  };
 
protected:
  static QVector<SelectiveCall> _standard;
};
 
Q_DECLARE_METATYPE(SelectiveCall)
 
 
namespace YAML
{
  template<>
  struct convert<SelectiveCall>
  {
    static Node encode(const SelectiveCall& rhs) {
      Node node;
      if (rhs.isCTCSS())
        node["ctcss"] = rhs.format().toStdString();
      else if (rhs.isDCS())
        node["dcs"] = rhs.format().toStdString();
      return node;
    }

    static bool decode(const Node& node, SelectiveCall& rhs) {
      if (node.IsNull()) {
        rhs = SelectiveCall();
        return true;
      }
 
      if ((! node.IsMap()) || (1 != node.size()))
        return false;
 
      if (node["ctcss"])
        rhs = SelectiveCall::parseCTCSS(QString::fromStdString(node["ctcss"].as<std::string>()));
 
      if (node["dcs"])
        rhs = SelectiveCall::parseDCS(QString::fromStdString(node["dcs"].as<std::string>()));
 
      return rhs.isValid();
    }
  };
}
 
#endif // SIGNALING_HH