union.h

Go to the documentation of this file.

 
/*
Copyright (c) 2026 MrXie1109
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#pragma once
#include <cstddef>
#include <cstring>
#include <exception>
#include <new>
#include <type_traits>
#include <utility>
 
namespace console {
    template <class... Ts>
    class Union {
        template <size_t, class...>
        struct type_at;
        template <class T, class... Rest>
        struct type_at<0, T, Rest...> {
            using type = T;
        };
        template <size_t N, class T, class... Rest>
        struct type_at<N, T, Rest...> {
            using type = typename type_at<N - 1, Rest...>::type;
        };
        template <size_t N, class... Types>
        using type_at_t = typename type_at<N, Types...>::type;

        template <class, class...>
        struct type_index;
        template <class T>
        struct type_index<T> {
            static constexpr size_t value = 0;
        };
        template <class T, class U, class... Rest>
        struct type_index<T, U, Rest...> {
            static constexpr bool _is_match
                = std::is_same<typename std::decay<T>::type,
                    typename std::decay<U>::type>::value;
            static constexpr size_t _rest_index = type_index<T, Rest...>::value;
            static constexpr size_t value = _is_match ? 0 : _rest_index + 1;
        };

        template <size_t...>
        struct max;
        template <size_t N>
        struct max<N> {
            static constexpr size_t value = N;
        };
        template <size_t N, size_t... Ns>
        struct max<N, Ns...> {
            static constexpr size_t value
                = N > max<Ns...>::value ? N : max<Ns...>::value;
        };

        template <class...>
        struct has_void;
        template <class T>
        struct has_void<T> {
            static const bool value
                = std::is_same<typename std::decay<T>::type, void>::value;
        };
        template <class T, class... Rest>
        struct has_void<T, Rest...> {
            static const bool value
                = std::is_same<typename std::decay<T>::type, void>::value
                  || has_void<Rest...>::value;
        };
 
        template <class...>
        friend class Union;

        alignas(max<alignof(Ts)...>::value) //
            char data_[max<sizeof(Ts)...>::value];

        size_t index_{static_cast<size_t>(-1)};

        void (*deleter_)(void *) = [](void *) {};
        void (*copier_)(void *, const void *) = [](void *, const void *) {};
        void (*mover_)(void *, void *) = [](void *, void *) {};
        void (*cctor_)(void *, const void *) = [](void *, const void *) {};
        void (*mctor_)(void *, void *) = [](void *, void *) {};

#define TERMINATE_FOR_EXCEPTION(...)                                           \
    try {                                                                      \
        __VA_ARGS__;                                                           \
    } catch (...) {                                                            \
        std::terminate();                                                      \
    }

        template <class T>
        static inline void deleter(void *ptr) {
            static_cast<T *>(ptr)->~T();
        }

        template <class T>
        static inline void copier(void *dest, const void *src) {
            if (dest == src) return;
            static_cast<T *>(dest)->~T();
            TERMINATE_FOR_EXCEPTION(new (dest) T(*static_cast<const T *>(src)));
        }

        template <class T>
        static void mover(void *dest, void *src) {
            if (dest == src) return;
            static_cast<T *>(dest)->~T();
            TERMINATE_FOR_EXCEPTION(
                new (dest) T(std::move(*static_cast<T *>(src))));
        }

        template <class T>
        static inline void cctor(void *dest, const void *src) {
            TERMINATE_FOR_EXCEPTION(new (dest) T(*static_cast<const T *>(src)));
        }

        template <class T>
        static inline void mctor(void *dest, void *src) {
            TERMINATE_FOR_EXCEPTION(
                new (dest) T(std::move(*static_cast<T *>(src))));
        }

        template <size_t N, class F, class Ret>
        typename std::enable_if<(N < sizeof...(Ts))>::type
        _visit1(F &&f, Ret &r) {
            if (N == index_)
                r = f(*get<type_at_t<N, Ts...>>());
            else
                _visit1<N + 1>(std::forward<F>(f), r);
        }
 
        template <size_t N, class F, class Ret>
        typename std::enable_if<(N == sizeof...(Ts))>::type
        _visit1(F &&, Ret &) {}

        template <size_t N, class F, class Ret>
        typename std::enable_if<(N < sizeof...(Ts))>::type
        _visit1(F &&f, Ret &r) const {
            if (N == index_)
                r = f(*get<type_at_t<N, Ts...>>());
            else
                _visit1<N + 1>(std::forward<F>(f), r);
        }
 
        template <size_t N, class F, class Ret>
        typename std::enable_if<(N == sizeof...(Ts))>::type
        _visit1(F &&, Ret &) const {}

        template <size_t N, class F>
        typename std::enable_if<(N < sizeof...(Ts))>::type _visit2(F &&f) {
            if (N == index_)
                f(*get<type_at_t<N, Ts...>>());
            else
                _visit2<N + 1>(std::forward<F>(f));
        }
 
        template <size_t N, class F>
        typename std::enable_if<(N == sizeof...(Ts))>::type _visit2(F &&) {}

        template <size_t N, class F>
        typename std::enable_if<(N < sizeof...(Ts))>::type
        _visit2(F &&f) const {
            if (N == index_)
                f(*get<type_at_t<N, Ts...>>());
            else
                _visit2<N + 1>(std::forward<F>(f));
        }
 
        template <size_t N, class F>
        typename std::enable_if<(N == sizeof...(Ts))>::type
        _visit2(F &&) const {}

        template <size_t N, class Ret, class F, class... Rest>
        typename std::enable_if<(N < sizeof...(Ts))>::type
        _visit3(Ret &r, F &&f, Rest &&...rest) {
            if (N == index_)
                r = f(*get<type_at_t<N, Ts...>>());
            else
                _visit3<N + 1>(r, std::forward<Rest>(rest)...);
        }
 
        template <size_t N, class Ret, class F, class... Rest>
        typename std::enable_if<(N == sizeof...(Ts))>::type
        _visit3(Ret &, F &&, Rest &&...) {}

        template <size_t N, class Ret, class F, class... Rest>
        typename std::enable_if<(N < sizeof...(Ts))>::type
        _visit3(Ret &r, F &&f, Rest &&...rest) const {
            if (N == index_)
                r = f(*get<type_at_t<N, Ts...>>());
            else
                _visit3<N + 1>(r, std::forward<Rest>(rest)...);
        }
 
        template <size_t N, class Ret>
        typename std::enable_if<(N == sizeof...(Ts))>::type
        _visit3(Ret &) const {}

        template <size_t N, class F, class... Rest>
        typename std::enable_if<(N < sizeof...(Ts))>::type
        _visit4(F &&f, Rest &&...rest) {
            if (N == index_)
                f(*get<type_at_t<N, Ts...>>());
            else
                _visit4<N + 1>(std::forward<Rest>(rest)...);
        }
 
        template <size_t N>
        typename std::enable_if<(N == sizeof...(Ts))>::type _visit4() {}

        template <size_t N, class F, class... Rest>
        typename std::enable_if<(N < sizeof...(Ts))>::type
        _visit4(F &&f, Rest &&...rest) const {
            if (N == index_)
                f(*get<type_at_t<N, Ts...>>());
            else
                _visit4<N + 1>(std::forward<Rest>(rest)...);
        }
 
        template <size_t N>
        typename std::enable_if<(N == sizeof...(Ts))>::type _visit4() const {}
 
    public:
        Union() = default;

        ~Union() { deleter_(data_); }

        template <class T,
            class = typename std::enable_if<
                type_index<typename std::decay<T>::type, Ts...>::value
                != sizeof...(Ts)>::type>
        Union(T &&value) :
            index_(type_index<T, Ts...>::value),
            deleter_(&deleter<typename std::decay<T>::type>),
            copier_(&copier<typename std::decay<T>::type>),
            mover_(&mover<typename std::decay<T>::type>), //
            cctor_(&cctor<typename std::decay<T>::type>), //
            mctor_(&mctor<typename std::decay<T>::type>) {
            new (data_) typename std::decay<T>::type(std::forward<T>(value));
        }

        template <class T,
            class = typename std::enable_if<
                type_index<typename std::decay<T>::type, Ts...>::value
                != sizeof...(Ts)>::type>
        Union &operator=(T &&value) {
            if (!empty()) deleter_(data_);
            TERMINATE_FOR_EXCEPTION(new (data_)
                    typename std::decay<T>::type(std::forward<T>(value)));
            index_   = type_index<T, Ts...>::value;
            deleter_ = &deleter<typename std::decay<T>::type>;
            copier_  = &copier<typename std::decay<T>::type>;
            mover_   = &mover<typename std::decay<T>::type>;
            cctor_   = &cctor<typename std::decay<T>::type>;
            mctor_   = &mctor<typename std::decay<T>::type>;
            return *this;
        }

        Union(const Union &other) :
            index_(other.index_), deleter_(other.deleter_),
            copier_(other.copier_), mover_(other.mover_), //
            cctor_(other.cctor_), mctor_(other.mctor_) {
            cctor_(data_, other.data_);
        }

        Union(Union &&other) :
            index_(other.index_), deleter_(other.deleter_),
            copier_(other.copier_), mover_(other.mover_), //
            cctor_(other.cctor_), mctor_(other.mctor_) {
            mctor_(data_, other.data_);
            other.index_ = static_cast<size_t>(-1);
        }

        Union &operator=(const Union &other) {
            if (this == &other) return *this;
            deleter_ = other.deleter_;
            copier_  = other.copier_;
            mover_   = other.mover_;
            cctor_   = other.cctor_;
            mctor_   = other.mctor_;
            if (empty())
                cctor_(data_, other.data_);
            else
                copier_(data_, other.data_);
            index_ = other.index_;
            return *this;
        }

        Union &operator=(Union &&other) {
            if (this == &other) return *this;
            deleter_ = other.deleter_;
            copier_  = other.copier_;
            mover_   = other.mover_;
            cctor_   = other.cctor_;
            mctor_   = other.mctor_;
            if (empty())
                mctor_(data_, other.data_);
            else
                mover_(data_, other.data_);
            index_       = other.index_;
            other.index_ = static_cast<size_t>(-1);
            return *this;
        }

        template <class T>
        T *get() {
            return type_index<T, Ts...>::value == index_
                       ? reinterpret_cast<T *>(data_)
                       : nullptr;
        }

        template <class T>
        const T *get() const {
            return type_index<T, Ts...>::value == index_
                       ? reinterpret_cast<const T *>(data_)
                       : nullptr;
        }

        template <class F>
        auto visit(F &&f) -> typename std::enable_if<
            !has_void<decltype(f(std::declval<Ts &>()))...>::value,
            typename std::common_type<decltype(f(
                std::declval<Ts &>()))...>::type>::type {
            if (empty()) std::terminate();
            typename std::common_type< //
                decltype(f(std::declval<Ts &>()))...>::type result;
            _visit1<0>(std::forward<F>(f), result);
            return result;
        }

        template <class F>
        auto visit(F &&f) const -> typename std::enable_if<
            !has_void<decltype(f(std::declval<const Ts &>()))...>::value,
            typename std::common_type<decltype(f(
                std::declval<const Ts &>()))...>::type>::type {
            if (empty()) std::terminate();
            typename std::common_type< //
                decltype(f(std::declval<const Ts &>()))...>::type result;
            _visit1<0>(std::forward<F>(f), result);
            return result;
        }

        template <class F>
        auto visit(F &&f) -> typename std::enable_if<
            has_void<decltype(f(std::declval<Ts &>()))...>::value>::type {
            if (empty()) std::terminate();
            _visit2<0>(std::forward<F>(f));
        }

        template <class F>
        auto visit(F &&f) const -> typename std::enable_if<
            has_void<decltype(f(std::declval<const Ts &>()))...>::value>::type {
            if (empty()) std::terminate();
            _visit2<0>(std::forward<F>(f));
        }

        template <class... Fs>
        auto visit(Fs &&...fs) -> typename std::enable_if<
            !has_void<decltype(fs(std::declval<Ts &>()))...>::value,
            typename std::common_type<decltype(fs(
                std::declval<Ts &>()))...>::type>::type {
            static_assert(sizeof...(Fs) == sizeof...(Ts),
                "Number of functors does not match number of types!");
            if (empty()) std::terminate();
            typename std::common_type< //
                decltype(fs(std::declval<Ts &>()))...>::type result;
            _visit3<0>(result, std::forward<Fs>(fs)...);
            return result;
        }

        template <class... Fs>
        auto visit(Fs &&...fs) const -> typename std::enable_if<
            !has_void<decltype(fs(std::declval<const Ts &>()))...>::value,
            typename std::common_type<decltype(fs(
                std::declval<const Ts &>()))...>::type>::type {
            static_assert(sizeof...(Fs) == sizeof...(Ts),
                "Number of functors does not match number of types!");
            if (empty()) std::terminate();
            typename std::common_type< //
                decltype(fs(std::declval<const Ts &>()))...>::type result;
            _visit3<0>(result, std::forward<Fs>(fs)...);
        }

        template <class... Fs>
        auto visit(Fs &&...fs) -> typename std::enable_if<
            has_void<decltype(fs(std::declval<Ts &>()))...>::value>::type {
            static_assert(sizeof...(Fs) == sizeof...(Ts),
                "Number of functors does not match number of types!");
            if (empty()) std::terminate();
            _visit4<0>(std::forward<Fs>(fs)...);
        }

        template <class... Fs>
        auto
        visit(Fs &&...fs) const -> typename std::enable_if<has_void<decltype(fs(
            std::declval<const Ts &>()))...>::value>::type {
            static_assert(sizeof...(Fs) == sizeof...(Ts),
                "Number of functors does not match number of types!");
            if (empty()) std::terminate();
            _visit4<0>(std::forward<Fs>(fs)...);
        }

        size_t index() const { return index_; }

        bool empty() const { return index_ == static_cast<size_t>(-1); }
 
#undef TERMINATE_FOR_EXCEPTION
    };

    struct ignore_t {
        template <class... Ts>
        void operator()(Ts &&...) {}
    };

    static constexpr ignore_t ignore;
}