Refactor .clang-tidy configuration and codebase for consistency and readability improvements

- Updated .clang-tidy configuration:
  - Added more checks such as google-*, misc-*, cert-*, and
clang-analyzer-*.
  - Disabled specific checks like performance-unnecessary-value-param
and modernize-use-trailing-return-type for better project relevance.
  - Replaced invalid `snake_case` with `lower_case` for
readability-identifier-naming.
  - Improved formatting and removed redundancy in check options.

- Refactored `Config` and `Model` classes:
  - Standardized function names to use `lower_case` for consistency
across the project.
  - Deleted copy and move constructors for the `Config` class to ensure
immutability.

- Updated `Random` utility class:
  - Replaced `using namespace Utils` with `using utils::Random` to avoid
namespace pollution.
  - Updated template assertions to use `std::is_arithmetic_v<T>` for
better modern C++ practices.
  - Applied consistent function naming and code clean-up.

- Applied consistent naming conventions in tests and across namespaces
(`Utils` to `utils`).

Author: merlinvn

.clang-tidy

@@ -1,16 +1,28 @@
 Checks: >
-  -*,
-  bugprone-*,             # Enable bug-prone checks
-  cppcoreguidelines-*,    # Enable C++ Core Guidelines checks
-  modernize-*,            # Enable modernization checks
-  readability-*,          # Enable readability checks
-  performance-*           # Enable performance checks
-
-# Optionally, disable specific checks that are not relevant
-# For example, if you don't use certain C++ features or have specific project constraints
-# -*.fuchsia-*
-# -*.llvmlibc-*
-# -*.llvm-*
+  cppcoreguidelines-*,
+  performance-*,
+  modernize-*,
+  google-*,
+  misc-*
+  cert-*,
+  readability-*,
+  clang-analyzer-*,
+  -performance-unnecessary-value-param,
+  -modernize-use-trailing-return-type,
+  -google-runtime-references,
+  -misc-non-private-member-variables-in-classes,
+  -readability-braces-around-statements,
+  -google-readability-braces-around-statements,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -readability-magic-numbers,
+  -readability-magic-numbers,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-avoid-c-arrays,
+  -modernize-avoid-c-arrays,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -readability-named-parameter,
+  -cert-env33-c
 
 WarningsAsErrors: "*"
 
@@ -25,13 +37,10 @@ CheckOptions:
 
   # Naming Conventions
   # Namespaces
-  - { key: readability-identifier-naming.NamespaceCase, value: snake_case }
+  - { key: readability-identifier-naming.NamespaceCase, value: lower_case }
 
   # Macros
-  - {
-      key: readability-identifier-naming.MacroDefinitionCase,
-      value: UPPER_CASE,
-    }
+  - { key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }
 
   # Types
   - { key: readability-identifier-naming.ClassCase, value: CamelCase }
@@ -43,48 +52,35 @@ CheckOptions:
   - { key: readability-identifier-naming.UnionCase, value: CamelCase }
 
   # Functions
-  - { key: readability-identifier-naming.FunctionCase, value: snake_case }
-  - { key: readability-identifier-naming.GlobalFunctionCase, value: snake_case }
+  - { key: readability-identifier-naming.FunctionCase, value: lower_case }
+  - { key: readability-identifier-naming.GlobalFunctionCase, value: lower_case }
 
   # Variables
-  - { key: readability-identifier-naming.GlobalVariableCase, value: snake_case }
-  - { key: readability-identifier-naming.LocalVariableCase, value: snake_case }
-  - { key: readability-identifier-naming.ParameterCase, value: snake_case }
+  - { key: readability-identifier-naming.GlobalVariableCase, value: lower_case }
+  - { key: readability-identifier-naming.LocalVariableCase, value: lower_case }
+  - { key: readability-identifier-naming.ParameterCase, value: lower_case }
 
   # Class Members and Methods
-  - { key: readability-identifier-naming.ClassMemberCase, value: snake_case_ }
-  - { key: readability-identifier-naming.ClassMethodCase, value: snake_case }
-
-  # General Methods
-  - { key: readability-identifier-naming.MethodCase, value: snake_case }
-  - { key: readability-identifier-naming.PrivateMethodCase, value: snake_case }
+  - { key: readability-identifier-naming.ClassMemberCase, value: lower_case_ }
+  - { key: readability-identifier-naming.ClassMethodCase, value: lower_case }
+  - { key: readability-identifier-naming.PrivateMethodCase, value: lower_case }
 
   # Members
-  - { key: readability-identifier-naming.MemberCase, value: snake_case_ }
-  - { key: readability-identifier-naming.PrivateMemberCase, value: snake_case_ }
+  - { key: readability-identifier-naming.MemberCase, value: lower_case_ }
+  - { key: readability-identifier-naming.PrivateMemberCase, value: lower_case_ }
   - { key: readability-identifier-naming.PrivateMemberSuffix, value: "_" }
 
   # Variables
-  - { key: readability-identifier-naming.VariableCase, value: snake_case }
-  - { key: readability-identifier-naming.StaticVariableCase, value: snake_case }
-  - {
-      key: readability-identifier-naming.ConstexprVariableCase,
-      value: UPPER_CASE,
-    }
+  - { key: readability-identifier-naming.VariableCase, value: lower_case }
+  - { key: readability-identifier-naming.StaticVariableCase, value: lower_case }
+  - { key: readability-identifier-naming.ConstexprVariableCase, value: UPPER_CASE }
 
   # Constants
   - { key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE }
   - { key: readability-identifier-naming.MemberConstantCase, value: UPPER_CASE }
   - { key: readability-identifier-naming.StaticConstantCase, value: UPPER_CASE }
 
   # Template Parameters
-  - {
-      key: readability-identifier-naming.TemplateParameterCase,
-      value: CamelCase,
-    }
-
+  - { key: readability-identifier-naming.TemplateParameterCase, value: CamelCase }
   # Magic Numbers
-  - {
-      key: readability-magic-numbers.IgnoredIntegerValues,
-      value: "-1;0;1;2;3;4;5;10;100",
-}
+  - { key: readability-magic-numbers.IgnoredIntegerValues, value: "-1;0;1;2;3;4;5;10;100" }

src/Configuration/Config.cpp

@@ -7,7 +7,7 @@
 
 #include "YAMLConverters.h"
 
-void Config::Load(const std::string &filename) {
+void Config::load(const std::string &filename) {
   std::shared_lock lock(mutex_);
   config_file_path_ = filename;
   YAML::Node config = YAML::LoadFile(filename);
@@ -16,17 +16,17 @@ void Config::Load(const std::string &filename) {
       config["TransmissionSettings"].as<TransmissionSettings>();
   config_data_.population_demographic =
       config["PopulationDemographic"].as<PopulationDemographic>();
-  NotifyObservers();
+  notify_observers();
 }
 
-void Config::Reload() { Load(config_file_path_); }
+void Config::reload() { load(config_file_path_); }
 
-void Config::RegisterObserver(ConfigObserver observer) {
+void Config::register_observer(ConfigObserver observer) {
   std::unique_lock lock(mutex_);
   observers_.push_back(observer);
 }
 
-void Config::NotifyObservers() {
+void Config::notify_observers() {
   for (const auto &observer : observers_) { observer(config_data_); }
 }
 

src/Configuration/Config.h

@@ -7,6 +7,7 @@
 
 #include <functional>
 #include <shared_mutex>
+#include <string>
 #include <vector>
 
 #include "ConfigData.h"
@@ -23,18 +24,24 @@ class Config {
   Config() = default;
   ~Config() = default;
 
+  // delete copy and move constructors and assign operators
+  Config(const Config &) = delete;
+  Config &operator=(const Config &) = delete;
+  Config(Config &&) = delete;
+  Config &operator=(Config &&) = delete;
+
   // Load configuration from a YAML file
-  void Load(const std::string &filename);
+  void load(const std::string &filename);
 
   // Reload configuration (useful for dynamic updates)
-  void Reload();
+  void reload();
 
   // Register an observer for configuration changes
-  void RegisterObserver(ConfigObserver observer);
+  void register_observer(ConfigObserver observer);
 
 private:
   // Internal Method to Notify Observers
-  void NotifyObservers();
+  void notify_observers();
 
   // Configuration Data
   ConfigData config_data_;

src/Simulation/Model.cpp

@@ -14,13 +14,13 @@ Model::Model()
   // Initialization is deferred to the Initialize() method
 }
 
-void Model::Initialize() {
+void Model::initialize() {
   if (!config_file_path_.empty()) {
     // Load the configuration file
-    config_->Load(config_file_path_);
+    config_->load(config_file_path_);
 
     // Register an observer to handle dynamic configuration changes
-    config_->RegisterObserver([this](const ConfigData &new_config) {
+    config_->register_observer([this](const ConfigData &new_config) {
       // Handle configuration changes, e.g., adjust simulation parameters
       std::cout << "Model received updated configuration.\n";
       // Update internal state based on new_config if necessary
@@ -36,15 +36,15 @@ void Model::Initialize() {
   }
 }
 
-void Model::Run() {
+void Model::run() const {
   if (!is_initialized_) {
     throw std::runtime_error(
         "Model is not initialized. Call Initialize() first.");
   }
   // Simulation run code
 }
 
-void Model::Finalize() {
+void Model::finalize() {
   if (!is_initialized_) {
     throw std::runtime_error("Model is not initialized or already finalized.");
   }

src/Simulation/Model.h

@@ -10,22 +10,22 @@ class Config;
 class Model {
 public:
   // Provides global access to the singleton instance
-  static Model &Instance() {
+  static Model &instance() {
     static Model instance;
     return instance;
   }
 
   // Initialize the model
-  void Initialize();
+  void initialize();
 
   // Run the simulation
-  void Run();
+  void run() const;
 
   // Finalize and clean up resources
-  void Finalize();
+  void finalize();
 
   // Access configuration in a controlled manner
-  const Config* GetConfig() const {
+  [[nodiscard]] const Config* get_config() const {
     if (!config_) {
       throw std::runtime_error(
           "Model not initialized. Call Initialize() first.");

src/Utils/Random.cpp

@@ -15,7 +15,7 @@
 #include <stdexcept>
 #include <vector>
 
-using namespace Utils;
+using utils::Random;
 
 // Constructor
 Random::Random(gsl_rng* rng, uint64_t seed) : seed_(seed) {
@@ -62,11 +62,11 @@ void Random::set_seed(uint64_t new_seed) {
 }
 
 // Generates a Poisson-distributed random number
-int Random::random_poisson(double poissonMean) {
+int Random::random_poisson(double poisson_mean) {
   if (!rng_) {
     throw std::runtime_error("Random number generator not initialized.");
   }
-  return static_cast<int>(gsl_ran_poisson(rng_.get(), poissonMean));
+  return static_cast<int>(gsl_ran_poisson(rng_.get(), poisson_mean));
 }
 
 // Generates a uniform random integer in [0, range)

src/Utils/Random.h

@@ -12,7 +12,7 @@
 #include <memory>
 #include <vector>
 
-namespace Utils {
+namespace utils {
 /**
  * @class Random
  * @brief Encapsulates random number generation functionalities using GSL.
@@ -120,7 +120,7 @@ class Random {
    */
   template <typename T>
   T random_uniform(T from, T to) {
-    static_assert(std::is_arithmetic<T>::value,
+    static_assert(std::is_arithmetic_v<T>,
                   "Template parameter T must be numeric.");
 
     if (!rng_) {
@@ -131,14 +131,14 @@ class Random {
       throw std::invalid_argument("Parameter 'from' must be less than 'to'.");
     }
 
-    if constexpr (std::is_integral<T>::value) {
+    if constexpr (std::is_integral_v<T>) {
       // gsl_rng_uniform_int takes an unsigned long as upper bound
       // Ensure that (to - from) does not exceed the maximum value of unsigned
       // long
-      unsigned long range = static_cast<unsigned long>(to - from);
+      auto range = static_cast<uint64_t>(to - from);
       // Note: gsl_rng_uniform_int handles range values up to the maximum of
       // unsigned long
-      unsigned long value = gsl_rng_uniform_int(rng_.get(), range);
+      uint64_t value = gsl_rng_uniform_int(rng_.get(), range);
       return static_cast<T>(from + value);
     } else {
       double value = gsl_ran_flat(rng_.get(), static_cast<double>(from),
@@ -161,7 +161,7 @@ class Random {
    */
   template <typename T>
   T random_normal(T mean, double standard_deviation) {
-    static_assert(std::is_arithmetic<T>::value,
+    static_assert(std::is_arithmetic_v<T>,
                   "Template parameter T must be numeric.");
 
     if (!rng_) {
@@ -174,7 +174,7 @@ class Random {
     }
     double value = mean + gsl_ran_gaussian(rng_.get(), standard_deviation);
 
-    if constexpr (std::is_integral<T>::value) {
+    if constexpr (std::is_integral_v<T>) {
       return static_cast<T>(std::round(value));
     } else {
       return static_cast<T>(value);
@@ -207,7 +207,7 @@ class Random {
   T random_normal_truncated(T mean, double standard_deviation,
                             double truncation_limit = 3.0,  // NOLINT
                             int max_attempts = 1000) {
-    static_assert(std::is_arithmetic<T>::value,
+    static_assert(std::is_arithmetic_v<T>,
                   "Template parameter T must be numeric.");
     if (!rng_) {
       throw std::runtime_error("Random number generator not initialized.");
@@ -222,7 +222,7 @@ class Random {
       }
       value = gsl_ran_gaussian(rng_.get(), standard_deviation);
     }
-    if constexpr (std::is_integral<T>::value) {
+    if constexpr (std::is_integral_v<T>) {
       return static_cast<T>(mean + std::round(value));
     } else {
       return static_cast<T>(mean + value);
@@ -386,6 +386,6 @@ class Random {
    */
   void initialize(uint64_t initial_seed = 0);
 };
-}  // namespace Utils
+}  // namespace utils
 #endif  // RANDOM_H
 

tests/Core/Random/RandomTestBase.h

@@ -10,7 +10,7 @@
 // Test fixture for Random class
 class RandomTest : public ::testing::Test {
 protected:
-  Utils::Random rng;
+  utils::Random rng;
   void SetUp() override {
     // Optional: Initialize any shared resources
   }

tests/Core/Random/RandomTest_base.cpp

@@ -2,8 +2,9 @@
 #include <gtest/gtest.h>
 
 #include "RandomTestBase.h"
+#include "Utils/Random.h"
 
-using namespace Utils;
+using utils::Random;
 // Test default constructor initializes RNG
 TEST_F(RandomTest, DefaultConstructorInitializesRNG) {
   Random const rng;