deckField.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2026 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef INP_DECKFIELD_H
#define INP_DECKFIELD_H
 
#include "util/io.h"
#include "util/json.h"
 
#include <algorithm>
#include <functional>
#include <optional>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
 
namespace inp {
 
template <class Deck> struct Field {
 
  std::string key;
 
  std::string doc;
 
  std::string type;
 
  std::function<void(Deck &, const json &)> read;
 
  std::function<void(const Deck &, json &)> write;
 
  std::function<void(json &)> writeDefault;
 
  std::function<void(const Deck &, std::ostringstream &, const std::string &)>
      print;
 
  std::function<void(const json &)> check;
 
  std::function<bool(const json &)> emit;
};
 
template <class T> inline std::string typeName() { return "value"; }
template <> inline std::string typeName<bool>() { return "bool"; }
template <> inline std::string typeName<int>() { return "int"; }
template <> inline std::string typeName<std::size_t>() { return "size_t"; }
template <> inline std::string typeName<double>() { return "double"; }
template <> inline std::string typeName<std::string>() { return "string"; }
template <> inline std::string typeName<std::vector<double>>() {
  return "double[]";
}
template <> inline std::string typeName<std::vector<std::string>>() {
  return "string[]";
}
template <> inline std::string typeName<std::vector<std::size_t>>() {
  return "size_t[]";
}
 
template <class T>
void printValue(std::ostringstream &oss, const T &v) {
  oss << v;
}
 
template <class T>
void printValue(std::ostringstream &oss, const std::vector<T> &v) {
  oss << util::io::printStr<T>(v, 0);
}
 
template <class T> struct Accepts {
 
  std::vector<T> values = {};
 
  std::optional<T> min = std::nullopt;
 
  std::optional<T> max = std::nullopt;
};
 
template <class Deck, class T>
Field<Deck> field(
    T Deck::*m, std::string key, T def, std::string doc,
    Accepts<T> accepts = {},
    std::function<bool(const T &)> emitIf = [](const T &) { return true; }) {
 
  // Accepted values and bounds apply to the scalar types. A field holding a
  // list is checked by the deck if it needs to be.
  constexpr bool checkable =
      std::is_arithmetic_v<T> || std::is_same_v<T, std::string>;
 
  auto check = [key, accepts](const T &v) {
    if constexpr (checkable) {
      if (!accepts.values.empty() &&
          std::find(accepts.values.begin(), accepts.values.end(), v) ==
              accepts.values.end()) {
        std::ostringstream oss;
        oss << "Error: " << key << " must be one of:";
        for (const auto &a : accepts.values)
          oss << " " << a;
        oss << ". Given value is " << v << ".\n";
        throw std::runtime_error(oss.str());
      }
      if (accepts.min.has_value() && v < accepts.min.value()) {
        std::ostringstream oss;
        oss << "Error: " << key << " must be at least " << accepts.min.value()
            << ". Given value is " << v << ".\n";
        throw std::runtime_error(oss.str());
      }
      if (accepts.max.has_value() && accepts.max.value() < v) {
        std::ostringstream oss;
        oss << "Error: " << key << " must be at most " << accepts.max.value()
            << ". Given value is " << v << ".\n";
        throw std::runtime_error(oss.str());
      }
    }
  };
 
  return Field<Deck>{
      key, std::move(doc), typeName<T>(),
      [m, key, def, check](Deck &d, const json &j) {
        d.*m = j.value(key, def);
        check(d.*m);
      },
      [m, key, emitIf](const Deck &d, json &j) {
        if (emitIf(d.*m))
          j[key] = d.*m;
      },
      [key, def, emitIf](json &j) {
        if (emitIf(def))
          j[key] = def;
      },
      [m, key](const Deck &d, std::ostringstream &oss,
               const std::string &tab) {
        oss << tab << key << " = ";
        printValue(oss, d.*m);
        oss << std::endl;
      },
      [check](const json &v) { check(v.get<T>()); },
      [emitIf](const json &v) { return emitIf(v.get<T>()); }};
}
 
template <class Deck, class T>
Field<Deck> requiredField(T Deck::*m, std::string key, std::string doc,
                          Accepts<T> accepts = {}) {
  auto f = field(m, key, T{}, std::move(doc), accepts);
  f.read = [m, key, accepts, f](Deck &d, const json &j) {
    if (j.find(key) == j.end())
      throw std::runtime_error("Error: " + key + " is required.\n");
    json one = json::object();
    one[key] = j.at(key);
    f.read(d, one);
  };
  return f;
}
 
template <class Deck>
void readFields(Deck &d, const json &j, const std::vector<Field<Deck>> &fs) {
  for (const auto &f : fs)
    f.read(d, j);
}
 
template <class Deck>
void writeFields(const Deck &d, json &j, const std::vector<Field<Deck>> &fs) {
  for (const auto &f : fs)
    f.write(d, j);
}
 
template <class Deck>
void printFields(const Deck &d, std::ostringstream &oss,
                 const std::vector<Field<Deck>> &fs,
                 const std::string &tab = "") {
  for (const auto &f : fs)
    f.print(d, oss, tab);
}
 
template <class Deck>
json defaultsJson(const std::vector<Field<Deck>> &fs) {
  json j = json::object();
  for (const auto &f : fs)
    f.writeDefault(j);
  return j;
}
 
template <class Deck> json schemaJson(const std::vector<Field<Deck>> &fs) {
  json out = json::array();
  const json defaults = defaultsJson(fs);
  for (const auto &f : fs) {
    json entry = {{"key", f.key}, {"type", f.type}, {"doc", f.doc}};
    if (defaults.find(f.key) != defaults.end())
      entry["default"] = defaults.at(f.key);
    out.push_back(entry);
  }
  return out;
}
 
struct OneOf {
 
  std::string what;
 
  std::vector<std::string> keys;
 
  bool required = true;
};
 
inline void checkGroups(const json &block, const std::vector<OneOf> &groups) {
  for (const auto &g : groups) {
    std::vector<std::string> present;
    for (const auto &k : g.keys)
      if (block.find(k) != block.end())
        present.push_back(k);
 
    if (present.size() == 1 || (present.empty() && !g.required))
      continue;
 
    std::ostringstream oss;
    oss << "Error: give exactly one of";
    for (const auto &k : g.keys)
      oss << " " << k;
    oss << " for " << g.what << ". ";
    if (present.empty())
      oss << "None was given.\n";
    else {
      oss << "These were given:";
      for (const auto &k : present)
        oss << " " << k;
      oss << ".\n";
    }
    throw std::runtime_error(oss.str());
  }
}
 
inline std::size_t editDistance(const std::string &a, const std::string &b) {
  std::vector<std::size_t> prev(b.size() + 1), cur(b.size() + 1);
  for (std::size_t j = 0; j <= b.size(); ++j)
    prev[j] = j;
  for (std::size_t i = 1; i <= a.size(); ++i) {
    cur[0] = i;
    for (std::size_t j = 1; j <= b.size(); ++j)
      cur[j] = std::min({prev[j] + 1, cur[j - 1] + 1,
                         prev[j - 1] + (a[i - 1] == b[j - 1] ? 0 : 1)});
    prev = cur;
  }
  return prev[b.size()];
}
 
inline void checkNames(const json &given,
                       const std::vector<std::string> &names) {
  if (given.is_null() || given.empty())
    return;
  if (!given.is_object())
    throw std::runtime_error(
        "Error: deck values must be given as name and value pairs.\n");
 
  for (const auto &item : given.items()) {
    const std::string key = item.key();
    if (std::find(names.begin(), names.end(), key) != names.end())
      continue;
 
    std::string closest;
    std::size_t best = std::string::npos;
    for (const auto &n : names) {
      const std::size_t d = editDistance(key, n);
      if (d < best) {
        best = d;
        closest = n;
      }
    }
    std::ostringstream oss;
    oss << "Error: no field named " << key << ".";
    if (best <= 3)
      oss << " Closest declared field is " << closest << ".";
    oss << "\nDeclared fields are:";
    for (const auto &n : names)
      oss << " " << n;
    oss << "\n";
    throw std::runtime_error(oss.str());
  }
}
 
template <class Deck>
void checkKeys(const json &given, const std::vector<Field<Deck>> &fs,
               const std::vector<std::string> &extra = {}) {
  std::vector<std::string> names;
  names.reserve(fs.size() + extra.size());
  for (const auto &f : fs)
    names.push_back(f.key);
  names.insert(names.end(), extra.begin(), extra.end());
  checkNames(given, names);
}
 
template <class Deck>
json applyGiven(const json &given, const std::vector<Field<Deck>> &fs,
                const std::vector<std::string> &extra = {}) {
  checkKeys(given, fs, extra);
  json j = defaultsJson(fs);
  if (!given.is_object())
    return j;
 
  for (const auto &item : given.items()) {
    bool emit = true;
    for (const auto &f : fs)
      if (f.key == item.key()) {
        f.check(item.value());
        emit = f.emit(item.value());
      }
    // A field that is not written at its default is not written when the
    // same value is given, so that the block does not depend on whether the
    // caller named the field.
    if (emit)
      j[item.key()] = item.value();
    else
      j.erase(item.key());
  }
  return j;
}
 
} // namespace inp
 
#endif // INP_DECKFIELD_H