robust-services-core/src/subs/chrono at master · GregUtas/robust-services-core · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
//==============================================================================
//
//  chrono
//
#ifndef CHRONO_INCLUDED
#define CHRONO_INCLUDED

#include "ctime"
#include "ratio"

namespace std
{
namespace chrono
{
   template<typename Numeric, typename Ratio = ratio<1>> class duration
   {
   public:
      duration() = default;
      explicit duration(Numeric value);
      duration(const duration& that);
      Numeric count() const;
      duration operator+() const;
      duration operator-() const;
      duration& operator++();
      duration operator++(int);
      duration& operator--();
      duration operator--(int);
      duration& operator+=(const duration& rhs);
      duration& operator-=(const duration& rhs);
      duration& operator*=(const Numeric& rhs);
      duration& operator/=(const Numeric& rhs);
      duration& operator%=(const Numeric& rhs);
      duration& operator%=(const duration& rhs);
      static constexpr duration zero();
      static constexpr duration min();
      static constexpr duration max();
   };

   using nanoseconds = duration<long long, nano>;
   using microseconds = duration<long long, micro>;
   using milliseconds = duration<long long, milli>;
   using seconds = duration<long long>;

   //  The following use the numeric type double in operators */% so that any numeric
   //  type will match through conversion.  The actual <chrono> is a rat's nest of
   //  template metaprogramming, and implementing folding and other things needed to
   //  properly support it is not a priority in the least.
   //
   template<typename Numeric, typename Ratio> duration<Numeric, Ratio>
      operator+(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> duration<Numeric, Ratio>
      operator-(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> duration<Numeric, Ratio>
      operator*(const duration<Numeric, Ratio>& dur, double num);

   template<typename Numeric, typename Ratio> duration<Numeric, Ratio>
      operator*(double num, const duration<Numeric, Ratio>& dur);

   template<typename Numeric, typename Ratio> double
      operator/(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> duration<Numeric, Ratio>
      operator/(const duration<Numeric, Ratio>& dur, double num);

   template<typename Numeric, typename Ratio> duration<Numeric, Ratio>
      operator%(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> duration<Numeric, Ratio>
      operator%(const duration<Numeric, Ratio>& dur, double num);

   template<typename Numeric, typename Ratio> bool
      operator==(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> bool
      operator!=(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> bool
      operator<(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> bool
      operator<=(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> bool
      operator>(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio> bool
      operator>=(const duration<Numeric, Ratio>& lhs, const duration<Numeric, Ratio>& rhs);

   template<class Clock, class Duration> class time_point
   {
   public:
      using duration = Duration;

      time_point() = default;
      explicit time_point(const Duration& that);
      Duration time_since_epoch() const;
      time_point& operator+=(const Duration& dur);
      time_point& operator-=(const Duration& dur);
      static constexpr time_point min();
      static constexpr time_point max();
   };

   template<class Clock, class Duration, typename Numeric, typename Ratio> time_point<Clock, Duration>
      operator+(const time_point<Clock, Duration>& lhs, const duration<Numeric, Ratio>& rhs);

   template<typename Numeric, typename Ratio, class Clock, class Duration> time_point<Clock, Duration>
      operator+(const duration<Numeric, Ratio>& lhs, const time_point<Clock, Duration>& rhs);

   template<class Clock, class Duration, typename Numeric, typename Ratio> time_point<Clock, Duration>
      operator-(const time_point<Clock, Duration>& lhs, const duration<Numeric, Ratio>& rhs);

   template<class Clock, class Duration> Duration
      operator-(const time_point<Clock, Duration>& lhs, const time_point<Clock, Duration>& rhs);

   template<class Clock, class Duration> bool
      operator==(const time_point<Clock, Duration>& lhs, const time_point<Clock, Duration>& rhs);

   template<class Clock, class Duration> bool
      operator!=(const time_point<Clock, Duration>& lhs, const time_point<Clock, Duration>& rhs);

   template<class Clock, class Duration> bool
      operator<(const time_point<Clock, Duration>& lhs, const time_point<Clock, Duration>& rhs);

   template<class Clock, class Duration> bool
      operator<=(const time_point<Clock, Duration>& lhs, const time_point<Clock, Duration>& rhs);

   template<class Clock, class Duration> bool
      operator>(const time_point<Clock, Duration>& lhs, const time_point<Clock, Duration>& rhs);

   template<class Clock, class Duration> bool
      operator>=(const time_point<Clock, Duration>& lhs, const time_point<Clock, Duration>& rhs);

   struct system_clock
   {
      using rep = long long;
      using period = ratio<1, 10000000>;
      using duration = chrono::duration<rep, period>;
      using time_point = chrono::time_point<system_clock, duration>;

      static constexpr bool is_steady = false;
      static time_point now();
      static time_t to_time_t(const time_point& time);
   };

   struct steady_clock
   {
      using rep = long long;
      using period = nano;
      using duration = nanoseconds;
      using time_point = chrono::time_point<steady_clock, duration>;

      static constexpr bool is_steady = true;
      static time_point now();
   };
}
}
#endif