From 7479deacbd1e6547675cbc4d64cb45fa532c81e4 Mon Sep 17 00:00:00 2001
From: Arseniy Obolenskiy <gooddoog@student.su>
Date: Fri, 4 Jul 2025 14:23:51 +0200
Subject: [PATCH] refactor: remove global using directives

---
 modules/util/include/func_test_util.hpp | 14 +++++------
 modules/util/include/perf_test_util.hpp | 31 ++++++++++++-------------
 2 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/modules/util/include/func_test_util.hpp b/modules/util/include/func_test_util.hpp
index e43b59e7..5be35e73 100644
--- a/modules/util/include/func_test_util.hpp
+++ b/modules/util/include/func_test_util.hpp
@@ -16,12 +16,10 @@
 #include "task/include/task.hpp"
 #include "util/include/util.hpp"
 
-using namespace ppc::task;
-
 namespace ppc::util {
 
 template <typename InType, typename OutType, typename TestType = void>
-using FuncTestParam = std::tuple<std::function<TaskPtr<InType, OutType>(InType)>, std::string, TestType>;
+using FuncTestParam = std::tuple<std::function<ppc::task::TaskPtr<InType, OutType>(InType)>, std::string, TestType>;
 
 template <typename InType, typename OutType, typename TestType = void>
 using GTestFuncParam = ::testing::TestParamInfo<FuncTestParam<InType, OutType, TestType>>;
@@ -98,7 +96,7 @@ class BaseRunFuncTests : public ::testing::TestWithParam<FuncTestParam<InType, O
   }
 
  private:
-  TaskPtr<InType, OutType> task_;
+  ppc::task::TaskPtr<InType, OutType> task_;
 };
 
 template <typename Tuple, std::size_t... Is>
@@ -115,10 +113,10 @@ auto ExpandToValues(const Tuple& t) {
 template <typename Task, typename InType, typename SizesContainer, std::size_t... Is>
 auto GenTaskTuplesImpl(const SizesContainer& sizes, const std::string& settings_path,
                        std::index_sequence<Is...> /*unused*/) {
-  return std::make_tuple(std::make_tuple(
-      TaskGetter<Task, InType>,
-      std::string(GetNamespace<Task>()) + "_" + GetStringTaskType(Task::GetStaticTypeOfTask(), settings_path),
-      sizes[Is])...);
+  return std::make_tuple(std::make_tuple(ppc::task::TaskGetter<Task, InType>,
+                                         std::string(GetNamespace<Task>()) + "_" +
+                                             ppc::task::GetStringTaskType(Task::GetStaticTypeOfTask(), settings_path),
+                                         sizes[Is])...);
 }
 
 template <typename Task, typename InType, typename SizesContainer>
diff --git a/modules/util/include/perf_test_util.hpp b/modules/util/include/perf_test_util.hpp
index 66afefd1..16f66cfb 100644
--- a/modules/util/include/perf_test_util.hpp
+++ b/modules/util/include/perf_test_util.hpp
@@ -18,17 +18,14 @@
 #include "task/include/task.hpp"
 #include "util/include/util.hpp"
 
-using namespace ppc::task;
-using namespace ppc::performance;
-
 namespace ppc::util {
 
 double GetTimeMPI();
 int GetMPIRank();
 
 template <typename InType, typename OutType>
-using PerfTestParam =
-    std::tuple<std::function<TaskPtr<InType, OutType>(InType)>, std::string, PerfResults::TypeOfRunning>;
+using PerfTestParam = std::tuple<std::function<ppc::task::TaskPtr<InType, OutType>(InType)>, std::string,
+                                 ppc::performance::PerfResults::TypeOfRunning>;
 
 template <typename InType, typename OutType>
 /// @brief Base class for performance testing of parallel tasks.
@@ -38,7 +35,7 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
  public:
   /// @brief Generates a readable name for the performance test case.
   static std::string CustomPerfTestName(const ::testing::TestParamInfo<PerfTestParam<InType, OutType>>& info) {
-    return GetStringParamName(std::get<GTestParamIndex::kTestParams>(info.param)) + "_" +
+    return ppc::performance::GetStringParamName(std::get<GTestParamIndex::kTestParams>(info.param)) + "_" +
            std::get<GTestParamIndex::kNameTest>(info.param);
   }
 
@@ -47,7 +44,7 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
   /// @brief Supplies input data for performance testing.
   virtual InType GetTestInputData() = 0;
 
-  virtual void SetPerfAttributes(PerfAttr& perf_attrs) {
+  virtual void SetPerfAttributes(ppc::performance::PerfAttr& perf_attrs) {
     if (task_->GetDynamicTypeOfTask() == ppc::task::TypeOfTask::kMPI ||
         task_->GetDynamicTypeOfTask() == ppc::task::TypeOfTask::kALL) {
       const double t0 = GetTimeMPI();
@@ -80,13 +77,13 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
     }
 
     task_ = task_getter(GetTestInputData());
-    Perf perf(task_);
-    PerfAttr perf_attr;
+    ppc::performance::Perf perf(task_);
+    ppc::performance::PerfAttr perf_attr;
     SetPerfAttributes(perf_attr);
 
-    if (mode == PerfResults::TypeOfRunning::kPipeline) {
+    if (mode == ppc::performance::PerfResults::TypeOfRunning::kPipeline) {
       perf.PipelineRun(perf_attr);
-    } else if (mode == PerfResults::TypeOfRunning::kTaskRun) {
+    } else if (mode == ppc::performance::PerfResults::TypeOfRunning::kTaskRun) {
       perf.TaskRun(perf_attr);
     } else {
       std::stringstream err_msg;
@@ -103,16 +100,18 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
   }
 
  private:
-  TaskPtr<InType, OutType> task_;
+  ppc::task::TaskPtr<InType, OutType> task_;
 };
 
 template <typename TaskType, typename InputType>
 auto MakePerfTaskTuples(const std::string& settings_path) {
-  const auto name =
-      std::string(GetNamespace<TaskType>()) + "_" + GetStringTaskType(TaskType::GetStaticTypeOfTask(), settings_path);
+  const auto name = std::string(GetNamespace<TaskType>()) + "_" +
+                    ppc::task::GetStringTaskType(TaskType::GetStaticTypeOfTask(), settings_path);
 
-  return std::make_tuple(std::make_tuple(TaskGetter<TaskType, InputType>, name, PerfResults::TypeOfRunning::kPipeline),
-                         std::make_tuple(TaskGetter<TaskType, InputType>, name, PerfResults::TypeOfRunning::kTaskRun));
+  return std::make_tuple(std::make_tuple(ppc::task::TaskGetter<TaskType, InputType>, name,
+                                         ppc::performance::PerfResults::TypeOfRunning::kPipeline),
+                         std::make_tuple(ppc::task::TaskGetter<TaskType, InputType>, name,
+                                         ppc::performance::PerfResults::TypeOfRunning::kTaskRun));
 }
 
 template <typename Tuple, std::size_t... I>