reflection.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <dantelion2/kernel_runtime.hpp>
#include <detail/preprocessor.hpp>
#include <detail/symbols.hpp>
#include <memory/from_memory.hpp>
#include <memory/from_vector.hpp>
 
#include <algorithm>
#include <string>
 
namespace from {
namespace DLRF {
class DLRuntimeClass;
class DLMethodInvoker;
 
struct DLRuntimeMethod {
    LIBER_CLASS(DLRuntimeMethod);
 
    const char* get_method_name() const noexcept {
        return this->method_name;
    }
 
    const wchar_t* get_method_name_w() const noexcept {
        return this->method_name_w;
    }
 
    const from::vector<DLMethodInvoker*>& get_invokers() const noexcept {
        return this->invokers;
    }
 
private:
    friend class DLRuntimeClass;
 
    DLRuntimeClass* owner;
    const char* method_name;
    const wchar_t* method_name_w;
    from::vector<DLMethodInvoker*> invokers;
    from::vector<void*> liber_unknown;
    void* liber_unknown;
    DLKR::DLPlainMutex mutex;
};
 
class DLRuntimeClass {
public:
    LIBER_CLASS(DLRuntimeClass);
 
    virtual ~DLRuntimeClass() = default;
 
    virtual const char* get_class_name() const noexcept = 0;
 
    virtual const wchar_t* get_class_name_w() const noexcept = 0;
 
private:
    virtual void* liber_unknown() = 0;
    virtual void* liber_unknown() = 0;
    virtual void* liber_unknown() = 0;
    virtual void* liber_unknown() = 0;
    virtual bool liber_unknown() = 0;
    virtual void liber_unknown() = 0;
 
public:
    virtual size_t get_class_size() const noexcept = 0;
 
private:
    virtual void liber_unknown() = 0;
    virtual void liber_unknown() = 0;
 
public:
    const DLRuntimeClass* get_class_base() const noexcept {
        return this->base_class;
    }
 
    template <typename T>
    struct DLRuntimeObjectHolder {
        T* instance;
        const char* name;
        const wchar_t* name_w;
        size_t name_length;
    };
 
    using DLRuntimeClassHolder = DLRuntimeObjectHolder<DLRuntimeClass>;
    using DLRuntimeMethodHolder = DLRuntimeObjectHolder<DLRuntimeMethod>;
 
    static const from::vector<DLRuntimeClassHolder>*
    get_registered_classes() noexcept {
        using pointer_type =
            from::static_ptr<from::vector<DLRuntimeClassHolder>>;
        return liber::symbol<"GLOBAL_DLRuntimeClass_types">::as<pointer_type>()
            .get();
    }
 
    static DLRuntimeClass* get_runtime_class(
        std::string_view class_name) noexcept {
        const auto* classes = get_registered_classes();
        if (!classes)
            return nullptr;
        auto iter = std::lower_bound(classes->begin(), classes->end(),
            class_name,
            [](const DLRuntimeClassHolder& holder,
                const std::string_view& rhs) {
                return std::string_view(holder.name, holder.name_length) < rhs;
            });
        if (iter == classes->end()
            || std::string_view(iter->name, iter->name_length) != class_name)
            return nullptr;
        return iter->instance;
    }
 
    const from::vector<DLRuntimeMethodHolder>& get_methods() const noexcept {
        return this->runtime_methods;
    }
 
private:
    // A pointer to the base class, if the class is derived
    DLRuntimeClass* base_class;
    // A DLRuntimeMethod of the class's constructor
    DLRuntimeMethod* runtime_constructor;
    // A vector of DLRuntimeMethodHolders sorted by string length
    from::vector<DLRuntimeMethodHolder> runtime_methods;
};
} // namespace DLRF
} // namespace from