spk_inherence_with_priority_object.hpp

#pragma once
 
#include "structure/design_pattern/spk_inherence_object.hpp"
 
#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
 
namespace spk
{
    template <typename TType>
    class InherenceWithPriorityObject : public spk::InherenceObject<TType>
    {
    public:
        using Priority = std::size_t;
 
    private:
        Priority _priority = 0;
 
    protected:
        void _sortChildByPriority()
        {
            auto &childs = this->children();
 
            std::stable_sort(childs.begin(), childs.end(), [](const TType *a, const TType *b) {
                return a->priority() > b->priority();
            });
        }

        void _notifyParentPriorityChanged()
        {
            if (auto *p = this->parent(); p != nullptr)
            {
                static_cast<InherenceWithPriorityObject<TType> *>(p)->_sortChildByPriority();
            }
        }
 
    public:
        InherenceWithPriorityObject()
        {
            static_assert(
                std::is_base_of_v<InherenceWithPriorityObject<TType>, TType>,
                "TType must inherit from InherenceWithPriorityObject<TType> to use priority() sorting.");
        }

        void addChild(TType *p_child) override
        {
            spk::InherenceObject<TType>::addChild(p_child);
            _sortChildByPriority();
        }

        void setPriority(const Priority &p_priority)
        {
            if (_priority == p_priority)
            {
                return;
            }
 
            _priority = p_priority;
            _notifyParentPriorityChanged();
        }

        const Priority &priority() const
        {
            return _priority;
        }
    };
}