Rearrange the chrono project, make the windows chrono stuff a separat…

src/libraries/chrono/CMakeLists.txt

@@ -12,4 +12,6 @@ list(APPEND m_installation_targets
     m_chrono
 )
 
+add_subdirectory(Platforms)
+
 set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)

src/libraries/chrono/src/Platforms/CMakeLists.txt → src/libraries/chrono/Platforms/CMakeLists.txt

@@ -1,7 +1,9 @@
-cmake_minimum_required(VERSION 3.23)
-
-if(WIN32)
-add_subdirectory(Windows)
-endif()
-
-set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)
+cmake_minimum_required(VERSION 3.23)
+
+if(WIN32)
+
+add_subdirectory(Windows)
+
+endif()
+
+set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)

src/libraries/chrono/Platforms/Windows/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.23)
+
+add_library(m_windows_chrono STATIC)
+
+target_compile_features(m_windows_chrono PUBLIC cxx_std_23)
+
+add_subdirectory(include)
+add_subdirectory(src)
+add_subdirectory(test)
+
+list(APPEND m_installation_targets
+    m_windows_chrono
+)
+
+set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)

src/libraries/chrono/include/Platforms/Windows/CMakeLists.txt → src/libraries/chrono/Platforms/Windows/include/CMakeLists.txt

@@ -1,7 +1,7 @@
-cmake_minimum_required(VERSION 3.23)
-
-target_sources(m_chrono PUBLIC FILE_SET HEADERS FILES
-    m/chrono/windows_chrono_casts.h
-)
-
-set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)
+cmake_minimum_required(VERSION 3.23)
+
+target_sources(m_windows_chrono PUBLIC FILE_SET HEADERS FILES
+    m/windows_chrono/windows_chrono_casts.h
+)
+
+set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)

src/libraries/chrono/include/Platforms/Windows/m/chrono/windows_chrono_casts.h → src/libraries/chrono/Platforms/Windows/include/m/windows_chrono/windows_chrono_casts.h

@@ -1,154 +1,154 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <m/utility/compiler.h>
-
-#include <bit>
-#include <chrono>
-
-#include <m/cast/to.h>
-#include <m/cast/try_cast.h>
-#include <m/exception/exception.h>
-#include <m/tracing/tracing.h>
-#include <m/windows_wrappers/win32_dword_ms.h>
-
-#undef NOMINMAX
-#define NOMINMAX
-
-#include <Windows.h>
-
-namespace m
-{
-    template <typename ResultType, typename Clock, typename Duration = Clock::duration>
-    struct time_point_cast_helper;
-
-    template <typename ResultType, typename Clock, typename Duration>
-    auto
-    utc_time_point_cast(std::chrono::time_point<Clock, Duration> tp)
-    {
-        return time_point_cast_helper<ResultType, Clock, Duration>::cast_utc_time_point(tp);
-    }
-
-    template <typename Rep, typename Period>
-    win32_dword_ms
-    win32_dword_ms_cast(std::chrono::duration<Rep, Period> const& d)
-    {
-        auto const as_ms = std::chrono::duration_cast<std::chrono::milliseconds>(d);
-
-        using value_type = typename win32_dword_ms::value_type;
-
-        if (as_ms.count() < (std::numeric_limits<value_type>::min)() ||
-            as_ms.count() > (std::numeric_limits<value_type>::max)())
-        {
-            m::trace_error("Attempted to convert value {} to DWORD milliseconds; out of range",
-                           as_ms.count());
-            throw m::invalid_parameter("d");
-        }
-
-        return win32_dword_ms(m::to<DWORD>(as_ms.count()));
-    }
-
-    template <typename Rep, typename Period>
-        requires(std::integral<Rep>)
-    struct try_cast_helper<std::chrono::duration<Rep, Period>, win32_dword_ms, void>
-    {
-        static constexpr decltype(auto)
-        do_cast(std::chrono::duration<Rep, Period> const& d)
-        {
-            return win32_dword_ms_cast(d);
-        }
-    };
-
-    template <typename Clock, typename Duration>
-    struct time_point_cast_helper<SYSTEMTIME, Clock, Duration>
-    {
-
-        template <typename DestinationClock>
-        static SYSTEMTIME
-        cast_time_point(std::chrono::time_point<Clock, Duration> tp)
-        {
-            auto const as_destination_clock = std::chrono::clock_cast<DestinationClock>(tp);
-            auto const sys_time             = std::chrono::utc_clock::to_sys(as_destination_clock);
-            auto const time_t_time          = std::chrono::system_clock::to_time_t(sys_time);
-            std::tm    tm_time{};
-
-            gmtime_s(&tm_time, &time_t_time);
-
-            SYSTEMTIME st{};
-
-            st.wDay          = m::to<WORD>(tm_time.tm_mday);
-            st.wDayOfWeek    = m::to<WORD>(tm_time.tm_wday);
-            st.wHour         = m::to<WORD>(tm_time.tm_hour);
-            st.wMilliseconds = 0;
-            st.wMinute       = m::to<WORD>(tm_time.tm_min);
-            st.wMonth        = m::to<WORD>(tm_time.tm_mon) + 1;
-            st.wSecond       = m::to<WORD>(tm_time.tm_sec);
-            st.wYear         = m::to<WORD>(tm_time.tm_year) + 1900;
-
-            return st;
-        }
-
-        static SYSTEMTIME
-        cast_utc_time_point(std::chrono::time_point<Clock, Duration> tp)
-        {
-            return cast_time_point<std::chrono::utc_clock>(tp);
-        }
-    };
-
-    template <typename Clock, typename Duration>
-    struct try_cast_helper<std::chrono::time_point<Clock, Duration>, SYSTEMTIME, void>
-    {
-        static constexpr decltype(auto)
-        do_cast(std::chrono::time_point<Clock, Duration> const& tp)
-        {
-            return time_point_cast_helper<SYSTEMTIME, Clock, Duration>::cast_utc_time_point(tp);
-        }
-    };
-
-    template <typename Rep, typename Period>
-    struct try_cast_helper<std::chrono::duration<Rep, Period>, FILETIME, void>
-    {
-        template <typename Rep, typename Period>
-        static FILETIME
-        DurationToFILETIME(std::chrono::duration<Rep, Period> const& duration)
-        {
-            if (duration.count() < 0)
-            {
-                trace_error("Programming error: invalid duration passed in; count < 0: {}",
-                                   duration.count());
-                throw m::invalid_parameter("duration");
-            }
-
-            //
-            // FILETIME is 100ns units, so for the ratio
-            // have the denominator be 1 billion divided by
-            // 100.
-            //
-            using FiletimeRatio    = std::ratio<1, 1'000'000'000 / 100>;
-            using FiletimeDuration = std::chrono::duration<int64_t, FiletimeRatio>;
-
-            auto const as_filetime_duration =
-                std::chrono::duration_cast<FiletimeDuration>(duration);
-
-            static_assert(std::numeric_limits<int64_t>::digits ==
-                          std::numeric_limits<typename FiletimeDuration::rep>::digits);
-
-            int64_t count = as_filetime_duration.count();
-
-            // Durations in FILETIME are negative.
-            //
-            count = -count;
-            
-            return std::bit_cast<FILETIME>(count);
-        }
-
-        static constexpr decltype(auto)
-        do_cast(std::chrono::duration<Rep, Period> const& d)
-        {
-            return DurationToFILETIME(d);
-        }
-    };
-
-} // namespace m
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <m/utility/compiler.h>
+
+#include <bit>
+#include <chrono>
+
+#include <m/cast/to.h>
+#include <m/cast/try_cast.h>
+#include <m/exception/exception.h>
+#include <m/tracing/tracing.h>
+#include <m/windows_wrappers/win32_dword_ms.h>
+
+#undef NOMINMAX
+#define NOMINMAX
+
+#include <Windows.h>
+
+namespace m
+{
+    template <typename ResultType, typename Clock, typename Duration = Clock::duration>
+    struct time_point_cast_helper;
+
+    template <typename ResultType, typename Clock, typename Duration>
+    auto
+    utc_time_point_cast(std::chrono::time_point<Clock, Duration> tp)
+    {
+        return time_point_cast_helper<ResultType, Clock, Duration>::cast_utc_time_point(tp);
+    }
+
+    template <typename Rep, typename Period>
+    win32_dword_ms
+    win32_dword_ms_cast(std::chrono::duration<Rep, Period> const& d)
+    {
+        auto const as_ms = std::chrono::duration_cast<std::chrono::milliseconds>(d);
+
+        using value_type = typename win32_dword_ms::value_type;
+
+        if (as_ms.count() < (std::numeric_limits<value_type>::min)() ||
+            as_ms.count() > (std::numeric_limits<value_type>::max)())
+        {
+            m::trace_error("Attempted to convert value {} to DWORD milliseconds; out of range",
+                           as_ms.count());
+            throw m::invalid_parameter("d");
+        }
+
+        return win32_dword_ms(m::to<DWORD>(as_ms.count()));
+    }
+
+    template <typename Rep, typename Period>
+        requires(std::integral<Rep>)
+    struct try_cast_helper<std::chrono::duration<Rep, Period>, win32_dword_ms, void>
+    {
+        static constexpr decltype(auto)
+        do_cast(std::chrono::duration<Rep, Period> const& d)
+        {
+            return win32_dword_ms_cast(d);
+        }
+    };
+
+    template <typename Clock, typename Duration>
+    struct time_point_cast_helper<SYSTEMTIME, Clock, Duration>
+    {
+
+        template <typename DestinationClock>
+        static SYSTEMTIME
+        cast_time_point(std::chrono::time_point<Clock, Duration> tp)
+        {
+            auto const as_destination_clock = std::chrono::clock_cast<DestinationClock>(tp);
+            auto const sys_time             = std::chrono::utc_clock::to_sys(as_destination_clock);
+            auto const time_t_time          = std::chrono::system_clock::to_time_t(sys_time);
+            std::tm    tm_time{};
+
+            gmtime_s(&tm_time, &time_t_time);
+
+            SYSTEMTIME st{};
+
+            st.wDay          = m::to<WORD>(tm_time.tm_mday);
+            st.wDayOfWeek    = m::to<WORD>(tm_time.tm_wday);
+            st.wHour         = m::to<WORD>(tm_time.tm_hour);
+            st.wMilliseconds = 0;
+            st.wMinute       = m::to<WORD>(tm_time.tm_min);
+            st.wMonth        = m::to<WORD>(tm_time.tm_mon) + 1;
+            st.wSecond       = m::to<WORD>(tm_time.tm_sec);
+            st.wYear         = m::to<WORD>(tm_time.tm_year) + 1900;
+
+            return st;
+        }
+
+        static SYSTEMTIME
+        cast_utc_time_point(std::chrono::time_point<Clock, Duration> tp)
+        {
+            return cast_time_point<std::chrono::utc_clock>(tp);
+        }
+    };
+
+    template <typename Clock, typename Duration>
+    struct try_cast_helper<std::chrono::time_point<Clock, Duration>, SYSTEMTIME, void>
+    {
+        static constexpr decltype(auto)
+        do_cast(std::chrono::time_point<Clock, Duration> const& tp)
+        {
+            return time_point_cast_helper<SYSTEMTIME, Clock, Duration>::cast_utc_time_point(tp);
+        }
+    };
+
+    template <typename Rep, typename Period>
+    struct try_cast_helper<std::chrono::duration<Rep, Period>, FILETIME, void>
+    {
+        template <typename Rep, typename Period>
+        static FILETIME
+        DurationToFILETIME(std::chrono::duration<Rep, Period> const& duration)
+        {
+            if (duration.count() < 0)
+            {
+                trace_error("Programming error: invalid duration passed in; count < 0: {}",
+                                   duration.count());
+                throw m::invalid_parameter("duration");
+            }
+
+            //
+            // FILETIME is 100ns units, so for the ratio
+            // have the denominator be 1 billion divided by
+            // 100.
+            //
+            using FiletimeRatio    = std::ratio<1, 1'000'000'000 / 100>;
+            using FiletimeDuration = std::chrono::duration<int64_t, FiletimeRatio>;
+
+            auto const as_filetime_duration =
+                std::chrono::duration_cast<FiletimeDuration>(duration);
+
+            static_assert(std::numeric_limits<int64_t>::digits ==
+                          std::numeric_limits<typename FiletimeDuration::rep>::digits);
+
+            int64_t count = as_filetime_duration.count();
+
+            // Durations in FILETIME are negative.
+            //
+            count = -count;
+
+            return std::bit_cast<FILETIME>(count);
+        }
+
+        static constexpr decltype(auto)
+        do_cast(std::chrono::duration<Rep, Period> const& d)
+        {
+            return DurationToFILETIME(d);
+        }
+    };
+
+} // namespace m

src/libraries/chrono/Platforms/Windows/src/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.23)
+
+target_sources(m_windows_chrono PRIVATE
+    windows_chrono_casts.cpp
+)
+
+target_include_directories(m_windows_chrono PUBLIC
+    ../include/Platforms/Windows
+)
+
+target_link_libraries(m_windows_chrono PUBLIC
+    m_cast
+    m_chrono
+    m_tracing
+    m_windows_wrappers
+)
+
+set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)

src/libraries/chrono/src/Platforms/Windows/windows_chrono_casts.cpp → src/libraries/chrono/Platforms/Windows/src/windows_chrono_casts.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include <m/chrono/windows_chrono_casts.h>
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include <m/windows_chrono/windows_chrono_casts.h>