this is a breaking change (logging)

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 include(cmake/color.cmake)
-set(BLT_VERSION 2.0.4)
+set(BLT_VERSION 5.0.0)
 
 set(BLT_TARGET BLT)
 
@@ -17,6 +17,7 @@ option(BUILD_PROFILING "Build the BLT profiler extension" ON)
 option(BUILD_FS "Build the BLT FS utilities including the NBT + eNBT extension" ON)
 option(BUILD_PARSE "Build the BLT parsers" ON)
 option(BUILD_FORMAT "Build the BLT formatters" ON)
+option(BUILD_LOGGING "Build the BLT logging utilities" ON)
 
 option(BUILD_TESTS "Build the BLT test set" OFF)
 
@@ -70,8 +71,14 @@ if (${BUILD_FORMAT})
     message(STATUS "Building ${Yellow}format${ColourReset} cxx files")
     file(GLOB_RECURSE FORMAT_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src/blt/format/*.cpp")
 else ()
-    set(FORMAT_FILES ""
-            include/blt/std/iterator.h)
+    set(FORMAT_FILES "")
+endif ()
+
+if (${BUILD_LOGGING})
+    message(STATUS "Building ${Yellow}logging${ColourReset} cxx files")
+    file(GLOB_RECURSE LOGGING_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src/blt/logging/*.cpp")
+else ()
+    set(PARSE_FILES "")
 endif ()
 
 if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/libraries/parallel-hashmap)
@@ -93,7 +100,7 @@ endif ()
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/config/)
 
-add_library(${BLT_TARGET} ${STD_FILES} ${PROFILING_FILES} ${FS_FILES} ${PARSE_FILES} ${FORMAT_FILES})
+add_library(${BLT_TARGET} ${STD_FILES} ${PROFILING_FILES} ${FS_FILES} ${PARSE_FILES} ${FORMAT_FILES} ${LOGGING_FILES})
 
 string(REPLACE "+" "\\+" escaped_source ${CMAKE_CURRENT_SOURCE_DIR})
 string(APPEND escaped_source "/src/blt/.*/")
@@ -148,8 +155,9 @@ install(TARGETS ${BLT_TARGET}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
-macro(blt_add_project name source type)
+macro(blt_add_test name source type)
 
+    message("Adding project ${name} of type ${type}" DEBUG)
     project(${name}-${type})
 
     add_executable(${name}-${type} ${source})
@@ -194,7 +202,9 @@ endmacro()
 if (${BUILD_TESTS})
     message("Building tests for version ${BLT_VERSION}")
 
-    blt_add_project(blt-iterator tests/iterator_tests.cpp test)
+    blt_add_test(blt_iterator tests/iterator_tests.cpp test)
+    blt_add_test(blt_argparse tests/argparse_tests.cpp test)
+    blt_add_test(blt_logging tests/logger_tests.cpp test)
 
     message("Built tests")
 endif ()

commit.py

@@ -1,4 +1,4 @@
-#!/usr/bin/python3
+#!python3
 
 import subprocess
 import argparse

commit.py.save

@@ -1,74 +0,0 @@
-#!/usr/bin/python3
-
-import subprocess
-
-#---------------------------------------
-#		CONFIG
-#---------------------------------------
-
-VERSION_BEGIN_STR = "set(BLT_VERSION "
-VERSION_END_STR = ")"
-
-#---------------------------------------
-#	      DO NOT TOUCH
-#---------------------------------------
-
-type = input("What kind of commit is this ((M)ajor, (m)inor, (p)atch)? ")
-
-def load_cmake():
-	cmake_file = open("CMakeLists.txt", 'r')
-	cmake_text = cmake_file.read()
-	cmake_file.close()
-	return cmake_text
-
-def write_cmake(cmake_text):
-	cmake_file = open("CMakeLists.txt", 'w')
-	cmake_file.write(cmake_text)
-	cmake_file.close()
-
-def get_version(cmake_text):
-	begin = cmake_text.find(VERSION_BEGIN_STR) + len(find_text)
-	end = cmake_text.find(VERSION_END_STR, begin)
-	return (cmake_text[begin:end], begin, end)
-
-def split_version(cmake_text):
-	version, begin, end = get_version(cmake_text)
-	version_parts = version.split('.')
-	return (version_parts, begin, end)
-
-def recombine(cmake_text, version_parts, begin, end):
-	constructed_version = version_parts[0] + '.' + version_parts[1] + '.' + version_parts[2]
-	constructed_text_begin = cmake_text[0:begin]
-	constrcuted_text_end = cmake_text[end::]
-	return constructed_text_begin + constructed_version + constrcuted_text_end
-
-
-def inc_major(cmake_text):
-	version_parts, begin, end = split_version(cmake_text)
-	version_parts[0] = str(int(version_parts[0]) + 1)
-	return recombine(cmake_text, version_parts, begin, end)
-
-def inc_minor(cmake_text):
-	version_parts, begin, end = split_version(cmake_text)
-	version_parts[1] = str(int(version_parts[1]) + 1)
-	return recombine(cmake_text, version_parts, begin, end)
-
-def inc_patch(cmake_text):
-	version_parts, begin, end = split_version(cmake_text)
-	version_parts[2] = str(int(version_parts[2]) + 1)
-	return recombine(cmake_text, version_parts, begin, end)
-
-if type.startswith('M'):
-	print("Selected major")
-	write_cmake(inc_major(load_cmake()))
-elif type.startswith('m'):
-	print("Selected minor")
-	write_cmake(inc_minor(load_cmake()))
-elif type.startswith('p') or type.startswith('P') or len(type) == 0:
-	print("Selected patch")
-	write_cmake(inc_patch(load_cmake()))
-
-#subprocess.call("./py_commit_helper.sh")
-subprocess.call("git", "add", "*")
-subprocess.call("git", "commit")
-subprocess.call("sh -e 'git remote | xargs -L1 git push --all'")

include/blt/compatibility.h

@@ -51,4 +51,12 @@
             #error Filesystem ops not supported!\
     #endif
 
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
+    #define BLT_OS_WINDOWS
+#elif  defined(__linux__) || defined(__unix__)
+    #define BLT_OS_LINUX
+#else
+    #define BLT_OS_UNKNOWN
+#endif
+
 #endif //BLT_COMPATIBILITY_H

include/blt/fs/path_helper.h

@@ -0,0 +1,33 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_FS_PATH_HELPER_H
+#define BLT_FS_PATH_HELPER_H
+
+#include <string>
+#include <string_view>
+
+namespace blt::fs
+{
+
+    std::string base_name(const std::string& str);
+    std::string_view base_name_sv(std::string_view str);
+
+}
+
+#endif //BLT_FS_PATH_HELPER_H

include/blt/iterator/common.h

@@ -27,10 +27,43 @@
 #include <blt/meta/iterator.h>
 #include <functional>
 #include <optional>
+#include <blt/meta/type_traits.h>
 
 namespace blt::iterator
 {
-    template<typename Derived>
+    namespace detail
+    {
+        template<typename T>
+        static auto forward_as_tuple(T&& t) -> decltype(auto)
+        {
+            using Decay = std::decay_t<T>;
+            static_assert(!(meta::is_tuple_v<Decay> || meta::is_pair_v<Decay>), "Tuple or pair passed to forward_as_tuple! Must not be a tuple!");
+            if constexpr (std::is_lvalue_reference_v<T>)
+            {
+                return std::forward_as_tuple(std::forward<T>(t));
+            }
+            else
+            {
+                return std::make_tuple(std::forward<T>(t));
+            }
+        }
+
+        template <typename Tuple>
+        static auto ensure_tuple(Tuple&& tuple) -> decltype(auto)
+        {
+            using Decay = std::decay_t<Tuple>;
+            if constexpr (meta::is_tuple_v<Decay> || meta::is_pair_v<Decay>)
+            {
+                return std::forward<Tuple>(tuple);
+            }
+            else
+            {
+                return forward_as_tuple(std::forward<Tuple>(tuple));
+            }
+        }
+    }
+
+    template <typename Derived>
     struct base_wrapper
     {
         base_wrapper operator++(int)
@@ -39,355 +72,454 @@ namespace blt::iterator
             ++*this;
             return tmp;
         }
-        
+
         base_wrapper operator--(int)
         {
-            static_assert(meta::is_bidirectional_or_better_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
+            static_assert(meta::is_bidirectional_or_better_category_v<typename Derived::iterator_category>,
+                          "Iterator must allow bidirectional access");
             auto tmp = *this;
             --*this;
             return tmp;
         }
-        
-        auto operator[](blt::ptrdiff_t n) const
+
+        auto operator[](ptrdiff_t n) const
         {
-            static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
+            static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>,
+                          "Iterator must allow bidirectional access");
             return *(*this + n);
         }
-        
-        friend base_wrapper operator+(blt::ptrdiff_t n, const base_wrapper& a)
+
+        friend base_wrapper operator+(ptrdiff_t n, const base_wrapper& a)
         {
             return a + n;
         }
-        
+
         friend bool operator<(const base_wrapper& a, const base_wrapper& b)
         {
             static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
             return b - a > 0;
         }
-        
+
         friend bool operator>(const base_wrapper& a, const base_wrapper& b)
         {
             static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
             return b < a;
         }
-        
+
         friend bool operator>=(const base_wrapper& a, base_wrapper& b)
         {
             static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
             return !(a < b); // NOLINT
         }
-        
+
         friend bool operator<=(const base_wrapper& a, const base_wrapper& b)
         {
             static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
             return !(a > b); // NOLINT
         }
-        
+
         friend bool operator==(const base_wrapper& a, const base_wrapper& b)
         {
             return static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base();
         }
-        
+
         friend bool operator!=(const base_wrapper& a, const base_wrapper& b)
         {
             return !(static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base()); // NOLINT
         }
     };
-    
-    template<typename Iter, typename Derived, bool dereference = false>
-    struct passthrough_wrapper : public base_wrapper<Derived>
+
+    template <typename Iter, typename Derived, bool dereference = false>
+    struct passthrough_wrapper : base_wrapper<Derived>
     {
-        public:
-            explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
-            {}
-            
-            auto base() const
-            {
-                return iter;
-            }
-            
-            friend blt::ptrdiff_t operator-(const passthrough_wrapper& a, const passthrough_wrapper& b)
-            {
-                return a.base() - b.base();
-            }
-        
-        protected:
-            mutable Iter iter;
+        explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
+        {
+        }
+
+        auto base() const
+        {
+            return iter;
+        }
+
+        friend ptrdiff_t operator-(const passthrough_wrapper& a, const passthrough_wrapper& b)
+        {
+            return a.base() - b.base();
+        }
+
+    protected:
+        mutable Iter iter;
     };
-    
-    template<typename Iter, typename Derived>
-    struct passthrough_wrapper<Iter, Derived, true> : public passthrough_wrapper<Iter, Derived>
+
+    template <typename Iter, typename Derived>
+    struct passthrough_wrapper<Iter, Derived, true> : passthrough_wrapper<Iter, Derived>
     {
         using passthrough_wrapper<Iter, Derived>::passthrough_wrapper;
-        
+
         meta::deref_return_t<Iter> operator*() const
         {
             return *this->iter;
         }
     };
-    
-    template<typename Iter, typename Derived>
+
+    template <typename Iter, typename Derived>
     class deref_only_wrapper : public passthrough_wrapper<Iter, Derived, false>
     {
-        public:
-            using passthrough_wrapper<Iter, Derived, false>::passthrough_wrapper;
-            
-            deref_only_wrapper& operator++()
-            {
-                ++this->iter;
-                return *this;
-            }
-            
-            deref_only_wrapper& operator--()
-            {
-                --this->iter;
-                return *this;
-            }
-            
-            deref_only_wrapper& operator+(blt::ptrdiff_t n)
-            {
-                static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
-                this->iter = this->iter + n;
-                return *this;
-            }
-            
-            deref_only_wrapper& operator-(blt::ptrdiff_t n)
-            {
-                static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
-                this->iter = this->iter - n;
-                return *this;
-            }
+    public:
+        using passthrough_wrapper<Iter, Derived, false>::passthrough_wrapper;
+
+        deref_only_wrapper& operator++()
+        {
+            ++this->iter;
+            return *this;
+        }
+
+        deref_only_wrapper& operator--()
+        {
+            --this->iter;
+            return *this;
+        }
+
+        deref_only_wrapper& operator+(blt::ptrdiff_t n)
+        {
+            static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
+            this->iter = this->iter + n;
+            return *this;
+        }
+
+        deref_only_wrapper& operator-(blt::ptrdiff_t n)
+        {
+            static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
+            this->iter = this->iter - n;
+            return *this;
+        }
     };
-    
-    template<typename Iter, typename Func>
+
+    template <typename Iter, typename Func>
     class map_wrapper : public deref_only_wrapper<Iter, map_wrapper<Iter, Func>>
     {
-        public:
-            using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
-            using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>;
-            using difference_type = blt::ptrdiff_t;
-            using pointer = value_type;
-            using reference = value_type;
-            
-            map_wrapper(Iter iter, Func func):
-                    deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
-            {}
-            
-            reference operator*() const
-            {
-                return func(*this->iter);
-            }
-        
-        private:
-            Func func;
+    public:
+        using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
+        using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>;
+        using difference_type = blt::ptrdiff_t;
+        using pointer = value_type;
+        using reference = value_type;
+
+        map_wrapper(Iter iter, Func func):
+            deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
+        {
+        }
+
+        reference operator*() const
+        {
+            return func(*this->iter);
+        }
+
+    private:
+        Func func;
     };
-    
-    template<typename Iter, typename Pred>
+
+    template <typename Iter, typename Pred>
     class filter_wrapper : public deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>
     {
-        public:
-            using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
-            using value_type = std::conditional_t<
-                    std::is_reference_v<meta::deref_return_t<Iter>>,
-                    std::optional<std::reference_wrapper<std::remove_reference_t<meta::deref_return_t<Iter>>>>,
-                    std::optional<meta::deref_return_t<Iter>>>;
-            using difference_type = blt::ptrdiff_t;
-            using pointer = value_type;
-            using reference = value_type;
-            
-            filter_wrapper(Iter iter, Pred func):
-                    deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
-            {}
-            
-            reference operator*() const
+    public:
+        using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
+        using value_type = std::conditional_t<
+            std::is_reference_v<meta::deref_return_t<Iter>>,
+            std::optional<std::reference_wrapper<std::remove_reference_t<meta::deref_return_t<Iter>>>>,
+            std::optional<meta::deref_return_t<Iter>>>;
+        using difference_type = blt::ptrdiff_t;
+        using pointer = value_type;
+        using reference = value_type;
+
+        filter_wrapper(Iter iter, Pred func):
+            deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
+        {
+        }
+
+        reference operator*() const
+        {
+            if (!func(*this->iter))
             {
-                if (!func(*this->iter))
+                return {};
+            }
+            return *this->iter;
+        }
+
+    private:
+        Pred func;
+    };
+
+    template <typename Iter>
+    class const_wrapper : public deref_only_wrapper<Iter, const_wrapper<Iter>>
+    {
+    public:
+        using ref_return = meta::deref_return_t<Iter>;
+
+        using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
+        using value_type = std::conditional_t<std::is_reference_v<ref_return>, std::remove_reference_t<ref_return>, ref_return>;
+        using difference_type = ptrdiff_t;
+        using pointer = const value_type*;
+        using reference = const value_type&;
+
+        explicit const_wrapper(Iter iter): deref_only_wrapper<Iter, const_wrapper>(std::move(iter))
+        {
+        }
+
+        template<typename T>
+        static auto make_const(T&& value) -> decltype(auto)
+        {
+            using Decay = std::decay_t<T>;
+            if constexpr (std::is_lvalue_reference_v<T>)
+            {
+                return const_cast<const Decay&>(value);
+            } else
+            {
+                return static_cast<const Decay>(value);
+            }
+        }
+
+        auto operator*() const
+        {
+            if constexpr (std::is_reference_v<ref_return>)
+            {
+                return const_cast<const value_type&>(*this->iter);
+            } else if constexpr (meta::is_tuple_v<value_type> || meta::is_pair_v<value_type>)
+            {
+                return std::apply([](auto&&... args)
                 {
-                    return {};
-                }
+                    return std::tuple<decltype(make_const(std::forward<decltype(args)>(args)))...>{make_const(std::forward<decltype(args)>(args))...};
+                }, *this->iter);
+            }
+            else
+            {
                 return *this->iter;
             }
-        
-        private:
-            Pred func;
+        }
     };
-    
+
     namespace impl
     {
-        template<typename Derived>
+        template <typename Derived>
         class skip_t
         {
-            private:
-                template<bool check>
-                auto skip_base(blt::size_t n)
+        private:
+            template <bool check>
+            auto skip_base(blt::size_t n)
+            {
+                auto* d = static_cast<Derived*>(this);
+                auto begin = d->begin();
+                auto end = d->end();
+
+                if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
                 {
-                    auto* d = static_cast<Derived*>(this);
-                    auto begin = d->begin();
-                    auto end = d->end();
-                    
-                    if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
+                    // random access iterators can have math directly applied to them.
+                    if constexpr (check)
                     {
-                        // random access iterators can have math directly applied to them.
-                        if constexpr (check)
-                        {
-                            return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
-                        } else
-                        {
-                            return Derived{begin + n, end};
-                        }
-                    } else
+                        return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
+                    }
+                    else
                     {
-                        for (blt::size_t i = 0; i < n; i++)
-                        {
-                            if constexpr (check)
-                            {
-                                if (begin == end)
-                                    break;
-                            }
-                            ++begin;
-                        }
-                        return Derived{std::move(begin), std::move(end)};
+                        return Derived{begin + n, end};
                     }
                 }
-            
-            public:
-                auto skip(blt::size_t n)
-                { return skip_base<false>(n); }
-                
-                auto skip_or(blt::size_t n)
-                { return skip_base<true>(n); }
+                else
+                {
+                    for (blt::size_t i = 0; i < n; i++)
+                    {
+                        if constexpr (check)
+                        {
+                            if (begin == end)
+                                break;
+                        }
+                        ++begin;
+                    }
+                    return Derived{std::move(begin), std::move(end)};
+                }
+            }
+
+        public:
+            auto skip(blt::size_t n)
+            {
+                return skip_base<false>(n);
+            }
+
+            auto skip_or(blt::size_t n)
+            {
+                return skip_base<true>(n);
+            }
         };
-        
-        template<typename Derived>
+
+        template <typename Derived>
         class take_t
         {
-            private:
-                template<bool check>
-                auto take_base(blt::size_t n)
+        private:
+            template <bool check>
+            auto take_base(blt::size_t n)
+            {
+                static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>,
+                              "Cannot .take() on an input iterator!");
+                auto* d = static_cast<Derived*>(this);
+                auto begin = d->begin();
+                auto end = d->end();
+
+                // take variant for forward and bidirectional iterators
+                if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> ||
+                    meta::is_bidirectional_iterator_category_v<typename Derived::iterator_category>)
                 {
-                    static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>,
-                                  "Cannot .take() on an input iterator!");
-                    auto* d = static_cast<Derived*>(this);
-                    auto begin = d->begin();
-                    auto end = d->end();
-                    
-                    // take variant for forward and bidirectional iterators
-                    if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> ||
-                                  meta::is_bidirectional_iterator_category_v<typename Derived::iterator_category>)
+                    // with these guys we have to loop forward to move the iterators. an unfortunate inefficiency
+                    auto new_end = begin;
+                    for (blt::size_t i = 0; i < n; i++)
                     {
-                        // with these guys we have to loop forward to move the iterators. an unfortunate inefficiency
-                        auto new_end = begin;
-                        for (blt::size_t i = 0; i < n; i++)
-                        {
-                            if constexpr (check)
-                            {
-                                if (new_end == end)
-                                    break;
-                            }
-                            ++new_end;
-                        }
-                        return Derived{std::move(begin), std::move(new_end)};
-                    } else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
-                    {
-                        // random access iterators can have math directly applied to them.
                         if constexpr (check)
                         {
-                            return Derived{begin, begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end))};
-                        } else
-                        {
-                            return Derived{begin, begin + n};
+                            if (new_end == end)
+                                break;
                         }
+                        ++new_end;
+                    }
+                    return Derived{std::move(begin), std::move(new_end)};
+                }
+                else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
+                {
+                    // random access iterators can have math directly applied to them.
+                    if constexpr (check)
+                    {
+                        return Derived{begin, begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end))};
+                    }
+                    else
+                    {
+                        return Derived{begin, begin + n};
                     }
                 }
-            
-            public:
-                auto take(blt::size_t n)
-                { return take_base<false>(n); }
-                
-                auto take_or(blt::size_t n)
-                { return take_base<true>(n); }
+            }
+
+        public:
+            auto take(blt::size_t n)
+            {
+                return take_base<false>(n);
+            }
+
+            auto take_or(blt::size_t n)
+            {
+                return take_base<true>(n);
+            }
         };
     }
-    
-    template<typename IterBase>
+
+    template <typename IterBase>
     class iterator_container : public impl::take_t<iterator_container<IterBase>>,
                                public impl::skip_t<iterator_container<IterBase>>
     {
-        public:
-            using iterator_category = typename std::iterator_traits<IterBase>::iterator_category;
-            using iterator = IterBase;
-            
-            iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end))
-            {}
-            
-            template<typename Iter>
-            iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end))
-            {}
-            
-            auto rev() const
-            {
-                static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
-                              ".rev() must be used with bidirectional (or better) iterators!");
-                return iterator_container<std::reverse_iterator<IterBase>>{std::reverse_iterator<IterBase>{end()},
-                                                                           std::reverse_iterator<IterBase>{begin()}};
-            }
-            
-            template<typename... Iter>
-            auto zip(iterator_pair<Iter>... iterator_pairs) const
-            {
-                return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
-            }
-            
-            template<typename... Container>
-            auto zip(Container& ... containers) const
-            {
-                return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
-                                              iterator_pair{containers.begin(), containers.end()}...);
-            }
-            
-            template<typename... Container>
-            auto zip(const Container& ... containers) const
-            {
-                return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
-                                              iterator_pair{containers.begin(), containers.end()}...);
-            }
-            
-            auto enumerate() const
-            {
-                return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
-            }
-            
-            template<typename Func>
-            auto map(Func func) const
-            {
-                return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{
-                        blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
-                        blt::iterator::map_wrapper<IterBase, Func>{m_end, func}};
-            }
-            
-            template<typename Pred>
-            auto filter(Pred pred) const
-            {
-                return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{
-                        blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred},
-                        blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}};
-            }
-            
-            auto begin() const
-            {
-                return m_begin;
-            }
-            
-            auto end() const
-            {
-                return m_end;
-            }
-        
-        protected:
-            IterBase m_begin;
-            IterBase m_end;
+    public:
+        using iterator_category = typename std::iterator_traits<IterBase>::iterator_category;
+        using iterator = IterBase;
+
+        iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end))
+        {
+        }
+
+        template <typename Iter>
+        iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end))
+        {
+        }
+
+        auto rev() const
+        {
+            static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
+                          ".rev() must be used with bidirectional (or better) iterators!");
+            return iterator_container<std::reverse_iterator<IterBase>>{
+                std::reverse_iterator<IterBase>{end()},
+                std::reverse_iterator<IterBase>{begin()}
+            };
+        }
+
+        template <typename... Iter>
+        auto zip(iterator_pair<Iter>... iterator_pairs) const
+        {
+            return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
+        }
+
+        template <typename... Container>
+        auto zip(Container&... containers) const
+        {
+            return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
+                                          iterator_pair{containers.begin(), containers.end()}...);
+        }
+
+        template <typename... Container>
+        auto zip(const Container&... containers) const
+        {
+            return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
+                                          iterator_pair{containers.begin(), containers.end()}...);
+        }
+
+        template <typename Iter>
+        auto zip(Iter begin, Iter end)
+        {
+            return zip(iterator_pair<Iter>{begin, end});
+        }
+
+        auto enumerate() const
+        {
+            return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
+        }
+
+        auto flatten() const
+        {
+            return iterator_container<flatten_wrapper<IterBase, false>>{
+                blt::iterator::flatten_wrapper<IterBase, false>{m_begin},
+                blt::iterator::flatten_wrapper<IterBase, false>{m_end}
+            };
+        }
+
+        auto flatten_all() const
+        {
+            return iterator_container<flatten_wrapper<IterBase, true>>{
+                blt::iterator::flatten_wrapper<IterBase, true>{m_begin},
+                blt::iterator::flatten_wrapper<IterBase, true>{m_end}
+            };
+        }
+
+        auto as_const() const
+        {
+            return iterator_container<const_wrapper<IterBase>>{
+                const_wrapper<IterBase>{m_begin},
+                const_wrapper<IterBase>{m_end}
+            };
+        }
+
+        template <typename Func>
+        auto map(Func func) const
+        {
+            return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{
+                blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
+                blt::iterator::map_wrapper<IterBase, Func>{m_end, func}
+            };
+        }
+
+        template <typename Pred>
+        auto filter(Pred pred) const
+        {
+            return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{
+                blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred},
+                blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}
+            };
+        }
+
+        auto begin() const
+        {
+            return m_begin;
+        }
+
+        auto end() const
+        {
+            return m_end;
+        }
+
+    protected:
+        IterBase m_begin;
+        IterBase m_end;
     };
-    
 }
 
 #endif //BLT_ITERATOR_ITER_COMMON

include/blt/iterator/enumerate.h

@@ -20,118 +20,112 @@
 #define BLT_ITERATOR_ENUMERATE_H
 
 #include <blt/iterator/common.h>
-#include <tuple>
 
 namespace blt
 {
-    
     namespace iterator
     {
-        /**
-         * struct which is returned by the enumerator.
-         * @tparam T type to store.
-         */
-        template<typename T>
-        struct enumerate_item
-        {
-            blt::size_t index;
-            T value;
-        };
-        
-        template<typename Iter>
+        template <typename Iter>
         class enumerate_wrapper : public passthrough_wrapper<Iter, enumerate_wrapper<Iter>>
         {
-            public:
-                enumerate_wrapper(blt::size_t index, Iter iter): passthrough_wrapper<Iter, enumerate_wrapper<Iter>>(std::move(iter)), index(index)
-                {}
-                
-                using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
-                using value_type = enumerate_item<meta::deref_return_t<Iter>>;
-                using difference_type = blt::ptrdiff_t;
-                using pointer = value_type;
-                using reference = value_type;
-                
-                enumerate_item<meta::deref_return_t<Iter>> operator*() const
-                {
-                    return {index, *this->iter};
-                }
-                
-                enumerate_wrapper& operator++()
-                {
-                    ++index;
-                    ++this->iter;
-                    return *this;
-                }
-                
-                enumerate_wrapper& operator--()
-                {
-                    --index;
-                    --this->iter;
-                    return *this;
-                }
-                
-                friend enumerate_wrapper operator+(const enumerate_wrapper& a, blt::ptrdiff_t n)
-                {
-                    static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
-                    auto copy = a;
-                    copy.index += n;
-                    copy.iter = copy.iter + n;
-                    return copy;
-                }
-                
-                friend enumerate_wrapper operator-(const enumerate_wrapper& a, blt::ptrdiff_t n)
-                {
-                    static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
-                    auto copy = a;
-                    copy.index -= n;
-                    copy.iter = copy.iter - n;
-                    return copy;
-                }
-            
-            private:
-                blt::size_t index;
+        public:
+            enumerate_wrapper(const size_t index, Iter iter): passthrough_wrapper<Iter, enumerate_wrapper<Iter>>(std::move(iter)), index(index)
+            {
+            }
+
+            using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
+            using value_type = enumerate_item<Iter>;
+            using difference_type = blt::ptrdiff_t;
+            using pointer = value_type;
+            using reference = value_type;
+
+            enumerate_item<meta::deref_return_t<Iter>> operator*() const
+            {
+                return {index, *this->iter};
+            }
+
+            enumerate_wrapper& operator++()
+            {
+                ++index;
+                ++this->iter;
+                return *this;
+            }
+
+            enumerate_wrapper& operator--()
+            {
+                --index;
+                --this->iter;
+                return *this;
+            }
+
+            friend enumerate_wrapper operator+(const enumerate_wrapper& a, blt::ptrdiff_t n)
+            {
+                static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
+                auto copy = a;
+                copy.index += n;
+                copy.iter = copy.iter + n;
+                return copy;
+            }
+
+            friend enumerate_wrapper operator-(const enumerate_wrapper& a, blt::ptrdiff_t n)
+            {
+                static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
+                auto copy = a;
+                copy.index -= n;
+                copy.iter = copy.iter - n;
+                return copy;
+            }
+
+        private:
+            blt::size_t index;
         };
     }
-    
-    template<typename Iter>
+
+    template <typename Iter>
     class enumerate_iterator_container : public iterator::iterator_container<iterator::enumerate_wrapper<Iter>>
     {
-        public:
-            using iterator::iterator_container<iterator::enumerate_wrapper<Iter>>::iterator_container;
-            
-            enumerate_iterator_container(Iter begin, Iter end, blt::size_t size):
-                    iterator::iterator_container<iterator::enumerate_wrapper<Iter>>(
-                            iterator::enumerate_wrapper<Iter>{0, std::move(begin)}, iterator::enumerate_wrapper<Iter>{size, std::move(end)})
-            {}
+    public:
+        using iterator::iterator_container<iterator::enumerate_wrapper<Iter>>::iterator_container;
+
+        enumerate_iterator_container(Iter begin, Iter end, blt::size_t size):
+            iterator::iterator_container<iterator::enumerate_wrapper<Iter>>(
+                iterator::enumerate_wrapper<Iter>{0, std::move(begin)}, iterator::enumerate_wrapper<Iter>{size, std::move(end)})
+        {
+        }
     };
-    
-    template<typename Iter>
+
+    template <typename Iter>
     enumerate_iterator_container(Iter, Iter, blt::size_t) -> enumerate_iterator_container<Iter>;
-    
-    template<typename T>
+
+    template <typename T>
     static inline auto enumerate(T& container)
     {
-        return enumerate_iterator_container{container.begin(), container.end(), container.size()};
+        return enumerate_iterator_container{
+            container.begin(), container.end(),
+            static_cast<blt::size_t>(std::distance(container.begin(), container.end()))
+        };
     }
-    
-    template<typename T>
+
+    template <typename T>
     static inline auto enumerate(const T& container)
     {
-        return enumerate_iterator_container{container.begin(), container.end(), container.size()};
+        return enumerate_iterator_container{
+            container.begin(), container.end(),
+            static_cast<blt::size_t>(std::distance(container.begin(), container.end()))
+        };
     }
-    
-    template<typename T, blt::size_t size>
-    static inline auto enumerate(const T(& container)[size])
+
+    template <typename T, blt::size_t size>
+    static inline auto enumerate(const T (&container)[size])
     {
         return enumerate_iterator_container{&container[0], &container[size], size};
     }
-    
-    template<typename T, blt::size_t size>
-    static inline auto enumerate(T(& container)[size])
+
+    template <typename T, blt::size_t size>
+    static inline auto enumerate(T (&container)[size])
     {
         return enumerate_iterator_container{&container[0], &container[size], size};
     }
-    
 }
 
 #endif //BLT_ITERATOR_ENUMERATE_H

include/blt/iterator/flatten.h

@@ -0,0 +1,89 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_ITERATOR_FLATTEN_H
+#define BLT_ITERATOR_FLATTEN_H
+
+#include <blt/iterator/common.h>
+#include <blt/meta/type_traits.h>
+#include <tuple>
+
+namespace blt::iterator
+{
+    namespace detail
+    {
+        template <typename Tuple>
+        static auto flatten_recursive(Tuple&& tuple) -> decltype(auto)
+        {
+            using Decay = std::decay_t<Tuple>;
+            if constexpr (meta::is_tuple_v<Decay> || meta::is_pair_v<Decay>)
+            {
+                return std::apply([](auto&&... args)
+                {
+                    return std::tuple_cat(flatten_recursive(std::forward<decltype(args)>(args))...);
+                }, std::forward<Tuple>(tuple));
+            }
+            else
+            {
+                return forward_as_tuple(std::forward<Tuple>(tuple));
+            }
+        }
+
+        template <typename Tuple>
+        static auto flatten(Tuple&& tuple) -> decltype(auto)
+        {
+            return std::apply([](auto&&... args)
+            {
+                return std::tuple_cat(ensure_tuple(std::forward<decltype(args)>(args))...);
+            }, std::forward<Tuple>(tuple));
+        }
+    }
+
+    template <typename Iter, bool Recursive>
+    class flatten_wrapper : public deref_only_wrapper<Iter, flatten_wrapper<Iter, Recursive>>
+    {
+    public:
+        using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
+        using value_type = std::conditional_t<Recursive,
+                                              std::remove_reference_t<decltype(detail::flatten_recursive(*std::declval<Iter>()))>,
+                                              std::remove_reference_t<decltype(detail::flatten(*std::declval<Iter>()))>>;
+        using difference_type = ptrdiff_t;
+        using pointer = value_type*;
+        using reference = value_type&;
+
+        explicit flatten_wrapper(Iter iter):
+            deref_only_wrapper<Iter, flatten_wrapper>(std::move(iter))
+        {
+        }
+
+        auto operator*() const -> decltype(auto)
+        {
+            if constexpr (Recursive)
+            {
+                return detail::flatten_recursive(*this->iter);
+            }
+            else
+            {
+                return detail::flatten(*this->iter);
+            }
+        }
+    };
+}
+
+
+#endif //BLT_ITERATOR_FLATTEN_H

include/blt/iterator/fwddecl.h

@@ -19,6 +19,8 @@
 #ifndef BLT_ITERATOR_FWDDECL_H
 #define BLT_ITERATOR_FWDDECL_H
 
+#include <utility>
+
 namespace blt
 {
     template<typename... Iter>
@@ -33,7 +35,7 @@ namespace blt
         struct iterator_pair;
         
         template<typename T>
-        struct enumerate_item;
+        using enumerate_item = std::pair<size_t, T>;
         
         template<typename Iter>
         class enumerate_wrapper;
@@ -46,6 +48,12 @@ namespace blt
         
         template<typename Iter, typename Pred>
         class filter_wrapper;
+
+        template<typename Iter, bool Recursive>
+        class flatten_wrapper;
+
+        template<typename Iter>
+        class const_wrapper;
         
         namespace impl
         {

include/blt/iterator/iterator.h

@@ -29,6 +29,12 @@
 namespace blt
 {
     
+    template<typename T>
+    static inline auto iterate(T begin, T end)
+    {
+        return iterator::iterator_container<T>{std::move(begin), std::move(end)};
+    }
+    
     template<typename T>
     static inline auto iterate(T& container)
     {

include/blt/logging/logging.h

@@ -0,0 +1,83 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_LOGGING_LOGGING_H
+#define BLT_LOGGING_LOGGING_H
+
+#include <iostream>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <blt/std/utility.h>
+#include <blt/meta/meta.h>
+
+namespace blt::logging
+{
+	struct logger_t
+	{
+		explicit logger_t() = default;
+
+		template <typename T>
+		void print_value(T&& t)
+		{
+			static_assert(meta::is_streamable_v<T>, "T must be streamable in order to work with blt::logging!");
+			m_stream << std::forward<T>(t);
+		}
+
+		template <typename... Args>
+		std::string log(std::string fmt, Args&&... args)
+		{
+			compile(std::move(fmt));
+			((consume_until_fmt(), print_value(std::forward<Args>(args))), ...);
+			return to_string();
+		}
+
+		std::string to_string();
+
+	private:
+		void compile(std::string fmt);
+
+		void consume_until_fmt();
+
+		std::string m_fmt;
+		std::stringstream m_stream;
+		size_t m_last_fmt_pos = 0;
+	};
+
+	void print(const std::string& fmt);
+
+	void newline();
+
+	logger_t& get_global_logger();
+
+	template <typename... Args>
+	void print(std::string fmt, Args&&... args)
+	{
+		auto& logger = get_global_logger();
+		print(logger.log(std::move(fmt), std::forward<Args>(args)...));
+	}
+
+	template <typename... Args>
+	void println(std::string fmt, Args&&... args)
+	{
+		print(std::move(fmt), std::forward<Args>(args)...);
+		newline();
+	}
+}
+
+#endif // BLT_LOGGING_LOGGING_H

include/blt/logging/status.h

@@ -0,0 +1,27 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_LOGGING_STATUS_H
+#define BLT_LOGGING_STATUS_H
+
+namespace blt::logging
+{
+
+}
+
+#endif //BLT_LOGGING_STATUS_H

include/blt/math/matrix.h

@@ -12,6 +12,7 @@
 #include <type_traits>
 #include <array>
 #include <initializer_list>
+#include "blt/iterator/iterator.h"
 
 #ifndef M_PI
 // MSVC does not have M_PI
@@ -24,6 +25,10 @@ namespace blt
     template<typename T, blt::u32 rows, blt::u32 columns>
     class generalized_matrix
     {
+        public:
+            static constexpr auto data_rows = rows;
+            static constexpr auto data_columns = columns;
+        private:
             using matrix_t = generalized_matrix<T, rows, columns>;
             enum class init_type
             {
@@ -163,6 +168,14 @@ namespace blt
                 return copy;
             }
             
+            [[nodiscard]] constexpr matrix_t bipolar() const
+            {
+                matrix_t copy = *this;
+                for (auto& v : copy.data)
+                    v = v.bipolar();
+                return copy;
+            }
+            
             constexpr inline const blt::vec<T, rows>& operator[](u32 column) const
             {
                 return data[column];

include/blt/math/vectors.h

@@ -17,377 +17,401 @@
 
 namespace blt
 {
-
 #define MSVC_COMPILER (!defined(__GNUC__) && !defined(__clang__))
-    
+
     constexpr float EPSILON = std::numeric_limits<float>::epsilon();
-    
+
     static inline constexpr bool f_equal(float v1, float v2)
     {
         return v1 >= v2 - EPSILON && v1 <= v2 + EPSILON;
     }
-    
-    template<typename T, blt::u32 size>
+
+    template <typename T, blt::u32 size>
     struct vec
     {
-            static_assert(std::is_arithmetic_v<T> && "blt::vec must be created using an arithmetic type!");
-        private:
-            std::array<T, size> elements;
-        public:
-            constexpr vec()
+        static_assert(std::is_arithmetic_v<T> && "blt::vec must be created using an arithmetic type!");
+
+    private:
+        std::array<T, size> elements;
+
+    public:
+        constexpr static blt::u32 data_size = size;
+
+        constexpr vec()
+        {
+            for (auto& v : elements)
+                v = static_cast<T>(0);
+        }
+
+        /**
+         * Create a vector with initializer list, if the initializer list doesn't contain enough values to fill this vec, it will use t
+         * @param t default value to fill with
+         * @param args list of args
+         */
+        template <typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool>  = true>
+        constexpr vec(U t, std::initializer_list<U> args): elements()
+        {
+            auto b = args.begin();
+            for (auto& v : elements)
             {
-                for (auto& v : elements)
-                    v = static_cast<T>(0);
-            }
-            
-            /**
-             * Create a vector with initializer list, if the initializer list doesn't contain enough values to fill this vec, it will use t
-             * @param t default value to fill with
-             * @param args list of args
-             */
-            template<typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool> = true>
-            constexpr vec(U t, std::initializer_list<U> args): elements()
-            {
-                auto b = args.begin();
-                for (auto& v : elements)
+                if (b == args.end())
                 {
-                    if (b == args.end())
-                    {
-                        v = t;
-                        continue;
-                    }
-                    v = *b;
-                    ++b;
-                }
-            }
-            
-            /**
-             * Create a vector from an initializer list, if the list doesn't have enough elements it will be filled with the default value (0)
-             * @param args
-             */
-            template<typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool> = true>
-            constexpr vec(std::initializer_list<U> args): vec(U(), args)
-            {}
-            
-            template<typename... Args, std::enable_if_t<sizeof...(Args) == size, bool> = true>
-            constexpr explicit vec(Args... args): vec(std::array<T, size>{static_cast<T>(args)...})
-            {}
-            
-            constexpr explicit vec(T t)
-            {
-                for (auto& v : elements)
                     v = t;
-            }
-            
-            constexpr explicit vec(const T elem[size])
-            {
-                for (size_t i = 0; i < size; i++)
-                    elements[i] = elem[i];
-            }
-            
-            constexpr explicit vec(std::array<T, size> elem): elements(elem)
-            {}
-            
-            template<typename G, size_t base_size, std::enable_if_t<std::is_convertible_v<G, T>, bool> = true>
-            constexpr explicit vec(std::array<G, base_size> el): elements()
-            {
-                auto b = el.begin();
-                auto m = elements.begin();
-                while (b != el.end() && m != elements.end())
-                {
-                    *m = *b;
-                    ++m;
-                    ++b;
+                    continue;
                 }
+                v = *b;
+                ++b;
             }
-            
-            [[nodiscard]] constexpr inline T x() const
+        }
+
+        /**
+         * Create a vector from an initializer list, if the list doesn't have enough elements it will be filled with the default value (0)
+         * @param args
+         */
+        template <typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool>  = true>
+        constexpr vec(std::initializer_list<U> args): vec(U(), args)
+        {
+        }
+
+        template <typename... Args, std::enable_if_t<sizeof...(Args) == size, bool>  = true>
+        constexpr explicit vec(Args... args): vec(std::array<T, size>{static_cast<T>(args)...})
+        {
+        }
+
+        constexpr explicit vec(T t)
+        {
+            for (auto& v : elements)
+                v = t;
+        }
+
+        constexpr explicit vec(const T elem[size])
+        {
+            for (size_t i = 0; i < size; i++)
+                elements[i] = elem[i];
+        }
+
+        constexpr explicit vec(std::array<T, size> elem): elements(elem)
+        {
+        }
+
+        template <typename G, size_t base_size, std::enable_if_t<std::is_convertible_v<G, T>, bool>  = true>
+        constexpr explicit vec(std::array<G, base_size> el): elements()
+        {
+            auto b = el.begin();
+            auto m = elements.begin();
+            while (b != el.end() && m != elements.end())
             {
-                return elements[0];
-            }
-            
-            [[nodiscard]] constexpr inline T y() const
-            {
-                static_assert(size > 1);
-                return elements[1];
-            }
-            
-            [[nodiscard]] constexpr inline T z() const
-            {
-                static_assert(size > 2);
-                return elements[2];
-            }
-            
-            [[nodiscard]] constexpr inline T w() const
-            {
-                static_assert(size > 3);
-                return elements[3];
-            }
-            
-            [[nodiscard]] constexpr inline vec<T, size> abs() const
-            {
-                auto copy = *this;
-                for (auto& v : copy.elements)
-                    v = std::abs(v);
-                return copy;
-            }
-            
-            [[nodiscard]] constexpr inline T magnitude() const
-            {
-                T total = 0;
-                for (blt::u32 i = 0; i < size; i++)
-                    total += elements[i] * elements[i];
-                return std::sqrt(total);
-            }
-            
-            [[nodiscard]] constexpr inline vec<T, size> normalize() const
-            {
-                T mag = this->magnitude();
-                if (mag == 0)
-                    return vec<T, size>(*this);
-                return *this / mag;
-            }
-            
-            constexpr inline T& operator[](blt::size_t index)
-            {
-                return elements[index];
-            }
-            
-            constexpr inline T operator[](blt::size_t index) const
-            {
-                return elements[index];
-            }
-            
-            constexpr inline vec<T, size>& operator=(T v)
-            {
-                for (blt::u32 i = 0; i < size; i++)
-                    elements[i] = v;
-                return *this;
-            }
-            
-            constexpr inline vec<T, size> operator-()
-            {
-                vec<T, size> initializer{};
-                for (blt::u32 i = 0; i < size; i++)
-                    initializer[i] = -elements[i];
-                return vec<T, size>{initializer};
-            }
-            
-            constexpr inline vec<T, size>& operator+=(const vec<T, size>& other)
-            {
-                for (blt::u32 i = 0; i < size; i++)
-                    elements[i] += other[i];
-                return *this;
-            }
-            
-            constexpr inline vec<T, size>& operator*=(const vec<T, size>& other)
-            {
-                for (blt::u32 i = 0; i < size; i++)
-                    elements[i] *= other[i];
-                return *this;
-            }
-            
-            constexpr inline vec<T, size>& operator+=(T f)
-            {
-                for (blt::u32 i = 0; i < size; i++)
-                    elements[i] += f;
-                return *this;
-            }
-            
-            constexpr inline vec<T, size>& operator*=(T f)
-            {
-                for (blt::u32 i = 0; i < size; i++)
-                    elements[i] *= f;
-                return *this;
-            }
-            
-            constexpr inline vec<T, size>& operator-=(const vec<T, size>& other)
-            {
-                for (blt::u32 i = 0; i < size; i++)
-                    elements[i] -= other[i];
-                return *this;
-            }
-            
-            constexpr inline vec<T, size>& operator-=(T f)
-            {
-                for (blt::u32 i = 0; i < size; i++)
-                    elements[i] -= f;
-                return *this;
-            }
-            
-            /**
-             * performs the dot product of left * right
-             */
-            constexpr static inline T dot(const vec<T, size>& left, const vec<T, size>& right)
-            {
-                T dot = 0;
-                for (blt::u32 i = 0; i < size; i++)
-                    dot += left[i] * right[i];
-                return dot;
-            }
-            
-            constexpr static inline vec<T, size> cross(
-                    const vec<T, size>& left, const vec<T, size>& right
-                                                      )
-            {
-                // cross is only defined on vectors of size 3. 2D could be implemented, which is a TODO
-                static_assert(size == 3);
-                return {left.y() * right.z() - left.z() * right.y(),
-                        left.z() * right.x() - left.x() * right.z(),
-                        left.x() * right.y() - left.y() * right.x()};
-            }
-            
-            constexpr static inline vec<T, size> project(
-                    const vec<T, size>& u, const vec<T, size>& v
-                                                        )
-            {
-                T du = dot(u);
-                T dv = dot(v);
-                return (du / dv) * v;
-            }
-            
-            constexpr inline auto* data()
-            {
-                return elements.data();
-            }
-            
-            [[nodiscard]] constexpr inline const auto* data() const
-            {
-                return elements.data();
-            }
-            
-            constexpr auto begin()
-            {
-                return elements.begin();
-            }
-            
-            constexpr auto end()
-            {
-                return elements.end();
-            }
-            
-            constexpr auto rbegin()
-            {
-                return elements.rbegin();
-            }
-            
-            constexpr auto rend()
-            {
-                return elements.rend();
-            }
-            
-            [[nodiscard]] constexpr auto cbegin() const
-            {
-                return elements.cbegin();
-            }
-            
-            [[nodiscard]] constexpr auto cend() const
-            {
-                return elements.cend();
+                *m = *b;
+                ++m;
+                ++b;
             }
+        }
+
+        [[nodiscard]] constexpr inline T x() const
+        {
+            return elements[0];
+        }
+
+        [[nodiscard]] constexpr inline T y() const
+        {
+            static_assert(size > 1);
+            return elements[1];
+        }
+
+        [[nodiscard]] constexpr inline T z() const
+        {
+            static_assert(size > 2);
+            return elements[2];
+        }
+
+        [[nodiscard]] constexpr inline T w() const
+        {
+            static_assert(size > 3);
+            return elements[3];
+        }
+
+        [[nodiscard]] constexpr inline vec<T, size> abs() const
+        {
+            auto copy = *this;
+            for (auto& v : copy.elements)
+                v = std::abs(v);
+            return copy;
+        }
+
+        [[nodiscard]] constexpr inline vec<T, size> bipolar() const
+        {
+            auto copy = *this;
+            for (auto& v : copy.elements)
+                v = v >= 0 ? 1 : -1;
+            return copy;
+        }
+
+        [[nodiscard]] constexpr inline T magnitude() const
+        {
+            T total = 0;
+            for (blt::u32 i = 0; i < size; i++)
+                total += elements[i] * elements[i];
+            return std::sqrt(total);
+        }
+
+        [[nodiscard]] constexpr inline vec<T, size> normalize() const
+        {
+            T mag = this->magnitude();
+            if (mag == 0)
+                return vec<T, size>(*this);
+            return *this / mag;
+        }
+
+        constexpr inline T& operator[](blt::size_t index)
+        {
+            return elements[index];
+        }
+
+        constexpr inline T operator[](blt::size_t index) const
+        {
+            return elements[index];
+        }
+
+        constexpr inline vec<T, size>& operator=(T v)
+        {
+            for (blt::u32 i = 0; i < size; i++)
+                elements[i] = v;
+            return *this;
+        }
+
+        constexpr inline vec<T, size> operator-()
+        {
+            vec<T, size> initializer{};
+            for (blt::u32 i = 0; i < size; i++)
+                initializer[i] = -elements[i];
+            return vec<T, size>{initializer};
+        }
+
+        constexpr inline vec<T, size>& operator+=(const vec<T, size>& other)
+        {
+            for (blt::u32 i = 0; i < size; i++)
+                elements[i] += other[i];
+            return *this;
+        }
+
+        constexpr inline vec<T, size>& operator*=(const vec<T, size>& other)
+        {
+            for (blt::u32 i = 0; i < size; i++)
+                elements[i] *= other[i];
+            return *this;
+        }
+
+        constexpr inline vec<T, size>& operator+=(T f)
+        {
+            for (blt::u32 i = 0; i < size; i++)
+                elements[i] += f;
+            return *this;
+        }
+
+        constexpr inline vec<T, size>& operator*=(T f)
+        {
+            for (blt::u32 i = 0; i < size; i++)
+                elements[i] *= f;
+            return *this;
+        }
+
+        constexpr inline vec<T, size>& operator-=(const vec<T, size>& other)
+        {
+            for (blt::u32 i = 0; i < size; i++)
+                elements[i] -= other[i];
+            return *this;
+        }
+
+        constexpr inline vec<T, size>& operator-=(T f)
+        {
+            for (blt::u32 i = 0; i < size; i++)
+                elements[i] -= f;
+            return *this;
+        }
+
+        /**
+         * performs the dot product of left * right
+         */
+        constexpr static inline T dot(const vec<T, size>& left, const vec<T, size>& right)
+        {
+            T dot = 0;
+            for (blt::u32 i = 0; i < size; i++)
+                dot += left[i] * right[i];
+            return dot;
+        }
+
+        constexpr static inline vec<T, size> cross(
+            const vec<T, size>& left, const vec<T, size>& right
+        )
+        {
+            // cross is only defined on vectors of size 3. 2D could be implemented, which is a TODO
+            static_assert(size == 3);
+            return {
+                left.y() * right.z() - left.z() * right.y(),
+                left.z() * right.x() - left.x() * right.z(),
+                left.x() * right.y() - left.y() * right.x()
+            };
+        }
+
+        constexpr static inline vec<T, size> project(
+            const vec<T, size>& u, const vec<T, size>& v
+        )
+        {
+            T du = dot(u);
+            T dv = dot(v);
+            return (du / dv) * v;
+        }
+
+        constexpr inline auto* data()
+        {
+            return elements.data();
+        }
+
+        [[nodiscard]] constexpr inline const auto* data() const
+        {
+            return elements.data();
+        }
+
+        [[nodiscard]] constexpr auto begin() const
+        {
+            return elements.begin();
+        }
+
+        [[nodiscard]] constexpr auto end() const
+        {
+            return elements.end();
+        }
+
+        [[nodiscard]] constexpr auto rbegin() const
+        {
+            return elements.rbegin();
+        }
+
+        [[nodiscard]] constexpr auto rend() const
+        {
+            return elements.rend();
+        }
+
+        [[nodiscard]] constexpr auto cbegin() const
+        {
+            return elements.cbegin();
+        }
+
+        [[nodiscard]] constexpr auto cend() const
+        {
+            return elements.cend();
+        }
+
+        friend std::size_t hash_value(const vec& obj)
+        {
+            std::size_t seed = 0x5410391E;
+            for (const auto& v : obj)
+                seed ^= (seed << 6) + (seed >> 2) + std::hash<T>{}(v);
+            return seed;
+        }
     };
-    
-    template<typename T, blt::u32 size>
-    inline constexpr vec<T, size> operator+(const vec<T, size>& left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
+    inline constexpr vec<R, size> operator+(const vec<T, size>& left, const vec<G, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] + right[i];
+            initializer[i] = static_cast<R>(left[i]) + static_cast<R>(right[i]);
         return initializer;
     }
-    
-    template<typename T, blt::u32 size>
-    inline constexpr vec<T, size> operator-(const vec<T, size>& left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
+    inline constexpr vec<R, size> operator-(const vec<T, size>& left, const vec<G, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] - right[i];
+            initializer[i] = static_cast<R>(left[i]) - static_cast<R>(right[i]);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator+(const vec<T, size>& left, G right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
+    inline constexpr vec<R, size> operator+(const vec<T, size>& left, G right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] + static_cast<T>(right);
+            initializer[i] = static_cast<R>(left[i]) + static_cast<R>(right);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator-(const vec<T, size>& left, G right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
+    inline constexpr vec<R, size> operator-(const vec<T, size>& left, G right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] + static_cast<T>(right);
+            initializer[i] = static_cast<R>(left[i]) - static_cast<R>(right);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator+(G left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
+    inline constexpr vec<R, size> operator+(G left, const vec<T, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = static_cast<T>(left) + right[i];
+            initializer[i] = static_cast<R>(left) + static_cast<R>(right[i]);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator-(G left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
+    inline constexpr vec<R, size> operator-(G left, const vec<T, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = static_cast<T>(left) - right[i];
+            initializer[i] = static_cast<R>(left) - static_cast<R>(right[i]);
         return initializer;
     }
-    
-    template<typename T, blt::u32 size>
-    inline constexpr vec<T, size> operator*(const vec<T, size>& left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
+    inline constexpr vec<R, size> operator*(const vec<T, size>& left, const vec<G, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] * right[i];
+            initializer[i] = static_cast<R>(left[i]) * static_cast<R>(right[i]);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator*(const vec<T, size>& left, G right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
+    inline constexpr vec<R, size> operator*(const vec<T, size>& left, G right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] * static_cast<T>(right);
+            initializer[i] = static_cast<R>(left[i]) * static_cast<R>(right);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator*(G left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
+    inline constexpr vec<R, size> operator*(G left, const vec<T, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = static_cast<T>(left) * right[i];
+            initializer[i] = static_cast<R>(left) * static_cast<R>(right[i]);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator/(const vec<T, size>& left, G right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
+    inline constexpr vec<R, size> operator/(const vec<T, size>& left, G right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] / static_cast<T>(right);
+            initializer[i] = static_cast<R>(left[i]) / static_cast<R>(right);
         return initializer;
     }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator/(G left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
+    inline constexpr vec<R, size> operator/(G left, const vec<T, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = static_cast<T>(left) / right[i];
+            initializer[i] = static_cast<R>(left) / static_cast<R>(right[i]);
         return initializer;
     }
-    
-    template<typename T, blt::u32 size>
-    inline constexpr bool operator==(const vec<T, size>& left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size>
+    inline constexpr bool operator==(const vec<T, size>& left, const vec<G, size>& right)
     {
         constexpr double E = std::numeric_limits<T>::epsilon();
         for (blt::u32 i = 0; i < size; i++)
@@ -398,77 +422,79 @@ namespace blt
         }
         return true;
     }
-    
-    template<typename T, blt::u32 size>
-    inline constexpr bool operator!=(const vec<T, size>& left, const vec<T, size>& right)
+
+    template <typename T, typename G, blt::u32 size>
+    inline constexpr bool operator!=(const vec<T, size>& left, const vec<G, size>& right)
     {
         return !(left == right);
     }
-    
-    template<typename T, blt::u32 size>
-    inline constexpr bool operator&&(const vec<T, size>& left, const vec<T, size>& right)
+
+    template <typename Ret, typename T, blt::u32 size>
+    inline constexpr vec<Ret, size> vec_cast(const vec<T, size>& conv)
     {
+        vec<Ret, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            if (!f_equal(left[i], right[i]))
-                return false;
-        return true;
+            initializer[i] = static_cast<Ret>(conv[i]);
+        return initializer;
     }
-    
+
     using vec2f = vec<float, 2>;
     using vec3f = vec<float, 3>;
     using vec4f = vec<float, 4>;
-    
+
     using vec2d = vec<double, 2>;
     using vec3d = vec<double, 3>;
     using vec4d = vec<double, 4>;
-    
+
     using vec2i = vec<blt::i32, 2>;
     using vec3i = vec<blt::i32, 3>;
     using vec4i = vec<blt::i32, 4>;
-    
+
     using vec2l = vec<blt::i64, 2>;
     using vec3l = vec<blt::i64, 3>;
     using vec4l = vec<blt::i64, 4>;
-    
+
     using vec2ui = vec<blt::u32, 2>;
     using vec3ui = vec<blt::u32, 3>;
     using vec4ui = vec<blt::u32, 4>;
-    
+
     using vec2ul = vec<blt::u64, 2>;
     using vec3ul = vec<blt::u64, 3>;
     using vec4ul = vec<blt::u64, 4>;
-    
+
     using vec2 = vec2f;
     using vec3 = vec3f;
     using vec4 = vec4f;
-    
+
     using color4 = vec4;
     using color3 = vec3;
-    
+
     inline constexpr color4 make_color(float r, float g, float b)
     {
         return color4{r, g, b, 1.0f};
     }
-    
-    template<typename ValueType, u32 size>
+
+    template <typename ValueType, u32 size>
     inline constexpr blt::vec<ValueType, 2> make_vec2(const blt::vec<ValueType, size>& t, size_t fill = 0)
     {
         if constexpr (size >= 2)
         {
             return blt::vec<ValueType, 2>(t.x(), t.y());
-        } else
+        }
+        else
         {
             return blt::vec<ValueType, 2>(t.x(), fill);
         }
     }
-    
-    template<typename ValueType, u32 size>
+
+    template <typename ValueType, u32 size>
     inline constexpr blt::vec<ValueType, 3> make_vec3(const blt::vec<ValueType, size>& t, size_t fill = 0)
     {
         if constexpr (size >= 3)
         {
             return blt::vec<ValueType, 3>(t.x(), t.y(), t.z());
-        } else
+        }
+        else
         {
             blt::vec<ValueType, 3> ret;
             for (size_t i = 0; i < size; i++)
@@ -478,14 +504,15 @@ namespace blt
             return ret;
         }
     }
-    
-    template<typename ValueType, u32 size>
+
+    template <typename ValueType, u32 size>
     inline constexpr blt::vec<ValueType, 4> make_vec4(const blt::vec<ValueType, size>& t, size_t fill = 0)
     {
         if constexpr (size >= 4)
         {
             return blt::vec<ValueType, 4>(t.x(), t.y(), t.z(), t.w());
-        } else
+        }
+        else
         {
             blt::vec<ValueType, 4> ret;
             for (size_t i = 0; i < size; i++)
@@ -495,33 +522,33 @@ namespace blt
             return ret;
         }
     }
-    
+
     namespace vec_algorithm
     {
         static inline void findOrthogonalBasis(const vec3& v, vec3& v1, vec3& v2, vec3& v3)
         {
             v1 = v.normalize();
-            
+
             vec3 arbitraryVector{1, 0, 0};
             if (std::abs(vec3::dot(v, arbitraryVector)) > 0.9)
             {
                 arbitraryVector = vec3{0, 1, 0};
             }
-            
+
             v2 = vec3::cross(v, arbitraryVector).normalize();
             v3 = vec3::cross(v1, v2);
         }
-        
+
         // Gram-Schmidt orthonormalization algorithm
         static inline void gramSchmidt(std::vector<vec3>& vectors)
         {
-            int n = (int) vectors.size();
+            int n = (int)vectors.size();
             std::vector<vec3> basis;
-            
+
             // normalize first vector
             basis.push_back(vectors[0]);
             basis[0] = basis[0].normalize();
-            
+
             // iterate over the rest of the vectors
             for (int i = 1; i < n; ++i)
             {
@@ -538,7 +565,7 @@ namespace blt
                 new_vector = new_vector.normalize();
                 basis.push_back(new_vector);
             }
-            
+
             vectors = basis;
         }
     }

include/blt/meta/codegen.h

@@ -0,0 +1,55 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_META_CODEGEN_H
+#define BLT_META_CODEGEN_H
+
+namespace blt
+{
+#define BLT_CONST_LVALUE_GETTER(TYPE, NAME) const TYPE& get_##NAME() const { return NAME; }
+#define BLT_LVALUE_GETTER(TYPE, NAME) TYPE& get_##NAME() { return NAME; }
+#define BLT_PRVALUE_GETTER(TYPE, NAME) TYPE get_##NAME() const { return NAME; }
+
+#define BLT_GLVALUE_GETTER(TYPE, NAME)                                  \
+    BLT_CONST_LVALUE_GETTER(TYPE, NAME)                                 \
+    BLT_LVALUE_GETTER(TYPE, NAME)
+
+#define BLT_PRVALUE_SETTER(TYPE, NAME)                                  \
+    auto& set_##NAME(TYPE new_##NAME)                                   \
+    {                                                                   \
+        NAME = new_##NAME;                                              \
+        return *this;                                                   \
+    }
+
+#define BLT_PRVALUE_MOVE_SETTER(TYPE, NAME)                             \
+    auto& set_##NAME(TYPE new_##NAME)                                   \
+    {                                                                   \
+        NAME = std::move(new_##NAME);                                   \
+        return *this;                                                   \
+    }
+
+#define BLT_LVALUE_SETTER(TYPE, NAME)                                   \
+    auto& set_##NAME(const TYPE& new_##NAME)                            \
+    {                                                                   \
+        NAME = new_##NAME;                                              \
+        return *this;                                                   \
+    }
+    
+}
+
+#endif //BLT_META_CODEGEN_H

include/blt/meta/meta.h

@@ -114,7 +114,7 @@ namespace blt::meta
     template<typename T>
     struct deref_return
     {
-        using type = typename std::invoke_result_t<decltype(&T::operator*), T&>;
+        using type = std::invoke_result_t<decltype(&T::operator*), T&>;
     };
     
     template<typename T>
@@ -137,6 +137,15 @@ namespace blt::meta
     template<typename T> \
     inline constexpr bool has_func_##FUNC##_v = has_func_##FUNC<T>::value;
 
+#define BLT_META_MAKE_STATIC_FUNCTION_CHECK(FUNC, ...)\
+    template<typename T, typename = void> \
+    class has_static_func_##FUNC : public std::false_type \
+    {}; \
+    template<typename T> \
+    class has_static_func_##FUNC<T, std::void_t<decltype(T::FUNC(,##__VA_ARGS__))>> : public std::true_type \
+    {}; \
+    template<typename T> \
+    inline constexpr bool has_static_func_##FUNC##_v = has_static_func_##FUNC<T>::value;
 
 #define BLT_META_MAKE_MEMBER_CHECK(MEMBER)\
     template<typename T, typename = void> \

include/blt/meta/type_traits.h

@@ -0,0 +1,73 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_META_TYPE_TRAITS_H
+#define BLT_META_TYPE_TRAITS_H
+
+#include <type_traits>
+#include <tuple>
+
+namespace blt::meta
+{
+    namespace detail
+    {
+        template<typename... Args>
+        void empty_apply_function(Args...)
+        {
+
+        }
+
+        inline auto lambda = [](auto...)
+        {
+        };
+    }
+
+    template <typename T>
+    using remove_cvref_t = std::remove_volatile_t<std::remove_const_t<std::remove_reference_t<T>>>;
+
+    template <typename U>
+    using add_const_ref_t = std::conditional_t<std::is_reference_v<U>, const std::remove_reference_t<U>&, const U>;
+
+    template <typename>
+    struct is_tuple : std::false_type
+    {
+    };
+
+    template <typename... T>
+    struct is_tuple<std::tuple<T...>> : std::true_type
+    {
+    };
+
+    template <typename>
+    struct is_pair : std::false_type
+    {
+    };
+
+    template <typename T, typename G>
+    struct is_pair<std::pair<T, G>> : std::true_type
+    {
+    };
+
+    template <typename T>
+    static constexpr bool is_tuple_v = is_tuple<T>::value;
+
+    template <typename T>
+    static constexpr bool is_pair_v = is_pair<T>::value;
+}
+
+#endif // BLT_META_TYPE_TRAITS_H

include/blt/parse/argparse_v2.h

@@ -0,0 +1,811 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_PARSE_ARGPARSE_V2_H
+#define BLT_PARSE_ARGPARSE_V2_H
+
+#include <complex>
+#include <blt/std/types.h>
+#include <blt/std/hashmap.h>
+#include <blt/meta/meta.h>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <variant>
+#include <optional>
+#include <memory>
+#include <functional>
+#include <type_traits>
+#include <blt/iterator/iterator.h>
+#include <blt/meta/type_traits.h>
+#include <blt/std/assert.h>
+#include <blt/std/expected.h>
+#include <blt/std/ranges.h>
+#include <blt/std/utility.h>
+
+namespace blt::argparse
+{
+    class argument_string_t;
+    class argument_consumer_t;
+    class argument_parser_t;
+    class argument_subparser_t;
+    class argument_builder_t;
+    class argument_storage_t;
+    class argument_positional_storage_t;
+
+    enum class action_t
+    {
+        STORE,
+        STORE_CONST,
+        STORE_TRUE,
+        STORE_FALSE,
+        APPEND,
+        APPEND_CONST,
+        EXTEND,
+        COUNT,
+        HELP,
+        VERSION
+    };
+
+    enum class nargs_t
+    {
+        IF_POSSIBLE,
+        ALL,
+        ALL_AT_LEAST_ONE
+    };
+
+    using nargs_v = std::variant<nargs_t, i32>;
+
+    namespace detail
+    {
+        class bad_flag final : public std::runtime_error
+        {
+        public:
+            explicit bad_flag(const std::string& message): std::runtime_error(message)
+            {
+            }
+        };
+
+        class bad_positional final : public std::runtime_error
+        {
+        public:
+            explicit bad_positional(const std::string& message): std::runtime_error(message)
+            {
+            }
+        };
+
+        class missing_argument_error final : public std::runtime_error
+        {
+        public:
+            explicit missing_argument_error(const std::string& message): std::runtime_error(message)
+            {
+            }
+        };
+
+        class missing_value_error final : public std::runtime_error
+        {
+        public:
+            explicit missing_value_error(const std::string& message): std::runtime_error(message)
+            {
+            }
+        };
+
+        class type_error final : public std::runtime_error
+        {
+        public:
+            explicit type_error(const std::string& message): std::runtime_error(message)
+            {
+            }
+        };
+
+        class unexpected_argument_error final : public std::runtime_error
+        {
+        public:
+            explicit unexpected_argument_error(const std::string& message): std::runtime_error(message)
+            {
+            }
+        };
+
+        class bad_choice_error final : public std::runtime_error
+        {
+        public:
+            explicit bad_choice_error(const std::string& message): std::runtime_error(message)
+            {
+            }
+        };
+
+        class subparse_error final : public std::exception
+        {
+        public:
+            explicit subparse_error(const std::string_view found_string, std::vector<std::vector<std::string_view>> allowed_strings):
+                m_found_string(found_string),
+                m_allowed_strings(std::move(allowed_strings))
+            {
+            }
+
+            [[nodiscard]] const std::vector<std::vector<std::string_view>>& get_allowed_strings() const
+            {
+                return m_allowed_strings;
+            }
+
+            [[nodiscard]] std::string_view get_found_string() const
+            {
+                return m_found_string;
+            }
+
+            [[nodiscard]] std::string error_string() const;
+
+            [[nodiscard]] const char* what() const noexcept override
+            {
+                m_error_string = error_string();
+                return m_error_string.c_str();
+            }
+
+        private:
+            mutable std::string m_error_string;
+            std::string_view m_found_string;
+            std::vector<std::vector<std::string_view>> m_allowed_strings;
+        };
+
+        template <typename... Args>
+        struct arg_data_helper_t
+        {
+            using variant_t = std::variant<Args..., std::vector<Args>...>;
+            using arg_t = meta::arg_helper<Args...>;
+            using arg_vec_t = meta::arg_helper<std::vector<Args>...>;
+
+            template <typename T>
+            constexpr static bool is_type_stored_v = std::disjunction_v<std::is_same<T, Args>...>;
+
+            template <typename DefaultPrimitiveAction, typename DefaultListAction>
+            static auto make_visitor(const DefaultPrimitiveAction& primitive_action, const DefaultListAction& list_action)
+            {
+                return lambda_visitor{
+                    ([&primitive_action](Args& arg)
+                    {
+                        return primitive_action(arg);
+                    })...,
+                    ([&list_action](std::vector<Args>& arg_vec)
+                    {
+                        return list_action(arg_vec);
+                    })...
+                };
+            }
+        };
+
+        using arg_meta_type_helper_t = arg_data_helper_t<bool, i8, i16, i32, i64, u8, u16, u32, u64, float, double, std::string>;
+        using arg_data_t = arg_meta_type_helper_t::variant_t;
+
+        template <typename T>
+        struct arg_string_converter_t
+        {
+            static T convert(const std::string_view value)
+            {
+                static_assert(std::is_arithmetic_v<T> || std::is_same_v<T, std::string_view> || std::is_same_v<T, std::string>,
+                              "Type must be arithmetic, string_view or string!");
+                const std::string temp{value};
+
+                if constexpr (std::is_same_v<T, float>)
+                {
+                    return std::stof(temp);
+                }
+                else if constexpr (std::is_same_v<T, double>)
+                {
+                    return std::stod(temp);
+                }
+                else if constexpr (std::is_unsigned_v<T>)
+                {
+                    return static_cast<T>(std::stoull(temp));
+                }
+                else if constexpr (std::is_signed_v<T>)
+                {
+                    return static_cast<T>(std::stoll(temp));
+                }
+                else if constexpr (std::is_same_v<T, std::string_view>)
+                {
+                    return value;
+                }
+                else if constexpr (std::is_same_v<T, std::string>)
+                {
+                    return std::string(value);
+                }
+                BLT_UNREACHABLE;
+            }
+        };
+
+        template <typename T>
+        auto ensure_is_string(T&& t)
+        {
+            using NO_REF = meta::remove_cvref_t<T>;
+            if constexpr (std::is_same_v<NO_REF, bool>)
+                return t ? "true" : "false";
+            else if constexpr (std::is_arithmetic_v<NO_REF> && !(std::is_same_v<NO_REF, char>
+                || std::is_same_v<NO_REF, unsigned char> || std::is_same_v<NO_REF, signed char>))
+                return std::to_string(std::forward<T>(t));
+            else
+                return std::forward<T>(t);
+        }
+
+        void test();
+    }
+
+    class argument_string_t
+    {
+    public:
+        explicit argument_string_t(const std::string_view input, const hashset_t<char>& allowed_flag_prefix): m_argument(input),
+            m_allowed_flag_prefix(&allowed_flag_prefix)
+        {
+            process_argument();
+        }
+
+
+        [[nodiscard]] std::string_view get_flag() const
+        {
+            return m_flag_section;
+        }
+
+        [[nodiscard]] std::string_view get_name() const
+        {
+            return m_name_section;
+        }
+
+        [[nodiscard]] std::string_view value() const
+        {
+            return get_name();
+        }
+
+        [[nodiscard]] bool is_flag() const
+        {
+            return !m_flag_section.empty();
+        }
+
+        [[nodiscard]] std::string_view get_argument() const
+        {
+            return m_argument;
+        }
+
+    private:
+        /**
+         * This function takes the command line argument represented by this class,
+         * stored in m_argument and converts into flag side and name side arguments.
+         *
+         * What this means is in the case of a flag provided, for example passing --foo or --bar, this function will split the argument into
+         *
+         * m_flag_section = "--"
+         * m_name_section = "foo" || "bar"
+         *
+         * If the argument is purely positional, meaning there is no flag prefix,
+         * this function will do nothing and m_flag_section will be true for .empty()
+         *
+         * For example, if you provide res/some/folder/or/file as a command line positional argument,
+         * this function will create the following internal state:
+         *
+         * m_flag_section = ""
+         * m_flag_section.empty() == true
+         * m_name_section = "res/some/folder/or/file"
+         *
+         * m_argument is not modified by this function
+         */
+        void process_argument()
+        {
+            // user provides a list of allowed prefix characters to argument_parser_t, which is then provided to this class at construction time
+            // it is not the job of this class to validate flag prefixes beyond this. // TODO: requiring this pointer is a code smell.
+            size_t start = 0;
+            for (; start < m_argument.size() && m_allowed_flag_prefix->contains(m_argument[start]); start++)
+            {
+            }
+
+            m_flag_section = {m_argument.data(), start};
+            m_name_section = {m_argument.data() + start, m_argument.size() - start};
+        }
+
+        std::string_view m_argument;
+        std::string_view m_flag_section;
+        std::string_view m_name_section;
+        const hashset_t<char>* m_allowed_flag_prefix;
+    };
+
+    class argument_consumer_t
+    {
+    public:
+        explicit argument_consumer_t(const span<argument_string_t>& args): m_absolute_begin(args.data()), m_begin(args.data() + 1),
+                                                                           m_end(args.data() + args.size())
+        {
+            BLT_ASSERT(!args.empty() &&
+                "Argument consumer must have at least one argument allocated to it. First argument is always assumed to be program");
+        }
+
+        [[nodiscard]] const argument_string_t& absolute_first() const
+        {
+            return *m_absolute_begin;
+        }
+
+        [[nodiscard]] argument_string_t peek(const i32 offset = 0) const
+        {
+            return *(m_begin + offset);
+        }
+
+        [[nodiscard]] argument_string_t r_peek(const i32 offset = 0) const
+        {
+            return *(m_end - 1 - offset);
+        }
+
+        argument_string_t consume()
+        {
+            return *(m_begin++);
+        }
+
+        argument_string_t r_consume()
+        {
+            return *(--m_end);
+        }
+
+        [[nodiscard]] i32 remaining() const
+        {
+            return static_cast<i32>(size());
+        }
+
+        [[nodiscard]] bool can_consume(const i32 amount = 0) const
+        {
+            return amount < remaining();
+        }
+
+    private:
+        [[nodiscard]] ptrdiff_t size() const
+        {
+            return m_end - m_begin;
+        }
+
+        argument_string_t* m_absolute_begin;
+        argument_string_t* m_begin;
+        argument_string_t* m_end;
+    };
+
+    class argument_storage_t
+    {
+        friend argument_parser_t;
+        friend argument_subparser_t;
+        friend argument_builder_t;
+
+    public:
+        template <typename T>
+        [[nodiscard]] const T& get(const std::string_view key) const
+        {
+            return std::get<T>(m_data.at(key));
+        }
+
+        [[nodiscard]] const std::string& get(const std::string_view key) const
+        {
+            return std::get<std::string>(m_data.at(key));
+        }
+
+        bool contains(const std::string_view key)
+        {
+            return m_data.find(key) != m_data.end();
+        }
+
+        [[nodiscard]] size_t size() const
+        {
+            return m_data.size();
+        }
+
+    private:
+        void add(const argument_storage_t& values)
+        {
+            for (const auto& value : values.m_data)
+                m_data.insert(value);
+        }
+
+        hashmap_t<std::string, detail::arg_data_t> m_data;
+    };
+
+    class argument_builder_t
+    {
+        friend argument_parser_t;
+
+    public:
+        argument_builder_t()
+        {
+            m_dest_func = [](const std::string_view dest, argument_storage_t& storage, std::string_view value)
+            {
+                storage.m_data.emplace(std::string{dest}, std::string{value});
+            };
+            m_dest_vec_func = [](const std::string_view dest, argument_storage_t& storage, const std::vector<std::string>& values)
+            {
+                storage.m_data.emplace(std::string{dest}, values);
+            };
+        }
+
+        template <typename T>
+        argument_builder_t& as_type()
+        {
+            static_assert(detail::arg_data_helper_t<T>::template is_type_stored_v<T>, "Type is not valid to be stored/converted as an argument");
+            m_dest_func = [](const std::string_view dest, argument_storage_t& storage, std::string_view value)
+            {
+                storage.m_data.emplace(std::string{dest}, detail::arg_string_converter_t<T>::convert(value));
+            };
+            m_dest_vec_func = [](const std::string_view dest, argument_storage_t& storage, const std::vector<std::string>& values)
+            {
+                if (storage.m_data.contains(dest))
+                {
+                    auto& data = storage.m_data[dest];
+                    if (!std::holds_alternative<std::vector<T>>(data))
+                        throw detail::type_error("Invalid type conversion. Trying to add type " + blt::type_string<T>() +
+                            " but this does not match existing type index '" + std::to_string(data.index()) + "'!");
+                    auto& converted_values = std::get<std::vector<T>>(data);
+                    for (const auto& value : values)
+                        converted_values.push_back(detail::arg_string_converter_t<T>::convert(value));
+                }
+                else
+                {
+                    std::vector<T> converted_values;
+                    for (const auto& value : values)
+                        converted_values.push_back(detail::arg_string_converter_t<T>::convert(value));
+                    storage.m_data.emplace(std::string{dest}, std::move(converted_values));
+                }
+            };
+            return *this;
+        }
+
+        argument_builder_t& make_flag()
+        {
+            return set_action(action_t::STORE_TRUE);
+        }
+
+        argument_builder_t& set_action(action_t action);
+
+        argument_builder_t& set_required(const bool required)
+        {
+            m_required = required;
+            return *this;
+        }
+
+        argument_builder_t& set_nargs(const nargs_v nargs)
+        {
+            m_nargs = nargs;
+            return *this;
+        }
+
+        argument_builder_t& set_metavar(const std::string& metavar)
+        {
+            m_metavar = metavar;
+            return *this;
+        }
+
+        argument_builder_t& set_help(const std::string& help)
+        {
+            m_help = help;
+            return *this;
+        }
+
+        argument_builder_t& set_choices(const std::vector<std::string>& choices)
+        {
+            m_choices = hashset_t<std::string>{};
+            for (const auto& choice : choices)
+                m_choices->emplace(choice);
+            return *this;
+        }
+
+        argument_builder_t& set_choices(const hashset_t<std::string>& choices)
+        {
+            m_choices = choices;
+            return *this;
+        }
+
+        template <typename... Args>
+        argument_builder_t& set_choices(Args&&... args)
+        {
+            m_choices = hashset_t<std::string>{};
+            ((m_choices->emplace(detail::ensure_is_string(std::forward<Args>(args)))), ...);
+            return *this;
+        }
+
+        argument_builder_t& set_default(const detail::arg_data_t& default_value)
+        {
+            m_default_value = default_value;
+            return *this;
+        }
+
+        argument_builder_t& set_const(const detail::arg_data_t& const_value)
+        {
+            m_const_value = const_value;
+            return *this;
+        }
+
+        argument_builder_t& set_dest(const std::string_view& dest)
+        {
+            m_dest = dest;
+            return *this;
+        }
+
+    private:
+        action_t m_action = action_t::STORE;
+        bool m_required = false; // do we require this argument to be provided as an argument?
+        nargs_v m_nargs = 1; // number of arguments to consume
+        std::optional<std::string> m_metavar; // variable name to be used in the help string
+        std::optional<std::string> m_help; // help string to be used in the help string
+        std::optional<hashset_t<std::string>> m_choices; // optional allowed choices for this argument
+        std::optional<detail::arg_data_t> m_default_value;
+        std::optional<detail::arg_data_t> m_const_value;
+        std::optional<std::string> m_dest;
+        // dest, storage, value input
+        std::function<void(std::string_view, argument_storage_t&, std::string_view)> m_dest_func;
+        // dest, storage, value input
+        std::function<void(std::string_view, argument_storage_t&, const std::vector<std::string>& values)> m_dest_vec_func;
+    };
+
+    class argument_positional_storage_t
+    {
+    public:
+        explicit argument_positional_storage_t(std::vector<std::pair<std::string, argument_builder_t>> storage): positional_arguments(
+            std::move(storage))
+        {
+        }
+
+        argument_builder_t& peek()
+        {
+            return positional_arguments[current_positional].second;
+        }
+
+        argument_builder_t& next()
+        {
+            return positional_arguments[current_positional++].second;
+        }
+
+        [[nodiscard]] bool has_positional() const
+        {
+            return current_positional < positional_arguments.size();
+        }
+
+        [[nodiscard]] auto remaining() const
+        {
+            return iterate(positional_arguments).skip(current_positional);
+        }
+
+    private:
+        std::vector<std::pair<std::string, argument_builder_t>> positional_arguments;
+        size_t current_positional = 0;
+    };
+
+    class argument_parser_t
+    {
+        friend argument_subparser_t;
+        explicit argument_parser_t(const argument_subparser_t* parent): m_parent(parent)
+        {
+        }
+    public:
+        explicit argument_parser_t(const std::optional<std::string_view> description = {}, const std::optional<std::string_view> epilogue = {},
+                                   const std::optional<std::string_view> version = {},
+                                   const std::optional<std::string_view> usage = {}, const std::optional<std::string_view> name = {}):
+            m_name(name), m_usage(usage), m_description(description), m_epilogue(epilogue), m_version(version)
+        {
+        }
+
+        template <typename... Aliases>
+        argument_builder_t& add_flag(const std::string_view arg, Aliases... aliases)
+        {
+            static_assert(
+                std::conjunction_v<std::disjunction<std::is_convertible<Aliases, std::string>, std::is_constructible<
+                                                        std::string, Aliases>>...>,
+                "Arguments must be of type string_view, convertible to string_view or be string_view constructable");
+            m_argument_builders.emplace_back(std::make_unique<argument_builder_t>());
+            m_argument_builders.back()->set_dest(arg);
+            m_flag_arguments.emplace(arg, m_argument_builders.back().get());
+            (m_flag_arguments.emplace(aliases, m_argument_builders.back().get()), ...);
+            return *m_argument_builders.back().get();
+        }
+
+        argument_builder_t& add_positional(const std::string_view arg)
+        {
+            auto& b = m_positional_arguments.emplace_back(arg, argument_builder_t{}).second;
+            b.set_dest(std::string{arg});
+            b.set_required(true);
+            b.set_nargs(1);
+            return b;
+        }
+
+        argument_subparser_t* add_subparser(std::string_view dest);
+
+        argument_parser_t& with_help()
+        {
+            add_flag("--help", "-h").set_action(action_t::HELP).set_help("Show this help menu and exit");
+            return *this;
+        }
+
+        argument_parser_t& with_version()
+        {
+            add_flag("--version").set_action(action_t::VERSION);
+            return *this;
+        }
+
+        argument_storage_t parse(argument_consumer_t& consumer); // NOLINT
+
+        argument_storage_t parse(const std::vector<std::string_view>& args)
+        {
+            std::vector<argument_string_t> arg_strings;
+            arg_strings.reserve(args.size());
+            for (const auto& arg : args)
+                arg_strings.emplace_back(arg, allowed_flag_prefixes);
+            argument_consumer_t consumer{arg_strings};
+            return parse(consumer);
+        }
+
+        argument_storage_t parse(const std::vector<std::string>& args)
+        {
+            std::vector<argument_string_t> arg_strings;
+            arg_strings.reserve(args.size());
+            for (const auto& arg : args)
+                arg_strings.emplace_back(arg, allowed_flag_prefixes);
+            argument_consumer_t consumer{arg_strings};
+            return parse(consumer);
+        }
+
+        argument_storage_t parse(const int argc, const char** argv)
+        {
+            std::vector<argument_string_t> arg_strings;
+            arg_strings.reserve(argc);
+            for (int i = 0; i < argc; ++i)
+                arg_strings.emplace_back(argv[i], allowed_flag_prefixes);
+            argument_consumer_t consumer{arg_strings};
+            return parse(consumer);
+        }
+
+        void print_help();
+
+        void print_usage();
+
+        void print_version() const;
+
+        argument_parser_t& set_name(const std::optional<std::string>& name)
+        {
+            m_name = name;
+            return *this;
+        }
+
+        argument_parser_t& set_usage(const std::optional<std::string>& usage)
+        {
+            m_usage = usage;
+            return *this;
+        }
+
+        [[nodiscard]] const std::optional<std::string>& get_usage() const
+        {
+            return m_usage;
+        }
+
+        argument_parser_t& set_description(const std::optional<std::string>& description)
+        {
+            m_description = description;
+            return *this;
+        }
+
+        [[nodiscard]] const std::optional<std::string>& get_description() const
+        {
+            return m_description;
+        }
+
+        argument_parser_t& set_epilogue(const std::optional<std::string>& epilogue)
+        {
+            m_epilogue = epilogue;
+            return *this;
+        }
+
+        [[nodiscard]] const std::optional<std::string>& get_epilogue() const
+        {
+            return m_epilogue;
+        }
+
+        argument_parser_t& set_version(const std::optional<std::string>& version)
+        {
+            m_epilogue = version;
+            return *this;
+        }
+
+        [[nodiscard]] const std::optional<std::string>& get_version() const
+        {
+            return m_version;
+        }
+
+        [[nodiscard]] const hashset_t<char>& get_allowed_flag_prefixes() const
+        {
+            return allowed_flag_prefixes;
+        }
+
+    private:
+        void handle_compound_flags(hashset_t<std::string>& found_flags, argument_storage_t& parsed_args, argument_consumer_t& consumer,
+                                   const argument_string_t& arg);
+        void parse_flag(argument_storage_t& parsed_args, argument_consumer_t& consumer, std::string_view arg);
+        void parse_positional(argument_storage_t& parsed_args, argument_consumer_t& consumer, argument_positional_storage_t& storage,
+                              std::string_view arg);
+        static void handle_missing_and_default_args(hashmap_t<std::string_view, argument_builder_t*>& arguments,
+                                                    const hashset_t<std::string>& found, argument_storage_t& parsed_args, std::string_view type);
+        static expected<std::vector<std::string>, std::string> consume_until_flag_or_end(argument_consumer_t& consumer,
+                                                                                         hashset_t<std::string>* allowed_choices);
+        static std::vector<std::string> consume_argc(i32 argc, argument_consumer_t& consumer, hashset_t<std::string>* allowed_choices,
+                                                     std::string_view arg);
+
+        std::optional<std::string> m_name;
+        std::optional<std::string> m_usage;
+        std::optional<std::string> m_description;
+        std::optional<std::string> m_epilogue;
+        std::optional<std::string> m_version;
+        const argument_subparser_t* m_parent = nullptr;
+        std::vector<std::pair<std::string_view, argument_subparser_t>> m_subparsers;
+        std::vector<std::unique_ptr<argument_builder_t>> m_argument_builders;
+        hashmap_t<std::string_view, argument_builder_t*> m_flag_arguments;
+        std::vector<std::pair<std::string, argument_builder_t>> m_positional_arguments;
+        hashset_t<char> allowed_flag_prefixes = {'-', '+', '/'};
+    };
+
+    class argument_subparser_t
+    {
+        friend argument_parser_t;
+    public:
+        explicit argument_subparser_t(const argument_parser_t& parent): m_parent(&parent)
+        {
+        }
+
+        template <typename... Aliases>
+        argument_parser_t* add_parser(const std::string_view name, Aliases... aliases)
+        {
+            static_assert(
+                std::conjunction_v<std::disjunction<std::is_convertible<Aliases, std::string_view>, std::is_constructible<
+                                                        std::string_view, Aliases>>...>,
+                "Arguments must be of type string_view, convertible to string_view or be string_view constructable");
+            m_parsers.emplace_back(new argument_parser_t{this});
+            m_aliases[name] = m_parsers.back().get();
+            ((m_aliases[std::string_view{aliases}] = m_parsers.back().get()), ...);
+            return m_parsers.back().get();
+        }
+
+        argument_subparser_t* set_help(const std::optional<std::string>& help)
+        {
+            m_help = help;
+            return this;
+        }
+
+
+        /**
+         * Parses the next argument using the provided argument consumer.
+         *
+         * This function uses an argument consumer to extract and process the next argument.
+         * If the argument is a flag or if it cannot be matched against the available parsers,
+         * an exception is thrown.
+         *
+         * @param consumer Reference to an argument_consumer_t object, which handles argument parsing.
+         *                  The consumer provides the next argument to be parsed.
+         *
+         * @throws detail::subparse_error If the argument is a flag or does not match any known parser.
+         */
+        std::pair<argument_string_t, argument_storage_t> parse(argument_consumer_t& consumer); // NOLINT
+
+    private:
+        [[nodiscard]] hashmap_t<argument_parser_t*, std::vector<std::string_view>> get_allowed_strings() const;
+
+        // annoying compatability because im lazy
+        static std::vector<std::vector<std::string_view>> to_vec(const hashmap_t<argument_parser_t*, std::vector<std::string_view>>& map);
+
+        const argument_parser_t* m_parent;
+        std::optional<std::string> m_last_parsed_parser; // bad hack
+        std::optional<std::string> m_help;
+        std::vector<std::unique_ptr<argument_parser_t>> m_parsers;
+        hashmap_t<std::string_view, argument_parser_t*> m_aliases;
+    };
+}
+
+#endif //BLT_PARSE_ARGPARSE_V2_H

include/blt/profiling/profiler_v2.h

@@ -23,41 +23,41 @@ namespace blt
     static inline constexpr std::uint32_t PRINT_WALL = 0x4;
     // print out the thread CPU time
     static inline constexpr std::uint32_t PRINT_THREAD = 0x8;
-    
+
     enum class sort_by
     {
         CYCLES,
         WALL,
         THREAD
     };
-    
+
     // 32 bit currently not supported
     typedef std::int64_t pf_time_t;
     typedef std::uint64_t pf_cycle_t;
-    
+
     struct interval_t
     {
         pf_time_t wall_start = 0;
         pf_time_t wall_end = 0;
         pf_time_t wall_total = 0;
-        
+
         pf_time_t thread_start = 0;
         pf_time_t thread_end = 0;
         pf_time_t thread_total = 0;
-        
+
         pf_cycle_t cycles_start = 0;
         pf_cycle_t cycles_end = 0;
         pf_cycle_t cycles_total = 0;
-        
+
         std::uint64_t count = 0;
         std::string interval_name;
-        
+
         interval_t() = default;
-        
+
         interval_t(pf_time_t wallStart, pf_time_t wallEnd, pf_time_t wallTotal, pf_time_t threadStart, pf_time_t threadEnd, pf_time_t threadTotal,
                    pf_cycle_t cyclesStart, pf_cycle_t cyclesEnd, pf_cycle_t cyclesTotal, uint64_t count, std::string intervalName);
     };
-    
+
     struct cycle_interval_t
     {
         pf_cycle_t cycles_start = 0;
@@ -66,81 +66,86 @@ namespace blt
         std::uint64_t count = 0;
         std::string interval_name;
     };
-    
+
     struct profile_t
     {
         std::vector<interval_t*> intervals;
         std::vector<cycle_interval_t*> cycle_intervals;
         std::string name;
-        
+
         explicit profile_t(std::string name): name(std::move(name))
-        {}
-        
+        {
+        }
+
         profile_t(const profile_t& p) = delete;
-        
+
         profile_t& operator=(const profile_t& p) = delete;
-        
+
         ~profile_t();
     };
-    
+
     interval_t* createInterval(profile_t& profiler, std::string interval_name);
-    
+
     void startInterval(interval_t* interval);
-    
+
     inline interval_t* startInterval(profile_t& profiler, std::string interval_name)
     {
         auto* p = createInterval(profiler, std::move(interval_name));
         startInterval(p);
         return p;
     }
-    
+
     void endInterval(interval_t* interval);
-    
+
     void printProfile(profile_t& profiler, std::uint32_t flags = AVERAGE_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL,
                       sort_by sort = sort_by::CYCLES, blt::logging::log_level log_level = blt::logging::log_level::NONE);
-    
-    void writeProfile(std::ifstream& stream, const profile_t& profiler);
-    
+
+    void writeProfile(std::ostream& stream, profile_t& profiler,
+                      std::uint32_t flags = AVERAGE_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL,
+                      sort_by sort = sort_by::CYCLES);
+
     void clearProfile(profile_t& profiler);
-    
+
     namespace _internal
     {
         void startInterval(const std::string& profile_name, const std::string& interval_name);
-        
+
         void endInterval(const std::string& profile_name, const std::string& interval_name);
-        
+
         void printProfile(const std::string& profile_name, std::uint32_t flags = AVERAGE_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL,
                           sort_by sort = sort_by::CYCLES, blt::logging::log_level log_level = blt::logging::log_level::NONE);
-        
-        void writeProfile(std::ifstream& stream, const std::string& profile_name);
+
+        void writeProfile(std::ostream& stream, const std::string& profile_name,
+                          std::uint32_t flags = AVERAGE_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL,
+                          sort_by sort = sort_by::CYCLES);
     }
-    
+
     class auto_interval
     {
-        private:
-            interval_t* iv;
-        public:
-            auto_interval(std::string interval_name, profile_t& profiler)
-            {
-                iv = blt::createInterval(profiler, std::move(interval_name));
-                blt::startInterval(iv);
-            }
-            
-            explicit auto_interval(interval_t* iv): iv(iv)
-            {
-                blt::startInterval(iv);
-            }
-            
-            auto_interval(const auto_interval& i) = delete;
-            
-            auto_interval& operator=(const auto_interval& i) = delete;
-            
-            ~auto_interval()
-            {
-                blt::endInterval(iv);
-            }
+    private:
+        interval_t* iv;
+
+    public:
+        auto_interval(std::string interval_name, profile_t& profiler)
+        {
+            iv = blt::createInterval(profiler, std::move(interval_name));
+            blt::startInterval(iv);
+        }
+
+        explicit auto_interval(interval_t* iv): iv(iv)
+        {
+            blt::startInterval(iv);
+        }
+
+        auto_interval(const auto_interval& i) = delete;
+
+        auto_interval& operator=(const auto_interval& i) = delete;
+
+        ~auto_interval()
+        {
+            blt::endInterval(iv);
+        }
     };
-    
 }
 
 #ifdef BLT_DISABLE_PROFILING
@@ -152,22 +157,22 @@ namespace blt
 /**
  * Starts an interval to be measured, when ended the row will be added to the specified profile.
  */
-    #define BLT_START_INTERVAL(profileName, intervalName) blt::_internal::startInterval(profileName, intervalName)
+#define BLT_START_INTERVAL(profileName, intervalName) blt::_internal::startInterval(profileName, intervalName)
 /**
  * Ends an interval, adds the interval to the profile.
  */
-    #define BLT_END_INTERVAL(profileName, intervalName) blt::_internal::endInterval(profileName, intervalName)
+#define BLT_END_INTERVAL(profileName, intervalName) blt::_internal::endInterval(profileName, intervalName)
 /**
  * Prints the profile order from least time to most time.
  * @param profileName the profile to print
  * @param loggingLevel blt::logging::LOG_LEVEL to log with (default: BLT_NONE)
  * @param averageHistory use the historical collection of interval rows in an average or just the latest? (default: false)
  */
-    #define BLT_PRINT_PROFILE(profileName, ...) blt::_internal::printProfile(profileName, ##__VA_ARGS__)
+#define BLT_PRINT_PROFILE(profileName, ...) blt::_internal::printProfile(profileName, ##__VA_ARGS__)
 /**
  * writes the profile to an output stream, ordered from least time to most time, in CSV format.
  */
-    #define BLT_WRITE_PROFILE(stream, profileName) blt::_internal::writeProfile(stream, profileName)
+#define BLT_WRITE_PROFILE(stream, profileName) blt::_internal::writeProfile(stream, profileName)
 #endif
 
 #endif //BLT_PROFILER_V2_H

include/blt/std/allocator.h

@@ -546,6 +546,7 @@ namespace blt
     template<typename T, bool WARN_ON_FAIL = false>
     static inline T* allocate_huge_page(blt::size_t BLOCK_SIZE, blt::size_t HUGE_PAGE_SIZE = BLT_2MB_SIZE)
     {
+#ifdef __unix__
         BLT_ASSERT((BLOCK_SIZE & (HUGE_PAGE_SIZE - 1)) == 0 && "Must be multiple of the huge page size!");
         T* buffer = static_cast<T*>(mmap(nullptr, BLOCK_SIZE, PROT_READ | PROT_WRITE,
                                          MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_POPULATE, -1, 0));
@@ -578,6 +579,8 @@ namespace blt
                 BLT_ERROR("Offset by %ld pages, resulting: %p", (reinterpret_cast<blt::size_t>(buffer) - ptr_size) / 4096, buffer);
         }
         return buffer;
+#endif
+        return malloc(BLOCK_SIZE);
     }
     
     /**
@@ -701,7 +704,7 @@ namespace blt
                 } else
                     buffer = reinterpret_cast<block*>(std::aligned_alloc(BLOCK_SIZE, BLOCK_SIZE));
 #else
-                buffer = reinterpret_cast<block*>(std::aligned_alloc(BLOCK_SIZE, BLOCK_SIZE));
+                buffer = static_cast<block*>(_aligned_malloc(BLOCK_SIZE, BLOCK_SIZE));
 #endif
                 construct(buffer);
 #ifndef BLT_DISABLE_STATS

include/blt/std/binary_tree.h

@@ -10,10 +10,12 @@
 #include <stdexcept>
 #include <vector>
 #include <blt/std/allocator.h>
+#include <blt/std/types.h>
 #include <iostream>
 #include <memory>
 // TODO: blt::queue
 #include <queue>
+#include <stack>
 
 namespace blt
 {
@@ -142,6 +144,185 @@ namespace blt
             }
     };
     
+    template<typename K, typename V>
+    class range_tree_t
+    {
+        public:
+            struct node_t
+            {
+                K k;
+                V v;
+                blt::i64 children = 0;
+                
+                node_t(K k, V v): k(std::move(k)), v(std::move(v))
+                {}
+            };
+            
+            void insert(K k, V v)
+            {
+                auto insert_point = nodes.begin();
+                auto insert_parent = insert_point;
+                
+                while (insert_point != nodes.end())
+                {
+                    // no children
+                    if (insert_point->children == 0)
+                    {
+                        ++insert_point->children;
+                        ++insert_point;
+                        break;
+                    } else if (insert_point->children == 1)
+                    {
+                        // 1 child case
+                        insert_parent = insert_point;
+                        // find if child is min & move to it
+                        ++insert_point;
+                        bool min = insert_point->k < insert_parent->k;
+                        if (k < insert_parent->k)
+                        {
+                            // if the parent's child is a min value, then we can safely move towards it
+                            if (min)
+                                continue;
+                            else
+                            {
+                                // otherwise we can break and this will insert the new node as the new min.
+                                ++insert_parent->children;
+                                break;
+                            }
+                        } else
+                        {
+                            // parents child is min, so we move past it
+                            if (min)
+                            {
+                                insert_point = skip_children(insert_point);
+                                // can break as we insert here
+                                ++insert_parent->children;
+                                break;
+                            } else
+                            {
+                                // parents child is max, we can safely move towards it
+                                continue;
+                            }
+                        }
+                    } else
+                    {
+                        insert_parent = insert_point;
+                        ++insert_point;
+                        if (k < insert_parent->k)
+                            continue;
+                        else
+                            insert_point = skip_children(insert_point);
+                    }
+                }
+                
+                nodes.insert(insert_point, {std::move(k), std::move(v)});
+            }
+            
+            void print(std::ostream& out, bool pretty_print)
+            {
+                std::stack<blt::size_t> left;
+                blt::size_t indent = 0;
+                for (auto& v : nodes)
+                {
+                    if (v.children > 0)
+                    {
+                        create_indent(out, indent, pretty_print) << "(";
+                        indent++;
+                        left.emplace(v.children);
+                        out << v.k << ": " << v.v << end_indent(pretty_print);
+                    } else
+                        create_indent(out, indent, pretty_print) << v.k << ": " << v.v << end_indent(pretty_print);
+                    while (!left.empty())
+                    {
+                        auto top = left.top();
+                        left.pop();
+                        if (top == 0)
+                        {
+                            indent--;
+                            create_indent(out, indent, pretty_print) << ")" << end_indent(pretty_print);
+                            continue;
+                        } else
+                        {
+                            if (!pretty_print)
+                                out << " ";
+                            left.push(top - 1);
+                            break;
+                        }
+                    }
+                }
+                while (!left.empty())
+                {
+                    auto top = left.top();
+                    left.pop();
+                    if (top == 0)
+                    {
+                        indent--;
+                        create_indent(out, indent, pretty_print) << ")" << end_indent(pretty_print);
+                        continue;
+                    } else
+                    {
+                        out << "TREE MISMATCH";
+                        break;
+                    }
+                }
+                out << '\n';
+            }
+            
+            std::optional<V> search(const K& k)
+            {
+                auto point = nodes.begin();
+                while (point != nodes.end())
+                {
+                    if (k == point->k)
+                        return point->v;
+                    if (point->children == 0)
+                        return {};
+                    auto parent = point;
+                    ++point;
+                    auto min = point->k < parent->k;
+                    if (k >= parent->k)
+                    {
+                        if (min)
+                            point = skip_children(point);
+                    }
+                }
+                return {};
+            }
+        
+        private:
+            auto skip_children(typename std::vector<node_t>::iterator begin)
+            {
+                blt::i64 children_left = 0;
+                
+                do
+                {
+                    if (children_left != 0)
+                        children_left--;
+                    if (begin->children > 0)
+                        children_left += begin->children;
+                    ++begin;
+                } while (children_left > 0);
+                
+                return begin;
+            }
+            
+            std::ostream& create_indent(std::ostream& out, blt::size_t amount, bool pretty_print)
+            {
+                if (!pretty_print)
+                    return out;
+                for (blt::size_t i = 0; i < amount; i++)
+                    out << '\t';
+                return out;
+            }
+            
+            std::string_view end_indent(bool pretty_print)
+            {
+                return pretty_print ? "\n" : "";
+            }
+            
+            std::vector<node_t> nodes;
+    };
+    
 }
 
 #endif //BLT_BINARY_TREE_H

include/blt/std/expected.h

@@ -375,12 +375,12 @@ namespace blt
     };
     
     template<typename T, typename E>
-    class expected<T, E, false>
+    class expected<T, E, false> : public expected<T, E, true>
     {
         public:
             using expected<T, E, true>::expected;
             
-            constexpr expected(const expected<T, E, false>& copy) = delete;
+            constexpr expected(const expected& copy) = delete;
             
             expected& operator=(const expected& copy) = delete;
     };

include/blt/std/memory.h

@@ -11,13 +11,9 @@
 #include <initializer_list>
 #include <iterator>
 #include <cstring>
-#include "queue.h"
-#include "utility.h"
 #include <blt/std/assert.h>
-#include <cstdint>
 #include <type_traits>
 #include <utility>
-#include <cstring>
 
 namespace blt
 {
@@ -42,6 +38,7 @@ namespace blt
             using const_pointer = const T*;
             using reference = T&;
             using const_reference = const T&;
+
             using iterator = ptr_iterator<T>;
             using const_iterator = ptr_iterator<const T>;
             using reverse_iterator = std::reverse_iterator<iterator>;

include/blt/std/memory_util.h

@@ -19,38 +19,41 @@
 #ifndef BLT_MEMORY_UTIL_H
 #define BLT_MEMORY_UTIL_H
 
-#include <blt/std/types.h>
 #include <type_traits>
 #include <array>
+#include <string>
 #include <cstring>
 #include <algorithm>
 #include <cstdint>
+#include <climits>
+#include <cmath>
+#include <iostream>
 
 #if defined(__clang__) || defined(__llvm__) || defined(__GNUC__) || defined(__GNUG__)
-    
-    #if defined(__GNUC__) || defined(__GNUG__)
-        
-        #include <byteswap.h>
-        
-        #define SWAP16(val) bswap_16(val)
-        #define SWAP32(val) bswap_32(val)
-        #define SWAP64(val) bswap_64(val)
-    #else
+
+#if (defined(__GNUC__) || defined(__GNUG__)) && !defined(WIN32)
+
+#include <byteswap.h>
+
+#define SWAP16(val) bswap_16(val)
+#define SWAP32(val) bswap_32(val)
+#define SWAP64(val) bswap_64(val)
+#else
         #define SWAP16(val) __builtin_bswap16(val)
         #define SWAP32(val) __builtin_bswap32(val)
         #define SWAP64(val) __builtin_bswap64(val)
-    #endif
-    
-    
-    #if __cplusplus >= 202002L
-        
+#endif
+
+
+#if __cplusplus >= 202002L
+
         #include <bit>
 
         #define ENDIAN_LOOKUP(little_endian) (std::endian::native == std::endian::little && !little_endian) || \
                                              (std::endian::native == std::endian::big && little_endian)
-    #else
-        #define ENDIAN_LOOKUP(little_endian) !little_endian
-    #endif
+#else
+#define ENDIAN_LOOKUP(little_endian) !little_endian
+#endif
 #elif defined(_MSC_VER)
     #include <intrin.h>
     #define SWAP16(val) _byteswap_ushort(val)
@@ -61,60 +64,77 @@
 
 namespace blt::mem
 {
+    template <typename R, typename T>
+    static R type_cast(T type)
+    {
+        static_assert(std::is_trivially_copyable_v<T>, "Type must be trivially copyable to be type casted!");
+        static_assert(sizeof(T) == sizeof(R));
+        R r;
+        std::memcpy(&r, &type, sizeof(type));
+        return r;
+    }
+
+    template <typename T>
+    void reverse(T& out)
+    {
+        static_assert(std::is_trivially_copyable_v<T>, "Type must be trivially copyable to be reversible!");
+        // if we need to swap find the best way to do so
+        if constexpr (std::is_same_v<T, std::int16_t> || std::is_same_v<T, std::uint16_t>)
+            out = type_cast<T>(SWAP16(type_cast<std::uint16_t>(out)));
+        else if constexpr (std::is_same_v<T, std::int32_t> || std::is_same_v<T, std::uint32_t> || std::is_same_v<T, float>)
+            out = type_cast<T>(SWAP32(type_cast<std::uint32_t>(out)));
+        else if constexpr (std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t> || std::is_same_v<T, double>)
+            out = type_cast<T>(SWAP64(type_cast<std::uint64_t>(out)));
+        else
+        {
+            std::array<std::byte, sizeof(T)> data;
+            std::memcpy(data.data(), &out, sizeof(T));
+            std::reverse(data.begin(), data.end());
+            std::memcpy(&out, data.data(), sizeof(T));
+        }
+    }
+
     // Used to grab the byte-data of any T element. Defaults to Big Endian, however can be configured to use little endian
-    template<bool little_endian = false, typename BYTE_TYPE, typename T>
-    inline static int toBytes(const T& in, BYTE_TYPE* out)
+    template <bool little_endian = false, typename BYTE_TYPE, typename T>
+    int toBytes(const T& in, BYTE_TYPE* out)
     {
         if constexpr (!(std::is_same_v<BYTE_TYPE, std::int8_t> || std::is_same_v<BYTE_TYPE, std::uint8_t>))
             static_assert("Must provide a signed/unsigned int8 type");
-        std::memcpy(out, (void*) &in, sizeof(T));
-        
+        std::memcpy(out, &in, sizeof(T));
+
         if constexpr (ENDIAN_LOOKUP(little_endian))
         {
             // TODO: this but better.
             for (size_t i = 0; i < sizeof(T) / 2; i++)
                 std::swap(out[i], out[sizeof(T) - 1 - i]);
         }
-        
+
         return 0;
     }
-    
+
     // Used to cast the binary data of any T object, into a T object. Assumes data is in big ending (configurable)
-    template<bool little_endian = false, typename BYTE_TYPE, typename T>
-    inline static int fromBytes(const BYTE_TYPE* in, T& out)
+    template <bool little_endian = false, typename BYTE_TYPE, typename T>
+    int fromBytes(const BYTE_TYPE* in, T& out)
     {
         if constexpr (!(std::is_same_v<BYTE_TYPE, std::int8_t> || std::is_same_v<BYTE_TYPE, std::uint8_t>))
             static_assert("Must provide a signed/unsigned int8 type");
-        
-        std::array<BYTE_TYPE, sizeof(T)> data;
-        std::memcpy(data.data(), in, sizeof(T));
-        
+
+        std::memcpy(&out, in, sizeof(T));
         if constexpr (ENDIAN_LOOKUP(little_endian))
         {
-            // if we need to swap find the best way to do so
-            if constexpr (std::is_same_v<T, int16_t> || std::is_same_v<T, uint16_t>)
-                out = SWAP16(*reinterpret_cast<T*>(data.data()));
-            else if constexpr (std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>)
-                out = SWAP32(*reinterpret_cast<T*>(data.data()));
-            else if constexpr (std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>)
-                out = SWAP64(*reinterpret_cast<T*>(data.data()));
-            else
-            {
-                std::reverse(data.begin(), data.end());
-                out = *reinterpret_cast<T*>(data.data());
-            }
+            reverse(out);
         }
-        
+
         return 0;
     }
-    
-    template<bool little_endian = false, typename BYTE_TYPE, typename T>
-    inline static int fromBytes(const BYTE_TYPE* in, T* out)
+
+    template <bool little_endian = false, typename BYTE_TYPE, typename T>
+    static int fromBytes(const BYTE_TYPE* in, T* out)
     {
-        return fromBytes(in, *out);
+        return fromBytes<little_endian>(in, *out);
     }
-    
-    inline static size_t next_byte_allocation(size_t prev_size, size_t default_allocation_block = 8192, size_t default_size = 16)
+
+    inline std::size_t next_byte_allocation(std::size_t prev_size, std::size_t default_allocation_block = 8192, std::size_t default_size = 16)
     {
         if (prev_size < default_size)
             return default_size;
@@ -122,139 +142,333 @@ namespace blt::mem
             return prev_size * 2;
         return prev_size + default_allocation_block;
     }
-    
-    template<typename R, typename T>
-    inline static R type_cast(T type)
+
+    template <bool bits = true, typename OStream, typename Value>
+    void print_bytes(OStream& stream, const Value& value)
     {
-        static_assert(sizeof(T) == sizeof(R));
-        R r;
-        std::memcpy(&r, &type, sizeof(type));
-        return r;
+        constexpr auto size = sizeof(Value);
+
+        std::string line;
+        for (std::size_t i = 0; i < size; i++)
+        {
+            std::uint8_t byte;
+            std::memcpy(&byte, reinterpret_cast<const char*>(&value) + i, 1);
+            if constexpr (bits)
+            {
+                for (std::ptrdiff_t j = CHAR_BIT - 1; j >= 0; j--)
+                {
+                    const auto bit = (byte >> j) & 1;
+                    line += std::to_string(bit);
+                }
+            }
+            else
+            {
+                const auto byte_str = std::to_string(byte);
+                const auto amount = CHAR_BIT - byte_str.size();
+                for (std::size_t j = 0; j < static_cast<std::size_t>(std::ceil(static_cast<double>(amount) / 2.0)); j++)
+                    line += ' ';
+                line += byte_str;
+                for (std::size_t j = 0; j < static_cast<std::size_t>(std::floor(static_cast<double>(amount) / 2.0)); j++)
+                    line += ' ';
+            }
+            if (i != size - 1)
+                line += " : ";
+        }
+        for (std::size_t i = 0; i < size; i++)
+        {
+            auto index = std::to_string(i);
+            const auto amount = CHAR_BIT - index.size();
+            for (std::size_t j = 0; j < static_cast<std::size_t>(std::ceil(static_cast<double>(amount) / 2.0)); j++)
+                stream << ' ';
+            stream << index;
+            for (std::size_t j = 0; j < static_cast<std::size_t>(std::floor(static_cast<double>(amount) / 2.0)); j++)
+                stream << ' ';
+            if (i != size - 1)
+                stream << " | ";
+        }
+        stream << '\n';
+        stream << line;
+        stream << '\n';
     }
-    
+
+    // TODO: check if the platform actually has enough room in their pointers for this. plus endianness
+
+    struct bit_storage
+    {
+        static constexpr std::size_t START_BIT = 48;
+        static constexpr std::size_t END_BIT = sizeof(std::uintptr_t) * CHAR_BIT;
+        static constexpr std::size_t AVAILABLE_BITS = END_BIT - START_BIT;
+
+        static constexpr std::size_t make_storage_ones()
+        {
+            std::size_t result = 0;
+            for (std::size_t i = START_BIT; i < END_BIT; i++)
+                result |= 1ul << i;
+            return result;
+        }
+
+        static constexpr std::size_t make_ptr_ones()
+        {
+            std::size_t result = 0;
+            for (std::size_t i = 0; i < START_BIT; i++)
+                result |= 1ul << i;
+            return result;
+        }
+
+        bit_storage(): bits(0)
+        {
+        }
+
+        explicit bit_storage(const std::uint16_t bits): bits(bits)
+        {
+        }
+
+        std::uint16_t bits : AVAILABLE_BITS;
+    };
+
+    template <typename Ptr>
+    struct pointer_storage
+    {
+        static constexpr std::size_t STORAGE_ALL_ONES = bit_storage::make_storage_ones();
+        static constexpr std::size_t PTR_ALL_ONES = bit_storage::make_ptr_ones();
+
+        explicit pointer_storage(Ptr* ptr): ptr_bits(reinterpret_cast<std::uintptr_t>(ptr))
+        {
+        }
+
+        explicit pointer_storage(Ptr* ptr, const bit_storage bits): ptr_bits(reinterpret_cast<std::uintptr_t>(ptr))
+        {
+            storage(bits);
+        }
+
+        template <typename T, std::enable_if_t<!std::is_same_v<T, bit_storage>, bool> = false>
+        explicit pointer_storage(Ptr* ptr, const T& type): ptr_bits(reinterpret_cast<std::uintptr_t>(ptr))
+        {
+            storage(type);
+        }
+
+        [[nodiscard]] bit_storage storage() const noexcept
+        {
+            bit_storage storage{};
+            storage.bits = (ptr_bits & STORAGE_ALL_ONES) >> bit_storage::START_BIT;
+            return storage;
+        }
+
+        [[nodiscard]] bool bit(const std::size_t index) const noexcept
+        {
+            if (index >= bit_storage::END_BIT)
+                return false;
+            return (ptr_bits >> (bit_storage::START_BIT + index)) & 1;
+        }
+
+        pointer_storage& bit(const std::size_t index, const bool b) noexcept
+        {
+            if (index >= bit_storage::END_BIT)
+                return *this;
+            ptr_bits &= ~(1ul << (bit_storage::START_BIT + index));
+            ptr_bits |= (static_cast<std::uintptr_t>(b) << (bit_storage::START_BIT + index));
+            return *this;
+        }
+
+        template<typename T, std::enable_if_t<!std::is_same_v<T, bit_storage>, bool> = false>
+        pointer_storage& storage(const T& type)
+        {
+            static_assert(sizeof(T) <= sizeof(std::uintptr_t), "Type takes too many bits to be stored!");
+            static constexpr std::uintptr_t store_bits = (2 << (bit_storage::AVAILABLE_BITS - 1)) - 1;
+            std::uintptr_t bit_store = 0;
+            bit_storage store{};
+            std::memcpy(&bit_store, &type, sizeof(T));
+            store.bits |= bit_store & store_bits;
+            storage(store);
+            return *this;
+        }
+
+        pointer_storage& storage(const bit_storage bits) noexcept
+        {
+            ptr_bits = ((ptr_bits & PTR_ALL_ONES) | (static_cast<std::uintptr_t>(bits.bits) << bit_storage::START_BIT));
+            return *this;
+        }
+
+        pointer_storage& operator=(const bit_storage bits) noexcept
+        {
+            storage(bits);
+            return *this;
+        }
+
+        template<typename T, std::enable_if_t<!std::is_same_v<T, bit_storage>, bool> = false>
+        pointer_storage& operator=(const T& type)
+        {
+            storage(type);
+            return *this;
+        }
+
+        pointer_storage& clear_storage() noexcept
+        {
+            ptr_bits &= PTR_ALL_ONES;
+            return *this;
+        }
+
+        // changes pointer without changing the tag bits
+        pointer_storage& pointer(Ptr* ptr) noexcept
+        {
+            const bit_storage old_storage = storage();
+            ptr_bits = (reinterpret_cast<std::uintptr_t>(ptr) & PTR_ALL_ONES) | old_storage.bits;
+            return *this;
+        }
+
+        pointer_storage& operator=(Ptr* ptr) noexcept
+        {
+            pointer(ptr);
+            return *this;
+        }
+
+        pointer_storage& clear_pointer() noexcept
+        {
+            ptr_bits &= STORAGE_ALL_ONES;
+            return *this;
+        }
+
+        Ptr* get() const noexcept
+        {
+            return reinterpret_cast<Ptr*>(ptr_bits & PTR_ALL_ONES);
+        }
+
+        Ptr& operator*() const noexcept
+        {
+            return *get();
+        }
+
+        Ptr* operator->() const noexcept
+        {
+            return get();
+        }
+
+    private:
+        std::uintptr_t ptr_bits;
+    };
 }
 
 namespace blt
 {
-    template<typename V>
+    template <typename V>
     struct ptr_iterator
     {
-        public:
-            using iterator_category = std::random_access_iterator_tag;
-            using difference_type = blt::ptrdiff_t;
-            using value_type = V;
-            using pointer = value_type*;
-            using reference = value_type&;
-            using iter_reference = ptr_iterator&;
-            
-            explicit ptr_iterator(V* v): _v(v)
-            {}
-            
-            reference operator*() const
-            {
-                return *_v;
-            }
-            
-            pointer operator->()
-            {
-                return _v;
-            }
-            
-            ptr_iterator& operator++()
-            {
-                _v++;
-                return *this;
-            }
-            
-            ptr_iterator& operator--()
-            {
-                _v--;
-                return *this;
-            }
-            
-            ptr_iterator operator++(int)
-            {
-                auto tmp = *this;
-                ++(*this);
-                return tmp;
-            }
-            
-            ptr_iterator operator--(int)
-            {
-                auto tmp = *this;
-                --(*this);
-                return tmp;
-            }
-            
-            iter_reference operator+=(difference_type amount)
-            {
-                _v += amount;
-                return *this;
-            }
-            
-            iter_reference operator-=(difference_type amount)
-            {
-                _v -= amount;
-                return *this;
-            }
-            
-            reference operator[](difference_type index)
-            {
-                return *(_v + index);
-            }
-            
-            reference operator[](blt::size_t index)
-            {
-                return *(_v + index);
-            }
-            
-            friend bool operator<(const ptr_iterator& a, const ptr_iterator& b)
-            {
-                return b._v - a._v > 0;
-            }
-            
-            friend bool operator>(const ptr_iterator& a, const ptr_iterator& b)
-            {
-                return a._v - b._v > 0;
-            }
-            
-            friend bool operator<=(const ptr_iterator& a, const ptr_iterator& b)
-            {
-                return b._v - a._v >= 0;
-            }
-            
-            friend bool operator>=(const ptr_iterator& a, const ptr_iterator& b)
-            {
-                return a._v - b._v >= 0;
-            }
-            
-            friend difference_type operator-(const ptr_iterator& a, const ptr_iterator& b)
-            {
-                return a._v - b._v;
-            }
-            
-            friend ptr_iterator operator+(const ptr_iterator& a, difference_type n)
-            {
-                return ptr_iterator(a._v + n);
-            }
-            
-            friend ptr_iterator operator+(difference_type n, const ptr_iterator& a)
-            {
-                return ptr_iterator(a._v + n);
-            }
-            
-            friend bool operator==(const ptr_iterator& a, const ptr_iterator& b)
-            {
-                return a._v == b._v;
-            }
-            
-            friend bool operator!=(const ptr_iterator& a, const ptr_iterator& b)
-            {
-                return a._v != b._v;
-            }
-        
-        private:
-            V* _v;
+        using iterator_category = std::random_access_iterator_tag;
+        using difference_type = std::ptrdiff_t;
+        using value_type = V;
+        using pointer = value_type*;
+        using reference = value_type&;
+        using iter_reference = ptr_iterator&;
+
+        explicit ptr_iterator(V* v): _v(v)
+        {
+        }
+
+        reference operator*() const
+        {
+            return *_v;
+        }
+
+        pointer operator->()
+        {
+            return _v;
+        }
+
+        ptr_iterator& operator++()
+        {
+            _v++;
+            return *this;
+        }
+
+        ptr_iterator& operator--()
+        {
+            _v--;
+            return *this;
+        }
+
+        ptr_iterator operator++(int)
+        {
+            auto tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        ptr_iterator operator--(int)
+        {
+            auto tmp = *this;
+            --(*this);
+            return tmp;
+        }
+
+        iter_reference operator+=(difference_type amount)
+        {
+            _v += amount;
+            return *this;
+        }
+
+        iter_reference operator-=(difference_type amount)
+        {
+            _v -= amount;
+            return *this;
+        }
+
+        reference operator[](difference_type index)
+        {
+            return *(_v + index);
+        }
+
+        reference operator[](std::size_t index)
+        {
+            return *(_v + index);
+        }
+
+        friend bool operator<(const ptr_iterator& a, const ptr_iterator& b)
+        {
+            return b._v - a._v > 0;
+        }
+
+        friend bool operator>(const ptr_iterator& a, const ptr_iterator& b)
+        {
+            return a._v - b._v > 0;
+        }
+
+        friend bool operator<=(const ptr_iterator& a, const ptr_iterator& b)
+        {
+            return b._v - a._v >= 0;
+        }
+
+        friend bool operator>=(const ptr_iterator& a, const ptr_iterator& b)
+        {
+            return a._v - b._v >= 0;
+        }
+
+        friend difference_type operator-(const ptr_iterator& a, const ptr_iterator& b)
+        {
+            return a._v - b._v;
+        }
+
+        friend ptr_iterator operator+(const ptr_iterator& a, difference_type n)
+        {
+            return ptr_iterator(a._v + n);
+        }
+
+        friend ptr_iterator operator+(difference_type n, const ptr_iterator& a)
+        {
+            return ptr_iterator(a._v + n);
+        }
+
+        friend bool operator==(const ptr_iterator& a, const ptr_iterator& b)
+        {
+            return a._v == b._v;
+        }
+
+        friend bool operator!=(const ptr_iterator& a, const ptr_iterator& b)
+        {
+            return a._v != b._v;
+        }
+
+    private:
+        V* _v;
     };
 }
 

include/blt/std/mmap.h

@@ -95,7 +95,11 @@ namespace blt
         public:
             void* allocate(blt::size_t bytes) // NOLINT
             {
+#ifdef WIN32
+                return _aligned_malloc(bytes, BLT_2MB_SIZE);
+#else
                 return std::aligned_alloc(BLT_2MB_SIZE, bytes);
+#endif
             }
             
             void deallocate(void* ptr, blt::size_t) // NOLINT

include/blt/std/random.h

@@ -191,13 +191,7 @@ namespace blt::random
             }
             
             template<typename Container>
-            constexpr auto& select(Container& container)
-            {
-                return container[get_u64(0, container.size())];
-            }
-            
-            template<typename Container>
-            constexpr const auto& select(const Container& container)
+            constexpr decltype(auto) select(Container& container)
             {
                 return container[get_u64(0, container.size())];
             }

include/blt/std/ranges.h

@@ -213,25 +213,28 @@ namespace blt
             {}
             
             template<class R, class RCV = std::remove_cv_t<std::remove_reference_t<R>>, typename std::enable_if_t<
-                    extent != dynamic_extent && span_detail::is_cont_v<RCV> &&
-                    std::is_convertible_v<std::remove_pointer_t<decltype(std::data(std::declval<R>()))>(*)[], T(*)[]>, bool> = true>
+                    extent != dynamic_extent && span_detail::is_cont_v<RCV>, bool> = true>
             explicit constexpr span(R&& range): size_(std::size(range)), data_(std::data(range))
             {}
             
             template<class R, class RCV = std::remove_cv_t<std::remove_reference_t<R>>, typename std::enable_if_t<
-                    extent == dynamic_extent && span_detail::is_cont_v<RCV> &&
-                    std::is_convertible_v<std::remove_pointer_t<decltype(std::data(std::declval<R>()))>(*)[], T(*)[]>, bool> = true>
-            constexpr span(R&& range): size_(std::size(range)), data_(std::data(range)) // NOLINT
+                    extent == dynamic_extent && span_detail::is_cont_v<RCV>, bool> = true>
+            constexpr span(R& range): size_(std::size(range)), data_(range.data()) // NOLINT
             {}
             
-            template<size_type SIZE, typename std::enable_if_t<
+            template<class R, class RCV = std::remove_cv_t<std::remove_reference_t<R>>, typename std::enable_if_t<
+                    extent == dynamic_extent && span_detail::is_cont_v<RCV>, bool> = true>
+            constexpr span(const R& range): size_(std::size(range)), data_(range.data()) // NOLINT
+            {}
+            
+            template<blt::size_t SIZE, typename std::enable_if_t<
                     extent != dynamic_extent && SIZE == extent && std::is_const_v<element_type>, bool> = true>
             explicit constexpr span(std::initializer_list<value_type> il) noexcept: size_(il.size()), data_(&il.begin()) // NOLINT
             {}
             
-            template<size_type SIZE, typename std::enable_if_t<
-                    extent == dynamic_extent && SIZE == extent && std::is_const_v<element_type>, bool> = true>
-            explicit span(std::initializer_list<value_type> il) noexcept: size_(il.size()), data_(&il.begin()) // NOLINT
+//            template<blt::size_t SIZE, typename std::enable_if_t<
+//                    extent == dynamic_extent && SIZE == extent && std::is_const_v<pointer>, bool> = true>
+            span(std::initializer_list<T> il) noexcept: size_(il.size()), data_(std::data(il)) // NOLINT
             {}
             
             template<class U, std::size_t N, typename std::enable_if_t<
@@ -355,20 +358,27 @@ namespace blt
         
     };
     
-    template<class T, std::size_t N>
+    template<typename T, std::size_t N>
     span(T (&)[N]) -> span<T, N>;
     
-    template<class T, std::size_t N>
+    template<typename T, std::size_t N>
+    span(const T (&)[N]) -> span<T, N>;
+    
+    template<typename T, std::size_t N>
     span(std::array<T, N>&) -> span<T, N>;
     
-    template<class T, std::size_t N>
+    template<typename T, std::size_t N>
     span(const std::array<T, N>&) -> span<const T, N>;
     
-    template<class Cont>
+    template<typename Cont>
     span(Cont&) -> span<typename Cont::value_type>;
     
-    template<class Cont>
+    template<typename Cont>
     span(const Cont&) -> span<const typename Cont::value_type>;
+    
+    template<typename T>
+    span(std::initializer_list<T>) -> span<const T>;
+    
 }
 
 #endif //BLT_RANGES_H

include/blt/std/string.h

@@ -252,6 +252,22 @@ namespace blt::string
 #endif
     }
     
+    inline std::string ensure_ends_with_path_separator(std::string_view string)
+    {
+        if (ends_with(string, '/'))
+            return std::string(string);
+        else
+            return std::string(string) += '/';
+    }
+    
+    inline std::string ensure_ends_with_path_separator(std::string&& string)
+    {
+        if (ends_with(string, '/'))
+            return string;
+        else
+            return (std::move(string) + '/');
+    }
+    
     class match
     {
         private:

include/blt/std/system.h

@@ -146,7 +146,7 @@ namespace blt::system
         std::uint64_t dt;
     };
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) || defined(WIN32)
     using suseconds_t = std::size_t;
 #endif
     

include/blt/std/thread.h

@@ -62,11 +62,11 @@ namespace blt
                 // (unique_lock acquires lock)
                 std::unique_lock lock(count_mutex);
                 std::size_t current_uses = use_count;
-                
+
                 if (++threads_waiting == thread_count)
                 {
                     threads_waiting = 0;
-                    use_count++;
+                    ++use_count;
                     cv.notify_all();
                 } else
                 {

include/blt/std/utility.h

@@ -19,9 +19,6 @@
 #ifndef BLT_UTILITY_H
 #define BLT_UTILITY_H
 
-#include <blt/compatibility.h>
-#include <blt/std/ranges.h>
-#include <blt/std/expected.h>
 #include <string>
 #include <utility>
 
@@ -59,13 +56,13 @@ namespace blt
 namespace blt
 {
     template<typename T>
-    static BLT_CPP20_CONSTEXPR inline std::string type_string()
+    static std::string type_string()
     {
         return demangle(typeid(T).name());
     }
     
     template<typename T>
-    static BLT_CPP20_CONSTEXPR inline std::string type_string_raw()
+    static std::string type_string_raw()
     {
         return typeid(T).name();
     }

include/blt/window/window.h

@@ -1,71 +0,0 @@
-/*
- * Created by Brett on 16/01/23.
- * Licensed under GNU General Public License V3.0
- * See LICENSE file for license detail
- */
-
-#ifndef BLT_WINDOW_H
-#define BLT_WINDOW_H
-
-#include <functional>
-#include <vector>
-
-#ifndef BLT_MAP_FUNC
-    #include <unordered_map>
-    #define BLT_MAP_FUNC std::unordered_map
-#endif
-
-#define KEY_MAP BLT_MAP_FUNC<int, bool>
-
-namespace blt {
-
-class window {
-    protected:
-        bool m_windowOpen = true;
-        int m_width = 800, m_height = 600;
-
-        std::vector<std::function<void(window*)>> renderFunctions{};
-        std::vector<std::function<void(window*, int, bool)>> keyListeners{};
-        std::vector<std::function<void(window*, int, bool)>> mouseListeners{};
-
-        KEY_MAP keysDown{};
-        KEY_MAP mouseDown{};
-    public:
-        window() = default;
-        window(int width_, int height_) {
-            m_width = width_;
-            m_height = height_;
-        }
-        virtual void createWindow() = 0;
-        virtual void startMainLoop() = 0;
-        virtual void destroyWindow() = 0;
-        virtual ~window() = 0;
-
-        virtual inline bool setResizeable(bool resizeEnabled) = 0;
-        virtual inline bool setWindowSize(int width_, int height_) = 0;
-        [[nodiscard]] inline int getWidth() const {return m_width;};
-        [[nodiscard]] inline int getHeight() const {return m_height;};
-
-        [[nodiscard]] virtual inline bool isWindowOpen() const {return m_windowOpen;};
-        virtual inline void closeWindow(){
-            m_windowOpen = false;
-        }
-        virtual inline void registerLoopFunction(const std::function<void(window*)>& func) {
-            renderFunctions.push_back(func);
-        }
-
-        virtual inline bool isKeyDown(int key) const { return keysDown.at(key); }
-        virtual inline bool isMouseDown(int button) const {return mouseDown.at(button);};
-        // Function signature is window pointer to this, key press, pressed/released (true/false)
-        virtual inline void registerKeyListener(const std::function<void(window*, int, bool)>& listener) {
-            keyListeners.push_back(listener);
-        }
-        // Function signature is window pointer to this, mouse button press, pressed/released (true/false)
-        virtual inline void registerMouseListener(const std::function<void(window*, int, bool)>& listener) {
-            mouseListeners.push_back(listener);
-        }
-};
-
-}
-
-#endif

src/blt/fs/path_helper.cpp

@@ -0,0 +1,41 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2025  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <blt/fs/path_helper.h>
+#include <blt/std/string.h>
+#include <blt/compatibility.h>
+
+namespace blt::fs
+{
+#ifdef BLT_WINDOWS
+    constexpr static char delim = '\\';
+#else
+    constexpr static char delim = '/';
+#endif
+
+    std::string base_name(const std::string& str)
+    {
+        return std::string(base_name_sv(str));
+    }
+
+    std::string_view base_name_sv(const std::string_view str)
+    {
+        const auto parts = string::split_sv(str, delim);
+        const auto file_parts = string::split_sv(parts.back(), '.');
+        return file_parts.front();
+    }
+}

src/blt/logging/logging.cpp

@@ -0,0 +1,65 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2025  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <blt/logging/logging.h>
+#include <blt/std/types.h>
+
+namespace blt::logging
+{
+	struct logging_thread_context_t
+	{
+		logger_t logger;
+	};
+
+	std::string logger_t::to_string()
+	{
+		auto str = m_stream.str();
+		m_stream.str("");
+		m_stream.clear();
+		return str;
+	}
+
+	void logger_t::compile(std::string fmt)
+	{
+		m_fmt = std::move(fmt);
+		m_last_fmt_pos = 0;
+	}
+
+	void logger_t::consume_until_fmt()
+	{
+		const auto begin = m_fmt.find('{', m_last_fmt_pos);
+		const auto end = m_fmt.find('}', begin);
+		m_stream << std::string_view(m_fmt.data() + static_cast<ptrdiff_t>(m_last_fmt_pos), begin - m_last_fmt_pos);
+		m_last_fmt_pos = end;
+	}
+
+	logger_t& get_global_logger()
+	{
+		thread_local logging_thread_context_t context;
+		return context.logger;
+	}
+
+	void print(const std::string& fmt)
+	{
+		std::cout << fmt;
+	}
+
+	void newline()
+	{
+		std::cout << std::endl;
+	}
+}

src/blt/logging/status.cpp

@@ -0,0 +1,23 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2025  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <blt/logging/status.h>
+
+namespace blt::logging
+{
+
+}

src/blt/profiling/profiler_v2.cpp

@@ -89,11 +89,6 @@ namespace blt
         profiler.cycle_intervals.clear();
     }
     
-    void writeProfile(std::ifstream&, const profile_t&)
-    {
-        BLT_WARN("Write profile for V2 is currently a TODO");
-    }
-    
     void sort_intervals(std::vector<interval_t*>& intervals, sort_by sort, bool)
     {
         std::function<bool(const interval_t* a, const interval_t* b)> sort_func;
@@ -136,27 +131,22 @@ namespace blt
             container.thread = unit::S;
         return container;
     }
-    
-    inline void println(const std::vector<std::string>&& lines, logging::log_level level) {
-        for (const auto& line : lines)
-            BLT_LOG_STREAM(level) << line << "\n";
-    }
-    
-    void printProfile(profile_t& profiler, std::uint32_t flags, sort_by sort, blt::logging::log_level log_level)
+
+    void writeProfile(std::ostream& stream, profile_t& profiler, std::uint32_t flags, sort_by sort)
     {
         bool printHistory = flags & AVERAGE_HISTORY;
         bool printCycles = flags & PRINT_CYCLES;
         bool printThread = flags & PRINT_THREAD;
         bool printWall = flags & PRINT_WALL;
-        
+
         sort_intervals(profiler.intervals, sort, printHistory);
-        
+
         auto units = determine_max_unit(profiler.intervals, printHistory);
         std::string thread_unit_string = units.thread == unit::MS ? "ms" : units.thread == unit::NS ? "ns" : "s";
         std::string wall_unit_string = units.wall == unit::MS ? "ms" : units.wall == unit::NS ? "ns" : "s";
         auto thread_unit_divide = units.thread == unit::MS ? 1e6 : units.thread == unit::NS ? 1 : 1e9;
         auto wall_unit_divide = units.wall == unit::MS ? 1e6 : units.wall == unit::NS ? 1 : 1e9;
-        
+
         string::TableFormatter formatter{profiler.name};
         formatter.addColumn("Order");
         if (printHistory)
@@ -168,17 +158,17 @@ namespace blt
             formatter.addColumn("CPU Time (" + thread_unit_string += ")");
         if (printWall)
             formatter.addColumn("Wall Time (" + wall_unit_string += ")");
-        
+
         for (size_t i = 0; i < profiler.intervals.size(); i++)
         {
             blt::string::TableRow row;
             auto interval = profiler.intervals[i];
-            
+
             if (interval->count == 0)
                 continue;
-            
+
             INTERVAL_DIFFERENCE_MACRO(printHistory, interval);
-            
+
             row.rowValues.push_back(std::to_string(i + 1));
             if (printHistory)
                 row.rowValues.push_back(std::to_string(interval->count));
@@ -191,8 +181,17 @@ namespace blt
                 row.rowValues.push_back(std::to_string(wall / static_cast<double>(wall_unit_divide)));
             formatter.addRow(row);
         }
-        
-        println(formatter.createTable(true, true), log_level);
+
+        auto lines = formatter.createTable(true, true);
+        for (const auto& line : lines)
+            stream << line << "\n";
+    }
+    
+    void printProfile(profile_t& profiler, const std::uint32_t flags, sort_by sort, blt::logging::log_level log_level)
+    {
+        std::stringstream stream;
+        writeProfile(stream, profiler, flags, sort);
+        BLT_LOG_STREAM(log_level) << stream.str();
     }
     
     profile_t::~profile_t()
@@ -226,7 +225,7 @@ namespace blt
         blt::endInterval(profiles[profile_name].at(interval_name));
     }
     
-    void _internal::writeProfile(std::ifstream& stream, const std::string& profile_name)
+    void _internal::writeProfile(std::ostream& stream, const std::string& profile_name, std::uint32_t flags, sort_by sort)
     {
         if (profiles.find(profile_name) == profiles.end())
             return;
@@ -234,7 +233,7 @@ namespace blt
         profile_t profile{profile_name};
         for (const auto& i : pref)
             profile.intervals.push_back(i.second);
-        blt::writeProfile(stream, profile);
+        blt::writeProfile(stream, profile, flags, sort);
         profiles.erase(profile_name);
     }
     

src/blt/std/assert.cpp

@@ -13,7 +13,7 @@
 #include <exception>
 #include <cstring>
 
-struct abort_exception : public std::exception
+struct abort_exception final : public std::exception
 {
     public:
         explicit abort_exception(const char* what)
@@ -42,14 +42,18 @@ struct abort_exception : public std::exception
         char* error{nullptr};
 };
 
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+#if defined(__GNUC__) && !defined(__EMSCRIPTEN__) && !defined(WIN32)
+    #define IS_GNU_BACKTRACE
+#endif
+
+#ifdef IS_GNU_BACKTRACE
     
     #include <execinfo.h>
     #include <cstdlib>
 
 #endif
 
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+#ifdef IS_GNU_BACKTRACE
     #define BLT_STACK_TRACE(number) void* ptrs[number]; \
             int size = backtrace(ptrs, number);         \
             char** messages = backtrace_symbols(ptrs, size);
@@ -64,7 +68,7 @@ struct abort_exception : public std::exception
 namespace blt
 {
 
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+#ifdef IS_GNU_BACKTRACE
     
     static inline std::string _macro_filename(const std::string& path)
     {
@@ -79,7 +83,7 @@ namespace blt
     
     void b_throw(const char* what, const char* path, int line)
     {
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+#ifdef IS_GNU_BACKTRACE
         BLT_STACK_TRACE(50);
         
         BLT_ERROR("An exception '%s' has occurred in file '%s:%d'", what, path, line);
@@ -96,7 +100,7 @@ namespace blt
     
     void b_assert_failed(const char* expression, const char* msg, const char* path, int line)
     {
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+#ifdef IS_GNU_BACKTRACE
         BLT_STACK_TRACE(50);
         
         BLT_ERROR("The assertion '%s' has failed in file '%s:%d'", expression, path, line);
@@ -122,7 +126,7 @@ namespace blt
     {
         if (messages == nullptr)
             return;
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+#ifdef IS_GNU_BACKTRACE
         for (int i = 1; i < size; i++)
         {
             int tabs = i - 1;
@@ -167,13 +171,13 @@ namespace blt
     
     void b_abort(const char* what, const char* path, int line)
     {
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+#ifdef IS_GNU_BACKTRACE
         BLT_STACK_TRACE(50);
 #endif
         BLT_FATAL("----{BLT ABORT}----");
         BLT_FATAL("\tWhat: %s", what);
-        BLT_FATAL("\tcalled from %s:%d", path, line);
-#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
+        BLT_FATAL("\tCalled from %s:%d", path, line);
+#ifdef IS_GNU_BACKTRACE
         printStacktrace(messages, size, path, line);
         
         BLT_FREE_STACK_TRACE();

src/blt/std/mmap.cpp

@@ -21,6 +21,8 @@
     
     #include <sys/mman.h>
 
+#else
+#include <blt/std/assert.h>
 #endif
 
 namespace blt
@@ -99,16 +101,23 @@ namespace blt
         }
         return buffer;
 #else
+        (void)page_type;
+        (void)bytes;
         BLT_ABORT("Platform not supported for huge page allocation!");
 #endif
     }
     
     void mmap_free(void* ptr, blt::size_t bytes)
     {
+#ifdef __unix__
         if (munmap(ptr, bytes))
         {
             BLT_ERROR_STREAM << "Failed to deallocate\n";
             throw bad_alloc_t(handle_mmap_error());
         }
+#else
+        (void)ptr;
+        (void)bytes;
+#endif
     }
 }

src/blt/std/string.cpp

@@ -130,10 +130,13 @@ namespace blt
         {
             auto size = pos - from;
             auto token = s.substr(from, size);
-            tokens.emplace_back(token);
+            if (!token.empty())
+                tokens.emplace_back(token);
             from += size + delim.length();
         }
-        tokens.emplace_back(s.substr(from));
+        auto str = s.substr(from);
+        if (!str.empty())
+            tokens.emplace_back(str);
         return tokens;
     }
     
@@ -146,10 +149,13 @@ namespace blt
         {
             auto size = pos - from;
             auto token = s.substr(from, size);
-            tokens.emplace_back(token);
+            if (!token.empty())
+                tokens.emplace_back(token);
             from += size + 1;
         }
-        tokens.emplace_back(s.substr(from));
+        auto str = s.substr(from);
+        if (!str.empty())
+            tokens.emplace_back(str);
         return tokens;
     }
     
@@ -162,10 +168,13 @@ namespace blt
         {
             auto size = pos - from;
             auto token = s.substr(from, size);
-            tokens.push_back(token);
+            if (!token.empty())
+                tokens.push_back(token);
             from += size + delim.length();
         }
-        tokens.push_back(s.substr(from));
+        auto str = s.substr(from);
+        if (!str.empty())
+            tokens.push_back(str);
         return tokens;
     }
     
@@ -178,10 +187,13 @@ namespace blt
         {
             auto size = pos - from;
             auto token = s.substr(from, size);
-            tokens.push_back(token);
+            if (!token.empty())
+                tokens.push_back(token);
             from += size + 1;
         }
-        tokens.push_back(s.substr(from));
+        auto str = s.substr(from);
+        if (!str.empty())
+            tokens.push_back(str);
         return tokens;
     }
     

src/blt/std/system.cpp

@@ -6,7 +6,7 @@
 #include <blt/std/system.h>
 #include <blt/std/logging.h>
 
-#ifndef _MSC_VER
+#if !defined(_MSC_VER) && !defined(WIN32)
 #include <sys/time.h>            /* for struct timeval */
 #include <sys/resource.h>
 #else

tests/argparse_tests.cpp

@@ -0,0 +1,23 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2025  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <blt/parse/argparse_v2.h>
+
+int main(){
+    blt::argparse::detail::test();
+    return 0;
+}

tests/logger_tests.cpp

@@ -0,0 +1,25 @@
+/*
+ *  <Short Description>
+ *  Copyright (C) 2025  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <blt/logging/logging.h>
+
+int main()
+{
+    blt::logging::println("This is a println!");
+    blt::logging::println("This is a println with args '{}'", 42);
+    blt::logging::println("This is a println with multiple args '{}' '{}' '{}'", 42, 32.34231233, "Hello World!");
+}