Simplified the DAH SOAP service classes.

Plugins/org.commontk.dah.app/ctkDicomHostService.cpp

@@ -21,12 +21,10 @@
 
 #include "ctkDicomHostService_p.h"
 
-#include "ctkDicomServicePrivate.h"
+#include <ctkDicomAppHostingTypesHelper.h>
 
-#include "ctkDicomAppHostingTypesHelper.h"
-
-ctkDicomHostService::ctkDicomHostService(ushort port, QString path):
-    d(new ctkDicomServicePrivate(port, path)), service(port, path)
+ctkDicomHostService::ctkDicomHostService(ushort port, QString path)
+  : ctkDicomExchangeService(port, path)
 {
 }
 
@@ -36,30 +34,24 @@ ctkDicomHostService::~ctkDicomHostService()
 
 QString ctkDicomHostService::generateUID()
 {
-  //Q_D(ctkDicomService);
-
-  const QtSoapType& result = d->askHost("generateUID", NULL);
+  const QtSoapType& result = submitSoapRequest("generateUID", NULL);
   QString resultUID = ctkDicomSoapUID::getUID(result);
   return resultUID;
 }
 
 QString ctkDicomHostService::getOutputLocation(const QStringList& preferredProtocols)
 {
-  //Q_D(ctkDicomHostService);
-
   QtSoapStruct* input = dynamic_cast<QtSoapStruct*>(
     new ctkDicomSoapArrayOfStringType("string","preferredProtocols", preferredProtocols));
-  const QtSoapType& result = d->askHost("getOutputLocation", input);
+  const QtSoapType& result = submitSoapRequest("getOutputLocation", input);
   QString resultString = result.value().toString();
   return resultString;
 }
 
 QRect ctkDicomHostService::getAvailableScreen(const QRect& preferredScreen)
 {
-  //Q_D(ctkDicomService);
-
   QtSoapStruct* input = new ctkDicomSoapRectangle("preferredScreen", preferredScreen);
-  const QtSoapType& result = d->askHost("getAvailableScreen", input);
+  const QtSoapType& result = submitSoapRequest("getAvailableScreen", input);
   QRect resultRect = ctkDicomSoapRectangle::getQRect(result);
   qDebug() << "x:" << resultRect.x() << " y:" << resultRect.y();
   return resultRect;
@@ -67,24 +59,22 @@ QRect ctkDicomHostService::getAvailableScreen(const QRect& preferredScreen)
 
 void ctkDicomHostService::notifyStateChanged(ctkDicomAppHosting::State state)
 {
-  //Q_D(ctkDicomService);
-
   QtSoapType* input = new ctkDicomSoapState("newState", state); // spec would be "state", java has "newState" FIX JAVA/STANDARD
-  d->askHost("notifyStateChanged", input);
+  submitSoapRequest("notifyStateChanged", input);
 }
 
 void ctkDicomHostService::notifyStatus(const ctkDicomAppHosting::Status& status)
 {
   //Q_D(ctkDicomService);
   QtSoapStruct* input = new ctkDicomSoapStatus("status", status);
-  d->askHost("notifyStatus", input);
+  submitSoapRequest("notifyStatus", input);
 }
 
 // Exchange methods
 
 bool ctkDicomHostService::notifyDataAvailable(ctkDicomAppHosting::AvailableData data, bool lastData)
 {
-  return service.notifyDataAvailable(data, lastData);
+  return ctkDicomExchangeService::notifyDataAvailable(data, lastData);
 }
 
 QList<ctkDicomAppHosting::ObjectLocator> ctkDicomHostService::getData(
@@ -92,10 +82,10 @@ QList<ctkDicomAppHosting::ObjectLocator> ctkDicomHostService::getData(
   QList<QString> acceptableTransferSyntaxUIDs, 
   bool includeBulkData)
 {
-  return service.getData(objectUUIDs, acceptableTransferSyntaxUIDs, includeBulkData);
+  return ctkDicomExchangeService::getData(objectUUIDs, acceptableTransferSyntaxUIDs, includeBulkData);
 }
 
 void ctkDicomHostService::releaseData(QList<QUuid> objectUUIDs)
 {
-  service.releaseData(objectUUIDs);
+  ctkDicomExchangeService::releaseData(objectUUIDs);
 }

Plugins/org.commontk.dah.app/ctkDicomHostService_p.h

@@ -26,7 +26,7 @@
 #include <ctkDicomHostInterface.h>
 #include <ctkDicomExchangeService.h>
 
-class ctkDicomHostService : public QObject, public ctkDicomHostInterface
+class ctkDicomHostService : public ctkDicomExchangeService, public ctkDicomHostInterface
 {
   Q_OBJECT
   Q_INTERFACES(ctkDicomHostInterface)
@@ -41,18 +41,15 @@ public:
   void notifyStateChanged(ctkDicomAppHosting::State state);
   void notifyStatus(const ctkDicomAppHosting::Status& status);
 
-  // Exchange methods
+  // Exchange methods implemented in ctkDicomExchangeService
   bool notifyDataAvailable(ctkDicomAppHosting::AvailableData data, bool lastData);
+
   QList<ctkDicomAppHosting::ObjectLocator> getData(
     QList<QUuid> objectUUIDs, 
     QList<QString> acceptableTransferSyntaxUIDs, 
     bool includeBulkData);
-  void releaseData(QList<QUuid> objectUUIDs);
 
-private:
-  ctkDicomServicePrivate * d;
-
-  ctkDicomExchangeService service;
+  void releaseData(QList<QUuid> objectUUIDs);
 
 };
 

Plugins/org.commontk.dah.core/CMakeLists.txt

@@ -11,8 +11,8 @@ SET(PLUGIN_SRCS
   ctkDicomExchangeInterface.h
   ctkDicomExchangeService.cpp
   ctkDicomHostInterface.h
-  ctkDicomServicePrivate.cpp
   ctkExchangeSoapMessageProcessor.cpp
+  ctkSimpleSoapClient.cpp
   ctkSimpleSoapServer.cpp
   ctkSoapConnectionRunnable.cpp
   ctkSoapConnectionRunnable_p.h
@@ -23,7 +23,7 @@ SET(PLUGIN_SRCS
 # Files which should be processed by Qts moc
 SET(PLUGIN_MOC_SRCS
   ctkDicomAppHostingCorePlugin_p.h
-  ctkDicomServicePrivate.h
+  ctkSimpleSoapClient.h
   ctkSimpleSoapServer.h
   ctkSoapConnectionRunnable_p.h
 )

Plugins/org.commontk.dah.core/ctkDicomExchangeService.cpp

@@ -21,30 +21,28 @@
 
 #include "ctkDicomExchangeService.h"
 
-#include "ctkDicomServicePrivate.h"
+#include "ctkSimpleSoapClient.h"
 
 #include "ctkDicomAppHostingTypesHelper.h"
 
 ctkDicomExchangeService::ctkDicomExchangeService(ushort port, QString path)
-  : d(new ctkDicomServicePrivate(port, path))
+  : ctkSimpleSoapClient(port, path)
 {
 
 }
 
 ctkDicomExchangeService::~ctkDicomExchangeService()
 {
-  delete d;
-  d = NULL;
+
 }
 
 bool ctkDicomExchangeService::notifyDataAvailable(
     ctkDicomAppHosting::AvailableData data, bool lastData)
 {
-  //Q_D(ctkDicomService);
   QList<QtSoapType*> list;
   list << new ctkDicomSoapAvailableData("data", data);
   list << new ctkDicomSoapBool("lastData", lastData);
-  const QtSoapType & result = d->askHost("notifyDataAvailable",list);
+  const QtSoapType & result = submitSoapRequest("notifyDataAvailable",list);
   return ctkDicomSoapBool::getBool(result);
 }
 
@@ -58,7 +56,7 @@ QList<ctkDicomAppHosting::ObjectLocator> ctkDicomExchangeService::getData(
   list << new ctkDicomSoapArrayOfUUIDS("objectUUIDS",objectUUIDs);
   list << new ctkDicomSoapArrayOfStringType("UID","acceptableTransferSyntaxUIDs", acceptableTransferSyntaxUIDs);
   list << new ctkDicomSoapBool("includeBulkData", includeBulkData);
-  const QtSoapType & result = d->askHost("getData",list);
+  const QtSoapType & result = submitSoapRequest("getData",list);
   return ctkDicomSoapArrayOfObjectLocators::getArray(static_cast<const QtSoapArray &>(result));
 }
 

Plugins/org.commontk.dah.core/ctkDicomExchangeService.h

@@ -23,16 +23,17 @@
 #ifndef CTKDICOMEXCHANGESERVICE_H
 #define CTKDICOMEXCHANGESERVICE_H
 
+#include "ctkSimpleSoapClient.h"
 #include "ctkDicomExchangeInterface.h"
 
 #include <org_commontk_dah_core_Export.h>
 
-class ctkDicomServicePrivate;
-
-class org_commontk_dah_core_EXPORT ctkDicomExchangeService : public ctkDicomExchangeInterface
+class org_commontk_dah_core_EXPORT ctkDicomExchangeService :
+    public ctkSimpleSoapClient, public ctkDicomExchangeInterface
 {
 
 public:
+
   ctkDicomExchangeService(ushort port, QString path);
   ~ctkDicomExchangeService();
 
@@ -41,9 +42,6 @@ public:
                                              QList<QString> acceptableTransferSyntaxUIDs, bool includeBulkData);
   void releaseData(QList<QUuid> objectUUIDs);
 
-
-protected:
-  ctkDicomServicePrivate * d;
 };
 
 #endif // CTKDICOMEXCHANGESERVICE_H

Plugins/org.commontk.dah.core/ctkDicomServicePrivate.cpp

@@ -19,81 +19,103 @@
 
 =============================================================================*/
 
-#include "ctkDicomServicePrivate.h"
-#include "ctkDicomAppHostingTypesHelper.h"
+#include "ctkSimpleSoapClient.h"
+#include "ctkDicomAppHostingTypes.h"
 
 #include <QApplication>
 #include <QCursor>
 #include <QNetworkReply>
+#include <QtSoapHttpTransport>
 
-#include <stdexcept>
+class ctkSimpleSoapClientPrivate
+{
+public:
+
+  QEventLoop blockingLoop;
+  QtSoapHttpTransport http;
+
+  int port;
+  QString path;
+};
+
+ctkSimpleSoapClient::ctkSimpleSoapClient(int port, QString path)
+  : d_ptr(new ctkSimpleSoapClientPrivate())
+{
+  Q_D(ctkSimpleSoapClient);
+
+  d->port = port;
+  d->path = path;
 
+  connect(&d->http, SIGNAL(responseReady()), this, SLOT(responseReady()));
 
-#include <iostream>
+  d->http.setHost("127.0.0.1", false, port);
+}
 
-ctkDicomServicePrivate::ctkDicomServicePrivate(int port, QString path) : path(path)
+ctkSimpleSoapClient::~ctkSimpleSoapClient()
 {
-  connect(&http, SIGNAL(responseReady()), this, SLOT(responseReady()));
 
-  http.setHost("127.0.0.1", false, port);
 }
 
-void ctkDicomServicePrivate::responseReady()
+void ctkSimpleSoapClient::responseReady()
 {
-  blockingLoop.exit();
+  Q_D(ctkSimpleSoapClient);
+  d->blockingLoop.exit();
 }
 
-const QtSoapType & ctkDicomServicePrivate::askHost(const QString& methodName,
+const QtSoapType & ctkSimpleSoapClient::submitSoapRequest(const QString& methodName,
                                                    QtSoapType* soapType )
 {
   QList<QtSoapType*> list;
   list.append(soapType);
-  return askHost(methodName,list);
+  return submitSoapRequest(methodName,list);
 }
 
-const QtSoapType & ctkDicomServicePrivate::askHost(const QString& methodName,
+const QtSoapType & ctkSimpleSoapClient::submitSoapRequest(const QString& methodName,
                                                    const QList<QtSoapType*>& soapTypes )
 {
+  Q_D(ctkSimpleSoapClient);
+
   QString action="\"";
   //action.append(methodName);
   action.append("\"");
-  http.setAction(action);
+  d->http.setAction(action);
 
-  std::cout << "Submitting action " << action.toStdString() << " method " << methodName.toStdString() << " to path " << path.toStdString();
+  qDebug() << "Submitting action " << action << " method " << methodName << " to path " << d->path;
 
   QtSoapMessage request;
   request.setMethod(QtSoapQName(methodName,"http://wg23.dicom.nema.org/"));
-  if( !soapTypes.isEmpty())
+  if(!soapTypes.isEmpty())
   {
     for (QList<QtSoapType*>::ConstIterator it = soapTypes.begin();
-    it < soapTypes.constEnd(); it++){
+         it < soapTypes.constEnd(); it++)
+    {
       request.addMethodArgument(*it);
       qDebug() << "  Argument type added " << (*it)->typeName() << ". Argument name is " << (*it)->name().name();;
     }
   }
   qDebug() << request.toXmlString();
 
-  http.submitRequest(request, path);;
+  d->http.submitRequest(request, d->path);;
 
   qDebug() << "Submitted request " << methodName ;
 
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
-  blockingLoop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);
+  d->blockingLoop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);
 
   QApplication::restoreOverrideCursor();
 
   //qDebug() << "Reply error: " << reply->errorString();
   //qDebug() << reply->readAll();
-  const QtSoapMessage& response = http.getResponse();
+  const QtSoapMessage& response = d->http.getResponse();
 
   if (response.isFault())
   {
-    qCritical() << "ctkDicomServicePrivate: server error (response.IsFault())";
+    qCritical() << "ctkSimpleSoapClient: server error (response.IsFault())";
     qDebug() << response.faultString().toString().toLatin1().constData() << endl;
     qDebug() << response.toXmlString();
     return response.returnValue();
-    //    throw std::runtime_error("ctkDicomServicePrivate: server error (response.IsFault())");
+    //    throw std::runtime_error("ctkSimpleSoapClient: server error (response.IsFault())");
   }
 
   qDebug() << "Response: " << response.toXmlString();

Plugins/org.commontk.dah.core/ctkDicomServicePrivate.h

@@ -19,35 +19,39 @@
 
 =============================================================================*/
 
-#ifndef CTKDICOMSERVICEPRIVATE_H
-#define CTKDICOMSERVICEPRIVATE_H
+#ifndef CTKSIMPLESOAPCLIENT_H
+#define CTKSIMPLESOAPCLIENT_H
 
-#include "ctkDicomAppHostingTypes.h"
+#include <QObject>
+#include <QScopedPointer>
 
-#include <QEventLoop>
-#include <QtSoapHttpTransport>
+#include <QtSoapType>
 
 #include <org_commontk_dah_core_Export.h>
 
-class org_commontk_dah_core_EXPORT ctkDicomServicePrivate : public QObject
+class ctkSimpleSoapClientPrivate;
+
+class org_commontk_dah_core_EXPORT ctkSimpleSoapClient : public QObject
 {
   Q_OBJECT
 
 public:
-  ctkDicomServicePrivate(int port, QString path);
-
-  const QtSoapType & askHost(const QString& methodName, const QList<QtSoapType*>& soapTypes);
-  const QtSoapType & askHost(const QString& methodName, QtSoapType* soapType);
-    
-  QEventLoop blockingLoop;
-  QtSoapHttpTransport http;
+  ctkSimpleSoapClient(int port, QString path);
+  ~ctkSimpleSoapClient();
 
-  int port;
-  QString path;
+  const QtSoapType & submitSoapRequest(const QString& methodName, const QList<QtSoapType*>& soapTypes);
+  const QtSoapType & submitSoapRequest(const QString& methodName, QtSoapType* soapType);
 
 private slots:
 
   void responseReady();
+
+private:
+
+  const QScopedPointer<ctkSimpleSoapClientPrivate> d_ptr;
+
+  Q_DECLARE_PRIVATE(ctkSimpleSoapClient);
+  Q_DISABLE_COPY(ctkSimpleSoapClient);
 };
 
-#endif // CTKDICOMSERVICEPRIVATE_H
+#endif // CTKSIMPLESOAPCLIENT_H

Plugins/org.commontk.dah.host/ctkDicomAppService.cpp

@@ -21,12 +21,12 @@
 
 #include "ctkDicomAppService.h"
 
-#include "ctkDicomServicePrivate.h"
+#include "ctkSimpleSoapClient.h"
 
 #include "ctkDicomAppHostingTypesHelper.h"
 
-ctkDicomAppService::ctkDicomAppService(ushort port, QString path):
-  d(new ctkDicomServicePrivate(port, path)), service(port, path)
+ctkDicomAppService::ctkDicomAppService(ushort port, QString path)
+  : ctkDicomExchangeService(port, path)
 {
 }
 
@@ -36,24 +36,21 @@ ctkDicomAppService::~ctkDicomAppService()
 
 ctkDicomAppHosting::State ctkDicomAppService::getState()
 {
-  //Q_D(ctkDicomService);
-  const QtSoapType & result = d->askHost("getState", NULL);
+  const QtSoapType & result = submitSoapRequest("getState", NULL);
   return ctkDicomSoapState::getState(result);
 }
 
 bool ctkDicomAppService::setState(ctkDicomAppHosting::State newState)
 {
-  //Q_D(ctkDicomService);
   QtSoapType* input = new ctkDicomSoapState("newState", newState);
-  const QtSoapType & result = d->askHost("setState", input);
+  const QtSoapType & result = submitSoapRequest("setState", input);
   return ctkDicomSoapBool::getBool(result);
 }
 
 bool ctkDicomAppService::bringToFront(const QRect& requestedScreenArea)
 {
-  //Q_D(ctkDicomService);
   QtSoapType* input = new ctkDicomSoapRectangle("requestedScreenArea", requestedScreenArea);
-  const QtSoapType & result = d->askHost("bringToFront", input);
+  const QtSoapType & result = submitSoapRequest("bringToFront", input);
   return ctkDicomSoapBool::getBool(result);
 }
 
@@ -61,7 +58,7 @@ bool ctkDicomAppService::bringToFront(const QRect& requestedScreenArea)
 
 bool ctkDicomAppService::notifyDataAvailable(ctkDicomAppHosting::AvailableData data, bool lastData)
 {
-  return service.notifyDataAvailable(data, lastData);
+  return ctkDicomExchangeService::notifyDataAvailable(data, lastData);
 }
 
 QList<ctkDicomAppHosting::ObjectLocator> ctkDicomAppService::getData(
@@ -69,10 +66,10 @@ QList<ctkDicomAppHosting::ObjectLocator> ctkDicomAppService::getData(
   QList<QString> acceptableTransferSyntaxUIDs, 
   bool includeBulkData)
 {
-  return service.getData(objectUUIDs, acceptableTransferSyntaxUIDs, includeBulkData);
+  return ctkDicomExchangeService::getData(objectUUIDs, acceptableTransferSyntaxUIDs, includeBulkData);
 }
 
 void ctkDicomAppService::releaseData(QList<QUuid> objectUUIDs)
 {
-  service.releaseData(objectUUIDs);
+  ctkDicomExchangeService::releaseData(objectUUIDs);
 }

Plugins/org.commontk.dah.host/ctkDicomAppService.h

@@ -25,9 +25,8 @@
 
 #include <ctkDicomAppInterface.h>
 #include <ctkDicomExchangeService.h>
-#include <org_commontk_dah_host_Export.h>
 
-class org_commontk_dah_host_EXPORT ctkDicomAppService : public ctkDicomAppInterface
+class ctkDicomAppService : public ctkDicomExchangeService, public ctkDicomAppInterface
 {
 
 public:
@@ -38,18 +37,16 @@ public:
   bool setState(ctkDicomAppHosting::State newState);
   bool bringToFront(const QRect& requestedScreenArea);
 
-  // Exchange methods
+  // Exchange methods implemented in ctkDicomExchangeService
   bool notifyDataAvailable(ctkDicomAppHosting::AvailableData data, bool lastData);
+
   QList<ctkDicomAppHosting::ObjectLocator> getData(
     QList<QUuid> objectUUIDs, 
     QList<QString> acceptableTransferSyntaxUIDs, 
     bool includeBulkData);
-  void releaseData(QList<QUuid> objectUUIDs);
 
-private:
-  ctkDicomServicePrivate * d;
+  void releaseData(QList<QUuid> objectUUIDs);
 
-  ctkDicomExchangeService service;
 };
 
 #endif // CTKDICOMAPPSERVICE_H