libfilezilla
time.hpp
Go to the documentation of this file.
1#ifndef LIBFILEZILLA_TIME_HEADER
2#define LIBFILEZILLA_TIME_HEADER
3
4#include "libfilezilla.hpp"
5
6#include <chrono>
7#include <ctime>
8
9#include <limits>
10
11#ifdef FZ_WINDOWS
12#include "glue/windows.hpp"
13#endif
14
19namespace fz {
20
21class FZ_PUBLIC_SYMBOL duration;
22
40class FZ_PUBLIC_SYMBOL datetime final
41{
42public:
46 enum accuracy : char {
47 days,
48 hours,
49 minutes,
50 seconds,
51 milliseconds
52 };
53
58 enum zone {
59 utc,
60 local
61 };
62
64 datetime() = default;
65
66 datetime(zone z, int year, int month, int day, int hour = -1, int minute = -1, int second = -1, int millisecond = -1);
67
68 explicit datetime(time_t, accuracy a);
69
74 explicit datetime(std::string_view const& s, zone z);
75 explicit datetime(std::wstring_view const& s, zone z);
76
77#ifdef FZ_WINDOWS
79 explicit datetime(FILETIME const& ft, accuracy a);
80#endif
81
82 datetime(datetime const& op) = default;
83 datetime(datetime && op) noexcept = default;
84 datetime& operator=(datetime const& op) = default;
85 datetime& operator=(datetime && op) noexcept = default;
86
88 bool empty() const;
89
90 explicit operator bool() const {
91 return !empty();
92 }
93
95 void clear();
96
97 accuracy get_accuracy() const { return a_; }
98
100 static datetime now();
101
108 bool operator==(datetime const& op) const;
109 bool operator!=(datetime const& op) const { return !(*this == op); }
110 bool operator<(datetime const& op) const;
111 bool operator<=(datetime const& op) const;
112 bool operator>(datetime const& op) const { return op < *this; }
114
124 int compare(datetime const& op) const;
125
127 bool earlier_than(datetime const& op) const { return compare(op) < 0; };
128
130 bool later_than(datetime const& op) const { return compare(op) > 0; };
131
137 datetime& operator+=(duration const& op);
138 datetime operator+(duration const& op) const { datetime t(*this); t += op; return t; }
139
140 datetime& operator-=(duration const& op);
141 datetime operator-(duration const& op) const { datetime t(*this); t -= op; return t; }
143
144 friend duration FZ_PUBLIC_SYMBOL operator-(datetime const& a, datetime const& b);
145
153 bool set(zone z, int year, int month, int day, int hour = -1, int minute = -1, int second = -1, int millisecond = -1);
154
164 bool set(std::string_view const& str, zone z);
165 bool set(std::wstring_view const& str, zone z);
166
167#ifdef FZ_WINDOWS
169 bool set(FILETIME const& ft, accuracy a);
171 bool set(SYSTEMTIME const& ft, accuracy a, zone z);
172#endif
173
174#if defined(FZ_UNIX) || defined(FZ_MAC)
180 bool set(tm & t, accuracy a, zone z);
181#endif
182
189 bool imbue_time(int hour, int minute, int second = -1, int millisecond = -1);
190
197 std::string format(std::string const& format, zone z) const;
198 std::wstring format(std::wstring const& format, zone z) const;
199
205 static bool verify_format(std::string const& fmt);
206 static bool verify_format(std::wstring const& fmt);
207
209 int get_milliseconds() const { return t_ % 1000; }
210
212 time_t get_time_t() const;
213
218 tm get_tm(zone z) const;
219
220#ifdef FZ_WINDOWS
222 FILETIME get_filetime() const;
223#endif
224
231 std::string get_rfc822() const;
232
248 bool set_rfc822(std::string_view const& str);
249 bool set_rfc822(std::wstring_view const& str);
250
262 bool set_rfc3339(std::string_view const& str);
263 bool set_rfc3339(std::wstring_view const& str);
264
265private:
266 int FZ_PRIVATE_SYMBOL compare_slow(datetime const& op) const;
267
268 bool FZ_PRIVATE_SYMBOL clamped();
269
270 enum invalid_t : int64_t {
271 invalid = std::numeric_limits<int64_t>::min()
272 };
273
274 int64_t t_{invalid};
275 accuracy a_{days};
276};
277
285class FZ_PUBLIC_SYMBOL duration final
286{
287public:
288 duration() = default;
289
294 int64_t get_days() const { return ms_ / 1000 / 3600 / 24; }
295 int64_t get_hours() const { return ms_ / 1000 / 3600; }
296 int64_t get_minutes() const { return ms_ / 1000 / 60; }
297 int64_t get_seconds() const { return ms_ / 1000; }
298 int64_t get_milliseconds() const { return ms_; }
300
301 static duration from_days(int64_t m) {
302 return duration(m * 1000 * 60 * 60 * 24);
303 }
304 static duration from_hours(int64_t m) {
305 return duration(m * 1000 * 60 * 60);
306 }
307 static duration from_minutes(int64_t m) {
308 return duration(m * 1000 * 60);
309 }
310 static duration from_seconds(int64_t m) {
311 return duration(m * 1000);
312 }
313 static duration from_milliseconds(int64_t m) {
314 return duration(m);
315 }
317
318 duration& operator+=(duration const& op) {
319 ms_ += op.ms_;
320 return *this;
321 }
322
323 duration& operator-=(duration const& op) {
324 ms_ -= op.ms_;
325 return *this;
326 }
327
328 duration operator-() const {
329 return duration(-ms_);
330 }
331
332 explicit operator bool() const {
333 return ms_ != 0;
334 }
335
336 duration& operator*=(int64_t op) {
337 ms_ *= op;
338 return *this;
339 }
340
341 bool operator<(duration const& op) const { return ms_ < op.ms_; }
342 bool operator<=(duration const& op) const { return ms_ <= op.ms_; }
343 bool operator>(duration const& op) const { return ms_ > op.ms_; }
344 bool operator>=(duration const& op) const { return ms_ >= op.ms_; }
345
346 friend duration FZ_PUBLIC_SYMBOL operator-(duration const& a, duration const& b);
347 friend duration FZ_PUBLIC_SYMBOL operator+(duration const& a, duration const& b);
348private:
349 explicit FZ_PRIVATE_SYMBOL duration(int64_t ms) : ms_(ms) {}
350
351 int64_t ms_{};
352};
353
354inline duration operator-(duration const& a, duration const& b)
355{
356 return duration(a) -= b;
357}
358
359inline duration operator+(duration const& a, duration const& b)
360{
361 return duration(a) += b;
362}
363
370duration FZ_PUBLIC_SYMBOL operator-(datetime const& a, datetime const& b);
371
372
373
374
382class FZ_PUBLIC_SYMBOL monotonic_clock final
383{
384public:
389 monotonic_clock() = default;
390
391 monotonic_clock(monotonic_clock const&) = default;
392 monotonic_clock(monotonic_clock &&) noexcept = default;
393 monotonic_clock& operator=(monotonic_clock const&) = default;
394 monotonic_clock& operator=(monotonic_clock &&) noexcept = default;
395
396 monotonic_clock const operator+(duration const& d) const
397 {
398 return monotonic_clock(*this) += d;
399 }
400
401private:
402 typedef std::chrono::steady_clock clock_type;
403 static_assert(std::chrono::steady_clock::is_steady, "Nonconforming stdlib, your steady_clock isn't steady");
404
405public:
408 return monotonic_clock(clock_type::now());
409 }
410
411 explicit operator bool() const {
412 return t_ != clock_type::time_point();
413 }
414
415 monotonic_clock& operator+=(duration const& d)
416 {
417 t_ += std::chrono::milliseconds(d.get_milliseconds());
418 return *this;
419 }
420
421 monotonic_clock& operator-=(duration const& d)
422 {
423 t_ -= std::chrono::milliseconds(d.get_milliseconds());
424 return *this;
425 }
426
427private:
428 explicit FZ_PRIVATE_SYMBOL monotonic_clock(clock_type::time_point const& t)
429 : t_(t)
430 {}
431
432 clock_type::time_point t_;
433
434 friend duration operator-(monotonic_clock const& a, monotonic_clock const& b);
435 friend bool operator==(monotonic_clock const& a, monotonic_clock const& b);
436 friend bool operator<(monotonic_clock const& a, monotonic_clock const& b);
437 friend bool operator<=(monotonic_clock const& a, monotonic_clock const& b);
438 friend bool operator>(monotonic_clock const& a, monotonic_clock const& b);
439 friend bool operator>=(monotonic_clock const& a, monotonic_clock const& b);
440};
441
446inline duration operator-(monotonic_clock const& a, monotonic_clock const& b)
447{
448 return duration::from_milliseconds(std::chrono::duration_cast<std::chrono::milliseconds>(a.t_ - b.t_).count());
449}
450
452inline bool operator==(monotonic_clock const& a, monotonic_clock const& b)
453{
454 return a.t_ == b.t_;
455}
456
458inline bool operator<(monotonic_clock const& a, monotonic_clock const& b)
459{
460 return a.t_ < b.t_;
461}
462
464inline bool operator<=(monotonic_clock const& a, monotonic_clock const& b)
465{
466 return a.t_ <= b.t_;
467}
468
470inline bool operator>(monotonic_clock const& a, monotonic_clock const& b)
471{
472 return a.t_ > b.t_;
473}
474
476inline bool operator>=(monotonic_clock const& a, monotonic_clock const& b)
477{
478 return a.t_ >= b.t_;
479}
480
481}
482
483#endif
Represents a point of time in wallclock, tracking the timestamps accuracy/precision.
Definition: time.hpp:41
FILETIME get_filetime() const
Windows-only: Get timestamp as FILETIME.
int get_milliseconds() const
Get millisecond part of timestamp.
Definition: time.hpp:209
bool later_than(datetime const &op) const
Equivalent to compare(op) > 0.
Definition: time.hpp:130
bool set(std::string_view const &str, zone z)
Set from string, looks for YYYYmmDD[[[[HH]MM]SS]sss].
accuracy
The datetime's accuracy.
Definition: time.hpp:46
tm get_tm(zone z) const
Get timestamp as struct tm.
bool empty() const
time_t get_time_t() const
Get timestamp as time_t, seconds since 1970-01-01 00:00:00.
bool set(tm &t, accuracy a, zone z)
bool imbue_time(int hour, int minute, int second=-1, int millisecond=-1)
Adds time to timestamps that only have a day-accuracy.
datetime()=default
A default-constructed timestamp is empty()
friend duration operator-(datetime const &a, datetime const &b)
Gets the difference between two timestamps as duration.
datetime(FILETIME const &ft, accuracy a)
Windows-only: Construct from FILETIME.
zone
When importing or exporting a timestamp, zone is used to explicitly specify whether the conversion is...
Definition: time.hpp:58
static datetime now()
Returns the current date/time.
bool set_rfc3339(std::string_view const &str)
bool set(FILETIME const &ft, accuracy a)
Windows-only: Set timestamp from FILETIME.
std::string format(std::string const &format, zone z) const
bool set(SYSTEMTIME const &ft, accuracy a, zone z)
Windows-only: Set timestamp from SYSTEMTIME.
bool set(zone z, int year, int month, int day, int hour=-1, int minute=-1, int second=-1, int millisecond=-1)
Sets the timestamp.
bool earlier_than(datetime const &op) const
Equivalent to compare(op) < 0.
Definition: time.hpp:127
void clear()
Resulting timestamp is empty()
int compare(datetime const &op) const
Accuracy-aware comparison against another timestamp.
std::string get_rfc822() const
static bool verify_format(std::string const &fmt)
bool set_rfc822(std::string_view const &str)
datetime(std::string_view const &s, zone z)
Construct from string, looks for YYYYmmDD[[[[HH]MM]SS]sss].
The duration class represents a time interval in milliseconds.
Definition: time.hpp:286
duration operator-(datetime const &a, datetime const &b)
Gets the difference between two timestamps as duration.
A monotonic clock (aka steady clock) is independent from walltime.
Definition: time.hpp:383
static monotonic_clock now()
Gets the current point in time time.
Definition: time.hpp:407
monotonic_clock()=default
Constructs empty clock.
Sets some global macros and further includes string.hpp.
The namespace used by libfilezilla.
Definition: apply.hpp:17
bool operator==(symmetric_key const &lhs, symmetric_key const &rhs)
Side-channel safe comparison.