TCPTreeAdapter.cpp

Go to the documentation of this file.

#include "Network/Adapter/TCPTreeAdapter.h"
 
namespace Ember {
namespace Network {
 
TCPTreeAdapter::TCPTreeAdapter(std::shared_ptr<EmberCore::BehaviorTree> tree,
                               std::shared_ptr<StateManager> state_manager)
    : m_tree(std::move(tree)), m_stateManager(std::move(state_manager)) {}
 
EmberCore::ITreeNode *TCPTreeAdapter::GetRootNode() const {
    if (!m_tree || !m_tree->HasRootNode()) {
        return nullptr;
    }
 
    if (!m_adapterCacheBuilt) {
        BuildAdapterCache();
    }
 
    return m_rootAdapter;
}
 
const EmberCore::String &TCPTreeAdapter::GetName() const {
    static EmberCore::String empty;
    if (!m_tree) {
        return empty;
    }
    return m_tree->GetName();
}
 
const EmberCore::String &TCPTreeAdapter::GetDescription() const {
    static EmberCore::String empty;
    if (!m_tree) {
        return empty;
    }
    return m_tree->GetDescription();
}
 
size_t TCPTreeAdapter::GetNodeCount() const {
    if (!m_tree) {
        return 0;
    }
    return m_tree->GetNodeCount();
}
 
size_t TCPTreeAdapter::GetMaxDepth() const {
    if (!m_tree) {
        return 0;
    }
    return m_tree->GetMaxDepth();
}
 
EmberCore::ITreeNode *TCPTreeAdapter::FindNodeById(size_t id) const {
    if (!m_tree) {
        return nullptr;
    }
 
    if (!m_adapterCacheBuilt) {
        BuildAdapterCache();
    }
 
    auto it = m_adapters.find(id);
    if (it != m_adapters.end()) {
        return it->second.get();
    }
 
    return nullptr;
}
 
EmberCore::ITreeNode *TCPTreeAdapter::FindNodeByName(const EmberCore::String &name) const {
    if (!m_tree) {
        return nullptr;
    }
 
    EmberCore::Node *node = m_tree->FindNodeByName(name);
    if (!node) {
        return nullptr;
    }
 
    return GetOrCreateAdapter(node);
}
 
std::vector<EmberCore::ITreeNode *> TCPTreeAdapter::FindNodesByType(EmberCore::ITreeNode::NodeType type) const {
    std::vector<EmberCore::ITreeNode *> result;
 
    if (!m_tree) {
        return result;
    }
 
    EmberCore::Node::Type coreType;
    switch (type) {
    case EmberCore::ITreeNode::NodeType::Action:
        coreType = EmberCore::Node::Type::Action;
        break;
    case EmberCore::ITreeNode::NodeType::Control:
        coreType = EmberCore::Node::Type::Control;
        break;
    case EmberCore::ITreeNode::NodeType::Condition:
        coreType = EmberCore::Node::Type::Condition;
        break;
    case EmberCore::ITreeNode::NodeType::Decorator:
        coreType = EmberCore::Node::Type::Decorator;
        break;
    case EmberCore::ITreeNode::NodeType::BehaviorTree:
        coreType = EmberCore::Node::Type::BehaviorTree;
        break;
    default:
        coreType = EmberCore::Node::Type::None;
        break;
    }
 
    auto nodes = m_tree->FindNodesByType(coreType);
    result.reserve(nodes.size());
 
    for (auto *node : nodes) {
        auto *adapter = GetOrCreateAdapter(node);
        if (adapter) {
            result.push_back(adapter);
        }
    }
 
    return result;
}
 
void TCPTreeAdapter::TraverseNodes(std::function<void(EmberCore::ITreeNode *)> visitor) {
    if (!m_tree || !visitor) {
        return;
    }
 
    m_tree->TraverseNodes([this, &visitor](EmberCore::Node *node) {
        auto *adapter = GetOrCreateAdapter(node);
        if (adapter) {
            visitor(adapter);
        }
    });
}
 
void TCPTreeAdapter::TraverseNodes(std::function<void(const EmberCore::ITreeNode *)> visitor) const {
    if (!m_tree || !visitor) {
        return;
    }
 
    m_tree->TraverseNodes([this, &visitor](const EmberCore::Node *node) {
        auto *adapter = GetOrCreateAdapter(const_cast<EmberCore::Node *>(node));
        if (adapter) {
            visitor(adapter);
        }
    });
}
 
bool TCPTreeAdapter::IsValid() const {
    if (!m_tree) {
        return false;
    }
    return m_tree->IsValid();
}
 
bool TCPTreeAdapter::HasCycles() const {
    if (!m_tree) {
        return false;
    }
    return m_tree->HasCycles();
}
 
std::vector<EmberCore::ITreeNode *> TCPTreeAdapter::GetAllNodes() {
    std::vector<EmberCore::ITreeNode *> result;
 
    if (!m_tree) {
        return result;
    }
 
    auto nodes = m_tree->GetAllNodes();
    result.reserve(nodes.size());
 
    for (auto *node : nodes) {
        auto *adapter = GetOrCreateAdapter(node);
        if (adapter) {
            result.push_back(adapter);
        }
    }
 
    return result;
}
 
std::vector<const EmberCore::ITreeNode *> TCPTreeAdapter::GetAllNodes() const {
    std::vector<const EmberCore::ITreeNode *> result;
 
    if (!m_tree) {
        return result;
    }
 
    auto nodes = m_tree->GetAllNodes();
    result.reserve(nodes.size());
 
    for (auto *node : nodes) {
        auto *adapter = GetOrCreateAdapter(const_cast<EmberCore::Node *>(node));
        if (adapter) {
            result.push_back(adapter);
        }
    }
 
    return result;
}
 
EmberCore::String TCPTreeAdapter::GetTreeStructure() const {
    if (!m_tree) {
        return "";
    }
    return m_tree->GetTreeStructure();
}
 
void TCPTreeAdapter::PrintTree() const {
    if (m_tree) {
        m_tree->PrintTree();
    }
}
 
TCPTreeAdapter::NodeStatus TCPTreeAdapter::GetNodeStatus(size_t node_id) const {
    if (!m_stateManager) {
        return Protocol::NodeStatus_Idle;
    }
    return m_stateManager->GetNodeStatus(static_cast<int64_t>(node_id));
}
 
bool TCPTreeAdapter::IsNodeInExecutionPath(size_t node_id) const {
    if (!m_stateManager) {
        return false;
    }
 
    const auto &path = m_stateManager->GetExecutionPath();
    int64_t id = static_cast<int64_t>(node_id);
 
    for (auto pathId : path) {
        if (pathId == id) {
            return true;
        }
    }
 
    return false;
}
 
int64_t TCPTreeAdapter::GetCurrentTick() const {
    if (!m_stateManager) {
        return 0;
    }
    return m_stateManager->GetCurrentTick();
}
 
EmberCore::NodeAdapter *TCPTreeAdapter::GetOrCreateAdapter(EmberCore::Node *node) const {
    if (!node) {
        return nullptr;
    }
 
    size_t id = node->GetId();
    auto it = m_adapters.find(id);
 
    if (it != m_adapters.end()) {
        return it->second.get();
    }
 
    auto adapter = std::make_unique<EmberCore::NodeAdapter>(node);
    auto *ptr = adapter.get();
    m_adapters[id] = std::move(adapter);
 
    return ptr;
}
 
void TCPTreeAdapter::BuildAdapterCache() const {
    if (m_adapterCacheBuilt) {
        return;
    }
 
    if (!m_tree || !m_tree->HasRootNode()) {
        m_adapterCacheBuilt = true;
        return;
    }
 
    m_rootAdapter = GetOrCreateAdapter(m_tree->GetRootNode());
 
    m_tree->TraverseNodes([this](EmberCore::Node *node) { GetOrCreateAdapter(node); });
 
    m_adapterCacheBuilt = true;
}
 
} // namespace Network
} // namespace Ember