BlackboardEntry.cpp

Go to the documentation of this file.

#include "Core/BlackboardEntry.h"
#include "Utils/Logger.h"
#include <algorithm>
#include <cctype>
 
namespace EmberCore {
 
BlackboardEntry::BlackboardEntry(const EmberCore::String &key, DataType type, const EmberCore::String &value)
    : key_(key), type_(type), value_(value) {}
 
EmberCore::String BlackboardEntry::GetTypeString() const { return DataTypeToString(type_); }
 
BlackboardEntry::DataType BlackboardEntry::ParseDataType(const EmberCore::String &typeStr) {
    EmberCore::String lower = typeStr;
    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
 
    // Basic types
    if (lower == "bool")
        return DataType::BOOL;
    if (lower == "int")
        return DataType::INT;
    if (lower == "int8_t")
        return DataType::INT8;
    if (lower == "uint8_t")
        return DataType::UINT8;
    if (lower == "uint32_t")
        return DataType::UINT32;
    if (lower == "size_t")
        return DataType::SIZE_T;
    if (lower == "float")
        return DataType::FLOAT;
    if (lower == "string")
        return DataType::STRING;
    if (lower == "currency")
        return DataType::CURRENCY;
    if (lower == "auto")
        return DataType::AUTO;
 
    // Vector types - basic
    if (lower == "vec(int)")
        return DataType::VEC_INT;
    if (lower == "vec(int8_t)")
        return DataType::VEC_INT8;
    if (lower == "vec(uint8_t)")
        return DataType::VEC_UINT8;
    if (lower == "vec(uint32_t)")
        return DataType::VEC_UINT32;
    if (lower == "vec(float)")
        return DataType::VEC_FLOAT;
    if (lower == "vec(string)")
        return DataType::VEC_STRING;
    if (lower == "vec(currency)")
        return DataType::VEC_CURRENCY;
 
    // Nested vector types
    if (lower == "vec(vec(uint8_t))")
        return DataType::VEC_VEC_UINT8;
    if (lower == "vec(vec(uint32_t))")
        return DataType::VEC_VEC_UINT32;
    if (lower == "vec(pair(float, float))" || lower == "vec(pair(float,float))")
        return DataType::VEC_PAIR_FLOAT;
 
    // Pair types
    if (lower == "pair(float, float)" || lower == "pair(float,float)")
        return DataType::PAIR_FLOAT;
    if (lower == "pair(int, int)" || lower == "pair(int,int)")
        return DataType::PAIR_INT;
    if (lower == "pair(string, string)" || lower == "pair(string,string)")
        return DataType::PAIR_STRING;
 
    // Map types
    if (lower == "map(string, string)" || lower == "map(string,string)")
        return DataType::MAP_STRING_STRING;
    if (lower == "map(string, int)" || lower == "map(string,int)")
        return DataType::MAP_STRING_INT;
 
    // Set types
    if (lower == "set(string)" || lower == "set")
        return DataType::SET_STRING;
    if (lower == "set(int)")
        return DataType::SET_INT;
    if (lower == "set(uint32_t)")
        return DataType::SET_UINT32;
 
    LOG_WARNING("Blackboard", "Unknown data type: " + typeStr);
    return DataType::UNKNOWN;
}
 
EmberCore::String BlackboardEntry::DataTypeToString(DataType type) {
    switch (type) {
    case DataType::BOOL:
        return "bool";
    case DataType::INT:
        return "int";
    case DataType::INT8:
        return "int8_t";
    case DataType::UINT8:
        return "uint8_t";
    case DataType::UINT32:
        return "uint32_t";
    case DataType::SIZE_T:
        return "size_t";
    case DataType::FLOAT:
        return "float";
    case DataType::STRING:
        return "string";
    case DataType::CURRENCY:
        return "Currency";
    case DataType::AUTO:
        return "auto";
    case DataType::VEC_INT:
        return "vec(int)";
    case DataType::VEC_INT8:
        return "vec(int8_t)";
    case DataType::VEC_UINT8:
        return "vec(uint8_t)";
    case DataType::VEC_UINT32:
        return "vec(uint32_t)";
    case DataType::VEC_FLOAT:
        return "vec(float)";
    case DataType::VEC_STRING:
        return "vec(string)";
    case DataType::VEC_CURRENCY:
        return "vec(Currency)";
    case DataType::VEC_VEC_UINT8:
        return "vec(vec(uint8_t))";
    case DataType::VEC_VEC_UINT32:
        return "vec(vec(uint32_t))";
    case DataType::VEC_PAIR_FLOAT:
        return "vec(pair(float, float))";
    case DataType::PAIR_FLOAT:
        return "pair(float, float)";
    case DataType::PAIR_INT:
        return "pair(int, int)";
    case DataType::PAIR_STRING:
        return "pair(string, string)";
    case DataType::MAP_STRING_STRING:
        return "map(string, string)";
    case DataType::MAP_STRING_INT:
        return "map(string, int)";
    case DataType::SET_STRING:
        return "set(string)";
    case DataType::SET_INT:
        return "set(int)";
    case DataType::SET_UINT32:
        return "set(uint32_t)";
    case DataType::UNKNOWN:
        return "unknown";
    default:
        return "unknown";
    }
}
 
bool BlackboardEntry::IsValidValue() const {
    if (type_ == DataType::AUTO) {
        return true; // AUTO type can have any value or no value
    }
 
    if (value_.empty()) {
        return type_ == DataType::AUTO; // Only AUTO can have empty values
    }
 
    // TODO: Add more sophisticated validation based on type
    // For now, just check that non-AUTO types have values
    return true;
}
 
// Blackboard implementation
 
Blackboard::Blackboard(const EmberCore::String &id) : id_(id) {}
 
void Blackboard::AddEntry(std::unique_ptr<BlackboardEntry> entry) {
    if (!entry) {
        LOG_ERROR("Blackboard", "Cannot add null entry to blackboard");
        return;
    }
 
    EmberCore::String key = entry->GetKey();
    if (key.empty()) {
        LOG_ERROR("Blackboard", "Cannot add entry with empty key to blackboard");
        return;
    }
 
    entries_[key] = std::move(entry);
    LOG_TRACE("Blackboard", "Added entry '" + key + "' to blackboard '" + id_ + "'");
}
 
void Blackboard::AddEntry(const EmberCore::String &key, BlackboardEntry::DataType type,
                          const EmberCore::String &value) {
    auto entry = std::make_unique<BlackboardEntry>(key, type, value);
    AddEntry(std::move(entry));
}
 
BlackboardEntry *Blackboard::GetEntry(const EmberCore::String &key) {
    auto it = entries_.find(key);
    return (it != entries_.end()) ? it->second.get() : nullptr;
}
 
const BlackboardEntry *Blackboard::GetEntry(const EmberCore::String &key) const {
    auto it = entries_.find(key);
    return (it != entries_.end()) ? it->second.get() : nullptr;
}
 
bool Blackboard::HasEntry(const EmberCore::String &key) const { return entries_.find(key) != entries_.end(); }
 
void Blackboard::RemoveEntry(const EmberCore::String &key) {
    auto it = entries_.find(key);
    if (it != entries_.end()) {
        entries_.erase(it);
        LOG_TRACE("Blackboard", "Removed entry '" + key + "' from blackboard '" + id_ + "'");
    }
}
 
void Blackboard::Clear() {
    entries_.clear();
    LOG_TRACE("Blackboard", "Cleared all entries from blackboard '" + id_ + "'");
}
 
std::unique_ptr<Blackboard> Blackboard::Clone() const {
    auto clone = std::make_unique<Blackboard>(id_);
    clone->SetParentId(parent_id_);
 
    // Clone all entries
    for (const auto &entry_pair : entries_) {
        const BlackboardEntry *original_entry = entry_pair.second.get();
        auto cloned_entry = std::make_unique<BlackboardEntry>(original_entry->GetKey(), original_entry->GetType(),
                                                              original_entry->GetValue());
        clone->AddEntry(std::move(cloned_entry));
    }
 
    return clone;
}
 
} // namespace EmberCore