ThreadRelay.h

Go to the documentation of this file.

#pragma once
#include <atomic>
#include <misc/gen/Semaphore.h>
#include <misc/gen/Sync.h>
#include <misc/gen/Thread.h>
#include <misc/global.h>
 
namespace sf
{
 
class _MISC_CLASS ThreadRelay : public Sync
{
  public:
    ThreadRelay();
 
    int checkForWork();
 
    void makeOwner(Thread::id_type threadId = 0);
 
    class _MISC_CLASS RelayBase
    {
      public:
        inline explicit RelayBase(ThreadRelay& tr);
 
        virtual ~RelayBase() = default;
 
        virtual void call() = 0;
 
        explicit operator bool();
 
      protected:
        std::atomic<bool> _sentry{false};
        ThreadRelay& _tr;
        Semaphore _semaphore;
 
        friend ThreadRelay;
    };
 
    template<typename ClassType, typename MethodType, typename Ret>
    class Relay0 final : public RelayBase
    {
      public:
        Relay0(ThreadRelay& tr, ClassType* cls, MethodType mtd, Ret& ret)
          : RelayBase(tr)
          , _cls(cls)
          , _mtd(mtd)
          , _ret(ret)
        {}
 
      private:
        void call() override
        {
          _ret = ((*_cls).*static_cast<Ret (ClassType::*)()>(_mtd))();
        }
 
        ClassType* _cls;
        MethodType _mtd;
        Ret& _ret;
    };
 
    template<typename ClassType, typename MethodType, typename Ret, typename Arg1>
    class Relay1 : public RelayBase
    {
      public:
        Relay1(ThreadRelay& tr, ClassType* cls, MethodType mtd, Ret& ret, Arg1& arg1)
          : RelayBase(tr)
          , _cls(cls)
          , _mtd(mtd)
          , _ret(ret)
          , _arg1(arg1)
        {}
 
      private:
        void call() override
        {
          _ret = ((*_cls).*static_cast<Ret (ClassType::*)(Arg1)>(_mtd))(_arg1);
        }
 
        ClassType* _cls;
        MethodType _mtd;
        Ret& _ret;
        Arg1& _arg1;
    };
 
    template<typename ClassType, typename MethodType, typename Ret, typename Arg1, typename Arg2>
    class Relay2 : public RelayBase
    {
      public:
        Relay2(ThreadRelay& tr, ClassType* cls, MethodType mtd, Ret& ret, Arg1& arg1, Arg2& arg2)
          : RelayBase(tr)
          , _cls(cls)
          , _mtd(mtd)
          , _ret(ret)
          , _arg1(arg1)
          , _arg2(arg2)
        {}
 
      private:
        void call() override
        {
          _ret = ((*_cls).*static_cast<Ret (ClassType::*)(Arg1, Arg2)>(_mtd))(_arg1, _arg2);
        }
 
        ClassType* _cls;
        MethodType _mtd;
        Ret& _ret;
        Arg1& _arg1;
        Arg2& _arg2;
    };
 
    template<typename ClassType, typename MethodType, typename Ret, typename Arg1, typename Arg2, typename Arg3>
    class Relay3 : public RelayBase
    {
      public:
        Relay3(ThreadRelay& tr, ClassType* cls, MethodType mtd, Ret& ret, Arg1& arg1, Arg2& arg2, Arg3& arg3)
          : RelayBase(tr)
          , _cls(cls)
          , _mtd(mtd)
          , _ret(ret)
          , _arg1(arg1)
          , _arg2(arg2)
          , _arg3(arg3)
        {}
 
      private:
        void call() override
        {
          _ret = ((*_cls).*static_cast<Ret (ClassType::*)(Arg1, Arg2, Arg3)>(_mtd))(_arg1, _arg2, _arg3);
        }
 
        ClassType* _cls;
        MethodType _mtd;
        Ret& _ret;
        Arg1& _arg1;
        Arg2& _arg2;
        Arg3& _arg3;
    };
 
    template<typename ClassType, typename MethodType, typename Ret, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
    class Relay4 final : public RelayBase
    {
      public:
        Relay4(ThreadRelay& tr, ClassType* cls, MethodType mtd, Ret& ret, Arg1& arg1, Arg2& arg2, Arg3& arg3, Arg4& arg4)
          : RelayBase(tr)
          , _cls(cls)
          , _mtd(mtd)
          , _ret(ret)
          , _arg1(arg1)
          , _arg2(arg2)
          , _arg3(arg3)
          , _arg4(arg4)
        {}
 
      private:
        void call() override
        {
          _ret = ((*_cls).*static_cast<Ret (ClassType::*)(Arg1, Arg2, Arg3, Arg4)>(_mtd))(_arg1, _arg2, _arg3, _arg4);
        }
 
        ClassType* _cls;
        MethodType _mtd;
        Ret& _ret;
        Arg1& _arg1;
        Arg2& _arg2;
        Arg3& _arg3;
        Arg4& _arg4;
    };
 
  private:
    // Thread in which the methods are called to be called in.
    Thread::id_type _threadId;
    // List containing the instance waiting to be called.
    std::vector<RelayBase*> _list{};
};
 
inline ThreadRelay::RelayBase::RelayBase(ThreadRelay& tr)
  : _tr(tr)
{}
 
}// namespace sf