Utilities.h

#pragma once

#include <exception>
#include <filesystem>
#include <iomanip>
#include <memory>
#include <optional>
#include <sstream>
#include <chrono>
#include <SDL.h>
#include <stack>
#include "Constants.h"

namespace rose::util {

    template<typename T>
    std::string fmtNumber(T value, int precision) {
        std::stringstream strm{};
        strm << std::setprecision(precision) << value;
        return strm.str();
    }

    template<class Iterator>
    struct iterator_pair {
        Iterator mBegin, mEnd;

        Iterator begin() const { return mBegin; }
        Iterator end() const { return mEnd; }
    };

    template<class C>
    using iterator_t = decltype(std::begin(std::declval<C&>()));

    template<class C>
    iterator_pair<iterator_t<C>> offset(C& container, size_t skip) {
        return {std::next(container.begin(), skip), container.end()};
    }

    template<typename T, size_t N>
    std::ostream & printScreenMetric(std::ostream &strm, const std::array<T,N> &metric) {
        strm << '(' << metric.front();
        for (auto &i : offset(metric,1)) {
            strm << ',' << i;
        }
        return strm << ')';
    }

    template<typename T>
    extern std::chrono::system_clock::time_point fileClockToSystemClock(T fileTimePoint) {
        using namespace std::chrono_literals;
        using namespace std::chrono;

        auto sysWriteTime = time_point_cast<system_clock::duration>(
                fileTimePoint - decltype(fileTimePoint)::clock::now() +
                system_clock::now());
        return sysWriteTime;
    }

    struct FontMetrics {
        int fontAscent,     
        fontDescent,        
        fontHeight,         
        fontLineSkip;       

        constexpr FontMetrics(const FontMetrics &) noexcept = default;
        constexpr FontMetrics(FontMetrics &&) noexcept = default;
        constexpr FontMetrics& operator=(const FontMetrics &) noexcept = default;
        constexpr FontMetrics& operator=(FontMetrics &&) noexcept = default;
    };

    template<class ContainerType>
    class ReverseContainerView {
    protected:
        ContainerType &mContainer;      

    public:
        ReverseContainerView() = delete;

        explicit ReverseContainerView(ContainerType &container, bool reverse = true) : mContainer(container) {}

        auto begin() {
            return std::rbegin(mContainer);
        }

        auto end() {
            return std::rend(mContainer);
        }
    };

#define XSTR(arg) STR(arg)  
#define STR(arg) #arg       

#define FILE_LOC " -- ", __FILE__, ':', __LINE__    


    using DebugTuple = std::optional<std::tuple<const std::string_view, unsigned int>>;

#define DEBUG_TUPLE(use) use ? std::make_optional(std::make_tuple(std::string_view{__FILE__},__LINE__)) : (std::nullopt)

    static bool bxor(bool a, bool b) { return b == !a; }

    template<typename Arg, typename... Args>
    std::string StringCompositor(Arg &&arg, Args &&... args) {
        std::stringstream out;
        out << std::forward<Arg>(arg);
        ((out << std::forward<Args>(args)), ...);
        return out.str();
    }
}