printer.h

#pragma once
 
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <memory>
#include <iomanip>
#include <variant>
#include <functional>
 
 
namespace TuringSim::Utils::Debug {
    template<typename CharT, typename Traits, typename T>
    struct Debug;
 
    template<typename T, typename CharT = char, typename Traits = std::char_traits<CharT>>
    std::function<std::basic_ostream<CharT, Traits>&(std::basic_ostream<CharT, Traits>&)> debug(const T& s) {
        return [&s](std::basic_ostream<CharT, Traits>& os) -> std::basic_ostream<CharT, Traits>& { return Debug<CharT, Traits, T>::print(os, s); };
    }
 
    template<typename CharT, typename Traits>
    std::basic_ostream<CharT, Traits>& operator<<(
            std::basic_ostream<CharT, Traits>& os,
            const std::function<std::basic_ostream<CharT, Traits>&(std::basic_ostream<CharT, Traits>&)>& f
    ) {
        return f(os);
    }
 
    template<typename CharT, typename Traits, typename T>
    struct Debug {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const T& s) {
            return os << s;
        }
    };
 
    template<typename CharT, typename Traits>
    struct Debug<CharT, Traits, std::string> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::string& s) {
            return os << "\"" << s << "\"";
        }
    };
 
    template<typename CharT, typename Traits>
    struct Debug<CharT, Traits, bool> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const bool& b) {
            using std::operator""s;
            return os << (b ? "true"s : "false"s);
        }
    };
 
    template<typename CharT, typename Traits, typename T, typename Alloc>
    struct Debug<CharT, Traits, std::vector<T, Alloc>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::vector<T, Alloc>& vector) {
            bool first = true;
            os << "[";
            for(const T& item : vector) {
                if(first) {
                    first = false;
                }
                else {
                    os << ", ";
                }
                os << debug<T, CharT, Traits>(item);
            }
            return os << "]";
        }
    };
 
    template<typename CharT, typename Traits, typename Key, typename Value, typename Comp, typename Alloc>
    struct Debug<CharT, Traits, std::map<Key, Value, Comp, Alloc>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::map<Key, Value, Comp, Alloc>& map) {
            bool first = true;
            os << "{";
            for(auto& [key, value] : map) {
                if(first) {
                    first = false;
                }
                else {
                    os << ", ";
                }
                os << debug<Key, CharT, Traits>(key) << ": " << debug<Value, CharT, Traits>(value);
            }
            return os << "}";
        }
    };
 
    template<typename CharT, typename Traits, typename T, typename Comp, typename Alloc>
    struct Debug<CharT, Traits, std::set<T, Comp, Alloc>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::set<T, Comp, Alloc>& set) {
            bool first = true;
            os << "{";
            for(const T& item : set) {
                if(first) {
                    first = false;
                }
                else {
                    os << ", ";
                }
                os << debug<T, CharT, Traits>(item);
            }
            return os << "}";
        }
    };
 
    template<typename CharT, typename Traits, typename T1, typename T2>
    struct Debug<CharT, Traits, std::pair<T1, T2>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::pair<T1, T2>& p) {
            return os << "(" << debug<T1, CharT, Traits>(p.first) << ": " << debug<T2, CharT, Traits>(p.second) << ")";
        }
    };
 
    template<typename CharT, typename Traits, typename ...TT>
    struct Debug<CharT, Traits, std::tuple<TT...>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::tuple<TT...>& tuple) {
            os << "(";
            print(os, tuple, std::index_sequence_for<TT...>{});
            return os << ")";
        }
    private:
        template<std::size_t... Is>
        static void print(std::basic_ostream<CharT, Traits>& os, const std::tuple<TT...>& t, std::index_sequence<Is...>) {
            ((os << (Is == 0 ? "" : ", ") << debug<TT, CharT, Traits>(std::get<Is>(t))), ...);
        }
    };
 
    template<typename CharT, typename Traits, typename T, size_t N>
    struct Debug<CharT, Traits, std::array<T, N>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::array<T, N>& array) {
            bool first = true;
            os << "[";
            for(const T& item : array) {
                if(first) {
                    first = false;
                }
                else {
                    os << ", ";
                }
                os << debug<T, CharT, Traits>(item);
            }
            return os << "]";
        }
    };
 
    template<typename CharT, typename Traits, typename T>
    struct Debug<CharT, Traits, std::optional<T>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::optional<T>& opt) {
            if(opt) {
                return os << debug<T, CharT, Traits>(*opt);
            }
            return os << "_";
        }
    };
 
    template<typename CharT, typename Traits, typename T>
    struct Debug<CharT, Traits, std::shared_ptr<T>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::shared_ptr<T>& ptr) {
            if(ptr) {
                return os << ptr << "(" << debug<T, CharT, Traits>(*ptr) << ")";
            }
            return os << ptr << "(empty)";
        }
    };
 
    template<typename CharT, typename Traits, typename T>
    struct Debug<CharT, Traits, std::weak_ptr<T>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::weak_ptr<T>& ptr) {
            if(auto s_ptr = ptr.lock()) {
                return os << debug<std::shared_ptr<T>, CharT, Traits>(s_ptr);
            }
            return os << "(expired)";
        }
    };
 
    template<typename CharT, typename Traits>
    struct Debug<CharT, Traits, std::monostate> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::monostate& m) {
            return os << ".";
        }
#pragma clang diagnostic pop
    };
 
    template<typename CharT, typename Traits, typename T, typename C>
    struct Debug<CharT, Traits, std::queue<T, C>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::queue<T, C>& q) {
            std::queue<T, C> qq = q;
            bool first = true;
            os << "[";
            while(!qq.empty()) {
                if(first) {
                    first = false;
                }
                else {
                    os << ", ";
                }
                os << debug<T, CharT, Traits>(qq.front());
                qq.pop();
            }
            return os << "]";
        }
    };
 
    template<typename CharT, typename Traits, typename T, typename Alloc>
    struct Debug<CharT, Traits, std::deque<T, Alloc>> {
        static std::basic_ostream<CharT, Traits>& print(std::basic_ostream<CharT, Traits>& os, const std::deque<T, Alloc>& d) {
            bool first = true;
            os << "[";
            for(const T& item : d) {
                if(first) {
                    first = false;
                }
                else {
                    os << ", ";
                }
                os << debug<T, CharT, Traits>(item);
            }
            return os << "]";
        }
    };
 
    template<typename T, typename CharT = char, typename Trait = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>
    std::basic_string<CharT, Trait, Alloc> toString(const T& s) {
        std::basic_ostringstream<CharT, Trait, Alloc> ss;
        ss << debug(s);
        return ss.str();
    }
 
    template<typename T, typename CharT = char, typename Traits = std::char_traits<CharT>>
    std::function<std::basic_ostream<CharT, Traits>&(std::basic_ostream<CharT, Traits>&)> spaceNumber(const T& k) {
        return [k](std::basic_ostream<CharT, Traits>& os) -> std::basic_ostream<CharT, Traits>& {
            T n = k;
            if(n == 0) {
                os << 0;
            }
            else {
                std::vector<T> v;
                while(n != 0) {
                    v.push_back(n % 1000);
                    n = n / 1000;
                }
                bool first = true;
                for(size_t i = 0; i < v.size(); i++) {
                    if(first) {
                        first = false;
                    }
                    else {
                        os << " " << std::setfill('0') << std::setw(3);
                    }
                    os << v[v.size() - 1 - i];
                }
            }
            return os;
        };
    }
}