parameter_metadata.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_METADATA_HPP
#define PFC_UI_PARAMETER_METADATA_HPP
 
#include <optional>
#include <sstream>
#include <string>
#include <type_traits>
#include <limits>
 
namespace pfc {
namespace ui {
 
template <typename T>
struct ParameterMetadata {
  std::string name;                        
  std::string description;                 
  bool required = false;                   
  std::optional<T> min_value;             
  std::optional<T> max_value;             
  std::optional<T> typical_value;         
  std::optional<T> default_value;         
  std::string physical_units;              
  std::string category;                    
 
  std::optional<std::string> validate(T value) const {
    if (min_value && value < *min_value) {
      std::ostringstream msg;
      msg << "Parameter '" << name << "' = " << value 
          << " is below minimum " << *min_value;
      if (min_value && max_value) {
        msg << " (valid range: [" << *min_value << ", " << *max_value << "])";
      }
      return msg.str();
    }
 
    if (max_value && value > *max_value) {
      std::ostringstream msg;
      msg << "Parameter '" << name << "' = " << value 
          << " exceeds maximum " << *max_value;
      if (min_value && max_value) {
        msg << " (valid range: [" << *min_value << ", " << *max_value << "])";
      }
      return msg.str();
    }
 
    return std::nullopt;  // Valid
  }
 
  std::string format_info() const {
    std::ostringstream info;
    info << "Parameter: " << name << "\n";
    info << "  Description: " << description;
    if (!physical_units.empty()) {
      info << " (" << physical_units << ")";
    }
    info << "\n";
    
    if (min_value || max_value) {
      info << "  Valid range: [";
      if (min_value) {
        info << *min_value;
      } else {
        info << "-inf";
      }
      info << ", ";
      if (max_value) {
        info << *max_value;
      } else {
        info << "+inf";
      }
      info << "]\n";
    }
    
    if (typical_value) {
      info << "  Typical value: " << *typical_value << "\n";
    }
    
    if (default_value) {
      info << "  Default value: " << *default_value << "\n";
    }
    
    info << "  Required: " << (required ? "yes" : "no");
    
    return info.str();
  }
 
  class Builder {
  private:
    ParameterMetadata<T> param_;
 
  public:
    Builder& name(const std::string& n) {
      param_.name = n;
      return *this;
    }
 
    Builder& description(const std::string& desc) {
      param_.description = desc;
      return *this;
    }
 
    Builder& required(bool req = true) {
      param_.required = req;
      return *this;
    }
 
    Builder& optional(bool opt = true) {
      param_.required = !opt;
      return *this;
    }
 
    Builder& min(T min_val) {
      param_.min_value = min_val;
      return *this;
    }
 
    Builder& max(T max_val) {
      param_.max_value = max_val;
      return *this;
    }
 
    Builder& range(T min_val, T max_val) {
      param_.min_value = min_val;
      param_.max_value = max_val;
      return *this;
    }
 
    Builder& typical(T typ_val) {
      param_.typical_value = typ_val;
      return *this;
    }
 
    Builder& default_val(T def_val) {
      param_.default_value = def_val;
      return *this;
    }
 
    Builder& units(const std::string& u) {
      param_.physical_units = u;
      return *this;
    }
 
    Builder& category(const std::string& cat) {
      param_.category = cat;
      return *this;
    }
 
    ParameterMetadata<T> build() const {
      return param_;
    }
  };
 
  static Builder builder() {
    return Builder();
  }
};
 
} // namespace ui
} // namespace pfc
 
#endif // PFC_UI_PARAMETER_METADATA_HPP