Class.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "MetaContainer.hpp"
#include "MetaItem.hpp"
#include "Type.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Span.hpp"
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
namespace CeresEngine {
 
    using MetaValues = SmallVector<Box, 4>;
 
    enum class MetaMemberIterationFlag {
        None = 0,
 
        IncludeFromBase = (1u << 0u),
 
        Default = None,
    };
 
    using MetaMemberIterationFlags = Flags<MetaMemberIterationFlag>;
 
    class Class : public MetaContainer {
    public:
        using CastFunctionType = const void* (*)(const void*);
        template<typename T> using MemberIterator = Generator<const T>;
        template<typename T> using MemberIteratorFunc = FunctionView<bool(const T&) const>;
 
    public:
        const StringView name;
        ReflectionAttributeContainer attributes;
 
    private:
        HashMap<TypeID, CastFunctionType> mBaseClasses;
 
    public:
        explicit Class(const StringView name) : name(name) {}
        ~Class() override = default;
 
    public:
        [[nodiscard]] static const Class* find(TypeID typeID);
 
        [[nodiscard]] static const Class* find(StringView name);
 
    public: // Base classes
        [[nodiscard]] Generator<const Class> forEachDirectBase() const;
        [[nodiscard]] Generator<const Class> forEachBase() const;
 
        [[nodiscard]] bool inheritedFrom(const Class* base) const;
 
    public: // Constructors
        void forEachConstructor(const MemberIteratorFunc<ClassConstructor>& func) const;
 
        [[nodiscard]] MemberIterator<ClassConstructor> forEachConstructor() const;
 
        template<typename... Args> [[nodiscard]] const ClassConstructor* getConstructor() const;
 
        [[nodiscard]] const ClassConstructor* getConstructor(StringView oldSignature) const;
 
        [[nodiscard]] const ClassConstructor* getDefaultConstructor() const;
        [[nodiscard]] const ClassConstructor* getCopyConstructor() const;
        [[nodiscard]] const ClassConstructor* getMoveConstructor() const;
 
    public: // Properties
        void forEachProperty(const MemberIteratorFunc<ClassProperty>& func) const { forEachProperty(MetaMemberIterationFlag::Default, func); }
 
        void forEachProperty(const MetaMemberIterationFlags& flags, const MemberIteratorFunc<ClassProperty>& func) const;
 
        [[nodiscard]] MemberIterator<ClassProperty> forEachProperty(MetaMemberIterationFlags flags = MetaMemberIterationFlag::Default) const;
 
        [[nodiscard]] const ClassProperty* getProperty(StringView name) const;
 
    public: // Methods
        void forEachMethod(const MemberIteratorFunc<ClassMethod>& func) const { forEachMethod(MetaMemberIterationFlag::Default, func); }
 
        void forEachMethod(const MetaMemberIterationFlags& flags, const MemberIteratorFunc<ClassMethod>& func) const;
 
        [[nodiscard]] MemberIterator<ClassMethod> forEachMethod(MetaMemberIterationFlags flags = MetaMemberIterationFlag::Default) const;
 
        template<typename... Args> [[nodiscard]] const ClassMethod* getMethod(StringView name) const;
 
    public:
        [[nodiscard]] const void* cast(const Class* base, const void* instance) const;
        [[nodiscard]] void* cast(const Class* base, void* instance) const;
 
    private:
        [[nodiscard]] const ClassMethod* getMethodInternal(StringView name) const;
        [[nodiscard]] const ClassProperty* getPropertyInternal(StringView name) const;
 
    protected:
        void addBaseClass(TypeID typeID, CastFunctionType caster);
    };
 
    class ReflectableClassTypeTrait {
    public:
        virtual ~ReflectableClassTypeTrait() = default;
        [[nodiscard]] virtual ClassInfo getClassInfo(void* target) const = 0;
        [[nodiscard]] virtual ClassInfo getClassInfo(const void* target) const = 0;
    };
 
    template<typename T> const Class* getClass() { return getType<T>().getClass(); }
 
    class ClassMember : public MetaItem {
    protected:
        using MetaItem::MetaItem;
    };
 
    class ClassConstructor : public ClassMember {
    public:
        String name;
        ReflectionAttributeContainer attributes;
 
    public:
        explicit ClassConstructor(Class& owner, StringView name);
 
    public:
        static constexpr MetaCategory kCategory = MetaCategory::Constructor;
        [[nodiscard]] MetaCategory getCategory() const override { return kCategory; }
 
        [[nodiscard]] virtual Span<const TypeID> getParameterTypeIDs() const = 0;
        [[nodiscard]] Span<const Type> getParameterTypes() const;
 
        virtual Box invoke(const MetaValues& arguments) const = 0;
 
        template<typename... Args> [[nodiscard]] auto invoke(Args&&... args) const { return invoke({std::ref(args)...}); }
    };
 
    class ClassProperty : public ClassMember {
    public:
        StringView name;
        ReflectionAttributeContainer attributes;
 
    public:
        explicit ClassProperty(Class& owner, StringView name);
        ~ClassProperty() noexcept override;
 
    public:
        static constexpr MetaCategory kCategory = MetaCategory::Property;
 
        [[nodiscard]] MetaCategory getCategory() const final { return kCategory; }
 
        [[nodiscard]] virtual bool isStatic() const noexcept = 0;
 
        [[nodiscard]] virtual bool isReadOnly() const noexcept = 0;
 
        [[nodiscard]] TypeID getTypeID() const noexcept;
        [[nodiscard]] Type getType() const;
 
    public: // Getter
        [[nodiscard]] virtual TypeID getGetterReturnTypeID() const noexcept = 0;
        [[nodiscard]] Type getGetterReturnType() const;
 
        [[nodiscard]] virtual Box get(const Box& target) const = 0;
 
        template<typename T> requires(!std::is_same_v<std::decay_t<T>, Box> && !std::is_same_v<std::decay_t<T>, Box>)
        [[nodiscard]] auto get(T& target) const {
            return get(std::ref(target));
        }
 
        [[nodiscard]] Box get() const;
 
    public: // Setter
        [[nodiscard]] virtual TypeID getSetterParameterTypeID() const noexcept = 0;
        [[nodiscard]] Type getSetterParameterType() const;
 
        virtual void set(const Box& target, const Box& value) const = 0;
 
        virtual void set(const Box& target, Box&& value) const = 0;
 
        template<typename T, typename V> requires(!std::is_same_v<std::decay_t<T>, Box> && !std::is_same_v<std::decay_t<V>, Box>)
        void set(T& target, const V& value) const {
            set(std::ref(target), std::ref(value));
        }
 
        template<typename T, typename V> requires(!std::is_same_v<std::decay_t<T>, Box> && !std::is_same_v<std::decay_t<V>, Box>)
        void set(T& target, V& value) const {
            set(std::ref(target), std::ref(value));
        }
 
        template<typename T, typename V> requires(!std::is_same_v<std::decay_t<T>, Box> && !std::is_same_v<std::decay_t<V>, Box>)
        void set(T& target, V&& value) const {
            set(std::ref(target), std::forward<V>(value));
        }
 
        void set(const Box& value) const;
 
        void set(Box&& value) const;
 
        template<typename V> requires(!std::is_same_v<std::decay_t<V>, Box>)
        void set(const V& value) const {
            set(nullptr, std::ref(value));
        }
 
        template<typename V> requires(!std::is_same_v<std::decay_t<V>, Box>)
        void set(V& value) const {
            set(nullptr, std::ref(value));
        }
 
        template<typename V> requires(!std::is_same_v<std::decay_t<V>, Box>)
        void set(V&& value) const {
            set(nullptr, std::forward<V>(value));
        }
    };
 
    class ClassMethod : public ClassMember {
    public:
        StringView name;
        ReflectionAttributeContainer attributes;
 
    private:
        mutable Vector<Type> mParameterTypes;
 
    public:
        explicit ClassMethod(Class& owner, StringView name);
 
    public:
        static constexpr MetaCategory kCategory = MetaCategory::Method;
 
        [[nodiscard]] MetaCategory getCategory() const override { return kCategory; }
 
        [[nodiscard]] virtual bool isStatic() const noexcept = 0;
        [[nodiscard]] virtual TypeID getReturnTypeID() const noexcept = 0;
        [[nodiscard]] Type getReturnType() const;
        [[nodiscard]] virtual Span<const TypeID> getParameterTypeIDs() const = 0;
        [[nodiscard]] Span<const Type> getParameterTypes() const;
 
    public: // Invoke
        virtual Box invoke(const MetaValues& arguments) const = 0;
        template<typename... Args> auto invoke(Args&&... args) const;
    };
 
    template<typename... Args> auto ClassMethod::invoke(Args&&... args) const { return invoke({std::ref(args)...}); }
 
} // namespace CeresEngine