Refactor code to use getter and setter methods for configuration classes

- Updated `.clang-tidy` to ignore 'google-readability-todo' check.
- Introduced a new `class_to_yaml_converter.md` with example usage of `yaml-cpp` to convert class objects.
- Added a new `struct_to_class.md` with examples of converting structs to classes with getters and setters.
- Refactored `ModelSettings`, `PopulationDemographic`, and `TransmissionSettings` classes to use getters and setters.
- Updated YAMLConverters to use the new getters and setters for `ModelSettings`, `PopulationDemographic`, and `TransmissionSettings`.
- Modified `Config` class and removed observer pattern in favor of cleaner cross-field validation.
- Updated related tests to use getter and setter methods instead of directly accessing member variables.

Author: merlinvn

.clang-tidy

@@ -13,6 +13,7 @@ Checks: >
   -misc-non-private-member-variables-in-classes,
   -readability-braces-around-statements,
   -google-readability-braces-around-statements,
+  -google-readability-todo,
   -cppcoreguidelines-avoid-magic-numbers,
   -readability-magic-numbers,
   -readability-magic-numbers,

promts/class_to_yaml_converter.md

@@ -0,0 +1,126 @@
+```
+Here is the example of using yaml-cpp to read in yaml node to class object
+
+class ModelSettings {
+public:
+  // Getters
+  [[nodiscard]] int get_days_between_stdout_output() const {
+    return days_between_stdout_output_;
+  }
+  // Setters with validation
+  void set_days_between_stdout_output(int value) {
+    if (value <= 0)
+      throw std::invalid_argument(
+          "days_between_stdout_output must be greater than 0");
+    days_between_stdout_output_ = value;
+  }
+  [[nodiscard]] int get_initial_seed_number() const {
+    return initial_seed_number_;
+  }
+  void set_initial_seed_number(int value) {
+    if (value < 0)
+      throw std::invalid_argument("initial_seed_number must be non-negative");
+    initial_seed_number_ = value;
+  }
+  [[nodiscard]] bool get_record_genome_db() const { return record_genome_db_; }
+  void set_record_genome_db(bool value) { record_genome_db_ = value; }
+  [[nodiscard]] const date::year_month_day &get_starting_date() const {
+    return starting_date_;
+  }
+  void set_starting_date(const date::year_month_day &value) {
+    starting_date_ = value;
+  }
+  [[nodiscard]] const date::year_month_day &get_start_of_comparison_period()
+      const {
+    return start_of_comparison_period_;
+  }
+  void set_start_of_comparison_period(const date::year_month_day &value) {
+    if (value < starting_date_)
+      throw std::invalid_argument(
+          "start_of_comparison_period cannot be before starting_date");
+    start_of_comparison_period_ = value;
+  }
+  [[nodiscard]] const date::year_month_day &get_ending_date() const {
+    return ending_date_;
+  }
+  void set_ending_date(const date::year_month_day &value) {
+    if (value < start_of_comparison_period_)
+      throw std::invalid_argument(
+          "ending_date cannot be before start_of_comparison_period");
+    ending_date_ = value;
+  }
+  [[nodiscard]] int get_start_collect_data_day() const {
+    return start_collect_data_day_;
+  }
+  void set_start_collect_data_day(int value) {
+    if (value < 0)
+      throw std::invalid_argument(
+          "start_collect_data_day must be non-negative");
+    start_collect_data_day_ = value;
+  }
+
+private:
+  int days_between_stdout_output_;
+  int initial_seed_number_;
+  bool record_genome_db_;
+  date::year_month_day starting_date_;
+  date::year_month_day start_of_comparison_period_;
+  date::year_month_day ending_date_;
+  int start_collect_data_day_;
+};
+
+
+template <>
+struct convert<ModelSettings> {
+  static Node encode(const ModelSettings &rhs) {
+    Node node;
+    node["days_between_stdout_output"] = rhs.get_days_between_stdout_output();
+    node["initial_seed_number"] = rhs.get_initial_seed_number();
+    node["record_genome_db"] = rhs.get_record_genome_db();
+    node["starting_date"] = rhs.get_starting_date();
+    node["start_of_comparison_period"] = rhs.get_start_of_comparison_period();
+    node["ending_date"] = rhs.get_ending_date();
+    node["start_collect_data_day"] = rhs.get_start_collect_data_day();
+    return node;
+  }
+
+  static bool decode(const Node &node, ModelSettings &rhs) {
+    if (!node["days_between_stdout_output"]) {
+      throw std::runtime_error("Missing 'days_between_stdout_output' field.");
+    }
+    if (!node["initial_seed_number"]) {
+      throw std::runtime_error("Missing 'initial_seed_number' field.");
+    }
+    if (!node["record_genome_db"]) {
+      throw std::runtime_error("Missing 'record_genome_db' field.");
+    }
+    if (!node["starting_date"]) {
+      throw std::runtime_error("Missing 'starting_date' field.");
+    }
+    if (!node["start_of_comparison_period"]) {
+      throw std::runtime_error("Missing 'start_of_comparison_period' field.");
+    }
+    if (!node["ending_date"]) {
+      throw std::runtime_error("Missing 'ending_date' field.");
+    }
+    if (!node["start_collect_data_day"]) {
+      throw std::runtime_error("Missing 'start_collect_data_day' field.");
+    }
+
+    // TODO: Add more error checking for each field
+
+    rhs.set_days_between_stdout_output(
+        node["days_between_stdout_output"].as<int>());
+    rhs.set_initial_seed_number(node["initial_seed_number"].as<int>());
+    rhs.set_record_genome_db(node["record_genome_db"].as<bool>());
+    rhs.set_starting_date(node["starting_date"].as<date::year_month_day>());
+    rhs.set_start_of_comparison_period(
+        node["start_of_comparison_period"].as<date::year_month_day>());
+    rhs.set_ending_date(node["ending_date"].as<date::year_month_day>());
+    rhs.set_start_collect_data_day(node["start_collect_data_day"].as<int>());
+    return true;
+  }
+};
+
+As an expert in C++ developer, would you mind make the similar convert function for the following class:
+```

promts/struct_to_class.md

@@ -0,0 +1,109 @@
+```
+Here is an example of conversion a struct into class:
+
+
+struct PopulationDemographic {
+  int number_of_age_classes;
+  std::vector<int> age_structure;
+  std::vector<int> initial_age_structure;
+  double birth_rate;
+  std::vector<double> death_rate_by_age_class;
+  std::vector<double> mortality_when_treatment_fail_by_age_class;
+  double artificial_rescaling_of_population_size;
+};
+
+class PopulationDemographic {
+public:
+  // Getters
+  [[nodiscard]] int get_number_of_age_classes() const {
+    return number_of_age_classes_;
+  }
+  // Setters with validation
+  void set_number_of_age_classes(int value) {
+    if (value <= 0)
+      throw std::invalid_argument(
+          "number_of_age_classes must be greater than 0");
+    number_of_age_classes_ = value;
+  }
+
+  [[nodiscard]] const std::vector<int> &get_age_structure() const {
+    return age_structure_;
+  }
+  void set_age_structure(const std::vector<int> &value) {
+    if (value.size() != number_of_age_classes_)
+      throw std::invalid_argument(
+          "age_structure size must match number_of_age_classes");
+    age_structure_ = value;
+  }
+
+  [[nodiscard]] const std::vector<int> &get_initial_age_structure() const {
+    return initial_age_structure_;
+  }
+  void set_initial_age_structure(const std::vector<int> &value) {
+    if (value.size() != number_of_age_classes_)
+      throw std::invalid_argument(
+          "initial_age_structure size must match number_of_age_classes");
+    initial_age_structure_ = value;
+  }
+
+  [[nodiscard]] double get_birth_rate() const { return birth_rate_; }
+  void set_birth_rate(double value) {
+    if (value < 0)
+      throw std::invalid_argument("birth_rate must be non-negative");
+    birth_rate_ = value;
+  }
+
+  [[nodiscard]] const std::vector<double> &get_death_rate_by_age_class() const {
+    return death_rate_by_age_class_;
+  }
+
+  void set_death_rate_by_age_class(const std::vector<double> &value) {
+    if (value.size() != number_of_age_classes_)
+      throw std::invalid_argument(
+          "death_rate_by_age_class size must match number_of_age_classes");
+    death_rate_by_age_class_ = value;
+  }
+
+  [[nodiscard]] const std::vector<double> &
+  get_mortality_when_treatment_fail_by_age_class() const {
+    return mortality_when_treatment_fail_by_age_class_;
+  }
+
+  void set_mortality_when_treatment_fail_by_age_class(
+      const std::vector<double> &value) {
+    if (value.size() != number_of_age_classes_)
+      throw std::invalid_argument(
+          "mortality_when_treatment_fail_by_age_class size must match "
+          "number_of_age_classes");
+    mortality_when_treatment_fail_by_age_class_ = value;
+  }
+
+  [[nodiscard]] double get_artificial_rescaling_of_population_size() const {
+    return artificial_rescaling_of_population_size_;
+  }
+
+  void set_artificial_rescaling_of_population_size(double value) {
+    if (value <= 0)
+      throw std::invalid_argument(
+          "artificial_rescaling_of_population_size must be greater than 0");
+    artificial_rescaling_of_population_size_ = value;
+  }
+
+private:
+  int number_of_age_classes_;
+  std::vector<int> age_structure_;
+  std::vector<int> initial_age_structure_;
+  double birth_rate_;
+  std::vector<double> death_rate_by_age_class_;
+  std::vector<double> mortality_when_treatment_fail_by_age_class_;
+  double artificial_rescaling_of_population_size_;
+};
+
+
+
+As an expert C++ developer, would you mind help me convert the following struct.
+Requirments:
+  The getter and setter should be in pair, next to each other.
+
+
+```

promts/struct_to_yaml_converter.md

@@ -8,25 +8,20 @@
 #include "YAMLConverters.h"
 
 void Config::load(const std::string &filename) {
-  std::shared_lock lock(mutex_);
   config_file_path_ = filename;
   YAML::Node config = YAML::LoadFile(filename);
-  config_data_.model_settings = config["ModelSettings"].as<ModelSettings>();
+
+  config_data_.model_settings = config["model_settings"].as<ModelSettings>();
+
   config_data_.transmission_settings =
-      config["TransmissionSettings"].as<TransmissionSettings>();
-  config_data_.population_demographic =
-      config["PopulationDemographic"].as<PopulationDemographic>();
-  notify_observers();
-}
+      config["transmission_settings"].as<TransmissionSettings>();
 
-void Config::reload() { load(config_file_path_); }
+  config_data_.population_demographic =
+      config["population_demographic"].as<PopulationDemographic>();
 
-void Config::register_observer(ConfigObserver observer) {
-  std::unique_lock lock(mutex_);
-  observers_.push_back(observer);
+  // Validate all cross field validations
+  validate_all_cross_field_validations();
 }
 
-void Config::notify_observers() {
-  for (const auto &observer : observers_) { observer(config_data_); }
-}
+void Config::reload() { load(config_file_path_); }