type_data.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_DATA_H
#define FENNEC_RTTI_TYPE_DATA_H
 
#include <fennec/containers/bitfield.h>
#include <fennec/containers/dynarray.h>
#include <fennec/string/string.h>
#include <fennec/memory/pointers.h>
#include <fennec/rtti/typeid.h>
#include <fennec/rtti/forward.h>
#include <fennec/rtti/detail/_type_name.h>
 
namespace fennec
{
 
struct type_data {
    enum property_ {
        property_complete = 0,
        property_iterable,
        property_indexable,
        property_mappable,
 
        property_count
    };
 
    using properties_t = bitfield<property_count>;
 
    uint64_t uuid;
    string   name;
 
    type_data*           raw_type;
    dynarray<type_data*> supers;
    dynarray<type_data*> subs;
 
    properties_t properties;
 
    type_data* key_type;
};
 
struct type_storage {
private:
    template<typename ClassT> using _super_class_list = typename ClassT::super_class_list;
    template<typename ClassT> using _key_t            = typename ClassT::key_t;
 
    static dynarray<unique_ptr<type_data>>& _typelist() {
        static dynarray<unique_ptr<type_data>> typelist;
        return typelist;
    }
 
    template<typename T>
    static unique_ptr<type_data> _make_data() {
        using raw_t    = remove_cvrefptr_t<T>;
        using supers_t = detect_t<typelist<>, _super_class_list, T>;
 
        auto res = fennec::unique_ptr<type_data>(new type_data{
            .uuid = typeuuid<T>(),
            .name = detail::type_name<T>(),
 
            .raw_type = typeuuid<raw_t>() == typeuuid<T>() ? nullptr : type_storage::get_data<raw_t>(),
            .supers   = type_storage::get_data(supers_t{}),
            .subs     = {},
 
            .properties = { is_complete_v<T>, is_iterable_v<T>, is_indexable_v<T>, is_mappable_v<T> },
 
            .key_type = type_storage::get_data<detect_t<void, _key_t, T>>(),
        });
 
        for (type_data* t : res->supers) {
            t->subs.push_back(res.get());
        }
 
        return res;
    }
 
public:
    template<typename T>
    static type_data* get_data() requires(not is_void_v<T>) {
        auto&    typelist = _typelist();
        uint64_t uuid     = typeuuid<T>();
 
        if (typelist.size() <= uuid) {
            typelist.resize(uuid * 2);
        }
 
        if (typelist[uuid].empty()) {
            typelist[uuid] = fennec::forward<unique_ptr<type_data>>(_make_data<T>());
        }
 
        return typelist[uuid].get();
    }
 
    template<typename T>
    static type_data* get_data() {
        return nullptr;
    }
 
    template<typename...Ts>
    static dynarray<type_data*> get_data(typelist<Ts...>) {
        return {
            get_data<Ts>()...
        };
    }
};
 
}
 
#endif // FENNEC_RTTI_TYPE_DATA_H