interval.hh

#ifndef INTERVAL_HH
#define INTERVAL_HH
 
#include <QString>
#include <QMetaType>
#include <yaml-cpp/yaml.h>

class Interval
{
public:
  enum class Format {
    Automatic, Milliseconds, Seconds, Minutes
  };
 
protected:
  constexpr explicit Interval(unsigned long long ms)
    : _duration(ms)
  {
    // pass...
  }
 
public:
  Interval()
    : _duration(0)
  {
    // pass...
  }

  constexpr Interval(const Interval &other)
    : _duration(other._duration)
  {
    // pass...
  }
 
  inline Interval &operator =(const Interval &other) {   
    _duration = other._duration; return *this;
  }
 
  inline bool isNull() const { return 0 == _duration; }  
  inline bool isInfinite() const {
    return std::numeric_limits<unsigned long long>::max() == _duration;
  }

  inline bool isFinite() const { return (!isNull()) && (!isInfinite()); }
 
  inline bool operator ==(const Interval &other) const { 
    return _duration == other._duration;
  }
  inline bool operator<  (const Interval &other) const {
    return _duration < other._duration;
  }
  inline bool operator<=  (const Interval &other) const {
    return _duration <= other._duration;
  }
  inline bool operator>  (const Interval &other) const {
    return _duration > other._duration;
  }
  inline bool operator>=  (const Interval &other) const {
    return _duration >= other._duration;
  }
 
  inline unsigned long long milliseconds() const { return _duration; }      
  inline unsigned long long seconds() const { return _duration/1000ULL; }   
  inline unsigned long long minutes() const { return _duration/60000ULL; }  
 
  static inline constexpr Interval fromMilliseconds(unsigned long long ms) {          
    return Interval(ms);
  }
  static inline constexpr Interval fromSeconds(unsigned long long s) {                
    return Interval(s*1000ULL);
  }
  static inline constexpr Interval fromMinutes(unsigned long long min) {              
    return Interval(min*60000ULL);
  }

  QString format(Format f=Format::Automatic) const;
  bool parse(const QString &value);
 
public:
  static inline Interval null() { return Interval(0); }
  static inline Interval infinity() {
    return Interval(std::numeric_limits<unsigned long long>::max());
  }
 
private:
  unsigned long long _duration;
};
 
Q_DECLARE_METATYPE(Interval)
 
 
namespace YAML
{
  template<>
  struct convert<Interval>
  {
    static Node encode(const Interval& rhs) {
      return Node(rhs.format().toStdString());
    }

    static bool decode(const Node& node, Interval& rhs) {
      if (!node.IsScalar())
        return false;
      return rhs.parse(QString::fromStdString(node.as<std::string>()));
    }
  };
}
 
 
#endif // INTERVAL_HH