Blinker

1) /* Blinker
2)    Copyright 2011-2014 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 <winsock2.h> // not allowed after windows.h, so include here
7) #include <windows.h>

8) #include <iomanip>

9) #include <math.h>

10) #include <sstream>

11) #include <stdint.h>

12) #include <string>

13) 
14) #include "Time.h"
15) 
16) namespace Blinker {
17) 
18) const Time Time::zero(0); ///< zero time
19) 
20) /**
21)  * @brief get current time
22)  * @return current time
23)  */
24) Time Time::now()
25) {
26)   Time now;
27) 
28)   SYSTEMTIME st;
29)   GetSystemTime(&st);
30)   FILETIME ft;
31)   SystemTimeToFileTime(&st, &ft);
32)   now.fromFileTime(ft);
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 milliseconds
187)  * @return milliseconds
188)  */
189) int Time::toMs() const
190) {
191)   if (m_sec > INT_MAX / 1000) {
192)     return INT_MAX;
193)   }
194)   if (m_sec < INT_MIN / 1000) {
195)     return INT_MIN;
196)   }
197)   int ms = m_sec * 1000;
198)   int ms2 = m_ns / 1000000;
199)   if (ms2 > 0 && ms > INT_MAX - ms2) {
200)     return INT_MAX;
201)   }
202)   if (ms2 < 0 && ms < INT_MIN - ms2) {
203)     return INT_MIN;
204)   }
205)   return ms + ms2;
206) }
207) 

208) /**
209)  * @brief convert to struct timeval
210)  * @param[out] tv struct timeval
211)  */
212) void Time::toTimeval(struct timeval &tv) const

213) {

214)   if (m_sec >= 0) {
215)     tv.tv_sec = m_sec;
216)     tv.tv_usec = (m_ns + 500) / 1000;
217)     if (tv.tv_usec >= 1000000) {
218)       ++tv.tv_sec;
219)       tv.tv_usec -= 1000000;
220)     }
221)   } else {
222)     tv.tv_sec = m_sec;
223)     tv.tv_usec = -((-m_ns + 500) / 1000);
224)     if (tv.tv_usec <= -1000000) {
225)       --tv.tv_sec;
226)       tv.tv_usec += 1000000;
227)     }

228)   }
229) }
230) 
231) /**
232)  * @brief convert from file time strcuture
233)  * @param[in] ft file time structure
234)  */
235) void Time::fromFileTime(FILETIME const &ft)
236) {
237)   union {
238)     FILETIME ft;
239)     ULARGE_INTEGER u;
240)   } ft_u;
241)   ft_u.ft = ft;
242)   m_sec = ft_u.u.QuadPart / 10000000ULL;
243)   m_ns = (ft_u.u.QuadPart % 10000000ULL) * 100ULL;
244) }
245) 

246) /**
247)  * @brief convert to human-readable string
248)  * @return human-readable string
249)  */
250) std::string Time::toStr() const
251) {
252)   time_t sec = m_sec;
253)   struct tm t;
254)   localtime_s(&t, &sec);
255)   std::stringstream strm;
256)   strm << std::setfill('0')
257)        << std::setw(4) << (t.tm_year + 1900)
258)        << "-" << std::setw(2) << (t.tm_mon + 1)
259)        << "-" << std::setw(2) << t.tm_mday
260)        << " " << std::setw(2) << t.tm_hour
261)        << ":" << std::setw(2) << t.tm_min
262)        << ":" << std::setw(2) << t.tm_sec
263)        << "." << std::setw(9) << m_ns;
264)   return strm.str();
265) }
266) 

267) /// fix internal time representation after calculation
268) void Time::fix()
269) {
270)   if (m_ns >= 1000000000) {
271)     m_sec += m_ns / 1000000000;
272)     m_ns = m_ns % 1000000000;
273)   } else if (m_ns <= -1000000000) {
274)     m_sec -= -m_ns / 1000000000;
275)     m_ns = -(-m_ns % 1000000000);
276)   }
277)   if (m_sec > 0 && m_ns < 0) {
278)     m_sec -= 1;
279)     m_ns += 1000000000;
280)   } else if (m_sec < 0 && m_ns > 0) {
281)     m_sec += 1;
282)     m_ns -= 1000000000;
283)   }
284) }
285)