DirectTreeAdapter.cpp

Go to the documentation of this file.

#include "Adapters/DirectTreeAdapter.h"
#include <algorithm>
 
namespace EmberCore {
 
DirectTreeAdapter::DirectTreeAdapter(std::shared_ptr<BehaviorTree> tree) : behavior_tree_(tree) {}
 
ITreeNode *DirectTreeAdapter::GetRootNode() const {
    if (!behavior_tree_)
        return nullptr;
 
    EnsureRootAdapter();
    return root_adapter_.get();
}
 
const EmberCore::String &DirectTreeAdapter::GetName() const {
    static EmberCore::String defaultName = "Direct Tree";
    return behavior_tree_ ? behavior_tree_->GetName() : defaultName;
}
 
const EmberCore::String &DirectTreeAdapter::GetDescription() const {
    static EmberCore::String emptyDesc = "Empty tree";
    return behavior_tree_ ? behavior_tree_->GetDescription() : emptyDesc;
}
 
size_t DirectTreeAdapter::GetNodeCount() const { return behavior_tree_ ? behavior_tree_->GetNodeCount() : 0; }
 
size_t DirectTreeAdapter::GetMaxDepth() const { return behavior_tree_ ? behavior_tree_->GetMaxDepth() : 0; }
 
ITreeNode *DirectTreeAdapter::FindNodeById(size_t id) const {
    if (!behavior_tree_)
        return nullptr;
 
    // Use BehaviorTree's optimized node lookup
    Node *found = behavior_tree_->FindNodeById(id);
    return found ? GetOrCreateNodeAdapter(found) : nullptr;
}
 
ITreeNode *DirectTreeAdapter::FindNodeByName(const EmberCore::String &name) const {
    if (!behavior_tree_)
        return nullptr;
 
    // Use BehaviorTree's node lookup
    Node *found = behavior_tree_->FindNodeByName(name);
    return found ? GetOrCreateNodeAdapter(found) : nullptr;
}
 
std::vector<ITreeNode *> DirectTreeAdapter::FindNodesByType(ITreeNode::NodeType type) const {
    std::vector<ITreeNode *> result;
    if (!behavior_tree_)
        return result;
 
    Node::Type convertedType = ConvertNodeType(type);
    std::vector<Node *> nodes = behavior_tree_->FindNodesByType(convertedType);
 
    result.reserve(nodes.size());
    std::transform(nodes.begin(), nodes.end(), std::back_inserter(result),
                   [this](Node *node) { return GetOrCreateNodeAdapter(node); });
 
    return result;
}
 
void DirectTreeAdapter::TraverseNodes(std::function<void(ITreeNode *)> visitor) {
    if (!behavior_tree_)
        return;
 
    behavior_tree_->TraverseNodes([&](Node *node) {
        if (node) {
            visitor(GetOrCreateNodeAdapter(node));
        }
    });
}
 
void DirectTreeAdapter::TraverseNodes(std::function<void(const ITreeNode *)> visitor) const {
    if (!behavior_tree_)
        return;
 
    behavior_tree_->TraverseNodes([&](const Node *node) {
        if (node) {
            visitor(GetOrCreateNodeAdapter(const_cast<Node *>(node)));
        }
    });
}
 
bool DirectTreeAdapter::IsValid() const {
    // Simple validation - tree is valid if it has a root
    return behavior_tree_ && behavior_tree_->HasRootNode();
}
 
bool DirectTreeAdapter::HasCycles() const {
    // For now, assume no cycles (BehaviorTree doesn't implement cycle detection yet)
    return false;
}
 
std::vector<ITreeNode *> DirectTreeAdapter::GetAllNodes() {
    std::vector<ITreeNode *> result;
    TraverseNodes([&](ITreeNode *node) { result.push_back(node); });
    return result;
}
 
std::vector<const ITreeNode *> DirectTreeAdapter::GetAllNodes() const {
    std::vector<const ITreeNode *> result;
    TraverseNodes([&](const ITreeNode *node) { result.push_back(node); });
    return result;
}
 
EmberCore::String DirectTreeAdapter::GetTreeStructure() const {
    return behavior_tree_ ? behavior_tree_->GetTreeStructure() : EmberCore::String("Empty tree");
}
 
void DirectTreeAdapter::PrintTree() const {
    if (behavior_tree_) {
        behavior_tree_->PrintTree();
    }
}
 
// Helper methods
ITreeNode::NodeType DirectTreeAdapter::ConvertNodeType(Node::Type type) const {
    switch (type) {
    case Node::Type::Action:
        return ITreeNode::NodeType::Action;
    case Node::Type::Control:
        return ITreeNode::NodeType::Control;
    case Node::Type::Condition:
        return ITreeNode::NodeType::Condition;
    case Node::Type::Decorator:
        return ITreeNode::NodeType::Decorator;
    default:
        return ITreeNode::NodeType::Unknown;
    }
}
 
Node::Type DirectTreeAdapter::ConvertNodeType(ITreeNode::NodeType type) const {
    switch (type) {
    case ITreeNode::NodeType::Action:
        return Node::Type::Action;
    case ITreeNode::NodeType::Control:
        return Node::Type::Control;
    case ITreeNode::NodeType::Condition:
        return Node::Type::Condition;
    case ITreeNode::NodeType::Decorator:
        return Node::Type::Decorator;
    default:
        return Node::Type::None;
    }
}
 
void DirectTreeAdapter::EnsureRootAdapter() const {
    if (!root_adapter_ && behavior_tree_) {
        Node *root = behavior_tree_->GetRootNode();
        if (root) {
            root_adapter_ = std::make_unique<NodeAdapter>(root);
        }
    }
}
 
NodeAdapter *DirectTreeAdapter::GetOrCreateNodeAdapter(Node *node) const {
    if (!node)
        return nullptr;
 
    auto it = node_adapter_cache_.find(node);
    if (it == node_adapter_cache_.end()) {
        auto adapter = std::make_unique<NodeAdapter>(node);
        NodeAdapter *result = adapter.get();
        node_adapter_cache_[node] = std::move(adapter);
        return result;
    }
    return it->second.get();
}
 
} // namespace EmberCore