Line data    Source code

       1             : // SPDX-FileCopyrightText: 2024 PairInteraction Developers
       2             : // SPDX-License-Identifier: LGPL-3.0-or-later
       3             : 
       4             : #include "pairinteraction/utils/TaskControl.hpp"
       5             : 
       6             : #include <atomic>
       7             : #include <mutex>
       8             : 
       9             : namespace pairinteraction {
      10             : namespace {
      11             : 
      12      122135 : std::atomic_bool &task_abort_requested() {
      13             :     static std::atomic_bool value{false};
      14      122135 :     return value;
      15             : }
      16             : 
      17      121844 : std::mutex &task_info_mutex() {
      18             :     static std::mutex value;
      19      121844 :     return value;
      20             : }
      21             : 
      22      122138 : std::string &task_info() {
      23      122138 :     static std::string value;
      24      122138 :     return value;
      25             : }
      26             : 
      27         636 : std::atomic<std::size_t> &progress_count() {
      28             :     static std::atomic<std::size_t> value{0};
      29         636 :     return value;
      30             : }
      31             : 
      32             : } // namespace
      33             : 
      34           0 : TaskAbortedError::TaskAbortedError() : std::runtime_error("Task aborted.") {}
      35             : 
      36           0 : void request_task_abort() noexcept { task_abort_requested().store(true); }
      37             : 
      38          32 : void reset_task_status() noexcept {
      39          32 :     task_abort_requested().store(false);
      40          32 :     progress_count().store(0);
      41          32 :     std::scoped_lock lock(task_info_mutex());
      42          32 :     task_info().clear();
      43          32 : }
      44             : 
      45           2 : std::string get_task_info() {
      46           2 :     std::scoped_lock lock(task_info_mutex());
      47           4 :     return task_info();
      48           2 : }
      49             : 
      50      121973 : void set_task_status(std::string_view status_message, bool increase_progress_count) {
      51      121973 :     if (!status_message.empty()) {
      52      121835 :         std::scoped_lock lock(task_info_mutex());
      53      122104 :         task_info().assign(status_message);
      54      122104 :     }
      55      122087 :     if (increase_progress_count) {
      56         602 :         progress_count().fetch_add(1);
      57             :     }
      58      122087 :     if (task_abort_requested().load()) {
      59           0 :         throw TaskAbortedError();
      60             :     }
      61      122098 : }
      62             : 
      63           4 : std::size_t get_progress_count() noexcept { return progress_count().load(); }
      64             : 
      65             : } // namespace pairinteraction