Component.h

Go to the documentation of this file.

#pragma once
 
#pragma once
 
#include <string>
#include <memory>
#include <vector>
#include <algorithm>
#ifdef COMPONENT_THREAD_SAFE
#include <atomic>
#include <mutex>
#endif
#include <queue>
#include <unordered_set>
#include <nlohmann/json.hpp>
#include <stdexcept>
#include <type_traits>
 
#include "ship/core/Part.h"
#include "ship/core/PartList.h"
#include "ship/core/ComponentList.h"
 
namespace Ship {
 
class Component : public Part, public std::enable_shared_from_this<Component> {
  public:
    explicit Component(const std::string& name, std::shared_ptr<Context> context = nullptr);
    virtual ~Component();
 
    void Init(const nlohmann::json& initArgs = nlohmann::json::object());
 
    bool IsInitialized() const;
 
    const std::string& GetName() const;
 
    std::string ToString() const;
 
    std::string ToTreeString(int depth = 0) const;
 
    explicit operator std::string() const;
 
    // ---- Parent/child relationship accessors ----
 
    ParentComponentList& GetParents();
    const ParentComponentList& GetParents() const;
 
    ComponentList& GetChildren();
    const ComponentList& GetChildren() const;
 
    virtual std::shared_ptr<Component> TryGetSharedComponent() noexcept;
 
    virtual std::shared_ptr<Component> GetSharedComponent();
 
    // ---- Breadth-first hierarchy search ----
 
    template <typename T> bool HasInChildren() const;
 
    template <typename T> std::shared_ptr<T> GetFirstInChildren() const;
 
    template <typename T> std::shared_ptr<std::vector<std::shared_ptr<T>>> GetInChildren() const;
 
    // ---- Breadth-first ancestor search ----
 
    template <typename T> bool HasInParents() const;
 
    template <typename T> std::shared_ptr<T> GetFirstInParents() const;
 
    template <typename T> std::shared_ptr<std::vector<std::shared_ptr<T>>> GetInParents() const;
 
  protected:
    virtual void OnInit(const nlohmann::json& initArgs = nlohmann::json::object());
 
    void MarkInitialized();
 
    template <typename T>
    std::shared_ptr<T> RequireDependency(const std::shared_ptr<T>& dependency, const std::string& dependencyName) const;
 
  private:
    std::string ToTreeStringImpl(int depth, std::unordered_set<uint64_t>& visited) const;
 
    std::string mName;
    std::weak_ptr<Component> mWeakSelf;
#ifdef COMPONENT_THREAD_SAFE
    std::atomic<bool> mIsInitialized{ false };
    mutable std::recursive_mutex mInitMutex;
#else
    bool mIsInitialized = false;
#endif
    ParentComponentList mParents;
    ComponentList mChildren;
};
 
// ---- Template BFS implementations (children) ----
// All three methods perform a full breadth-first traversal through the entire
// descendant tree. Every node's children are enqueued for further exploration,
// so the search is not limited to any particular depth.
 
template <typename T> bool Component::HasInChildren() const {
    std::queue<std::shared_ptr<const Component>> queue;
    std::unordered_set<uint64_t> visited;
    visited.insert(GetId());
 
    // Seed the queue with this component's direct children. The root itself is
    // handled here (rather than enqueued) so we never require it to be owned by
    // a shared_ptr.
    auto seed = GetChildren().Get();
    for (const auto& child : *seed) {
        if (visited.insert(child->GetId()).second) {
            if (std::dynamic_pointer_cast<T>(child)) {
                return true;
            }
            queue.push(child);
        }
    }
 
    // BFS: process every node, enqueue its children so we reach all depths.
    // The queue owns a shared_ptr to each node, so nodes stay alive even if a
    // concurrent Remove drops the last owning reference held by a parent list.
    while (!queue.empty()) {
        auto current = queue.front();
        queue.pop();
 
        auto currentChildren = current->GetChildren().Get();
        for (const auto& child : *currentChildren) {
            if (visited.insert(child->GetId()).second) {
                if (std::dynamic_pointer_cast<T>(child)) {
                    return true;
                }
                queue.push(child);
            }
        }
    }
    return false;
}
 
template <typename T>
std::shared_ptr<T> Component::RequireDependency(const std::shared_ptr<T>& dependency,
                                                const std::string& dependencyName) const {
    static_assert(std::is_base_of_v<Component, T>, "RequireDependency only supports Component dependencies");
 
    if (!dependency) {
        throw std::runtime_error("Component '" + GetName() + "' requires dependency '" + dependencyName +
                                 "' to exist before use");
    }
 
    if (!dependency->IsInitialized()) {
        throw std::runtime_error("Component '" + GetName() + "' requires dependency '" + dependencyName +
                                 "' to be initialized before use");
    }
 
    return dependency;
}
 
template <typename T> std::shared_ptr<T> Component::GetFirstInChildren() const {
    std::queue<std::shared_ptr<const Component>> queue;
    std::unordered_set<uint64_t> visited;
    visited.insert(GetId());
 
    auto seed = GetChildren().Get();
    for (const auto& child : *seed) {
        if (visited.insert(child->GetId()).second) {
            auto typed = std::dynamic_pointer_cast<T>(child);
            if (typed) {
                return typed;
            }
            queue.push(child);
        }
    }
 
    while (!queue.empty()) {
        auto current = queue.front();
        queue.pop();
 
        auto currentChildren = current->GetChildren().Get();
        for (const auto& child : *currentChildren) {
            if (visited.insert(child->GetId()).second) {
                auto typed = std::dynamic_pointer_cast<T>(child);
                if (typed) {
                    return typed;
                }
                queue.push(child);
            }
        }
    }
    return nullptr;
}
 
template <typename T> std::shared_ptr<std::vector<std::shared_ptr<T>>> Component::GetInChildren() const {
    auto result = std::make_shared<std::vector<std::shared_ptr<T>>>();
    std::queue<std::shared_ptr<const Component>> queue;
    std::unordered_set<uint64_t> visited;
    visited.insert(GetId());
 
    auto seed = GetChildren().Get();
    for (const auto& child : *seed) {
        if (visited.insert(child->GetId()).second) {
            auto typed = std::dynamic_pointer_cast<T>(child);
            if (typed) {
                result->push_back(typed);
            }
            queue.push(child);
        }
    }
 
    while (!queue.empty()) {
        auto current = queue.front();
        queue.pop();
 
        auto currentChildren = current->GetChildren().Get();
        for (const auto& child : *currentChildren) {
            if (visited.insert(child->GetId()).second) {
                auto typed = std::dynamic_pointer_cast<T>(child);
                if (typed) {
                    result->push_back(typed);
                }
                queue.push(child);
            }
        }
    }
    return result;
}
 
// ---- Template BFS implementations (parents) ----
// Mirror of the InChildren methods, but traversing upward through parents.
 
template <typename T> bool Component::HasInParents() const {
    std::queue<std::shared_ptr<const Component>> queue;
    std::unordered_set<uint64_t> visited;
    visited.insert(GetId());
 
    auto seed = GetParents().Get();
    for (const auto& parent : *seed) {
        if (visited.insert(parent->GetId()).second) {
            if (std::dynamic_pointer_cast<T>(parent)) {
                return true;
            }
            queue.push(parent);
        }
    }
 
    while (!queue.empty()) {
        auto current = queue.front();
        queue.pop();
 
        auto currentParents = current->GetParents().Get();
        for (const auto& parent : *currentParents) {
            if (visited.insert(parent->GetId()).second) {
                if (std::dynamic_pointer_cast<T>(parent)) {
                    return true;
                }
                queue.push(parent);
            }
        }
    }
    return false;
}
 
template <typename T> std::shared_ptr<T> Component::GetFirstInParents() const {
    std::queue<std::shared_ptr<const Component>> queue;
    std::unordered_set<uint64_t> visited;
    visited.insert(GetId());
 
    auto seed = GetParents().Get();
    for (const auto& parent : *seed) {
        if (visited.insert(parent->GetId()).second) {
            auto typed = std::dynamic_pointer_cast<T>(parent);
            if (typed) {
                return typed;
            }
            queue.push(parent);
        }
    }
 
    while (!queue.empty()) {
        auto current = queue.front();
        queue.pop();
 
        auto currentParents = current->GetParents().Get();
        for (const auto& parent : *currentParents) {
            if (visited.insert(parent->GetId()).second) {
                auto typed = std::dynamic_pointer_cast<T>(parent);
                if (typed) {
                    return typed;
                }
                queue.push(parent);
            }
        }
    }
    return nullptr;
}
 
template <typename T> std::shared_ptr<std::vector<std::shared_ptr<T>>> Component::GetInParents() const {
    auto result = std::make_shared<std::vector<std::shared_ptr<T>>>();
    std::queue<std::shared_ptr<const Component>> queue;
    std::unordered_set<uint64_t> visited;
    visited.insert(GetId());
 
    auto seed = GetParents().Get();
    for (const auto& parent : *seed) {
        if (visited.insert(parent->GetId()).second) {
            auto typed = std::dynamic_pointer_cast<T>(parent);
            if (typed) {
                result->push_back(typed);
            }
            queue.push(parent);
        }
    }
 
    while (!queue.empty()) {
        auto current = queue.front();
        queue.pop();
 
        auto currentParents = current->GetParents().Get();
        for (const auto& parent : *currentParents) {
            if (visited.insert(parent->GetId()).second) {
                auto typed = std::dynamic_pointer_cast<T>(parent);
                if (typed) {
                    result->push_back(typed);
                }
                queue.push(parent);
            }
        }
    }
    return result;
}
 
// ---- ComponentList template implementations ----
// These live here because they need the full Component definition,
// while ComponentList.h only forward-declares Component to break the
// circular dependency.
 
template <typename StoredPtr>
template <typename T>
bool BasicComponentList<StoredPtr>::Has(const std::string& name) const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(this->GetMutex());
#endif
    auto list = this->Get();
    return std::find_if(list->begin(), list->end(), [&name](const std::shared_ptr<Component>& c) {
               return c->GetName() == name && std::dynamic_pointer_cast<T>(c) != nullptr;
           }) != list->end();
}
 
template <typename StoredPtr>
template <typename T>
std::shared_ptr<std::vector<std::shared_ptr<T>>> BasicComponentList<StoredPtr>::Get(const std::string& name) const {
#ifdef COMPONENT_THREAD_SAFE
    const std::lock_guard<std::recursive_mutex> lock(this->GetMutex());
#endif
    auto result = std::make_shared<std::vector<std::shared_ptr<T>>>();
    auto list = this->Get();
    for (const auto& c : *list) {
        auto typed = std::dynamic_pointer_cast<T>(c);
        if (typed && c->GetName() == name) {
            result->push_back(typed);
        }
    }
    return result;
}
 
} // namespace Ship