Moved fetch() methods to subclasses and use QMetaType to create instances.

Libs/XNAT/Core/ctkXnatDataModel.cpp

@@ -70,7 +70,19 @@ QString ctkXnatDataModel::resourceUri() const
 
 void ctkXnatDataModel::fetchImpl()
 {
-  this->session()->fetch(this);
+  Q_D(ctkXnatDataModel);
+
+  QString projectsUri("/data/archive/projects");
+
+  QUuid queryId = d->session->httpGet(projectsUri);
+  QList<ctkXnatObject*> projects = d->session->httpResults(queryId, ctkXnatProject::staticSchemaType());
+
+  qDebug() << "ctkXnatDataModel::fetchImpl(): project number:" << projects.size();
+
+  foreach (ctkXnatObject* project, projects)
+  {
+    this->add(project);
+  }
 }
 
 ctkXnatSession* ctkXnatDataModel::session() const

Libs/XNAT/Core/ctkXnatDataModel.h

@@ -35,6 +35,8 @@ class ctkXnatDataModel : public ctkXnatObject
 
 public:
 
+  CTK_XNAT_OBJECT(ctkXnatDataModel, ctkXnatObject, "https://central.xnat.org/schemas/xnat/xnat.xsd")
+
   ctkXnatDataModel(ctkXnatSession* connection);
 
   QList<ctkXnatProject*> projects() const;
@@ -48,7 +50,6 @@ private:
   virtual void fetchImpl();
 
   Q_DECLARE_PRIVATE(ctkXnatDataModel)
-  Q_DISABLE_COPY(ctkXnatDataModel)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatExperiment.cpp

@@ -24,6 +24,10 @@
 #include "ctkXnatSession.h"
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatSubject.h"
+#include "ctkXnatScan.h"
+#include "ctkXnatReconstruction.h"
+#include "ctkXnatScanFolder.h"
+#include "ctkXnatReconstructionFolder.h"
 
 class ctkXnatExperimentPrivate : public ctkXnatObjectPrivate
 {
@@ -43,8 +47,8 @@ public:
 };
 
 
-ctkXnatExperiment::ctkXnatExperiment(ctkXnatSubject* parent, const QString& schemaType)
-: ctkXnatObject(*new ctkXnatExperimentPrivate(), parent, schemaType)
+ctkXnatExperiment::ctkXnatExperiment(ctkXnatSubject* parent)
+: ctkXnatObject(*new ctkXnatExperimentPrivate(), parent)
 {
 }
 
@@ -64,5 +68,27 @@ void ctkXnatExperiment::reset()
 
 void ctkXnatExperiment::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString scansUri = this->resourceUri() + "/scans";
+  ctkXnatSession* const session = this->session();
+  QUuid scansQueryId = session->httpGet(scansUri);
+
+  QList<ctkXnatObject*> scans = session->httpResults(scansQueryId, ctkXnatScan::staticSchemaType());
+
+  if (!scans.isEmpty())
+  {
+    ctkXnatScanFolder* scanFolder = new ctkXnatScanFolder();
+    this->add(scanFolder);
+  }
+
+  QString reconstructionsUri = this->resourceUri() + "/reconstructions";
+  QUuid reconstructionsQueryId = session->httpGet(reconstructionsUri);
+
+  QList<ctkXnatObject*> reconstructions = session->httpResults(reconstructionsQueryId,
+                                                                   ctkXnatReconstruction::staticSchemaType());
+
+  if (!reconstructions.isEmpty())
+  {
+    ctkXnatReconstructionFolder* reconstructionFolder = new ctkXnatReconstructionFolder();
+    this->add(reconstructionFolder);
+  }
 }

Libs/XNAT/Core/ctkXnatExperiment.h

@@ -32,24 +32,23 @@ class ctkXnatSubject;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatExperiment : public ctkXnatObject
 {
-  
+
 public:
-  
-  explicit ctkXnatExperiment(ctkXnatSubject* parent = 0, const QString& schemaType = "xnat:experimentData");
+
+  CTK_XNAT_OBJECT(ctkXnatExperiment, ctkXnatObject, "xnat:experimentData")
+
+  explicit ctkXnatExperiment(ctkXnatSubject* parent = 0);
   virtual ~ctkXnatExperiment();
-  
+
   virtual QString resourceUri() const;
 
   void reset();
-  
+
 private:
-  
-  friend class qRestResult;
 
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatExperiment);
-  Q_DISABLE_COPY(ctkXnatExperiment);
+
+  Q_DECLARE_PRIVATE(ctkXnatExperiment)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatFile.h

@@ -34,23 +34,23 @@ class CTK_XNAT_CORE_EXPORT ctkXnatFile : public ctkXnatObject
 
 public:
 
+  CTK_XNAT_OBJECT(ctkXnatFile, ctkXnatObject, "xnat:abstractResource")
+
   explicit ctkXnatFile(ctkXnatObject* parent = 0);
   virtual ~ctkXnatFile();
-  
+
   virtual QString resourceUri() const;
 
   void download(const QString& filename);
   void upload(const QString& filename);
 
   void reset();
-  
+
 private:
-  
-  friend class qRestResult;
+
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatFile);
-  Q_DISABLE_COPY(ctkXnatFile);
+
+  Q_DECLARE_PRIVATE(ctkXnatFile)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatObject.cpp

@@ -29,23 +29,26 @@
 #include <QVariant>
 
 
-ctkXnatObject::ctkXnatObject(ctkXnatObject* parent, const QString& schemaType)
+ctkXnatObject::ctkXnatObject(ctkXnatObject* parent)
 : d_ptr(new ctkXnatObjectPrivate())
 {
   Q_D(ctkXnatObject);
   this->setParent(parent);
-  d->schemaType = schemaType;
 }
 
-ctkXnatObject::ctkXnatObject(ctkXnatObjectPrivate& dd, ctkXnatObject* parent, const QString& schemaType)
+ctkXnatObject::ctkXnatObject(ctkXnatObjectPrivate& dd, ctkXnatObject* parent)
 : d_ptr(&dd)
 {
   Q_D(ctkXnatObject);
   this->setParent(parent);
-  d->schemaType = schemaType;
 }
 
 
+ctkXnatObject::ctkXnatObject(const ctkXnatObject& /*other*/)
+{
+  throw ctkRuntimeException("Copy constructor not implemented");
+}
+
 ctkXnatObject::~ctkXnatObject()
 {
   Q_D(ctkXnatObject);
@@ -65,12 +68,6 @@ void ctkXnatObject::setId(const QString& id)
   setProperty("ID", id);
 }
 
-QString ctkXnatObject::schemaType() const
-{
-  Q_D(const ctkXnatObject);
-  return d->schemaType;
-}
-
 QString ctkXnatObject::name() const
 {
   return property("name");

Libs/XNAT/Core/ctkXnatObject.h

@@ -24,6 +24,8 @@
 
 #include "ctkXNATCoreExport.h"
 
+#include "ctkException.h"
+
 #include <QList>
 #include <QObject>
 #include <QString>
@@ -32,6 +34,11 @@
 class ctkXnatSession;
 class ctkXnatObjectPrivate;
 
+#define CTK_XNAT_OBJECT(classType_, baseType_, schemaType_) \
+  classType_(const classType_& other) : baseType_(other) { throw ctkRuntimeException("Copy constructor not implemented"); } \
+  static const char* staticSchemaType() { return schemaType_; } \
+  virtual const char* schemaType() const { return schemaType_; }
+
 //----------------------------------------------------------------------------
 /// \ingroup XNATCore
 /// ctkXnatObject is the base class of the objects that represent the nodes in
@@ -41,11 +48,14 @@ class CTK_XNAT_CORE_EXPORT ctkXnatObject
 
 public:
 
+  /// No-op. Throws a ctkRuntimeException
+  ctkXnatObject(const ctkXnatObject& other);
+
   /// Destructs the ctkXnatObject.
   virtual ~ctkXnatObject();
 
-  /// Gets the XML Schema type of the object.
-  QString schemaType() const;
+  /// Get the dynamic schema type of object.
+  virtual const char* schemaType() const = 0;
 
   /// Gets the ID of the object.
   QString id() const;
@@ -135,10 +145,10 @@ public:
 protected:
 
   /// Constructs the ctkXnatObject.
-  ctkXnatObject(ctkXnatObject* parent = 0, const QString& schemaType = QString());
+  ctkXnatObject(ctkXnatObject* parent = 0);
 
   /// Constructs the ctkXnatObject with the given private part.
-  ctkXnatObject(ctkXnatObjectPrivate& dd, ctkXnatObject* parent = 0, const QString& schemaType = QString());
+  ctkXnatObject(ctkXnatObjectPrivate& dd, ctkXnatObject* parent = 0);
 
   /// Gets the object that represents the connection to the XNAT server
   /// that stores the current object.
@@ -155,7 +165,6 @@ private:
   virtual void fetchImpl() = 0;
 
   Q_DECLARE_PRIVATE(ctkXnatObject)
-  Q_DISABLE_COPY(ctkXnatObject)
 };
 
 Q_DECLARE_METATYPE(ctkXnatObject*)

Libs/XNAT/Core/ctkXnatObjectPrivate.h

@@ -44,8 +44,6 @@ private:
 
   friend class ctkXnatObject;
 
-  QString schemaType;
-
   QMap<QString, QString> properties;
 
   QList<ctkXnatObject*> children;

Libs/XNAT/Core/ctkXnatProject.cpp

@@ -23,6 +23,7 @@
 
 #include "ctkXnatDataModel.h"
 #include "ctkXnatSession.h"
+#include "ctkXnatSubject.h"
 #include "ctkXnatObjectPrivate.h"
 
 class ctkXnatProjectPrivate : public ctkXnatObjectPrivate
@@ -48,8 +49,8 @@ public:
 //  QString uri;
 };
 
-ctkXnatProject::ctkXnatProject(ctkXnatDataModel* parent, const QString& schemaType)
-: ctkXnatObject(*new ctkXnatProjectPrivate(), parent, schemaType)
+ctkXnatProject::ctkXnatProject(ctkXnatDataModel* parent)
+: ctkXnatObject(*new ctkXnatProjectPrivate(), parent)
 {
 }
 
@@ -117,5 +118,19 @@ void ctkXnatProject::reset()
 
 void ctkXnatProject::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString subjectsUri = this->resourceUri() + "/subjects";
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(subjectsUri);
+  QList<ctkXnatObject*> subjects = session->httpResults(queryId, ctkXnatSubject::staticSchemaType());
+
+  foreach (ctkXnatObject* subject, subjects)
+  {
+    QString label = subject->property("label");
+    if (!label.isEmpty())
+    {
+      subject->setProperty("ID", label);
+    }
+
+    this->add(subject);
+  }
 }

Libs/XNAT/Core/ctkXnatProject.h

@@ -34,7 +34,9 @@ class CTK_XNAT_CORE_EXPORT ctkXnatProject : public ctkXnatObject
 
 public:
 
-  explicit ctkXnatProject(ctkXnatDataModel* parent = 0, const QString& schemaType = "xnat:projectData");
+  CTK_XNAT_OBJECT(ctkXnatProject, ctkXnatObject, "xnat::projectData")
+
+  explicit ctkXnatProject(ctkXnatDataModel* parent = 0);
   virtual ~ctkXnatProject();
 
   virtual QString resourceUri() const;
@@ -52,12 +54,9 @@ public:
 
 private:
 
-  friend class qRestResult;
-
   virtual void fetchImpl();
 
   Q_DECLARE_PRIVATE(ctkXnatProject)
-  Q_DISABLE_COPY(ctkXnatProject)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatReconstruction.cpp

@@ -24,6 +24,7 @@
 #include "ctkXnatSession.h"
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatReconstructionFolder.h"
+#include "ctkXnatReconstructionResource.h"
 
 class ctkXnatReconstructionPrivate : public ctkXnatObjectPrivate
 {
@@ -43,8 +44,8 @@ public:
 };
 
 
-ctkXnatReconstruction::ctkXnatReconstruction(ctkXnatReconstructionFolder* parent, const QString& schemaType)
-: ctkXnatObject(*new ctkXnatReconstructionPrivate(), parent, schemaType)
+ctkXnatReconstruction::ctkXnatReconstruction(ctkXnatReconstructionFolder* parent)
+: ctkXnatObject(*new ctkXnatReconstructionPrivate(), parent)
 {
 }
 
@@ -64,5 +65,21 @@ void ctkXnatReconstruction::reset()
 
 void ctkXnatReconstruction::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString reconstructionResourcesUri = this->resourceUri() + "/resources";
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(reconstructionResourcesUri);
+
+  QList<ctkXnatObject*> reconstructionResources = session->httpResults(queryId,
+                                                                   ctkXnatReconstructionResource::staticSchemaType());
+
+  foreach (ctkXnatObject* reconstructionResource, reconstructionResources)
+  {
+    QString label = reconstructionResource->property("label");
+    if (!label.isEmpty())
+    {
+      reconstructionResource->setProperty("ID", label);
+    }
+
+    this->add(reconstructionResource);
+  }
 }

Libs/XNAT/Core/ctkXnatReconstruction.h

@@ -35,20 +35,20 @@ class CTK_XNAT_CORE_EXPORT ctkXnatReconstruction : public ctkXnatObject
 
 public:
 
-  explicit ctkXnatReconstruction(ctkXnatReconstructionFolder* parent = 0, const QString& schemaType = "xnat:reconstructedImageData");
+  CTK_XNAT_OBJECT(ctkXnatReconstruction, ctkXnatObject, "xnat:reconstructedImageData")
+
+  explicit ctkXnatReconstruction(ctkXnatReconstructionFolder* parent = 0);
   virtual ~ctkXnatReconstruction();
-  
+
   virtual QString resourceUri() const;
 
   void reset();
-  
+
 private:
-  
-  friend class qRestResult;
+
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatReconstruction);
-  Q_DISABLE_COPY(ctkXnatReconstruction);
+
+  Q_DECLARE_PRIVATE(ctkXnatReconstruction)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatReconstructionFolder.cpp

@@ -24,6 +24,7 @@
 #include "ctkXnatSession.h"
 #include "ctkXnatExperiment.h"
 #include "ctkXnatObjectPrivate.h"
+#include "ctkXnatReconstruction.h"
 
 
 class ctkXnatReconstructionFolderPrivate : public ctkXnatObjectPrivate
@@ -66,5 +67,15 @@ void ctkXnatReconstructionFolder::reset()
 
 void ctkXnatReconstructionFolder::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString reconstructionsUri = this->resourceUri();
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(reconstructionsUri);
+
+  QList<ctkXnatObject*> reconstructions = session->httpResults(queryId, ctkXnatReconstruction::staticSchemaType());
+
+  foreach (ctkXnatObject* reconstruction, reconstructions)
+  {
+    this->add(reconstruction);
+  }
+
 }

Libs/XNAT/Core/ctkXnatReconstructionFolder.h

@@ -34,22 +34,21 @@ class CTK_XNAT_CORE_EXPORT ctkXnatReconstructionFolder : public ctkXnatObject
 {
 
 public:
-  
+
+  CTK_XNAT_OBJECT(ctkXnatReconstructionFolder, ctkXnatObject, "xnat:reconstructedImageFolder")
+
   explicit ctkXnatReconstructionFolder(ctkXnatExperiment* parent = 0);
   virtual ~ctkXnatReconstructionFolder();
-  
+
   virtual QString resourceUri() const;
 
   void reset();
-  
+
 private:
-  
-  friend class qRestResult;
 
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatReconstructionFolder);
-  Q_DISABLE_COPY(ctkXnatReconstructionFolder);
+
+  Q_DECLARE_PRIVATE(ctkXnatReconstructionFolder)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatReconstructionResource.cpp

@@ -22,6 +22,7 @@
 #include "ctkXnatReconstructionResource.h"
 
 #include "ctkXnatSession.h"
+#include "ctkXnatFile.h"
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatReconstruction.h"
 
@@ -64,7 +65,22 @@ void ctkXnatReconstructionResource::reset()
 
 void ctkXnatReconstructionResource::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString reconstructionResourceFilesUri = this->resourceUri() + "/files";
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(reconstructionResourceFilesUri);
+
+  QList<ctkXnatObject*> files = session->httpResults(queryId, ctkXnatFile::staticSchemaType());
+
+  foreach (ctkXnatObject* file, files)
+  {
+    QString label = file->property("Name");
+    if (label.isEmpty())
+    {
+      file->setProperty("ID", label);
+    }
+
+    this->add(file);
+  }
 }
 
 void ctkXnatReconstructionResource::download(const QString& filename)

Libs/XNAT/Core/ctkXnatReconstructionResource.h

@@ -32,26 +32,27 @@ class ctkXnatReconstruction;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstructionResource : public ctkXnatObject
 {
-  
+
 public:
 
+  CTK_XNAT_OBJECT(ctkXnatReconstructionResource, ctkXnatObject, "xnat:reconstructionResource")
+
   explicit ctkXnatReconstructionResource(ctkXnatReconstruction* parent = 0);
   virtual ~ctkXnatReconstructionResource();
-  
+
   virtual QString resourceUri() const;
 
   void reset();
-  
+
   void download(const QString& filename);
 
 private:
-  
+
   friend class qRestResult;
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatReconstructionResource);
-  Q_DISABLE_COPY(ctkXnatReconstructionResource);
-  
+
+  Q_DECLARE_PRIVATE(ctkXnatReconstructionResource)
+
 };
 
 #endif

Libs/XNAT/Core/ctkXnatScan.cpp

@@ -23,6 +23,8 @@
 
 #include "ctkXnatSession.h"
 #include "ctkXnatScanFolder.h"
+#include "ctkXnatScanResource.h"
+#include "ctkXnatObject.h"
 #include "ctkXnatObjectPrivate.h"
 
 class ctkXnatScanPrivate : public ctkXnatObjectPrivate
@@ -43,8 +45,8 @@ public:
 };
 
 
-ctkXnatScan::ctkXnatScan(ctkXnatScanFolder* parent, const QString& schemaType)
-: ctkXnatObject(*new ctkXnatScanPrivate(), parent, schemaType)
+ctkXnatScan::ctkXnatScan(ctkXnatScanFolder* parent)
+: ctkXnatObject(*new ctkXnatScanPrivate(), parent)
 {
 }
 
@@ -64,5 +66,19 @@ void ctkXnatScan::reset()
 
 void ctkXnatScan::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString scanResourcesUri = this->resourceUri() + "/resources";
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(scanResourcesUri);
+
+  QList<ctkXnatObject*> scanResources = session->httpResults(queryId, ctkXnatScanResource::staticSchemaType());
+
+  foreach (ctkXnatObject* scanResource, scanResources)
+  {
+    QString label = scanResource->property("label");
+    if (!label.isEmpty())
+    {
+      scanResource->setProperty("ID", label);
+    }
+    this->add(scanResource);
+  }
 }

Libs/XNAT/Core/ctkXnatScan.h

@@ -35,20 +35,21 @@ class CTK_XNAT_CORE_EXPORT ctkXnatScan : public ctkXnatObject
 
 public:
 
-  explicit ctkXnatScan(ctkXnatScanFolder* parent = 0, const QString& schemaType = "xnat:imageScanData");
+  CTK_XNAT_OBJECT(ctkXnatScan, ctkXnatObject, "xnat:imageScanData")
+
+  explicit ctkXnatScan(ctkXnatScanFolder* parent = 0);
   virtual ~ctkXnatScan();
-  
+
   virtual QString resourceUri() const;
 
   void reset();
-  
+
 private:
-  
+
   friend class qRestResult;
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatScan);
-  Q_DISABLE_COPY(ctkXnatScan);
+
+  Q_DECLARE_PRIVATE(ctkXnatScan)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatScanFolder.cpp

@@ -24,7 +24,7 @@
 #include "ctkXnatSession.h"
 #include "ctkXnatExperiment.h"
 #include "ctkXnatObjectPrivate.h"
-
+#include "ctkXnatScan.h"
 
 class ctkXnatScanFolderPrivate : public ctkXnatObjectPrivate
 {
@@ -66,5 +66,14 @@ void ctkXnatScanFolder::reset()
 
 void ctkXnatScanFolder::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString scansUri = this->resourceUri();
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(scansUri);
+
+  QList<ctkXnatObject*> scans = session->httpResults(queryId, ctkXnatScan::staticSchemaType());
+
+  foreach (ctkXnatObject* scan, scans)
+  {
+    this->add(scan);
+  }
 }

Libs/XNAT/Core/ctkXnatScanFolder.h

@@ -34,21 +34,22 @@ class CTK_XNAT_CORE_EXPORT ctkXnatScanFolder : public ctkXnatObject
 {
 
 public:
-  
+
+  CTK_XNAT_OBJECT(ctkXnatScanFolder, ctkXnatObject, "xnat:imageScanFolder")
+
   explicit ctkXnatScanFolder(ctkXnatExperiment* parent = 0);
   virtual ~ctkXnatScanFolder();
-  
+
   virtual QString resourceUri() const;
-  
+
   void reset();
-  
+
 private:
-  
+
   friend class qRestResult;
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatScanFolder);
-  Q_DISABLE_COPY(ctkXnatScanFolder);
+
+  Q_DECLARE_PRIVATE(ctkXnatScanFolder)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatScanResource.cpp

@@ -24,6 +24,7 @@
 #include "ctkXnatSession.h"
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatScan.h"
+#include "ctkXnatFile.h"
 
 class ctkXnatScanResourcePrivate : public ctkXnatObjectPrivate
 {
@@ -64,7 +65,21 @@ void ctkXnatScanResource::reset()
 
 void ctkXnatScanResource::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString scanResourceFilesUri = this->resourceUri() + "/files";
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(scanResourceFilesUri);
+
+  QList<ctkXnatObject*> files = session->httpResults(queryId, ctkXnatFile::staticSchemaType());
+
+  foreach (ctkXnatObject* file, files)
+  {
+    QString label = file->property("Name");
+    if (!label.isEmpty())
+    {
+      file->setProperty("ID", label);
+    }
+    this->add(file);
+  }
 }
 
 void ctkXnatScanResource::download(const QString& filename)

Libs/XNAT/Core/ctkXnatScanResource.h

@@ -32,26 +32,27 @@ class ctkXnatScanResourcePrivate;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatScanResource : public ctkXnatObject
 {
-  
+
 public:
 
+  CTK_XNAT_OBJECT(ctkXnatScanResource, ctkXnatObject, "xnat:scanResource")
+
   explicit ctkXnatScanResource(ctkXnatScan* parent = 0);
   virtual ~ctkXnatScanResource();
 
   QString resourceUri() const;
-  
+
   void reset();
-  
+
   void download(const QString& filename);
 
 private:
-  
+
   friend class qRestResult;
   virtual void fetchImpl();
-  
-  Q_DECLARE_PRIVATE(ctkXnatScanResource);
-  Q_DISABLE_COPY(ctkXnatScanResource);
-  
+
+  Q_DECLARE_PRIVATE(ctkXnatScanResource)
+
 };
 
 #endif

Libs/XNAT/Core/ctkXnatSession.cpp

@@ -55,6 +55,8 @@ public:
   ~ctkXnatSessionPrivate();
 
   void throwXnatException(const QString& msg);
+
+  void createConnections();
 };
 
 ctkXnatSessionPrivate::ctkXnatSessionPrivate(const ctkXnatLoginProfile& loginProfile, ctkXnatSession* q)
@@ -65,6 +67,8 @@ ctkXnatSessionPrivate::ctkXnatSessionPrivate(const ctkXnatLoginProfile& loginPro
   // TODO This is a workaround for connecting to sites with self-signed
   // certificate. Should be replaced with something more clever.
   xnat->setSuppressSslErrors(true);
+
+  createConnections();
 }
 
 ctkXnatSessionPrivate::~ctkXnatSessionPrivate()
@@ -93,6 +97,15 @@ void ctkXnatSessionPrivate::throwXnatException(const QString& msg)
   }
 }
 
+void ctkXnatSessionPrivate::createConnections()
+{
+//  Q_D(ctkXnatSession);
+//  connect(d->xnat, SIGNAL(resultReceived(QUuid,QList<QVariantMap>)),
+//           this, SLOT(processResult(QUuid,QList<QVariantMap>)));
+//  connect(d->xnat, SIGNAL(progress(QUuid,double)),
+  //           this, SLOT(progress(QUuid,double)));
+}
+
 // ctkXnatSession class
 
 ctkXnatSession::ctkXnatSession(const ctkXnatLoginProfile& loginProfile)
@@ -100,6 +113,16 @@ ctkXnatSession::ctkXnatSession(const ctkXnatLoginProfile& loginProfile)
 {
   Q_D(ctkXnatSession);
 
+  qRegisterMetaType<ctkXnatProject>(ctkXnatProject::staticSchemaType());
+  qRegisterMetaType<ctkXnatSubject>(ctkXnatSubject::staticSchemaType());
+  qRegisterMetaType<ctkXnatExperiment>(ctkXnatExperiment::staticSchemaType());
+  qRegisterMetaType<ctkXnatScan>(ctkXnatScan::staticSchemaType());
+  qRegisterMetaType<ctkXnatScanFolder>(ctkXnatScanFolder::staticSchemaType());
+  qRegisterMetaType<ctkXnatReconstruction>(ctkXnatReconstruction::staticSchemaType());
+  qRegisterMetaType<ctkXnatScanResource>(ctkXnatScanResource::staticSchemaType());
+  qRegisterMetaType<ctkXnatFile>(ctkXnatFile::staticSchemaType());
+  qRegisterMetaType<ctkXnatReconstructionResource>(ctkXnatReconstructionResource::staticSchemaType());
+
   ctkXnatAPI::RawHeaders rawHeaders;
   rawHeaders["User-Agent"] = "Qt";
   rawHeaders["Authorization"] = "Basic " +
@@ -111,23 +134,12 @@ ctkXnatSession::ctkXnatSession(const ctkXnatLoginProfile& loginProfile)
   d->xnat->setServerUrl(url);
 
   d->dataModel->setProperty("ID", url);
-
-  createConnections();
 }
 
 ctkXnatSession::~ctkXnatSession()
 {
 }
 
-void ctkXnatSession::createConnections()
-{
-//  Q_D(ctkXnatSession);
-//  connect(d->xnat, SIGNAL(resultReceived(QUuid,QList<QVariantMap>)),
-//           this, SLOT(processResult(QUuid,QList<QVariantMap>)));
-//  connect(d->xnat, SIGNAL(progress(QUuid,double)),
-  //           this, SLOT(progress(QUuid,double)));
-}
-
 ctkXnatLoginProfile ctkXnatSession::loginProfile() const
 {
   Q_D(const ctkXnatSession);
@@ -165,228 +177,22 @@ ctkXnatDataModel* ctkXnatSession::dataModel() const
   return d->dataModel;
 }
 
-void ctkXnatSession::fetch(ctkXnatDataModel* dataModel)
-{
-  Q_D(ctkXnatSession);
-
-  QString projectsUri("/data/archive/projects");
-
-  QUuid queryId = d->xnat->get(projectsUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-  QList<ctkXnatProject*> projects = restResult->results<ctkXnatProject>();
-
-  qDebug() << "ctkXnatSession::fetch(ctkXnatDataModel* server): project number:" << projects.size();
-
-  foreach (ctkXnatProject* project, projects)
-  {
-    dataModel->add(project);
-  }
-
-  delete restResult;
-}
-
-void ctkXnatSession::fetch(ctkXnatProject* project)
+QUuid ctkXnatSession::httpGet(const QString& resource, const ctkXnatSession::UrlParameters& parameters, const ctkXnatSession::HttpRawHeaders& rawHeaders)
 {
   Q_D(ctkXnatSession);
-
-  QString subjectsUri = project->resourceUri() + "/subjects";
-  QUuid queryId = d->xnat->get(subjectsUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-  QList<ctkXnatSubject*> subjects = restResult->results<ctkXnatSubject>();
-
-  foreach (ctkXnatSubject* subject, subjects)
-  {
-    QString label = subject->property("label");
-    if (label.size())
-    {
-      subject->setProperty("ID", label);
-    }
-
-    project->add(subject);
-  }
-
-  delete restResult;
+  return d->xnat->get(resource, parameters, rawHeaders);
 }
 
-void ctkXnatSession::fetch(ctkXnatSubject* subject)
+QList<ctkXnatObject*> ctkXnatSession::httpResults(const QUuid& uuid, const QString& schemaType)
 {
   Q_D(ctkXnatSession);
 
-  QString experimentsUri = subject->resourceUri() + "/experiments";
-  QUuid queryId = d->xnat->get(experimentsUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-
-  QList<ctkXnatExperiment*> experiments = restResult->results<ctkXnatExperiment>();
-
-  foreach (ctkXnatExperiment* experiment, experiments)
+  QScopedPointer<qRestResult> restResult(d->xnat->takeResult(uuid));
+  if (restResult == NULL)
   {
-    QString label = experiment->property ("label");
-    if (label.size())
-    {
-      experiment->setProperty ("ID", label);
-    }
-
-    subject->add(experiment);
-  }
-
-  delete restResult;
-}
-
-void ctkXnatSession::fetch(ctkXnatExperiment* experiment)
-{
-  Q_D(ctkXnatSession);
-
-  QString scansUri = experiment->resourceUri() + "/scans";
-  QUuid scansQueryId = d->xnat->get(scansUri);
-  qRestResult* restResult = d->xnat->takeResult(scansQueryId);
-
-  QList<ctkXnatScan*> scans = restResult->results<ctkXnatScan>();
-
-  if (scans.size() > 0)
-  {
-    ctkXnatScanFolder* scanFolder = new ctkXnatScanFolder();
-    experiment->add(scanFolder);
-  }
-
-  delete restResult;
-
-  QString reconstructionsUri = experiment->resourceUri() + "/reconstructions";
-  QUuid reconstructionsQueryId = d->xnat->get(reconstructionsUri);
-  restResult = d->xnat->takeResult(reconstructionsQueryId);
-
-  QList<ctkXnatReconstruction*> reconstructions = restResult->results<ctkXnatReconstruction>();
-
-  if (reconstructions.size() > 0)
-  {
-    ctkXnatReconstructionFolder* reconstructionFolder = new ctkXnatReconstructionFolder();
-    experiment->add(reconstructionFolder);
-  }
-
-  delete restResult;
-}
-
-void ctkXnatSession::fetch(ctkXnatScanFolder* scanFolder)
-{
-  Q_D(ctkXnatSession);
-
-  QString scansUri = scanFolder->resourceUri();
-  QUuid queryId = d->xnat->get(scansUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-
-  QList<ctkXnatScan*> scans = restResult->results<ctkXnatScan>();
-
-  foreach (ctkXnatScan* scan, scans)
-  {
-    scanFolder->add(scan);
-  }
-
-  delete restResult;
-
-}
-
-void ctkXnatSession::fetch(ctkXnatScan* scan)
-{
-  Q_D(ctkXnatSession);
-
-  QString scanResourcesUri = scan->resourceUri() + "/resources";
-  QUuid queryId = d->xnat->get(scanResourcesUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-
-  QList<ctkXnatScanResource*> scanResources = restResult->results<ctkXnatScanResource>();
-
-  foreach (ctkXnatScanResource* scanResource, scanResources)
-  {
-    QString label = scanResource->property("label");
-    if (label.size())
-    {
-      scanResource->setProperty("ID", label);
-    }
-    scan->add(scanResource);
-  }
-}
-
-void ctkXnatSession::fetch(ctkXnatScanResource* scanResource)
-{
-  Q_D(ctkXnatSession);
-
-  QString scanResourceFilesUri = scanResource->resourceUri() + "/files";
-  QUuid queryId = d->xnat->get(scanResourceFilesUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-
-  QList<ctkXnatFile*> files = restResult->results<ctkXnatFile>();
-
-  foreach (ctkXnatFile* file, files)
-  {
-    QString label = file->property("Name");
-    if (label.size())
-    {
-      file->setProperty("ID", label);
-    }
-    scanResource->add(file);
-  }
-}
-
-void ctkXnatSession::fetch(ctkXnatReconstructionFolder* reconstructionFolder)
-{
-  Q_D(ctkXnatSession);
-
-  QString reconstructionsUri = reconstructionFolder->resourceUri();
-  QUuid queryId = d->xnat->get(reconstructionsUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-
-  QList<ctkXnatReconstruction*> reconstructions = restResult->results<ctkXnatReconstruction>();
-
-  foreach (ctkXnatReconstruction* reconstruction, reconstructions)
-  {
-    reconstructionFolder->add(reconstruction);
-  }
-
-  delete restResult;
-
-}
-
-void ctkXnatSession::fetch(ctkXnatReconstruction* reconstruction)
-{
-  Q_D(ctkXnatSession);
-
-  QString reconstructionResourcesUri = reconstruction->resourceUri() + "/resources";
-  QUuid queryId = d->xnat->get(reconstructionResourcesUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-
-  QList<ctkXnatReconstructionResource*> reconstructionResources = restResult->results<ctkXnatReconstructionResource>();
-
-  foreach (ctkXnatReconstructionResource* reconstructionResource, reconstructionResources)
-  {
-    QString label = reconstructionResource->property("label");
-    if (label.size())
-    {
-      reconstructionResource->setProperty("ID", label);
-    }
-
-    reconstruction->add(reconstructionResource);
-  }
-}
-
-void ctkXnatSession::fetch(ctkXnatReconstructionResource* reconstructionResource)
-{
-  Q_D(ctkXnatSession);
-
-  QString reconstructionResourceFilesUri = reconstructionResource->resourceUri() + "/files";
-  QUuid queryId = d->xnat->get(reconstructionResourceFilesUri);
-  qRestResult* restResult = d->xnat->takeResult(queryId);
-
-  QList<ctkXnatFile*> files = restResult->results<ctkXnatFile>();
-
-  foreach (ctkXnatFile* file, files)
-  {
-    QString label = file->property("Name");
-    if (label.size())
-    {
-      file->setProperty("ID", label);
-    }
-
-    reconstructionResource->add(file);
+    d->throwXnatException("REST result is NULL");
   }
+  return restResult->results<ctkXnatObject>(schemaType);
 }
 
 bool ctkXnatSession::exists(const ctkXnatObject* object)

Libs/XNAT/Core/ctkXnatSession.h

@@ -33,36 +33,24 @@
 
 class ctkXnatSessionPrivate;
 
-class ctkXnatDataModel;
-class ctkXnatExperiment;
 class ctkXnatFile;
 class ctkXnatLoginProfile;
+class ctkXnatDataModel;
 class ctkXnatObject;
-class ctkXnatProject;
-class ctkXnatReconstruction;
-class ctkXnatReconstructionFolder;
-class ctkXnatReconstructionResource;
-class ctkXnatRoot;
-class ctkXnatScan;
-class ctkXnatScanFolder;
 class ctkXnatScanResource;
-class ctkXnatSubject;
+class ctkXnatReconstructionResource;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatSession
 {
 
 public:
 
-  //********
-  // Add ctkXnatLoginProfile argument
+  typedef QMap<QString, QString> UrlParameters;
+  typedef QMap<QByteArray, QByteArray> HttpRawHeaders;
+
   ctkXnatSession(const ctkXnatLoginProfile& loginProfile);
   ~ctkXnatSession();
 
-  // **********
-  // Remove ?
-  // For Qt singal/slots; should go into the constructor or private impl.
-  void createConnections();
-
   /**
    * @brief Get the current login profile for this session object.
    * @return A copy of the currently used login profile.
@@ -98,18 +86,11 @@ public:
 
   ctkXnatDataModel* dataModel() const;
 
-  // **********
-  // Should these methods still be moved to the subclasses?
-  void fetch(ctkXnatDataModel* server);
-  void fetch(ctkXnatProject* project);
-  void fetch(ctkXnatSubject* subject);
-  void fetch(ctkXnatExperiment* experiment);
-  void fetch(ctkXnatScanFolder* scanFolder);
-  void fetch(ctkXnatScan* scan);
-  void fetch(ctkXnatScanResource* scanResource);
-  void fetch(ctkXnatReconstructionFolder* reconstructionFolder);
-  void fetch(ctkXnatReconstruction* reconstruction);
-  void fetch(ctkXnatReconstructionResource* reconstructionResource);
+  QUuid httpGet(const QString& resource,
+                const UrlParameters& parameters = UrlParameters(),
+                const HttpRawHeaders& rawHeaders = HttpRawHeaders());
+
+  QList<ctkXnatObject*> httpResults(const QUuid& uuid, const QString& schemaType);
 
   bool exists(const ctkXnatObject* object);
 

Libs/XNAT/Core/ctkXnatSubject.cpp

@@ -25,6 +25,7 @@
 
 #include "ctkXnatSession.h"
 #include "ctkXnatObjectPrivate.h"
+#include "ctkXnatExperiment.h"
 #include "ctkXnatProject.h"
 
 class ctkXnatSubjectPrivate : public ctkXnatObjectPrivate
@@ -51,8 +52,8 @@ public:
   QList<ctkXnatProject*> projects;
 };
 
-ctkXnatSubject::ctkXnatSubject(ctkXnatProject* parent, const QString& schemaType)
-: ctkXnatObject(*new ctkXnatSubjectPrivate(), parent, schemaType)
+ctkXnatSubject::ctkXnatSubject(ctkXnatProject* parent)
+: ctkXnatObject(*new ctkXnatSubjectPrivate(), parent)
 {
 }
 
@@ -97,5 +98,19 @@ void ctkXnatSubject::reset()
 
 void ctkXnatSubject::fetchImpl()
 {
-  this->session()->fetch(this);
+  QString experimentsUri = this->resourceUri() + "/experiments";
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(experimentsUri);
+  QList<ctkXnatObject*> experiments = session->httpResults(queryId, ctkXnatExperiment::staticSchemaType());
+
+  foreach (ctkXnatObject* experiment, experiments)
+  {
+    QString label = experiment->property ("label");
+    if (!label.isEmpty())
+    {
+      experiment->setProperty ("ID", label);
+    }
+
+    this->add(experiment);
+  }
 }

Libs/XNAT/Core/ctkXnatSubject.h

@@ -34,7 +34,9 @@ class CTK_XNAT_CORE_EXPORT ctkXnatSubject : public ctkXnatObject
 
 public:
 
-  explicit ctkXnatSubject(ctkXnatProject* parent = 0, const QString& schemaType = "xnat:subjectData");
+  CTK_XNAT_OBJECT(ctkXnatSubject, ctkXnatObject, "xnat:subjectData")
+
+  explicit ctkXnatSubject(ctkXnatProject* parent = 0);
   virtual ~ctkXnatSubject();
 
   ctkXnatProject* getPrimaryProject() const;
@@ -49,7 +51,7 @@ public:
   virtual QString resourceUri() const;
 
   void reset();
-  
+
 private:
 
   friend class qRestResult;
@@ -57,7 +59,6 @@ private:
   virtual void fetchImpl();
 
   Q_DECLARE_PRIVATE(ctkXnatSubject)
-  Q_DISABLE_COPY(ctkXnatSubject)
 };
 
 #endif