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 <math.h>
9) #include <stdint.h>
10) 
11) #include "Time.h"
12) 
13) namespace Blinker {
14) 
15) const Time Time::zero(0); ///< zero time
16) 
17) /**
18)  * @brief get current time
19)  * @return current time
20)  */
21) Time Time::now()
22) {
23)   Time now;
24) 
25)   SYSTEMTIME st;
26)   GetSystemTime(&st);
27)   FILETIME ft;
28)   SystemTimeToFileTime(&st, &ft);
29)   now.fromFileTime(ft);
30) 
31)   return now;
32) }
33) 
34) /// constructor
35) Time::Time():
36)   m_sec(0),
37)   m_ns(0)
38) {
39) }
40) 
41) /**
42)  * @brief constructor from seconds
43)  * @param[in] t time in seconds
44)  */
45) Time::Time(time_t t):
46)   m_sec(t),
47)   m_ns(0)
48) {
49) }
50) 
51) /// comparison
52) //@{
53) 
54) int Time::compare(const Time &that) const
55) {
56)   if (m_sec < that.m_sec)
57)     return -1;
58)   if (m_sec > that.m_sec)
59)     return 1;
60)   if (m_ns < that.m_ns)
61)     return -1;
62)   if (m_ns > that.m_ns)
63)     return 1;
64)   return 0;
65) }
66) 
67) bool Time::operator==(const Time &that) const
68) {
69)   return compare(that) == 0;
70) }
71) 
72) bool Time::operator!=(const Time &that) const
73) {
74)   return compare(that) != 0;
75) }
76) 
77) bool Time::operator<(const Time &that) const
78) {
79)   return compare(that) < 0;
80) }
81) 
82) bool Time::operator>(const Time &that) const
83) {
84)   return compare(that) > 0;
85) }
86) 
87) bool Time::operator<=(const Time &that) const
88) {
89)   return compare(that) <= 0;
90) }
91) 
92) bool Time::operator>=(const Time &that) const
93) {
94)   return compare(that) >= 0;
95) }
96) 
97) //@}
98) 
99) /// arithmetic
100) //@{
101) 
102) const Time & Time::operator+=(const Time &that)
103) {
104)   m_sec += that.m_sec;
105)   m_ns += that.m_ns;
106)   fix();
107)   return *this;
108) }
109) 
110) const Time & Time::operator-=(const Time &that)
111) {
112)   m_sec -= that.m_sec;
113)   m_ns -= that.m_ns;
114)   fix();
115)   return *this;
116) }
117) 
118) Time Time::operator+(const Time &that) const
119) {
120)   Time result(*this);
121)   result += that;
122)   return result;
123) }
124) 
125) Time Time::operator-(const Time &that) const
126) {
127)   Time result(*this);
128)   result -= that;
129)   return result;
130) }
131) 
132) //@}
133) 
134) /**
135)  * @brief convert from floating point seconds
136)  * @param[in] s time in seconds
137)  */
138) void Time::fromFloatSec(float s)
139) {
140)   m_sec = (int64_t)truncf(s);
141)   m_ns  = (int64_t)((s - m_sec) * 1.0e9);
142) }
143) 
144) /**
145)  * @brief convert from milliseconds
146)  * @param[in] ms milliseconds
147)  */
148) void Time::fromMs(int ms)
149) {
150)   if (ms >= 0) {
151)     m_sec = ms / 1000;
152)     m_ns = (ms % 1000) * 1000000;
153)   } else {
154)     m_sec = -(-ms / 1000);
155)     m_ns = -(-ms % 1000) * 1000000;
156)   }
157) }
158) 
159) /**
160)  * @brief convert to seconds
161)  * @return seconds
162)  */
163) time_t Time::toSec() const
164) {
165)   if (m_ns >= 500000000)
166)     return m_sec + 1;
167)   else if (m_ns <= -500000000)
168)     return m_sec - 1;
169)   else
170)     return m_sec;
171) }
172) 
173) /**
174)  * @brief convert to floating point seconds
175)  * @return time in seconds
176)  */
177) float Time::toFloatSec() const
178) {
179)   return m_sec + m_ns * 1.0e-9f;
180) }
181) 

182) /**
183)  * @brief convert to milliseconds
184)  * @return milliseconds
185)  */
186) int Time::toMs() const
187) {
188)   if (m_sec > INT_MAX / 1000) {
189)     return INT_MAX;
190)   }
191)   if (m_sec < INT_MIN / 1000) {
192)     return INT_MIN;
193)   }
194)   int ms = m_sec * 1000;
195)   int ms2 = m_ns / 1000000;
196)   if (ms2 > 0 && ms > INT_MAX - ms2) {
197)     return INT_MAX;
198)   }
199)   if (ms2 < 0 && ms < INT_MIN - ms2) {
200)     return INT_MIN;
201)   }
202)   return ms + ms2;
203) }
204) 

205) /**
206)  * @brief convert to struct timeval
207)  * @param[out] tv struct timeval
208)  */
209) void Time::toTimeval(struct timeval &tv) const

210) {

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

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

243) /// fix internal time representation after calculation
244) void Time::fix()
245) {
246)   if (m_ns >= 1000000000) {
247)     m_sec += m_ns / 1000000000;
248)     m_ns = m_ns % 1000000000;
249)   } else if (m_ns <= -1000000000) {
250)     m_sec -= -m_ns / 1000000000;
251)     m_ns = -(-m_ns % 1000000000);
252)   }
253)   if (m_sec > 0 && m_ns < 0) {
254)     m_sec -= 1;
255)     m_ns += 1000000000;
256)   } else if (m_sec < 0 && m_ns > 0) {
257)     m_sec += 1;
258)     m_ns -= 1000000000;
259)   }
260) }
261)