config_validators.hpp

Go to the documentation of this file.

#pragma once
 
#include <sstream>
#include <stdexcept>
#include <string>
#include <toml++/toml.hpp>
#include <vector>
 
namespace validators {
 
template <typename T>
std::string getTypeName() {
  if constexpr (std::is_same_v<T, int> || std::is_same_v<T, int64_t>) {
    return "integer";
  } else if constexpr (std::is_same_v<T, size_t>) {
    return "nonnegative integer";
  } else if constexpr (std::is_same_v<T, double> || std::is_same_v<T, float>) {
    return "number";
  } else if constexpr (std::is_same_v<T, std::string>) {
    return "string";
  } else if constexpr (std::is_same_v<T, bool>) {
    return "boolean";
  } else {
    return "unknown type";
  }
}
 
class ValidationError : public std::runtime_error {
 public:
  ValidationError(const std::string& field, const std::string& message)
      : std::runtime_error("Validation error for field '" + field + "': " + message) {}
};
 
template <typename T>
class Validator {
 private:
  const toml::table& config;
  std::string key;
  std::optional<T> greater_than;
  std::optional<T> greater_than_equal;
  std::optional<T> less_than;
 
 public:
  Validator(const toml::table& config_, const std::string& key_) : config(config_), key(key_) {}
 
  Validator& greaterThan(T greater_than_) {
    greater_than = greater_than_;
    return *this;
  }
 
  Validator& greaterThanEqual(T greater_than_equal_) {
    greater_than_equal = greater_than_equal_;
    return *this;
  }
 
  Validator& lessThan(T less_than_) {
    less_than = less_than_;
    return *this;
  }
 
  Validator& positive() {
    greaterThan(T{0});
    return *this;
  }
 
 private:
  std::optional<T> extractValue() {
    // If key doesn't exist, return nullopt
    if (!config.contains(key)) {
      return std::nullopt;
    }
 
    // Key exists, try to extract value with type checking
    auto val = config[key].template value<T>();
    if (!val) {
      // Key exists but wrong type - always an error
      throw ValidationError(key, "wrong type (expected " + getTypeName<T>() + ")");
    }
 
    return val;
  }
 
  T validateValue(T result) {
    if (greater_than && result <= *greater_than) {
      std::ostringstream oss;
      oss << "must be > " << *greater_than << ", got " << result;
      throw ValidationError(key, oss.str());
    }
 
    if (greater_than_equal && result < *greater_than_equal) {
      std::ostringstream oss;
      oss << "must be >= " << *greater_than_equal << ", got " << result;
      throw ValidationError(key, oss.str());
    }
 
    if (less_than && result >= *less_than) {
      std::ostringstream oss;
      oss << "must be < " << *less_than << ", got " << result;
      throw ValidationError(key, oss.str());
    }
 
    return result;
  }
 
 public:
  T value() {
    auto val = extractValue();
 
    if (!val) {
      throw ValidationError(key, "field not found");
    }
 
    return validateValue(*val);
  }
 
  T valueOr(T default_value_) {
    auto val = extractValue();
    if (!val) return default_value_; // Key doesn't exist - use default
 
    return validateValue(*val); // Key exists - validate it (will throw on wrong type)
  }
};
 
template <typename T>
class VectorValidator {
 private:
  const toml::table& config;
  std::string key;
  std::optional<size_t> min_length;
  std::optional<size_t> exact_length;
  bool is_positive = false;
 
 public:
  VectorValidator(const toml::table& config_, const std::string& key_) : config(config_), key(key_) {}
 
  VectorValidator& minLength(size_t min_len_) {
    min_length = min_len_;
    return *this;
  }
 
  VectorValidator& positive() {
    is_positive = true;
    return *this;
  }
 
  VectorValidator& hasLength(size_t exact_len_) {
    exact_length = exact_len_;
    return *this;
  }
 
 private:
  std::optional<std::vector<T>> extractVector() {
    // If key doesn't exist, return nullopt
    if (!config.contains(key)) {
      return std::nullopt;
    }
 
    // Key exists, check if it's an array
    auto* arr = config[key].as_array();
    if (!arr) {
      // Key exists but wrong type - always an error
      throw ValidationError(key, "wrong type (expected array)");
    }
 
    // Extract and validate array elements
    std::vector<T> result;
    for (size_t i = 0; i < arr->size(); ++i) {
      auto val = arr->at(i).template value<T>();
      if (!val) {
        std::ostringstream oss;
        oss << "element [" << i << "] wrong type (expected " << getTypeName<T>() << ")";
        throw ValidationError(key, oss.str());
      }
      result.push_back(*val);
    }
 
    return result;
  }
 
  std::vector<T> validateVector(std::vector<T> result) {
    if (exact_length && result.size() != *exact_length) {
      std::ostringstream oss;
      oss << "must have exactly " << *exact_length << " elements, got " << result.size();
      throw ValidationError(key, oss.str());
    }
 
    if (min_length && result.size() < *min_length) {
      std::ostringstream oss;
      oss << "must have at least " << *min_length << " elements, got " << result.size();
      throw ValidationError(key, oss.str());
    }
 
    for (size_t i = 0; i < result.size(); ++i) {
      T& element = result[i];
 
      if (is_positive && element <= T{0}) {
        std::ostringstream oss;
        oss << "element [" << i << "] must be positive, got " << element;
        throw ValidationError(key, oss.str());
      }
    }
 
    return result;
  }
 
 public:
  std::vector<T> value() {
    auto val = extractVector();
 
    if (!val) {
      throw ValidationError(key, "field not found");
    }
 
    return validateVector(*val);
  }
 
  std::vector<T> valueOr(const std::vector<T>& default_value_) {
    auto val = extractVector();
    if (!val) return default_value_; // Key doesn't exist - use default
 
    return validateVector(*val); // Key exists - validate it (will throw on wrong type)
  }
};
 
template <typename T>
Validator<T> field(const toml::table& config_, const std::string& key_) {
  return Validator<T>(config_, key_);
}
 
template <typename T>
VectorValidator<T> vectorField(const toml::table& config_, const std::string& key_) {
  return VectorValidator<T>(config_, key_);
}
 
template <typename T, typename NodeType>
std::optional<T> getOptional(const toml::node_view<NodeType>& node) {
  return node.template value<T>();
}
 
template <typename T, typename NodeType>
std::optional<std::vector<T>> getOptionalVector(const toml::node_view<NodeType>& node) {
  auto* arr = node.as_array();
  if (!arr) return std::nullopt;
 
  std::vector<T> result;
  for (size_t i = 0; i < arr->size(); ++i) {
    auto val = arr->at(i).template value<T>();
    if (!val) return std::nullopt; // Type mismatch in array element
    result.push_back(*val);
  }
 
  return result;
}
 
inline const toml::table& getRequiredTable(const toml::table& config, const std::string& key) {
  if (!config.contains(key)) {
    throw ValidationError(key, "table is required");
  }
 
  auto* table = config[key].as_table();
  if (!table) {
    throw ValidationError(key, "must be a table");
  }
 
  return *table;
}
 
template <typename T>
std::vector<T> scalarOrVector(const toml::table& config, const std::string& key, size_t expected_size) {
  if (!config.contains(key)) {
    throw ValidationError(key, "field not found");
  }
 
  if (auto* arr = config[key].as_array()) {
    // Array: must have exact expected size
    if (arr->size() != expected_size) {
      std::ostringstream oss;
      oss << "array must have exactly " << expected_size << " elements, got " << arr->size();
      throw ValidationError(key, oss.str());
    }
    std::vector<T> result;
    for (size_t i = 0; i < arr->size(); ++i) {
      auto val = arr->at(i).template value<T>();
      if (!val) {
        std::ostringstream oss;
        oss << "element [" << i << "] wrong type (expected " << getTypeName<T>() << ")";
        throw ValidationError(key, oss.str());
      }
      result.push_back(*val);
    }
    return result;
  }
 
  if (auto val = config[key].template value<T>()) {
    // Scalar: fill vector with this value
    return std::vector<T>(expected_size, *val);
  }
 
  throw ValidationError(key, "must be either a scalar value or an array of " + getTypeName<T>());
}
 
template <typename T>
std::vector<T> scalarOrVectorOr(const toml::table& config, const std::string& key, size_t expected_size, const std::vector<T>& default_value) {
  if (!config.contains(key)) {
    return default_value;
  }
  return scalarOrVector<T>(config, key, expected_size);
}
 
} // namespace validators