]> git.stg.codes - stg.git/blob - include/stg/utime.h
Immediate disconnect on Unauthorize if not authorized.
[stg.git] / include / stg / utime.h
1 #ifndef UTIME_H
2 #define UTIME_H
3
4 /*
5  *    This program is free software; you can redistribute it and/or modify
6  *    it under the terms of the GNU General Public License as published by
7  *    the Free Software Foundation; either version 2 of the License, or
8  *    (at your option) any later version.
9  *
10  *    This program is distributed in the hope that it will be useful,
11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *    GNU General Public License for more details.
14  *
15  *    You should have received a copy of the GNU General Public License
16  *    along with this program; if not, write to the Free Software
17  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19
20 /*
21  *    Date: 22.12.2007
22  */
23
24 /*
25  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
26  */
27
28  /*
29  $Revision: 1.6 $
30  $Date: 2009/08/05 11:40:30 $
31  $Author: faust $
32  */
33
34 #include <sys/time.h>
35 #include <time.h>
36
37 #ifdef FREE_BSD
38 typedef long suseconds_t;
39 #endif
40
41 struct UTIME: public timeval
42 {
43     UTIME()
44     {
45     tv_sec = 0;
46     tv_usec = 0;
47     }
48
49     UTIME(time_t t)
50     {
51     tv_sec = t;
52     tv_usec = 0;
53     }
54
55     UTIME(long long a, long long b)
56     {
57     tv_sec = a;
58     tv_usec = b;
59     }
60
61     bool operator<(const UTIME & rhs) const
62     {
63     if (tv_sec < rhs.tv_sec)
64         return true;
65     else if (tv_sec > rhs.tv_sec)
66         return false;
67     else if (tv_usec < rhs.tv_usec)
68         return true;
69     return false;
70     }
71
72     bool operator<=(const UTIME & rhs) const
73     {
74     if (tv_sec < rhs.tv_sec)
75         return true;
76     else if (tv_sec > rhs.tv_sec)
77         return false;
78     else if (tv_usec < rhs.tv_usec)
79         return true;
80     else if (tv_usec > rhs.tv_usec)
81         return false;
82     return true;
83     }
84
85     bool operator>(const UTIME & rhs) const
86     {
87     if (tv_sec > rhs.tv_sec)
88         return true;
89     else if (tv_sec < rhs.tv_sec)
90         return false;
91     else if (tv_usec > rhs.tv_usec)
92         return true;
93     return false;
94     }
95
96     bool operator>=(const UTIME & rhs) const
97     {
98     if (tv_sec > rhs.tv_sec)
99         return true;
100     else if (tv_sec < rhs.tv_sec)
101         return false;
102     else if (tv_usec > rhs.tv_usec)
103         return true;
104     else if (tv_usec < rhs.tv_usec)
105         return false;
106     return true;
107     }
108
109     bool operator==(const UTIME & rhs) const
110     {
111     return (tv_sec == rhs.tv_sec) && (tv_usec == rhs.tv_usec);
112     }
113
114     UTIME operator+(const UTIME & rhs)
115     {
116     // TODO optimize
117     long long a, b;
118     a = tv_sec + rhs.tv_sec;
119     b = tv_usec + rhs.tv_usec;
120     if (b > 1000000)
121         {
122         ++a;
123         b -= 1000000;
124         }
125     return UTIME(a, b);
126     }
127
128     UTIME operator-(const UTIME & rhs)
129     {
130     // TODO optimize
131     long long a, b;
132     a = tv_sec - rhs.tv_sec;
133     b = tv_usec - rhs.tv_usec;
134     if (a >= 0)
135         {
136         if (b >= 0)
137             {
138             return UTIME(a, b);
139             }
140         else
141             {
142             return UTIME(--a, b + 1000000);
143             }
144         }
145     else
146         {
147         if (b >= 0)
148             {
149             return UTIME(++a, 1000000 - b);
150             }
151         else
152             {
153             return UTIME(a, b);
154             }
155         }
156     }
157
158     time_t GetSec() const
159     {
160     return tv_sec;
161     }
162
163     suseconds_t GetUSec() const
164     {
165     return tv_usec;
166     }
167
168     double AsDouble() const
169     {
170     return tv_sec + tv_usec * 1e-6;
171     }
172 };
173
174
175 #endif //UTIME_H