src/time.cc

   1 ///
   2 /// \file       time.cc
   3 ///             Conversion between time_t and cenmin_t and back.
   4 ///             time_t is the POSIX time, seconds from Jan 1, 1970
   5 ///             min1900_t is the minutes from Jan 1, 1900
   6 ///
   7
   8 /*
   9     Copyright (C) 2005-2007, Net Direct Inc. (http://www.netdirect.ca/)
  10
  11     This program is free software; you can redistribute it and/or modify
  12     it under the terms of the GNU General Public License as published by
  13     the Free Software Foundation; either version 2 of the License, or
  14     (at your option) any later version.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  19
  20     See the GNU General Public License in the COPYING file at the
  21     root directory of this project for more details.
  22 */
  23
  24 #include "time.h"
  25 #include "endian.h"
  26
  27 namespace Barry {
  28
  29 TimeZone Zones[] = {
  30         { 0x0000,  -12,   0, "Eniwetok, Kwajalein (-12)" },
  31         { 0x0001,  -12,   0, "Midway Island, Samoa (-12)" },
  32         { 0x0002,  -10,   0, "Hawaii (-10)" },
  33         { 0x0003,   -9,   0, "Alaska (-9)" },
  34         { 0x0004,   -8,   0, "Pacific Time (US & Canada), Tijuana (-8)" },
  35         { 0x000a,   -7,   0, "Mountain Time (US & Canada) (-7)" },
  36         { 0x000f,   -7,   0, "Arizona (-7)" },
  37         { 0x000d,   -7,   0, "Chihuahua, La Paz, Mazatlan (-7)" },
  38         { 0x0014,   -6,   0, "Central Time (US & Canada) (-6)" },
  39         { 0x0021,   -6,   0, "Central America (-6)" },
  40         { 0x0019,   -6,   0, "Saskatchewan (-6)" },
  41         { 0x001e,   -6,   0, "Mexico City (-6)" },
  42         { 0x0023,   -5,   0, "Eastern Time (US & Canada) (-5)" },
  43         { 0x002d,   -5,   0, "Bogota, Lima, Quito (-5)" },
  44         { 0x0028,   -5,   0, "Indiana (East) (-5)" },
  45         { 0x0032,   -4,   0, "Atlantic Time (Canada) (-4)" },
  46         { 0x0037,   -4,   0, "Caracas, La Paz (-4)" },
  47         { 0x0038,   -4,   0, "Santiago (-4)" },
  48         { 0x003c,   -3, -30, "Newfoundland (-3.5)" },
  49         { 0x0046,   -3,   0, "Buenos Aires, Georgetown (-3)" },
  50         { 0x0041,   -3,   0, "Brasilia (-3)" },
  51         { 0x0049,   -3,   0, "Greenland (-3)" },
  52         { 0x004b,   -2,   0, "Mid-Atlantic (-2)" },
  53         { 0x0053,   -1,   0, "Cape Verde Island (-1)" },
  54         { 0x0050,   -1,   0, "Azores (-1)" },
  55         { 0x0055,    0,   0, "Dublin, Edinburgh, Lisbon, London (GMT)" },
  56         { 0x005a,    0,   0, "Casablanca, Monrovia (GMT)" },
  57         { 0x006e,    1,   0, "Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna (+1)" },
  58         { 0x0071,    1,   0, "West Central Africa (+1)" },
  59         { 0x005f,    1,   0, "Belgrade, Bratislava, Budapest, Ljubljana, Prague (+1)" },
  60         { 0x0069,    1,   0, "Brussels, Copenhagen, Madrid, Paris (+1)" },
  61         { 0x0064,    1,   0, "Sarajevo, Skopje, Sofija, Vilnius, Warsaw, Zagreb (+1)" },
  62         { 0x008c,    2,   0, "Harare, Pretoria (+2)" },
  63         { 0x0087,    2,   0, "Jerusalem (+2)" },
  64         { 0x0073,    2,   0, "Bucharest (+2)" },
  65         { 0x0078,    2,   0, "Cairo (+2)" },
  66         { 0x0082,    2,   0, "Athens, Istanbul, Minsk (+2)" },
  67         { 0x007d,    2,   0, "Helsinki, Riga, Tallinn (+2)" },
  68         { 0x0096,    3,   0, "Kuwait, Riyadh (+3)" },
  69         { 0x009b,    3,   0, "Nairobi (+3)" },
  70         { 0x009e,    3,   0, "Baghdad (+3)" },
  71         { 0x0091,    3,   0, "Moscow, St. Petersburg, Volgograd (+3)" },
  72         { 0x00a0,    3,  30, "Tehran (+3.5)" },
  73         { 0x00a5,    4,   0, "Abu Dhabi, Muscat (+4)" },
  74         { 0x00aa,    4,   0, "Baku, Tbilisi, Yerevan (+4)" },
  75         { 0x00af,    4,  30, "Kabul (+4.5)" },
  76         { 0x00b9,    5,   0, "Islamabad, Karachi, Tashkent (+5)" },
  77         { 0x00b4,    5,   0, "Ekaterinburg (+5)" },
  78         { 0x00be,    5,  30, "Calcutta, Chennai, Mumbai, New Delhi (+5.5)" },
  79         { 0x00c1,    5,  45, "Kathmandu (+5.75)" },
  80         { 0x00c3,    6,   0, "Astana, Dhaka (+6)" },
  81         { 0x00c8,    6,   0, "Sri Lanka (+6)" },
  82         { 0x00c9,    6,   0, "Almaty, Novosibirsk (+6)" },
  83         { 0x00cb,    6,  30, "Rangoon (+6.5)" },
  84         { 0x00cd,    7,   0, "Bangkok, Hanoi, Jakarta (+7)" },
  85         { 0x00cf,    7,   0, "Krasnoyarsk (+7)" },
  86         { 0x00d2,    8,   0, "Beijing, Chongqing, Hong Kong, Urumqi (+8)" },
  87         { 0x00d7,    8,   0, "Kuala Lumpur, Singapore (+8)" },
  88         { 0x00e1,    8,   0, "Perth (+8)" },
  89         { 0x00dc,    8,   0, "Taipei (+8)" },
  90         { 0x00e3,    8,   0, "Irkutsk, Ulaan Bataar (+8)" },
  91         { 0x00eb,    9,   0, "Osaka, Sapporo, Tokyo (+9)" },
  92         { 0x00e6,    9,   0, "Seoul (+9)" },
  93         { 0x00f0,    9,   0, "Yakutsk (+9)" },
  94         { 0x00f5,    9,  30, "Darwin (+9.5)" },
  95         { 0x00fa,    9,  30, "Adelaide (+9.5)" },
  96         { 0x0104,   10,   0, "Brisbane (+10)" },
  97         { 0x0113,   10,   0, "Guam, Port Moresby (+10)" },
  98         { 0x00ff,   10,   0, "Canberra, Melbourne, Sydney (+10)" },
  99         { 0x0109,   10,   0, "Hobart (+10)" },
 100         { 0x010e,   10,   0, "Vladivostok (+10)" },
 101         { 0x0118,   11,   0, "Magadan, Solomon Islands, New Caledonia (+11)" },
 102         { 0x011d,   12,   0, "Fiji, Kamchatka, Marshall Islands (+12)" },
 103         { 0x0122,   12,   0, "Auckland, Wellington (+12)" },
 104         { 0x012c,   13,   0, "Nuku'alofa (+13)" },
 105         { 0,         0,   0, 0 }
 106 };
 107
 108 min1900_t time2min(time_t t)
 109 {
 110         if( t == 0 )
 111                 return htobl(0xffffffff);
 112
 113         min1900_t r = t / 60 + STDC_MIN1900_DIFF;
 114         return htobl(r);
 115 }
 116
 117 time_t min2time(min1900_t m)
 118 {
 119         if( (unsigned long) btohl(m) == 0xffffffff )
 120                 return 0;
 121         else
 122                 return (btohl(m) - STDC_MIN1900_DIFF) * 60;
 123 }
 124
 125
 126 //
 127 // GetTimeZoneTable
 128 //
 129 /// Returns a pointer to an array of TimeZone structs.
 130 /// The last struct contains 0 in all fields, and can be used as
 131 /// an "end of array" marker.
 132 ///
 133 const TimeZone* GetTimeZoneTable()
 134 {
 135         return Zones;
 136 }
 137
 138 //
 139 // GetTimeZone
 140 //
 141 /// Searches the internal timezone code table for the given Code
 142 /// and returns a pointer to a TimeZone struct found.  If the
 143 /// code is not found, a pointer to a valid TimeZone struct is
 144 /// is still returned, but the struct's Code contains TIME_ZONE_CODE_ERR,
 145 /// and the name is "Unknown time zone."  The unknown timezone
 146 /// is the same offset as GMT.
 147 ///
 148 const TimeZone* GetTimeZone(unsigned short Code)
 149 {
 150         static TimeZone Unknown = { TIME_ZONE_CODE_ERR, 0, 0, "Unknown time zone" };
 151
 152         for( TimeZone *z = Zones; z->Name; z++ ) {
 153                 if( Code == z->Code )
 154                         return z;
 155         }
 156         return &Unknown;
 157 }
 158
 159 //
 160 // GetTimeZoneCode
 161 //
 162 /// Searches the internal timezone table for the first matching
 163 /// Code.  If no matching Code is found, TIME_ZONE_CODE_ERR is returned.
 164 ///
 165 /// This function does not adjust for daylight saving time.
 166 ///
 167 unsigned short GetTimeZoneCode(signed short HourOffset,
 168                                signed short MinOffset)
 169 {
 170         for( TimeZone *z = Zones; z->Name; z++ ) {
 171                 if( HourOffset == z->HourOffset && MinOffset == z->MinOffset )
 172                         return z->Code;
 173         }
 174         return TIME_ZONE_CODE_ERR;
 175 }
 176
 177 /// This routine takes the day of the year and
 178 /// returns a time_t adjusted from the first of
 179 /// the year.
 180 ///
 181 /// FIXME This function assumes the year hasn't changed,
 182 /// but I don't have enough information to determine
 183 /// where the year is in this header info
 184 ///
 185 time_t DayToDate( unsigned short Day )
 186 {
 187         struct tm *now, then;
 188         time_t t = time( NULL );
 189
 190         now = localtime( &t ); // need this to get year
 191         // set to Jan 1 midnight, this year;
 192         then.tm_sec = 0;
 193         then.tm_min = 0;
 194         then.tm_hour = 0;
 195         then.tm_mday = 0;
 196         then.tm_mon = 0;
 197         then.tm_year = now->tm_year;
 198         then.tm_isdst = -1;
 199         t = mktime(&then);
 200         t -= 60*60;                     // need to subract an hour
 201         t += Day * 24 * 60 * 60;        // Add the day converted to seconds
 202
 203         return t;
 204 }
 205
 206
 207 } // namespace Barry
 208
 209
 210 #ifdef __TEST_MODE__
 211
 212 #include <iostream>
 213 #include <iomanip>
 214
 215 using namespace std;
 216 using namespace Barry;
 217
 218 void display(const char *msg, time_t t)
 219 {
 220         cout << msg << ": " << ctime(&t);
 221         cout << msg << " seconds: "
 222                 << setbase(10) << t
 223                 << "(0x" << setbase(16) << t << ")"
 224                 << endl;
 225         cout << msg << " minutes: "
 226                 << setbase(10) << (t/60)
 227                 << "(0x" << setbase(16) << (t/60) << ")"
 228                 << endl;
 229         cout << endl;
 230 }
 231
 232 void calc(const char *msg, time_t t, min1900_t dbval)
 233 {
 234         cout << msg << endl;
 235         display("    Initial time", t);
 236         display("    DB Val", min2time(dbval));
 237 }
 238
 239 int main()
 240 {
 241         struct tm start;
 242         time_t t;
 243
 244         // set to Oct 4, 2005, 2pm;
 245         start.tm_sec = 0;
 246         start.tm_min = 0;
 247         start.tm_hour = 14;
 248         start.tm_mday = 4;
 249         start.tm_mon = 9;
 250         start.tm_year = 105;
 251         start.tm_isdst = -1;
 252         t = mktime(&start);
 253         calc("Oct 4", t, 0x0350c118);
 254
 255         // comparison
 256         t = time(NULL);
 257         min1900_t m = time2min(t);
 258         time_t tc = min2time(m);
 259         cout << "Original time: " << t << endl;
 260         cout << "time2min:      " << m << endl;
 261         cout << "min2time:      " << tc << endl;
 262         if( t == (tc + t % 60) )
 263                 cout << "Success! (orig == converted + mod)" << endl;
 264         else
 265                 cout << "Failed!" << endl;
 266
 267         // time zone
 268         cout << "Should say Eastern: " << GetTimeZone(0x23)->Name << endl;
 269         cout << "should say Unknown: " << GetTimeZone(0xffff)->Name << endl;
 270 }
 271
 272 #endif
 273