species_input.h

#pragma once
 
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "errors.h"
#include "parser.h"
 
class SpeciesInput {
 public:
  SpeciesInput(FileContent* pfc, std::string instance_name);
 
  const std::string& instance_name() const {
    return instance_name_;
  }
 
  template <class T>
  std::optional<T> get(const std::string& field) const {
    return pfc_->get<T>(qualify(field));
  }
 
  template <class T>
  T get_or(const std::string& field, T fallback) const {
    if (auto v = get<T>(field))
      return *v;
    return fallback;
  }
 
  template <class T>
  T require(const std::string& field) const {
    if (auto v = get<T>(field))
      return *v;
    class_stop_severe("species '%s': missing required field '%s'",
                      instance_name_.c_str(),
                      field.c_str());
  }
 
 private:
  std::string qualify(const std::string& field) const;
 
  FileContent* pfc_;
  std::string instance_name_;
};
 
std::vector<std::string> CollectInstanceFieldValues(FileContent* pfc,
                                                    const std::vector<std::string>& instances,
                                                    const std::string& field);
 
bool AnyInstanceFieldValue(const std::vector<std::string>& values);
 
bool SynthesiseIdenticalScalarField(FileContent* pfc,
                                    const std::vector<std::string>& instances,
                                    const std::string& dot_field,
                                    const std::string& legacy_key,
                                    const std::string& species_description);
 
void TranslateSingleInstanceDotSyntax(FileContent* pfc);