src/local_time.cc

   1 /*
   2     Copyright (C) 2014-2019 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34 /** @file  src/local_time.cc
  35  *  @brief LocalTime class.
  36  */
  37
  38 #include "local_time.h"
  39 #include "exceptions.h"
  40 #include "dcp_assert.h"
  41 #include <boost/lexical_cast.hpp>
  42 #include <boost/date_time/c_local_time_adjustor.hpp>
  43 #include <cstdio>
  44
  45 using std::string;
  46 using std::ostream;
  47 using boost::lexical_cast;
  48 using namespace dcp;
  49
  50 /** Construct a LocalTime from the current time */
  51 LocalTime::LocalTime ()
  52 {
  53         time_t now = time (0);
  54         struct tm* tm = localtime (&now);
  55
  56         _year = tm->tm_year + 1900;
  57         _month = tm->tm_mon + 1;
  58         _day = tm->tm_mday;
  59         _hour = tm->tm_hour;
  60         _minute = tm->tm_min;
  61         _second = tm->tm_sec;
  62         _millisecond = 0;
  63
  64         set_local_time_zone ();
  65 }
  66
  67 /** Construct a LocalTime from a boost::posix_time::ptime using the local
  68  *  time zone.
  69  */
  70 LocalTime::LocalTime (boost::posix_time::ptime t)
  71 {
  72         _year = t.date().year ();
  73         _month = t.date().month ();
  74         _day = t.date().day ();
  75         _hour = t.time_of_day().hours ();
  76         _minute = t.time_of_day().minutes ();
  77         _second = t.time_of_day().seconds ();
  78         _millisecond = t.time_of_day().fractional_seconds () / 1000;
  79         DCP_ASSERT (_millisecond < 1000);
  80
  81         set_local_time_zone ();
  82 }
  83
  84 /** Construct a LocalTime from a boost::posix_time::ptime and a time zone offset.
  85  *  @param tz_minute Offset from UTC in minutes; if the timezone is behind UTC this may be negative,
  86  *  e.g. -04:30 would have tz_hour=-1 and tz_minute=-30.
  87  */
  88 LocalTime::LocalTime (boost::posix_time::ptime t, int tz_hour, int tz_minute)
  89 {
  90         _year = t.date().year ();
  91         _month = t.date().month ();
  92         _day = t.date().day ();
  93         _hour = t.time_of_day().hours ();
  94         _minute = t.time_of_day().minutes ();
  95         _second = t.time_of_day().seconds ();
  96         _millisecond = t.time_of_day().fractional_seconds () / 1000;
  97         DCP_ASSERT (_millisecond < 1000);
  98
  99         _tz_hour = tz_hour;
 100         _tz_minute = tz_minute;
 101 }
 102
 103 /** Set our UTC offset to be according to the local time zone */
 104 void
 105 LocalTime::set_local_time_zone ()
 106 {
 107         boost::posix_time::ptime const utc_now = boost::posix_time::second_clock::universal_time ();
 108         boost::posix_time::ptime const now = boost::date_time::c_local_adjustor<boost::posix_time::ptime>::utc_to_local (utc_now);
 109         boost::posix_time::time_duration offset = now - utc_now;
 110
 111         _tz_hour = offset.hours ();
 112         _tz_minute = offset.minutes ();
 113 }
 114
 115 /** @param s A string of the form 2013-01-05T18:06:59[.123][+04:00] */
 116 LocalTime::LocalTime (string s)
 117 {
 118         /* 2013-01-05T18:06:59 or 2013-01-05T18:06:59.123 or 2013-01-05T18:06:59+04:00 or 2013-01-05T18:06:59.123+04:00 */
 119         /* 0123456789012345678 or 01234567890123456789012 or 0123456789012345678901234 or 01234567890123456789012345678 */
 120
 121         if (s.length() < 19) {
 122                 throw TimeFormatError (s);
 123         }
 124
 125         bool with_millisecond = false;
 126         bool with_tz = false;
 127
 128         switch (s.length ()) {
 129         case 19:
 130                 break;
 131         case 23:
 132                 with_millisecond = true;
 133                 break;
 134         case 25:
 135                 with_tz = true;
 136                 break;
 137         case 29:
 138                 with_millisecond = with_tz = true;
 139                 break;
 140         default:
 141                 throw TimeFormatError (s);
 142         }
 143
 144         int const tz_pos = with_millisecond ? 23 : 19;
 145
 146         /* Check incidental characters */
 147         if (s[4] != '-' || s[7] != '-' || s[10] != 'T' || s[13] != ':' || s[16] != ':') {
 148                 throw TimeFormatError (s);
 149         }
 150         if (with_millisecond && s[19] != '.') {
 151                 throw TimeFormatError (s);
 152         }
 153         if (with_tz && s[tz_pos] != '+' && s[tz_pos] != '-') {
 154                 throw TimeFormatError (s);
 155         }
 156
 157         _year = lexical_cast<int> (s.substr (0, 4));
 158         _month = lexical_cast<int> (s.substr (5, 2));
 159         _day = lexical_cast<int> (s.substr (8, 2));
 160         _hour = lexical_cast<int> (s.substr (11, 2));
 161         _minute = lexical_cast<int> (s.substr (14, 2));
 162         _second = lexical_cast<int> (s.substr (17, 2));
 163         _millisecond = with_millisecond ? lexical_cast<int> (s.substr (20, 3)) : 0;
 164         _tz_hour = with_tz ? lexical_cast<int> (s.substr (tz_pos + 1, 2)) : 0;
 165         _tz_minute = with_tz ? lexical_cast<int> (s.substr (tz_pos + 4, 2)) : 0;
 166
 167         if (with_tz && s[tz_pos] == '-') {
 168                 _tz_hour = -_tz_hour;
 169                 _tz_minute = -_tz_minute;
 170         }
 171 }
 172
 173 /** @return A string of the form 2013-01-05T18:06:59+04:00 or 2013-01-05T18:06:59.123+04:00 */
 174 string
 175 LocalTime::as_string (bool with_millisecond) const
 176 {
 177         char buffer[32];
 178         snprintf (
 179                 buffer, sizeof (buffer),
 180                 "%sT%s%s%02d:%02d",
 181                 date().c_str(), time_of_day(true, with_millisecond).c_str(), (_tz_hour >= 0 ? "+" : "-"), abs (_tz_hour), abs(_tz_minute)
 182                 );
 183         return buffer;
 184 }
 185
 186 /** @return The date in the form YYYY-MM-DD */
 187 string
 188 LocalTime::date () const
 189 {
 190         char buffer[32];
 191         snprintf (buffer, sizeof (buffer), "%04d-%02d-%02d", _year, _month, _day);
 192         return buffer;
 193 }
 194
 195 /** @return The time in the form HH:MM:SS or HH:MM:SS.mmm */
 196 string
 197 LocalTime::time_of_day (bool with_second, bool with_millisecond) const
 198 {
 199         char buffer[32];
 200         DCP_ASSERT(!(with_millisecond && !with_second));
 201         if (with_millisecond) {
 202                 snprintf (buffer, sizeof (buffer), "%02d:%02d:%02d.%03d", _hour, _minute, _second, _millisecond);
 203         } else if (with_second) {
 204                 snprintf (buffer, sizeof (buffer), "%02d:%02d:%02d", _hour, _minute, _second);
 205         } else {
 206                 snprintf (buffer, sizeof (buffer), "%02d:%02d", _hour, _minute);
 207         }
 208         return buffer;
 209 }
 210
 211 bool
 212 LocalTime::operator== (LocalTime const & other) const
 213 {
 214         return _year == other._year && _month == other._month && _day == other._day &&
 215                 _hour == other._hour && _second == other._second && _millisecond == other._millisecond &&
 216                 _tz_hour == other._tz_hour && _tz_minute == other._tz_minute;
 217 }
 218
 219 bool
 220 LocalTime::operator< (LocalTime const & other) const
 221 {
 222         if (_year != other._year) {
 223                 return _year < other._year;
 224         }
 225         if (_month != other._month) {
 226                 return _month < other._month;
 227         }
 228         if (_day != other._day) {
 229                 return _day < other._day;
 230         }
 231         if (_hour != other._hour) {
 232                 return _hour < other._hour;
 233         }
 234         if (_second != other._second) {
 235                 return _second < other._second;
 236         }
 237         return _millisecond < other._millisecond;
 238 }
 239
 240 bool
 241 LocalTime::operator!= (LocalTime const & other) const
 242 {
 243         return !(*this == other);
 244 }
 245
 246 ostream&
 247 dcp::operator<< (ostream& s, LocalTime const & t)
 248 {
 249         s << t.as_string ();
 250         return s;
 251 }