imstkEntity.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkEventObject.h"
#include "imstkLogger.h"

#include <atomic>

namespace imstk
{
using EntityID = std::uint32_t;

class Component;

class Entity : public EventObject, public std::enable_shared_from_this<Entity>
{
public:
    Entity(const std::string& name = "Entity");
    ~Entity() override = default;

    // *INDENT-OFF*
    SIGNAL(Entity, modified);
    // *INDENT-ON*

    EntityID getID() const { return m_ID; }

    virtual const std::string getTypeName() const { return "Entity"; }

    const std::string& getName() const { return m_name; }
    void setName(const std::string& name) { m_name = name; }

    template<typename T>
    std::shared_ptr<T> addComponent()
    {
        auto component = std::make_shared<T>();
        addComponent(component);
        return component;
    }

    template<typename T>
    std::shared_ptr<T> addComponent(std::string name)
    {
        auto component = std::make_shared<T>(name);
        addComponent(component);
        return component;
    }

    void addComponent(std::shared_ptr<Component> component);

    std::shared_ptr<Component> getComponent(const unsigned int index) const;

    template<typename T>
    std::shared_ptr<T> getComponent() const
    {
        for (const auto& component : m_components)
        {
            if (auto compT = std::dynamic_pointer_cast<T>(component))
            {
                return compT;
            }
        }
        return nullptr;
    }

    template<typename T>
    std::shared_ptr<T> getComponentN(const int index) const
    {
        int count = 0;
        for (auto comp : m_components)
        {
            if (auto castComp = std::dynamic_pointer_cast<T>(comp))
            {
                if (count == index)
                {
                    return castComp;
                }
                count++;
            }
        }
        return nullptr;
    }

    template<class T>
    bool containsComponent() const { return getComponent<T>() != nullptr; }
    bool containsComponent(std::shared_ptr<Component> component) const;

    template<typename T>
    std::vector<std::shared_ptr<T>> getComponents() const
    {
        std::vector<std::shared_ptr<T>> components;
        for (const auto& component : m_components)
        {
            if (auto compT = std::dynamic_pointer_cast<T>(component))
            {
                components.push_back(compT);
            }
        }
        return components;
    }

    const std::vector<std::shared_ptr<Component>>& getComponents() { return m_components; }

    void removeComponent(std::shared_ptr<Component> component);

protected:
    std::vector<std::shared_ptr<Component>> m_components;

    static std::atomic<EntityID> m_count; 

    EntityID    m_ID;                     
    std::string m_name;                   
};
} // namespace imstk