EntityTemplate.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 "Component.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/FlatMap.hpp"
 
namespace CeresEngine {
 
    class EntityTemplate {
    private:
        class ComponentData {
        public:
            [[nodiscard]] virtual const ComponentType& getComponentType() const noexcept = 0;
            virtual Any getComponent() noexcept = 0;
            [[nodiscard]] virtual Any getComponent() const noexcept = 0;
        };
 
        template<CComponent C> class TComponentData : public ComponentData {
        public:
            C component;
 
        public:
            template<typename... Args> explicit TComponentData(Args&&... args) : component(std::forward<Args>(args)...) {}
 
        public:
            [[nodiscard]] const ComponentType& getComponentType() const noexcept final { return ComponentType::get<C>(); }
 
            Any getComponent() noexcept final { return std::ref(component); }
 
            [[nodiscard]] Any getComponent() const noexcept final { return std::cref(component); }
        };
 
        FlatMap<ComponentID, UPtr<ComponentData>> mComponents;
        String mName;
 
    public:
        template<CComponent C, typename... Args> inline C& add(Args&&... args) noexcept(std::is_nothrow_constructible_v<C, Args...>) {
            const auto found = mComponents.find(ComponentType::get<C>().componentID);
            if(found != mComponents.end()) {
                // TODO Throw an exception here!
            }
 
            mComponents[ComponentType::get<C>().componentID] = ce_unique_new<TComponentData<C>>(std::forward<Args>(args)...);
        }
 
        template<CComponent C, typename Block, typename... Args>
        inline C& addWith(Block&& block, Args&&... args) noexcept(std::is_nothrow_constructible_v<C, Args...>);
 
        template<CComponent C, typename... Args> inline C& set(Args&&... args) noexcept(std::is_nothrow_constructible_v<C, Args...>);
 
        template<CComponent C> inline void remove() noexcept(std::is_nothrow_destructible_v<C>) {
            const auto found = mComponents.find(ComponentType::get<C>().componentID);
            if(found == mComponents.end()) {
                // TODO Throw an exception here!
            }
 
            mComponents.erase(found);
        }
 
        template<CComponent C> [[nodiscard]] inline C& get() noexcept {
            const auto found = mComponents.find(ComponentType::get<C>().componentID);
            if(found == mComponents.end()) {
                // TODO Throw an exception here!
            }
 
            TComponentData<C>& componentData = static_cast<TComponentData<C>&>(*found->second);
            return componentData.component;
        }
 
        template<CComponent C> [[nodiscard]] inline const C& get() const noexcept {
            const auto found = mComponents.find(ComponentType::get<C>().componentID);
            if(found == mComponents.end()) {
                // TODO Throw an exception here!
            }
 
            const TComponentData<C>& componentData = static_cast<const TComponentData<C>&>(*found->second);
            return componentData.component;
        }
 
        template<CComponent C0, CComponent C1, CComponent... Cs> [[nodiscard]] inline Tuple<C0&, C1&, Cs&...> get() noexcept {
            return {get<C0>(), get<C1>(), get<Cs>()...};
        }
 
        template<CComponent C0, CComponent C1, CComponent... Cs> [[nodiscard]] inline Tuple<const C0&, const C1&, const Cs&...> get() const noexcept {
            return {get<C0>(), get<C1>(), get<Cs>()...};
        }
 
        template<CComponent C> inline C& getOr() noexcept(std::is_nothrow_constructible_v<C>) {}
 
        template<CComponent C0, CComponent C1, CComponent... Cs> inline Tuple<C0&, C1&, Cs&...> getOr() noexcept;
 
        template<CComponent C> inline C* getIf() noexcept;
 
        template<CComponent C> [[nodiscard]] inline const C* getIf() const noexcept;
 
        template<CComponent C0, CComponent C1, CComponent... Cs> [[nodiscard]] inline Tuple<C0*, C1*, Cs*...> getIf() noexcept;
 
        template<CComponent C0, CComponent C1, CComponent... Cs> [[nodiscard]] inline Tuple<const C0*, const C1*, const Cs*...> getIf() const noexcept;
 
        template<CComponent C, CComponent... Cs> [[nodiscard]] inline bool has() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void clear();
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool empty() noexcept;
    };
 
} // namespace CeresEngine