Microsecond.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_Microsecond_hpp
#define anna_core_util_Microsecond_hpp

#include <string>

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

namespace anna {

class Millisecond;
class Second;

class Microsecond {
public:
  typedef S64 type_t;

  Microsecond() : a_value(0) {;}

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

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

  Microsecond(const Millisecond& other);

  Microsecond(const Second& other);

  operator type_t () const { return a_value; }

  type_t& refValue() { return a_value; }

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

  Microsecond& operator= (const Millisecond& other) ;

  Microsecond& operator= (const Second& other) ;

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

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

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

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

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

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

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

  bool operator> (const Millisecond& other) const ;

  bool operator> (const Second& other) const ;

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

  bool operator< (const Millisecond& other) const ;

  bool operator< (const Second& other) const ;

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

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

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

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

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

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

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

  type_t getValue() const { return a_value; }

  static Microsecond getTime() ;

  std::string asString() const ;

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

private:
  type_t a_value;

  friend class Millisecond;
  friend class Second;

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

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

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

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

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

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

}

#endif