Merge pull request #1091 from PowerGridModel/feature/rename-job-dispatch-classes

Clean-up main model: Rename job dispatch-related classes

Author: mgovers

power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -15,24 +15,24 @@
 
 namespace power_grid_model {
 
-template <class MainModel, typename... ComponentType> class JobDispatchAdapter;
+template <class MainModel, typename... ComponentType> class JobAdapter;
 
 template <class MainModel, class... ComponentType>
-class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
-    : public JobDispatchInterface<JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>> {
+class JobAdapter<MainModel, ComponentList<ComponentType...>>
+    : public JobInterface<JobAdapter<MainModel, ComponentList<ComponentType...>>> {
   public:
-    JobDispatchAdapter(std::reference_wrapper<MainModel> model_reference,
-                       std::reference_wrapper<MainModelOptions const> options)
+    JobAdapter(std::reference_wrapper<MainModel> model_reference,
+               std::reference_wrapper<MainModelOptions const> options)
         : model_reference_{model_reference}, options_{options} {}
-    JobDispatchAdapter(JobDispatchAdapter const& other)
+    JobAdapter(JobAdapter const& other)
         : model_copy_{std::make_unique<MainModel>(other.model_reference_.get())},
           model_reference_{std::ref(*model_copy_)},
           options_{std::ref(other.options_)},
           components_to_update_{other.components_to_update_},
           update_independence_{other.update_independence_},
           independence_flags_{other.independence_flags_},
           all_scenarios_sequence_{other.all_scenarios_sequence_} {}
-    JobDispatchAdapter& operator=(JobDispatchAdapter const& other) {
+    JobAdapter& operator=(JobAdapter const& other) {
         if (this != &other) {
             model_copy_ = std::make_unique<MainModel>(other.model_reference_.get());
             model_reference_ = std::ref(*model_copy_);
@@ -44,15 +44,15 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
         }
         return *this;
     }
-    JobDispatchAdapter(JobDispatchAdapter&& other) noexcept
+    JobAdapter(JobAdapter&& other) noexcept
         : model_copy_{std::move(other.model_copy_)},
           model_reference_{model_copy_ ? std::ref(*model_copy_) : std::move(other.model_reference_)},
           options_{other.options_},
           components_to_update_{std::move(other.components_to_update_)},
           update_independence_{std::move(other.update_independence_)},
           independence_flags_{std::move(other.independence_flags_)},
           all_scenarios_sequence_{std::move(other.all_scenarios_sequence_)} {}
-    JobDispatchAdapter& operator=(JobDispatchAdapter&& other) noexcept {
+    JobAdapter& operator=(JobAdapter&& other) noexcept {
         if (this != &other) {
             model_copy_ = std::move(other.model_copy_);
             model_reference_ = model_copy_ ? std::ref(*model_copy_) : std::move(other.model_reference_);
@@ -64,13 +64,13 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
         }
         return *this;
     }
-    ~JobDispatchAdapter() { model_copy_.reset(); }
+    ~JobAdapter() { model_copy_.reset(); }
 
   private:
-    // Grant the CRTP base (JobDispatchInterface<JobDispatchAdapter>) access to
-    // JobDispatchAdapter's private members. This allows the base class template
+    // Grant the CRTP base (JobInterface<JobAdapter>) access to
+    // JobAdapter's private members. This allows the base class template
     // to call derived-class implementation details as part of the CRTP pattern.
-    friend class JobDispatchInterface<JobDispatchAdapter>;
+    friend class JobInterface<JobAdapter>;
 
     std::unique_ptr<MainModel> model_copy_;
     std::reference_wrapper<MainModel> model_reference_;

power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp

@@ -19,7 +19,7 @@ class JobDispatch {
 
     // TODO(figueroa1395): add generic template parameters for update_data and result_data
     template <typename Adapter, typename ResultDataset, typename UpdateDataset>
-        requires std::is_base_of_v<JobDispatchInterface<Adapter>, Adapter>
+        requires std::is_base_of_v<JobInterface<Adapter>, Adapter>
     static BatchParameter batch_calculation(Adapter& adapter, ResultDataset const& result_data,
                                             UpdateDataset const& update_data, Idx threading = sequential) {
         if (update_data.empty()) {

power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -15,7 +15,7 @@
 #include <utility>
 
 namespace power_grid_model {
-template <typename Adapter> class JobDispatchInterface {
+template <typename Adapter> class JobInterface {
   public:
     // the multiple  NOSONARs are used to avoid the complaints about the unnamed concepts
     template <typename ResultDataset>
@@ -79,12 +79,12 @@ template <typename Adapter> class JobDispatchInterface {
 
   protected:
     // Protected & defaulted special members — CRTP: only the derived can create/copy/move this base
-    JobDispatchInterface() = default;
-    JobDispatchInterface(const JobDispatchInterface& /*other*/) = default;
-    JobDispatchInterface& operator=(const JobDispatchInterface& /*other*/) = default;
-    JobDispatchInterface(JobDispatchInterface&& /*other*/) noexcept = default;
-    JobDispatchInterface& operator=(JobDispatchInterface&& /*other*/) noexcept = default;
-    ~JobDispatchInterface() = default;
+    JobInterface() = default;
+    JobInterface(const JobInterface& /*other*/) = default;
+    JobInterface& operator=(const JobInterface& /*other*/) = default;
+    JobInterface(JobInterface&& /*other*/) noexcept = default;
+    JobInterface& operator=(JobInterface&& /*other*/) noexcept = default;
+    ~JobInterface() = default;
 };
 
 } // namespace power_grid_model

power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp

@@ -78,7 +78,7 @@ class MainModel {
     */
     BatchParameter calculate(Options const& options, MutableDataset const& result_data,
                              ConstDataset const& update_data) {
-        JobDispatchAdapter<Impl, AllComponents> adapter{std::ref(impl()), std::ref(options)};
+        JobAdapter<Impl, AllComponents> adapter{std::ref(impl()), std::ref(options)};
         return JobDispatch::batch_calculation(adapter, result_data, update_data, options.threading);
     }