chrono.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <chrono>
#include <limits>
 
#include <userver/storages/postgres/io/buffer_io.hpp>
#include <userver/storages/postgres/io/buffer_io_base.hpp>
#include <userver/storages/postgres/io/interval.hpp>
#include <userver/storages/postgres/io/transform_io.hpp>
#include <userver/storages/postgres/io/type_mapping.hpp>
#include <userver/utils/strong_typedef.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres {
 
using ClockType = std::chrono::system_clock;
 
using TimePoint = ClockType::time_point;
 
using TimePointTz = USERVER_NAMESPACE::utils::StrongTypedef<
    struct TimestampWithTz, TimePoint,
    USERVER_NAMESPACE::utils::StrongTypedefOps::kCompareTransparent>;
using IntervalType = std::chrono::microseconds;
 
TimePoint PostgresEpochTimePoint();
 
inline constexpr TimePoint kTimestampPositiveInfinity = TimePoint::max();
inline constexpr TimePoint kTimestampNegativeInfinity = TimePoint::min();
 
namespace io {
 
template <typename Duration>
struct BufferFormatter<std::chrono::time_point<ClockType, Duration>> {
  using ValueType = std::chrono::time_point<ClockType, Duration>;
 
  const ValueType value;
 
  explicit BufferFormatter(ValueType val) : value{val} {}
 
  template <typename Buffer>
  void operator()(const UserTypes& types, Buffer& buf) const {
    static const ValueType pg_epoch =
        std::chrono::time_point_cast<Duration>(PostgresEpochTimePoint());
    if (value == kTimestampPositiveInfinity) {
      WriteBuffer(types, buf, std::numeric_limits<Bigint>::max());
    } else if (value == kTimestampNegativeInfinity) {
      WriteBuffer(types, buf, std::numeric_limits<Bigint>::min());
    } else {
      auto tmp = std::chrono::duration_cast<std::chrono::microseconds>(value -
                                                                       pg_epoch)
                     .count();
      WriteBuffer(types, buf, tmp);
    }
  }
};
 
template <typename Duration>
struct BufferParser<std::chrono::time_point<ClockType, Duration>>
    : detail::BufferParserBase<std::chrono::time_point<ClockType, Duration>> {
  using BaseType =
      detail::BufferParserBase<std::chrono::time_point<ClockType, Duration>>;
  using ValueType = typename BaseType::ValueType;
  using BaseType::BaseType;
 
  void operator()(const FieldBuffer& buffer) {
    static const ValueType pg_epoch =
        std::chrono::time_point_cast<Duration>(PostgresEpochTimePoint());
    Bigint usec{0};
    ReadBuffer(buffer, usec);
    if (usec == std::numeric_limits<Bigint>::max()) {
      this->value = kTimestampPositiveInfinity;
    } else if (usec == std::numeric_limits<Bigint>::min()) {
      this->value = kTimestampNegativeInfinity;
    } else {
      ValueType tmp = pg_epoch + std::chrono::microseconds{usec};
      std::swap(tmp, this->value);
    }
  }
};
 
namespace detail {
 
template <typename Rep, typename Period>
struct DurationIntervalCvt {
  using UserType = std::chrono::duration<Rep, Period>;
  UserType operator()(const Interval& wire_val) const {
    return std::chrono::duration_cast<UserType>(wire_val.GetDuration());
  }
  Interval operator()(const UserType& user_val) const {
    return Interval{std::chrono::duration_cast<IntervalType>(user_val)};
  }
};
 
}  // namespace detail
 
namespace traits {
 
template <typename Rep, typename Period>
struct Output<std::chrono::duration<Rep, Period>> {
  using type = TransformFormatter<std::chrono::duration<Rep, Period>,
                                  io::detail::Interval,
                                  io::detail::DurationIntervalCvt<Rep, Period>>;
};
 
template <typename Rep, typename Period>
struct Input<std::chrono::duration<Rep, Period>> {
  using type =
      TransformParser<std::chrono::duration<Rep, Period>, io::detail::Interval,
                      io::detail::DurationIntervalCvt<Rep, Period>>;
};
 
}  // namespace traits
 
template <>
struct CppToSystemPg<TimePointTz>
    : PredefinedOid<PredefinedOids::kTimestamptz> {};
 
template <typename Duration>
struct CppToSystemPg<std::chrono::time_point<ClockType, Duration>>
    : PredefinedOid<PredefinedOids::kTimestamp> {};
 
template <typename Rep, typename Period>
struct CppToSystemPg<std::chrono::duration<Rep, Period>>
    : PredefinedOid<PredefinedOids::kInterval> {};
 
}  // namespace io
}  // namespace storages::postgres
 
USERVER_NAMESPACE_END