qt-migration-legatus/qt5-before/dlbo/TetraIF/PrtCnv/PrtCnvInjectionThread.cpp

// **************************************************************************
//
//  (C) Copyright 2009   Swiss SIMTEC AG
//
// **************************************************************************
//
//  $HeadURL$
//  $LastChangedBy$
//  $LastChangedDate$
//  $LastChangedRevision$
//
// **************************************************************************

// manual class headers
#include "PrtCnvInjectionThread.hpp"
#include "PrtCnvInjectionSocket.hpp"

#include <QtNetwork/QTcpServer>
#include <QtNetwork/QTcpSocket>
#include <QtCore/QMutex>
#include <nglsettings/nglsettings_settings.h>


namespace PrtCnv
{
// ---------------------------------------------------------------
PrtCnvInjectionThread::PrtCnvInjectionThread(PrtCnvThreadStarter* a_parent)
  : PrtCnvThread(a_parent, "PrtCnvInjectionThread")
  , m_Port(46666)
  , m_Enabled(false)
  , m_Server(nullptr)
  , m_CentralListMutex(nullptr)
  , m_RadioListMutex(nullptr)
{
  m_Name = QStringLiteral("Injection");
}

PrtCnvInjectionThread::~PrtCnvInjectionThread()
{
  delete m_CentralListMutex;
  delete m_RadioListMutex;
}

// ---------------------------------------------------------------
int32_t PrtCnvInjectionThread::create(NGL::Settings *settings)
{
  INFO_LOG(m_logger) << "create";
  PrtCnvThread::create(settings);

  m_CentralListMutex = new QMutex;
  m_RadioListMutex = new QMutex;

  m_Enabled = m_Config->getBoolean(getName(), QStringLiteral("Enable"), false);

  // prepare a tcp-server for simulating central
  if (m_Enabled)
  {
    m_Server = new QTcpServer(this);
    if (m_Server)
      connect(m_Server, &QTcpServer::newConnection, this, &PrtCnvInjectionThread::connectClient, Qt::QueuedConnection);
  }

  return 0;
}


// ---------------------------------------------------------------
int32_t PrtCnvInjectionThread::init()
{
  INFO_LOG(m_logger) << "init";
  PrtCnvThread::init();
  m_Port = m_Config->getInteger(getName(), QStringLiteral("Port"), 46666);

  return 0;
}



// ---------------------------------------------------------------
// Starts the thread and listen for TCP-clients
// ---------------------------------------------------------------
int32_t PrtCnvInjectionThread::start()
{
  INFO_LOG(m_logger) << "Start";
  PrtCnvThread::start();

  // start the TCP-server
  if (m_Enabled)
  {
    m_Server->setMaxPendingConnections(1);
    m_Server->listen(QHostAddress::Any, m_Port);
    INFO_LOG(m_logger) << "Injection-Server is listening on port " << m_Port;
  }

  return 0;
}



// ---------------------------------------------------------------
// Connects a TCP-client
// ---------------------------------------------------------------
void PrtCnvInjectionThread::connectClient()
{
  INFO_LOG(m_logger) << "A client has connected to the injection-server";
  PrtCnvInjectionSocket* injectSocket = new PrtCnvInjectionSocket;
  m_SocketList.insert(injectSocket);
  INFO_LOG(m_logger) << "Now are " << m_SocketList.size() << " injection-client(s) connected";
  injectSocket->setSocket(m_Server->nextPendingConnection(), this);
}



// ---------------------------------------------------------------
// Disconnects a TCP-client
// ---------------------------------------------------------------
void PrtCnvInjectionThread::disconnectClient(PrtCnvInjectionSocket *a_injectionSocket)
{
  auto it = m_SocketList.find(a_injectionSocket);
  if (it != m_SocketList.end())
    m_SocketList.erase(it);
  INFO_LOG(m_logger) << "Now are " << m_SocketList.size() << " injection-client(s) connected";
  delete a_injectionSocket;
}



// ---------------------------------------------------------------
// Returns the next central-telegram to be injected. It will
// automatically be taken out of the list.
// The caller is responsible to delete the telegram, if no
// longer used.
// Returns NULL if no central-telegram available
// ---------------------------------------------------------------
N_CoPrtCnv::CoPrtCnvCentralTelegram *PrtCnvInjectionThread::getNextCentralInjectionTelegram()
{
  QMutexLocker l(m_CentralListMutex);

  if (m_CentralTelegramList.empty())
    return nullptr;
  auto centralTelegram = m_CentralTelegramList.front();
  m_CentralTelegramList.pop();
  return centralTelegram;
}


// ---------------------------------------------------------------
// Returns the next radio-telegram to be injected. It will
// automatically be taken out of the list.
// The caller is responsible to delete the telegram, if no
// longer used.
// Returns NULL if no radio-telegram available
// ---------------------------------------------------------------
N_CoPrtCnv::CoPrtCnvCentralTelegram *PrtCnvInjectionThread::getNextRadioInjectionTelegram()
{
  QMutexLocker l(m_RadioListMutex);

  if (m_RadioTelegramList.empty())
    return nullptr;
  auto radioTelegram = m_RadioTelegramList.front();
  m_RadioTelegramList.pop();
  return radioTelegram;
}


// ---------------------------------------------------------------
void PrtCnvInjectionThread::addToCentralList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram)
{
  QMutexLocker l(m_CentralListMutex);
  m_CentralTelegramList.push(a_telegram);
}


// ---------------------------------------------------------------
void PrtCnvInjectionThread::addToRadioList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram)
{
  QMutexLocker l(m_RadioListMutex);
  m_RadioTelegramList.push(a_telegram);
}

} // namespace PrtCnv