ComponentConfig.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/CoreTypes.hpp>
#include <icarus/core/Error.hpp>
 
#include <limits>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace icarus {

struct ComponentConfig {
    // =========================================================================
    // Identity (set by loader/factory)
    // =========================================================================
 
    std::string name;   
    std::string entity; 
    std::string type;   
 
    // =========================================================================
    // Raw Storage (populated by loader)
    // =========================================================================
 
    std::unordered_map<std::string, double> scalars;
    std::unordered_map<std::string, std::vector<double>> vectors; 
    std::unordered_map<std::string, std::vector<double>> arrays;
    std::unordered_map<std::string, std::string> strings;
    std::unordered_map<std::string, int64_t> integers;
    std::unordered_map<std::string, bool> booleans;

    std::vector<std::string> sources;

    std::vector<std::string> body_sources; 
    std::vector<std::string> ecef_sources; 
 
    // =========================================================================
    // Typed Accessors
    // =========================================================================

    template <typename T> T Require(const std::string &key) const;

    template <typename T> T Get(const std::string &key, const T &default_value) const;

    template <typename T> [[nodiscard]] bool Has(const std::string &key) const;

    [[nodiscard]] std::string FullPath() const { return MakeFullPath(entity, name); }
};
 
// =============================================================================
// Template Specializations - double
// =============================================================================
 
template <>
inline double ComponentConfig::Get<double>(const std::string &key, const double &def) const {
    auto it = scalars.find(key);
    return (it != scalars.end()) ? it->second : def;
}
 
template <> inline double ComponentConfig::Require<double>(const std::string &key) const {
    auto it = scalars.find(key);
    if (it == scalars.end()) {
        throw ConfigError("Component '" + FullPath() + "' missing required scalar: " + key);
    }
    return it->second;
}
 
template <> inline bool ComponentConfig::Has<double>(const std::string &key) const {
    return scalars.count(key) > 0;
}
 
// =============================================================================
// Template Specializations - int / int64_t
// =============================================================================
 
template <> inline int ComponentConfig::Get<int>(const std::string &key, const int &def) const {
    auto it = integers.find(key);
    if (it == integers.end()) {
        return def;
    }
    // Range check to prevent silent truncation
    int64_t val = it->second;
    if (val < static_cast<int64_t>(std::numeric_limits<int>::min()) ||
        val > static_cast<int64_t>(std::numeric_limits<int>::max())) {
        throw ConfigError("Component '" + FullPath() + "' integer '" + key + "' value " +
                          std::to_string(val) + " overflows int range [" +
                          std::to_string(std::numeric_limits<int>::min()) + ", " +
                          std::to_string(std::numeric_limits<int>::max()) + "]");
    }
    return static_cast<int>(val);
}
 
template <> inline int ComponentConfig::Require<int>(const std::string &key) const {
    auto it = integers.find(key);
    if (it == integers.end()) {
        throw ConfigError("Component '" + FullPath() + "' missing required integer: " + key);
    }
    // Range check to prevent silent truncation
    int64_t val = it->second;
    if (val < static_cast<int64_t>(std::numeric_limits<int>::min()) ||
        val > static_cast<int64_t>(std::numeric_limits<int>::max())) {
        throw ConfigError("Component '" + FullPath() + "' integer '" + key + "' value " +
                          std::to_string(val) + " overflows int range [" +
                          std::to_string(std::numeric_limits<int>::min()) + ", " +
                          std::to_string(std::numeric_limits<int>::max()) + "]");
    }
    return static_cast<int>(val);
}
 
template <> inline bool ComponentConfig::Has<int>(const std::string &key) const {
    return integers.count(key) > 0;
}
 
template <>
inline int64_t ComponentConfig::Get<int64_t>(const std::string &key, const int64_t &def) const {
    auto it = integers.find(key);
    return (it != integers.end()) ? it->second : def;
}
 
template <> inline int64_t ComponentConfig::Require<int64_t>(const std::string &key) const {
    auto it = integers.find(key);
    if (it == integers.end()) {
        throw ConfigError("Component '" + FullPath() + "' missing required integer: " + key);
    }
    return it->second;
}
 
template <> inline bool ComponentConfig::Has<int64_t>(const std::string &key) const {
    return integers.count(key) > 0;
}
 
// =============================================================================
// Template Specializations - bool
// =============================================================================
 
template <> inline bool ComponentConfig::Get<bool>(const std::string &key, const bool &def) const {
    auto it = booleans.find(key);
    return (it != booleans.end()) ? it->second : def;
}
 
template <>
inline bool ComponentConfig::Require<bool>(
    const std::string &key) const { // NOLINT(readability-identifier-naming)
    auto it = booleans.find(key);
    if (it == booleans.end()) {
        throw ConfigError("Component '" + FullPath() + "' missing required boolean: " + key);
    }
    return it->second;
}
 
template <> inline bool ComponentConfig::Has<bool>(const std::string &key) const {
    return booleans.count(key) > 0;
}
 
// =============================================================================
// Template Specializations - std::string
// =============================================================================
 
template <>
inline std::string ComponentConfig::Get<std::string>(const std::string &key,
                                                     const std::string &def) const {
    auto it = strings.find(key);
    return (it != strings.end()) ? it->second : def;
}
 
template <> inline std::string ComponentConfig::Require<std::string>(const std::string &key) const {
    auto it = strings.find(key);
    if (it == strings.end()) {
        throw ConfigError("Component '" + FullPath() + "' missing required string: " + key);
    }
    return it->second;
}
 
template <> inline bool ComponentConfig::Has<std::string>(const std::string &key) const {
    return strings.count(key) > 0;
}
 
// =============================================================================
// Template Specializations - Vec3<double>
// =============================================================================
 
template <>
inline Vec3<double> ComponentConfig::Get<Vec3<double>>(const std::string &key,
                                                       const Vec3<double> &def) const {
    auto it = vectors.find(key);
    if (it == vectors.end() || it->second.size() != 3) {
        return def;
    }
    return Vec3<double>{it->second[0], it->second[1], it->second[2]};
}
 
template <>
inline Vec3<double> ComponentConfig::Require<Vec3<double>>(const std::string &key) const {
    auto it = vectors.find(key);
    if (it == vectors.end()) {
        throw ConfigError("Component '" + FullPath() + "' missing required vector: " + key);
    }
    if (it->second.size() != 3) {
        throw ConfigError("Component '" + FullPath() + "' vector '" + key +
                          "' must have exactly 3 elements, got " +
                          std::to_string(it->second.size()));
    }
    return Vec3<double>{it->second[0], it->second[1], it->second[2]};
}
 
template <> inline bool ComponentConfig::Has<Vec3<double>>(const std::string &key) const {
    auto it = vectors.find(key);
    return it != vectors.end() && it->second.size() == 3;
}
 
// =============================================================================
// Template Specializations - Vec4<double> (Quaternion stored as [w,x,y,z])
// =============================================================================
 
template <>
inline Vec4<double> ComponentConfig::Get<Vec4<double>>(const std::string &key,
                                                       const Vec4<double> &def) const {
    auto it = vectors.find(key);
    if (it == vectors.end() || it->second.size() != 4) {
        return def;
    }
    return Vec4<double>{it->second[0], it->second[1], it->second[2], it->second[3]};
}
 
template <>
inline Vec4<double> ComponentConfig::Require<Vec4<double>>(const std::string &key) const {
    auto it = vectors.find(key);
    if (it == vectors.end()) {
        throw ConfigError("Component '" + FullPath() +
                          "' missing required quaternion/vec4: " + key);
    }
    if (it->second.size() != 4) {
        throw ConfigError("Component '" + FullPath() + "' quaternion/vec4 '" + key +
                          "' must have exactly 4 elements, got " +
                          std::to_string(it->second.size()));
    }
    return Vec4<double>{it->second[0], it->second[1], it->second[2], it->second[3]};
}
 
template <> inline bool ComponentConfig::Has<Vec4<double>>(const std::string &key) const {
    auto it = vectors.find(key);
    return it != vectors.end() && it->second.size() == 4;
}
 
// =============================================================================
// Template Specializations - std::vector<double>
// =============================================================================
 
template <>
inline std::vector<double>
ComponentConfig::Get<std::vector<double>>(const std::string &key,
                                          const std::vector<double> &def) const {
    auto it = arrays.find(key);
    if (it != arrays.end()) {
        return it->second;
    }
    // Also check vectors (arrays and vectors use same underlying storage for flexibility)
    auto vit = vectors.find(key);
    return (vit != vectors.end()) ? vit->second : def;
}
 
template <>
inline std::vector<double>
ComponentConfig::Require<std::vector<double>>(const std::string &key) const {
    auto it = arrays.find(key);
    if (it != arrays.end()) {
        return it->second;
    }
    auto vit = vectors.find(key);
    if (vit != vectors.end()) {
        return vit->second;
    }
    throw ConfigError("Component '" + FullPath() + "' missing required array: " + key);
}
 
template <> inline bool ComponentConfig::Has<std::vector<double>>(const std::string &key) const {
    return arrays.count(key) > 0 || vectors.count(key) > 0;
}
 
// =============================================================================
// Template Specializations - std::vector<std::string>
// =============================================================================
 
template <>
inline std::vector<std::string>
ComponentConfig::Get<std::vector<std::string>>(const std::string &key,
                                               const std::vector<std::string> &def) const {
    // Special case: known string list members
    if (key == "sources") {
        return sources.empty() ? def : sources;
    }
    if (key == "body_sources") {
        return body_sources.empty() ? def : body_sources;
    }
    if (key == "ecef_sources") {
        return ecef_sources.empty() ? def : ecef_sources;
    }
    return def;
}
 
template <>
inline std::vector<std::string>
ComponentConfig::Require<std::vector<std::string>>(const std::string &key) const {
    if (key == "sources") {
        if (sources.empty()) {
            throw ConfigError("Component '" + FullPath() + "' missing required sources list");
        }
        return sources;
    }
    if (key == "body_sources") {
        if (body_sources.empty()) {
            throw ConfigError("Component '" + FullPath() + "' missing required body_sources list");
        }
        return body_sources;
    }
    if (key == "ecef_sources") {
        if (ecef_sources.empty()) {
            throw ConfigError("Component '" + FullPath() + "' missing required ecef_sources list");
        }
        return ecef_sources;
    }
    throw ConfigError("Component '" + FullPath() + "' missing required string list: " + key);
}
 
template <>
inline bool ComponentConfig::Has<std::vector<std::string>>(const std::string &key) const {
    if (key == "sources") {
        return !sources.empty();
    }
    if (key == "body_sources") {
        return !body_sources.empty();
    }
    if (key == "ecef_sources") {
        return !ecef_sources.empty();
    }
    return false;
}
 
} // namespace icarus