Adds initial intermediate qt6 porting state

qt6-after/qt6-migrated-legatus/Z/src/tcpserver/commandinterface.cpp

@@ -0,0 +1,329 @@
+
+
+
+#include "commandinterface.h"
+#include "workerbase.h"
+#include "tcpserver.h"
+#include "tcpserver_logger.h"
+
+#include <QtCore/QDebug>
+#include <QtCore/QStringList>
+#include <QtNetwork/QAbstractSocket>
+
+class CommandInterface::Private
+{
+public:
+  explicit Private(unsigned short port_, const QByteArray &command_)
+    : command(command_)
+    , port(port_)
+  {}
+
+  QByteArray m_connString;
+  QByteArray command;
+  QAbstractSocket *dev = nullptr; 
+  WorkerBase *wb = nullptr; 
+  int  writeTimeout = 1000;
+  unsigned short port;
+  bool autoWriteEOL = true;
+  bool bWriteError = false;
+  bool closeConnection = false;
+
+  static QByteArray defaultSuccessMessage;
+  static QByteArray defaultErrorMessage;
+};
+QByteArray CommandInterface::Private::defaultSuccessMessage("OK");
+QByteArray CommandInterface::Private::defaultErrorMessage("ERROR");
+
+CommandInterface::CommandInterface(unsigned short port, const QByteArray &command)
+  : d(new Private(port, command))
+{}
+
+CommandInterface::~CommandInterface()
+{
+  delete d;
+}
+
+void CommandInterface::handleCommand(const QVector<QByteArray> &args)
+{
+  Q_ASSERT(d->dev);
+  d->bWriteError = false;
+  d->closeConnection = false;
+  d->m_connString = WorkerBase::formatForDebug(d->dev);
+  handleCommandInternal(args);
+  if (d->autoWriteEOL)
+    writeEOL();
+  d->dev->flush();
+  if (d->closeConnection)
+  {
+    
+    d->dev->disconnectFromHost();
+    
+    d->dev = nullptr;
+  }
+}
+
+void CommandInterface::newPlainData()
+{
+  Q_ASSERT(false);
+  TCPSERVER_ERROR("CommandInterface::newData called which should never happen!");
+}
+
+void CommandInterface::writeData(const char *payload)
+{
+  writeData(QByteArray::fromRawData(payload, strlen(payload)));
+}
+
+void CommandInterface::writeData(const QByteArray &payload)
+{
+  Q_ASSERT(d->dev);
+
+  if (!d->dev->isOpen())
+    return;
+
+  if (!payload.size())
+    return;
+
+  TCPSERVER_DEBUG("Sending \'" << WorkerBase::formatForDebug(payload).constData()
+                  << "\' (" << payload.size() << " Bytes) to "
+                  << d->m_connString.constData())
+  
+  qint64 bytesToWrite = payload.size();
+  qint64 bytesWritten = 0;
+  do
+  {
+    bytesWritten += d->dev->write(&payload.data()[bytesWritten], bytesToWrite - bytesWritten);
+    if (!d->dev->waitForBytesWritten(d->writeTimeout))
+    {
+      TCPSERVER_ERROR("waitForBytesWritten returned false for connection "
+                      << d->m_connString.constData()
+                      << " "
+                      << d->dev->error()
+                      << " "
+                      << d->dev->errorString())
+      d->bWriteError = true;
+      return;
+    }
+  }
+  while (bytesToWrite != bytesWritten);
+}
+
+void CommandInterface::writeData(const QString &payload)
+{
+  writeData(payload.toUtf8());
+}
+
+void CommandInterface::writeData(const QList<QByteArray> &payload)
+{
+  QByteArray cmd;
+  for (QByteArray s : payload)
+  {
+    s.replace('\"', "\\\"");
+    if (s.contains(' '))
+      s = '"' + s + '"';
+    cmd += s + ' ';
+  }
+  writeData(cmd);
+}
+
+void CommandInterface::writeData(const QStringList &payload)
+{
+  QList<QByteArray> baList;
+  baList.reserve(payload.size());
+  for (const QString &ba : payload)
+    baList += ba.toUtf8();
+  writeData(baList);
+}
+
+void CommandInterface::writeOk(const QString &additionalMsg)
+{
+  writeData(Private::defaultSuccessMessage);
+  if (!additionalMsg.isEmpty())
+  {
+    writeData(" ");
+    writeData(additionalMsg);
+  }
+}
+
+void CommandInterface::writeError(const QString &additionalMsg)
+{
+  writeData(Private::defaultErrorMessage);
+  if (!additionalMsg.isEmpty())
+  {
+    writeData(" ");
+    writeData(additionalMsg);
+  }
+}
+
+void CommandInterface::writeEOL()
+{
+  writeData("\n");
+
+  Q_ASSERT(d->dev);
+  d->dev->flush();
+}
+
+QByteArray CommandInterface::quote(const QByteArray &payload)
+{
+  static const QByteArray escapedQuote("\"");
+  int idx = payload.indexOf(' ');
+  if (idx < 0)
+    return payload;
+  QByteArray ret = payload;
+  return escapedQuote + ret.replace('\"', "\\\"") + escapedQuote;
+}
+
+QAbstractSocket *CommandInterface::socket()
+{
+  return d->dev;
+}
+void CommandInterface::setSocket(QAbstractSocket *socket)
+{
+  d->dev = socket;
+}
+
+WorkerBase *CommandInterface::workerBase()
+{
+  return d->wb;
+}
+
+void CommandInterface::setWorkerBase(WorkerBase *wb)
+{
+  d->wb = wb;
+}
+
+QByteArray CommandInterface::command() const
+{
+  return d->command;
+}
+
+void CommandInterface::setWriteTimeout(int iMS)
+{
+  d->writeTimeout = iMS < 0 ? 1000 : iMS;
+}
+
+void CommandInterface::setAutoWriteEOL(bool newAutoWriteEOL)
+{
+  d->autoWriteEOL = newAutoWriteEOL;
+}
+
+bool CommandInterface::autoWriteEOL() const
+{
+  return d->autoWriteEOL;
+}
+
+bool CommandInterface::errorOccured() const
+{
+  return d->bWriteError;
+}
+
+void CommandInterface::setDefaultSuccessMessage(const QString &msg)
+{
+  Private::defaultSuccessMessage = msg.isEmpty() ? "OK" : msg.toUtf8();
+}
+
+void CommandInterface::setDefaultErrorMessage(const QString &msg)
+{
+  Private::defaultErrorMessage = msg.isEmpty() ? "ERROR" : msg.toUtf8();
+}
+
+unsigned short CommandInterface::port() const
+{
+  return d->port;
+}
+
+void CommandInterface::closeConnection()
+{
+  d->closeConnection = true;
+}
+
+bool CommandInterface::socketIsOpen() const
+{
+  return d->dev && d->dev->isOpen();
+}
+
+void CommandInterface::conversionError(const QByteArray &arg, const QByteArray &type)
+{
+  writeError(QLatin1String("Can not convert ") + QString::fromUtf8(arg) +
+             QLatin1String(" to ") + QString::fromUtf8(type));
+}
+
+bool CommandInterface::getValue(const QByteArray &arg, bool &value)
+{
+  bool bOk;
+  int intValue;
+
+  if (arg.startsWith("0x"))
+    intValue = arg.mid(2).toInt(&bOk, 16);
+  else
+    intValue = arg.toInt(&bOk);
+  if (!bOk)
+    conversionError(arg, "bool");
+  value = (intValue != 0);
+  return bOk;
+}
+
+bool CommandInterface::getValue(const QByteArray &arg, long &value)
+{
+  bool bOk;
+  if (arg.startsWith("0x"))
+    value = arg.mid(2).toLong(&bOk, 16);
+  else
+    value = arg.toLong(&bOk);
+  if (!bOk)
+    conversionError(arg, "long");
+  return bOk;
+}
+
+bool CommandInterface::getValue(const QByteArray &arg, unsigned long &value)
+{
+  bool bOk;
+  if (arg.startsWith("0x"))
+    value = arg.mid(2).toULong(&bOk, 16);
+  else
+    value = arg.toUInt(&bOk);
+  if (!bOk)
+    conversionError(arg, "unsigned long");
+  return bOk;
+}
+
+bool CommandInterface::getValue(const QByteArray &arg, int &value)
+{
+  bool bOk;
+  if (arg.startsWith("0x"))
+    value = arg.mid(2).toInt(&bOk, 16);
+  else
+    value = arg.toInt(&bOk);
+  if (!bOk)
+    conversionError(arg, "int");
+  return bOk;
+}
+
+bool CommandInterface::getValue(const QByteArray &arg, unsigned int &value)
+{
+  bool bOk;
+  if (arg.startsWith("0x"))
+    value = arg.mid(2).toUInt(&bOk, 16);
+  else
+    value = arg.toUInt(&bOk);
+  if (!bOk)
+    conversionError(arg, "unsigned int");
+  return bOk;
+}
+
+bool CommandInterface::getValue(const QByteArray &arg, float &value)
+{
+  bool bOk;
+  value = arg.toFloat(&bOk);
+  if (!bOk)
+    conversionError(arg, "float");
+  return bOk;
+}
+
+bool CommandInterface::getValue(const QByteArray &arg, double &value)
+{
+  bool bOk;
+  value = arg.toDouble(&bOk);
+  if (!bOk)
+    conversionError(arg, "double");
+  return bOk;
+}