type_registry.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_RTTI_TYPE_REGISTRY_H
#define FENNEC_RTTI_TYPE_REGISTRY_H
 
#include <fennec/containers/priority_queue.h>
 
#include <fennec/lang/type_traits.h>
 
#include <fennec/rtti/type.h>
 
namespace fennec
{
 
template<typename BaseT, typename...ArgsT>
class type_registry {
public:
    using ctor_t = BaseT* (*)(ArgsT...);
 
    struct entry {
        size_t priority;
        type   type;
        ctor_t ctor;
 
        entry()
            : priority(0)
            , type(nullptr)
            , ctor(nullptr) {
        }
 
        entry(const entry& e)
            : priority(e.priority)
            , type(e.type)
            , ctor(e.ctor) {
        }
 
        entry(entry&& e) noexcept
            : priority(e.priority)
            , type(e.type)
            , ctor(e.ctor) {
        }
 
        ~entry() {
        }
 
        entry& operator=(const entry& e) {
            priority = e.priority;
            type = e.type;
            ctor = e.ctor;
            return *this;
        }
 
        entry& operator=(entry&&) noexcept = default;
 
        entry(size_t p, fennec::type type, ctor_t ctor)
            : priority(p), type(type), ctor(ctor) {
        }
    };
 
    struct compare {
        bool operator()(const entry& a, const entry& b) const {
            return a.priority > b.priority and a.ctor < b.ctor;
        }
    };
 
    using entrylist_t = priority_queue<entry, compare>;
 
    template<typename DerivedT> requires(is_base_of_v<BaseT, DerivedT>)
    static void register_type(size_t priority = 0) {
        _global_list().emplace(
            priority,
            type::get<DerivedT>(),
            _constructor_helper<DerivedT>
        );
    }
 
    static const entrylist_t& get_type_list() {
        return _global_list();
    }
 
private:
    static entrylist_t& _global_list() {
        static entrylist_t list;
        return list;
    }
 
    template<typename T>
    static BaseT* _constructor_helper(ArgsT...args) {
        return new T(args...);
    }
};
 
}
 
#endif // FENNEC_RTTI_TYPE_REGISTRY_H