Millisecond.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_util_Millisecond_hpp
#define anna_core_util_Millisecond_hpp

#include <time.h>

#include <string>

#include <anna/core/util/defines.hpp>
#include <anna/core/RuntimeException.hpp>

namespace anna {

class Second;
class Microsecond;

class Millisecond {
public:
  typedef S64 type_t;

  Millisecond() : a_value(0) {;}

  explicit Millisecond(const type_t value) : a_value(value) {;}

  Millisecond(const Millisecond& other) : a_value(other.a_value) {;}

  Millisecond(const Second& other);

  Millisecond(const Microsecond& other);

  operator type_t () const { return a_value; }

  type_t& refValue() { return a_value; }

  Millisecond& operator= (const type_t other) { a_value = other; return *this; }

  Millisecond& operator= (const Millisecond& other) { a_value = other.a_value; return *this; }

  Millisecond& operator= (const Second& other) ;

  Millisecond& operator= (const Microsecond& other) ;

  bool operator== (const Millisecond& other) const { return a_value == other.a_value; }

  bool operator== (const Second& other) const ;

  bool operator== (const Microsecond& other) const ;

  bool operator!= (const Millisecond& other) const { return a_value != other.a_value; }

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

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

  bool operator> (const Millisecond& other) const { return a_value > other.a_value; }

  bool operator> (const Second& other) const ;

  bool operator> (const Microsecond& other) const ;

  bool operator< (const Millisecond& other) const { return a_value < other.a_value; }

  bool operator< (const Second& other) const ;

  bool operator< (const Microsecond& other) const ;

  bool operator>= (const Millisecond& other) const { return a_value >= other.a_value; }

  bool operator>= (const Second& other) const { return (operator==(other) == true) ? true : operator>(other); }

  bool operator>= (const Microsecond& other) const { return (operator==(other) == true) ? true : operator>(other); }

  bool operator<= (const Millisecond& other) const { return a_value <= other.a_value; }

  bool operator<= (const Second& other) const { return (operator==(other) == true) ? true : operator<(other); }

  bool operator<= (const Microsecond& other) const { return (operator==(other) == true) ? true : operator<(other); }

  Millisecond& operator+= (const Millisecond& other) { a_value += other.a_value; return *this; }

  Millisecond& operator-= (const Millisecond& other) {(a_value > other.a_value) ? (a_value -= other.a_value) : (a_value = 0); return *this; }

  type_t getValue() const { return a_value; }

  timeval* getTimeVal(timeval& tv) const ;

  static Millisecond getTime() ;

  std::string asString() const ;

  static Millisecond fromString(const std::string& value) noexcept(false);

private:
  type_t a_value;

  friend class Second;
  friend class Microsecond;

  friend class Millisecond operator / (const Millisecond& left, const Millisecond& right) ;
  friend class Millisecond operator + (const Millisecond& left, const Millisecond& right) ;
  friend class Millisecond operator - (const Millisecond& left, const Millisecond& right) ;
  friend class Millisecond operator / (const Millisecond& left, const int right) ;
  friend class Millisecond operator / (const Millisecond& left, const unsigned int right) ;
  friend class Millisecond operator *(const Millisecond& left, const int right) ;
};

inline Millisecond operator / (const Millisecond& left, const Millisecond& right)
{
  return Millisecond(left.a_value / right.a_value);
}

inline Millisecond operator + (const Millisecond& left, const Millisecond& right)
{
  return Millisecond(left.a_value + right.a_value);
}

inline Millisecond operator - (const Millisecond& left, const Millisecond& right)
{
  return Millisecond(left.a_value - right.a_value);
}

inline Millisecond operator / (const Millisecond& left, const int right)
{
  return Millisecond(left.a_value / right);
}

inline Millisecond operator / (const Millisecond& left, const unsigned int right)
{
  return Millisecond(left.a_value / right);
}

inline Millisecond operator *(const Millisecond& left, const int right)
{
  return Millisecond(left.a_value * right);
}

}

#endif