generic.h

// =====================================================================================================================
//  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_GENERIC_H
#define FENNEC_CONTAINERS_GENERIC_H
 
#include <fennec/memory/allocator.h>
#include <fennec/rtti/type.h>
 
namespace fennec
{
 
struct generic {
 
// Definitions =========================================================================================================
private:
 
    // based on GCC
    enum op_ : uint8_t {
        op_clone,
        op_destroy,
        op_type,
    };
 
    using manager_t = void* (*)(uint8_t, void*);
 
 
// Constructors ========================================================================================================
public:
 
    generic()
        : _handle(nullptr)
        , _manage(nullptr) {
    }
 
    generic(const generic& gen)
        : _handle(nullptr)
        , _manage(gen._manage) {
        if (_manage) {
            _handle = _manage(op_clone, gen._handle);
        }
    }
 
    generic(generic&& gen)
        : _handle(gen._handle)
        , _manage(gen._manage) {
        gen._handle = nullptr;
        gen._manage = nullptr;
    }
 
    template<typename T>
    generic(T&& x)
        : _handle(new T(fennec::forward<T>(x)))
        , _manage(_manage_impl<T>) {
    }
 
    template<typename T, typename...ArgsT>
    generic(type_identity<T>, ArgsT&&...args)
        : _handle(new T(fennec::forward<ArgsT>(args)...))
        , _manage(_manage_impl<T>) {
    }
 
    ~generic() {
        reset();
    }
 
 
// Properties ==========================================================================================================
 
    type type() const {
        return *static_cast<fennec::type*>(_manage(op_type, nullptr));
    }
 
    bool has_value() const {
        return _handle != nullptr;
    }
 
 
// Assignment ==========================================================================================================
 
    generic& operator=(const generic& gen) {
        if (this == &gen) { // self-assignment case
            return *this;
        }
 
        reset();
        _manage = gen._manage;
        _handle = _manage(op_clone, gen._handle);
        return *this;
    }
 
    generic& operator=(generic&& gen) noexcept {
        swap(gen);
        return *this;
    }
 
 
// Utility =============================================================================================================
 
    template<typename T>
    generic& operator=(T&& x) {
        reset();
        _handle = new T(fennec::forward<T>(x));
        _manage = _manage_impl<T>();
        return *this;
    }
 
    template<typename T, typename...ArgsT>
    void emplace(ArgsT&&...args) {
        reset();
        _handle = new T(fennec::forward<ArgsT>(args)...);
        _manage = _manage_impl<T>;
    }
 
    void reset() {
        if (_manage) {
            _handle = _manage(op_destroy, _handle);
            _manage = nullptr;
        }
    }
 
    void swap(generic& gen) noexcept {
        fennec::swap(_handle, gen._handle);
        fennec::swap(_manage, gen._manage);
    }
 
    template<typename T>
    T& cast() {
        return *static_cast<T*>(_handle);
    }
 
    template<typename T>
    const T& cast() const {
        return *static_cast<T*>(_handle);
    }
 
private:
    void*     _handle;
    manager_t _manage;
 
    template<typename T>
    static void* _manage_impl(uint8_t op, void* hnd) {
        static fennec::type t = type::get<T>();
        T* ptr = hnd;
 
        switch (op) {
            case op_clone:
                return new T(*ptr);
            case op_destroy:
                delete ptr;
                return nullptr;
            case op_type:
                return &t;
            default:
                return nullptr;
        }
    }
};
 
}
 
#endif // FENNEC_CONTAINERS_GENERIC_H