Time.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 | \  |  | |  __\  |  ___|\\   / / |   __ \
 |  \ |  | | | \\ | |___ \\ / /  |  |__)  |
 |  .\|  | | |__/ / | |___  \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  |\ \
 |__|\__________________________________| \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: Time
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/BaseValues.h>
#include <NDEVR/BufferBase.h>
#include <functional>
struct tm;
namespace NDEVR
{
    class String;
    class StringView;
    class StringAllocatingView;
    class Exception;
    class Time
    {
    public:
        enum Month : uint01
        {
              JANUARY = 1//First month of the year
            , FEBRUARY//Second month of the year
            , MARCH//Third month of the year
            , APRIL//Fourth month of the year
            , MAY//Fifth month of the year
            , JUNE//Sixth month of the year
            , JULY//Seventh month of the year
            , AUGUST//Eigth month of the year
            , SEPTEMBER//Ninth month of the year
            , OCTOBER//Tenth month of the year
            , NOVEMBER//Eleventh month of the year
            , DECEMBER//Twelve month of the year
        };
        // Static Variables
        //------------------------
    public:
        static constexpr uint08 NANOSECOND = 1;
        static constexpr uint08 MICROSECOND = 1000 * NANOSECOND;
        static constexpr uint08 MILLISECOND = 1000000;
        static constexpr uint08 SECOND = 1000000000;
        static constexpr uint08 MINUTE = SECOND * 60;
        static constexpr uint08 HOUR = MINUTE * 60;
        static constexpr uint08 DAY = HOUR * 24;
        static constexpr uint08 WEEK = DAY * 7;
        static constexpr uint08 YEAR = DAY * 365;
        static constexpr uint08 LEAP_YEAR = DAY * 366;
        // Member Functions
        //------------------------
    public:
        constexpr Time()
            : m_time(Constant<uint08>::Invalid)
        {}

        constexpr explicit Time(const uint08& time)
            : m_time(time)
        {}

        NDEVR_BASE_API Time(uint04 year, uint04 month, uint04 day, uint04 hour = 0, uint04 minute = 0, uint04 second = 0, bool is_local_time = false);
        NDEVR_BASE_API Time(const StringView& time_string, bool is_local_time, const StringView& format_string);
        NDEVR_BASE_API void setTime(const uint08& time);
        NDEVR_BASE_API StringAllocatingView getAsString(bool get_local_time, const StringView& format_string) const;
 
        //NDEVR_BASE_API void appendTo(StringAllocatingView& value, bool get_local_time, const StringView& format_string) const;
        NDEVR_BASE_API void appendTo(StringAllocatingView& value, bool get_local_time, const StringView& format_string) const;
        NDEVR_BASE_API void setTimeFromString(const StringView& time_string, bool is_local_time, const StringView& format_string);
        NDEVR_BASE_API void setHour(const uint01& hour, bool is_local_time);
        NDEVR_BASE_API void setMinute(const uint01& minute, bool is_local_time);
        NDEVR_BASE_API void setSecond(const uint01& second, bool is_local_time);
        NDEVR_BASE_API void setMillisecond(const uint02& millisecond);
        NDEVR_BASE_API void setYear(const uint02& year, bool is_local_time);
        NDEVR_BASE_API void setMonth(const Month& month, bool is_local_time);
        NDEVR_BASE_API void setMonthDay(const uint01& day, bool is_local_time);
        NDEVR_BASE_API void setDayOfYear(const uint02& day, bool is_local_time);
        NDEVR_BASE_API fltp08 julianDay(bool is_local_time) const;
        NDEVR_BASE_API uint02 year(bool is_local_time) const;
        NDEVR_BASE_API Month month(bool is_local_time) const;
        NDEVR_BASE_API uint01 monthDay(bool is_local_time) const;
        NDEVR_BASE_API uint02 yearDay(bool is_local_time) const;

        NDEVR_BASE_API uint01 hour(bool is_local_time) const;
        NDEVR_BASE_API uint01 minute(bool is_local_time) const;
        NDEVR_BASE_API uint01 second(bool is_local_time) const;
        NDEVR_BASE_API uint02 millisecond() const;
        [[nodiscard]] constexpr uint08 getNanoSeconds() const
        {
            return m_time;
        }

        [[nodiscard]] uint08 getMilliseconds() const
        {
            return m_time / MILLISECOND;
        }

        NDEVR_BASE_API uint08 unixTime() const;
 
        //Used for TimeSpan calculations
        [[nodiscard]] NDEVR_BASE_API uint08 leapYearConstant() const;
        [[nodiscard]] NDEVR_BASE_API uint08 daysConstant() const;
        [[nodiscard]] NDEVR_BASE_API uint08 monthsConstant() const;
        
        inline constexpr bool operator==(const Time& time) const
        {
            return m_time == time.m_time;
        }
        inline constexpr bool operator!=(const Time& time) const
        {
            return m_time != time.m_time;
        }
        inline constexpr bool operator<(const Time& time) const
        {
            return m_time < time.m_time;
        }
        inline constexpr bool operator<=(const Time& time) const
        {
            return m_time <= time.m_time;
        }
        inline constexpr bool operator>(const Time& time) const
        {
            return m_time > time.m_time;
        }
        inline constexpr bool operator>=(const Time& time) const
        {
            return m_time >= time.m_time;
        }
    private:
        uint08 m_time;
    public:
        NDEVR_BASE_API static Time SystemTime();
        static NDEVR_BASE_API void SetSystemTime(const Time& time);
        NDEVR_BASE_API static void SetMakeUTCFromLocalFunction(const std::function<uint08(const tm& tm)>& function);
        NDEVR_BASE_API static void SetMakeLocalFromUTCFunction(const std::function<uint08(const tm& tm)>& function);
        NDEVR_BASE_API static void SetClockErrorCallback(const std::function<void(const Exception& error)>& function);
    private:
        static tm getTime(sint08 time, bool use_local_time);
        static uint08 MakeGMTFromLocal(const tm& time);
        static uint08 MakeLocalFromGMT(const tm& time);
    private:
        static constexpr uint02 s_epoch_year = 1970;
        static constexpr uint02 s_tm_year_base = 1900;
        static std::function<uint08(const tm& tm)> s_make_utc_from_local;
        static std::function<uint08(const tm& tm)> s_make_local_from_utc;
        static std::function<void(const Exception& error)> s_clock_error_callback;
        static sint08 s_nano_second_offset;
    };
 

    template<>
    struct ObjectInfo<Time, false, false>
    {
        static const uint01 Dimensions = 0;
        static const bool Vector = false;
        static const bool Primitive = true;
        static const bool Pointer = false;
        static const bool Unsigned = false;
        static const bool Float = true;
        static const bool Integer = false;
        static const bool Number = true;
        static const bool String = false;
        static const bool Color = false;
        static const bool Buffer = false;
        static const bool Boolean = false;
        static constexpr ObjectInfo<Time, false, false> VectorSub() { return ObjectInfo<Time, false, false>(); }
    };
 
    static_assert(sizeof(Time(0)) == 8, "Bad time allocation size");
 
    template<> constexpr const Time Constant<Time>::Invalid = Time(18446744073709551615ULL);
    template<> constexpr const Time Constant<Time>::Max = Time(18446744073709551614ULL);
    template<> constexpr const Time Constant<Time>::Min = Time(0);
}