sol/date_time/duration.hpp

   1 #if !defined(sol_date_time_duration_hpp_included)
   2 #define sol_date_time_duration_hpp_included
   3 /// \addtogroup sol_date_time
   4 /// \{
   5
   6
   7 /**
   8  * \file sol/date_time/duration.hpp
   9  * \brief Length of time unattached to a any time point.
  10  * \author Sven Suursoho
  11  */
  12
  13
  14 namespace sol { namespace date_time {
  15
  16
  17 /// Common duration type, ancestor class for more specific duration
  18 template <
  19     typename FinalType
  20     , typename TickType
  21     , int TicksPerSecond
  22     , int SecondsPerTick
  23 >
  24 class duration_type
  25 {
  26 public:
  27
  28     /// Count type at the resolution of duration type
  29     typedef TickType tick_type;
  30
  31
  32     /// Number of ticks per second
  33     static tick_type const ticks_per_second = TicksPerSecond;
  34
  35
  36     /// Number of seconds per tick
  37     static tick_type const seconds_per_tick = SecondsPerTick;
  38
  39
  40     /// True if resolution is less than 1 second
  41     static bool const is_subsecond = TicksPerSecond > SecondsPerTick;
  42
  43
  44     /// \internal Helper type definition
  45     typedef duration_type<
  46         FinalType, TickType, TicksPerSecond, SecondsPerTick
  47     > this_type;
  48
  49
  50     /// Construct duration object (defaulting to count of 0)
  51     duration_type (tick_type d = 0)
  52         : count_(d)
  53     {}
  54
  55
  56     /// Return the count at the resolution of the time duration type
  57     tick_type
  58     get_count () const
  59     {
  60         return count_;
  61     }
  62
  63
  64     /// Return this + that
  65     FinalType
  66     operator+ (FinalType const &that) const
  67     {
  68         return FinalType(count_ + that.count_);
  69     }
  70
  71
  72     /// Return this += that
  73     FinalType &
  74     operator+= (FinalType const &that)
  75     {
  76         count_ += that.count_;
  77         return *static_cast<FinalType *>(this);
  78     }
  79
  80
  81     /// Return this - that
  82     FinalType
  83     operator- (FinalType const &that) const
  84     {
  85         return FinalType(count_ - that.count_);
  86     }
  87
  88
  89     /// Return this -= that
  90     FinalType &
  91     operator-= (FinalType const &that)
  92     {
  93         count_ -= that.count_;
  94         return *static_cast<FinalType *>(this);
  95     }
  96
  97
  98     /// Return this/divisor
  99     FinalType
 100     operator/ (int divisor) const
 101     {
 102         return FinalType(count_/divisor);
 103     }
 104
 105
 106     /// Return this/=divisor
 107     FinalType &
 108     operator/= (int divisor)
 109     {
 110         count_ /= divisor;
 111         return *static_cast<FinalType *>(this);
 112     }
 113
 114
 115     /// Return this*divisor
 116     FinalType
 117     operator* (int multiplier) const
 118     {
 119         return FinalType(count_*multiplier);
 120     }
 121
 122
 123     /// Return this*=divisor
 124     FinalType &
 125     operator*= (int multiplier)
 126     {
 127         count_ *= multiplier;
 128         return *static_cast<FinalType *>(this);
 129     }
 130
 131
 132     /// Return negate of this
 133     FinalType
 134     operator- () const
 135     {
 136         return FinalType(-count_);
 137     }
 138
 139
 140     /// Return true if this == that
 141     bool
 142     operator== (this_type const &that) const
 143     {
 144         return count_ == that.count_;
 145     }
 146
 147
 148     /// Return true if this != that
 149     bool
 150     operator!= (this_type const &that) const
 151     {
 152         return count_ != that.count_;
 153     }
 154
 155
 156     /// Return true if this > that
 157     bool
 158     operator> (this_type const &that) const
 159     {
 160         return count_ > that.count_;
 161     }
 162
 163
 164     /// Return true if this >= that
 165     bool
 166     operator>= (this_type const &that) const
 167     {
 168         return count_ >= that.count_;
 169     }
 170
 171
 172     /// Return true if this < that
 173     bool
 174     operator< (this_type const &that) const
 175     {
 176         return count_ < that.count_;
 177     }
 178
 179
 180     /// Return true if this <= that
 181     bool
 182     operator<= (this_type const &that) const
 183     {
 184         return count_ <= that.count_;
 185     }
 186
 187
 188 protected:
 189
 190     tick_type count_;
 191 };
 192
 193
 194 /// Duration in nanoseconds
 195 class nanoseconds
 196     : public duration_type<nanoseconds, long long, 1000000000, 0>
 197 {
 198 public:
 199
 200     nanoseconds (tick_type d = 0)
 201         : this_type(d)
 202     {}
 203 };
 204
 205
 206 /// Duration in microseconds
 207 class microseconds
 208     : public duration_type<microseconds, long long, 1000000, 0>
 209 {
 210 public:
 211
 212     microseconds (tick_type d = 0)
 213         : this_type(d)
 214     {}
 215
 216
 217     operator nanoseconds () const
 218     {
 219         return count_*(nanoseconds::ticks_per_second/ticks_per_second);
 220     }
 221 };
 222
 223
 224 /// Duration in milliseconds
 225 class milliseconds
 226     : public duration_type<milliseconds, long long, 1000, 0>
 227 {
 228 public:
 229
 230     milliseconds (tick_type d = 0)
 231         : this_type(d)
 232     {}
 233
 234
 235     operator nanoseconds () const
 236     {
 237         return count_*(nanoseconds::ticks_per_second/ticks_per_second);
 238     }
 239
 240
 241     operator microseconds () const
 242     {
 243         return count_*(microseconds::ticks_per_second/ticks_per_second);
 244     }
 245 };
 246
 247
 248 /// Duration in seconds
 249 class seconds
 250     : public duration_type<seconds, long long, 1, 1>
 251 {
 252 public:
 253
 254     seconds (tick_type d = 0)
 255         : this_type(d)
 256     {}
 257
 258
 259     operator nanoseconds () const
 260     {
 261         return count_*(nanoseconds::ticks_per_second/ticks_per_second);
 262     }
 263
 264
 265     operator microseconds () const
 266     {
 267         return count_*(microseconds::ticks_per_second/ticks_per_second);
 268     }
 269
 270
 271     operator milliseconds () const
 272     {
 273         return count_*(milliseconds::ticks_per_second/ticks_per_second);
 274     }
 275 };
 276
 277
 278 /// Duration in minutes
 279 class minutes
 280     : public duration_type<minutes, long long, 0, 60>
 281 {
 282 public:
 283
 284     minutes (tick_type d = 0): this_type(d)
 285     {}
 286
 287
 288     operator nanoseconds () const
 289     {
 290         return count_*seconds_per_tick*nanoseconds::ticks_per_second;
 291     }
 292
 293
 294     operator microseconds () const
 295     {
 296         return count_*seconds_per_tick*microseconds::ticks_per_second;
 297     }
 298
 299
 300     operator milliseconds () const
 301     {
 302         return count_*seconds_per_tick*milliseconds::ticks_per_second;
 303     }
 304
 305
 306     operator seconds () const
 307     {
 308         return count_*seconds_per_tick;
 309     }
 310 };
 311
 312
 313 /// Duration in hours
 314 class hours
 315     : public duration_type<hours, long long, 0, 3600>
 316 {
 317 public:
 318
 319     hours (tick_type d = 0)
 320         : this_type(d)
 321     {}
 322
 323
 324     operator nanoseconds () const
 325     {
 326         return count_*seconds_per_tick*nanoseconds::ticks_per_second;
 327     }
 328
 329
 330     operator microseconds () const
 331     {
 332         return count_*seconds_per_tick*microseconds::ticks_per_second;
 333     }
 334
 335
 336     operator milliseconds () const
 337     {
 338         return count_*seconds_per_tick*milliseconds::ticks_per_second;
 339     }
 340
 341
 342     operator seconds () const
 343     {
 344         return count_*seconds_per_tick;
 345     }
 346
 347
 348     operator minutes () const
 349     {
 350         return count_*(seconds_per_tick/minutes::seconds_per_tick);
 351     }
 352 };
 353
 354
 355 }}  // namespace sol::date_time
 356
 357
 358 /// \}
 359 #endif  // sol_date_time_duration_hpp_included