MRPT  1.9.9
datetime.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "system-precomp.h" // Precompiled headers
11 
12 #include <mrpt/core/exceptions.h>
13 #include <mrpt/system/datetime.h>
14 #include <mrpt/system/os.h>
15 
16 #ifdef _WIN32
17 #include <windows.h>
18 
19 #include <conio.h>
20 #include <direct.h>
21 #include <io.h>
22 #include <process.h>
23 #include <sys/utime.h>
24 #include <tlhelp32.h>
25 #else
26 #include <pthread.h>
27 #include <sys/select.h>
28 #include <sys/time.h>
29 #include <termios.h>
30 #include <unistd.h>
31 #include <utime.h>
32 #include <cerrno>
33 #endif
34 
35 #include <sys/stat.h>
36 #include <sys/types.h>
37 #include <cmath> // floor()
38 #include <ctime>
39 #include <iostream> // for the << operator
40 
41 using namespace mrpt;
42 using namespace mrpt::system;
43 using namespace std;
44 
46 {
47  return time_tToTimestamp(static_cast<double>(t));
48 }
49 
51 {
52  const double T = mrpt::system::timestampTotime_t(t);
53  double sec_frac = T - floor(T);
54  ASSERT_(sec_frac < 1.0);
55 
56  const auto tt = time_t(T);
57 
58  struct tm* parts = localTime ? localtime(&tt) : gmtime(&tt);
59  ASSERTMSG_(parts, "Malformed timestamp");
60 
61  p.year = parts->tm_year + 1900;
62  p.month = parts->tm_mon + 1;
63  p.day = parts->tm_mday;
64  p.day_of_week = parts->tm_wday + 1;
65  p.daylight_saving = parts->tm_isdst;
66  p.hour = parts->tm_hour;
67  p.minute = parts->tm_min;
68  p.second = parts->tm_sec + sec_frac;
69 }
70 
71 /*---------------------------------------------------------------
72  buildTimestampFromParts
73  ---------------------------------------------------------------*/
75 {
76  struct tm parts
77  {
78  };
79 
80  parts.tm_year = p.year - 1900;
81  parts.tm_mon = p.month - 1;
82  parts.tm_mday = p.day;
83  parts.tm_wday = p.day_of_week - 1;
84  parts.tm_isdst = p.daylight_saving;
85  parts.tm_hour = p.hour;
86  parts.tm_min = p.minute;
87  parts.tm_sec = int(p.second);
88 
89  double sec_frac = p.second - parts.tm_sec;
90 
91  time_t tt = mrpt::system::os::timegm(&parts); // Local time: mktime
92 
93  return mrpt::system::time_tToTimestamp(double(tt) + sec_frac);
94 }
95 
96 /*---------------------------------------------------------------
97  buildTimestampFromPartsLocalTime
98  ---------------------------------------------------------------*/
100 {
101  struct tm parts
102  {
103  };
104 
105  parts.tm_year = p.year - 1900;
106  parts.tm_mon = p.month - 1;
107  parts.tm_mday = p.day;
108  parts.tm_wday = p.day_of_week - 1;
109  parts.tm_isdst = p.daylight_saving;
110  parts.tm_hour = p.hour;
111  parts.tm_min = p.minute;
112  parts.tm_sec = int(p.second);
113 
114  double sec_frac = p.second - parts.tm_sec;
115 
116  time_t tt = mktime(&parts);
117 
118  return mrpt::system::time_tToTimestamp(double(tt) + sec_frac);
119 }
120 
121 /*---------------------------------------------------------------
122  formatTimeInterval
123  ---------------------------------------------------------------*/
125 {
126  double timeSeconds = (t < 0) ? (-t) : t;
127  std::string s;
128 
129  const auto nDays = static_cast<unsigned int>(timeSeconds / (3600 * 24));
130  timeSeconds -= nDays * 3600 * 24;
131  const auto nHours = static_cast<unsigned int>(timeSeconds / 3600);
132  timeSeconds -= nHours * 3600;
133  const auto nMins = static_cast<unsigned int>(timeSeconds / 60);
134  const auto nSecs = static_cast<unsigned int>(timeSeconds) % 60;
135  const auto milSecs =
136  static_cast<unsigned int>(1000 * timeSeconds - floor(timeSeconds));
137 
138  if (nDays > 0) s += mrpt::format("%udays ", nDays);
139  if (nHours > 0) s += mrpt::format("%uh ", nHours);
140  if (nMins > 0) s += mrpt::format("%02umin ", nMins);
141  s += mrpt::format("%02u.%03us", nSecs, milSecs);
142  return s;
143 }
144 
145 /*---------------------------------------------------------------
146  Convert a timestamp into this textual form: YEAR/MONTH/DAY,HH:MM:SS.MMM
147  ---------------------------------------------------------------*/
149 {
150  if (t == INVALID_TIMESTAMP) return string("INVALID_TIMESTAMP");
151 
152  uint64_t tmp =
153  (t.time_since_epoch().count() - ((uint64_t)116444736 * 1000000000));
154  time_t auxTime = tmp / (uint64_t)10000000;
155  auto secFractions = (unsigned int)(1000000 * (tmp % 10000000) / 10000000.0);
156  tm* ptm = gmtime(&auxTime);
157 
158  if (!ptm) return std::string("(Malformed timestamp)");
159 
160  return format(
161  "%u/%02u/%02u,%02u:%02u:%02u.%06u", 1900 + ptm->tm_year,
162  ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min,
163  (unsigned int)ptm->tm_sec, secFractions);
164 }
165 
166 /*---------------------------------------------------------------
167  Convert a timestamp into this textual form (in local time):
168  YEAR/MONTH/DAY,HH:MM:SS.MMM
169  ---------------------------------------------------------------*/
171 {
172  if (t == INVALID_TIMESTAMP) return string("INVALID_TIMESTAMP");
173 
174  uint64_t tmp =
175  (t.time_since_epoch().count() - ((uint64_t)116444736 * 1000000000));
176  time_t auxTime = tmp / (uint64_t)10000000;
177  auto secFractions = (unsigned int)(1000000 * (tmp % 10000000) / 10000000.0);
178  tm* ptm = localtime(&auxTime);
179 
180  if (!ptm) return "(Malformed timestamp)";
181 
182  return format(
183  "%u/%02u/%02u,%02u:%02u:%02u.%06u", 1900 + ptm->tm_year,
184  ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min,
185  (unsigned int)ptm->tm_sec, secFractions);
186 }
187 
188 /*---------------------------------------------------------------
189  extractDayTimeFromTimestamp
190  ---------------------------------------------------------------*/
192  const mrpt::system::TTimeStamp tt)
193 {
194  MRPT_START
195  ASSERT_(tt != INVALID_TIMESTAMP);
196 
197  auto t = tt.time_since_epoch().count();
198 #ifdef _WIN32
199  SYSTEMTIME sysT;
200  FileTimeToSystemTime((FILETIME*)&t, &sysT);
201  return sysT.wHour * 3600.0 + sysT.wMinute * 60.0 + sysT.wSecond +
202  sysT.wMilliseconds * 0.001;
203 #else
204  time_t auxTime =
205  (t - ((uint64_t)116444736 * 1000000000)) / (uint64_t)10000000;
206  tm* ptm = gmtime(&auxTime);
207  ASSERTMSG_(ptm, "Malformed timestamp");
208  return ptm->tm_hour * 3600.0 + ptm->tm_min * 60.0 + ptm->tm_sec;
209 #endif
210  MRPT_END
211 }
212 
213 /*---------------------------------------------------------------
214  Convert a timestamp into this textual form: HH:MM:SS.MMM
215  ---------------------------------------------------------------*/
217  const mrpt::system::TTimeStamp tt, unsigned int secondFractionDigits)
218 {
219  if (tt == INVALID_TIMESTAMP) return string("INVALID_TIMESTAMP");
220  auto t = tt.time_since_epoch().count();
221 
222  uint64_t tmp = (t - ((uint64_t)116444736 * 1000000000));
223  const time_t auxTime = tmp / (uint64_t)10000000;
224  const tm* ptm = localtime(&auxTime);
225 
226  auto secFractions = (unsigned int)(1000000 * (tmp % 10000000) / 10000000.0);
227  // We start with 10^{-6} second units: reduce if requested by user:
228  const unsigned int user_secondFractionDigits = secondFractionDigits;
229  while (secondFractionDigits++ < 6) secFractions = secFractions / 10;
230 
231  return format(
232  "%02u:%02u:%02u.%0*u", ptm->tm_hour, ptm->tm_min,
233  (unsigned int)ptm->tm_sec, user_secondFractionDigits, secFractions);
234 }
235 
236 /*---------------------------------------------------------------
237  Convert a timestamp into this textual form: HH:MM:SS.MMM
238  ---------------------------------------------------------------*/
240 {
241  if (tt == INVALID_TIMESTAMP) return string("INVALID_TIMESTAMP");
242  auto t = tt.time_since_epoch().count();
243 
244  uint64_t tmp = (t - ((uint64_t)116444736 * 1000000000));
245  time_t auxTime = tmp / (uint64_t)10000000;
246  auto secFractions = (unsigned int)(1000000 * (tmp % 10000000) / 10000000.0);
247  tm* ptm = gmtime(&auxTime);
248  if (!ptm) return string("(Malformed timestamp)");
249 
250  return format(
251  "%02u:%02u:%02u.%06u", ptm->tm_hour, ptm->tm_min,
252  (unsigned int)ptm->tm_sec, secFractions);
253 }
254 
255 /*---------------------------------------------------------------
256  Convert a timestamp into this textual form: YEAR/MONTH/DAY
257  ---------------------------------------------------------------*/
259 {
260  if (tt == INVALID_TIMESTAMP) return string("INVALID_TIMESTAMP");
261  auto t = tt.time_since_epoch().count();
262 
263  uint64_t tmp = (t - ((uint64_t)116444736 * 1000000000));
264  time_t auxTime = tmp / (uint64_t)10000000;
265  tm* ptm = gmtime(&auxTime);
266  if (!ptm) return string("(Malformed timestamp)");
267 
268  return format(
269  "%u/%02u/%02u", 1900 + ptm->tm_year, ptm->tm_mon + 1, ptm->tm_mday);
270 }
271 
272 /** This function implements time interval formatting: Given a time in seconds,
273  * it will return a string describing the interval with the most appropriate
274  * unit.
275  * E.g.: 1.23 year, 3.50 days, 9.3 hours, 5.3 minutes, 3.34 sec, 178.1 ms, 87.1
276  * us.
277  */
279 {
280  if (seconds >= 365 * 24 * 3600)
281  return format("%.2f years", seconds / (365 * 24 * 3600));
282  else if (seconds >= 24 * 3600)
283  return format("%.2f days", seconds / (24 * 3600));
284  else if (seconds >= 3600)
285  return format("%.2f hours", seconds / 3600);
286  else if (seconds >= 60)
287  return format("%.2f minutes", seconds / 60);
288  else if (seconds >= 1)
289  return format("%.2f sec", seconds);
290  else if (seconds >= 1e-3)
291  return format("%.2f ms", seconds * 1e3);
292  else if (seconds >= 1e-6)
293  return format("%.2f us", seconds * 1e6);
294  else
295  return format("%.2f ns", seconds * 1e9);
296 }
297 
298 std::ostream& mrpt::system::operator<<(std::ostream& o, const TTimeStamp& t)
299 {
300  const uint64_t v = t.time_since_epoch().count();
301  o << v;
302  return o;
303 }
void timestampToParts(TTimeStamp t, TTimeParts &p, bool localTime=false)
Gets the individual parts of a date/time (days, hours, minutes, seconds) - UTC time or local time...
Definition: datetime.cpp:50
std::ostream & operator<<(std::ostream &o, const TTimeStamp &t)
Textual representation of a TTimeStamp as the plain number in time_since_epoch().count() ...
Definition: datetime.cpp:298
#define MRPT_START
Definition: exceptions.h:241
GLdouble GLdouble t
Definition: glext.h:3695
time_t timegm(struct tm *tm)
An OS-independent version of timegm (which is not present in all compilers): converts a time structur...
Definition: os.cpp:112
mrpt::system::TTimeStamp buildTimestampFromParts(const mrpt::system::TTimeParts &p)
Builds a timestamp from the parts (Parts are in UTC)
Definition: datetime.cpp:74
double extractDayTimeFromTimestamp(const mrpt::system::TTimeStamp t)
Returns the number of seconds ellapsed from midnight in the given timestamp.
Definition: datetime.cpp:191
std::string timeToString(const mrpt::system::TTimeStamp t)
Convert a timestamp into this textual form (UTC): HH:MM:SS.MMMMMM.
Definition: datetime.cpp:239
STL namespace.
std::string formatTimeInterval(const double timeSeconds)
Returns a formated string with the given time difference (passed as the number of seconds)...
Definition: datetime.cpp:124
GLdouble s
Definition: glext.h:3682
#define ASSERT_(f)
Defines an assertion mechanism.
Definition: exceptions.h:120
mrpt::Clock::time_point TTimeStamp
A system independent time type, it holds the the number of 100-nanosecond intervals since January 1...
Definition: datetime.h:40
std::string dateToString(const mrpt::system::TTimeStamp t)
Convert a timestamp into this textual form: YEAR/MONTH/DAY.
Definition: datetime.cpp:258
The parts of a date/time (it&#39;s like the standard &#39;tm&#39; but with fractions of seconds).
Definition: datetime.h:49
double timestampTotime_t(const mrpt::system::TTimeStamp t) noexcept
Transform from TTimeStamp to standard "time_t" (actually a double number, it can contain fractions of...
Definition: datetime.h:105
std::string intervalFormat(const double seconds)
This function implements time interval formatting: Given a time in seconds, it will return a string d...
Definition: datetime.cpp:278
#define ASSERTMSG_(f, __ERROR_MSG)
Defines an assertion mechanism.
Definition: exceptions.h:108
GLsizei const GLchar ** string
Definition: glext.h:4116
mrpt::system::TTimeStamp buildTimestampFromPartsLocalTime(const mrpt::system::TTimeParts &p)
Builds a timestamp from the parts (Parts are in local time)
Definition: datetime.cpp:99
unsigned __int64 uint64_t
Definition: rptypes.h:53
const GLdouble * v
Definition: glext.h:3684
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
std::string dateTimeToString(const mrpt::system::TTimeStamp t)
Convert a timestamp into this textual form (UTC time): YEAR/MONTH/DAY,HH:MM:SS.MMM.
Definition: datetime.cpp:148
std::string format(const char *fmt,...) MRPT_printf_format_check(1
A std::string version of C sprintf.
Definition: format.cpp:16
#define MRPT_END
Definition: exceptions.h:245
std::string timeLocalToString(const mrpt::system::TTimeStamp t, unsigned int secondFractionDigits=6)
Convert a timestamp into this textual form (in local time): HH:MM:SS.MMMMMM.
Definition: datetime.cpp:216
std::string dateTimeLocalToString(const mrpt::system::TTimeStamp t)
Convert a timestamp into this textual form (in local time): YEAR/MONTH/DAY,HH:MM:SS.MMM.
Definition: datetime.cpp:170
mrpt::system::TTimeStamp time_tToTimestamp(const double t)
Transform from standard "time_t" (actually a double number, it can contain fractions of seconds) to T...
Definition: datetime.h:91
GLfloat GLfloat p
Definition: glext.h:6398
#define INVALID_TIMESTAMP
Represents an invalid timestamp, where applicable.
Definition: datetime.h:43



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: 8a2d96f36 Mon Jul 15 00:01:58 2019 +0200 at lun jul 15 00:10:13 CEST 2019