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 struct timeval
184)  * @param[out] tv struct timeval
185)  */
186) void Time::toTimeval(struct timeval &tv) const

187) {

188)   if (m_sec >= 0) {
189)     tv.tv_sec = m_sec;
190)     tv.tv_usec = (m_ns + 500) / 1000;
191)     if (tv.tv_usec >= 1000000) {
192)       ++tv.tv_sec;
193)       tv.tv_usec -= 1000000;
194)     }
195)   } else {
196)     tv.tv_sec = m_sec;
197)     tv.tv_usec = -((-m_ns + 500) / 1000);
198)     if (tv.tv_usec <= -1000000) {
199)       --tv.tv_sec;
200)       tv.tv_usec += 1000000;
201)     }

202)   }
203) }
204) 
205) /**
206)  * @brief convert from file time strcuture
207)  * @param[in] ft file time structure
208)  */
209) void Time::fromFileTime(FILETIME const &ft)
210) {
211)   union {
212)     FILETIME ft;
213)     ULARGE_INTEGER u;
214)   } ft_u;
215)   ft_u.ft = ft;
216)   m_sec = ft_u.u.QuadPart / 10000000ULL;
217)   m_ns = (ft_u.u.QuadPart % 10000000ULL) * 100ULL;
218) }
219) 

220) /// fix internal time representation after calculation
221) void Time::fix()
222) {
223)   if (m_ns >= 1000000000) {
224)     m_sec += m_ns / 1000000000;
225)     m_ns = m_ns % 1000000000;
226)   } else if (m_ns <= -1000000000) {
227)     m_sec -= -m_ns / 1000000000;
228)     m_ns = -(-m_ns % 1000000000);
229)   }
230)   if (m_sec > 0 && m_ns < 0) {
231)     m_sec -= 1;
232)     m_ns += 1000000000;
233)   } else if (m_sec < 0 && m_ns > 0) {
234)     m_sec += 1;
235)     m_ns -= 1000000000;
236)   }
237) }
238)