ksHierarchyObject.h

/*************************************************************************
 * 
 * KINEMATICOUP CONFIDENTIAL
 * __________________
 * 
 *  Copyright (2016-2021) KinematicSoup Technologies Incorporated
 *  All Rights Reserved.
 * 
 * NOTICE:  All information contained herein is, and remains
 * the property of KinematicSoup Technologies Incorporated and its 
 * suppliers, if any.  The intellectual and technical concepts contained
 * herein are proprietary to KinematicSoup Technologies Incorporated
 * and its suppliers and may be covered by Canadian and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from KinematicSoup Technologies Incorporated.
 */
#pragma once
 
#include <functional>
#include <list>
#include <memory>
#include <stdexcept>
#include <stack>
 
namespace KS {
    template <typename T>
    class ksHierarchyObject : public std::enable_shared_from_this<T>
    {
    public:
        typedef std::function<bool(std::shared_ptr<T>)> ForEachCallback;
 
        ksHierarchyObject()
        {
        }
 
        virtual ~ksHierarchyObject()
        {
        }
 
        std::shared_ptr<T> Parent()
        {
            return m_parentPtr.lock();
        }
 
        const std::list<std::shared_ptr<T>>& Children()
        {
            return m_children;
        }
        
        std::shared_ptr<T> Child(size_t index)
        {
            if (m_children.size() <= index) {
                return nullptr;
            }
            auto iter = std::next(m_children.begin(), index);
            return *iter;
        }
 
        int IndexOfChild(std::shared_ptr<T> childPtr)
        {
            auto iter = m_children.begin();
            int index = 0;
            while (iter != m_children.end()) {
                if (*iter == childPtr) {
                    return index;
                }
                index++;
                iter++;
            }
            return -1;
        }
 
        void Detach()
        {
            std::shared_ptr<T> parentPtr = Parent();
            if (parentPtr != nullptr)
            {
                parentPtr->RemoveChild(std::enable_shared_from_this<T>::shared_from_this());
            }
        }
 
        bool IsDescendantOf(std::shared_ptr<T> objPtr)
        {
            if (objPtr == nullptr)
            {
                return false;
            }
 
            std::shared_ptr<T> parentPtr = Parent();
            while (parentPtr != nullptr) {
                if (objPtr == parentPtr)
                {
                    return true;
                }
                parentPtr = parentPtr->Parent();
            }
            return false;
        }
 
        virtual bool AddChild(std::shared_ptr<T> childPtr)
        {
            return PerformAddChild(childPtr);
        }
 
        virtual bool InsertChild(int index, std::shared_ptr<T> childPtr)
        {
            return PerformInsertChild(index, childPtr);
        }
 
        virtual bool RemoveChild(std::shared_ptr<T> childPtr)
        {
            return PerformRemoveChild(childPtr);
        }
 
        void ForEachDescendant(ForEachCallback callback)
        {
            for (auto childPtr : m_children)
            {
                if (callback(childPtr))
                {
                    childPtr->ForEachDescendant(callback);
                }
            }
        }
        
        void ForSelfAndDescendants(ForEachCallback callback)
        {
            if (callback(std::enable_shared_from_this<T>::shared_from_this()))
            {
                ForEachDescendant(callback);
            }
        }
 
        template <typename A>
        class AncestorIter
        {
        public:
            AncestorIter(A obj) : 
                m_current{ obj }
            {
            }
 
            bool Next() 
            { 
                if (m_current != nullptr) {
                    m_current = m_current->Parent();
                }
                return (m_current!= nullptr);
            }
 
            bool operator==(const AncestorIter<A>& other) const 
            { 
                return m_current == other.m_current;
            }
 
            bool operator!=(const AncestorIter<A>& other) const
            { 
                return m_current != other.m_current;
            }
 
            A Value() 
            { 
                return m_current;
            }
        private:
            A m_current;
        };
 
        AncestorIter<std::shared_ptr<T>> SelfAndAncestors()
        {
            return AncestorIter<std::shared_ptr<T>>{ std::enable_shared_from_this<T>::shared_from_this() };
        }
 
        AncestorIter<std::shared_ptr<T>> Ancestors()
        {
            return AncestorIter<std::shared_ptr<T>>{ m_parentPtr.lock() };
        }
 
        template <typename D>
        class DescendantIter
        {
        public:
            DescendantIter(D obj) : 
                m_current{ obj }
            {
            }
 
            bool Next()
            {
                if (m_current != nullptr) {
                    if (m_current->Children().size() > 0)
                    {
                        typename std::list<D>::const_iterator iter = m_current->Children().cbegin();
                        m_stack.push(std::make_pair(m_current, iter));
                        m_current = *(m_stack.top().second);
                        return m_current != nullptr;
                    }
                    else {
                        while (m_stack.size() > 0) {
                            m_stack.top().second++;
                            if (m_stack.top().second != m_stack.top().first->Children().cend())
                            {
                                m_current = *(m_stack.top().second);
                                return m_current != nullptr;
                            }
                            else {
                                m_stack.pop();
                            }
                        }
                        m_current = nullptr;
                    }
                }
                return m_current != nullptr;
            }
 
            bool operator==(const DescendantIter<D>& other) const
            {
                return m_current == other.m_current && m_stack == other.m_stack;
            }
 
            bool operator!=(const DescendantIter<D>& other) const
            {
                return m_current != other.m_current || m_stack != other.m_stack;
            }
 
            D Value()
            {
                return m_current;
            }
        private:
            std::stack<std::pair<D, typename std::list<D>::const_iterator>> m_stack;
            D m_current;
        };
 
        DescendantIter<std::shared_ptr<T>> SelfAndDescendants()
        {
            return DescendantIter<std::shared_ptr<T>>{ std::enable_shared_from_this<T>::shared_from_this() };
        }
 
        DescendantIter<std::shared_ptr<T>> Descendants()
        {
            auto iter = DescendantIter<std::shared_ptr<T>>{ std::enable_shared_from_this<T>::shared_from_this() };
            iter.Next();
            return iter;
        }
    protected:
        std::weak_ptr<T> m_parentPtr;
        std::list<std::shared_ptr<T>> m_children;
 
        virtual bool MoveChild(std::shared_ptr<T> childPtr, int newIndex)
        {
            if (childPtr == nullptr)
            {
                throw std::invalid_argument("Argument null exception");
            }
 
            auto iter = std::find(m_children.begin(), m_children.end(), childPtr);
            if (iter != m_children.end())
            {
                m_children.remove(childPtr);
                m_children.insert(std::next(m_children.begin(), newIndex), childPtr);
                return true;
            }
            return false;
        }
 
        virtual bool PerformAddChild(std::shared_ptr<T> childPtr)
        {
            if (childPtr == nullptr)
            {
                throw std::invalid_argument("Argument null exception");
            }
 
            if (childPtr->m_parentPtr.lock() == std::enable_shared_from_this<T>::shared_from_this() ||
                childPtr == std::enable_shared_from_this<T>::shared_from_this() ||
                IsDescendantOf(childPtr))
            {
                return false;
            }
 
            childPtr->PerformDetach();
            childPtr->m_parentPtr = std::enable_shared_from_this<T>::shared_from_this();
            m_children.push_back(childPtr);
            return true;
        }
 
        virtual bool PerformInsertChild(int index, std::shared_ptr<T> childPtr)
        {
            if (childPtr == nullptr)
            {
                throw std::invalid_argument("Argument null exception");
            }
 
            if (index > (int)m_children.size() || index < 0 ||
                childPtr->m_parentPtr.lock() == std::enable_shared_from_this<T>::shared_from_this() ||
                childPtr == std::enable_shared_from_this<T>::shared_from_this() ||
                IsDescendantOf(childPtr))
            {
                return false;
            }
 
            childPtr->PerformDetach();
            childPtr->m_parentPtr = std::enable_shared_from_this<T>::shared_from_this();
            auto iter = std::next(m_children.begin(), index);
            m_children.insert(iter, childPtr);
            return true;
        }
 
        virtual bool PerformRemoveChild(std::shared_ptr<T> childPtr)
        {
            if (childPtr == nullptr)
            {
                throw std::invalid_argument("Argument null exception");
            }
 
            auto iter = std::find(m_children.begin(), m_children.end(), childPtr);
            if (iter != m_children.end()) 
            {
                m_children.remove(childPtr);
                childPtr->m_parentPtr.reset();
                return true;
            }
            return false;
        }
 
        void PerformDetach()
        {
            std::shared_ptr<T> parentPtr = Parent();
            if (parentPtr != nullptr)
            {
                std::static_pointer_cast<ksHierarchyObject<T>>(parentPtr)->
                    PerformRemoveChild(std::enable_shared_from_this<T>::shared_from_this());
            }
        }
    };
}