TimeStamp.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_STAMP_H_INCLUDED
#define ICL_CORE_TIME_STAMP_H_INCLUDED

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

#if defined(_IC_BUILDER_BOOST_DATE_TIME_)
// Forward declaration
namespace boost {
namespace posix_time {
class ptime;
}
}
#endif

#ifdef _IC_BUILDER_OPENSPLICEDDS_
namespace DDS {
struct Time_t;
}
#endif

namespace icl_core {

#ifdef _IC_BUILDER_OPENSPLICEDDS_
struct iTimeStamp;
#endif


class ICL_CORE_IMPORT_EXPORT TimeStamp : protected TimeBase
{
public:
  TimeStamp()
    : TimeBase()
  { }

  //TimeStamp(timeval time) { secs = time.tv_sec; nsecs = time.tv_usec * 1000; }

  TimeStamp(uint64_t sec, uint32_t nsec)
    : TimeBase(sec, nsec)
  { }

  TimeStamp(const struct timespec& ts)
    : TimeBase(ts)
  { }

  explicit TimeStamp(time_t timestamp)
    : TimeBase(uint64_t(timestamp), 0)
  { }

#ifdef _IC_BUILDER_OPENSPLICEDDS_

  TimeStamp(const DDS::Time_t& time_stamp);

  TimeStamp(const iTimeStamp& time_stamp);

  TimeStamp& operator = (const DDS::Time_t& time_stamp);

  TimeStamp& operator = (const iTimeStamp& time_stamp);

  operator DDS::Time_t ();

  operator iTimeStamp ();
#endif

#if defined(_IC_BUILDER_BOOST_DATE_TIME_)

  TimeStamp(const boost::posix_time::ptime& ptime_stamp);

  TimeStamp& operator = (const boost::posix_time::ptime& ptime_stamp);
#endif

  static TimeStamp now();

  static TimeStamp futureMSec(uint64_t msec);

  static TimeStamp fromIso8601BasicUTC(const String& str);

  TimeStamp& fromNow();

  void strfTime(char* dest, size_t max_len, const char *format) const;
  void strfLocaltime(char* dest, size_t max_len, const char *format) const;
  String formatIso8601() const;
  String formatIso8601UTC() const;
  String formatIso8601Basic() const;
  String formatIso8601BasicUTC() const;

#ifdef _IC_BUILDER_DEPRECATED_STYLE_

  static ICL_CORE_VC_DEPRECATE_STYLE TimeStamp Now() ICL_CORE_GCC_DEPRECATE_STYLE;

  static ICL_CORE_VC_DEPRECATE_STYLE TimeStamp FutureMSec(uint64_t msec) ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE TimeStamp& FromNow() ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE void Strftime(char* dest, size_t max_len, const char *format) const
    ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE void StrfLocaltime(char* dest, size_t max_len, const char *format) const
    ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE String FormatIso8601() const
    ICL_CORE_GCC_DEPRECATE_STYLE;

#endif


  TimeStamp& operator += (const TimeSpan& span)
  {
    secs+=span.secs;
    nsecs+=span.nsecs;
    normalizeTime();
    return *this;
  }

  TimeStamp& operator -= (const TimeSpan& span)
  {
    secs-=span.secs;
    nsecs-=span.nsecs;
    normalizeTime();
    return *this;
  }

  bool operator != (const TimeStamp& other) const
  {
    return TimeBase::operator != (other);
  }

  bool operator == (const TimeStamp& other) const
  {
    return TimeBase::operator == (other);
  }

  bool operator < (const TimeStamp& other) const
  {
    return TimeBase::operator < (other);
  }

  bool operator > (const TimeStamp& other) const
  {
    return TimeBase::operator > (other);
  }

  bool operator <= (const TimeStamp& other) const
  {
    return TimeBase::operator <= (other);
  }

  bool operator >= (const TimeStamp& other) const
  {
    return TimeBase::operator >= (other);
  }

  uint64_t tsSec() const { return secs; }
  uint32_t tsUSec() const { return nsecs/1000; }
  uint32_t tsNSec() const { return nsecs; }

  static TimeStamp maxTime()
  {
    return TimeStamp(TimeBase::maxTime());
  }

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

  using TimeBase::timespec;
  using TimeBase::systemTimespec;

#ifdef _SYSTEM_DARWIN_
  using TimeBase::machTimespec;
#endif

#ifdef _IC_BUILDER_DEPRECATED_STYLE_

  ICL_CORE_VC_DEPRECATE_STYLE uint64_t TsSec() const ICL_CORE_GCC_DEPRECATE_STYLE;
  ICL_CORE_VC_DEPRECATE_STYLE uint32_t TsUSec() const ICL_CORE_GCC_DEPRECATE_STYLE;
  ICL_CORE_VC_DEPRECATE_STYLE uint32_t TsNSec() const ICL_CORE_GCC_DEPRECATE_STYLE;

  static ICL_CORE_VC_DEPRECATE_STYLE TimeStamp MaxTime() 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;
  using TimeBase::SystemTimespec;

#ifdef _SYSTEM_DARWIN_
  using TimeBase::MachTimespec;
#endif

#endif


  static const TimeStamp cZERO;

private:
  TimeStamp(const TimeBase &base)
    : TimeBase(base)
  { }

  TimeStamp& operator += (const TimeStamp& other);
};


inline TimeStamp operator + (const TimeSpan& span, const TimeStamp& time)
{
  TimeStamp a(time);
  return a += span;
}

inline TimeStamp operator + (const TimeStamp& time, const TimeSpan& span)
{
  TimeStamp a(time);
  return a += span;
}

inline TimeStamp operator - (const TimeStamp& time, const TimeSpan& span)
{
  TimeStamp a(time);
  return a -= span;
}

inline TimeSpan operator - (const TimeStamp& time_1, const TimeStamp& time_2)
{
  TimeSpan a(time_1.tsSec()-time_2.tsSec(), time_1.tsNSec()-time_2.tsNSec());
  return a;
}

}
#endif