NodeAdapter.cpp

Go to the documentation of this file.

#include "Adapters/NodeAdapter.h"
#include <algorithm>
#include <stdexcept>
 
namespace EmberCore {
 
NodeAdapter::NodeAdapter(Node *node) : wrapped_node_(node) {
    if (!wrapped_node_) {
        throw std::invalid_argument("NodeAdapter: wrapped_node cannot be null");
    }
}
 
const EmberCore::String &NodeAdapter::GetName() const { return wrapped_node_->GetName(); }
 
ITreeNode::NodeType NodeAdapter::GetType() const { return ConvertNodeType(wrapped_node_->GetType()); }
 
ITreeNode::NodeStatus NodeAdapter::GetStatus() const { return ConvertNodeStatus(wrapped_node_->GetStatus()); }
 
size_t NodeAdapter::GetId() const { return wrapped_node_->GetId(); }
 
size_t NodeAdapter::GetChildCount() const { return wrapped_node_->GetChildCount(); }
 
ITreeNode *NodeAdapter::GetChild(size_t index) const {
    EnsureChildAdapters();
 
    if (index >= child_adapters_.size()) {
        return nullptr;
    }
 
    return child_adapters_[index].get();
}
 
ITreeNode *NodeAdapter::GetParent() const {
    if (!wrapped_node_->GetParent()) {
        return nullptr;
    }
 
    EnsureParentAdapter();
    return parent_adapter_.get();
}
 
const EmberCore::Point &NodeAdapter::GetPosition() const { return wrapped_node_->GetPosition(); }
 
void NodeAdapter::SetPosition(const EmberCore::Point &position) { wrapped_node_->SetPosition(position); }
 
ITreeNode::VisualState NodeAdapter::GetVisualState() const {
    return ConvertVisualState(wrapped_node_->GetVisualState());
}
 
void NodeAdapter::SetVisualState(VisualState state) { wrapped_node_->SetVisualState(ConvertVisualState(state)); }
 
bool NodeAdapter::AreChildrenVisible() const { return wrapped_node_->AreChildrenVisible(); }
 
void NodeAdapter::SetChildrenVisible(bool visible) { wrapped_node_->SetChildrenVisible(visible); }
 
int NodeAdapter::GetChildrenWidth() const { return wrapped_node_->GetChildrenWidth(); }
 
void NodeAdapter::SetChildrenWidth(int width) { wrapped_node_->SetChildrenWidth(width); }
 
int NodeAdapter::CalculateSubtreeWidth(int node_width, int horizontal_spacing) const {
    return wrapped_node_->CalculateSubtreeWidth(node_width, horizontal_spacing);
}
 
size_t NodeAdapter::GetDepth() const { return wrapped_node_->GetDepth(); }
 
size_t NodeAdapter::GetSubtreeNodeCount() const { return wrapped_node_->GetSubtreeNodeCount(); }
 
void NodeAdapter::Accept(std::function<void(ITreeNode *)> visitor) {
    visitor(this);
 
    // Visit children
    EnsureChildAdapters();
    for (auto &child_adapter : child_adapters_) {
        if (child_adapter) {
            child_adapter->Accept(visitor);
        }
    }
}
 
void NodeAdapter::Accept(std::function<void(const ITreeNode *)> visitor) const {
    visitor(this);
 
    // Visit children
    EnsureChildAdapters();
    for (const auto &child_adapter : child_adapters_) {
        if (child_adapter) {
            static_cast<const ITreeNode *>(child_adapter.get())->Accept(visitor);
        }
    }
}
 
// Helper methods
 
ITreeNode::NodeType NodeAdapter::ConvertNodeType(Node::Type type) const {
    switch (type) {
    case Node::Type::Action:
        return NodeType::Action;
    case Node::Type::Control:
        return NodeType::Control;
    case Node::Type::Condition:
        return NodeType::Condition;
    case Node::Type::Decorator:
        return NodeType::Decorator;
    case Node::Type::BehaviorTree:
        return NodeType::BehaviorTree;
    default:
        return NodeType::Unknown;
    }
}
 
ITreeNode::NodeStatus NodeAdapter::ConvertNodeStatus(Node::Status status) const {
    switch (status) {
    case Node::Status::Idle:
        return NodeStatus::Idle;
    case Node::Status::Running:
        return NodeStatus::Running;
    case Node::Status::Success:
        return NodeStatus::Success;
    case Node::Status::Failure:
        return NodeStatus::Failure;
    default:
        return NodeStatus::Idle;
    }
}
 
ITreeNode::VisualState NodeAdapter::ConvertVisualState(Node::VisualState state) const {
    switch (state) {
    case Node::VisualState::Normal:
        return VisualState::Normal;
    case Node::VisualState::Selected:
        return VisualState::Selected;
    case Node::VisualState::Hovered:
        return VisualState::Hovered;
    case Node::VisualState::Highlighted:
        return VisualState::Highlighted;
    default:
        return VisualState::Normal;
    }
}
 
Node::VisualState NodeAdapter::ConvertVisualState(VisualState state) const {
    switch (state) {
    case VisualState::Normal:
        return Node::VisualState::Normal;
    case VisualState::Selected:
        return Node::VisualState::Selected;
    case VisualState::Hovered:
        return Node::VisualState::Hovered;
    case VisualState::Highlighted:
        return Node::VisualState::Highlighted;
    default:
        return Node::VisualState::Normal;
    }
}
 
void NodeAdapter::EnsureChildAdapters() const {
    if (child_adapters_.size() != wrapped_node_->GetChildCount()) {
        child_adapters_.clear();
        child_adapters_.reserve(wrapped_node_->GetChildCount());
 
        for (size_t i = 0; i < wrapped_node_->GetChildCount(); ++i) {
            Node *child = wrapped_node_->GetChild(i);
            if (child) {
                child_adapters_.push_back(std::make_unique<NodeAdapter>(child));
            } else {
                child_adapters_.push_back(nullptr);
            }
        }
    }
}
 
void NodeAdapter::EnsureParentAdapter() const {
    if (!parent_adapter_ && wrapped_node_->GetParent()) {
        parent_adapter_ = std::make_unique<NodeAdapter>(wrapped_node_->GetParent());
    }
}
 
bool NodeAdapter::IsSubTreeReference() const {
    // Check if this node has a SubTree reference attribute
    String subtree_ref = wrapped_node_->GetAttribute("__subtree_ref__", "");
    return !subtree_ref.empty();
}
 
bool NodeAdapter::IsUnimplementedReference() const {
    // Check if this node is marked as an unimplemented reference
    String unimplemented = wrapped_node_->GetAttribute("__unimplemented__", "");
    return unimplemented == "true";
}
 
String NodeAdapter::GetSubTreeReference() const { return wrapped_node_->GetAttribute("__subtree_ref__", ""); }
 
} // namespace EmberCore