Address clang-tidy-21 remarks

Author: aobolensk

.clang-tidy

@@ -36,6 +36,7 @@ Checks: >
   -misc-non-private-member-variables-in-classes,
   -modernize-avoid-c-arrays,
   -modernize-use-trailing-return-type,
+  -portability-avoid-pragma-once,
   -portability-template-virtual-member-function,
   -readability-magic-numbers
 

modules/performance/include/performance.hpp

@@ -30,7 +30,8 @@ struct PerfAttr {
 struct PerfResults {
   /// @brief Measured execution time in seconds.
   double time_sec = 0.0;
-  enum TypeOfRunning : uint8_t { kPipeline, kTaskRun, kNone } type_of_running = kNone;
+  enum class TypeOfRunning : uint8_t { kPipeline, kTaskRun, kNone };
+  TypeOfRunning type_of_running = TypeOfRunning::kNone;
   constexpr static double kMaxTime = 10.0;
 };
 
@@ -116,10 +117,10 @@ class Perf {
 };
 
 inline std::string GetStringParamName(PerfResults::TypeOfRunning type_of_running) {
-  if (type_of_running == PerfResults::kTaskRun) {
+  if (type_of_running == PerfResults::TypeOfRunning::kTaskRun) {
     return "task_run";
   }
-  if (type_of_running == PerfResults::kPipeline) {
+  if (type_of_running == PerfResults::TypeOfRunning::kPipeline) {
     return "pipeline";
   }
   return "none";

modules/task/include/task.hpp

@@ -20,7 +20,7 @@ namespace ppc::task {
 
 /// @brief Represents the type of task (parallelization technology).
 /// @details Used to select the implementation type in tests and execution logic.
-enum TypeOfTask : uint8_t {
+enum class TypeOfTask : uint8_t {
   /// Use all available implementations
   kALL,
   /// MPI (Message Passing Interface)
@@ -57,7 +57,7 @@ inline std::string TypeOfTaskToString(TypeOfTask type) {
 }
 
 /// @brief Indicates whether a task is enabled or disabled.
-enum StatusOfTask : uint8_t {
+enum class StatusOfTask : uint8_t {
   /// Task is enabled and should be executed
   kEnabled,
   /// Task is disabled and will be skipped
@@ -68,7 +68,7 @@ enum StatusOfTask : uint8_t {
 /// @param status_of_task Task status (enabled or disabled).
 /// @return "enabled" if the task is enabled, otherwise "disabled".
 inline std::string GetStringTaskStatus(StatusOfTask status_of_task) {
-  if (status_of_task == kDisabled) {
+  if (status_of_task == StatusOfTask::kDisabled) {
     return "disabled";
   }
   return "enabled";
@@ -96,7 +96,7 @@ inline std::string GetStringTaskType(TypeOfTask type_of_task, const std::string
   return type_str + "_" + std::string((*list_settings)["tasks"][type_str]);
 }
 
-enum StateOfTesting : uint8_t { kFunc, kPerf };
+enum class StateOfTesting : uint8_t { kFunc, kPerf };
 
 template <typename InType, typename OutType>
 /// @brief Base abstract class representing a generic task with a defined pipeline.
@@ -257,9 +257,9 @@ class Task {
  private:
   InType input_{};
   OutType output_{};
-  StateOfTesting state_of_testing_ = kFunc;
-  TypeOfTask type_of_task_ = kUnknown;
-  StatusOfTask status_of_task_ = kEnabled;
+  StateOfTesting state_of_testing_ = StateOfTesting::kFunc;
+  TypeOfTask type_of_task_ = TypeOfTask::kUnknown;
+  StatusOfTask status_of_task_ = StatusOfTask::kEnabled;
   std::chrono::high_resolution_clock::time_point tmp_time_point_;
   enum class PipelineStage : uint8_t {
     kNone,

modules/util/include/util.hpp

@@ -53,7 +53,7 @@ class DestructorFailureFlag {
   inline static std::atomic<bool> failure_flag{false};
 };
 
-enum GTestParamIndex : uint8_t { kTaskGetter, kNameTest, kTestParams };
+enum class GTestParamIndex : uint8_t { kTaskGetter, kNameTest, kTestParams };
 
 std::string GetAbsoluteTaskPath(const std::string& id_path, const std::string& relative_path);
 int GetNumThreads();
@@ -70,7 +70,7 @@ std::string GetNamespace() {
                                                    std::free};
   name = (status == 0) ? demangled.get() : name;
 #endif
-#if defined(_MSC_VER)
+#ifdef _MSC_VER
   const std::string prefixes[] = {"class ", "struct ", "enum ", "union "};
   for (const auto& prefix : prefixes) {
     if (name.starts_with(prefix)) {