spk_inherence_object.hpp

#pragma once
 
#include <vector>
 
namespace spk
{
    template <typename TType>
    class InherenceObject
    {
 
    private:
        TType *_parent = nullptr;
        std::vector<TType *> _children;
 
    public:
        InherenceObject()
        {
            static_assert(std::is_base_of_v<InherenceObject<TType>, TType>, "TType must inherit from InherenceObject<TType>");
        }
 
        virtual ~InherenceObject()
        {
            if (_parent != nullptr)
            {
                _parent->removeChild(static_cast<TType *>(this));
            }
        }

        virtual void addChild(TType *p_child)
        {
            if (p_child == nullptr || p_child == static_cast<TType *>(this))
            {
                return;
            }
 
            if (p_child->_parent != nullptr)
            {
                p_child->_parent->removeChild(p_child);
            }
 
            p_child->_parent = static_cast<TType *>(this);
            _children.emplace_back(p_child);
        }

        virtual void removeChild(TType *p_child)
        {
            if (p_child == nullptr)
            {
                return;
            }
 
            auto it = std::find(_children.begin(), _children.end(), p_child);
            if (it != _children.end())
            {
                _children.erase(it);
                p_child->_parent = nullptr;
            }
        }

        TType *parent() const
        {
            return _parent;
        }

        virtual std::vector<TType *> &children()
        {
            return _children;
        }

        virtual const std::vector<TType *> &children() const
        {
            return _children;
        }

        void clearChildren()
        {
            for (TType *child : _children)
            {
                child->_parent = nullptr;
            }
            _children.clear();
        }
    };
}