mlMainThreadCommunicator.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
 
#pragma once
 
#include "MLMainThreadCommunicatorSystem.h"
 
#include <FMEThirdPartyWarningsDisable.h>
#include <utility>
#include <mutex>
#include <FMEThirdPartyWarningsRestore.h>
 
// Block warnings since it's not done by background task includes below.
#include <FMEThirdPartyWarningsDisable.h>
#include <mlBackgroundTaskManager.h>
#include <mlBackgroundTaskMethodCallMessage.h>
#include <FMEThirdPartyWarningsRestore.h>
 
 
ML_START_NAMESPACE
 
 
class UnprotectedMainThreadCommunicator : public BackgroundTaskMessageReceiver
{
public:
 
  template <typename Callable>
  void callLater(Callable&& callable)
  {
    auto* message = NewBackgroundTaskMethodCall(this, &UnprotectedMainThreadCommunicator::execute<Callable>, std::forward<Callable>(callable));
    auto& mgr = BackgroundTaskManager::self();
    mgr.sendMessageToGUI(message);
  }
 
  template<typename Callable>
  void call(Callable&& callable)
  {
    if (BackgroundTaskManager::ensureGUIThread()) {
      std::forward<Callable>(callable)();
    }
    else {
      callLater(std::forward<Callable>(callable));
    }
  }
 
  template<typename Object, typename Method, typename... Args>
  void call(Object* object, Method method, const Args&... args)
  {
    call([object, method, args...] {
      (object->*method)(args...);
    });
  }
 
private:
 
  template<typename Callable>
  void execute(const Callable& callable)
  {
    callable();
  }
};
 
 
class MLMAINTHREADCOMMUNICATOR_EXPORT MainThreadCommunicator final
{
  class MLMAINTHREADCOMMUNICATOR_EXPORT Access
  {
  public:
 
    Access(std::mutex& mutex, std::weak_ptr<UnprotectedMainThreadCommunicator> implementation);
 
    operator bool() const;
 
    UnprotectedMainThreadCommunicator* operator->() const;
 
    UnprotectedMainThreadCommunicator& operator*() const;
 
  private:
 
    std::unique_lock<std::mutex> lock;
    std::shared_ptr<UnprotectedMainThreadCommunicator> implementation;
  };
 
  class MLMAINTHREADCOMMUNICATOR_EXPORT Handle
  {
  public:
 
    Handle(std::shared_ptr<std::mutex> mutex, const std::shared_ptr<UnprotectedMainThreadCommunicator>& implementation);
 
    Access access() const;
 
  private:
 
    std::shared_ptr<std::mutex> mutex;
    std::weak_ptr<UnprotectedMainThreadCommunicator> implementation;
  };
 
  MainThreadCommunicator(const MainThreadCommunicator&) = delete;
  MainThreadCommunicator& operator=(const MainThreadCommunicator&) = delete;
 
public:
 
  MainThreadCommunicator();
 
  ~MainThreadCommunicator();
 
  Handle handle() const;
 
private:
 
  std::shared_ptr<std::mutex> mutex;
  std::shared_ptr<UnprotectedMainThreadCommunicator> implementation;
};
 
 
ML_END_NAMESPACE