variant.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  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 FENNEC_CONTAINERS_VARIANT_H
#define FENNEC_CONTAINERS_VARIANT_H
 
#include <fennec/containers/optional.h>
#include <fennec/lang/type_sequences.h>
#include <fennec/math/ext/common.h>
#include <fennec/rtti/type.h>
 
namespace fennec
{
 
template<typename...TypesT>
struct variant {
// Assertions ==========================================================================================================
 
    static_assert(
             is_unique_v<TypesT...>         and // No two types in TypesT... may be equivalent
        not (is_reference_v<TypesT> or ...) and // No type in TypesT... may be a reference
        not (is_array_v<TypesT> or ...)     and // No type in TypesT... may be an array
        not (is_void_v<TypesT> or ...)          // No type in TypesT... may be void
    );
 
 
// Typedefs & Constants ================================================================================================
 
    static constexpr size_t size = max_element_size_v<TypesT...>;
    static constexpr size_t nulltype = sizeof...(TypesT);
 
 
 
 
// Constructors ========================================================================================================
 
    variant()
        : _bytes {}
        , _type(nulltype) {
        using construct_t = search_element_t<is_default_constructible, TypesT...>;
        fennec::construct<construct_t>(_handle);
    }
 
    template<typename T>
    variant(T&& t)
        : _bytes {}
        , _type() {
        using same_t = search_element_args<is_same, type_sequence<T>, TypesT...>;
        using convert_t = search_element_args<is_constructible, type_sequence<T>, TypesT...>;
        using construct_t = conditional_t<is_void_v<same_t>, convert_t, convert_t>;
        fennec::construct<construct_t>(_handle, fennec::forward<T>(t));
    }
 
    template<typename T, typename...ArgsT>
    variant(type_identity<T>, ArgsT&&...args)
        : _bytes{}
        , _type(nulltype) {
        static_assert(contains_element_v<T, TypesT...>, "T must be in TypesT...");
        fennec::construct<T>(_handle, fennec::forward<ArgsT>(args)...);
        _type = find_element_v<T>;
    }
 
    variant(const variant& v)
        : _bytes {}
        , _type(nulltype) {
 
        if (v._type == nulltype) {
            return;
        }
 
        ((v._type == find_element_v<TypesT, TypesT...> ?
            fennec::construct<TypesT>(_handle, v.get<TypesT>()) :
            (0)
        ), ...);
        _type = v._type;
    }
 
    variant(variant&& v) noexcept
        : _bytes {}
        , _type() {
 
        if (v._type == nulltype) {
            return;
        }
 
        ((v._type == find_element_v<TypesT, TypesT...> ?
            fennec::construct<TypesT>(_handle, fennec::move(v.get<TypesT>())) :
            (0)
        ), ...);
        _type = v._type;
    }
 
    ~variant() {
        _clear();
    }
 
 
// Assignment ==========================================================================================================
 
    template<typename T>
    variant& operator=(T&& t) {
 
        // First, check if `T` is in `TypesT...`
        if constexpr((contains_element_v<T, TypesT> or ...)) {
            using type_t = remove_reference_t<T>;
            if (_type == find_element_v<type_t, TypesT...>) {
                *static_cast<type_t*>(_handle) = fennec::forward<T>(t);
            } else {
                _clear();
                fennec::construct<type_t>(_handle, fennec::forward<T>(t));
                _type = find_element_v<type_t, TypesT...>;
            }
            return *this;
        }
 
        // Next, try to assign using the currently held type
        bool assigned = false;
        if (_type != nulltype) {
            ((_type == find_element_v<TypesT, TypesT...> ?
                (*static_cast<TypesT*>(_handle) = fennec::forward<T>(t), assigned = true) :
                (0)
            ), ...);
        }
 
        if (assigned) {
            return *this;
        }
 
        // Otherwise, destruct, then construct
        _clear();
        using construct_t = search_element_args<is_constructible, type_sequence<T>, TypesT...>;
        fennec::construct<construct_t>(_handle, fennec::forward<T>(t));
        return *this;
    }
 
    template<typename T, typename...ArgsT> requires(contains_element_v<T, TypesT...>)
    void emplace(ArgsT&&...args) {
        _clear();
        fennec::construct<T>(_handle, fennec::forward<ArgsT>(args)...);
    }
 
    template<size_t I, typename...ArgsT>
    void emplace(ArgsT&&...args) {
        using type_t = nth_element_t<I, TypesT...>;
        _clear();
        fennec::construct<type_t>(fennec::forward<ArgsT>(args)...);
    }
 
 
// Access ==============================================================================================================
 
    template<typename T> requires(contains_element_v<T, TypesT...>)
    T& get() {
        return *static_cast<T*>(_handle);
    }
 
    template<typename T> requires(contains_element_v<T, TypesT...>)
    const T& get() const {
        return *static_cast<T*>(_handle);
    }
 
    template<size_t I, typename T = nth_element_t<I, TypesT...>> requires(contains_element_v<T, TypesT...>)
    T& get() {
        return *static_cast<T*>(_handle);
    }
 
    template<size_t I, typename T = nth_element_t<I, TypesT...>> requires(contains_element_v<T, TypesT...>)
    const T& get() const {
        return *static_cast<T*>(_handle);
    }
 
 
 
 
private:
    union {
        byte_t _bytes[size];
        void*  _handle;
    };
    size_t _type;
 
    void _clear() {
        if (_type == nulltype) {
            return;
        }
 
        ((_type == find_element_v<TypesT, TypesT...> ?
            fennec::destruct<TypesT>(_handle) :
            (0)
        ), ...);
        _type = nulltype;
    }
};
 
}
 
#endif // FENNEC_CONTAINERS_VARIANT_H