LibXMLBehaviorTreeSerializer.cpp

Go to the documentation of this file.

#include "Parsers/LibXMLBehaviorTreeSerializer.h"
#include "Core/BehaviorTree.h"
#include "Core/BlackboardEntry.h"
#include "Core/Node.h"
#include "Utils/Logger.h"
#include <libxml/xmlsave.h>
 
namespace EmberCore {
 
LibXMLBehaviorTreeSerializer::LibXMLBehaviorTreeSerializer(const ParserConfig &config) : config_(config) {}
 
LibXMLBehaviorTreeSerializer::~LibXMLBehaviorTreeSerializer() {
    // Cleanup handled by libxml2
}
 
bool LibXMLBehaviorTreeSerializer::SerializeToFile(std::shared_ptr<BehaviorTree> tree,
                                                   const EmberCore::String &filepath) {
    ClearErrors();
 
    if (!tree) {
        AddError(SerializeError::INVALID_TREE, "Behavior tree is null");
        return false;
    }
 
    if (!tree->HasRootNode()) {
        AddError(SerializeError::MISSING_ROOT_NODE, "Behavior tree has no root node");
        return false;
    }
 
    LOG_INFO("LibXMLSerializer", "Serializing tree to file: " + filepath);
 
    // Create XML document
    xmlDocPtr doc = CreateXMLDocument(tree);
    if (!doc) {
        AddError(SerializeError::XML_CREATE_ERROR, "Failed to create XML document");
        return false;
    }
 
    // Save to file with pretty printing
    // Note: indent_size from metadata could be used with xmlSaveFormatFile if needed
    int result = xmlSaveFormatFileEnc(filepath.c_str(), doc, "UTF-8", 1);
 
    // Cleanup
    xmlFreeDoc(doc);
 
    if (result == -1) {
        AddError(SerializeError::FILE_WRITE_ERROR, "Failed to write XML file: " + filepath);
        return false;
    }
 
    LOG_INFO("LibXMLSerializer", "Successfully serialized tree to: " + filepath);
    return true;
}
 
EmberCore::String LibXMLBehaviorTreeSerializer::SerializeToString(std::shared_ptr<BehaviorTree> tree) {
    ClearErrors();
 
    if (!tree) {
        AddError(SerializeError::INVALID_TREE, "Behavior tree is null");
        return "";
    }
 
    if (!tree->HasRootNode()) {
        AddError(SerializeError::MISSING_ROOT_NODE, "Behavior tree has no root node");
        return "";
    }
 
    // Create XML document
    xmlDocPtr doc = CreateXMLDocument(tree);
    if (!doc) {
        AddError(SerializeError::XML_CREATE_ERROR, "Failed to create XML document");
        return "";
    }
 
    // Convert to string
    xmlChar *xml_buffer = nullptr;
    int buffer_size = 0;
    xmlDocDumpFormatMemoryEnc(doc, &xml_buffer, &buffer_size, "UTF-8", 1);
 
    EmberCore::String result;
    if (xml_buffer) {
        result = reinterpret_cast<const char *>(xml_buffer);
        xmlFree(xml_buffer);
    }
 
    // Cleanup
    xmlFreeDoc(doc);
 
    return result;
}
 
xmlDocPtr LibXMLBehaviorTreeSerializer::CreateXMLDocument(std::shared_ptr<BehaviorTree> tree) {
    const auto &doc_config = config_.GetDocumentConfig();
 
    // Create new XML document
    xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
    if (!doc) {
        return nullptr;
    }
 
    // Create root element
    xmlNodePtr root = xmlNewNode(nullptr, BAD_CAST doc_config.root_element.c_str());
    xmlDocSetRootElement(doc, root);
 
    // Add main_tree_to_execute attribute to root
    EmberCore::String tree_name = tree->GetName();
    if (!tree_name.empty()) {
        xmlNewProp(root, BAD_CAST doc_config.main_tree_attribute.c_str(), BAD_CAST tree_name.c_str());
    }
 
    // Add header comments
    const auto &xml_metadata = tree->GetXMLMetadata();
    for (const auto &comment : xml_metadata.header_comments) {
        xmlNodePtr comment_node = xmlNewComment(BAD_CAST comment.c_str());
        xmlAddPrevSibling(root, comment_node);
    }
 
    // Serialize the behavior tree
    SerializeBehaviorTree(tree, root);
 
    // Add footer comments
    for (const auto &comment : xml_metadata.footer_comments) {
        xmlNodePtr comment_node = xmlNewComment(BAD_CAST comment.c_str());
        xmlAddSibling(root, comment_node);
    }
 
    return doc;
}
 
xmlNodePtr LibXMLBehaviorTreeSerializer::SerializeBehaviorTree(std::shared_ptr<BehaviorTree> tree, xmlNodePtr parent) {
    const auto &tree_config = config_.GetTreeConfig();
 
    // Create BehaviorTree element
    xmlNodePtr tree_node = xmlNewChild(parent, nullptr, BAD_CAST tree_config.behavior_tree_element.c_str(), nullptr);
 
    // Add tree ID attribute
    EmberCore::String tree_name = tree->GetName();
    if (tree_name.empty()) {
        tree_name = "MainTree";
    }
    xmlNewProp(tree_node, BAD_CAST tree_config.tree_id_attribute.c_str(), BAD_CAST tree_name.c_str());
 
    // Serialize root node
    // Note: The parser creates a BehaviorTree wrapper node that contains the actual
    // root control node as its child. We need to skip this wrapper and serialize
    // its children directly to produce correct round-trip serialization.
    Node *root = tree->GetRootNode();
    if (root) {
        if (root->GetType() == Node::Type::BehaviorTree) {
            // This is the BehaviorTree wrapper node - serialize its children directly
            for (size_t i = 0; i < root->GetChildCount(); ++i) {
                Node *child = root->GetChild(i);
                if (child) {
                    SerializeNode(child, tree_node);
                }
            }
        } else {
            // No wrapper, serialize the root node directly
            SerializeNode(root, tree_node);
        }
    }
 
    // Serialize blackboards
    const auto &blackboards = tree->GetBlackboards();
    for (const auto &bb_pair : blackboards) {
        SerializeBlackboard(bb_pair.second.get(), parent);
    }
 
    return tree_node;
}
 
xmlNodePtr LibXMLBehaviorTreeSerializer::SerializeNode(Node *node, xmlNodePtr parent) {
    if (!node) {
        return nullptr;
    }
 
    // Get element name based on node type
    EmberCore::String element_name = GetElementNameForNode(node);
 
    // Create XML node
    xmlNodePtr xml_node = xmlNewChild(parent, nullptr, BAD_CAST element_name.c_str(), nullptr);
 
    const auto &node_config = config_.GetNodeConfig();
    const auto &tree_config = config_.GetTreeConfig();
 
    // Check if this is a SubTree placeholder node
    EmberCore::String subtree_ref = node->GetAttribute("__subtree_ref__");
    if (!subtree_ref.empty()) {
        // SubTree node - use the subtree reference as the ID
        xmlNewProp(xml_node, BAD_CAST tree_config.subtree_reference_attribute.c_str(), BAD_CAST subtree_ref.c_str());
        // SubTree nodes don't have children or regular attributes - they're just references
        return xml_node;
    }
 
    // Add node ID attribute (if configured)
    if (!node_config.node_id_attribute.empty()) {
        // Get the specific behavior type from the stored ID attribute (set during parsing)
        // This should always be present for properly parsed nodes (e.g., "Sequence", "SetInt")
        EmberCore::String node_type_id = node->GetAttribute("ID");
        if (!node_type_id.empty()) {
            xmlNewProp(xml_node, BAD_CAST node_config.node_id_attribute.c_str(), BAD_CAST node_type_id.c_str());
        } else {
            // ID is missing - this shouldn't happen for parsed nodes
            // Log a warning and skip the ID attribute
            LOG_WARNING("LibXMLSerializer", "Node '" + node->GetName() + "' has no ID attribute - skipping");
        }
    }
 
    // Add node name attribute
    xmlNewProp(xml_node, BAD_CAST node_config.node_name_attribute.c_str(), BAD_CAST node->GetName().c_str());
 
    // Serialize all custom attributes
    SerializeAttributes(node, xml_node);
 
    // Serialize children recursively
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        Node *child = node->GetChild(i);
        if (child) {
            SerializeNode(child, xml_node);
        }
    }
 
    return xml_node;
}
 
void LibXMLBehaviorTreeSerializer::SerializeAttributes(Node *node, xmlNodePtr xml_node) {
    const auto &node_config = config_.GetNodeConfig();
 
    // Get all custom attributes from the node
    const auto &attributes = node->GetAllAttributes();
 
    for (const auto &attr_pair : attributes) {
        // Skip the name and ID attributes as they're already added explicitly
        if (attr_pair.first == node_config.node_name_attribute || attr_pair.first == node_config.node_id_attribute) {
            continue;
        }
 
        // Skip internal parser attributes (these are implementation details, not real XML attributes)
        if (attr_pair.first == "__subtree_ref__" || attr_pair.first == "__is_placeholder__") {
            continue;
        }
 
        // Add attribute to XML node
        xmlNewProp(xml_node, BAD_CAST attr_pair.first.c_str(), BAD_CAST attr_pair.second.c_str());
    }
}
 
xmlNodePtr LibXMLBehaviorTreeSerializer::SerializeBlackboard(Blackboard *blackboard, xmlNodePtr parent) {
    if (!blackboard) {
        return nullptr;
    }
 
    const auto &blackboard_config = config_.GetBlackboardConfig();
 
    // Create Blackboard element
    xmlNodePtr bb_node = xmlNewChild(parent, nullptr, BAD_CAST blackboard_config.blackboard_element.c_str(), nullptr);
 
    // Add blackboard ID using configured attribute name
    xmlNewProp(bb_node, BAD_CAST blackboard_config.blackboard_id_attribute.c_str(),
               BAD_CAST blackboard->GetId().c_str());
 
    // Serialize entries
    const auto &entries = blackboard->GetEntries();
    for (const auto &entry_pair : entries) {
        xmlNodePtr entry_node =
            xmlNewChild(bb_node, nullptr, BAD_CAST blackboard_config.entry_element.c_str(), nullptr);
 
        xmlNewProp(entry_node, BAD_CAST blackboard_config.entry_key_attribute.c_str(),
                   BAD_CAST entry_pair.first.c_str());
        xmlNewProp(entry_node, BAD_CAST blackboard_config.entry_type_attribute.c_str(),
                   BAD_CAST entry_pair.second->GetTypeString().c_str());
 
        // Add value as attribute (only if not empty)
        const EmberCore::String &value = entry_pair.second->GetValue();
        if (!value.empty()) {
            xmlNewProp(entry_node, BAD_CAST blackboard_config.entry_value_attribute.c_str(), BAD_CAST value.c_str());
        }
    }
 
    return bb_node;
}
 
void LibXMLBehaviorTreeSerializer::AddError(SerializeError::Type type, const EmberCore::String &message) {
    errors_.emplace_back(type, message);
    LOG_ERROR("LibXMLSerializer", message);
}
 
EmberCore::String LibXMLBehaviorTreeSerializer::GetElementNameForNode(Node *node) const {
    if (!node) {
        return "";
    }
 
    const auto &node_config = config_.GetNodeConfig();
    const auto &tree_config = config_.GetTreeConfig();
 
    // Check if this is a SubTree placeholder node (has __subtree_ref__ attribute)
    if (node->GetType() == Node::Type::BehaviorTree) {
        EmberCore::String subtree_ref = node->GetAttribute("__subtree_ref__");
        if (!subtree_ref.empty()) {
            return tree_config.subtree_element; // "SubTree"
        }
        // Non-placeholder BehaviorTree nodes shouldn't reach here (they're skipped in SerializeBehaviorTree)
        LOG_WARNING("LibXMLSerializer", "Unexpected BehaviorTree node in serialization: " + node->GetName());
        return node_config.generic_node_element;
    }
 
    // Always return the generic category name based on node type
    // The specific behavior is stored in the ID attribute, not the element name
    switch (node->GetType()) {
    case Node::Type::Action:
        return node_config.action_element; // "Action"
    case Node::Type::Control:
        return node_config.control_element; // "Control"
    case Node::Type::Condition:
        return node_config.condition_element; // "Condition"
    case Node::Type::Decorator:
        return node_config.decorator_element; // "Decorator"
    default:
        return node_config.generic_node_element; // "Node"
    }
}
 
} // namespace EmberCore