nstime.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2005,2006 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef TIME_H
#define TIME_H
 
#include "assert.h"
#include "attribute.h"
#include "attribute-helper.h"
#include "event-id.h"
#include "int64x64.h"
#include <stdint.h>
#include <limits>
#include <cmath>
#include <ostream>
#include <set>
 
namespace ns3 {
 
class TimeWithUnit;
 
class Time
{
public:
  enum Unit
  {
    Y   = 0,   
    D   = 1,   
    H   = 2,   
    MIN = 3,   
    S   = 4,   
    MS  = 5,   
    US  = 6,   
    NS  = 7,   
    PS  = 8,   
    FS  = 9,   
    LAST = 10, 
    AUTO = 11  
  };
 
  inline Time & operator = (const Time & o)
  {
    m_data = o.m_data;
    return *this;
  }
  inline Time ()
    : m_data ()
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  inline Time (const Time & o)
    : m_data (o.m_data)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
 
  Time (Time &&o)
    : m_data (o.m_data)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (double v)
    : m_data (lround (v))
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (long long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (unsigned int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (unsigned long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (unsigned long long int v)
    : m_data (v)
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }
  explicit inline Time (const int64x64_t & v)
    : m_data (v.Round ())
  {
    if (g_markingTimes)
      {
        Mark (this);
      }
  }  // Numeric constructors
 
  explicit Time (const std::string & s);
 
  static Time Min ()
  {
    return Time (std::numeric_limits<int64_t>::min ());
  }
  static Time Max ()
  {
    return Time (std::numeric_limits<int64_t>::max ());
  }
 
  ~Time ()
  {
    if (g_markingTimes)
      {
        Clear (this);
      }
  }
 
  inline bool IsZero (void) const
  {
    return m_data == 0;
  }
  inline bool IsNegative (void) const
  {
    return m_data <= 0;
  }
  inline bool IsPositive (void) const
  {
    return m_data >= 0;
  }
  inline bool IsStrictlyNegative (void) const
  {
    return m_data < 0;
  }
  inline bool IsStrictlyPositive (void) const
  {
    return m_data > 0;
  }
  inline int Compare (const Time & o) const
  {
    return (m_data < o.m_data) ? -1 : (m_data == o.m_data) ? 0 : 1;
  }
 
  inline double GetYears (void) const
  {
    return ToDouble (Time::Y);
  }
  inline double GetDays (void) const
  {
    return ToDouble (Time::D);
  }
  inline double GetHours (void) const
  {
    return ToDouble (Time::H);
  }
  inline double GetMinutes (void) const
  {
    return ToDouble (Time::MIN);
  }
  inline double GetSeconds (void) const
  {
    return ToDouble (Time::S);
  }
  inline int64_t GetMilliSeconds (void) const
  {
    return ToInteger (Time::MS);
  }
  inline int64_t GetMicroSeconds (void) const
  {
    return ToInteger (Time::US);
  }
  inline int64_t GetNanoSeconds (void) const
  {
    return ToInteger (Time::NS);
  }
  inline int64_t GetPicoSeconds (void) const
  {
    return ToInteger (Time::PS);
  }
  inline int64_t GetFemtoSeconds (void) const
  {
    return ToInteger (Time::FS);
  }  // Convert to Number in a Unit.
 
  inline int64_t GetTimeStep (void) const
  {
    return m_data;
  }
  inline double GetDouble (void) const
  {
    return static_cast<double> (m_data);
  }
  inline int64_t GetInteger (void) const
  {
    return GetTimeStep ();
  }  // Convert to Raw Value
 
 
  static void SetResolution (enum Unit resolution);
  static enum Unit GetResolution (void);
 
 
  inline static Time From (const int64x64_t & value)
  {
    return Time (value);
  }
  inline static Time FromInteger (uint64_t value, enum Unit unit)
  {
    struct Information *info = PeekInformation (unit);
    if (info->fromMul)
      {
        value *= info->factor;
      }
    else
      {
        value /= info->factor;
      }
    return Time (value);
  }
  inline static Time FromDouble (double value, enum Unit unit)
  {
    return From (int64x64_t (value), unit);
  }
  inline static Time From (const int64x64_t & value, enum Unit unit)
  {
    struct Information *info = PeekInformation (unit);
    // DO NOT REMOVE this temporary variable. It's here
    // to work around a compiler bug in gcc 3.4
    int64x64_t retval = value;
    if (info->fromMul)
      {
        retval *= info->timeFrom;
      }
    else
      {
        retval.MulByInvert (info->timeFrom);
      }
    return Time (retval);
  }  // Create Times from Values and Units
 
 
  inline int64_t ToInteger (enum Unit unit) const
  {
    struct Information *info = PeekInformation (unit);
    int64_t v = m_data;
    if (info->toMul)
      {
        v *= info->factor;
      }
    else
      {
        v /= info->factor;
      }
    return v;
  }
  inline double ToDouble (enum Unit unit) const
  {
    return To (unit).GetDouble ();
  }
  inline int64x64_t To (enum Unit unit) const
  {
    struct Information *info = PeekInformation (unit);
    int64x64_t retval = int64x64_t (m_data);
    if (info->toMul)
      {
        retval *= info->timeTo;
      }
    else
      {
        retval.MulByInvert (info->timeTo);
      }
    return retval;
  }  // Get Times as Numbers in Specified Units
 
  Time RoundTo (enum Unit unit) const
  {
    return From (this->To (unit).Round (), unit);
  }
 
  TimeWithUnit As (const enum Unit unit = Time::AUTO) const;
 
  typedef void (* TracedCallback)(Time value);
 
private:
  struct Information
  {
    bool toMul;                     
    bool fromMul;                   
    int64_t factor;                 
    int64x64_t timeTo;              
    int64x64_t timeFrom;            
  };
  struct Resolution
  {
    struct Information info[LAST];  
    enum Time::Unit unit;           
  };
 
  static inline struct Resolution * PeekResolution (void)
  {
    static struct Time::Resolution resolution = SetDefaultNsResolution ();
    return &resolution;
  }
  static inline struct Information * PeekInformation (enum Unit timeUnit)
  {
    return &(PeekResolution ()->info[timeUnit]);
  }
 
  static struct Resolution SetDefaultNsResolution (void);
  static void SetResolution (enum Unit unit, struct Resolution *resolution,
                             const bool convert = true);
 
  typedef std::set< Time * > MarkedTimes;
  static MarkedTimes * g_markingTimes;
 
public:
  static bool StaticInit ();
private:
  friend class Simulator;
  static void ClearMarkedTimes ();
  static void Mark (Time * const time);
  static void Clear (Time * const time);
  static void ConvertTimes (const enum Unit unit);
 
 
  // Operator and related functions which need access
 
  friend bool operator == (const Time & lhs, const Time & rhs);
  friend bool operator != (const Time & lhs, const Time & rhs);
  friend bool operator <= (const Time & lhs, const Time & rhs);
  friend bool operator >= (const Time & lhs, const Time & rhs);
  friend bool operator <  (const Time & lhs, const Time & rhs);
  friend bool operator >  (const Time & lhs, const Time & rhs);
  friend bool operator <  (const Time & time,   const EventId & event);  // Comparison operators
 
  friend Time operator +  (const Time & lhs, const Time & rhs);
  friend Time operator -  (const Time & lhs, const Time & rhs);
  friend Time operator *  (const Time & lhs, const int64x64_t & rhs);
  friend Time operator *  (const int64x64_t & lhs, const Time & rhs);
  friend int64x64_t operator / (const Time & lhs, const Time & rhs);
  friend Time operator /  (const Time & lhs, const int64x64_t & rhs);
  friend Time operator %  (const Time & lhs, const Time & rhs);
  friend int64_t Div      (const Time & lhs, const Time & rhs);
  friend Time Rem         (const Time & lhs, const Time & rhs);
 
  template<class T>
  friend typename std::enable_if<std::is_integral<T>::value, Time>::type
  operator * (const Time& lhs, T rhs);
 
  // Reversed arg version (forwards to `rhs * lhs`) 
  // Accepts both integers and decimal types
  template<class T>
  friend typename std::enable_if<std::is_arithmetic<T>::value, Time>::type
  operator * (T lhs, const Time& rhs);
 
  template<class T>
  friend typename std::enable_if<std::is_integral<T>::value, Time>::type
  operator / (const Time& lhs, T rhs);
 
  friend Time Abs (const Time & time);
  friend Time Max (const Time & timeA, const Time & timeB);
  friend Time Min (const Time & timeA, const Time & timeB);
  // Arithmetic operators
 
  // Leave undocumented
  template<class T>
  friend typename std::enable_if<std::is_floating_point<T>::value, Time>::type
  operator * (const Time& lhs, T rhs);
  template<class T>
  friend typename std::enable_if<std::is_floating_point<T>::value, Time>::type
  operator / (const Time& lhs, T rhs);
 
 
  friend Time & operator += (Time & lhs, const Time & rhs);
  friend Time & operator -= (Time & lhs, const Time & rhs);  // Compound assignment
 
 
  int64_t m_data;  
 
};  // class Time
 
namespace TracedValueCallback {
 
typedef void (* Time)(Time oldValue, Time newValue);
 
}  // namespace TracedValueCallback
 
[[maybe_unused]] static bool g_TimeStaticInit = Time::StaticInit ();
 
inline bool
operator == (const Time & lhs, const Time & rhs)
{
  return lhs.m_data == rhs.m_data;
}
inline bool
operator != (const Time & lhs, const Time & rhs)
{
  return lhs.m_data != rhs.m_data;
}
inline bool
operator <= (const Time & lhs, const Time & rhs)
{
  return lhs.m_data <= rhs.m_data;
}
inline bool
operator >= (const Time & lhs, const Time & rhs)
{
  return lhs.m_data >= rhs.m_data;
}
inline bool
operator < (const Time & lhs, const Time & rhs)
{
  return lhs.m_data < rhs.m_data;
}
inline bool
operator > (const Time & lhs, const Time & rhs)
{
  return lhs.m_data > rhs.m_data;
}
inline bool
operator <  (const Time & time, const EventId & event)
{
  // Negative Time is less than any possible EventId, which are all >= 0.
  if (time.m_data < 0)
    {
      return true;
    }
  // Time must be >= 0 so casting to unsigned is safe.
  return static_cast<uint64_t> (time.m_data) < event.GetTs ();
}
inline Time operator + (const Time & lhs, const Time & rhs)
{
  return Time (lhs.m_data + rhs.m_data);
}
inline Time operator - (const Time & lhs, const Time & rhs)
{
  return Time (lhs.m_data - rhs.m_data);
}
 
inline Time
operator * (const Time & lhs, const int64x64_t & rhs)
{
  int64x64_t res = lhs.m_data;
  res *= rhs;
  return Time (res);
}
inline Time
operator * (const int64x64_t & lhs, const Time & rhs)
{
  return rhs * lhs;
}
 
template<class T>
typename std::enable_if<std::is_integral<T>::value, Time>::type
operator * (const Time& lhs, T rhs)
{
  static_assert(!std::is_same<T, bool>::value,
                "Multiplying a Time by a boolean is not supported"); 
 
  return Time (lhs.m_data * rhs);
}
 
// Leave undocumented
template<class T>
typename std::enable_if<std::is_floating_point<T>::value, Time>::type
operator * (const Time& lhs, T rhs)
{
  return lhs * int64x64_t(rhs);
}
 
template<class T>
typename std::enable_if<std::is_arithmetic<T>::value, Time>::type
operator * (T lhs, const Time& rhs)
{
  return rhs * lhs;
}
 
inline int64x64_t
operator / (const Time & lhs, const Time & rhs)
{
  int64x64_t num = lhs.m_data;
  int64x64_t den = rhs.m_data;
  return num / den;
}
 
inline Time
operator / (const Time & lhs, const int64x64_t & rhs)
{
  int64x64_t res = lhs.m_data;
  res /= rhs;
  return Time (res);
}
 
template<class T>
typename std::enable_if<std::is_integral<T>::value, Time>::type
operator / (const Time& lhs, T rhs)
{
  static_assert(!std::is_same<T, bool>::value,
                "Dividing a Time by a boolean is not supported"); 
 
  return Time(lhs.m_data / rhs);
}
 
// Leave undocumented
template<class T>
typename std::enable_if<std::is_floating_point<T>::value, Time>::type
operator / (const Time& lhs, T rhs)
{
  return lhs / int64x64_t(rhs);
}
 
 
inline Time
operator % (const Time & lhs, const Time & rhs)
{
  return Time (lhs.m_data % rhs.m_data);
}
inline Time
Rem (const Time & lhs, const Time & rhs)
{
  return Time (lhs.m_data % rhs.m_data);
}
inline int64_t
Div (const Time & lhs, const Time & rhs)
{
  return lhs.m_data / rhs.m_data;
}
inline Time & operator += (Time & lhs, const Time & rhs)
{
  lhs.m_data += rhs.m_data;
  return lhs;
}
inline Time & operator -= (Time & lhs, const Time & rhs)
{
  lhs.m_data -= rhs.m_data;
  return lhs;
}
inline Time Abs (const Time & time)
{
  return Time ((time.m_data < 0) ? -time.m_data : time.m_data);
}
inline Time Max (const Time & timeA, const Time & timeB)
{
  return Time ((timeA.m_data < timeB.m_data) ? timeB : timeA);
}
inline Time Min (const Time & timeA, const Time & timeB)
{
  return Time ((timeA.m_data > timeB.m_data) ? timeB : timeA);
}
 
std::ostream & operator << (std::ostream & os, const Time & time);
std::istream & operator >> (std::istream & is, Time & time);
 
 
inline Time Years (double value)
{
  return Time::FromDouble (value, Time::Y);
}
inline Time Years (int64x64_t value)
{
  return Time::From (value, Time::Y);
}
inline Time Days (double value)
{
  return Time::FromDouble (value, Time::D);
}
inline Time Days (int64x64_t value)
{
  return Time::From (value, Time::D);
}
inline Time Hours (double value)
{
  return Time::FromDouble (value, Time::H);
}
inline Time Hours (int64x64_t value)
{
  return Time::From (value, Time::H);
}
inline Time Minutes (double value)
{
  return Time::FromDouble (value, Time::MIN);
}
inline Time Minutes (int64x64_t value)
{
  return Time::From (value, Time::MIN);
}
inline Time Seconds (double value)
{
  return Time::FromDouble (value, Time::S);
}
inline Time Seconds (int64x64_t value)
{
  return Time::From (value, Time::S);
}
inline Time MilliSeconds (uint64_t value)
{
  return Time::FromInteger (value, Time::MS);
}
inline Time MilliSeconds (int64x64_t value)
{
  return Time::From (value, Time::MS);
}
inline Time MicroSeconds (uint64_t value)
{
  return Time::FromInteger (value, Time::US);
}
inline Time MicroSeconds (int64x64_t value)
{
  return Time::From (value, Time::US);
}
inline Time NanoSeconds (uint64_t value)
{
  return Time::FromInteger (value, Time::NS);
}
inline Time NanoSeconds (int64x64_t value)
{
  return Time::From (value, Time::NS);
}
inline Time PicoSeconds (uint64_t value)
{
  return Time::FromInteger (value, Time::PS);
}
inline Time PicoSeconds (int64x64_t value)
{
  return Time::From (value, Time::PS);
}
inline Time FemtoSeconds (uint64_t value)
{
  return Time::FromInteger (value, Time::FS);
}
inline Time FemtoSeconds (int64x64_t value)
{
  return Time::From (value, Time::FS);
}  // Construct a Time in the indicated unit.
 
 
inline Time TimeStep (uint64_t ts)
{
  return Time (ts);
}
 
ATTRIBUTE_VALUE_DEFINE (Time);
ATTRIBUTE_ACCESSOR_DEFINE (Time);
 
Ptr<const AttributeChecker> MakeTimeChecker (const Time min, const Time max);
 
inline
Ptr<const AttributeChecker> MakeTimeChecker (void)
{
  return MakeTimeChecker (Time::Min (), Time::Max ());
}
 
inline
Ptr<const AttributeChecker> MakeTimeChecker (const Time min)
{
  return MakeTimeChecker (min, Time::Max ());
}
 
class TimeWithUnit
{
public:
  TimeWithUnit (const Time time, const Time::Unit unit)
    : m_time (time),
      m_unit (unit)
  { }
 
private:
  Time m_time;        
  Time::Unit m_unit;  
 
  friend std::ostream & operator << (std::ostream & os, const TimeWithUnit & timeU);
 
};  // class TimeWithUnit
 
} // namespace ns3
 
#endif /* TIME_H */