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 "print_to_stream.hpp"
#include "header_start.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;
        }
    };
 
    TOML_ABI_NAMESPACE_BOOL(TOML_HAS_CUSTOM_OPTIONAL_TYPE, custopt, stdopt);
 
    struct date_time
    {
        toml::date date;
 
        toml::time time;
 
        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"