TimeSpan.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------
// This file is part of FZIs ic_workspace.
//
// This program is free software licensed under the LGPL
// (GNU LESSER GENERAL PUBLIC LICENSE Version 3).
// You can find a copy of this license in LICENSE folder in the top
// directory of the source code.
//
// © Copyright 2016 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef ICL_CORE_TIME_SPAN_H_INCLUDED
#define ICL_CORE_TIME_SPAN_H_INCLUDED

#include <iostream>

#include "icl_core/ImportExport.h"
#include "icl_core/TimeBase.h"

#ifdef _IC_BUILDER_DEPRECATED_STYLE_
# include "icl_core/Deprecate.h"
#endif

namespace icl_core {

#ifdef _IC_BUILDER_OPENSPLICEDDS_
struct iTimeSpan;
#endif


class ICL_CORE_IMPORT_EXPORT TimeSpan : protected TimeBase
{
  friend class TimeStamp;
public:

  explicit TimeSpan(int64_t sec=0, int32_t nsec=0);

  TimeSpan(const struct timespec& time_span);

#ifdef _IC_BUILDER_OPENSPLICEDDS_
  TimeSpan(const iTimeSpan& time_span);
  TimeSpan& operator = (const iTimeSpan& time_span);
  operator iTimeSpan ();
#endif

  TimeSpan& fromSec(int64_t sec);
  TimeSpan& fromMSec(int64_t msec);
  TimeSpan& fromUSec(int64_t usec);

  static TimeSpan createFromSec(int64_t sec);
  static TimeSpan createFromMSec(int64_t msec);
  static TimeSpan createFromUSec(int64_t usec);

  TimeSpan& operator += (const TimeSpan& span);

  TimeSpan& operator -= (const TimeSpan& span);

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

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

  bool operator < (const TimeSpan& other) const;

  bool operator > (const TimeSpan& other) const;

  bool operator <= (const TimeSpan& other) const;

  bool operator >= (const TimeSpan& other) const;

  int64_t tsSec() const;
  int32_t tsNSec() const;
  int32_t tsUSec() const;

  int64_t toMSec() const;

  int64_t toUSec() const;

  int64_t toNSec() const;

  using TimeBase::days;
  using TimeBase::hours;
  using TimeBase::minutes;
  using TimeBase::seconds;
  using TimeBase::milliSeconds;
  using TimeBase::microSeconds;
  using TimeBase::nanoSeconds;

  using TimeBase::timespec;

  /* Remark: TimeBase has a systemTimespec() function, which is also
   * available in TimeStamp.  However, TimeSpan does not need this
   * function because it represents a relative time.  Therefore the
   * systemTimespec() function, which performs a transformation
   * between two "absolute zero points" (system and global time), does
   * not make any sense with the relative TimeSpan!
   */

#ifdef _SYSTEM_DARWIN_
  using TimeBase::machTimespec;
#endif

  static const TimeSpan cZERO;

#ifdef _IC_BUILDER_DEPRECATED_STYLE_

  ICL_CORE_VC_DEPRECATE_STYLE TimeSpan& FromSec(int64_t sec) ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE TimeSpan& FromMSec(int64_t msec) ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE TimeSpan& FromUSec(int64_t usec) ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE int64_t TsSec() const ICL_CORE_GCC_DEPRECATE_STYLE;
  ICL_CORE_VC_DEPRECATE_STYLE int32_t TsNSec() const ICL_CORE_GCC_DEPRECATE_STYLE;
  ICL_CORE_VC_DEPRECATE_STYLE int32_t TsUSec() const ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE int64_t ToMSec() const ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE int64_t ToUSec() const ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE int64_t ToNSec() const ICL_CORE_GCC_DEPRECATE_STYLE;

  using TimeBase::Days;
  using TimeBase::Hours;
  using TimeBase::Minutes;
  using TimeBase::Seconds;
  using TimeBase::MilliSeconds;
  using TimeBase::MicroSeconds;
  using TimeBase::NanoSeconds;

  using TimeBase::Timespec;

#ifdef _SYSTEM_DARWIN_
  using TimeBase::MachTimespec;
#endif

#endif
};

inline TimeSpan operator + (const TimeSpan& left, const TimeSpan& right)
{
  TimeSpan a(left.tsSec() + right.tsSec(), left.tsNSec() + right.tsNSec());
  return a;
}

inline TimeSpan operator - (const TimeSpan& left, const TimeSpan& right)
{
  TimeSpan a(left.tsSec() - right.tsSec(), left.tsNSec() - right.tsNSec());
  return a;
}

inline TimeSpan operator / (const TimeSpan& span, double divisor)
{
  TimeSpan a(int64_t(span.tsSec() / divisor), int32_t(span.tsNSec() / divisor));
  return a;
}

inline TimeSpan operator * (const TimeSpan& span, double divisor)
{
  TimeSpan a(int64_t(span.tsSec() * divisor), int32_t(span.tsNSec() * divisor));
  return a;
}

inline TimeSpan abs(const TimeSpan& span)
{
  if (span < TimeSpan::cZERO)
  {
    return TimeSpan::cZERO - span;
  }
  else
  {
    return span;
  }
}

ICL_CORE_IMPORT_EXPORT std::ostream& operator << (std::ostream& stream, const TimeSpan& time_span);

#ifdef _IC_BUILDER_DEPRECATED_STYLE_

inline TimeSpan Abs(const TimeSpan& span) ICL_CORE_GCC_DEPRECATE_STYLE;
ICL_CORE_VC_DEPRECATE_STYLE inline TimeSpan Abs(const TimeSpan& span)
{
  return abs(span);
}

#endif

}

#endif