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 <errno.h>

7) #include <math.h>

8) #include <stdint.h>
9) #include <sys/time.h>
10) #include <time.h>
11) 
12) #include "Time.h"
13) 
14) namespace Blinker {
15) 
16) const Time Time::zero(0); ///< zero time
17) 
18) /**
19)  * @brief get current time
20)  * @return current time
21)  */
22) Time Time::now()
23) {
24)   Time now;
25) 
26)   struct timeval tv;
27)   gettimeofday(&tv, NULL);
28)   now.m_sec = tv.tv_sec;
29)   now.m_ns = tv.tv_usec * 1000;
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 struct timeval
175)  * @param[out] tv struct timeval
176)  */
177) void Time::toTimeval(struct timeval &tv) const
178) {
179)   if (m_sec >= 0) {
180)     tv.tv_sec = m_sec;
181)     tv.tv_usec = (m_ns + 500) / 1000;
182)     if (tv.tv_usec >= 1000000) {
183)       ++tv.tv_sec;
184)       tv.tv_usec -= 1000000;
185)     }
186)   } else {
187)     tv.tv_sec = m_sec;
188)     tv.tv_usec = -((-m_ns + 500) / 1000);
189)     if (tv.tv_usec <= -1000000) {
190)       --tv.tv_sec;
191)       tv.tv_usec += 1000000;
192)     }
193)   }
194) }
195)