WorkerBinding.hpp

#pragma once
#include <score/tools/ThreadPool.hpp>
 
#include <avnd/concepts/worker.hpp>
 
#include <memory>
#include <type_traits>
#include <utility>
 
namespace oscr
{
template <typename Object, typename Delivery>
void bind_worker(Object& obj, std::weak_ptr<Object> obj_wp, Delivery deliver)
{
  using worker_type = decltype(obj.worker);
  auto& tq = score::TaskPool::instance();
 
  obj.worker.request = [&tq, obj_wp = std::move(obj_wp),
                        deliver = std::move(deliver)]<typename... Args>(Args&&... f) mutable {
    tq.post([obj_wp, job = deliver.begin(), ... ff = std::forward<Args>(f)]() mutable {
      auto deliver = std::move(job);
      // The object was removed meanwhile: not much reason to perform the work,
      // unless the worker says this job must be done whatever, e.g. a file
      // the object leaves as it stops: static bool must_run(args...).
      bool needed = bool(obj_wp.lock());
      if constexpr(requires { worker_type::must_run(ff...); })
        needed = needed || worker_type::must_run(ff...);
      if(!needed)
        return;
 
      using type_of_result = decltype(worker_type::work(std::forward<decltype(ff)>(ff)...));
      if constexpr(std::is_void_v<type_of_result>)
      {
        worker_type::work(std::forward<decltype(ff)>(ff)...);
      }
      else
      {
        auto res = worker_type::work(std::forward<decltype(ff)>(ff)...);
        if(!res)
          return;
 
        // res is mutable so that it can e.g. keep data to free elsewhere.
        deliver([obj_wp = std::move(obj_wp), res = std::move(res)]() mutable {
          if(auto o = obj_wp.lock())
            res(*o);
        });
      }
    });
  };
}
}