Blinker

1) /* Blinker

2)    Copyright 2011-2019 Stefan Schuermans <stefan@blinkenarea.org>

3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #include <errno.h>

7) #include <iomanip>

8) #include <math.h>

9) #include <sstream>

10) #include <stdint.h>

11) #include <string>

12) #include <sys/time.h>
13) #include <time.h>
14) 
15) #include "Time.h"
16) 
17) namespace Blinker {
18) 
19) const Time Time::zero(0); ///< zero time
20) 
21) /**
22)  * @brief get current time
23)  * @return current time
24)  */
25) Time Time::now()
26) {
27)   Time now;
28) 
29)   struct timeval tv;
30)   gettimeofday(&tv, NULL);
31)   now.m_sec = tv.tv_sec;
32)   now.m_ns = tv.tv_usec * 1000;
33) 
34)   return now;
35) }
36) 
37) /// constructor
38) Time::Time():
39)   m_sec(0),
40)   m_ns(0)
41) {
42) }
43) 
44) /**
45)  * @brief constructor from seconds
46)  * @param[in] t time in seconds
47)  */
48) Time::Time(time_t t):
49)   m_sec(t),
50)   m_ns(0)
51) {
52) }
53) 
54) /// comparison
55) //@{
56) 
57) int Time::compare(const Time &that) const
58) {
59)   if (m_sec < that.m_sec)
60)     return -1;
61)   if (m_sec > that.m_sec)
62)     return 1;
63)   if (m_ns < that.m_ns)
64)     return -1;
65)   if (m_ns > that.m_ns)
66)     return 1;
67)   return 0;
68) }
69) 
70) bool Time::operator==(const Time &that) const
71) {
72)   return compare(that) == 0;
73) }
74) 
75) bool Time::operator!=(const Time &that) const
76) {
77)   return compare(that) != 0;
78) }
79) 
80) bool Time::operator<(const Time &that) const
81) {
82)   return compare(that) < 0;
83) }
84) 
85) bool Time::operator>(const Time &that) const
86) {
87)   return compare(that) > 0;
88) }
89) 
90) bool Time::operator<=(const Time &that) const
91) {
92)   return compare(that) <= 0;
93) }
94) 
95) bool Time::operator>=(const Time &that) const
96) {
97)   return compare(that) >= 0;
98) }
99) 
100) //@}
101) 
102) /// arithmetic
103) //@{
104) 
105) const Time & Time::operator+=(const Time &that)
106) {
107)   m_sec += that.m_sec;
108)   m_ns += that.m_ns;
109)   fix();
110)   return *this;
111) }
112) 
113) const Time & Time::operator-=(const Time &that)
114) {
115)   m_sec -= that.m_sec;
116)   m_ns -= that.m_ns;
117)   fix();
118)   return *this;
119) }
120) 
121) Time Time::operator+(const Time &that) const
122) {
123)   Time result(*this);
124)   result += that;
125)   return result;
126) }
127) 
128) Time Time::operator-(const Time &that) const
129) {
130)   Time result(*this);
131)   result -= that;
132)   return result;
133) }
134) 
135) //@}
136) 

137) /**
138)  * @brief convert from floating point seconds
139)  * @param[in] s time in seconds
140)  */
141) void Time::fromFloatSec(float s)
142) {
143)   m_sec = (int64_t)truncf(s);
144)   m_ns  = (int64_t)((s - m_sec) * 1.0e9);
145) }
146) 

147) /**
148)  * @brief convert from milliseconds
149)  * @param[in] ms milliseconds
150)  */
151) void Time::fromMs(int ms)
152) {
153)   if (ms >= 0) {
154)     m_sec = ms / 1000;
155)     m_ns = (ms % 1000) * 1000000;
156)   } else {
157)     m_sec = -(-ms / 1000);
158)     m_ns = -(-ms % 1000) * 1000000;
159)   }
160) }
161) 
162) /**
163)  * @brief convert to seconds
164)  * @return seconds
165)  */
166) time_t Time::toSec() const
167) {
168)   if (m_ns >= 500000000)
169)     return m_sec + 1;

170)   else if (m_ns <= -500000000)

171)     return m_sec - 1;
172)   else
173)     return m_sec;
174) }
175) 

176) /**
177)  * @brief convert to floating point seconds
178)  * @return time in seconds
179)  */

180) float Time::toFloatSec() const

181) {
182)   return m_sec + m_ns * 1.0e-9f;
183) }
184) 

185) /**
186)  * @brief convert to struct timeval
187)  * @param[out] tv struct timeval
188)  */
189) void Time::toTimeval(struct timeval &tv) const
190) {
191)   if (m_sec >= 0) {
192)     tv.tv_sec = m_sec;
193)     tv.tv_usec = (m_ns + 500) / 1000;
194)     if (tv.tv_usec >= 1000000) {
195)       ++tv.tv_sec;
196)       tv.tv_usec -= 1000000;
197)     }
198)   } else {
199)     tv.tv_sec = m_sec;
200)     tv.tv_usec = -((-m_ns + 500) / 1000);
201)     if (tv.tv_usec <= -1000000) {
202)       --tv.tv_sec;
203)       tv.tv_usec += 1000000;
204)     }
205)   }
206) }
207) 

208) /**
209)  * @brief convert to human-readable string
210)  * @return human-readable string
211)  */
212) std::string Time::toStr() const
213) {
214)   time_t sec = m_sec;
215)   struct tm t;
216)   localtime_r(&sec, &t);
217)   std::stringstream strm;
218)   strm << std::setfill('0')
219)        << std::setw(4) << (t.tm_year + 1900)
220)        << "-" << std::setw(2) << (t.tm_mon + 1)
221)        << "-" << std::setw(2) << t.tm_mday
222)        << " " << std::setw(2) << t.tm_hour
223)        << ":" << std::setw(2) << t.tm_min
224)        << ":" << std::setw(2) << t.tm_sec
225)        << "." << std::setw(9) << m_ns;
226)   return strm.str();
227) }
228)