LibXMLBehaviorTreeParser.h

Go to the documentation of this file.

#pragma once

 
#include "Parsers/BehaviorTreeProject.h"
#include "Parsers/IParseProgressCallback.h"
#include "Parsers/ParserConfig.h"
#include <condition_variable>
#include <libxml/parser.h>
#include <libxml/threads.h>
#include <libxml/tree.h>
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <set>
#include <thread>
#include <vector>
 
// Forward declarations
namespace EmberCore {
class BehaviorTree;
class Node;
class Blackboard;
class BlackboardEntry;
class BehaviorTreeProject;
} // namespace EmberCore
 
namespace EmberCore {

class LibXMLBehaviorTreeParser {
  public:
    struct ParseError {
        enum Type {
            FILE_NOT_FOUND,
            XML_SYNTAX_ERROR,
            UNKNOWN_NODE_TYPE,
            MISSING_ATTRIBUTE,
            INVALID_VALUE,
            MISSING_ROOT_ELEMENT,
            MISSING_BEHAVIOR_TREE,
            INVALID_TREE_STRUCTURE,
            THREAD_ERROR,
            MEMORY_ERROR
        };
 
        Type type;
        EmberCore::String message;
        EmberCore::String file_path;
        int line_number;
        int column_number; // libxml2 provides column info
        EmberCore::String node_path;
        EmberCore::String context; // Additional context from libxml2
 
        ParseError(Type t, const EmberCore::String &msg, const EmberCore::String &path = "", int line = -1,
                   int col = -1)
            : type(t), message(msg), file_path(path), line_number(line), column_number(col) {}
    };

    struct ParseResult {
        std::shared_ptr<BehaviorTree> tree;
        EmberCore::String file_path;
        std::vector<ParseError> errors;
        bool success;
 
        ParseResult() : success(false) {}
    };

    struct FileParseInfo {
        String filepath;
        bool parsed_successfully = false;
        bool has_behavior_trees = false;
        bool has_blackboards = false;
        int tree_count = 0;
        int blackboard_count = 0;
        std::vector<String> tree_ids;
        std::vector<String> blackboard_ids;
        std::vector<String> subtree_refs;
        std::vector<String> blackboard_includes;
        std::vector<String> errors;
        std::vector<String> warnings;
    };

    struct ProjectParseResult {
        bool success = false;
        std::map<EmberCore::String, std::shared_ptr<BehaviorTree>> parsed_trees;
        std::map<EmberCore::String, std::shared_ptr<Blackboard>> parsed_blackboards;
        std::map<EmberCore::String, TreeImplementationStatus> tree_statuses;
        std::vector<FileParseInfo> file_infos; // Per-file detailed info
        std::vector<ParseError> errors;
        std::vector<EmberCore::String> warnings;
        std::vector<EmberCore::String> unimplemented_references;
        std::vector<EmberCore::String> unresolved_blackboard_includes;
        std::vector<EmberCore::String> duplicate_tree_ids;
        std::vector<EmberCore::String> duplicate_blackboard_ids;
        std::vector<EmberCore::String> circular_references;
        std::map<EmberCore::String, std::vector<EmberCore::String>> blackboard_includes_map;
        EmberCore::String main_tree_name;
 
        bool HasUnimplementedReferences() const { return !unimplemented_references.empty(); }
        int GetImplementedTreeCount() const;
        int GetTotalTreeCount() const;
    };
 
  public:
    LibXMLBehaviorTreeParser();
    explicit LibXMLBehaviorTreeParser(const ParserConfig &config);
    ~LibXMLBehaviorTreeParser();
 
    // Main parsing methods (same interface as XMLBehaviorTreeParser)
    std::shared_ptr<BehaviorTree> ParseFromFile(const EmberCore::String &filepath);
    std::shared_ptr<BehaviorTree> ParseFromString(const EmberCore::String &xml_content);
 
    // Batch parsing method (sequential processing)
    std::vector<ParseResult> ParseMultipleFiles(const std::vector<EmberCore::String> &filepaths);
 
    // Project parsing method - parses all files and tracks cross-file references
    ProjectParseResult ParseProject(BehaviorTreeProject *project);
 
    // Parse multiple files with shared tree registry (for cross-file references)
    ProjectParseResult ParseFilesWithSharedRegistry(const std::vector<EmberCore::String> &filepaths);
 
    // Progress callback (thread-safe)
    void SetProgressCallback(IParseProgressCallback *callback) { progress_callback_ = callback; }
 
    // Get tree implementation status (populated after project parsing)
    const std::map<EmberCore::String, TreeImplementationStatus> &GetTreeImplementationStatuses() const {
        return tree_implementation_statuses_;
    }
 
    // Check if a specific tree is implemented
    bool IsTreeImplemented(const EmberCore::String &tree_id) const;
 
    // Get list of unimplemented tree references
    std::vector<EmberCore::String> GetUnimplementedReferences() const;
 
    // Error handling (thread-safe)
    bool HasErrors() const;
    const std::vector<ParseError> &GetErrors() const;
    void ClearErrors();
 
    // Get parsed tree information
    EmberCore::String GetMainTreeName() const { return main_tree_name_; }
    const std::map<EmberCore::String, std::shared_ptr<BehaviorTree>> &GetParsedTrees() const { return parsed_trees_; }
 
    // Thread safety and performance
    void SetMaxThreads(size_t max_threads) { max_threads_ = max_threads; }
    size_t GetMaxThreads() const { return max_threads_; }
    bool IsThreadSafe() const { return thread_safe_; }
 
    // Configuration management
    const ParserConfig &GetConfig() const { return config_; }
    void SetConfig(const ParserConfig &config) { config_ = config; }
 
  private:
    // Core parsing methods
    bool ParseXMLDocument(xmlDocPtr doc, const EmberCore::String &source_path = "");
    std::shared_ptr<BehaviorTree> ParseBehaviorTree(xmlNodePtr tree_node);
    std::unique_ptr<Node> ParseNode(xmlNodePtr xml_node);
 
    // Node type specific parsing
    std::unique_ptr<Node> ParseControlNode(xmlNodePtr xml_node);
    std::unique_ptr<Node> ParseActionNode(xmlNodePtr xml_node);
    std::unique_ptr<Node> ParseConditionNode(xmlNodePtr xml_node);
    std::unique_ptr<Node> ParseDecoratorNode(xmlNodePtr xml_node);
    std::unique_ptr<Node> ParseSubTreeNode(xmlNodePtr xml_node);
 
    // Blackboard parsing
    std::unique_ptr<Blackboard> ParseBlackboard(xmlNodePtr blackboard_node);
    std::unique_ptr<BlackboardEntry> ParseBlackboardEntry(xmlNodePtr entry_node);
 
    // Helper methods
    void SetNodeAttributes(Node *node, xmlNodePtr xml_node);
    void ParseChildNodes(Node *parent, xmlNodePtr xml_parent);
 
    // Comment and formatting capture
    void CaptureComments(xmlNodePtr parent, BehaviorTree *tree, Node *node = nullptr);
 
    // SubTree expansion (two-pass system)
    void ExpandAllSubTreePlaceholders();
    bool ExpandSubTreePlaceholder(Node *node);
 
    // Project-aware SubTree expansion (tracks unimplemented references)
    void ExpandAllSubTreePlaceholdersForProject();
    bool ExpandSubTreePlaceholderForProject(Node *node);
 
    // Track SubTree references for implementation status
    void CollectSubTreeReferences(Node *node, std::set<EmberCore::String> &references);
 
    // Error handling (thread-safe)
    void AddError(ParseError::Type type, const EmberCore::String &message, xmlNodePtr node = nullptr,
                  const EmberCore::String &context = "");
    EmberCore::String GetNodePath(xmlNodePtr node);
 
    // Validation
    bool ValidateRequiredAttribute(xmlNodePtr node, const EmberCore::String &attr_name);
 
    // Thread-safe progress reporting
    bool ReportProgress(const EmberCore::String &message, int current = 0, int total = 0);
 
    // libxml2 specific helpers
    EmberCore::String GetNodeName(xmlNodePtr node);
    EmberCore::String GetNodeAttribute(xmlNodePtr node, const EmberCore::String &attr_name);
    void InitializeLibXML2();
 
  private:
    // Configuration
    ParserConfig config_;
 
    // Thread-safe data members
    mutable std::mutex errors_mutex_;
    std::vector<ParseError> errors_;
    EmberCore::String main_tree_name_;
    std::map<EmberCore::String, std::shared_ptr<BehaviorTree>> parsed_trees_;
    std::map<EmberCore::String, std::unique_ptr<Blackboard>> parsed_blackboards_;
    std::set<EmberCore::String> expanded_subtree_cache_;
    std::set<EmberCore::String> expansion_stack_; // Track currently expanding subtrees for circular reference detection
    std::set<EmberCore::String> circular_references_; // Track detected circular references
    EmberCore::String current_file_path_;
    IParseProgressCallback *progress_callback_;
 
    // Tree implementation tracking for project parsing
    std::map<EmberCore::String, TreeImplementationStatus> tree_implementation_statuses_;
    std::set<EmberCore::String> unimplemented_references_;
    bool project_parsing_mode_; // When true, don't error on missing subtrees
 
    // Threading support
    size_t max_threads_;
    bool thread_safe_;
    bool libxml2_initialized_;
 
    // Static thread-safe initialization
    static std::once_flag libxml2_init_flag_;
    static bool global_libxml2_initialized_;
 
    // Static mutex for serializing parser destruction (prevents libxml2 race conditions)
    static std::mutex destruction_mutex_;
};
 
} // namespace EmberCore