MetaContainer.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 "MetaItem.hpp"
#include "Type.hpp"
 
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <functional>
 
namespace CeresEngine {
 
    constexpr auto ConstructorSignature = "constructor";
    constexpr auto DefaultConstructorSignature = "defaultConstructor";
    constexpr auto CopyConstructorSignature = "copyConstructor";
    constexpr auto MoveConstructorSignature = "moveConstructor";
 
    class MetaContainer;
    class Class;
    class ClassConstructor;
    class ClassMethod;
    class ClassProperty;
    class Enum;
    class EnumValue;
 
    class MetaContainer {
        friend class ClassProperty;
        friend class ClassConstructor;
        friend class ClassMethod;
        friend class EnumValue;
 
    private:
        // Need custom deleter since MetaItem destructor is protected
        struct Deleter {
            void operator()(const MetaItem* value) const;
        };
 
        using ItemPtr = UPtr<MetaItem, Deleter>;
        Vector<ItemPtr> mItems;
 
    protected:
        explicit MetaContainer() = default;
        virtual ~MetaContainer() = default;
 
    public:
        template<typename T, typename Func> void forEach(Func&& func) const;
        template<typename Func> void forEach(MetaCategory category, Func&& func) const;
 
        template<typename T> [[nodiscard]] Generator<const T> forEach() const;
        [[nodiscard]] Generator<const MetaItem> forEach(MetaCategory category) const;
 
    protected:
        [[nodiscard]] bool addItem(MetaItem* value);
        [[nodiscard]] std::size_t count(MetaCategory category) const;
    };
 
    extern template Generator<const ClassProperty> MetaContainer::forEach<ClassProperty>() const;
    extern template Generator<const ClassConstructor> MetaContainer::forEach<ClassConstructor>() const;
    extern template Generator<const ClassMethod> MetaContainer::forEach<ClassMethod>() const;
    extern template Generator<const EnumValue> MetaContainer::forEach<EnumValue>() const;
 
    template<typename T, typename Func> void MetaContainer::forEach(Func&& func) const {
        forEach(T::kCategory, [&func](const MetaItem& item) { return func(static_cast<const T&>(item)); });
    }
 
    template<typename Func> void MetaContainer::forEach(const MetaCategory category, Func&& func) const {
        using ReturnType = decltype(func(std::declval<const MetaItem&>()));
        for(const ItemPtr& item : mItems) {
            CE_ASSERT(item != nullptr);
 
            if(item->getCategory() != category)
                continue;
 
            if constexpr(std::is_same_v<ReturnType, void>) {
                func(*item);
            } else {
                if(!func(*item)) {
                    break;
                }
            }
        }
    }
 
    template<typename T> [[nodiscard]] Generator<const T> MetaContainer::forEach() const {
        for(const ItemPtr& item : mItems) {
            CE_ASSERT(item != nullptr);
 
            if(item->getCategory() != T::kCategory) {
                continue;
            }
 
            co_yield static_cast<const T&>(*item);
        }
    }
 
} // namespace CeresEngine