frequency.hh

#ifndef FREQUENCY_HH
#define FREQUENCY_HH
 
#include <yaml-cpp/yaml.h>
#include <QString>
#include <QMetaType>
#include <QList>
#include <QPair>
 

struct FrequencyBase
{
public:
  enum class Unit { Auto, Hz, kHz, MHz, GHz };
 
protected:
  FrequencyBase(qint64 hz) : _frequency(hz) {}
 
public:
  FrequencyBase(const FrequencyBase &other);

  FrequencyBase &operator = (const FrequencyBase &other);

  inline bool isNegative() const { return 0 > _frequency; }
  inline bool isPositive() const { return 0 < _frequency; }
  inline bool isZero() const { return 0 == _frequency; }

  QString format(Unit unit = Unit::Auto) const;
  bool parse(const QString &value, Qt::CaseSensitivity caseSensitivity = Qt::CaseInsensitive);
 
  inline 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; }   

  Unit unit() const;

  Unit unitFromString(const QString& input) const;

  bool isMultipleOf(Unit unit) const;

  static QString unitName(Unit unit);
 
protected:
  qint64 _frequency;
};
 
struct Frequency;

struct FrequencyOffset: public FrequencyBase
{
friend struct Frequency;
protected:
  FrequencyOffset(qint64 Hz) : FrequencyBase(Hz) { }
 
public:
  FrequencyOffset();
  FrequencyOffset(const FrequencyOffset &other);

  FrequencyOffset &operator = (const FrequencyOffset &other);

  inline FrequencyOffset invert() const { return FrequencyOffset(this->_frequency * -1); }

  inline FrequencyOffset abs() const {
    return FrequencyOffset(std::abs(this->_frequency));
  }

  static FrequencyOffset fromString(const QString &freq);
 
  static inline FrequencyOffset fromHz(qint64 Hz)   { return FrequencyOffset(Hz); }             
  static inline FrequencyOffset fromkHz(double kHz) { return FrequencyOffset(kHz*1e3); }      
  static inline FrequencyOffset fromMHz(double MHz) { return FrequencyOffset(MHz*1e6); }      
  static inline FrequencyOffset fromGHz(double GHz) { return FrequencyOffset(GHz*1e6); }      
};
 
 

struct Frequency: public FrequencyBase
{
protected:
  Frequency(quint64 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;
  }

  Frequency operator+(const FrequencyOffset &offset) const;
  Frequency &operator+=(const FrequencyOffset &offset);
  FrequencyOffset operator-(const Frequency &other) const;    

  static Frequency fromString(const QString &freq);
 
  inline quint64 inHz() const { return _frequency; }    
 
  static inline Frequency fromHz(quint64 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); } 
 
public:
  template <class T>
  class MapNearest
  {
  protected:
    typedef QList<QPair<Frequency, T>> container;
    typedef typename container::const_iterator const_iterator;
 
  public:
    MapNearest(const QList<QPair<Frequency, T>> &items)
      : _items(items)
    {
      // Sort items ascending.
      std::sort(_items.begin(), _items.end(), compItem);
    }

    const_iterator
    find(const Frequency &f) const {
      auto lower = std::lower_bound(_items.begin(), _items.end(), f, compItemValue);
 
      if (_items.begin() == lower)
        return lower;
 
      auto upper = lower--;
      if (_items.end() == upper)
        return lower;
 
      if ((f.inHz()-lower->first.inHz()) < (upper->first.inHz()-f.inHz()))
        return lower;
 
      return upper;
    }

    T value(const Frequency &f) const {
      return find(f)->second;
    }

    Frequency key(const Frequency &f) const {
      return find(f)->first;
    }
 
  protected:
    inline static bool compItem(const QPair<Frequency, T> &a, const QPair<Frequency, T> &b) {
      return a.first < b.first;
    }

    inline static bool compItemValue(const QPair<Frequency, T> &a, const Frequency &b) {
      return a.first < b;
    }
 
  protected:
    container _items;
  };
};
 
 
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>()), Qt::CaseSensitive);
    }
  };
}
 
#endif // FREQUENCY_HH