ParserProfile.cpp

Go to the documentation of this file.

#include "Parsers/ParserProfile.h"
#include "Utils/Logger.h"
#include <fstream>
#include <iomanip>
#include <sstream>
 
namespace EmberCore {
 
ParserProfile::ParserProfile()
    : name_("Unnamed Profile"), description_(""), version_("1.0"), author_(""),
      created_timestamp_(GetCurrentTimestamp()), modified_timestamp_(GetCurrentTimestamp()), config_() {}
 
ParserProfile::ParserProfile(const String &name, const String &description)
    : name_(name), description_(description), version_("1.0"), author_(""), created_timestamp_(GetCurrentTimestamp()),
      modified_timestamp_(GetCurrentTimestamp()), config_() {}
 
void ParserProfile::UpdateModifiedTimestamp() { modified_timestamp_ = GetCurrentTimestamp(); }
 
void ParserProfile::SetConfig(const ParserConfig &config) {
    config_ = config;
    UpdateModifiedTimestamp();
}
 
bool ParserProfile::Validate(std::vector<String> &errors) const {
    errors.clear();
 
    // Validate profile metadata
    if (name_.empty()) {
        errors.push_back("Profile name cannot be empty");
    }
 
    if (version_.empty()) {
        errors.push_back("Profile version cannot be empty");
    }
 
    // Validate the underlying config
    std::vector<String> config_errors;
    if (!config_.Validate(config_errors)) {
        errors.insert(errors.end(), config_errors.begin(), config_errors.end());
    }
 
    return errors.empty();
}
 
nlohmann::json ParserProfile::ToJson() const {
    nlohmann::json json;
 
    json["profile_name"] = name_;
    json["description"] = description_;
    json["version"] = version_;
    json["author"] = author_;
    json["created_timestamp"] = created_timestamp_;
    json["modified_timestamp"] = modified_timestamp_;
    json["config"] = config_.ToJson();
 
    return json;
}
 
void ParserProfile::FromJson(const nlohmann::json &json) {
    try {
        // Validate required fields
        if (!json.contains("profile_name")) {
            throw std::runtime_error("Missing required field: profile_name");
        }
 
        if (!json.contains("config")) {
            throw std::runtime_error("Missing required field: config");
        }
 
        // Validate that config is not empty and has required sections
        const auto &config_json = json["config"];
        if (config_json.empty()) {
            throw std::runtime_error("Config object cannot be empty");
        }
 
        // Validate that config has minimum required sections
        if (!config_json.contains("document") || !config_json.contains("tree") || !config_json.contains("node")) {
            throw std::runtime_error("Config must contain minimum required sections: document, tree, and node");
        }
 
        // Load required fields
        name_ = json["profile_name"].get<String>();
        config_.FromJson(config_json);
 
        // Load optional fields
        if (json.contains("description")) {
            description_ = json["description"].get<String>();
        }
        if (json.contains("version")) {
            version_ = json["version"].get<String>();
        }
        if (json.contains("author")) {
            author_ = json["author"].get<String>();
        }
        if (json.contains("created_timestamp")) {
            created_timestamp_ = json["created_timestamp"].get<int64_t>();
        }
        if (json.contains("modified_timestamp")) {
            modified_timestamp_ = json["modified_timestamp"].get<int64_t>();
        }
    } catch (const std::exception &e) {
        LOG_ERROR("ParserProfile", "Error parsing JSON profile: " + std::string(e.what()));
        throw;
    }
}
 
bool ParserProfile::SaveToFile(const String &filepath) const {
    try {
        nlohmann::json json = ToJson();
        std::ofstream file(filepath);
 
        if (!file.is_open()) {
            LOG_ERROR("ParserProfile", "Failed to open file for writing: " + filepath);
            return false;
        }
 
        // Write with pretty formatting (4 space indent)
        file << std::setw(4) << json << std::endl;
        file.close();
 
        LOG_INFO("ParserProfile", "Saved profile '" + name_ + "' to: " + filepath);
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("ParserProfile", "Error saving profile to file: " + std::string(e.what()));
        return false;
    }
}
 
bool ParserProfile::LoadFromFile(const String &filepath) {
    try {
        std::ifstream file(filepath);
 
        if (!file.is_open()) {
            LOG_ERROR("ParserProfile", "Failed to open file for reading: " + filepath);
            return false;
        }
 
        nlohmann::json json;
        file >> json;
        file.close();
 
        FromJson(json);
 
        LOG_INFO("ParserProfile", "Loaded profile '" + name_ + "' from: " + filepath);
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("ParserProfile", "Error loading profile from file: " + std::string(e.what()));
        return false;
    }
}
 
std::shared_ptr<ParserProfile> ParserProfile::Clone(const String &new_name) const {
    // Create new profile with cloned name
    // If no new name provided, keep the same name
    String cloned_name = new_name.empty() ? name_ : new_name;
    auto cloned = std::make_shared<ParserProfile>(cloned_name, description_);
 
    // Copy additional fields
    cloned->SetVersion(version_);
    cloned->SetAuthor(author_);
    cloned->SetConfig(config_);
 
    return cloned;
}
 
std::shared_ptr<ParserProfile> ParserProfile::CreateDefaultProfile() {
    auto profile = std::make_shared<ParserProfile>("Default", "Default BehaviorTree.CPP format");
    profile->SetVersion("1.0");
    profile->SetAuthor("EmberForge");
 
    // Config is already initialized with default values
    ParserConfig config = ParserConfig::CreateDefault();
    profile->SetConfig(config);
 
    return profile;
}
 
std::shared_ptr<ParserProfile> ParserProfile::CreateGenericProfile() {
    auto profile =
        std::make_shared<ParserProfile>("Generic", "Generic permissive format for various BT implementations");
    profile->SetVersion("1.0");
    profile->SetAuthor("EmberForge");
 
    ParserConfig config = ParserConfig::CreateGeneric();
    profile->SetConfig(config);
 
    return profile;
}
 
int64_t ParserProfile::GetCurrentTimestamp() {
    auto now = std::chrono::system_clock::now();
    auto duration = now.time_since_epoch();
    return std::chrono::duration_cast<std::chrono::seconds>(duration).count();
}
 
} // namespace EmberCore