datetime.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/core/dll_import_export.hpp"
 
#include <chrono>
#include <ostream>
#include <string>
 
namespace Azure {
 
namespace _detail {
  class Clock final {
  public:
    using rep = int64_t;
    using period = std::ratio<1, 10000000>;
    using duration = std::chrono::duration<rep, period>;
    using time_point = std::chrono::time_point<Clock>;
 
    // since now() calls system_clock::now(), we have the same to say about the clock steadiness.
    // system_clock is not a steady clock. It is calendar-based, which means it can be adjusted,
    // and it may go backwards in time after adjustments, or jump forward faster than the actual
    // time passes, if you catch the moment before and after syncing the clock.
    // Steady clock would be good for measuring elapsed time without reboots (or hibernation?).
    // Steady clock's epoch = boot time, and it would only go forward in steady fashion, after the
    // system has started.
    // Using this clock in combination with system_clock is common scenario.
    // It would not be possible to base this clock on steady_clock and provide an implementation
    // that universally works in any context in predictable manner. However, it does not mean that
    // implementation can't use steady_clock in conjunction with this clock: an author can get a
    // duration between two time_points of this clock (or between system_clock::time point at
    // this clock's time_point), and add that duration to steady clock's time_point to get a new
    // time_point in the steady clock's "coordinate system".
    static constexpr bool is_steady = std::chrono::system_clock::is_steady;
    static time_point now();
  };
} // namespace _detail
 
class DateTime final : public _detail::Clock::time_point {
 
private:
  AZ_CORE_DLLEXPORT static DateTime const SystemClockEpoch;
 
  DateTime(
      int16_t year,
      int8_t month,
      int8_t day,
      int8_t hour,
      int8_t minute,
      int8_t second,
      int32_t fracSec,
      int8_t dayOfWeek,
      int8_t localDiffHours,
      int8_t localDiffMinutes,
      bool roundFracSecUp = false);
 
  void ThrowIfUnsupportedYear() const;
 
  void GetDateTimeParts(
      int16_t* year,
      int8_t* month,
      int8_t* day,
      int8_t* hour,
      int8_t* minute,
      int8_t* second,
      int32_t* fracSec,
      int8_t* dayOfWeek) const;
 
  std::string ToStringRfc1123() const;
 
public:
  constexpr DateTime() : time_point() {}
 
  explicit DateTime(
      int16_t year,
      int8_t month = 1,
      int8_t day = 1,
      int8_t hour = 0,
      int8_t minute = 0,
      int8_t second = 0)
      : DateTime(year, month, day, hour, minute, second, 0, -1, 0, 0)
  {
  }
 
  constexpr DateTime(time_point const& timePoint) : time_point(timePoint) {}
 
  DateTime(std::chrono::system_clock::time_point const& systemTime)
      : DateTime(
          SystemClockEpoch + std::chrono::duration_cast<duration>(systemTime.time_since_epoch()))
  {
  }
 
  explicit operator std::chrono::system_clock::time_point() const;
 
  enum class TimeFractionFormat
  {
    DropTrailingZeros,
 
    AllDigits,
 
    Truncate
  };
 
  enum class DateFormat
  {
    Rfc1123,
 
    Rfc3339,
  };
 
  static DateTime Parse(std::string const& dateTime, DateFormat format);
 
  std::string ToString(DateFormat format = DateFormat::Rfc3339) const;
 
  std::string ToString(DateFormat format, TimeFractionFormat fractionFormat) const;
};
 
inline _detail::Clock::time_point _detail::Clock::now()
{
  return DateTime(std::chrono::system_clock::now());
}
 
inline bool operator==(DateTime const& dt, std::chrono::system_clock::time_point const& tp)
{
  return dt == DateTime(tp);
}
 
inline bool operator<(DateTime const& dt, std::chrono::system_clock::time_point const& tp)
{
  return dt < DateTime(tp);
}
 
inline bool operator<=(DateTime const& dt, std::chrono::system_clock::time_point const& tp)
{
  return dt <= DateTime(tp);
}
 
inline bool operator!=(DateTime const& dt, std::chrono::system_clock::time_point const& tp)
{
  return !(dt == tp);
}
 
inline bool operator>(DateTime const& dt, std::chrono::system_clock::time_point const& tp)
{
  return !(dt <= tp);
}
 
inline bool operator>=(DateTime const& dt, std::chrono::system_clock::time_point const& tp)
{
  return !(dt < tp);
}
 
inline bool operator==(std::chrono::system_clock::time_point const& tp, DateTime const& dt)
{
  return dt == tp;
}
 
inline bool operator!=(std::chrono::system_clock::time_point const& tp, DateTime const& dt)
{
  return dt != tp;
}
 
inline bool operator<(std::chrono::system_clock::time_point const& tp, DateTime const& dt)
{
  return (dt > tp);
}
 
inline bool operator<=(std::chrono::system_clock::time_point const& tp, DateTime const& dt)
{
  return (dt >= tp);
}
 
inline bool operator>(std::chrono::system_clock::time_point const& tp, DateTime const& dt)
{
  return (dt < tp);
}
 
inline bool operator>=(std::chrono::system_clock::time_point const& tp, DateTime const& dt)
{
  return (dt <= tp);
}
 
namespace Core { namespace _internal {
  class PosixTimeConverter final {
  public:
    static DateTime PosixTimeToDateTime(int64_t posixTime)
    {
      return {DateTime(1970) + std::chrono::seconds(posixTime)};
    }
 
    static int64_t DateTimeToPosixTime(DateTime const& dateTime)
    {
      //  This count starts at the POSIX epoch which is January 1st, 1970 UTC.
      return std::chrono::duration_cast<std::chrono::seconds>(dateTime - DateTime(1970)).count();
    }
 
  private:
    PosixTimeConverter() = delete;
 
    ~PosixTimeConverter() = delete;
  };
}} // namespace Core::_internal
 
} // namespace Azure