parameter_validator.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef PFC_UI_PARAMETER_VALIDATOR_HPP
#define PFC_UI_PARAMETER_VALIDATOR_HPP
 
#include "parameter_metadata.hpp"
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <map>
#include <nlohmann/json.hpp>
#include <sstream>
#include <string>
#include <vector>
 
namespace pfc {
namespace ui {
 
using json = nlohmann::json;
 
struct ValidationResult {
  bool valid = true;
  std::vector<std::string> errors;
  std::map<std::string, std::string> validated_params;
 
  bool is_valid() const { return valid && errors.empty(); }
 
  std::string format_errors() const {
    if (errors.empty()) {
      return "No errors";
    }
 
    std::ostringstream msg;
    msg << "\n" << std::string(80, '=') << "\n";
    msg << "CONFIGURATION VALIDATION FAILED\n";
    msg << std::string(80, '=') << "\n\n";
    msg << "Found " << errors.size() << " error(s):\n\n";
 
    for (size_t i = 0; i < errors.size(); ++i) {
      msg << (i + 1) << ". " << errors[i] << "\n\n";
    }
 
    msg << "ABORTING: Fix configuration errors before running simulation.\n";
    msg << std::string(80, '=') << "\n";
 
    return msg.str();
  }
 
  std::string format_summary(const std::string &model_name = "Model") const {
    std::ostringstream msg;
    msg << "\n" << std::string(80, '=') << "\n";
    msg << "Configuration Validation Summary - " << model_name << "\n";
    msg << std::string(80, '=') << "\n";
 
    if (validated_params.empty()) {
      msg << "No parameters validated\n";
    } else {
      msg << "Validated " << validated_params.size() << " parameter(s):\n";
      msg << std::string(80, '-') << "\n";
 
      // Find max key length for formatting
      size_t max_key_len = 0;
      for (const auto &[key, _] : validated_params) {
        max_key_len = std::max(max_key_len, key.length());
      }
 
      for (const auto &[key, value] : validated_params) {
        msg << "  " << std::left << std::setw(max_key_len + 2) << key << " = "
            << value << "\n";
      }
    }
 
    msg << std::string(80, '=') << "\n";
 
    return msg.str();
  }
};
 
class ParameterValidator {
private:
  std::vector<ParameterMetadata<double>> double_params_;
  std::vector<ParameterMetadata<int>> int_params_;
  std::string model_name_ = "Model";
 
public:
  void set_model_name(const std::string &name) { model_name_ = name; }
 
  void add_metadata(const ParameterMetadata<double> &meta) {
    double_params_.push_back(meta);
  }
 
  void add_metadata(const ParameterMetadata<int> &meta) {
    int_params_.push_back(meta);
  }
 
  ValidationResult validate(const json &config) const {
    ValidationResult result;
 
    // Validate double parameters
    for (const auto &meta : double_params_) {
      validate_parameter(config, meta, result);
    }
 
    // Validate int parameters
    for (const auto &meta : int_params_) {
      validate_parameter(config, meta, result);
    }
 
    result.valid = result.errors.empty();
    return result;
  }
 
private:
  // Retrieve a JSON value by dot-separated path (e.g., "outer.inner.param").
  // Falls back to direct key lookup if path has no dots.
  static json get_by_path(const json &j, const std::string &path) {
    if (path.find('.') == std::string::npos) {
      return j.contains(path) ? j.at(path) : json(nullptr);
    }
    const json *current = &j;
    size_t start = 0;
    while (start < path.size()) {
      size_t dot = path.find('.', start);
      std::string key = (dot == std::string::npos) ? path.substr(start)
                                                   : path.substr(start, dot - start);
      if (!current->is_object() || !current->contains(key)) {
        return json(nullptr);
      }
      current = &current->at(key);
      if (dot == std::string::npos) break;
      start = dot + 1;
    }
    return *current;
  }
 
  static bool has_by_path(const json &j, const std::string &path) {
    if (path.find('.') == std::string::npos) {
      return j.contains(path);
    }
    const json *current = &j;
    size_t start = 0;
    while (start < path.size()) {
      size_t dot = path.find('.', start);
      std::string key = (dot == std::string::npos) ? path.substr(start)
                                                   : path.substr(start, dot - start);
      if (!current->is_object() || !current->contains(key)) {
        return false;
      }
      current = &current->at(key);
      if (dot == std::string::npos) break;
      start = dot + 1;
    }
    return true;
  }
 
  static bool is_finite_number(const json &v) {
    if (!v.is_number()) return false;
    double x = v.get<double>();
    return std::isfinite(x);
  }
 
  void validate_parameter(const json &config, const ParameterMetadata<double> &meta,
                          ValidationResult &result) const {
    // Resolve value by path (supports nested keys like "a.b.c")
    bool exists = has_by_path(config, meta.name);
    json val = exists ? get_by_path(config, meta.name) : json(nullptr);
    // Check if parameter exists
    if (!exists) {
      if (meta.required && !meta.default_value) {
        std::ostringstream err;
        err << "Required parameter '" << meta.name << "' is missing\n"
            << "  " << meta.format_info();
        result.errors.push_back(err.str());
        return;
      } else if (meta.default_value) {
        // Use default value
        std::ostringstream val_str;
        val_str << *meta.default_value << " (default)";
        result.validated_params[meta.name] = val_str.str();
        return;
      } else {
        // Optional parameter, not provided
        return;
      }
    }
 
    // Check type
    if (!val.is_number()) {
      std::ostringstream err;
      err << "Parameter '" << meta.name << "' has wrong type\n"
          << "  Expected: number\n"
          << "  Got: " << val.type_name() << "\n"
          << "  Value: " << val.dump() << "\n"
          << "  " << meta.format_info();
      result.errors.push_back(err.str());
      return;
    }
 
    // Get value and validate bounds (reject NaN/Inf)
    double value = val.get<double>();
    if (!std::isfinite(value)) {
      std::ostringstream err;
      err << "Parameter '" << meta.name << "' is not finite (NaN/Inf)\n"
          << "  " << meta.format_info();
      result.errors.push_back(err.str());
      return;
    }
    if (auto error = meta.validate(value)) {
      std::ostringstream err;
      err << *error << "\n"
          << "  " << meta.format_info();
      result.errors.push_back(err.str());
    } else {
      // Valid parameter
      std::ostringstream val_str;
      val_str << value;
      if (meta.min_value && meta.max_value) {
        val_str << "  [range: " << *meta.min_value << ", " << *meta.max_value << "]";
      }
      result.validated_params[meta.name] = val_str.str();
    }
  }
 
  void validate_parameter(const json &config, const ParameterMetadata<int> &meta,
                          ValidationResult &result) const {
    // Resolve value by path (supports nested keys like "a.b.c")
    bool exists = has_by_path(config, meta.name);
    json val = exists ? get_by_path(config, meta.name) : json(nullptr);
    // Check if parameter exists
    if (!exists) {
      if (meta.required && !meta.default_value) {
        std::ostringstream err;
        err << "Required parameter '" << meta.name << "' is missing\n"
            << "  " << meta.format_info();
        result.errors.push_back(err.str());
        return;
      } else if (meta.default_value) {
        // Use default value
        std::ostringstream val_str;
        val_str << *meta.default_value << " (default)";
        result.validated_params[meta.name] = val_str.str();
        return;
      } else {
        // Optional parameter, not provided
        return;
      }
    }
 
    // Check type
    if (!val.is_number_integer()) {
      std::ostringstream err;
      err << "Parameter '" << meta.name << "' has wrong type\n"
          << "  Expected: integer\n"
          << "  Got: " << val.type_name() << "\n"
          << "  Value: " << val.dump() << "\n"
          << "  " << meta.format_info();
      result.errors.push_back(err.str());
      return;
    }
 
    // Get value and validate bounds
    int value = val.get<int>();
    if (auto error = meta.validate(value)) {
      std::ostringstream err;
      err << *error << "\n"
          << "  " << meta.format_info();
      result.errors.push_back(err.str());
    } else {
      // Valid parameter
      std::ostringstream val_str;
      val_str << value;
      if (meta.min_value && meta.max_value) {
        val_str << "  [range: " << *meta.min_value << ", " << *meta.max_value << "]";
      }
      result.validated_params[meta.name] = val_str.str();
    }
  }
};
 
} // namespace ui
} // namespace pfc
 
#endif // PFC_UI_PARAMETER_VALIDATOR_HPP