Adds q2 repos to migrate

TetraIF/LogView/Console/main.cpp

@@ -0,0 +1,201 @@
+
+
+#include <QCoreApplication>
+#include <QStringList>
+#include <QFile>
+#include <QByteArray>
+#include <QDateTime>
+#include <QBuffer>
+#include <QSet>
+
+#include <CoPrtCnv/CoPrtCnvLogHeader.hpp>
+#include <CoPrtCnv/CoPrtCnvRadioTelegram.hpp>
+#include <CoPrtCnv/CoPrtCnvTelegramConverter.hpp>
+#include <NGLLogger/NGLLoggerBootstrap.h>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <TrainingAreaBase/training_area_telegrams.h>
+
+static QSet<int> s_eqIds;
+template <typename T>
+bool validEqId(const T &tele)
+{
+  if (!s_eqIds.isEmpty() && !s_eqIds.contains(tele.header.equipmentNumber))
+    return false;
+  return true;
+}
+
+QByteArray formatTime(quint64 t)
+{
+  const quint64 secs = t >> 32;
+  const quint64 usecs = t & 0xFFFFFFFF;
+  const quint64 msecs = usecs / 1000;
+  return QDateTime::fromMSecsSinceEpoch(secs * 1000 + msecs).toString(QLatin1String("yy-MM-dd hh:mm:ss.zzz")).toUtf8();
+}
+
+int main(int argc, char **argv)
+{
+  using namespace TrainingAreaBase::TetraIcd;
+
+  QCoreApplication app(argc, argv);
+
+  
+  NGL::NGLLoggerBootstrap::createNGLRootLogger("log4cxx_tetra.props", false);
+
+  NGL::INGLLogger &logger(NGL::NGLLoggerBootstrap::getNGLRootLogger());
+
+  if (app.arguments().count() < 3)
+  {
+    ERROR_LOG(logger) << "Usage: " << app.arguments().at(0)
+                      << " <logfile> <telId> <equipId>";
+    return 1;
+  }
+
+  QFile telegramFile(app.arguments().at(1));
+  if (!telegramFile.open(QIODevice::ReadOnly))
+  {
+    ERROR_LOG(logger) << "Error opening " << telegramFile.fileName()
+                      << " for reading: " << telegramFile.errorString();
+    return 2;
+  }
+  bool bOk;
+  int telIdToSearch = app.arguments().at(2).toUShort(&bOk);
+  if (!bOk)
+  {
+    ERROR_LOG(logger) << "Error reading telId - not a (valid) number: "
+                      << app.arguments().at(2);
+    return 3;
+  }
+  s_eqIds.clear();
+  for (int i = 3; i < app.arguments().size(); ++i)
+  {
+    int eqId = app.arguments().at(i).toUShort(&bOk);
+    if (!bOk)
+    {
+      ERROR_LOG(logger) << "Error reading equipId - not a (valid) number: "
+                        << app.arguments().at(i);
+      return 4;
+    }
+    s_eqIds += eqId;
+  }
+
+  
+  while (true)
+  {
+    
+    N_CoPrtCnv::CoPrtCnvLogHeader lh;
+    if (sizeof(lh) == telegramFile.read((char *)&lh, sizeof(lh)))
+    {
+      if (lh.m_Version == 3)
+      {
+        
+        qint64 telegramLength = lh.m_Length - sizeof(lh);
+        QByteArray telegramData(telegramLength, Qt::Uninitialized);
+        if (telegramLength == telegramFile.read(telegramData.data(), telegramLength))
+        {
+          
+          N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol dest = (N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol)
+                                                                   (lh.m_Protocol & N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolMask);
+
+          switch (dest)
+          {
+          case N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolCentral:
+          {
+            const QJsonObject obj = QJsonDocument::fromJson(telegramData).object();
+            int telId = obj.value(QStringLiteral("typeId")).toInt();
+            if (telIdToSearch != telId)
+              continue;
+
+            const QJsonObject objData = obj.value(QStringLiteral("data")).toObject();
+
+            const QByteArray tBA = formatTime(lh.m_Time);
+            const char *timeStr = tBA.constData();
+
+            switch (telId)
+            {
+            case Constraints<CreateFunctionalArea>::id():
+            {
+              const CreateFunctionalArea tele(CreateFunctionalArea::fromJson(objData));
+              if (!validEqId(tele))
+                break;
+              fprintf(stdout, "%s, FUNKTIONSRAUM: '%s', %d, %d\n",
+                      timeStr,
+                      tele.name.c_str(),
+                      tele.aesDdsId,
+                      tele.header.equipmentNumber
+                     );
+              break;
+            }
+            case Constraints<DeactivateEffectSimulation>::id():
+            {
+              const DeactivateEffectSimulation tele(DeactivateEffectSimulation::fromJson(objData));
+              fprintf(stdout, "%s, DEAKTIVIERUNG_WIRKFELD: typ: %d - kennung: %d\n",
+                      timeStr,
+                      int(tele.aesType),
+                      tele.aesDdsId
+                     );
+              break;
+            }
+            case Constraints<PositionReport>::id():
+            {
+              const PositionReport tele(PositionReport::fromJson(objData));
+              if (!validEqId(tele))
+                break;
+              if (tele.opsPosition.opsId == 0)
+                break;
+              fprintf(stdout, "%s, IPS_POSITIONSDATEN: %d - OPS: %d\n",
+                      timeStr,
+                      tele.header.equipmentNumber,
+                      tele.opsPosition.opsId
+                     );
+              break;
+            }
+            case BESTAETIGUNG:
+            case UMGEBUNGS_MELDUNG2:
+              break;
+            default:
+              fprintf(stderr, "Printing telegram with id %d not implemented\n", telId);
+              break;
+
+            }
+            break;
+          }
+          case N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolTetra:
+          {
+            N_CoPrtCnv::CoPrtCnvRadioTelegram radioTelegram(telegramData);
+            gef_telegramm_id_et telId = radioTelegram.getTelID();
+            if (telId == GEF_UMGEBUNGS_MELDUNG2)
+            {
+              const QByteArray tBA = formatTime(lh.m_Time);
+              const char *timeStr = tBA.constData();
+              static uint16_t bci = 0xFFFF;
+              if (bci != radioTelegram.getBroadcastIndex())
+              {
+                if (bci > radioTelegram.getBroadcastIndex() && bci != 0xFFFF)
+                {
+                  fprintf(stdout, "BCI reset in %s at %s!\n",
+                          qPrintable(telegramFile.fileName()),
+                          timeStr);
+                }
+                fprintf(stdout, "BCI: %d\n", radioTelegram.getBroadcastIndex());
+                bci = radioTelegram.getBroadcastIndex();
+              }
+            }
+            break;
+          }
+          default:
+            break;
+          }
+        }
+      }
+      else
+      {
+        ERROR_LOG(logger) << "Wrong LogHeader version: " << lh.m_Version;
+        return 4;
+      }
+    }
+    else
+      break;
+  }
+  return 0;
+}