1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
#ifndef _PSITIME_H_
#define _PSITIME_H_
#include <sys/time.h>
#include <unistd.h>
#include <ostream.h>
/**
* Holds a Psion time value.
* Psion time values are 64 bit
* integers describing the time
* since 01.01.0001 in microseconds.
*/
typedef struct psi_timeval_t {
/**
* Prints a psi_timeval in human readable format.
*/
friend ostream &operator<<(ostream &o, const psi_timeval_t &ptv) {
ostream::fmtflags old = o.flags();
unsigned long long micro = ptv.tv_high;
micro = (micro << 32) | ptv.tv_low;
micro /= 1000000;
int s = micro % 60;
micro /= 60;
int m = micro % 60;
micro /= 60;
int h = micro % 24;
micro /= 24;
int d = micro % 365;
micro /= 365;
int y = micro;
o << dec;
if (y > 0)
o << y << " year" << ((y > 1) ? "s " : " ");
if (d > 0)
o << d << " day" << ((d > 1) ? "s " : " ");
if (h > 0)
o << h << " hour" << ((h != 1) ? "s " : " ");
if (m > 0)
o << m << " minute" << ((m != 1) ? "s " : " ");
o << s << " second" << ((s != 1) ? "s" : "");
o.flags(old);
return o;
}
/**
* The lower 32 bits
*/
unsigned long tv_low;
/**
* The upper 32 bits
*/
unsigned long tv_high;
} psi_timeval;
/**
* holds a Psion time zone description.
*/
typedef struct psi_timezone_t {
friend ostream &operator<<(ostream &s, const psi_timezone_t &ptz) {
ostream::fmtflags old = s.flags();
int h = ptz.utc_offset / 3600;
int m = ptz.utc_offset % 3600;
s << "offs: " << dec << h << "h";
if (m != 0)
s << ", " << m << "m";
s.flags(old);
return s;
}
unsigned long utc_offset;
unsigned long dst_zones;
unsigned long home_zone;
} psi_timezone;
/**
* Psion time related utility class.
*
* PsiTime provides easy access to the time format, used
* when communicating with a Psion. Internally, the time
* is always normalized to GMT. The time value can be set
* and retrieved in both Unix and Psion formats. This
* allows easy conversion between both formats.
* NOTE: For proper conversion, the current timezone of
* the Psion has to be set. For EPOC devices, the
* timezone can be evaluated using
* @ref rpcs::getMachineInfo. For SIBO devices,
* unfortunately there is no known method of retrieving
* this information. Therefore, if the timezone is
* <em>not</em> set, a fallback using the environment
* variable <em>PSI_TZ</em> is provided. Users should
* set this variable to the offset of their time zone
* in seconds. If <em>PSI_TZ</em> is net set, a second
* fallback uses the local machine's setup, which assumes
* that both Psion and local machine have the same
* time zone and daylight settings.
*/
class PsiTime {
public:
/**
* Contructs a new instance.
*
* @param _utv A Unix time value for initialization.
* @param _utz A Unix timezone for initialization.
*/
PsiTime(struct timeval *_utv, struct timezone *_utz = 0L);
/**
* Contructs a new instance.
*
* @param time A Unix time value for initialization.
*/
PsiTime(time_t time);
/**
* Contructs a new instance.
*
* @param _ptv A Psion time value for initialization.
* @param _ptz A Psion timezone for initialization.
*/
PsiTime(psi_timeval *_ptv, psi_timezone *_ptz = 0L);
/**
* Contructs a new instance.
*
* @param _ptvHi The high 16 bits of a Psion time value for initialization.
* @param _ptvLo The low 16 bits of a Psion time value for initialization.
*/
PsiTime(const unsigned long _ptvHi, const unsigned long _ptvLo);
/**
* Constructs a new instance, initializing to now.
*/
PsiTime(void);
/**
* Destroys the instance.
*/
~PsiTime();
/**
* Modifies the value of this instance.
*
* @param _ptv The new Psion time representation.
*/
void setPsiTime(psi_timeval *_ptv);
/**
* Modifies the value of this instance.
*
* @param _ptvHi The high 32 bits of a Psion time.
* @param _ptvLo The low 32 bits of a Psion time.
*/
void setPsiTime(const unsigned long _ptvHi, const unsigned long _ptvLo);
/**
* Sets the Psion time zone of this instance.
*
* @param _ptz The new Psion time zone.
*/
void setPsiZone(psi_timezone *_ptz);
/**
* Sets the value of this instance.
*
* @param _utv The new Unix time representation.
*/
void setUnixTime(struct timeval *_utv);
/**
* Sets the value of this instance.
*
* @param _utv The new Unix time representation.
*/
void setUnixTime(time_t time);
/**
* Sets the value of this instance to the
* current time of the Unix machine.
*/
void setUnixNow(void);
/**
* Retrieves the instance's current value
* in Unix time format.
*
* @returns The instance's current time as Unix struct timeval.
*/
struct timeval &getTimeval(void);
/**
* Retrieves the instance's current value
* in Unix time format.
*
* @returns The instance's current time as Unix time_t.
*/
time_t getTime(void);
/**
* Retrieves the instance's current value
* in Psion time format.
*
* @returns The instance's current time a Psion struct psi_timeval_t.
*/
psi_timeval &getPsiTimeval(void);
/**
* Retrieves the instance's current value
* in Psion time format, high 32 bits.
*
* @returns The instance's current time as lower 32 bits of a Psion struct psi_timeval_t.
*/
const unsigned long getPsiTimeLo(void);
/**
* Retrieves the instance's current value
* in Psion time format, low 32 bits.
*
* @returns The instance's current time as upper 32 bits of a Psion struct psi_timeval_t.
*/
const unsigned long getPsiTimeHi(void);
/**
* Prints the instance's value in human readable format.
* This function uses the current locale setting for
* formatting the time.
*
* @param s The stream to be written.
* @param t The instance whose value should be displayed.
*
* @returns The stream.
*/
friend ostream &operator<<(ostream &s, const PsiTime &t);
enum zone {
PSI_TZ_NONE = 0,
PSI_TZ_EUROPEAN = 1,
PSI_TZ_NORTHERN = 2,
PSI_TZ_SOUTHERN = 4,
PSI_TZ_HOME = 0x40000000,
};
private:
void psi2unix(void);
void unix2psi(void);
psi_timeval ptv;
psi_timezone ptz;
struct timeval utv;
struct timezone utz;
bool ptzValid;
};
#endif
|
