timepointbase.inl

Go to the documentation of this file.

//==================================================================================================
/// \file
/// This header-file is part of the \aliblong. It does not belong to an \alibmod and is
/// included in any \alibbuild.
///
/// \emoji :copyright: 2013-2025 A-Worx GmbH, Germany.
/// Published under \ref mainpage_license "Boost Software License".
//==================================================================================================
ALIB_EXPORT namespace alib::time {
 
#if !DOXYGEN
#   define sc std::chrono::
#endif
 
//==================================================================================================
/// As explained in detail in the documentation of module \alib_time, a steady time model is
/// supported with class \alib{time;Ticks} and a non-steady one representing the system clock with
/// class \alib{time;DateTime}.
/// Both types share this template class as their generic base.
///
/// The common features that this class provides to its descendants are:
/// - Type definition #TTimePoint used to store a point in time.
/// - Method #Export, which returns the internal value of type #TTimePoint which is of C++
///   standard type \c std::chrono::time_point.
/// - Inner class \alib{time::TimePointBase;Duration} that represents the difference type of this
///   class.
/// - Static method #Now which creates an instance representing the current point in time.
/// - Methods #Age and #Since.
/// - Various overloaded arithmetic and comparison operators.
///
/// \note
///   The resolution and accuracy of the values is platform-dependent. Especially nanoseconds are
///   deemed to be inaccurate if below several hundreds (this was written and fact in 2013,
///   reviewed 2019).
///
/// \attention
///   The dates storable in objects of this class are limited to a certain time range. In the
///   current GNU/Linux and Windows implementations the range is roughly <c>+-292.27</c> years
///   before and after the point in time that the system that the software is running on was
///   initialized (bootstrapped). This value results from the following facts for these
///   implementations:
///   - the storage resolution is one nanosecond.
///   - the storage size is 64 bits (63 plus the sign bit).
///   - system-dependent ticks counters are reset to \c 0 with the boot of a system.
///
///   Now, dividing <c>2^63</c> by the number of nanoseconds of one year which
///   consists of roughly 365.25 days, this results in 292.27 years.
///
/// @tparam TClock    The type of clock to use. This will be
///                   - \c std::chrono::system_clock with descendant class \alib{time;DateTime} and
///                   - \c std::chrono::steady_clock with descendant class \alib{time;Ticks}.
/// @tparam TDerived  The derived type itself, hence either \alib{time;DateTime} or
///                   \alib{time;Ticks}. This template parameter is needed to define the result
///                   type of various methods and operators.
//==================================================================================================
template<typename TClock, typename TDerived>
class TimePointBase
{
  public:
        /// The internal c++ type for time points.
        using   TTimePoint=    typename TClock::time_point;
 
        /// Integral type used for exporting and importing values in raw units.
        using   TRaw=          typename TTimePoint::rep;
 
 
    /// This inner class of \b %TimePointBase represents durations, hence difference values of two
    /// values of the parent class.
    ///
    /// Often, objects of this class are generated by the subtraction of \b %TimePointBase values or
    /// by using methods \alib{time;TimePointBase::Age} and \alib{time;TimePointBase::Since}.
    /// Furthermore, class \alib{strings::util;CalendarDuration} (found in the module
    /// \alib_strings) can be used to convert durations to and from human-readable units (days,
    /// hours, minutes, etc.).
    ///
    /// ## Friends ##
    /// class \alib{time;TimePointBase}
    class   Duration
    {
        #if !DOXYGEN
            // In C++ inner classes need to be friend to access protected elements of the outer class.
            friend class TimePointBase;
        #endif
 
 
      public:
            /// The value type for time spans.
            using   TDuration =   sc steady_clock::duration;
 
 
      //############################################################################################
      // protected fields
      //############################################################################################
      protected:
        /// The internal time value.
        TDuration         span;
 
      //############################################################################################
      // Constructors
      //############################################################################################
      public:
 
        /// Creates a zero-length time span.
        constexpr
        Duration()
        : span(0)                                                                                 {}
 
        /// Constructs an instance from C++ library values.
        /// @see Methods #Import/#Export.
        /// @param stdLibValue The value to copy into this.
        Duration( const TDuration& stdLibValue )
        : span( stdLibValue )                                                                     {}
 
        /// Constructs an instance from C++ library values.
        /// @see Methods #Import/#Export.
        /// @param stdLibValue The value to copy into this.
        /// @return A reference to this object.
        Duration& operator=( const TDuration& stdLibValue )     { span= stdLibValue; return *this; }
 
      //############################################################################################
      // Interface
      //############################################################################################
 
        /// Returns the internal time span value using the C++ standard library format.
        /// @return The internal value.
        TDuration       Export()                                              const { return span; }
 
        /// Creates an instance representing the time span given in C++ standard library format.
        /// @param timeSpan The C++ time point value.
        /// @return A time span value representing the given externalized \p{timeSpan}.
        static
        Duration        Import( const TDuration& timeSpan )        { return Duration ( timeSpan ); }
 
 
        /// Sets this object's value to the given duration, in the case the given is shorter.
        /// @param other The time stamp to compare.
        /// @return A reference to this object.
        Duration&       SetMinimum( const Duration& other  )
        {
            span= (std::min)(span, other.span);
            return *this;
        }
 
        /// Sets this object's value to the given duration, in the case the given is longer.
        /// @param other The time stamp to compare.
        /// @return A reference to this object.
        Duration&       SetMaximum( const Duration& other  )
        {
            span= (std::max)(span, other.span);
            return *this;
        }
 
        /// @return \c true if this is a positive duration, \c false otherwise.
        bool            IsPositive()                              const { return span.count() > 0; }
 
        /// @return \c true if this is a zero-length time-span, \c false otherwise.
        bool            IsZero()                                 const { return span.count() == 0; }
 
        /// Equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator==( const Duration& other )              const { return span == other.span; }
 
 
        /// Equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator==( const TDuration& other )                  const { return span == other; }
 
        /// Not equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator!=( const Duration& other )              const { return span != other.span; }
 
        /// Not equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator!=( const TDuration& other )                  const { return span != other; }
 
        /// Less than operator.
        /// @param other The duration to compare.
        /// @return A reference to this object.
        bool   operator<( const Duration& other )               const { return span <  other.span; }
 
        /// Less than operator.
        /// @param other The duration to compare.
        /// @return A reference to this object.
        bool   operator<( const TDuration& other )                   const { return span <  other; }
 
        /// Less than or equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator<=( const Duration& other )             const { return span <=  other.span; }
 
        /// Less than or equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator<=( const TDuration& other )                 const { return span <=  other; }
 
        /// Greater than operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator>( const Duration& other )               const { return span >  other.span; }
 
        /// Greater than operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator>( const TDuration& other )                   const { return span >  other; }
 
        /// Greater than or equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator>=( const Duration& other )             const { return span >=  other.span; }
 
        /// Greater than or equal to operator.
        /// @param other The duration to compare.
        /// @return The result of the comparison.
        bool   operator>=( const TDuration& other )                 const { return span >=  other; }
 
        /// Addition operator.
        /// @param rhs The right-hand side time span to add.
        /// @return A time span containing the sum.
        Duration operator+( const Duration& rhs )        const { return Duration(span + rhs.span); }
 
        /// Addition operator.
        /// @param rhs The right-hand side time span to add.
        /// @return A time span containing the sum.
        Duration operator+( const TDuration& rhs )            const { return Duration(span + rhs); }
 
        /// Assignment by sum operator.
        /// @param other The time span to subtract.
        /// @return A reference to this object.
        Duration& operator+=( const Duration& other )           { span+= other.span; return *this; }
 
        /// Assignment by sum operator.
        /// @param other The time span to subtract.
        /// @return A reference to this object.
        Duration& operator+=( const TDuration& other )               { span+= other; return *this; }
 
        /// Subtraction operator.
        /// @param rhs The right-hand side time span to subtract.
        /// @return A time span containing the sum.
        Duration operator-( const Duration& rhs )        const { return Duration(span - rhs.span); }
 
        /// Subtraction operator.
        /// @param rhs The right-hand side time span to subtract.
        /// @return A time span containing the sum.
        Duration operator-( const TDuration& rhs )            const { return Duration(span - rhs); }
 
        /// Assignment by difference operator.
        /// @param other The time span subtract.
        /// @return A reference to this object.
        Duration& operator-=( const Duration& other )           { span-= other.span; return *this; }
 
        /// Assignment by difference operator.
        /// @param other The time span subtract.
        /// @return A reference to this object.
        Duration& operator-=( const TDuration& other )               { span-= other; return *this; }
 
        /// Multiply operator.
        /// @param multiplier The multiplier.
        /// @return A time span containing the sum.
        Duration operator*( double multiplier )                                                const
        { return sc duration_cast<TDuration>( (span * multiplier) ); }
 
        /// Multiply operator.
        /// @param multiplier The multiplier.
        /// @return A time span containing the sum.
        Duration operator*( int64_t multiplier )                                               const
        { return sc duration_cast<TDuration>( (span * multiplier) ); }
 
        /// Assignment by product operator.
        /// @param multiplier The multiplier.
        /// @return A reference to this object.
        Duration& operator*=( double multiplier )
        { span= sc duration_cast<TDuration>( (span * multiplier) ); return *this; }
 
        /// Assignment by product operator.
        /// @param multiplier The multiplier.
        /// @return A reference to this object.
        Duration& operator*=( int64_t multiplier )
        { span= sc duration_cast<TDuration>( (span * multiplier) ); return *this; }
 
        /// Divide operator.
        /// @param divisor The divisor.
        /// @return A time span containing the sum.
        Duration operator/( double divisor )                                                   const
        { return sc duration_cast<TDuration>( (span / divisor) ); }
 
        /// Divide operator.
        /// @param divisor The divisor.
        /// @return A time span object containing the sum.
        Duration operator/( int64_t divisor )                                                  const
        { return sc duration_cast<TDuration>( (span / divisor) ); }
 
        /// Assignment by quotient operator.
        /// @param divisor The divisor.
        /// @return A reference to this object.
        Duration& operator/=( double divisor )
        { span= sc duration_cast<TDuration>( (span / divisor) ); return *this; }
 
 
        /// Assignment by quotient operator.
        /// @param divisor The divisor.
        /// @return A reference to this object.
        Duration& operator/=( int64_t divisor )
        { span= sc duration_cast<TDuration>( (span / divisor) ); return *this; }
 
 
      //############################################################################################
      // Conversion to/from time values (nanoseconds, milliseconds, microseconds, seconds, ...)
      //############################################################################################
      public:
 
        /// Converts the internal value to days.
        /// @return The internal value converted to days.
        double         InDays()                                                              const {
           return double( sc duration_cast<sc microseconds>( span ).count() )
                  / (1000000. * 3600. * 24. );
        }
 
        /// Converts the internal value to absolute days.
        /// @return The internal value converted to days.
        integer        InAbsoluteDays()                                                      const {
           return integer( sc duration_cast<sc hours>( span ).count()
                                        / 24 );
        }
 
        /// Converts the internal value to hours.
        /// @return The internal value converted to hours.
        double        InHours()                                                              const {
           return double( sc duration_cast<sc microseconds>( span ).count() )
                  / (1000000. * 3600. );
        }
 
        /// Converts the internal value to absolute hours.
        /// @return The internal value converted to hours.
        integer       InAbsoluteHours()                                                        const
        { return integer( sc duration_cast<sc hours>( span ).count() ); }
 
        /// Converts the internal value to minutes.
        /// @return The internal value converted to minutes.
        double        InMinutes()                                                            const {
           return double( sc duration_cast<sc microseconds>( span ).count() )
                  / (1000000. * 60. );
        }
 
        /// Converts the internal value to absolute minutes.
        /// @return The internal value converted to minutes.
        int64_t       InAbsoluteMinutes()                                                      const
        { return sc duration_cast<sc minutes>( span ).count(); }
 
        /// Converts the internal value to seconds.
        /// @return The internal value converted to seconds.
        double        InSeconds()                                                            const {
           return double( sc duration_cast<sc nanoseconds>( span ).count() )
                  / (1000000000. );
        }
 
        /// Converts the internal value to absolute seconds.
        /// @return The internal value converted to seconds.
        int64_t       InAbsoluteSeconds()                                                      const
        { return sc duration_cast<sc seconds>( span ).count(); }
 
        /// Converts the internal value to milliseconds.
        /// @return The internal value converted to milliseconds.
        double      InMilliseconds()                                                         const {
           return double( sc duration_cast<sc nanoseconds>( span ).count() )
                  / (1000000. );
        }
 
        /// Converts the internal value to absolute milliseconds.
        /// @return The internal value converted to milliseconds.
        int64_t     InAbsoluteMilliseconds()                                                   const
        { return sc duration_cast<sc milliseconds>( span ).count(); }
 
        /// Converts the internal value to microseconds.
        /// @return The internal value converted to microseconds.
        double      InMicroseconds()                                                         const {
           return double(sc duration_cast<sc nanoseconds>( span ).count())
                  / (1000. );
        }
 
        /// Converts the internal value to absolute microseconds.
        /// @return The internal value converted to microseconds.
        int64_t     InAbsoluteMicroseconds()                                                   const
        { return sc duration_cast<sc microseconds>( span ).count(); }
 
        /// Converts the internal value to nanoseconds.
        /// @return The internal value converted to nanoseconds.
        int64_t     InNanoseconds()                                                            const
        { return sc duration_cast<sc nanoseconds>( span ).count(); }
 
        /// Returns 1 divided by internal value in seconds, hence the number of Hertz that this
        /// object represents when interpreted as a time span.
        ///
        /// @param qtyFractionalDigits Number of digits that the return value will be rounded to.
        ///                            Defaults to -1 which means no rounding.
        /// @return     double value representing the frequency in hertz.
        double      InHertz( int qtyFractionalDigits= -1 )                                   const {
            // check
            if ( span.count() == 0)
                return 0.0;
 
            // calc hertz
            double hz= 1000000000.0 / double(InNanoseconds());
 
            // no rounding? that's it
            if ( qtyFractionalDigits < 0 )
                return hz;
 
            // round
            double mag= pow( 10, qtyFractionalDigits );
            return int( hz * mag + ( hz < 0 ? -0.5 : 0.5 ) ) / mag;
        }
 
 
        /// Sets the internal value to a time span provided in days.
        /// @param days  The time span to set in days.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromDays( double days )
        { return sc duration_cast<TDuration>(sc hours(24) * days); }
 
        /// Sets the internal value to a time span provided in days.
        /// @param days  The time span to set in days.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromAbsoluteDays( int64_t days )
        { return sc duration_cast<TDuration>(sc hours(24) * days); }
 
        /// Sets the internal value to a time span provided in hours.
        /// @param hours  The time span to set in hours.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromHours( double hours )
        { return sc duration_cast<TDuration>(sc hours(1) * hours); }
 
        /// Sets the internal value to a time span provided in hours.
        /// @param hours  The time span to set in hours.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromAbsoluteHours( int64_t hours )
        { return sc duration_cast<TDuration>( sc hours(1) * hours ); }
 
        /// Sets the internal value to a time span provided in hours.
        /// @param minutes  The time span to set in minutes.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration     FromMinutes(double minutes )
        { return sc duration_cast<TDuration>( sc minutes(1) * minutes ); }
 
        /// Sets the internal value to a time span provided in hours.
        /// @param minutes  The time span to set in minutes.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration     FromAbsoluteMinutes(int64_t minutes )
        { return sc duration_cast<TDuration>( sc minutes(1) * minutes ); }
 
        /// Sets the internal value to a time span provided in seconds.
        /// @param seconds  The time span to set in seconds.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromSeconds( double seconds )
        { return sc duration_cast<TDuration>(sc seconds(1) * seconds ); }
 
        /// Sets the internal value to a time span provided in seconds.
        /// @param seconds  The time span to set in seconds.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromAbsoluteSeconds( int64_t seconds )
        { return sc duration_cast<TDuration>(sc seconds(1) * seconds);  }
 
        /// Sets the internal value to a time span provided in milliseconds.
        /// @param milliseconds    The time span to set in milliseconds.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromMilliseconds( double  milliseconds )
        { return sc duration_cast<TDuration>(sc milliseconds(1) * milliseconds);  }
 
        /// Sets the internal value to a time span provided in milliseconds.
        /// @param milliseconds    The time span to set in milliseconds.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromAbsoluteMilliseconds( int64_t  milliseconds )
        { return sc duration_cast<TDuration>( sc milliseconds(1) * milliseconds ); }
 
        /// Sets the internal value to a time span provided in microseconds.
        /// @param microseconds  The time span to set in microseconds.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromMicroseconds( double  microseconds )
        { return sc duration_cast<TDuration>(sc microseconds(1) * microseconds   );  }
 
        /// Sets the internal value to a time span provided in microseconds.
        /// @param microseconds  The time span to set in microseconds.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration    FromAbsoluteMicroseconds( int64_t  microseconds )
        { return sc duration_cast<TDuration>( sc microseconds(1) * microseconds ); }
 
        /// Sets the internal value to a time span provided in nanoseconds.
        /// @param nanoseconds  The time span to set in nanoseconds.
        /// @return   \c *this to allow concatenated calls.
        static
        Duration  FromNanoseconds( int64_t  nanoseconds )
        { return sc duration_cast<TDuration>(sc nanoseconds( nanoseconds )); }
    }; // inner class Duration
 
  //################################################################################################
  // protected fields
  //################################################################################################
 
  protected:
    /// The internal timer value. This value can be accessed using methods #Export and
    /// #Import.
    TTimePoint                stamp;
 
  //################################################################################################
  // Constructors
  //################################################################################################
 
  public:
    /// Constructor. With parameter \p{init} being defaulted, this constructor acts as
    /// the default constructor, which creates an instance representing the point in time when
    /// this constructor was invoked.
    /// This measures the current point in time, which introduces some effort.
    ///
    /// To avoid this in situations where an instance is overwritten after construction
    /// (i.e., before it is read), parameter \p{init} can be passed to either \b Suppress
    /// or \b Nulled. Both values set this instance to a \e nulled state, as complete
    /// suppression is not available. Inn many situations the compiler will optimize out
    /// a nulled construction.
    ///
    /// If not initialized, the method #IsSet will return \c false.
    ///
    /// @param init If \c Initialization::Default, the current time is measured and set.
    ///             Defaults to \c Initialization::Default.
    constexpr
    TimePointBase(const lang::Initialization init= lang::Initialization::Default)
    {
         if(init == lang::Initialization::Default )
             stamp= TClock::now();
    }
 
    /// Returns an instance representing the actual point in time.
    /// @return The current point in time time.
    static
    TDerived    Now()                                            { return TDerived(TClock::now()); }
 
    /// Returns an instance representing the beginning of the epoch.
    /// No time point represented by this type can be further in the past.
    /// @return The earliest point in time.
    static
    TDerived    BeginningOfEpoch()                 { return TDerived((TClock::time_point::min)()); }
 
    /// Returns an instance representing the end of the epoch.
    /// No time point represented by this type can be further in the future.
    /// @return A maximum point in time.
    static
    TDerived    EndOfEpoch()                       { return TDerived((TClock::time_point::max)()); }
 
    /// Resets this instance to the current point in time.
    /// @return A reference to \c this, (cast to the derived type) to allow concatenated
    ///         operations.
    TDerived&   Reset()              { stamp= TClock::now(); return *static_cast<TDerived*>(this); }
 
    /// Constructor using native C++ library values.
    /// \see Methods #Import and #Export.
    ///
    /// @param internalValue The value to copy into this.
    constexpr
    TimePointBase( TTimePoint internalValue )
    : stamp(internalValue)                                                                        {}
 
  //################################################################################################
  // Interface
  //################################################################################################
  public:
 
    /// Returns \c true if this object is not representing the start of the epoch.
    /// An uninitialized object that returns \c false can be created with provision of
    /// \c Initialization::Suppress on construction.
    ///
    /// @return \c true if this object is initialized, \c false otherwise.
    bool        IsSet()                                            { return stamp != TTimePoint(); }
 
    /// Unsets this object, hence makes this object representing the start of the epoch, as if
    /// it was constructed with parameter value \c Initialization::Suppress.
    void        Unset()                                                     { stamp= TTimePoint(); }
 
    /// Copies the value from the given object.
    /// @param other The point in time to copy from.
    void        SetAs( const TDerived& other )                            { stamp=    other.stamp; }
 
    /// Returns the internal time value in the C++ standard library type.
    /// @return The internal value.
    TTimePoint  Export()                                                     const { return stamp; }
 
    /// Sets the internal time value given by a value of C++ standard library type.
    /// @param timePoint  The value to set.
    void        Import(TTimePoint timePoint)                                   { stamp= timePoint; }
 
 
    /// Returns the internal time value in the C++ standard library's tick unit.
    ///
    /// @return The internal value.
    TRaw        ToRaw()                           const { return stamp.time_since_epoch().count(); }
 
    /// Sets the value from a value of C++ standard library's tick unit type.
    /// @param raw The time span to create in raw units.
    void        SetFromRaw( TRaw raw )    { stamp= TTimePoint( typename TClock::duration( raw ) ); }
 
    /// Creates an instance from a value of C++ standard library's tick unit type.
    ///
    /// @param raw The time span to create in raw units.
    /// @return The internal value.
    static
    TDerived    FromRaw( TRaw raw )
    { return TDerived( TTimePoint( typename TClock::duration( raw ) ) );  }
 
    /// Addition operator.
    /// @param timeSpan The time span to add.
    /// @return A time stamp object containing the sum.
    TDerived operator+( const Duration& timeSpan )                                             const
    { return stamp + sc duration_cast<typename TClock::duration>( timeSpan.span );  }
 
    /// Addition operator.
    /// @param timeSpan The time span to add.
    /// @return A time stamp object containing the sum.
    TDerived operator+( const typename Duration::TDuration& timeSpan )                         const
    { return stamp + timeSpan; }
 
    /// Assignment by sum operator.
    /// @param timeSpan The time span to add.
    /// @return A reference to this object.
    TDerived  operator+=( const Duration& timeSpan )
    {
        stamp+= sc duration_cast<typename TClock::duration>( timeSpan.span );
        return stamp;
    }
 
    /// Assignment by sum operator.
    /// @param timeSpan The time span to add.
    /// @return A reference to this object.
    TDerived  operator+=( const typename Duration::TDuration& timeSpan )
    { stamp+= timeSpan;  return stamp;  }
 
    /// Subtraction operator.
    /// @param timeSpan The time span to subtract.
    /// @return A time stamp object containing the sum.
    TDerived operator-( const Duration& timeSpan )                                             const
    { return stamp - sc duration_cast<typename TClock::duration>( timeSpan.span );  }
 
    /// Subtraction operator.
    /// @param timeSpan The time span to subtract.
    /// @return A time stamp object containing the sum.
    TDerived operator-( const typename Duration::TDuration& timeSpan )                         const
    { return stamp - timeSpan; }
 
    /// Assignment by difference operator.
    /// @param timeSpan The time span to subtract.
    /// @return A reference to this object.
    TDerived  operator-=( const Duration& timeSpan )        { stamp-= timeSpan.span; return stamp; }
 
    /// Assignment by difference operator.
    /// @param timeSpan The time span to subtract.
    /// @return A reference to this object.
    TDerived  operator-=( const typename Duration::TDuration& timeSpan )
    { stamp-= timeSpan; return stamp;  }
 
    /// Subtraction operator with other time span argument. If the given time stamp represents
    /// a point in type earlier than the one this object represents, the result is positive.
    /// @param other The time stamp to subtract.
    /// @return A time span object containing the difference.
    Duration operator-( const TDerived& other )      const { return Duration(stamp - other.stamp); }
 
  //################################################################################################
  // Interface Age, Since
  //################################################################################################
 
    /// Returns the time span between the value represented by this instance and the current
    /// system time.
    /// If the internal value represents a historic point in time, the result is positive.
    ///
    /// @return The age of this instance stored in a new Duration.
    Duration    Age()                   const { return Duration( TDerived().stamp - this->stamp ); }
 
    /// Returns the time span between the value represented by this instance and the given
    /// other time stamp. If the given time stamp represents an earlier point in time, the result
    /// is positive.
    ///
    /// @param other The value to compare this instance with
    ///
    /// @return The age of this instance stored in the given or created object.
    Duration    Since( const TDerived& other )                     const { return (*this) - other; }
 
    /// Determines if this object's age is higher than a given time span.
    ///
    /// @param timeSpan  A time span to compare.
    /// @return \c true if the given time span is smaller equal than the age of this object,
    ///         hence to the time span passed since the point in time this object represents.
    ///         \c false otherwise.
    bool   IsOlderThan( const Duration& timeSpan )              const { return Age()  >  timeSpan; }
 
}; // class TimePointBase
 
} // namespace [alib::time]
 
#undef sc