date_time.hpp

Go to the documentation of this file.

// # This file is a part of toml++ and is subject to the the terms of the MIT license.
// # Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
// # See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
//  SPDX-License-Identifier: MIT
#pragma once
 
#include "forward_declarations.hpp"
#include "header_start.hpp"
#include "print_to_stream.hpp"
 
TOML_NAMESPACE_START {
  struct TOML_TRIVIAL_ABI date {
    uint16_t year;
 
    uint8_t month;
 
    uint8_t day;
 
    TOML_NODISCARD_CTOR
    date() noexcept = default;
 
    TOML_CONSTRAINED_TEMPLATE((impl::all_integral<Y, M, D>), typename Y, typename M, typename D)
    TOML_NODISCARD_CTOR
    constexpr date(Y y, M m, D d) noexcept  //
        : year{static_cast<uint16_t>(y)},
          month{static_cast<uint8_t>(m)},
          day{static_cast<uint8_t>(d)} {}
 
    TOML_PURE_GETTER
    friend constexpr bool operator==(const date& lhs, const date& rhs) noexcept {
      return lhs.year == rhs.year       //
             && lhs.month == rhs.month  //
             && lhs.day == rhs.day;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator!=(const date& lhs, const date& rhs) noexcept {
      return !(lhs == rhs);
    }
 
   private:
 
    TOML_PURE_GETTER
    static constexpr uint32_t pack(const date& d) noexcept {
      return (static_cast<uint32_t>(d.year) << 16) | (static_cast<uint32_t>(d.month) << 8) |
             static_cast<uint32_t>(d.day);
    }
 
 
   public:
    TOML_PURE_GETTER
    friend constexpr bool operator<(const date& lhs, const date& rhs) noexcept {
      return pack(lhs) < pack(rhs);
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator<=(const date& lhs, const date& rhs) noexcept {
      return pack(lhs) <= pack(rhs);
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator>(const date& lhs, const date& rhs) noexcept {
      return pack(lhs) > pack(rhs);
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator>=(const date& lhs, const date& rhs) noexcept {
      return pack(lhs) >= pack(rhs);
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, const date& rhs) {
      impl::print_to_stream(lhs, rhs);
      return lhs;
    }
  };
 
  struct TOML_TRIVIAL_ABI time {
    uint8_t hour;
 
    uint8_t minute;
 
    uint8_t second;
 
    uint32_t nanosecond;
 
    TOML_NODISCARD_CTOR
    time() noexcept = default;
 
    TOML_CONSTRAINED_TEMPLATE((impl::all_integral<H, M, S, NS>), typename H, typename M,
                              typename S = uint8_t, typename NS = uint32_t)
    TOML_NODISCARD_CTOR
    constexpr time(H h, M m, S s = S{}, NS ns = NS{}) noexcept  //
        : hour{static_cast<uint8_t>(h)},
          minute{static_cast<uint8_t>(m)},
          second{static_cast<uint8_t>(s)},
          nanosecond{static_cast<uint32_t>(ns)} {}
 
    TOML_PURE_GETTER
    friend constexpr bool operator==(const time& lhs, const time& rhs) noexcept {
      return lhs.hour == rhs.hour         //
             && lhs.minute == rhs.minute  //
             && lhs.second == rhs.second  //
             && lhs.nanosecond == rhs.nanosecond;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator!=(const time& lhs, const time& rhs) noexcept {
      return !(lhs == rhs);
    }
 
   private:
 
    TOML_PURE_GETTER
    static constexpr uint64_t pack(const time& t) noexcept {
      return static_cast<uint64_t>(t.hour) << 48 | static_cast<uint64_t>(t.minute) << 40 |
             static_cast<uint64_t>(t.second) << 32 | static_cast<uint64_t>(t.nanosecond);
    }
 
 
   public:
    TOML_PURE_GETTER
    friend constexpr bool operator<(const time& lhs, const time& rhs) noexcept {
      return pack(lhs) < pack(rhs);
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator<=(const time& lhs, const time& rhs) noexcept {
      return pack(lhs) <= pack(rhs);
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator>(const time& lhs, const time& rhs) noexcept {
      return pack(lhs) > pack(rhs);
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator>=(const time& lhs, const time& rhs) noexcept {
      return pack(lhs) >= pack(rhs);
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, const time& rhs) {
      impl::print_to_stream(lhs, rhs);
      return lhs;
    }
  };
 
  struct TOML_TRIVIAL_ABI time_offset {
    int16_t minutes;
 
    TOML_NODISCARD_CTOR
    time_offset() noexcept = default;
 
    TOML_CONSTRAINED_TEMPLATE((impl::all_integral<H, M>), typename H, typename M)
    TOML_NODISCARD_CTOR
    constexpr time_offset(H h, M m) noexcept  //
        : minutes{static_cast<int16_t>(static_cast<impl::common_signed_type<H, M>>(h) *
                                           impl::common_signed_type<H, M>{60} +
                                       static_cast<impl::common_signed_type<H, M>>(m))} {}
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator==(time_offset lhs, time_offset rhs) noexcept {
      return lhs.minutes == rhs.minutes;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator!=(time_offset lhs, time_offset rhs) noexcept {
      return lhs.minutes != rhs.minutes;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator<(time_offset lhs, time_offset rhs) noexcept {
      return lhs.minutes < rhs.minutes;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator<=(time_offset lhs, time_offset rhs) noexcept {
      return lhs.minutes <= rhs.minutes;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator>(time_offset lhs, time_offset rhs) noexcept {
      return lhs.minutes > rhs.minutes;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator>=(time_offset lhs, time_offset rhs) noexcept {
      return lhs.minutes >= rhs.minutes;
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, const time_offset& rhs) {
      impl::print_to_stream(lhs, rhs);
      return lhs;
    }
  };
 
#ifdef __linux__
#define TOML_STD std::
#else
#define TOML_STD
#endif
 
  TOML_ABI_NAMESPACE_BOOL(TOML_HAS_CUSTOM_OPTIONAL_TYPE, custopt, stdopt);
 
  struct date_time {
    toml::date date;
 
    toml::time time;
 
    TOML_STD optional<toml::time_offset> offset;
 
    TOML_NODISCARD_CTOR
    date_time() noexcept = default;
 
    TOML_NODISCARD_CTOR
    constexpr date_time(const toml::date& d, const toml::time& t) noexcept  //
        : date{d},
          time{t},
          offset{}  // TINAE - icc bugfix
    {}
 
    TOML_NODISCARD_CTOR
    explicit constexpr date_time(const toml::date& d) noexcept  //
        : date{d},
          time{},
          offset{}  // TINAE - icc bugfix
    {}
 
    TOML_NODISCARD_CTOR
    explicit constexpr date_time(const toml::time& t) noexcept  //
        : date{},
          time{t},
          offset{}  // TINAE - icc bugfix
    {}
 
    TOML_NODISCARD_CTOR
    constexpr date_time(const toml::date& d, const toml::time& t,
                        const toml::time_offset& off) noexcept
        : date{d}, time{t}, offset{off} {}
 
    TOML_PURE_INLINE_GETTER
    constexpr bool is_local() const noexcept { return !offset.has_value(); }
 
    TOML_PURE_GETTER
    friend constexpr bool operator==(const date_time& lhs, const date_time& rhs) noexcept {
      return lhs.date == rhs.date     //
             && lhs.time == rhs.time  //
             && lhs.offset == rhs.offset;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator!=(const date_time& lhs, const date_time& rhs) noexcept {
      return !(lhs == rhs);
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator<(const date_time& lhs, const date_time& rhs) noexcept {
      if (lhs.date != rhs.date) return lhs.date < rhs.date;
      if (lhs.time != rhs.time) return lhs.time < rhs.time;
      return lhs.offset < rhs.offset;
    }
 
    TOML_PURE_GETTER
    friend constexpr bool operator<=(const date_time& lhs, const date_time& rhs) noexcept {
      if (lhs.date != rhs.date) return lhs.date < rhs.date;
      if (lhs.time != rhs.time) return lhs.time < rhs.time;
      return lhs.offset <= rhs.offset;
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator>(const date_time& lhs, const date_time& rhs) noexcept {
      return !(lhs <= rhs);
    }
 
    TOML_PURE_INLINE_GETTER
    friend constexpr bool operator>=(const date_time& lhs, const date_time& rhs) noexcept {
      return !(lhs < rhs);
    }
 
    friend std::ostream& operator<<(std::ostream& lhs, const date_time& rhs) {
      impl::print_to_stream(lhs, rhs);
      return lhs;
    }
  };
 
  TOML_ABI_NAMESPACE_END;  // TOML_HAS_CUSTOM_OPTIONAL_TYPE
}
TOML_NAMESPACE_END;
 
#include "header_end.hpp"