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

181) /**
182)  * @brief convert to struct timeval
183)  * @param[out] tv struct timeval
184)  */
185) void Time::toTimeval(struct timeval &tv) const

186) {

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

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

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