frequency.hh

#ifndef FREQUENCY_HH
#define FREQUENCY_HH
 
#include <yaml-cpp/yaml.h>
#include <QString>
#include <QMetaType>
 
struct Frequency
{
public:
  enum class Format {
    Automatic, Hz, kHz, MHz, GHz
  };
 
protected:
  Frequency(unsigned long long hz);
 
public:
  Frequency();
  Frequency(const Frequency &other);
 
  Frequency &operator =   (const Frequency &other);
 
  inline bool operator<   (const Frequency &other) const {   
    return _frequency < other._frequency;
  }
  inline bool operator <=(const Frequency &other) const {    
    return _frequency <= other._frequency;
  }
  inline bool operator==  (const Frequency &other) const {   
    return _frequency == other._frequency;
  }
  inline bool operator != (const Frequency &other) const {   
    return _frequency != other._frequency;
  }
  inline bool operator>   (const Frequency &other) const {   
    return _frequency > other._frequency;
  }
  inline bool operator >=(const Frequency &other) const {    
    return _frequency >= other._frequency;
  }
 
  QString format(Format f=Format::Automatic) const;
  bool parse(const QString &value);
  static Frequency fromString(const QString &freq);
 
  inline unsigned long long inHz() const { return _frequency; }    
  inline double inkHz() const { return double(_frequency)/1e3; }   
  inline double inMHz() const { return double(_frequency)/1e6; }   
  inline double inGHz() const { return double(_frequency)/1e9; }   
 
  static inline Frequency fromHz(unsigned long long Hz) { return Frequency(Hz); } 
  static inline Frequency fromkHz(double kHz) { return Frequency(kHz*1e3); }      
  static inline Frequency fromMHz(double MHz) { return Frequency(MHz*1e6); }      
  static inline Frequency fromGHz(double GHz) { return Frequency(GHz*1e6); }      
 
protected:
  unsigned long long _frequency;
};
 
Q_DECLARE_METATYPE(Frequency)
 
 
namespace YAML
{
  template<>
  struct convert<Frequency>
  {
    static Node encode(const Frequency& rhs) {
      return Node(rhs.format().toStdString());
    }
 
    static bool decode(const Node& node, Frequency& rhs) {
      if (! node.IsScalar())
        return false;
      return rhs.parse(QString::fromStdString(node.as<std::string>()));
    }
  };
}
#endif // FREQUENCY_HH