Initial commit

Lts/Viewer/SituationMap/LocalSrv/CMakeLists.txt

@@ -0,0 +1,37 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+
+# LIBRARY
+
+SET(LocalServer_SRCS
+  local_server_export
+  local_server.cpp
+  local_server.h
+)
+
+SOURCE_GROUP(LocalServer FILES ${LocalServer_SRCS})
+
+NGL_ADD_LIBRARY(WS situationMapLocalServer SHARED ${LocalServer_SRCS})
+NGL_TARGET_LINK_LIBRARIES(situationMapLocalServer
+  PRIVATE
+    ArcGIS::ArcGIS
+    NGLLogger
+    Qt5::Gui  # can be removed once we get an official ESRI ArcGIS Qt version again
+  PUBLIC
+    Qt5::Core
+    situationMapCommon
+)
+
+# ESRI: /usr/include/arcgis/LocalServer/LocalServer.h: '#include "Object.h"'
+# so add required include path here as PRIVATE:
+NGL_TARGET_INCLUDE_DIRECTORIES(situationMapLocalServer
+  PRIVATE
+    ${ARCGIS_INCLUDE_DIR}/arcgis
+  INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}/..
+)
+
+NGL_INSTALL_TARGET(situationMapLocalServer)

Lts/Viewer/SituationMap/LocalSrv/local_server.cpp

@@ -0,0 +1,519 @@
+/**
+  * @RDE_HEADER@
+  * LocalServer
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+// Own
+#include "local_server.h"
+#include <Common/resource_path.h>
+
+
+// ESRI
+#include <arcgis/Error.h>
+
+#include <arcgis/LocalServer/LocalServer.h>
+#include <arcgis/LocalServer/LocalGeoprocessingService.h>
+
+
+//Qt
+#include <QMap>
+
+
+namespace Esri
+{
+namespace ArcGISRuntime
+{
+
+QString toString(const Esri::ArcGISRuntime::Error &value)
+{
+  std::ostringstream stream;
+  stream << "Esri::ArcGISRuntime::Error: "
+         << " code="                << value.code()
+         << ", domain="             << (int)value.domain()
+         << ", extendedErrorType="  << (int)value.extendedErrorType()
+         << ", message='"           << value.message() << "'"
+         << ", additionalMessage='" << value.additionalMessage() << "'";
+  return QString::fromStdString(stream.str());
+}
+
+std::ostream &operator<< (std::ostream &stream,
+                          const Esri::ArcGISRuntime::Error &value)
+{
+  stream << toString(value);
+  return stream;
+}
+
+} // namespace ArcGISRuntime
+} // namespace Esri
+
+
+//----------------------------------------------------------------------------
+namespace SituationMap
+{
+
+
+bool LocalServiceData::isEmpty() const
+{
+  return m_svcUrl.isEmpty();
+}
+
+void LocalServiceData::setSvcUrl(const QUrl &svcUrl)
+{
+  m_svcUrl = svcUrl;
+}
+
+const QUrl &LocalServiceData::svcUrl() const
+{
+  return m_svcUrl;
+}
+
+void LocalServiceData::setSync(bool sync)
+{
+  m_sync = sync;
+}
+
+bool LocalServiceData::isSync() const
+{
+  return m_sync;
+}
+
+
+//----------------------------------------------------------------------------
+
+static QString toString(const Esri::ArcGISRuntime::LocalServerStatus &value)
+{
+  switch (value)
+  {
+  case Esri::ArcGISRuntime::LocalServerStatus::Stopped:
+    return QLatin1String("Stopped");
+  case Esri::ArcGISRuntime::LocalServerStatus::Starting:
+    return QLatin1String("Starting");
+  case Esri::ArcGISRuntime::LocalServerStatus::Started:
+    return QLatin1String("Started");
+  case Esri::ArcGISRuntime::LocalServerStatus::Stopping:
+    return QLatin1String("Stopping");
+  case Esri::ArcGISRuntime::LocalServerStatus::Failed:
+    return QLatin1String("Failed");
+  } // switch
+  return QLatin1String("Esri-LocalServerStatusERROR");
+}
+
+
+
+//-----------------------------------------------------------------------------
+class LocalServer::Private
+{
+public:
+  Private()     = default;
+  ~Private()    = default;
+
+  // ESRI data:
+  Esri::ArcGISRuntime::LocalServer                               *m_localServer = nullptr;
+
+  // Own data:
+  QMap<QString, Esri::ArcGISRuntime::LocalGeoprocessingService *> m_gpServiceMap;
+  QMap<QString, QString>                                          m_serviceSubLocationMap;
+
+
+  QMap<QString, LocalServiceData>                                 m_svcData;
+
+
+}; // class LocalServer::Private
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+LocalServer *LocalServer::instance()
+{
+  static LocalServer *_instance = nullptr;
+  if (_instance == nullptr)
+    _instance = new LocalServer;
+  return _instance;
+}
+
+//-----------------------------------------------------------------------------
+LocalServer::LocalServer()
+  : BaseClass()
+  , m_logger(getLogger("LocalServer"))
+  , d(new Private)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  DEBUG_LOG(m_logger) << LOGFUNCTION << " installPath = "
+                      << " '" << Esri::ArcGISRuntime::LocalServer::installPath() << "'";
+
+  QString newInstallPath;
+
+  QString user = QString::fromLocal8Bit( qgetenv("USER") );
+  if (user.compare(QLatin1Literal("ctc")) == 0)
+    newInstallPath = SituationMap::getResourcePath() + QLatin1String("/localserver100.2_ctc/");  // USER ctc
+  else
+    newInstallPath = SituationMap::getResourcePath() + QLatin1String("/localserver100.2/");      // USER ctc_ws
+
+  Esri::ArcGISRuntime::LocalServer::setInstallPath(newInstallPath);
+
+  if (Esri::ArcGISRuntime::LocalServer::isInstallValid())
+    NOTICE_LOG(m_logger) << LOGFUNCTION << " installPath ok = "
+                         << " '" << Esri::ArcGISRuntime::LocalServer::installPath() << "'";
+  else
+    FATAL_LOG(m_logger) << LOGFUNCTION << " installPath failed = "
+                        << " InstallPath = '" << Esri::ArcGISRuntime::LocalServer::installPath() << "'";
+
+  d->m_localServer = Esri::ArcGISRuntime::LocalServer::instance();
+
+  connect(d->m_localServer, &Esri::ArcGISRuntime::LocalServer::errorOccurred,
+          this, &LocalServer::onLocalServerError);
+  connect(d->m_localServer, &Esri::ArcGISRuntime::LocalServer::statusChanged,
+          this, &LocalServer::onLocalServerStatusChanged);
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+LocalServer::~LocalServer()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+  this->stop();
+  delete d;
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+void LocalServer::start()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+  d->m_localServer->start();
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+void LocalServer::stop()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  stopAllLocalGeoprocessingServices();
+  d->m_localServer->stop();
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+bool LocalServer::isLocalServerStarted() const
+{
+  return d->m_localServer->status() == Esri::ArcGISRuntime::LocalServerStatus::Started;
+}
+bool LocalServer::isLocalServerStopped() const
+{
+  return d->m_localServer->status() == Esri::ArcGISRuntime::LocalServerStatus::Stopped;
+}
+
+
+bool LocalServer::setLocalGeoprocessingService(const QString &serviceName,
+                                               const QString &packagePath,
+                                               const QString &serviceSubLocation,
+                                               bool sync)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START"
+                      << " serviceName: '" << serviceName << "'"
+                      << " packagePath: '" << packagePath << "'"
+                      << " serviceSubLocation: '" << serviceSubLocation << "'";
+  if (d->m_gpServiceMap.contains(serviceName))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName: '" << serviceName << "'" << " already provided";
+    return false;
+  }
+
+  QString localPackagePath = packagePath;
+
+  {
+    QFileInfo fileinfo(packagePath);
+    if (!fileinfo.isAbsolute())
+      localPackagePath = SituationMap::getResourcePath() + QLatin1String("/gpk/") + packagePath;
+  }
+  QFileInfo fileinfo(localPackagePath);
+
+  if (!fileinfo.exists())
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName: '" << serviceName << "'"
+                        << " packagePath does not exist: "
+                        << " localPackagePath: '" << localPackagePath << "'";
+    return false;
+  }
+  if (!fileinfo.isReadable())
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName: '" << serviceName << "'"
+                        << " packagePath is not readable: "
+                        << " localPackagePath: '" << localPackagePath << "'";
+    return false;
+  }
+
+
+  NOTICE_LOG(m_logger) << LOGFUNCTION << " create LocalGeoprocessingService: "
+                       << " localPackagePath: '" << localPackagePath << "'";
+
+
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgps =
+    new Esri::ArcGISRuntime::LocalGeoprocessingService(localPackagePath, this);
+  lgps->setObjectName(QString(QLatin1Literal("LocalGeoprocessingService-%1")).arg(serviceName));
+
+  if (sync)
+    lgps->setServiceType(Esri::ArcGISRuntime::GeoprocessingServiceType::SynchronousExecute); // SynchronousExecute | AsynchronousSubmit | ...
+  else
+    lgps->setServiceType(Esri::ArcGISRuntime::GeoprocessingServiceType::AsynchronousSubmit); // SynchronousExecute | AsynchronousSubmit | ...
+
+  connect(lgps, &Esri::ArcGISRuntime::LocalGeoprocessingService::errorOccurred,
+          this, &LocalServer::onLGPSError);
+  connect(lgps, &Esri::ArcGISRuntime::LocalGeoprocessingService::statusChanged,
+          this, &LocalServer::onLGPSStatusChanged);
+
+  // add to own management:
+  d->m_gpServiceMap[serviceName]          = lgps;
+  d->m_serviceSubLocationMap[serviceName] = serviceSubLocation;
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END"
+                      << " serviceName: '" << serviceName << "'"
+                      << " localPackagePath: '" << localPackagePath << "'"
+                      << " serviceSubLocation: '" << serviceSubLocation << "'";
+  return true;
+}
+
+bool LocalServer::startLocalGeoprocessingService(const QString &serviceName)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  if (!d->m_gpServiceMap.contains(serviceName))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << " not found";
+    return false;
+  }
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = d->m_gpServiceMap[serviceName];
+  if (!lgps)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+    return false;
+  }
+
+  if (isLocalServerStarted())
+    lgps->start();
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+  return true;
+}
+
+bool LocalServer::stopLocalGeoprocessingService(const QString &serviceName)
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  if (!d->m_gpServiceMap.contains(serviceName))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << " not found";
+    return false;
+  }
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = d->m_gpServiceMap[serviceName];
+  if (!lgps)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+    return false;
+  }
+
+  lgps->stop();
+  return true;
+}
+
+bool LocalServer::isLocalGeoprocessingServiceStarted(const QString &serviceName) const
+{
+  if (!d->m_gpServiceMap.contains(serviceName))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << " not found";
+    return false;
+  }
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = d->m_gpServiceMap[serviceName];
+  if (!lgps)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+    return false;
+  }
+  return lgps->status() == Esri::ArcGISRuntime::LocalServerStatus::Started;
+}
+bool LocalServer::isLocalGeoprocessingServiceStopped(const QString &serviceName) const
+{
+  if (!d->m_gpServiceMap.contains(serviceName))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << " not found";
+    return false;
+  }
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = d->m_gpServiceMap[serviceName];
+  if (!lgps)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+    return false;
+  }
+  return lgps->status() == Esri::ArcGISRuntime::LocalServerStatus::Stopped;
+}
+
+bool LocalServer::isLocalGeoprocessingServiceSynchronousExecute(const QString &serviceName) const
+{
+  if (!d->m_gpServiceMap.contains(serviceName))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << " not found";
+    return false;
+  }
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = d->m_gpServiceMap[serviceName];
+  if (!lgps)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+    return false;
+  }
+  return lgps->serviceType() == Esri::ArcGISRuntime::GeoprocessingServiceType::SynchronousExecute;
+}
+
+bool LocalServer::isLocalGeoprocessingServiceAsynchronousSubmit(const QString &serviceName) const
+{
+  if (!d->m_gpServiceMap.contains(serviceName))
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << " not found";
+    return false;
+  }
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = d->m_gpServiceMap[serviceName];
+  if (!lgps)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+    return false;
+  }
+  return lgps->serviceType() == Esri::ArcGISRuntime::GeoprocessingServiceType::AsynchronousSubmit;
+}
+
+bool LocalServer::localGeoprocessingServiceData(const QString &serviceName, LocalServiceData &localServiceDataOut) const
+{
+  if (!d->m_svcData.contains(serviceName))
+  {
+    DEBUG_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << " not found";
+    return false;
+  }
+  localServiceDataOut = d->m_svcData[serviceName];
+  return true;
+}
+
+void LocalServer::startAllPendingLocalGeoprocessingServices()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  QMapIterator<QString, Esri::ArcGISRuntime::LocalGeoprocessingService *> mapIt(d->m_gpServiceMap);
+
+  while (mapIt.hasNext())
+  {
+    mapIt.next();
+    const QString &serviceName = mapIt.key();
+    Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = mapIt.value();
+
+    if (!lgps)
+    {
+      ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+      continue;
+    }
+
+    if (lgps->status() == Esri::ArcGISRuntime::LocalServerStatus::Started)
+    {
+      DEBUG_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", already started, continue";
+      continue;
+    }
+    else
+      lgps->start();
+  } // while
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+void LocalServer::stopAllLocalGeoprocessingServices()
+{
+  QMapIterator<QString, Esri::ArcGISRuntime::LocalGeoprocessingService *> mapIt(d->m_gpServiceMap);
+
+  while (mapIt.hasNext())
+  {
+    mapIt.next();
+    const QString &serviceName = mapIt.key();
+    Esri::ArcGISRuntime::LocalGeoprocessingService *lgps = mapIt.value();
+
+    if (!lgps)
+    {
+      ERROR_LOG(m_logger) << LOGFUNCTION << " serviceName '" << serviceName << "'" << ", no service";
+      continue;
+    }
+    lgps->stop();
+  } // while
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+
+void LocalServer::onLocalServerError(const Esri::ArcGISRuntime::Error &error)
+{
+  ERROR_LOG(m_logger) << LOGFUNCTION << " EsriError occured: " << error;
+}
+
+void LocalServer::onLocalServerStatusChanged()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  NOTICE_LOG(m_logger) << LOGFUNCTION << " LocalServer: status changed to: " << toString(d->m_localServer->status());
+
+  emit localServerStatusChanged();
+
+  if (d->m_localServer->status() == Esri::ArcGISRuntime::LocalServerStatus::Started)
+  {
+    NOTICE_LOG(m_logger) << LOGFUNCTION << " LocalServer: STARTED"
+                         << " (url= '" << d->m_localServer->url().toString() << "')"
+                         << " (Esri::ArcGISRuntime::LocalServer->tempDataPath= '" << d->m_localServer->tempDataPath() << "')";
+    startAllPendingLocalGeoprocessingServices();
+  }
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+void LocalServer::onLGPSError(const Esri::ArcGISRuntime::Error &error)
+{
+  QString senderName;
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgs = qobject_cast<Esri::ArcGISRuntime::LocalGeoprocessingService *>(sender());
+  if (lgs)
+    senderName = lgs->objectName();
+  ERROR_LOG(m_logger) << LOGFUNCTION << " LocalGeoprocessingService -> EsriError occured: " << error;
+}
+
+void LocalServer::onLGPSStatusChanged()
+{
+  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
+
+  Esri::ArcGISRuntime::LocalGeoprocessingService *lgsp = qobject_cast<Esri::ArcGISRuntime::LocalGeoprocessingService *>(sender());
+
+  if (!lgsp)
+  {
+    ERROR_LOG(m_logger) << LOGFUNCTION << " qobject_cast failed to get sender!?";
+    return;
+  }
+
+  QString senderName = lgsp->objectName();
+  const QString &serviceName = d->m_gpServiceMap.key(lgsp);
+
+  if (lgsp->status() == Esri::ArcGISRuntime::LocalServerStatus::Started)
+  {
+    NOTICE_LOG(m_logger) << LOGFUNCTION << " ***** LocalGeoprocessingService:"
+                         << " sender= '" << senderName << "'"
+                         << " status changed to: " << toString(lgsp->status())
+                         << " url= '" << lgsp->url().toString() << "'";
+
+    LocalServiceData svcData;
+
+    const QString &serviceSubLocation = d->m_serviceSubLocationMap[serviceName];
+    const QString &url = lgsp->url().toString() + QLatin1String("/") + serviceSubLocation;
+    svcData.setSvcUrl(QUrl(url));
+    svcData.setSync(lgsp->serviceType() == Esri::ArcGISRuntime::GeoprocessingServiceType::SynchronousExecute);
+
+    d->m_svcData[serviceName] = svcData; // store in own management
+
+    emit localGeoprocessingServiceStatusChanged(serviceName);
+    emit localGeoprocessingServiceStarted(serviceName, svcData);
+  }
+
+  NOTICE_LOG(m_logger) << LOGFUNCTION << " LocalGeoprocessingService:"
+                       << " sender= '" << senderName << "'"
+                       << " status changed to: " << toString(lgsp->status());
+
+  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+} // namespace SituationMap
+

Lts/Viewer/SituationMap/LocalSrv/local_server.h

@@ -0,0 +1,128 @@
+/**
+  * @RDE_HEADER@
+  * LocalServer
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+// Own
+#include "local_server_export.h"
+#include <Common/situation_map_logging.h>
+
+namespace Esri {
+namespace ArcGISRuntime {
+class Error;
+}
+}
+
+
+
+// Qt
+#include <QObject>
+#include <QUrl>
+#include <QString>
+
+
+//----------------------------------------------------------------------------
+namespace SituationMap
+{
+
+class LOCALSERVER_EXPORT LocalServiceData
+{
+private:
+  QUrl      m_svcUrl;
+  bool      m_sync = false;
+public:
+  bool isEmpty() const;
+
+  void setSvcUrl(const QUrl &svcUrl);
+  const QUrl &svcUrl() const;
+
+  void setSync(bool sync);
+  bool isSync() const;
+};
+
+
+
+/**
+ * @brief The LocalServer class wrap ESRI`s LocalServer.
+ * This is a container for geoprocessing services
+ * The LocalServer has to be started as well as the seperate instances of LocalGeoprocessingService.
+ * To ease the usage you should set the required number of LocalGeoprocessingService (with different serviceNames).
+ * Then simply start the LocalServer (and if that is up all pending will be started.)
+ */
+class LOCALSERVER_EXPORT LocalServer : public QObject
+{
+  Q_OBJECT
+
+  using BaseClass = QObject;
+
+private:
+  explicit LocalServer();
+  ~LocalServer();
+
+public:
+  /*! \name Check Installation ( no guarantee )*/
+  static bool isInstallValid();
+
+
+  /*! \name Singleton */
+  static LocalServer *instance();
+
+
+  /*! \name LocalServer */
+  //@{
+  void start();
+  void stop();
+
+  bool isLocalServerStarted() const;
+  bool isLocalServerStopped() const;
+  //@}
+
+  /*! \name LocalGeoprocessingService */
+  //@{
+  bool setLocalGeoprocessingService(const QString &serviceName, const QString &packagePath, const QString &serviceSubLocation, bool sync);
+  bool startLocalGeoprocessingService(const QString &serviceName);
+  bool stopLocalGeoprocessingService(const QString &serviceName);
+
+  bool isLocalGeoprocessingServiceStarted(const QString &serviceName) const;
+  bool isLocalGeoprocessingServiceStopped(const QString &serviceName) const;
+
+  bool isLocalGeoprocessingServiceSynchronousExecute(const QString &serviceName) const;
+  bool isLocalGeoprocessingServiceAsynchronousSubmit(const QString &serviceName) const;
+
+  bool localGeoprocessingServiceData(const QString &serviceName, LocalServiceData &localServiceDataOut) const;
+  //@}
+
+protected:
+  void startAllPendingLocalGeoprocessingServices();
+  void stopAllLocalGeoprocessingServices();
+
+protected Q_SLOTS:
+  void onLocalServerError(const Esri::ArcGISRuntime::Error &error);
+  void onLocalServerStatusChanged();
+
+  void onLGPSError(const Esri::ArcGISRuntime::Error &error);
+  void onLGPSStatusChanged();
+
+Q_SIGNALS:
+  void localServerStatusChanged();
+
+  void localGeoprocessingServiceStatusChanged(const QString &serviceName);
+  void localGeoprocessingServiceStarted(const QString &serviceName, const LocalServiceData&localSvcData);
+
+private:
+  LOGGER_T m_logger;      ///< Interface of the Logging-Facility
+
+  class Private;
+  /**
+      * The private d->pointer to not break BC when changing internals of this class
+     */
+  Private *d = nullptr;
+};
+
+} // namespace SituationMap
+

Lts/Viewer/SituationMap/LocalSrv/local_server_export.h

@@ -0,0 +1,21 @@
+/**
+  * Export definitions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+#pragma once
+
+#include <qglobal.h>
+
+#ifndef LOCALSERVER_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define LOCALSERVER_EXPORT
+# else
+#  if defined(MAKE_SITUATIONMAPLOCALSERVER_LIB)
+#   define LOCALSERVER_EXPORT Q_DECL_EXPORT
+#  else
+#   define LOCALSERVER_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif