F2592 locale date time

libs/containers/include/wolv/container/soo_buffer.hpp

@@ -0,0 +1,158 @@
+#pragma once
+// soo_buffer.hpp
+/*
+ * Small Object Optimization Buffer
+ *
+ *  A buffer for POD types that keeps small allocations on the stack and
+ *  transparently moves to heap storage when the size exceeds a configurable
+ *  limit. During reallocation, the contents of the previous buffer may
+ *  optionally be copied to the new one.
+ */
+
+#include <cstddef>
+#include <type_traits>
+#include <cstdlib>
+#include <initializer_list>
+
+namespace {
+
+    template <typename T>
+    struct  NewAlloc {
+        static T* alloc(T* old, size_t sz) {
+            delete [] old;
+            return new T[sz];
+        }
+
+        static void free(T* p) {
+            delete[] p;
+        }
+
+        static void copy(T* desc, T* src, size_t sz) {}
+    };
+
+    template <typename T>
+    struct RealloceAlloc {
+        static T* alloc(T* old, size_t sz) {
+            return static_cast<T*>(realloc(old, sz*sizeof(T)));
+        }
+
+        static void free(T* p) {
+            ::free(p);
+        }
+
+        static void copy(T* desc, T* src, size_t sz) {
+            memcpy(desc, src, sz*sizeof(T));
+        }
+    };
+
+} // namespace
+
+namespace wolv::util {
+
+    // T          - Type
+    // SZ         - Size in Ts of stack buffer
+    // UseRealloc - If true copies the contents of the old buffer to the new on reallocation
+    template <typename T, size_t SZ, bool UseRealloc=false>
+    class SOOBuffer {
+        static_assert(std::is_trivially_copyable_v<T>&& std::is_standard_layout_v<T>,
+            "SOOBuffer only supports trivial, standard-layout types");
+
+        using Alloc = std::conditional_t<UseRealloc, RealloceAlloc<T>, NewAlloc<T>>;
+
+    public:
+        using elementType = T;
+        static const size_t smallSZ = SZ;
+
+        SOOBuffer(size_t cap = 0) {
+            m_size = SZ;
+            grow(cap);
+        }
+
+        SOOBuffer(const SOOBuffer&) = delete;
+        SOOBuffer& operator=(const SOOBuffer&) = delete;
+        SOOBuffer(SOOBuffer&&) = delete;
+        SOOBuffer& operator=(SOOBuffer&&) = delete;
+
+        ~SOOBuffer() {
+            if (!isSmall())
+                Alloc::free(m_heap);
+        }
+
+        T* data() {
+            return isSmall() ? m_small : m_heap;
+        }
+
+        const T* data() const {
+            return isSmall() ? m_small : m_heap;
+        }
+
+        operator T* () {
+            return data();
+        }
+
+        operator const T* () const {
+            return data();
+        }
+
+        T& operator[](size_t i) {
+            return data()[i];
+        }
+
+        const T& operator[](size_t i) const {
+            return data()[i];
+        }
+
+        size_t small_size() const {
+            return smallSZ;
+        }
+
+        bool isSmall() const {
+            return m_size <= SZ;
+        }
+
+        size_t size() const {
+            return m_size;
+        }
+
+        void grow(size_t sz) {
+            if (sz > m_size) { // we never get smaller
+               growBuffer(sz);
+            }
+        }
+
+        void grow(size_t sz, std::initializer_list<T**> ptrs) {
+            if (sz <= m_size) { // we never get smaller
+                return;
+            }
+
+            T *pOldBase = data();
+            growBuffer(sz);
+            T *pNewBase = data();
+
+            for (T** p : ptrs) {
+                *p = (*p - pOldBase) + pNewBase;
+            }
+        }
+
+    private:
+        void growBuffer(size_t sz) {
+            if (isSmall()) {
+                T *pHeap = Alloc::alloc(NULL, sz);
+                Alloc::copy(pHeap, m_small, SZ);
+                m_heap = pHeap;
+            }
+            else {
+                m_heap = Alloc::alloc(m_heap, sz);
+            }
+            m_size = sz;
+        }
+
+        size_t m_size = 0;
+
+        union {
+            T* m_heap;
+            T m_small[SZ];
+        };
+    };
+
+} // namespace wolv::util

libs/utils/CMakeLists.txt

@@ -3,12 +3,18 @@ project(libwolv-utils)
 # Add library
 add_library(${PROJECT_NAME} STATIC
         source/utils/string.cpp
+        source/utils/date_time_format.cpp
 )
 
 add_subdirectory(lib/jthread)
 
 target_include_directories(${PROJECT_NAME} PUBLIC include)
-target_link_libraries(${PROJECT_NAME} PUBLIC wolv::types jthread)
+target_link_libraries(${PROJECT_NAME}
+    PUBLIC
+        wolv::types
+        wolv::containers
+        jthread
+)
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "")
 
 string(REPLACE "libwolv-" "" PROJECT_NAME_SPACE ${PROJECT_NAME})

libs/utils/include/wolv/utils/date_time_format.hpp

@@ -0,0 +1,106 @@
+#pragma once
+// date_time_format.hpp
+
+#include <optional>
+#include <string>
+#include <type_traits>
+
+#include <wolv/types.hpp>
+
+#if defined(OS_WINDOWS)
+# include <windows.h>
+#else
+# include <locale.h>
+#endif // #if defined(OS_WINDOWS)
+
+namespace wolv::util {
+
+#if defined(OS_WINDOWS)
+
+    class Locale {
+    public:
+        Locale() = default;
+        explicit Locale(const char *str);
+        explicit Locale(const std::string &str);
+        Locale(const Locale &copyMe) = default;
+
+        ~Locale() = default;
+
+        Locale& operator=(const Locale &copyMe);
+
+        void set(const char *str);
+        void set(const std::string &str);
+
+        operator const char*() const {
+            return m_locale.c_str();
+        }
+
+    private:
+        std::string m_locale;
+    };
+
+#else
+
+    class Locale {
+    public:
+        Locale();
+        explicit Locale(const char *str);
+        explicit Locale(const std::string &str);
+        Locale(const Locale &copyMe);
+
+        ~Locale();
+
+        Locale& operator=(const Locale &copyMe);
+
+        void set(const char *str);
+        void set(const std::string &str);
+
+        operator locale_t() const {
+            return m_locale;
+        }
+
+    private:
+        void setInvalid();
+        void free();
+
+        bool m_valid;
+        locale_t m_locale;
+    };
+
+#endif
+
+    enum class DTOpts {
+        TT32        = 0b0000,  // 32-bits
+        TT64        = 0b0001,  // 64-bits
+        TTMask      = 0b0001,
+
+        DandT       = 0b0110,  // date and time
+        D           = 0b0100,  // date
+        T           = 0b0010,  // time
+        DTMask      = 0b0110,
+
+        ShortDate   = 0b0000,
+        LongDate    = 0b1000,
+        DateFmtMask = 0b1000
+    };
+
+    constexpr DTOpts operator|(DTOpts a, DTOpts b) noexcept {
+        using T = std::underlying_type_t<DTOpts>;
+        return static_cast<DTOpts>(static_cast<T>(a) | static_cast<T>(b));
+    }
+
+    constexpr DTOpts operator&(DTOpts a, DTOpts b) noexcept {
+        using T = std::underlying_type_t<DTOpts>;
+        return static_cast<DTOpts>(static_cast<T>(a) & static_cast<T>(b));
+    }
+
+#if defined(OS_WINDOWS)
+    std::optional<SYSTEMTIME> timeTToSystemTime(i64 t, DTOpts sz = DTOpts::TT64);
+    std::optional<std::string> formatSystemTime(LPCSTR lc, const SYSTEMTIME* pss, DTOpts opts = DTOpts::LongDate);
+
+    std::optional<std::string> formatTT(const Locale &lc, wolv::i64 t, DTOpts opts = DTOpts::TT64|DTOpts::DandT|DTOpts::LongDate);
+#else
+    std::optional<std::string> formatTT(const Locale &lc, wolv::i64 t, DTOpts opts = DTOpts::TT64|DTOpts::DandT|DTOpts::LongDate);
+#endif
+
+} // namespace wolv::util