state.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "irsol/logging.hpp"
#include "irsol/types.hpp"
 
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
 
namespace irsol {
namespace server {
namespace internal {
 
struct GisParams
{
  uint64_t inputSequenceLength{16};
 
  uint64_t inputSequenceNumber{0};
 
  double frameRate{4.0};
};
 
struct FrameListeningState
{
  GisParams gisParams{};
 
  bool running() const;
 
  template<typename Callable>
  void start(Callable&& task, const std::string& description)
  {
    std::scoped_lock<std::mutex> lock(m_threadMutex);
    if(m_running.load()) {
      throw std::logic_error("Thread already running");
    }
 
    IRSOL_LOG_INFO("Locking the running of the thread");
    m_stopRequested = std::make_shared<std::atomic<bool>>(false);
    m_running.store(true);
 
    std::thread([this,
                 stopRequested = m_stopRequested,
                 task          = std::forward<Callable>(task),
                 description]() mutable {
      try {
        IRSOL_LOG_INFO("Inside thread");
        task(stopRequested);
        IRSOL_LOG_INFO("Inside thread, after task execution");
      } catch(...) {
        IRSOL_LOG_ERROR("Background thread for task '{}' failed running.", description);
      }
      m_running.store(false);
    })
      .detach();
 
    IRSOL_LOG_INFO("Thread started");
  }
 
  void stop();
 
private:
  std::atomic<bool> m_running{false};
 
  std::mutex m_threadMutex;
 
  std::shared_ptr<std::atomic<bool>> m_stopRequested;
};
 
struct UserSessionData
{
  FrameListeningState frameListeningState{};
};
 
}  // namespace internal
}  // namespace server
}  // namespace irsol