GNU Octave  3.8.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
oct-time.h
Go to the documentation of this file.
1 /*
2 
3 Copyright (C) 1999-2013 John W. Eaton
4 
5 This file is part of Octave.
6 
7 Octave is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3 of the License, or (at your
10 option) any later version.
11 
12 Octave is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16 
17 You should have received a copy of the GNU General Public License
18 along with Octave; see the file COPYING. If not, see
19 <http://www.gnu.org/licenses/>.
20 
21 */
22 
23 #if !defined (octave_oct_time_h)
24 #define octave_oct_time_h 1
25 
26 #include <ctime>
27 #include <string>
28 
29 #include "lo-math.h"
30 
31 class octave_base_tm;
32 
33 class
34 OCTAVE_API
36 {
37 public:
38 
39  octave_time (void)
40  : ot_unix_time (0), ot_usec (0) { stamp (); }
41 
42  octave_time (time_t t)
43  : ot_unix_time (t), ot_usec (0) { }
44 
45  octave_time (time_t t, int us)
46  : ot_unix_time (t), ot_usec ()
47  {
48  int rem, extra;
49 
50  if (us >= 0)
51  {
52  rem = us % 1000000;
53  extra = (us - rem) / 1000000;
54  }
55  else
56  {
57  us = -us;
58  rem = us % 1000000;
59  extra = - (1 + (us - rem) / 1000000);
60  rem = 1000000 - us % 1000000;
61  }
62 
63  ot_usec = rem;
64  ot_unix_time += extra;
65  }
66 
67  octave_time (double d)
68  : ot_unix_time (static_cast<time_t> (d)), ot_usec (0)
69  {
70  double ip;
71  ot_usec = static_cast<int> (std::modf (d, &ip) * 1e6);
72  }
73 
74  octave_time (const octave_base_tm& tm);
75 
77  : ot_unix_time (ot.ot_unix_time), ot_usec (ot.ot_usec) { }
78 
80  {
81  if (this != &ot)
82  {
83  ot_unix_time = ot.ot_unix_time;
84  ot_usec = ot.ot_usec;
85  }
86 
87  return *this;
88  }
89 
90  ~octave_time (void) { }
91 
92  void stamp (void);
93 
94  double double_value (void) const { return ot_unix_time + ot_usec / 1e6; }
95 
96  time_t unix_time (void) const { return ot_unix_time; }
97 
98  int usec (void) const { return ot_usec; }
99 
100  std::string ctime (void) const;
101 
102 private:
103 
104  // Seconds since the epoch.
105  time_t ot_unix_time;
106 
107  // Additional microseconds.
108  int ot_usec;
109 };
110 
111 inline bool
112 operator == (const octave_time& t1, const octave_time& t2)
113 {
114  return (t1.unix_time () == t2.unix_time () && t1.usec () == t2.usec ());
115 }
116 
117 inline bool
118 operator != (const octave_time& t1, const octave_time& t2)
119 {
120  return ! (t1 == t2);
121 }
122 
123 inline bool
124 operator < (const octave_time& t1, const octave_time& t2)
125 {
126  if (t1.unix_time () < t2.unix_time ())
127  return true;
128  else if (t1.unix_time () > t2.unix_time ())
129  return false;
130  else if (t1.usec () < t2.usec ())
131  return true;
132  else
133  return false;
134 }
135 
136 inline bool
137 operator <= (const octave_time& t1, const octave_time& t2)
138 {
139  return (t1 < t2 || t1 == t2);
140 }
141 
142 inline bool
143 operator > (const octave_time& t1, const octave_time& t2)
144 {
145  if (t1.unix_time () > t2.unix_time ())
146  return true;
147  else if (t1.unix_time () < t2.unix_time ())
148  return false;
149  else if (t1.usec () > t2.usec ())
150  return true;
151  else
152  return false;
153 }
154 
155 inline bool
156 operator >= (const octave_time& t1, const octave_time& t2)
157 {
158  return (t1 > t2 || t1 == t2);
159 }
160 
161 inline octave_time
162 operator + (const octave_time& t1, const octave_time& t2)
163 {
164  return octave_time (t1.unix_time () + t2.unix_time (),
165  t1.usec () + t2.usec ());
166 }
167 
168 class
169 OCTAVE_API
171 {
172 public:
173 
175  : tm_usec (0), tm_sec (0), tm_min (0), tm_hour (0),
176  tm_mday (0), tm_mon (0), tm_year (0), tm_wday (0),
177  tm_yday (0), tm_isdst (0), tm_gmtoff (0), tm_zone ("unknown")
178  { }
179 
181  : tm_usec (tm.tm_usec), tm_sec (tm.tm_sec), tm_min (tm.tm_min),
182  tm_hour (tm.tm_hour), tm_mday (tm.tm_mday), tm_mon (tm.tm_mon),
183  tm_year (tm.tm_year), tm_wday (tm.tm_wday), tm_yday (tm.tm_yday),
185  { }
186 
188  {
189  if (this != &tm)
190  {
191  tm_usec = tm.tm_usec;
192  tm_sec = tm.tm_sec;
193  tm_min = tm.tm_min;
194  tm_hour = tm.tm_hour;
195  tm_mday = tm.tm_mday;
196  tm_mon = tm.tm_mon;
197  tm_year = tm.tm_year;
198  tm_wday = tm.tm_wday;
199  tm_yday = tm.tm_yday;
200  tm_isdst = tm.tm_isdst;
201  tm_gmtoff = tm.tm_gmtoff;
202  tm_zone = tm.tm_zone;
203  }
204 
205  return *this;
206  }
207 
208  virtual ~octave_base_tm (void) { }
209 
210  int usec (void) const { return tm_usec; }
211  int sec (void) const { return tm_sec; }
212  int min (void) const { return tm_min; }
213  int hour (void) const { return tm_hour; }
214  int mday (void) const { return tm_mday; }
215  int mon (void) const { return tm_mon; }
216  int year (void) const { return tm_year; }
217  int wday (void) const { return tm_wday; }
218  int yday (void) const { return tm_yday; }
219  int isdst (void) const { return tm_isdst; }
220  long gmtoff (void) const { return tm_gmtoff; }
221  std::string zone (void) const { return tm_zone; }
222 
223  octave_base_tm& usec (int v);
224  octave_base_tm& sec (int v);
225  octave_base_tm& min (int v);
226  octave_base_tm& hour (int v);
227  octave_base_tm& mday (int v);
228  octave_base_tm& mon (int v);
229  octave_base_tm& year (int v);
230  octave_base_tm& wday (int v);
231  octave_base_tm& yday (int v);
232  octave_base_tm& isdst (int v);
233  octave_base_tm& gmtoff (long v);
234  octave_base_tm& zone (const std::string& s);
235 
236  std::string strftime (const std::string& fmt) const;
237 
238  std::string asctime (void) const
239  { return strftime ("%a %b %d %H:%M:%S %Y\n"); }
240 
241 protected:
242 
243  // Microseconds after the second (0, 999999).
244  int tm_usec;
245 
246  // Seconds after the minute (0, 61).
247  int tm_sec;
248 
249  // Minutes after the hour (0, 59).
250  int tm_min;
251 
252  // Hours since midnight (0, 23).
253  int tm_hour;
254 
255  // Day of the month (1, 31).
256  int tm_mday;
257 
258  // Months since January (0, 11).
259  int tm_mon;
260 
261  // Years since 1900.
262  int tm_year;
263 
264  // Days since Sunday (0, 6).
265  int tm_wday;
266 
267  // Days since January 1 (0, 365).
268  int tm_yday;
269 
270  // Daylight Savings Time flag.
271  int tm_isdst;
272 
273  // Time zone.
274  long tm_gmtoff;
275 
276  // Time zone.
277  std::string tm_zone;
278 
279  void init (void *p);
280 };
281 
282 class
283 OCTAVE_API
285 {
286 public:
287 
289  : octave_base_tm () { init (octave_time ()); }
290 
292  : octave_base_tm () { init (ot); }
293 
295  : octave_base_tm (t) { }
296 
298  {
300  return *this;
301  }
302 
303  ~octave_localtime (void) { }
304 
305 private:
306 
307  void init (const octave_time& ot);
308 };
309 
310 class
311 OCTAVE_API
313 {
314 public:
315 
317  : octave_base_tm () { init (octave_time ()); }
318 
320  : octave_base_tm () { init (ot); }
321 
323  {
325  return *this;
326  }
327 
328  ~octave_gmtime (void) { }
329 
330 private:
331 
332  void init (const octave_time& ot);
333 };
334 
335 class
336 OCTAVE_API
338 {
339 public:
340 
341  octave_strptime (const std::string& str, const std::string& fmt)
342  : octave_base_tm (), nchars (0)
343  {
344  init (str, fmt);
345  }
346 
348  : octave_base_tm (s), nchars (s.nchars) { }
349 
351  {
353  nchars = s.nchars;
354  return *this;
355  }
356 
357  int characters_converted (void) const { return nchars; }
358 
359  ~octave_strptime (void) { }
360 
361 private:
362 
363  int nchars;
364 
365  void init (const std::string& str, const std::string& fmt);
366 };
367 
368 #endif