Second.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_Second_hpp
#define anna_core_util_Second_hpp

#include <string>

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

namespace anna {

class Millisecond;
class Microsecond;

class Second {
public:
#ifdef __anna64__
  typedef S64 type_t;
#else
  typedef int type_t;
#endif

  static const int DateTimeSizeString = 21;

  Second() : a_value(0) {;}

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

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

  Second(const Millisecond& other);

  Second(const Microsecond& other);

  operator type_t () const { return a_value; }

  type_t& refValue() { return a_value; }

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

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

  Second& operator= (const Millisecond& other) ;

  Second& operator= (const Microsecond& other) ;

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

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

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

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

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

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

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

  bool operator> (const Millisecond& other) const ;

  bool operator> (const Microsecond& other) const ;

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

  bool operator< (const Millisecond& other) const ;

  bool operator< (const Microsecond& other) const ;

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

  bool operator>= (const Millisecond& 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 Second& other) const { return a_value <= other.a_value; }

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

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

  type_t getValue() const { return a_value; }

  std::string asDateTime(const char* format = "%d/%0m/%Y %T") const ;

  const char* asDateTime(char* result, const char* format = "%d/%0m/%Y %T") const ;

  std::string asString() const ;

  static Second getTime() ;

  static Second getLocalTime() ;

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

private:
  type_t a_value;

  friend class Millisecond;
  friend class Microsecond;

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

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

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

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

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

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

}

#endif