Time.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012-2015 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/

#ifndef _GAZEBO_COMMON_TIME_HH_
#define _GAZEBO_COMMON_TIME_HH_

#include <string>
#include <stdlib.h>
#include <time.h>
#include <iostream>

#include "gazebo/common/CommonTypes.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace common
  {

    class GZ_COMMON_VISIBLE Time
    {
      public: static const Time Zero;

      public: static const Time Second;

      public: static const Time Hour;

      public: enum FormatOption
      {
        DAYS = 0,
        HOURS = 1,
        MINUTES = 2,
        SECONDS = 3,
        MILLISECONDS = 4
      };

      public: Time();

      public: Time(const Time &_time);

      public: Time(const struct timeval &_tv);

      public: Time(const struct timespec &_tv);

      public: Time(int32_t _sec, int32_t _nsec);

      public: Time(double _time);

      public: virtual ~Time();

      public: static const Time &GetWallTime();

      public: static const std::string &GetWallTimeAsISOString();

      public: void SetToWallTime();

      public: void Set(int32_t _sec, int32_t _nsec);

      public: void Set(double _seconds);

      public: double Double() const;

      public: float Float() const;

      public: std::string FormattedString(FormatOption _start = DAYS,
          FormatOption _end = MILLISECONDS) const;

      public: static Time Sleep(const common::Time &_time);

      public: static Time MSleep(unsigned int _ms);

      public: static Time NSleep(unsigned int _ns);

      public: Time &operator =(const struct timeval &_tv);

      public: Time &operator =(const struct timespec &_tv);

      public: Time &operator =(const Time &_time);

      public: Time operator +(const struct timeval &_tv) const;

      public: Time operator +(const struct timespec &_tv) const;

      public: const Time &operator +=(const struct timeval &_tv);

      public: const Time &operator +=(const struct timespec &_tv);

      public: Time operator +(const Time &_time) const;

      public: const Time &operator +=(const Time &_time);

      public: Time operator -(const struct timeval &_tv) const;

      public: const Time &operator -=(const struct timeval &_tv);

      public: Time operator -(const struct timespec &_tv) const;

      public: const Time &operator -=(const struct timespec &_tv);

      public: Time operator -(const Time &_time) const;

      public: const Time &operator -=(const Time &_time);

      public: Time operator *(const struct timeval &_tv) const;

      public: const Time &operator *=(const struct timeval &_tv);

      public: Time operator *(const struct timespec &_tv) const;

      public: const Time &operator *=(const struct timespec &_tv);

      public: Time operator *(const Time &_time) const;

      public: const Time &operator *=(const Time &_time);

      public: Time operator /(const struct timeval &_tv) const;

      public: const Time &operator /=(const struct timeval &_tv);

      public: Time operator /(const struct timespec &_tv) const;

      public: const Time &operator /=(const struct timespec &_tv);

      public: Time operator /(const Time &_time) const;

      public: const Time &operator /=(const Time &time);

      public: bool operator ==(const struct timeval &_tv) const;

      public: bool operator ==(const struct timespec &_tv) const;

      public: bool operator ==(const Time &_time) const;

      public: bool operator ==(double _time) const;

      public: bool operator!=(const struct timeval &_tv) const;

      public: bool operator!=(const struct timespec &_tv) const;

      public: bool operator!=(const Time &_time) const;

      public: bool operator!=(double _time) const;

      public: bool operator<(const struct timeval &_tv) const;

      public: bool operator<(const struct timespec &_tv) const;

      public: bool operator<(const Time &_time) const;

      public: bool operator<(double _time) const;

      public: bool operator<=(const struct timeval &_tv) const;

      public: bool operator<=(const struct timespec &_tv) const;

      public: bool operator<=(const Time &_time) const;

      public: bool operator<=(double _time) const;

      public: bool operator>(const struct timeval &_tv) const;

      public: bool operator>(const struct timespec &_tv) const;

      public: bool operator>(const Time &_time) const;

      public: bool operator>(double _time) const;

      public: bool operator>=(const struct timeval &_tv) const;

      public: bool operator>=(const struct timespec &_tv) const;

      public: bool operator>=(const Time &_time) const;

      public: bool operator>=(double _time) const;

      public: static inline double SecToNano(double _sec)
              { return _sec * 1e9;}

      public: static inline double MilToNano(double _ms)
              { return _ms * 1e6;}

      public: static inline double MicToNano(double _ms)
              { return _ms * 1e3;}

      public: friend std::ostream &operator<<(std::ostream &_out,
                                              const gazebo::common::Time &_time)
              {
                _out << _time.sec << " " << _time.nsec;
                return _out;
              }

      public: friend std::istream &operator>>(std::istream &_in,
                                              gazebo::common::Time &_time)
              {
                // Skip white spaces
                _in.setf(std::ios_base::skipws);
                _in >> _time.sec >> _time.nsec;
                return _in;
              }

      public: int32_t sec;

      public: int32_t nsec;

      private: static Time wallTime;

      private: static std::string wallTimeISO;

      private: inline void Correct()
               {
                 // In the case sec and nsec have different signs, normalize
                 if (this->sec > 0 && this->nsec < 0)
                 {
                   int32_t n = abs(this->nsec / this->nsInSec) + 1;
                   this->sec -= n;
                   this->nsec += n * this->nsInSec;
                 }
                 if (this->sec < 0 && this->nsec > 0)
                 {
                   int32_t n = abs(this->nsec / this->nsInSec) + 1;
                   this->sec += n;
                   this->nsec -= n * this->nsInSec;
                 }

                 // Make any corrections
                 this->sec += this->nsec / this->nsInSec;
                 this->nsec = this->nsec % this->nsInSec;
               }

      private: static struct timespec clockResolution;

      private: static const int32_t nsInSec;

      private: static const int32_t nsInMs;
    };
  }
}
#endif