ns-3.24: comparison src/core/model/nstime.h

equal deleted inserted replaced

-:d45187afb01a
+:a1e09c7953a1
 class TimeWithUnit;
 /**
 * \ingroup core
+* \defgroup time Virtual Time
+* \brief Management of virtual time in real world units.
+*
+* The underlying simulator is unit agnostic, just dealing with
+* dimensionless virtual time.  Models usually need to handle
+* time in real world units, such as seconds, and conversions/scaling
+* between different units, between minutes and seconds, for example.
+*
+* The convenience constructors in the \ref timecivil "Standard Units" module
+* make it easy to create Times in specific units.
+*
+* The Time::SetResolution() function allows a one-time change of the
+* base resolution, before Simulator::Run().
+*/
+/**
+* \ingroup time
 * \brief Simulation virtual time values and global simulation resolution.
 *
 * This class defines all the classic C++ addition/subtraction
 * operators: +, -, +=, -=; and all the classic comparison operators:
 * ==, !=, <, >, <=, >=. It is thus easy to add, substract, or
 PS  = 8,   //!< picosecond
 FS  = 9,   //!< femtosecond
 LAST = 10
 };
+/**
+*  Assignment operator
+* \param [in] o Time to assign.
+* \return the Time.
+*/
 inline Time & operator = (const Time & o)
 {
 m_data = o.m_data;
 return *this;
 }
+/** Default constructor, with value 0. */
 inline Time ()
 : m_data ()
 {
 if (g_markingTimes)
 {
 	Mark (this);
 }
 }
+/**
+*  Copy constructor
+*
+* \param [in] o Time to copy
+*/
 inline Time(const Time & o)
 : m_data (o.m_data)
 {
 if (g_markingTimes)
 {
 	Mark (this);
 }
 }
+/**
+*  Construct from a numeric value.
+*
+*  The current time resolution will be assumed as the unit.
+*  \param [in] v The value.
+*  @{
+*/
 explicit inline Time (double v)
 : m_data (lround (v))
 {
 if (g_markingTimes)
 {
 if (g_markingTimes)
 {
 	Mark (this);
 }
 }
+explicit inline Time (const int64x64_t & v)
+: m_data (v.GetHigh ())
+{
+if (g_markingTimes)
+{
+	Mark (this);
+}
+}
+/**@}*/
 /**
 * \brief Construct Time object from common time expressions like "1ms"
 *
 * Supported units include:
 * - `s`  (seconds)
 * occur.
 * \param s The string to parse into a Time
 */
 explicit Time (const std::string & s);
-/**
+/** Minimum representable Time */
-* \brief Minimum representable Time
-*/
 static Time Min ()
 {
 return Time (std::numeric_limits<int64_t>::min ());
 }
-/**
+/** Maximum representable Time */
-* \brief Maximum representable Time
-*/
 static Time Max ()
 {
 return Time (std::numeric_limits<int64_t>::max ());
 }
-/**
+/** Destructor */
-*  Destructor
-*/
 ~Time ()
 {
 if (g_markingTimes)
 {
 Clear (this);
 }
 }
-/**
+/** \return true if the time is zero, false otherwise. */
-* \return true if the time is zero, false otherwise.
-*/
 inline bool IsZero (void) const
 {
 return m_data == 0;
 }
-/**
+/** \return true if the time is negative or zero, false otherwise. */
-* \return true if the time is negative or zero, false otherwise.
-*/
 inline bool IsNegative (void) const
 {
 return m_data <= 0;
 }
-/**
+/** \return true if the time is positive or zero, false otherwise. */
-* \return true if the time is positive or zero, false otherwise.
-*/
 inline bool IsPositive (void) const
 {
 return m_data >= 0;
 }
-/**
+/** \return true if the time is strictly negative, false otherwise. */
-* \return true if the time is strictly negative, false otherwise.
-*/
 inline bool IsStrictlyNegative (void) const
 {
 return m_data < 0;
 }
-/**
+/** \return true if the time is strictly positive, false otherwise. */
-* \return true if the time is strictly positive, false otherwise.
-*/
 inline bool IsStrictlyPositive (void) const
 {
 return m_data > 0;
 }
 /**
+*  Compare \p this to another Time
+*
+*  \param [in] o The other Time
 *  \return -1,0,+1 if `this < o`, `this == o`, or `this > o`
 */
 inline int Compare (const Time & o) const
 {
 return (m_data < o.m_data) ? -1 : (m_data == o.m_data) ? 0 : 1;
 }
 /**
-* \returns an approximation in seconds of the time stored in this
+* Get an approximation of the time stored in this instance
-*          instance.
+* in the indicated unit.
-*/
+*
+* \return An approximate value in the indicated unit.
+* @{
+*/
+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);
 }
-/**
-* \returns an approximation in milliseconds of the time stored in this
-*          instance.
-*/
 inline int64_t GetMilliSeconds (void) const
 {
 return ToInteger (Time::MS);
 }
-/**
-* \returns an approximation in microseconds of the time stored in this
-*          instance.
-*/
 inline int64_t GetMicroSeconds (void) const
 {
 return ToInteger (Time::US);
 }
-/**
-* \returns an approximation in nanoseconds of the time stored in this
-*          instance.
-*/
 inline int64_t GetNanoSeconds (void) const
 {
 return ToInteger (Time::NS);
 }
-/**
-* \returns an approximation in picoseconds of the time stored in this
-*          instance.
-*/
 inline int64_t GetPicoSeconds (void) const
 {
 return ToInteger (Time::PS);
 }
-/**
-* \returns an approximation in femtoseconds of the time stored in this
-*          instance.
-*/
 inline int64_t GetFemtoSeconds (void) const
 {
 return ToInteger (Time::FS);
 }
+/**@}*/
-/**
-* \returns an approximation in minutes of the time stored in this
+/**
-*          instance.
+* \returns the raw time value, in the current unit
-*/
+* @{
-inline double GetMinutes (void) const
-{
-return ToDouble (Time::MIN);
-}
-/**
-* \returns an approximation in hours of the time stored in this
-*          instance.
-*/
-inline double GetHours (void) const
-{
-return ToDouble (Time::H);
-}
-/**
-* \returns an approximation in days of the time stored in this
-*          instance.
-*/
-inline double GetDays (void) const
-{
-return ToDouble (Time::D);
-}
-/**
-* \returns an approximation in years of the time stored in this
-*          instance.
-*/
-inline double GetYears (void) const
-{
-return ToDouble (Time::Y);
-}
-/**
-* \returns the raw time value, in the current units
 */
 inline int64_t GetTimeStep (void) const
 {
 return m_data;
 }
 }
 inline int64_t GetInteger (void) const
 {
 return GetTimeStep ();
 }
+/**@}*/
 /**
 * \param resolution the new resolution to use
 *
 static void SetResolution (enum Unit resolution);
 /**
 * \returns the current global resolution.
 */
 static enum Unit GetResolution (void);
-/**
-* \param value to convert into a Time object
-* \param timeUnit the unit of the value to convert
+/**
-* \return a new Time object
+*  Create a Time in the current unit.
 *
-* This method interprets the input value according to the input
+*  \param [in] value The value of the new Time.
-* unit and constructs a matching Time object.
+*  \return A Time with \p value in the current time unit.
-*
+*/
-* \sa FromDouble, ToDouble, ToInteger
+inline static Time From (const int64x64_t & value)
-*/
+{
-inline static Time FromInteger (uint64_t value, enum Unit timeUnit)
+return Time (value);
-{
+}
-struct Information *info = PeekInformation (timeUnit);
+/**
+*  Create a Time equal to \p value  in unit \c unit
+*
+*  \param [in] value The new Time value, expressed in \c unit
+*  \param [in] unit The unit of \p value
+*  \return The Time representing \p value in \c unit
+*  @{
+*/
+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)
-* \param timeUnit the unit of the value to return
+{
-* \return int64_t time value
+return From (int64x64_t (value), unit);
-*
+}
-* Convert the input time into an integer value according to the requested
+inline static Time From (const int64x64_t & value, enum Unit unit)
-* time unit.
+{
-*/
+struct Information *info = PeekInformation (unit);
-inline int64_t ToInteger (enum Unit timeUnit) const
+// DO NOT REMOVE this temporary variable. It's here
-{
+// to work around a compiler bug in gcc 3.4
-struct Information *info = PeekInformation (timeUnit);
+int64x64_t retval = value;
+if (info->fromMul)
+{
+retval *= info->timeFrom;
+}
+else
+{
+retval.MulByInvert (info->timeFrom);
+}
+return Time (retval);
+}
+/**@}*/
+/**
+*  Get the Time value expressed in a particular unit.
+*
+*  \param [in] unit The desired unit
+*  \return The Time expressed in \p unit
+*  @{
+*/
+inline int64_t ToInteger (enum Unit unit) const
+{
+struct Information *info = PeekInformation (unit);
 int64_t v = m_data;
 if (info->toMul)
 {
 v *= info->factor;
 }
 {
 v /= info->factor;
 }
 return v;
 }
-/**
+inline double ToDouble (enum Unit unit) const
-* \param value to convert into a Time object
+{
-* \param timeUnit the unit of the value to convert
+return To (unit).GetDouble ();
-* \return a new Time object
+}
-*
+inline int64x64_t To (enum Unit unit) const
-* \sa FromInteger, ToInteger, ToDouble
+{
-*/
+struct Information *info = PeekInformation (unit);
-inline static Time FromDouble (double value, enum Unit timeUnit)
-{
-return From (int64x64_t (value), timeUnit);
-}
-/**
-* \param timeUnit the unit of the value to return
-* \return double time value
-*
-* Convert the input time into a floating point value according to the requested
-* time unit.
-*/
-inline double ToDouble (enum Unit timeUnit) const
-{
-return To (timeUnit).GetDouble ();
-}
-static inline Time From (const int64x64_t & from, enum Unit timeUnit)
-{
-struct Information *info = PeekInformation (timeUnit);
-// DO NOT REMOVE this temporary variable. It's here
-// to work around a compiler bug in gcc 3.4
-int64x64_t retval = from;
-if (info->fromMul)
-{
-retval *= info->timeFrom;
-}
-else
-{
-retval.MulByInvert (info->timeFrom);
-}
-return Time (retval);
-}
-inline int64x64_t To (enum Unit timeUnit) const
-{
-struct Information *info = PeekInformation (timeUnit);
 int64x64_t retval = int64x64_t (m_data);
 if (info->toMul)
 {
 retval *= info->timeTo;
 }
 {
 retval.MulByInvert (info->timeTo);
 }
 return retval;
 }
+/**@}*/
+/** Cast to int64x64_t */
 inline operator int64x64_t () const
 {
 return int64x64_t (m_data);
 }
-explicit inline Time (const int64x64_t & value)
-: m_data (value.GetHigh ())
-{
-if (g_markingTimes)
-{
-	Mark (this);
-}
-}
-inline static Time From (const int64x64_t & value)
-{
-return Time (value);
-}
 /**
 * Attach a unit to a Time, to facilitate output in a specific unit.
 *
 * For example,
 * \code
 *   std::cout << t.As (Time::MS) << std::endl;
 * \endcode
 * will print ``+3140.0ms``
 *
 * \param unit [in] The unit to use.
+* \return The Time with embedded unit.
 */
 TimeWithUnit As (const enum Unit unit) const;
 private:
-/**
+/** How to convert between other units and the current unit. */
-* How to convert between other units and the current unit
-*/
 struct Information
 {
 bool toMul;                     //!< Multiply when converting To, otherwise divide
 bool fromMul;                   //!< Multiple when converting From, otherwise divide
 int64_t factor;                 //!< Ratio of this unit / current unit
 int64x64_t timeTo;              //!< Multiplier to convert to this unit
 int64x64_t timeFrom;            //!< Multiplier to convert from this unit
 };
-/**
+/** Current time unit, and conversion info. */
-* Current time unit, and conversion info.
-*/
 struct Resolution
 {
 struct Information info[LAST];  //!<  Conversion info from current unit
 enum Time::Unit unit;           //!<  Current time unit
 };
+/**
+*  Get the current Resolution
+*
+* \return A pointer to the current Resolution
+*/
 static inline struct Resolution *PeekResolution (void)
 {
 static struct Time::Resolution resolution = SetDefaultNsResolution ();
 return & resolution;
 }
+/**
+*  Get the Information record for \p timeUnit for the current Resolution
+*
+*  \param [in] timeUnit The Unit to get Information for
+*  \return the Information for \p timeUnit
+*/
 static inline struct Information *PeekInformation (enum Unit timeUnit)
 {
 return & (PeekResolution ()->info[timeUnit]);
 }
+/**
+*  Set the default resolution
+*
+* \return The Resolution object for the default resolution.
+*/
 static struct Resolution SetDefaultNsResolution (void);
+/**
+*  Set the current Resolution.
+*
+*  \param [in] unit The unit to use as the new resolution.
+*  \param [in,out] resolution The Resolution record to update.
+*  \param [in] convert Whether to convert existing Time objects to the new resolution.
+*/
 static void SetResolution (enum Unit unit, struct Resolution *resolution,
 const bool convert = true);
 /**
 *  Record all instances of Time, so we can rescale them when
 *  includes nstime.h.
 */
 static MarkedTimes * g_markingTimes;
 public:
 /**
-*  Function to force static initialization of Time
+*  Function to force static initialization of Time.
+*
+* \return true on the first call
 */
 static bool StaticInit ();
 private:
 /* Friend the Simulator class so it can call the private function
 *  \internal
 *  Has to be visible to the Simulator class, hence the friending.
 */
 static void ClearMarkedTimes ();
 /**
-*  Record a Time instance with the MarkedTimes
+*  Record a Time instance with the MarkedTimes.
+*  \param [in] time The Time instance to record.
 */
 static void Mark (Time * const time);
 /**
-*  Remove a Time instance from the MarkedTimes, called by ~Time()
+*  Remove a Time instance from the MarkedTimes, called by ~Time().
+*  \param [in] time The Time instance to remove.
 */
 static void Clear (Time * const time);
 /**
 *  Convert existing Times to the new unit.
+*  \param [in] unit The Unit to convert existing Times to.
 */
 static void ConvertTimes (const enum Unit unit);
+/**
+*  @{
+*  Arithmetic operator.
+*  \param [in] lhs Left hand argument
+*  \param [in] rhs Righ hand argument
+*  \return The result of the operator.
+*/
 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 Time operator * (const int64_t & lhs, const Time & rhs);
 friend int64_t operator / (const Time & lhs, const Time & rhs);
 friend Time operator / (const Time & lhs, const int64_t & rhs);
 friend Time & operator += (Time & lhs, const Time & rhs);
 friend Time & operator -= (Time & lhs, const Time & rhs);
+/**@}*/
+/**
+*  Absolute value function for Time
+*  \param time the input value
+*  \returns the absolute value of the input value.
+*/
 friend Time Abs (const Time & time);
+/**
+*  Max function for Time.
+*  \param ta the first value
+*  \param tb the seconds value
+*  \returns the max of the two input values.
+*/
 friend Time Max (const Time & ta, const Time & tb);
+/**
+*  Min function for Time.
+*  \param ta the first value
+*  \param tb the seconds value
+*  \returns the min of the two input values.
+*/
 friend Time Min (const Time & ta, const Time & tb);
+int64_t m_data;  //!< Virtual time value, in the current unit.
-int64_t m_data;                   //!< Virtual time value, in the current unit.
 };  // class Time
 /// Force static initialization of Time
 {
 lhs.m_data -= rhs.m_data;
 return lhs;
 }
-/**
-* Max function for Time.
+inline Time Abs (const Time & time)
-* \param ta the first value
+{
-* \param tb the seconds value
+return Time ((time.m_data < 0) ? -time.m_data : time.m_data);
-* \returns the max of the two input values.
+}
-*/
 inline Time Max (const Time & ta, const Time & tb)
 {
 return Time ((ta.m_data < tb.m_data) ? tb : ta);
 }
-/**
-* Min function for Time.
-* \param ta the first value
-* \param tb the seconds value
-* \returns the min of the two input values.
-*/
 inline Time Min (const Time & ta, const Time & tb)
 {
 return Time ((ta.m_data > tb.m_data) ? tb : ta);
 }
 /**
-* Absolute value function for Time
+* \ingroup time
-* \param time the input value
-* \returns the absolute value of the input value.
-*/
-inline Time Abs (const Time & time)
-{
-return Time ((time.m_data < 0) ? -time.m_data : time.m_data);
-}
-/**
 * \brief Time output streamer.
 *
 * Generates output such as "3.96ns".  Times are printed with the
 * following format flags (independent of the stream flags):
 *   - `showpos`
 *   - `fixed`
 *   - `left`
 * The stream `width` and `precision` are ignored; Time output always
 * includes ".0".
-* \relates Time
+*
-*/
+* \param [in] os The output stream.
-std::ostream & operator<< (std::ostream & os, const Time & time);
+* \param [in] time The Time to put on the stream.
-/**
+* \return The stream.
+*/
+std::ostream & operator << (std::ostream & os, const Time & time);
+/**
+* \ingroup time
 * \brief Time input streamer
 *
 * Uses the Time::Time (const std::string &) constructor
-* \relates Time
+*
-*/
+* \param [in] is The input stream.
-std::istream & operator>> (std::istream & is, Time & time);
+* \param [out] time The Time variable to set from the stream data.
+* \return The stream.
-/**
+*/
-* \brief create ns3::Time instances in units of seconds.
+std::istream & operator >> (std::istream & is, Time & time);
+/**
+* \ingroup time
+* \defgroup timecivil Standard time units.
+* \brief Convenience constructors in standard units.
 *
 * For example:
 * \code
-* Time t = Seconds (2.0);
+*   Time t = Seconds (2.0);
-* Simulator::Schedule (Seconds (5.0), ...);
+*   Simulator::Schedule (Seconds (5.0), ...);
 * \endcode
-* \param seconds seconds value
+*/
-* \relates Time
+/**
-*/
+* \ingroup timecivil
-inline Time Seconds (double seconds)
+* Construct a Time in the indicated unit.
-{
+* \param value The value
-return Time::FromDouble (seconds, Time::S);
+* \return The Time
-}
+* @{
+*/
-/**
+inline Time Years (double value)
-* \brief create ns3::Time instances in units of milliseconds.
+{
-*
+return Time::FromDouble (value, Time::Y);
-* For example:
+}
-* \code
+inline Time Years (int64x64_t value)
-* Time t = MilliSeconds (2);
+{
-* Simulator::Schedule (MilliSeconds (5), ...);
+return Time::From (value, Time::Y);
-* \endcode
+}
-* \param ms milliseconds value
+inline Time Days (double value)
-* \relates Time
+{
-*/
+return Time::FromDouble (value, Time::D);
-inline Time MilliSeconds (uint64_t ms)
+}
-{
+inline Time Days (int64x64_t value)
-return Time::FromInteger (ms, Time::MS);
+{
-}
+return Time::From (value, Time::D);
-/**
+}
-* \brief create ns3::Time instances in units of microseconds.
+inline Time Hours (double value)
-*
+{
-* For example:
+return Time::FromDouble (value, Time::H);
-* \code
+}
-* Time t = MicroSeconds (2);
+inline Time Hours (int64x64_t value)
-* Simulator::Schedule (MicroSeconds (5), ...);
+{
-* \endcode
+return Time::From (value, Time::H);
-* \param us microseconds value
+}
-* \relates Time
+inline Time Minutes (double value)
-*/
+{
-inline Time MicroSeconds (uint64_t us)
+return Time::FromDouble (value, Time::MIN);
-{
+}
-return Time::FromInteger (us, Time::US);
+inline Time Minutes (int64x64_t value)
-}
+{
-/**
+return Time::From (value, Time::MIN);
-* \brief create ns3::Time instances in units of nanoseconds.
+}
-*
+inline Time Seconds (double value)
-* For example:
+{
-* \code
+return Time::FromDouble (value, Time::S);
-* Time t = NanoSeconds (2);
+}
-* Simulator::Schedule (NanoSeconds (5), ...);
+inline Time Seconds (int64x64_t value)
-* \endcode
+{
-* \param ns nanoseconds value
+return Time::From (value, Time::S);
-* \relates Time
+}
-*/
+inline Time MilliSeconds (uint64_t value)
-inline Time NanoSeconds (uint64_t ns)
+{
-{
+return Time::FromInteger (value, Time::MS);
-return Time::FromInteger (ns, Time::NS);
+}
-}
+inline Time MilliSeconds (int64x64_t value)
-/**
+{
-* \brief create ns3::Time instances in units of picoseconds.
+return Time::From (value, Time::MS);
-*
+}
-* For example:
+inline Time MicroSeconds (uint64_t value)
-* \code
+{
-* Time t = PicoSeconds (2);
+return Time::FromInteger (value, Time::US);
-* Simulator::Schedule (PicoSeconds (5), ...);
+}
-* \endcode
+inline Time MicroSeconds (int64x64_t value)
-* \param ps picoseconds value
+{
-* \relates Time
+return Time::From (value, Time::US);
-*/
+}
-inline Time PicoSeconds (uint64_t ps)
+inline Time NanoSeconds (uint64_t value)
 {
-return Time::FromInteger (ps, Time::PS);
+return Time::FromInteger (value, Time::NS);
 }
-/**
+inline Time NanoSeconds (int64x64_t value)
-* \brief create ns3::Time instances in units of femtoseconds.
+{
-*
+return Time::From (value, Time::NS);
-* For example:
+}
-* \code
+inline Time PicoSeconds (uint64_t value)
-* Time t = FemtoSeconds (2);
+{
-* Simulator::Schedule (FemtoSeconds (5), ...);
+return Time::FromInteger (value, Time::PS);
-* \endcode
+}
-* \param fs femtoseconds value
+inline Time PicoSeconds (int64x64_t value)
-* \relates Time
+{
-*/
+return Time::From (value, Time::PS);
-inline Time FemtoSeconds (uint64_t fs)
+}
-{
+inline Time FemtoSeconds (uint64_t value)
-return Time::FromInteger (fs, Time::FS);
+{
-}
+return Time::FromInteger (value, Time::FS);
-/**
+}
-* \brief create ns3::Time instances in units of minutes (equal to 60 seconds).
+inline Time FemtoSeconds (int64x64_t value)
-*
+{
-* For example:
+return Time::From (value, Time::FS);
-* \code
+}
-* Time t = Minutes (2.0);
+/**@}*/
-* Simulator::Schedule (Minutes (5.0), ...);
-* \endcode
-* \param minutes mintues value
+/**
-* \relates Time
+*  \ingroup time
-*/
+*  \internal Scheduler interface
-inline Time Minutes (double minutes)
+*  \param [in] ts The time value, in the current unit.
-{
+*  \return A Time.
-return Time::FromDouble (minutes, Time::MIN);
+*/
-}
-/**
-* \brief create ns3::Time instances in units of hours (equal to 60 minutes).
-*
-* For example:
-* \code
-* Time t = Hours (2.0);
-* Simulator::Schedule (Hours (5.0), ...);
-* \endcode
-* \param hours hours value
-* \relates Time
-*/
-inline Time Hours (double hours)
-{
-return Time::FromDouble (hours, Time::H);
-}
-/**
-* \brief create ns3::Time instances in units of days (equal to 24 hours).
-*
-* For example:
-* \code
-* Time t = Days (2.0);
-* Simulator::Schedule (Days (5.0), ...);
-* \endcode
-* \param days days value
-* \relates Time
-*/
-inline Time Days (double days)
-{
-return Time::FromDouble (days, Time::D);
-}
-/**
-* \brief create ns3::Time instances in units of years (equal to 365 days).
-*
-* For example:
-* \code
-* Time t = Years (2.0);
-* Simulator::Schedule (Years (5.0), ...);
-* \endcode
-* \param years years value
-* \relates Time
-*/
-inline Time Years (double years)
-{
-return Time::FromDouble (years, Time::Y);
-}
-/**
-* \see Seconds(double)
-* \relates Time
-*/
-inline Time Seconds (int64x64_t seconds)
-{
-return Time::From (seconds, Time::S);
-}
-/**
-* \see MilliSeconds(uint64_t)
-* \relates Time
-*/
-inline Time MilliSeconds (int64x64_t ms)
-{
-return Time::From (ms, Time::MS);
-}
-/**
-* \see MicroSeconds(uint64_t)
-* \relates Time
-*/
-inline Time MicroSeconds (int64x64_t us)
-{
-return Time::From (us, Time::US);
-}
-/**
-* \see NanoSeconds(uint64_t)
-* \relates Time
-*/
-inline Time NanoSeconds (int64x64_t ns)
-{
-return Time::From (ns, Time::NS);
-}
-/**
-* \see PicoSeconds(uint64_t)
-* \relates Time
-*/
-inline Time PicoSeconds (int64x64_t ps)
-{
-return Time::From (ps, Time::PS);
-}
-/**
-* \see FemtoSeconds(uint64_t)
-* \relates Time
-*/
-inline Time FemtoSeconds (int64x64_t fs)
-{
-return Time::From (fs, Time::FS);
-}
-/**
-* \see Minutes(uint64_t)
-* \relates Time
-*/
-inline Time Minutes (int64x64_t minutes)
-{
-return Time::From (minutes, Time::MIN);
-}
-/**
-* \see Minutes(uint64_t)
-* \relates Time
-*/
-inline Time Hours (int64x64_t hours)
-{
-return Time::From (hours, Time::H);
-}
-/**
-* \see Minutes(uint64_t)
-* \relates Time
-*/
-inline Time Days (int64x64_t days)
-{
-return Time::From (days, Time::D);
-}
-/**
-* \see Minutes(uint64_t)
-* \relates Time
-*/
-inline Time Years (int64x64_t years)
-{
-return Time::From (years, Time::Y);
-}
-// internal function not publicly documented
 inline Time TimeStep (uint64_t ts)
 {
 return Time (ts);
 }
 /**
+* \ingroup time
 * \class ns3::TimeValue
-* \brief hold objects of type ns3::Time
+* \brief Attribute for objects of type ns3::Time
 */
 ATTRIBUTE_VALUE_DEFINE (Time);
+/**
+*  Attribute accessor function for Time
+*  @{
+*/
 ATTRIBUTE_ACCESSOR_DEFINE (Time);
+/**@}*/
-/**
-* \brief Helper to make a Time checker with bounded range.
+/**
-* Both limits are inclusive
+*  \ingroup time
-*
+*  \brief Helper to make a Time checker with bounded range.
-* \return the AttributeChecker
+*  Both limits are inclusive
+*
+*  \param [in] min Minimum allowed value.
+*  \param [in] max Maximum allowed value.
+*  \return the AttributeChecker
 */
 Ptr<const AttributeChecker> MakeTimeChecker (const Time min, const Time max);
 /**
+* \ingroup time
 * \brief Helper to make an unbounded Time checker.
 *
 * \return the AttributeChecker
 */
 inline
 {
 return MakeTimeChecker (Time::Min (), Time::Max ());
 }
 /**
+* \ingroup time
 * \brief Helper to make a Time checker with a lower bound.
 *
+*  \param [in] min Minimum allowed value.
 * \return the AttributeChecker
 */
 inline
 Ptr<const AttributeChecker> MakeTimeChecker (const Time min)
 {
 private:
 Time m_time;        //!< The time
 Time::Unit m_unit;  //!< The unit to use in output
-/// Output streamer
+/**
-friend std::ostream & operator << (std::ostream & os, const TimeWithUnit & time);
+*  Output streamer
+*  \param [in] os The stream.
+*  \param [in] timeU The Time with desired unit
+*  \returns The stream.
+*/
+friend std::ostream & operator << (std::ostream & os, const TimeWithUnit & timeU);
 };  // class TimeWithUnit
 } // namespace ns3

changeset 10857	a1e09c7953a1
parent 10784	13017af6d1b0
child 10978	754c8256c35c