ParserConfig.cpp

Go to the documentation of this file.

#include "Parsers/ParserConfig.h"
#include "Utils/Logger.h"
#include <algorithm>
 
namespace EmberCore {
 
ParserConfig::ParserConfig() {
    // Initialize with default values (already set in struct definitions)
 
    // Initialize default blackboard type mappings
    blackboard_config_.type_mappings["bool"] = "BOOL";
    blackboard_config_.type_mappings["int"] = "INT";
    blackboard_config_.type_mappings["float"] = "FLOAT";
    blackboard_config_.type_mappings["double"] = "DOUBLE";
    blackboard_config_.type_mappings["string"] = "STRING";
    blackboard_config_.type_mappings["vector"] = "VECTOR";
    blackboard_config_.type_mappings["set"] = "SET";
    blackboard_config_.type_mappings["map"] = "MAP";
    blackboard_config_.type_mappings["auto"] = "AUTO";
}
 
nlohmann::json ParserConfig::ToJson() const {
    nlohmann::json json;
 
    // Document config
    json["document"] = {{"root_element", document_config_.root_element},
                        {"main_tree_attribute", document_config_.main_tree_attribute},
                        {"case_sensitive", document_config_.case_sensitive},
                        {"allow_unknown_elements", document_config_.allow_unknown_elements},
                        {"whitespace_handling", WhitespaceHandlingToJson(document_config_.whitespace_handling)},
                        {"naming_convention", NamingConventionToJson(document_config_.naming_convention)}};
 
    // Tree config
    json["tree"] = {{"behavior_tree_element", tree_config_.behavior_tree_element},
                    {"tree_id_attribute", tree_config_.tree_id_attribute},
                    {"allow_multiple_trees", tree_config_.allow_multiple_trees},
                    {"subtree_element", tree_config_.subtree_element},
                    {"subtree_reference_attribute", tree_config_.subtree_reference_attribute},
                    {"validate_tree_structure", tree_config_.validate_tree_structure},
                    {"require_root_node", tree_config_.require_root_node}};
 
    // Node config
    json["node"] = {{"control_element", node_config_.control_element},
                    {"action_element", node_config_.action_element},
                    {"condition_element", node_config_.condition_element},
                    {"decorator_element", node_config_.decorator_element},
                    {"generic_node_element", node_config_.generic_node_element},
                    {"node_id_attribute", node_config_.node_id_attribute},
                    {"node_name_attribute", node_config_.node_name_attribute},
                    {"node_type_attribute", node_config_.node_type_attribute},
                    {"allow_custom_attributes", node_config_.allow_custom_attributes}};
 
    // Classification config
    json["classification"] = {{"strategy", ClassificationStrategyToJson(classification_config_.strategy)},
                              {"control_types", classification_config_.control_types},
                              {"decorator_types", classification_config_.decorator_types},
                              {"action_types", classification_config_.action_types},
                              {"condition_types", classification_config_.condition_types},
                              {"unknown_behavior", UnknownTypeBehaviorToJson(classification_config_.unknown_behavior)},
                              {"type_attribute_name", classification_config_.type_attribute_name}};
 
    // Blackboard config
    json["blackboard"] = {{"blackboard_element", blackboard_config_.blackboard_element},
                          {"blackboard_id_attribute", blackboard_config_.blackboard_id_attribute},
                          {"parent_attribute", blackboard_config_.parent_attribute},
                          {"entry_element", blackboard_config_.entry_element},
                          {"entry_key_attribute", blackboard_config_.entry_key_attribute},
                          {"entry_type_attribute", blackboard_config_.entry_type_attribute},
                          {"entry_value_attribute", blackboard_config_.entry_value_attribute},
                          {"type_mappings", blackboard_config_.type_mappings},
                          {"allow_undefined_keys", blackboard_config_.allow_undefined_keys}};
 
    // Advanced config
    json["advanced"] = {{"enable_progress_reporting", advanced_config_.enable_progress_reporting},
                        {"detailed_error_messages", advanced_config_.detailed_error_messages},
                        {"track_line_column", advanced_config_.track_line_column},
                        {"subtree_expansion", SubTreeExpansionToJson(advanced_config_.subtree_expansion)},
                        {"max_recursion_depth", advanced_config_.max_recursion_depth},
                        {"xml_namespace_uri", advanced_config_.xml_namespace_uri},
                        {"preserve_comments", advanced_config_.preserve_comments},
                        {"preserve_attribute_order", advanced_config_.preserve_attribute_order},
                        {"custom_validation_rules", advanced_config_.custom_validation_rules}};
 
    return json;
}
 
void ParserConfig::FromJson(const nlohmann::json &json) {
    try {
        // Document config
        if (json.contains("document")) {
            const auto &doc = json["document"];
            if (doc.contains("root_element"))
                document_config_.root_element = doc["root_element"];
            if (doc.contains("main_tree_attribute"))
                document_config_.main_tree_attribute = doc["main_tree_attribute"];
            if (doc.contains("case_sensitive"))
                document_config_.case_sensitive = doc["case_sensitive"];
            if (doc.contains("allow_unknown_elements"))
                document_config_.allow_unknown_elements = doc["allow_unknown_elements"];
            if (doc.contains("whitespace_handling")) {
                document_config_.whitespace_handling = WhitespaceHandlingFromJson(doc["whitespace_handling"]);
            }
            if (doc.contains("naming_convention")) {
                document_config_.naming_convention = NamingConventionFromJson(doc["naming_convention"]);
            }
        }
 
        // Tree config
        if (json.contains("tree")) {
            const auto &tree = json["tree"];
            if (tree.contains("behavior_tree_element"))
                tree_config_.behavior_tree_element = tree["behavior_tree_element"];
            if (tree.contains("tree_id_attribute"))
                tree_config_.tree_id_attribute = tree["tree_id_attribute"];
            if (tree.contains("allow_multiple_trees"))
                tree_config_.allow_multiple_trees = tree["allow_multiple_trees"];
            if (tree.contains("subtree_element"))
                tree_config_.subtree_element = tree["subtree_element"];
            if (tree.contains("subtree_reference_attribute"))
                tree_config_.subtree_reference_attribute = tree["subtree_reference_attribute"];
            if (tree.contains("validate_tree_structure"))
                tree_config_.validate_tree_structure = tree["validate_tree_structure"];
            if (tree.contains("require_root_node"))
                tree_config_.require_root_node = tree["require_root_node"];
        }
 
        // Node config
        if (json.contains("node")) {
            const auto &node = json["node"];
            if (node.contains("control_element"))
                node_config_.control_element = node["control_element"];
            if (node.contains("action_element"))
                node_config_.action_element = node["action_element"];
            if (node.contains("condition_element"))
                node_config_.condition_element = node["condition_element"];
            if (node.contains("decorator_element"))
                node_config_.decorator_element = node["decorator_element"];
            if (node.contains("generic_node_element"))
                node_config_.generic_node_element = node["generic_node_element"];
            if (node.contains("node_id_attribute"))
                node_config_.node_id_attribute = node["node_id_attribute"];
            if (node.contains("node_name_attribute"))
                node_config_.node_name_attribute = node["node_name_attribute"];
            if (node.contains("node_type_attribute"))
                node_config_.node_type_attribute = node["node_type_attribute"];
            if (node.contains("allow_custom_attributes"))
                node_config_.allow_custom_attributes = node["allow_custom_attributes"];
        }
 
        // Classification config
        if (json.contains("classification")) {
            const auto &classification = json["classification"];
            if (classification.contains("strategy")) {
                classification_config_.strategy = ClassificationStrategyFromJson(classification["strategy"]);
            }
            if (classification.contains("control_types")) {
                classification_config_.control_types = classification["control_types"].get<std::vector<String>>();
            }
            if (classification.contains("decorator_types")) {
                classification_config_.decorator_types = classification["decorator_types"].get<std::vector<String>>();
            }
            if (classification.contains("action_types")) {
                classification_config_.action_types = classification["action_types"].get<std::vector<String>>();
            }
            if (classification.contains("condition_types")) {
                classification_config_.condition_types = classification["condition_types"].get<std::vector<String>>();
            }
            if (classification.contains("unknown_behavior")) {
                classification_config_.unknown_behavior =
                    UnknownTypeBehaviorFromJson(classification["unknown_behavior"]);
            }
            if (classification.contains("type_attribute_name")) {
                classification_config_.type_attribute_name = classification["type_attribute_name"];
            }
        }
 
        // Blackboard config
        if (json.contains("blackboard")) {
            const auto &blackboard = json["blackboard"];
            if (blackboard.contains("blackboard_element"))
                blackboard_config_.blackboard_element = blackboard["blackboard_element"];
            if (blackboard.contains("blackboard_id_attribute"))
                blackboard_config_.blackboard_id_attribute = blackboard["blackboard_id_attribute"];
            if (blackboard.contains("parent_attribute"))
                blackboard_config_.parent_attribute = blackboard["parent_attribute"];
            if (blackboard.contains("entry_element"))
                blackboard_config_.entry_element = blackboard["entry_element"];
            if (blackboard.contains("entry_key_attribute"))
                blackboard_config_.entry_key_attribute = blackboard["entry_key_attribute"];
            if (blackboard.contains("entry_type_attribute"))
                blackboard_config_.entry_type_attribute = blackboard["entry_type_attribute"];
            if (blackboard.contains("entry_value_attribute"))
                blackboard_config_.entry_value_attribute = blackboard["entry_value_attribute"];
            if (blackboard.contains("type_mappings")) {
                blackboard_config_.type_mappings = blackboard["type_mappings"].get<std::map<String, String>>();
            }
            if (blackboard.contains("allow_undefined_keys"))
                blackboard_config_.allow_undefined_keys = blackboard["allow_undefined_keys"];
        }
 
        // Advanced config
        if (json.contains("advanced")) {
            const auto &advanced = json["advanced"];
            if (advanced.contains("enable_progress_reporting"))
                advanced_config_.enable_progress_reporting = advanced["enable_progress_reporting"];
            if (advanced.contains("detailed_error_messages"))
                advanced_config_.detailed_error_messages = advanced["detailed_error_messages"];
            if (advanced.contains("track_line_column"))
                advanced_config_.track_line_column = advanced["track_line_column"];
            if (advanced.contains("subtree_expansion")) {
                advanced_config_.subtree_expansion = SubTreeExpansionFromJson(advanced["subtree_expansion"]);
            }
            if (advanced.contains("max_recursion_depth"))
                advanced_config_.max_recursion_depth = advanced["max_recursion_depth"];
            if (advanced.contains("xml_namespace_uri"))
                advanced_config_.xml_namespace_uri = advanced["xml_namespace_uri"];
            if (advanced.contains("preserve_comments"))
                advanced_config_.preserve_comments = advanced["preserve_comments"];
            if (advanced.contains("preserve_attribute_order"))
                advanced_config_.preserve_attribute_order = advanced["preserve_attribute_order"];
            if (advanced.contains("custom_validation_rules"))
                advanced_config_.custom_validation_rules = advanced["custom_validation_rules"];
        }
    } catch (const std::exception &e) {
        LOG_ERROR("ParserConfig", "Error parsing JSON configuration: " + std::string(e.what()));
        throw;
    }
}
 
bool ParserConfig::Validate(std::vector<String> &errors) const {
    errors.clear();
 
    // Validate document config
    if (document_config_.root_element.empty()) {
        errors.push_back("Document root element cannot be empty");
    }
 
    // Validate tree config
    if (tree_config_.behavior_tree_element.empty()) {
        errors.push_back("Behavior tree element cannot be empty");
    }
    if (tree_config_.tree_id_attribute.empty()) {
        errors.push_back("Tree ID attribute cannot be empty");
    }
 
    // Validate node config
    if (node_config_.control_element.empty()) {
        errors.push_back("Control element cannot be empty");
    }
    if (node_config_.action_element.empty()) {
        errors.push_back("Action element cannot be empty");
    }
    if (node_config_.condition_element.empty()) {
        errors.push_back("Condition element cannot be empty");
    }
    if (node_config_.decorator_element.empty()) {
        errors.push_back("Decorator element cannot be empty");
    }
    if (node_config_.node_id_attribute.empty()) {
        errors.push_back("Node ID attribute cannot be empty");
    }
 
    // Validate classification config
    if (classification_config_.control_types.empty()) {
        errors.push_back("Control types list cannot be empty");
    }
    if (classification_config_.decorator_types.empty()) {
        errors.push_back("Decorator types list cannot be empty");
    }
 
    // Validate blackboard config
    if (blackboard_config_.blackboard_element.empty()) {
        errors.push_back("Blackboard element cannot be empty");
    }
    if (blackboard_config_.entry_element.empty()) {
        errors.push_back("Blackboard entry element cannot be empty");
    }
 
    // Validate advanced config
    if (advanced_config_.max_recursion_depth <= 0) {
        errors.push_back("Maximum recursion depth must be positive");
    }
 
    return errors.empty();
}
 
bool ParserConfig::IsControlType(const String &type) const {
    return std::find(classification_config_.control_types.begin(), classification_config_.control_types.end(), type) !=
           classification_config_.control_types.end();
}
 
bool ParserConfig::IsDecoratorType(const String &type) const {
    return std::find(classification_config_.decorator_types.begin(), classification_config_.decorator_types.end(),
                     type) != classification_config_.decorator_types.end();
}
 
bool ParserConfig::IsActionType(const String &type) const {
    if (classification_config_.action_types.empty()) {
        // If no specific action types defined, any non-control/decorator/condition is an action
        return !IsControlType(type) && !IsDecoratorType(type) && !IsConditionType(type);
    }
    return std::find(classification_config_.action_types.begin(), classification_config_.action_types.end(), type) !=
           classification_config_.action_types.end();
}
 
bool ParserConfig::IsConditionType(const String &type) const {
    if (classification_config_.condition_types.empty()) {
        return false; // No conditions defined
    }
    return std::find(classification_config_.condition_types.begin(), classification_config_.condition_types.end(),
                     type) != classification_config_.condition_types.end();
}
 
ParserConfig ParserConfig::CreateDefault() {
    ParserConfig config;
    // Default values are already set in the constructor and struct defaults
    return config;
}
 
ParserConfig ParserConfig::CreateGeneric() {
    ParserConfig config;
 
    // Make it more permissive for generic use
    config.document_config_.allow_unknown_elements = true;
    config.classification_config_.unknown_behavior = UnknownTypeBehavior::GENERIC_NODE;
    config.blackboard_config_.allow_undefined_keys = true;
 
    return config;
}
 
// Helper methods for enum conversion
 
nlohmann::json ParserConfig::ClassificationStrategyToJson(ClassificationStrategy strategy) {
    switch (strategy) {
    case ClassificationStrategy::BY_ELEMENT_NAME:
        return "by_element_name";
    case ClassificationStrategy::BY_ATTRIBUTE:
        return "by_attribute";
    case ClassificationStrategy::HYBRID:
        return "hybrid";
    default:
        return "by_element_name";
    }
}
 
ParserConfig::ClassificationStrategy ParserConfig::ClassificationStrategyFromJson(const nlohmann::json &json) {
    String str = json.get<String>();
    if (str == "by_element_name")
        return ClassificationStrategy::BY_ELEMENT_NAME;
    if (str == "by_attribute")
        return ClassificationStrategy::BY_ATTRIBUTE;
    if (str == "hybrid")
        return ClassificationStrategy::HYBRID;
    return ClassificationStrategy::BY_ELEMENT_NAME;
}
 
nlohmann::json ParserConfig::UnknownTypeBehaviorToJson(UnknownTypeBehavior behavior) {
    switch (behavior) {
    case UnknownTypeBehavior::ERROR:
        return "error";
    case UnknownTypeBehavior::WARNING:
        return "warning";
    case UnknownTypeBehavior::GENERIC_NODE:
        return "generic_node";
    default:
        return "error";
    }
}
 
ParserConfig::UnknownTypeBehavior ParserConfig::UnknownTypeBehaviorFromJson(const nlohmann::json &json) {
    String str = json.get<String>();
    if (str == "error")
        return UnknownTypeBehavior::ERROR;
    if (str == "warning")
        return UnknownTypeBehavior::WARNING;
    if (str == "generic_node")
        return UnknownTypeBehavior::GENERIC_NODE;
    return UnknownTypeBehavior::ERROR;
}
 
nlohmann::json ParserConfig::WhitespaceHandlingToJson(WhitespaceHandling handling) {
    switch (handling) {
    case WhitespaceHandling::PRESERVE:
        return "preserve";
    case WhitespaceHandling::TRIM:
        return "trim";
    case WhitespaceHandling::NORMALIZE:
        return "normalize";
    default:
        return "trim";
    }
}
 
ParserConfig::WhitespaceHandling ParserConfig::WhitespaceHandlingFromJson(const nlohmann::json &json) {
    String str = json.get<String>();
    if (str == "preserve")
        return WhitespaceHandling::PRESERVE;
    if (str == "trim")
        return WhitespaceHandling::TRIM;
    if (str == "normalize")
        return WhitespaceHandling::NORMALIZE;
    return WhitespaceHandling::TRIM;
}
 
nlohmann::json ParserConfig::SubTreeExpansionToJson(SubTreeExpansion expansion) {
    switch (expansion) {
    case SubTreeExpansion::IMMEDIATE:
        return "immediate";
    case SubTreeExpansion::LAZY:
        return "lazy";
    case SubTreeExpansion::MANUAL:
        return "manual";
    default:
        return "immediate";
    }
}
 
ParserConfig::SubTreeExpansion ParserConfig::SubTreeExpansionFromJson(const nlohmann::json &json) {
    String str = json.get<String>();
    if (str == "immediate")
        return SubTreeExpansion::IMMEDIATE;
    if (str == "lazy")
        return SubTreeExpansion::LAZY;
    if (str == "manual")
        return SubTreeExpansion::MANUAL;
    return SubTreeExpansion::IMMEDIATE;
}
 
nlohmann::json ParserConfig::NamingConventionToJson(NamingConvention convention) {
    switch (convention) {
    case NamingConvention::STRICT:
        return "strict";
    case NamingConvention::BALANCED:
        return "balanced";
    case NamingConvention::LOOSE:
        return "loose";
    default:
        return "balanced";
    }
}
 
ParserConfig::NamingConvention ParserConfig::NamingConventionFromJson(const nlohmann::json &json) {
    String str = json.get<String>();
    if (str == "strict")
        return NamingConvention::STRICT;
    if (str == "balanced")
        return NamingConvention::BALANCED;
    if (str == "loose")
        return NamingConvention::LOOSE;
    return NamingConvention::BALANCED;
}
 
} // namespace EmberCore