type.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_H
#define FENNEC_RTTI_TYPE_H
 
#include <fennec/lang/types.h>
#include <fennec/rtti/type_data.h>
 
namespace fennec
{
 
struct type {
 
    const string& name() const {
        static const string nullname = string("[none]");
        return _data ? _data->name : nullname;
    }
 
    uint64_t id() const {
        return _data ? _data->uuid : 0;
    }
 
    dynarray<type> supertypes() const {
        return _data ? _data->supers : dynarray<type_data*>{};
    }
 
    dynarray<type> subtypes() const {
        return _data ? _data->subs : dynarray<type_data*>{};
    }
 
    bool is_complete() const {
        return _data ? _data->properties.test(type_data::property_complete) : false;
    }
 
    bool is_iterable() const {
        return _data ? _data->properties.test(type_data::property_iterable) : false;
    }
 
    bool is_indexable() const {
        return _data ? _data->properties.test(type_data::property_indexable) : false;
    }
 
    bool is_mappable() const {
        return _data ? _data->properties.test(type_data::property_mappable) : false;
    }
 
    type key_type() const {
        return _data ? _data->key_type : nullptr;
    }
 
    bool operator==(const type& c) const {
        return _data == c._data;
    }
 
    template<typename TypeT>
    static type get() { return type(static_cast<TypeT*>(nullptr)); }
 
    template<typename TypeT>
    static type get_from_instance(TypeT* t) { return type(t); }
 
    template<typename TypeT>
    static type get_from_instance(const TypeT*) { return type(static_cast<TypeT*>(nullptr)); }
 
private:
    const type_data* _data;
 
    template<typename TypeT>
    type(TypeT*) : _data(type_storage::get_data<TypeT>()) {
    }
 
public:
    type(type_data* d) : _data(d) { }
 
    type(const type& t) = default;
    type(type&& t) noexcept = default;
 
    type& operator=(const type&) = default;
    type& operator=(type&&) noexcept = default;
};
 
 
}
 
#endif // FENNEC_RTTI_TYPE_H