Entity.h

 
#pragma once
 
#include <cstddef>  //std::size_t
#include <type_traits>
 
#include "Refureku/Config.h"
#include "Refureku/Misc/Pimpl.h"
#include "Refureku/Misc/GetPimplMacro.h"
#include "Refureku/TypeInfo/Entity/EEntityKind.h"
#include "Refureku/Properties/Property.h"
#include "Refureku/Misc/Visitor.h"
#include "Refureku/Misc/Predicate.h"
#include "Refureku/Containers/Vector.h"
 
namespace rfk
{
    //Forward declarations
    class Struct;
    class Algorithm;
 
    class Entity
    {
        public:
            Entity(Entity const&) = delete;
 
            RFK_NODISCARD REFUREKU_API
                Property const*             getPropertyAt(std::size_t propertyIndex)                    const   noexcept;
 
            template <typename PropertyType, typename = std::enable_if_t<std::is_base_of_v<Property, PropertyType> && !std::is_same_v<PropertyType, Property>>>
            RFK_NODISCARD
                PropertyType const*         getProperty(bool isChildClassValid = true)                  const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                Property const*             getProperty(Struct const&   archetype,
                                                        bool            isChildClassValid = true)       const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                Property const*             getPropertyByName(char const* name)                         const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                Property const*             getPropertyByPredicate(Predicate<Property>  predicate,
                                                                   void*                userData)       const;
 
            template <typename PropertyType, typename = std::enable_if_t<std::is_base_of_v<Property, PropertyType> && !std::is_same_v<PropertyType, Property>>>
            RFK_NODISCARD
                Vector<PropertyType const*> getProperties(bool isChildClassValid = true)                const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                Vector<Property const*>     getProperties(Struct const& archetype,
                                                          bool          isChildClassValid = true)       const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                Vector<Property const*>     getPropertiesByName(char const* name)                       const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                Vector<Property const*>     getPropertiesByPredicate(Predicate<Property>    predicate,
                                                                     void*                  userData)   const;
 
            RFK_NODISCARD REFUREKU_API
                std::size_t                 getPropertiesCount()                                        const   noexcept;
 
            REFUREKU_API bool               foreachProperty(Visitor<Property>   visitor,
                                                            void*               userData)               const;
 
            RFK_NODISCARD REFUREKU_API
                char const*                 getName()                                                   const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                bool                        hasSameName(char const* name)                               const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                std::size_t                 getId()                                                     const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                EEntityKind                 getKind()                                                   const   noexcept;
 
            RFK_NODISCARD REFUREKU_API
                Entity const*               getOuterEntity()                                            const   noexcept;
 
            REFUREKU_API bool               addProperty(Property const& property)                               noexcept;
 
            REFUREKU_API void               setOuterEntity(Entity const* outerEntity)                           noexcept;
 
            REFUREKU_API void               setPropertiesCapacity(std::size_t capacity)                         noexcept;
 
 
            Entity&                         operator=(Entity const&)        = delete;
            Entity&                         operator=(Entity&&)             = delete;
 
            RFK_NODISCARD REFUREKU_API bool operator==(Entity const& other) const    noexcept;
            RFK_NODISCARD REFUREKU_API bool operator!=(Entity const& other) const    noexcept;
 
        protected:
            //Forward declaration
            class EntityImpl;
 
            REFUREKU_INTERNAL Entity(Entity&&)                      noexcept;
            REFUREKU_INTERNAL Entity(EntityImpl* implementation)    noexcept;
            REFUREKU_INTERNAL ~Entity()                             noexcept;
 
            RFK_GEN_GET_PIMPL(EntityImpl, _pimpl.get())
 
        private:
            Pimpl<EntityImpl> _pimpl;
 
        friend Algorithm;
    };
 
    #include "Refureku/TypeInfo/Entity/Entity.inl"
}