ParserConfig.h

Go to the documentation of this file.

#pragma once
 
#include "Types/Types.h"
#include <map>
#include <nlohmann/json.hpp>
#include <set>
#include <vector>
 
namespace EmberCore {

class ParserConfig {
  public:
    enum class ClassificationStrategy {
        BY_ELEMENT_NAME, // Node type determined by element name (e.g., <Control>, <Action>)
        BY_ATTRIBUTE,    // Node type determined by attribute value
        HYBRID           // Combination of both strategies
    };

    enum class UnknownTypeBehavior {
        ERROR,       // Throw error and fail parsing
        WARNING,     // Log warning and continue
        GENERIC_NODE // Create generic node with inferred type
    };

    enum class WhitespaceHandling {
        PRESERVE, // Keep all whitespace as-is
        TRIM,     // Trim leading/trailing whitespace
        NORMALIZE // Normalize multiple spaces to single space
    };

    enum class NamingConvention {
        STRICT,   // Strict naming validation
        BALANCED, // Balanced naming rules
        LOOSE     // Loose/permissive naming
    };

    enum class SubTreeExpansion {
        IMMEDIATE, // Expand all SubTrees immediately after parsing
        LAZY,      // Expand SubTrees on first access
        MANUAL     // User must manually trigger expansion
    };
 
    // Document Structure Configuration
    struct DocumentConfig {
        String root_element = "root";
        String main_tree_attribute = "main_tree_to_execute";
        bool case_sensitive = true;
        bool allow_unknown_elements = false;
        WhitespaceHandling whitespace_handling = WhitespaceHandling::TRIM;
        NamingConvention naming_convention = NamingConvention::BALANCED;
    };
 
    // Tree Element Configuration
    struct TreeConfig {
        String behavior_tree_element = "BehaviorTree";
        String tree_id_attribute = "ID";
        bool allow_multiple_trees = true;
        String subtree_element = "SubTree";
        String subtree_reference_attribute = "ID";
        bool validate_tree_structure = true;
        bool require_root_node = true;
    };
 
    // Node Element Configuration
    struct NodeConfig {
        String control_element = "Control";
        String action_element = "Action";
        String condition_element = "Condition";
        String decorator_element = "Decorator";
        String generic_node_element = "Node";
        String node_id_attribute = "ID";
        String node_name_attribute = "name";
        String node_type_attribute = "type";
        bool allow_custom_attributes = true;
    };
 
    // Node Type Classification Configuration
    struct ClassificationConfig {
        ClassificationStrategy strategy = ClassificationStrategy::BY_ELEMENT_NAME;
        std::vector<String> control_types = {"Sequence",         "Selector",   "Parallel",
                                             "ReactiveSequence", "IfThenElse", "RepeatAtOnce"};
        std::vector<String> decorator_types = {"ForceSuccess", "ForceFailure",       "Inverter",
                                               "Delay",        "RepeatUntilSuccess", "Repeat"};
        std::vector<String> action_types;    // Known action types (can be empty for generic)
        std::vector<String> condition_types; // Known condition types (can be empty for generic)
        UnknownTypeBehavior unknown_behavior = UnknownTypeBehavior::ERROR;
        String type_attribute_name = "type"; // Used for BY_ATTRIBUTE strategy
    };
 
    // Blackboard Configuration
    struct BlackboardConfig {
        String blackboard_element = "Blackboard";
        String blackboard_id_attribute = "ID";
        String parent_attribute = "parent";
        String entry_element = "Entry";
        String entry_key_attribute = "key";
        String entry_type_attribute = "type";
        String entry_value_attribute = "value";
        std::map<String, String> type_mappings; // XML type -> Internal type
        bool allow_undefined_keys = false;
    };
 
    // Advanced Options
    struct AdvancedConfig {
        bool enable_progress_reporting = true;
        bool detailed_error_messages = true;
        bool track_line_column = true;
        SubTreeExpansion subtree_expansion = SubTreeExpansion::IMMEDIATE;
        int max_recursion_depth = 100;
        String xml_namespace_uri = "";
        bool preserve_comments = false;
        bool preserve_attribute_order = false;
        String custom_validation_rules = "";
    };
 
  public:
    ParserConfig();
    ~ParserConfig() = default;
 
    // Configuration accessors
    DocumentConfig &GetDocumentConfig() { return document_config_; }
    const DocumentConfig &GetDocumentConfig() const { return document_config_; }
 
    TreeConfig &GetTreeConfig() { return tree_config_; }
    const TreeConfig &GetTreeConfig() const { return tree_config_; }
 
    NodeConfig &GetNodeConfig() { return node_config_; }
    const NodeConfig &GetNodeConfig() const { return node_config_; }
 
    ClassificationConfig &GetClassificationConfig() { return classification_config_; }
    const ClassificationConfig &GetClassificationConfig() const { return classification_config_; }
 
    BlackboardConfig &GetBlackboardConfig() { return blackboard_config_; }
    const BlackboardConfig &GetBlackboardConfig() const { return blackboard_config_; }
 
    AdvancedConfig &GetAdvancedConfig() { return advanced_config_; }
    const AdvancedConfig &GetAdvancedConfig() const { return advanced_config_; }
 
    // JSON serialization/deserialization
    nlohmann::json ToJson() const;
    void FromJson(const nlohmann::json &json);
 
    // Validation
    bool Validate(std::vector<String> &errors) const;
 
    // Helper methods
    bool IsControlType(const String &type) const;
    bool IsDecoratorType(const String &type) const;
    bool IsActionType(const String &type) const;
    bool IsConditionType(const String &type) const;
 
    // Create default configurations
    static ParserConfig CreateDefault();
    static ParserConfig CreateGeneric();
 
  private:
    DocumentConfig document_config_;
    TreeConfig tree_config_;
    NodeConfig node_config_;
    ClassificationConfig classification_config_;
    BlackboardConfig blackboard_config_;
    AdvancedConfig advanced_config_;
 
    // Helper methods for JSON conversion
    static nlohmann::json ClassificationStrategyToJson(ClassificationStrategy strategy);
    static ClassificationStrategy ClassificationStrategyFromJson(const nlohmann::json &json);
    static nlohmann::json UnknownTypeBehaviorToJson(UnknownTypeBehavior behavior);
    static UnknownTypeBehavior UnknownTypeBehaviorFromJson(const nlohmann::json &json);
    static nlohmann::json WhitespaceHandlingToJson(WhitespaceHandling handling);
    static WhitespaceHandling WhitespaceHandlingFromJson(const nlohmann::json &json);
    static nlohmann::json SubTreeExpansionToJson(SubTreeExpansion expansion);
    static SubTreeExpansion SubTreeExpansionFromJson(const nlohmann::json &json);
    static nlohmann::json NamingConventionToJson(NamingConvention convention);
    static NamingConvention NamingConventionFromJson(const nlohmann::json &json);
};
 
} // namespace EmberCore