src/r_timezone.cc

   1 ///
   2 /// \file       r_timezone.cc
   3 ///             Record parsing class for the timezone database.
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2012, Net Direct Inc. (http://www.netdirect.ca/)
   8     Copyright (C) 2008, Brian Edginton
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include "r_timezone.h"
  24 #include "record-internal.h"
  25 #include "protostructs.h"
  26 #include "data.h"
  27 #include "time.h"
  28 #include "iconv.h"
  29 #include "debug.h"
  30 #include <iostream>
  31 #include <sstream>
  32 #include <iomanip>
  33 #include "ios_state.h"
  34 #include <algorithm>
  35 #include "m_desktop.h"
  36
  37 using namespace std;
  38 using namespace Barry::Protocol;
  39
  40 namespace Barry
  41 {
  42
  43 ///////////////////////////////////////////////////////////////////////////////
  44 // TimeZone Class
  45
  46 // TimeZone Field Codes
  47 #define TZFC_INDEX              0x01
  48 #define TZFC_NAME               0x02
  49 #define TZFC_OFFSET             0x03
  50 #define TZFC_DST                0x04
  51 #define TZFC_STARTMONTH         0x06
  52 #define TZFC_ENDMONTH           0x0B
  53 #define TZFC_TZTYPE             0x64
  54
  55 #define TZFC_END                0xffff
  56
  57 static FieldLink<TimeZone> TimeZoneFieldLinks[] = {
  58    { TZFC_NAME,   "Name",        0, 0, &TimeZone::Name, 0, 0, 0, 0, true },
  59    { TZFC_END,    "End of List", 0, 0, 0, 0, 0, 0, 0, false },
  60 };
  61
  62 TimeZone::TimeZone()
  63 {
  64         Clear();
  65 }
  66
  67 TimeZone::TimeZone(int utc_offset)
  68 {
  69         Clear();
  70
  71         UTCOffset = utc_offset;
  72 }
  73
  74 TimeZone::TimeZone(int hours, int minutes)
  75 {
  76         Clear();
  77
  78         // make sure that minutes are always positive, for our logic
  79         if( minutes < 0 )
  80                 minutes = -minutes;
  81
  82         // calculate offset in total minutes
  83         UTCOffset = hours * 60;
  84         if( hours < 0 )
  85                 UTCOffset -= minutes;
  86         else
  87                 UTCOffset += minutes;
  88 }
  89
  90 TimeZone::~TimeZone()
  91 {
  92 }
  93
  94 const unsigned char* TimeZone::ParseField(const unsigned char *begin,
  95                                           const unsigned char *end,
  96                                           const IConverter *ic)
  97 {
  98         const CommonField *field = (const CommonField *) begin;
  99
 100         // advance and check size
 101         begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
 102         if( begin > end )       // if begin==end, we are ok
 103                 return begin;
 104
 105         if( !btohs(field->size) )   // if field has no size, something's up
 106                 return begin;
 107
 108         if( field->type == TZFC_TZTYPE ) {
 109                 if( ( TZType = field->u.uint32 ) != 1 ) {
 110                         throw Error("TimeZone::ParseField: TimeZone Type is not valid");
 111                 }
 112                 return begin;
 113         }
 114
 115         // cycle through the type table
 116         for(    FieldLink<TimeZone> *b = TimeZoneFieldLinks;
 117                 b->type != TZFC_END;
 118                 b++ )
 119         {
 120                 if( b->type == field->type ) {
 121                         if( b->strMember ) {
 122                                 std::string &s = this->*(b->strMember);
 123                                 s = ParseFieldString(field);
 124                                 if( b->iconvNeeded && ic )
 125                                         s = ic->FromBB(s);
 126                                 return begin;   // done!
 127                         }
 128                 }
 129         }
 130
 131         switch( field->type )
 132         {
 133         case TZFC_INDEX:
 134                 Index = btohl(field->u.uint32);
 135                 return begin;
 136
 137         case TZFC_OFFSET:
 138                 UTCOffset = btohs(field->u.int16);
 139                 return begin;
 140
 141         case TZFC_DST:
 142                 DSTOffset = btohl(field->u.uint32);
 143                 if (DSTOffset) {
 144                         UseDST = true;
 145                 }
 146                 return begin;
 147
 148         case TZFC_STARTMONTH:
 149                 StartMonth = btohl(field->u.uint32);
 150                 return begin;
 151
 152         case TZFC_ENDMONTH:
 153                 EndMonth = btohl(field->u.uint32);
 154                 return begin;
 155         }
 156
 157         // if still not handled, add to the Unknowns list
 158         UnknownField uf;
 159         uf.type = field->type;
 160         uf.data.assign((const char*)field->u.raw, btohs(field->size));
 161         Unknowns.push_back(uf);
 162
 163         // return new pointer for next field
 164         return begin;
 165 }
 166
 167 void TimeZone::ParseHeader(const Data &data, size_t &offset)
 168 {
 169         // no header in Task records
 170 }
 171
 172 void TimeZone::ParseFields(const Data &data, size_t &offset, const IConverter *ic)
 173 {
 174         const unsigned char *finish = ParseCommonFields(*this,
 175                 data.GetData() + offset, data.GetData() + data.GetSize(), ic);
 176         offset += finish - (data.GetData() + offset);
 177 }
 178
 179 void TimeZone::Validate() const
 180 {
 181 }
 182
 183 void TimeZone::BuildHeader(Data &data, size_t &offset) const
 184 {
 185         // not yet implemented
 186 }
 187
 188 void TimeZone::BuildFields(Data &data, size_t &offset, const IConverter *ic) const
 189 {
 190         // not yet implemented
 191 }
 192
 193 void TimeZone::Clear()
 194 {
 195         RecType = GetDefaultRecType();
 196         RecordId = 0;
 197
 198         Name.clear();
 199         Index = 0;
 200         UTCOffset = 0;
 201
 202         UseDST = false;
 203         DSTOffset = 0;
 204         StartMonth = -1;
 205         EndMonth = -1;
 206
 207         TZType = 0;
 208
 209         Unknowns.clear();
 210 }
 211
 212 const FieldHandle<TimeZone>::ListT& TimeZone::GetFieldHandles()
 213 {
 214         static FieldHandle<TimeZone>::ListT fhv;
 215
 216         if( fhv.size() )
 217                 return fhv;
 218
 219 #undef CONTAINER_OBJECT_NAME
 220 #define CONTAINER_OBJECT_NAME fhv
 221
 222 #undef RECORD_CLASS_NAME
 223 #define RECORD_CLASS_NAME TimeZone
 224
 225         FHP(RecType, "Record Type Code");
 226         FHP(RecordId, "Unique Record ID");
 227
 228         FHD(Name, "TimeZone Name", TZFC_NAME, true);
 229         FHD(Index, "Index", TZFC_INDEX, false);
 230         FHD(UTCOffset, "TimeZone Offset in Minutes", TZFC_OFFSET, false);
 231         FHD(UseDST, "Use DST?", TZFC_DST, false);
 232         FHD(DSTOffset, "DST Offset", TZFC_DST, false);
 233         FHD(StartMonth, "Start Month", TZFC_STARTMONTH, false);
 234         FHD(EndMonth, "End Month", TZFC_ENDMONTH, false);
 235         FHD(TZType, "TimeZone Type", TZFC_TZTYPE, false);
 236
 237         FHP(Unknowns, "Unknown Fields");
 238
 239         return fhv;
 240 }
 241
 242 std::string TimeZone::GetDescription() const
 243 {
 244         ostringstream oss;
 245         oss << Name <<
 246                 " (" << (UTCOffset > 0 ? "+" : "")
 247                 << dec << (UTCOffset / 60.0) << ")";
 248         return oss.str();
 249 }
 250
 251 void TimeZone::Dump(std::ostream &os) const
 252 {
 253         ios_format_state state(os);
 254
 255         static const char *month[] = {
 256                         "Jan", "Feb", "Mar", "Apr", "May",
 257                         "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 258         };
 259
 260         os << "TimeZone entry: 0x" << setbase(16) << RecordId
 261            << " (" << (unsigned int)RecType << ")\n";
 262
 263         // cycle through the type table
 264         for(    const FieldLink<TimeZone> *b = TimeZoneFieldLinks;
 265                 b->type != TZFC_END;
 266                 b++ )
 267         {
 268                 if( b->strMember ) {
 269                         const std::string &s = this->*(b->strMember);
 270                         if( s.size() )
 271                                 os << "       " << b->name << ": " << s << "\n";
 272                 }
 273         }
 274
 275         int hours, minutes;
 276         Split(&hours, &minutes);
 277
 278         os << "       Desc: " << GetDescription() << "\n";
 279         os << "      Index: 0x" <<setw(2) << Index << "\n";
 280         os << "       Type: 0x" <<setw(2) << (unsigned int)TZType << "\n";
 281         os << "     Offset: " << setbase(10) << UTCOffset << " minutes ("
 282                 << dec << (UTCOffset / 60.0) << ")\n";
 283         os << "            Split Offset: hours: "
 284                 << dec << hours << ", minutes: " << minutes << "\n";
 285         os << "  Sample TZ: " << GetTz("E") << "\n";
 286         os << "    Use DST: " << (UseDST ? "true" : "false") << "\n";
 287         if (UseDST) {
 288                 os << " DST Offset: " << setbase(10) << DSTOffset << "\n";
 289                 if ((StartMonth > 0) && (StartMonth < 11))
 290                                 os << "Start Month: " << month[StartMonth] << "\n";
 291                 else
 292                                 os << "Start Month: unknown (" << setbase(10) << StartMonth << ")\n";
 293                 if ((EndMonth > 0) && (EndMonth < 11))
 294                         os << "  End Month: " << month[EndMonth] << "\n";
 295                 else
 296                         os << "  End Month: unknown (" << setbase(10) << EndMonth << ")\n";
 297         }
 298
 299         os << Unknowns;
 300         os << "\n\n";
 301 }
 302
 303
 304 void TimeZone::Split(int *hours, int *minutes) const
 305 {
 306         *hours = UTCOffset / 60;
 307         *minutes = UTCOffset % 60;
 308         if( *minutes < 0 )
 309                 *minutes = -*minutes;
 310 }
 311
 312 void TimeZone::SplitAbsolute(bool *west,
 313                                 unsigned int *hours,
 314                                 unsigned int *minutes) const
 315 {
 316         int tmphours, tmpminutes;
 317         Split(&tmphours, &tmpminutes);
 318
 319         if( tmphours < 0 ) {
 320                 *west = true;
 321                 tmphours = -tmphours;
 322         }
 323         else {
 324                 *west = false;
 325         }
 326
 327         *hours = tmphours;
 328         *minutes = tmpminutes;
 329 }
 330
 331 std::string TimeZone::GetTz(const std::string &prefix) const
 332 {
 333         int hours, minutes;
 334         Split(&hours, &minutes);
 335
 336         // TZ variable uses positive for west, and negative for east,
 337         // so swap the hour value.  Minutes is always positive for
 338         // our purposes, so leave it alone.
 339         hours = -hours;
 340
 341         // standard time first
 342         ostringstream oss;
 343         oss << prefix << "ST"
 344                 << hours << ":"
 345                 << setfill('0') << setw(2) << minutes
 346                 << ":00";
 347
 348         // daylight saving time next, if available
 349         if( UseDST ) {
 350                 TimeZone dst(UTCOffset + DSTOffset);
 351
 352                 dst.Split(&hours, &minutes);
 353
 354                 // swap again for TZ semantics...
 355                 hours = -hours;
 356
 357                 oss << prefix << "DT"
 358                         << hours << ":"
 359                         << setfill('0') << setw(2) << minutes
 360                         << ":00";
 361
 362                 // assume second Sunday of start month to first Sunday of
 363                 // end month, since we don't have enough data to be more
 364                 // precise
 365                 oss << ",M" << (StartMonth + 1) << ".2.0";
 366                 oss << ",M" << (EndMonth + 1) << ".1.0";
 367         }
 368
 369         return oss.str();
 370 }
 371
 372
 373 ///////////////////////////////////////////////////////////////////////////////
 374 // TimeZones Class
 375
 376 TimeZones::TimeZones()
 377 {
 378         const StaticTimeZone *zones = GetStaticTimeZoneTable();
 379         for( ; zones->Name; zones++ ) {
 380                 TimeZone tz(zones->HourOffset, zones->MinOffset);
 381                 tz.Index = zones->Code;
 382                 tz.Name = zones->Name;
 383                 m_list.push_back(tz);
 384         }
 385
 386         sort(begin(), end(), &TimeZone::SortByZone);
 387 }
 388
 389 struct TimeZoneStore
 390 {
 391         TimeZones::ListType &m_list;
 392
 393         TimeZoneStore(TimeZones::ListType &list) : m_list(list)
 394         {
 395         }
 396
 397         void operator()(const TimeZone &rec)
 398         {
 399                 m_list.push_back(rec);
 400         }
 401 };
 402
 403 TimeZones::TimeZones(Barry::Mode::Desktop &desktop)
 404 {
 405         unsigned int dbId = desktop.GetDBID( TimeZone::GetDBName() );
 406         TimeZoneStore store(m_list);
 407         RecordParser<TimeZone, TimeZoneStore> parser(store);
 408
 409         desktop.LoadDatabase(dbId, parser);
 410
 411         sort(begin(), end(), &TimeZone::SortByZone);
 412 }
 413
 414 bool TimeZones::IsLoadable(Barry::Mode::Desktop &desktop)
 415 {
 416         unsigned int num;
 417         return desktop.GetDBDB().GetDBNumber(TimeZone::GetDBName(), num);
 418 }
 419
 420 TimeZones::iterator TimeZones::Find(int index)
 421 {
 422         for( iterator i = begin(), e = end(); i != e; ++i )
 423                 if( i->Index == index )
 424                         return i;
 425         return end();
 426 }
 427
 428 TimeZones::const_iterator TimeZones::Find(int index) const
 429 {
 430         return const_cast<TimeZones*>(this)->Find(index);
 431 }
 432
 433 TimeZones::iterator TimeZones::FindByOffset(int utc_offset)
 434 {
 435         for( iterator i = begin(), e = end(); i != e; ++i )
 436                 if( i->UTCOffset == utc_offset )
 437                         return i;
 438         return end();
 439 }
 440
 441 TimeZones::const_iterator TimeZones::FindByOffset(int utc_offset) const
 442 {
 443         return const_cast<TimeZones*>(this)->FindByOffset(utc_offset);
 444 }
 445
 446 void TimeZones::Dump(std::ostream &os) const
 447 {
 448         const_iterator b = begin(), e = end();
 449         for( ; b != e; ++b ) {
 450                 os << *b << endl;
 451         }
 452 }
 453
 454 } // namespace Barry
 455