parser.h

#ifndef __PARSER__
#define __PARSER__
 
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "common.h"
 
class FileContent {
 public:
  bool is_shooting = false;
 
  FileContent()                              = default;
  ~FileContent()                             = default;
  FileContent(const FileContent&)            = default;
  FileContent(FileContent&&)                 = default;
  FileContent& operator=(const FileContent&) = default;
  FileContent& operator=(FileContent&&)      = default;
 
  static FileContent from_file(const std::string& filename);
 
  void set(const std::string& name, const std::string& value);
 
  FileContent& operator+=(const FileContent& other);
  friend FileContent operator+(FileContent lhs, const FileContent& rhs) {
    return lhs += rhs;
  }
 
  int size() const {
    return static_cast<int>(params_.size());
  }
 
  const std::string& get_filename() const {
    return filename_;
  }
 
  template <class T>
  std::optional<T> get(const std::string& name) const;
 
  template <class T>
  T get_or(const std::string& name, T fallback) const {
    if (auto v = get<T>(name))
      return *v;
    return fallback;
  }
  std::string get_or(const std::string& name, const char* fallback) const;
 
  void mark_all_unread() const {
    read_params_.clear();
  }
 
  bool was_read(const std::string& name) const {
    return read_params_.count(name) > 0;
  }
 
  std::vector<std::string> instances_with(const std::string& field, const std::string& value) const;
 
  std::vector<std::string> unread_parameters() const;
 
 private:
  std::string filename_;
  std::vector<std::string> keys_; 
  std::map<std::string, std::string> params_;
  mutable std::set<std::string> read_params_;
 
 public:
  void for_each(
      const std::function<void(const std::string& name, const std::string& value, bool read)>& fn)
      const;
 
  static bool parse_line(const std::string& line, std::string& name, std::string& value);
 
  static std::vector<std::string> split_csv(const std::string& s);
};
 
// Explicit specialization declarations — definitions are in parser.cpp.
// These prevent implicit instantiation from the primary template in any TU.
template <>
std::optional<int> FileContent::get<int>(const std::string& name) const;
template <>
std::optional<double> FileContent::get<double>(const std::string& name) const;
template <>
std::optional<std::string> FileContent::get<std::string>(const std::string& name) const;
template <>
std::optional<std::vector<double>> FileContent::get<std::vector<double>>(
    const std::string& name) const;
template <>
std::optional<std::vector<int>> FileContent::get<std::vector<int>>(const std::string& name) const;
template <>
std::optional<std::vector<std::string>> FileContent::get<std::vector<std::string>>(
    const std::string& name) const;
 
/**************************************************************/
/* Legacy C-style free functions.                             */
/**************************************************************/
 
#ifdef __cplusplus
extern "C" {
#endif
 
void parser_read_file(const char* filename, FileContent* pfc);
 
void parser_cat(const FileContent* pfc1, const FileContent* pfc2, FileContent* pfc3);
 
#ifdef __cplusplus
}
#endif
 
#endif