ctkXnatObject redesign. No QObjects, using QSharedPointer.

Libs/XNAT/Core/CMakeLists.txt

@@ -10,17 +10,18 @@ set(KIT_SRCS
   ctkXnatConnection.cpp
   ctkXnatConnectionFactory.cpp
   ctkXnatException.cpp
-  ctkXnatExperiment.cpp
+  #ctkXnatExperiment.cpp
   ctkXnatObject.cpp
+  ctkXnatObjectPrivate.cpp
   ctkXnatProject.cpp
-  ctkXnatReconstruction.cpp
-  ctkXnatReconstructionFolder.cpp
-  ctkXnatReconstructionResource.cpp
-  ctkXnatReconstructionResourceFile.cpp
-  ctkXnatScan.cpp
-  ctkXnatScanFolder.cpp
-  ctkXnatScanResource.cpp
-  ctkXnatScanResourceFile.cpp
+  #ctkXnatReconstruction.cpp
+  #ctkXnatReconstructionFolder.cpp
+  #ctkXnatReconstructionResource.cpp
+  #ctkXnatReconstructionResourceFile.cpp
+  #ctkXnatScan.cpp
+  #ctkXnatScanFolder.cpp
+  #ctkXnatScanResource.cpp
+  #ctkXnatScanResourceFile.cpp
   ctkXnatServer.cpp
   ctkXnatSettings.cpp
   ctkXnatSubject.cpp
@@ -28,20 +29,20 @@ set(KIT_SRCS
 
 # Files which should be processed by Qts moc
 set(KIT_MOC_SRCS
-  ctkXnatConnection.h
-  ctkXnatExperiment.h
-  ctkXnatObject.h
-  ctkXnatProject.h
-  ctkXnatReconstruction.h
-  ctkXnatReconstructionFolder.h
-  ctkXnatReconstructionResource.h
-  ctkXnatReconstructionResourceFile.h
-  ctkXnatScan.h
-  ctkXnatScanFolder.h
-  ctkXnatScanResource.h
-  ctkXnatScanResourceFile.h
-  ctkXnatServer.h
-  ctkXnatSubject.h
+  #ctkXnatConnection.h
+  #ctkXnatExperiment.h
+  #ctkXnatObject.h
+  #ctkXnatProject.h
+  #ctkXnatReconstruction.h
+  #ctkXnatReconstructionFolder.h
+  #ctkXnatReconstructionResource.h
+  #ctkXnatReconstructionResourceFile.h
+  #ctkXnatScan.h
+  #ctkXnatScanFolder.h
+  #ctkXnatScanResource.h
+  #ctkXnatScanResourceFile.h
+  #ctkXnatServer.h
+  #ctkXnatSubject.h
 )
 
 

Libs/XNAT/Core/ctkXnatConnection.h

@@ -25,16 +25,15 @@
 #include "ctkXNATCoreExport.h"
 
 #include <QScopedPointer>
+#include <QSharedPointer>
 #include <QString>
-#include <QScriptValue>
 
-#include <qXnatAPI.h>
+#include <QObject>
+#include <QVariantMap>
+#include <QUuid>
 
 class ctkXnatConnectionPrivate;
 
-class QAuthenticator;
-class QNetworkReply;
-
 class ctkXnatExperiment;
 class ctkXnatObject;
 class ctkXnatProject;
@@ -50,11 +49,9 @@ class ctkXnatScanResourceFile;
 class ctkXnatServer;
 class ctkXnatSubject;
 
-class CTK_XNAT_CORE_EXPORT ctkXnatConnection : public QObject
+class CTK_XNAT_CORE_EXPORT ctkXnatConnection
 {
 
-  Q_OBJECT
-
 public:
 
   ctkXnatConnection();
@@ -71,18 +68,18 @@ public:
   QString password() const;
   void setPassword(const QString& password);
 
-  ctkXnatServer* server();
+  QSharedPointer<ctkXnatServer> server() const;
 
-  void fetch(ctkXnatServer* 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);
+  void fetch(const QSharedPointer<ctkXnatServer>& server);
+  void fetch(const QSharedPointer<ctkXnatProject>& project);
+  void fetch(const QSharedPointer<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);
 
   void create(ctkXnatProject* project);
   void create(ctkXnatSubject* subject);
@@ -116,8 +113,8 @@ protected:
   QScopedPointer<ctkXnatConnectionPrivate> d_ptr;
 
 private:
-  Q_DECLARE_PRIVATE(ctkXnatConnection);
-  Q_DISABLE_COPY(ctkXnatConnection);
+  Q_DECLARE_PRIVATE(ctkXnatConnection)
+  Q_DISABLE_COPY(ctkXnatConnection)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatConnectionFactory.cpp

@@ -28,20 +28,6 @@
 
 // ctkXnatConnectionFactory class
 
-ctkXnatConnectionFactory::ctkXnatConnectionFactory()
-{
-}
-
-ctkXnatConnectionFactory::~ctkXnatConnectionFactory()
-{
-}
-
-ctkXnatConnectionFactory& ctkXnatConnectionFactory::instance()
-{
-  static ctkXnatConnectionFactory connectionFactory;
-  return connectionFactory;
-}
-
 ctkXnatConnection* ctkXnatConnectionFactory::makeConnection(const QString& url, const QString& user, const QString& password)
 {
   // create XNAT connection
@@ -69,20 +55,7 @@ ctkXnatConnection* ctkXnatConnectionFactory::makeConnection(const QString& url,
 void ctkXnatConnectionFactory::testConnection(ctkXnatConnection* connection)
 {
   // test connection by retrieving project names from XNAT
-  ctkXnatServer* server = NULL;
-  try
-  {
-    // create XNAT root
-    server = connection->server();
+  ctkXnatServer::Pointer server = connection->server();
 
-    // TODO E.g. get version
-  }
-  catch (ctkXnatException& e)
-  {
-    if (server != NULL)
-    {
-      delete server;
-    }
-    throw;
-  }
+  // TODO E.g. get version
 }

Libs/XNAT/Core/ctkXnatConnectionFactory.h

@@ -31,15 +31,10 @@ class ctkXnatConnection;
 class CTK_XNAT_CORE_EXPORT ctkXnatConnectionFactory
 {
 public:
-  static ctkXnatConnectionFactory& instance();
-  ~ctkXnatConnectionFactory();
 
   ctkXnatConnection* makeConnection(const QString& url, const QString& user, const QString& password);
 
 private:
-  ctkXnatConnectionFactory();
-  ctkXnatConnectionFactory& operator=(ctkXnatConnectionFactory& f);
-  ctkXnatConnectionFactory(const ctkXnatConnectionFactory& f);
 
   void testConnection(ctkXnatConnection* conn);
 };

Libs/XNAT/Core/ctkXnatObject.cpp

@@ -20,165 +20,126 @@
 =============================================================================*/
 
 #include "ctkXnatObject.h"
+#include "ctkXnatObjectPrivate.h"
 
 #include <QDebug>
 
-class ctkXnatObjectPrivate
-{
-public:
-  ctkXnatObject* parent;
-  int parentIndex;
-  QList<QString> childrenNames;
-  QList<ctkXnatObject*> children;
-};
-
-ctkXnatObject::ctkXnatObject(ctkXnatObject* parent)
-: QObject(parent)
-, d_ptr(new ctkXnatObjectPrivate())
-{
-  Q_D(ctkXnatObject);
-  d->parent = parent;
-  d->parentIndex = -1;
-}
 
 ctkXnatObject::~ctkXnatObject()
 {
 }
 
-void ctkXnatObject::setParent(ctkXnatObject* parent)
+QString ctkXnatObject::getId() const
 {
-  Q_D(ctkXnatObject);
-  QObject::setParent(parent);
-  d->parent = parent;
+  return getProperty("ID");
 }
 
-int ctkXnatObject::parentIndex()
+QString ctkXnatObject::getName() const
 {
-  Q_D(ctkXnatObject);
-  return d->parentIndex;
+  return getProperty("name");
 }
 
-void ctkXnatObject::setParentIndex(int parentIndex)
+QString ctkXnatObject::getDescription() const
 {
-  Q_D(ctkXnatObject);
-  d->parentIndex = parentIndex;
+  return getProperty("description");
 }
 
-void ctkXnatObject::fetch(ctkXnatConnection* /*connection*/)
+QString ctkXnatObject::getProperty(const QString& name) const
 {
-//  connection->fetch(this);
+  Q_D(const ctkXnatObject);
+  ctkXnatObjectPrivate::PropertyMapConstInterator iter = d->properties.find(name);
+  if (iter != d->properties.end())
+  {
+    return iter.value();
+  }
+  return QString::null;
 }
 
-QString ctkXnatObject::getName() const
+void ctkXnatObject::setProperty(const QString& name, const QVariant& value)
 {
-  Q_D(const ctkXnatObject);
-  return d->parent ? d->parent->childName(d->parentIndex) : 0;
+  Q_D(ctkXnatObject);
+  d->properties.insert(name, value.toString());
 }
 
-ctkXnatObject* ctkXnatObject::getParent() const
+ctkXnatObject::Pointer ctkXnatObject::getParent() const
 {
   Q_D(const ctkXnatObject);
   return d->parent;
 }
 
-const QList<ctkXnatObject*>& ctkXnatObject::getChildren() const
+QList<ctkXnatObject::Pointer> ctkXnatObject::getChildren() const
 {
   Q_D(const ctkXnatObject);
   return d->children;
 }
 
-QString ctkXnatObject::childName(int childIndex) const
-{
-  Q_D(const ctkXnatObject);
-  return d->childrenNames[childIndex];
-}
-
-void ctkXnatObject::addChild(const QString& name, ctkXnatObject* child)
+void ctkXnatObject::addChild(const ctkXnatObject::Pointer& child)
 {
   Q_D(ctkXnatObject);
-  int index = d->childrenNames.indexOf(name);
-  if (index == -1)
+  d->children.push_back(child);
+  if (child->getConnection() == NULL)
   {
-    index = d->childrenNames.size();
-    d->childrenNames.push_back(name);
-    d->children.push_back(child);
+    child->d_func()->connection = this->getConnection();
   }
-  else
-  {
-    d->children[index] = child;
-  }
-  child->setParent(this);
-  child->setParentIndex(index);
 }
 
-void ctkXnatObject::removeChild(int childIndex)
+void ctkXnatObject::reset()
 {
   Q_D(ctkXnatObject);
-  if (d->children[childIndex])
-  {
-    delete d->children[childIndex];
-    d->children[childIndex] = NULL;
-  }
+  //d->properties.clear();
+  d->children.clear();
 }
 
-void ctkXnatObject::download(ctkXnatConnection* /*connection*/, const QString& /*zipFilename*/)
+void ctkXnatObject::fetch()
 {
-  // do nothing
+  this->reset();
+  this->fetchImpl();
 }
 
-void ctkXnatObject::upload(ctkXnatConnection* /*connection*/, const QString& /*zipFilename*/)
+void ctkXnatObject::download(const QString& /*zipFilename*/)
 {
   // do nothing
 }
 
-void ctkXnatObject::add(ctkXnatConnection* /*connection*/, const QString& /*name*/)
+void ctkXnatObject::upload(const QString& /*zipFilename*/)
 {
   // do nothing
 }
 
-void ctkXnatObject::remove(ctkXnatConnection* /*connection*/)
+void ctkXnatObject::add(const QString& /*name*/)
 {
   // do nothing
 }
 
-QString ctkXnatObject::getKind() const
+void ctkXnatObject::remove()
 {
-  return NULL;
-}
-
-QString ctkXnatObject::getModifiableChildKind() const
-{
-  return NULL;
-}
-
-QString ctkXnatObject::getModifiableParentName() const
-{
-  return NULL;
+  // do nothing
 }
 
-bool ctkXnatObject::isFile() const
+bool ctkXnatObject::isModifiable() const
 {
   return false;
 }
 
-bool ctkXnatObject::holdsFiles() const
+ctkXnatObject::ctkXnatObject(ctkXnatConnection* connection)
+  : d_ptr(new ctkXnatObjectPrivate(connection))
 {
-  return false;
 }
 
-bool ctkXnatObject::receivesFiles() const
+ctkXnatObject::ctkXnatObject(ctkXnatObjectPrivate& dd)
+  : d_ptr(&dd)
 {
-  return false;
 }
 
-bool ctkXnatObject::isModifiable(int /*childIndex*/) const
+ctkXnatConnection* ctkXnatObject::getConnection() const
 {
-  return false;
+  Q_D(const ctkXnatObject);
+  return d->connection;
 }
 
-bool ctkXnatObject::isModifiable() const
+void ctkXnatObject::setId(const QString& id)
 {
-  return false;
+  setProperty("ID", id);
 }
 
 bool ctkXnatObject::isDeletable() const

Libs/XNAT/Core/ctkXnatObject.h

@@ -27,54 +27,68 @@
 #include <QList>
 #include <QObject>
 #include <QString>
+#include <QSharedPointer>
+#include <QMetaType>
 
 class ctkXnatConnection;
 class ctkXnatObjectPrivate;
 
-class CTK_XNAT_CORE_EXPORT ctkXnatObject : public QObject
+class CTK_XNAT_CORE_EXPORT ctkXnatObject
 {
-  Q_OBJECT
 
 public:
-  explicit ctkXnatObject(ctkXnatObject* parent = 0);
+
+  typedef QSharedPointer<ctkXnatObject> Pointer;
+  typedef QWeakPointer<ctkXnatObject> WeakPointer;
+
   virtual ~ctkXnatObject();
 
+  QString getId() const;
   QString getName() const;
-  ctkXnatObject* getParent() const;
-  int parentIndex();
-  const QList<ctkXnatObject*>& getChildren() const;
-  QString childName(int childIndex) const;
+  QString getDescription() const;
 
-  void addChild(const QString& name, ctkXnatObject* child);
+  QString getProperty(const QString& name) const;
+  void setProperty(const QString& name, const QVariant& value);
 
-  virtual void fetch(ctkXnatConnection* connection);
-  void removeChild(int parentIndex);
+  ctkXnatObject::Pointer getParent() const;
+  QList<ctkXnatObject::Pointer> getChildren() const;
 
-  virtual void download(ctkXnatConnection* connection, const QString& zipFilename);
-  virtual void upload(ctkXnatConnection* connection, const QString& zipFilename);
-  virtual void add(ctkXnatConnection* connection, const QString& name);
-  virtual void remove(ctkXnatConnection* connection);
+  void addChild(const Pointer& child);
 
-  virtual QString getKind() const;
-  virtual QString getModifiableChildKind() const;
-  virtual QString getModifiableParentName() const;
+  virtual void reset();
+  void fetch();
 
-  virtual bool isFile() const;
-  virtual bool holdsFiles() const;
-  virtual bool receivesFiles() const;
-  virtual bool isModifiable(int childIndex) const;
-  virtual bool isDeletable() const;
+  virtual void download(const QString& zipFilename);
+  virtual void upload(const QString& zipFilename);
+  virtual void add(const QString& name);
+  virtual void remove();
 
+  virtual bool isDeletable() const;
   virtual bool isModifiable() const;
 
+protected:
+
+  ctkXnatObject(ctkXnatConnection* connection);
+  ctkXnatObject(ctkXnatObjectPrivate& dd);
+
+  ctkXnatConnection* getConnection() const;
+
+  void setId(const QString& id);
+  void setName(const QString& name);
+  void setDescription(const QString& description);
+
+  const QScopedPointer<ctkXnatObjectPrivate> d_ptr;
+
 private:
-  void setParent(ctkXnatObject* parent);
-  void setParentIndex(int index);
 
-  QScopedPointer<ctkXnatObjectPrivate> d_ptr;
+  friend class ctkXnatConnection;
 
-  Q_DECLARE_PRIVATE(ctkXnatObject);
-  Q_DISABLE_COPY(ctkXnatObject);
+  virtual void fetchImpl() = 0;
+
+  Q_DECLARE_PRIVATE(ctkXnatObject)
+  Q_DISABLE_COPY(ctkXnatObject)
 };
 
+Q_DECLARE_METATYPE(ctkXnatObject::Pointer)
+
 #endif

Libs/XNAT/Core/ctkXnatObjectPrivate.cpp

@@ -0,0 +1,33 @@
+/*=============================================================================
+
+  Library: CTK
+
+  Copyright (c) German Cancer Research Center,
+    Division of Medical and Biological Informatics
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=============================================================================*/
+
+#include "ctkXnatObjectPrivate.h"
+
+#include <QString>
+
+ctkXnatObjectPrivate::ctkXnatObjectPrivate(ctkXnatConnection* connection)
+  : connection(connection)
+{
+}
+
+ctkXnatObjectPrivate::~ctkXnatObjectPrivate()
+{
+}

Libs/XNAT/Core/ctkXnatObjectPrivate.h

@@ -0,0 +1,56 @@
+/*=============================================================================
+
+  Library: CTK
+
+  Copyright (c) German Cancer Research Center,
+    Division of Medical and Biological Informatics
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=============================================================================*/
+
+#ifndef CTKXNATOBJECTPRIVATE_H
+#define CTKXNATOBJECTPRIVATE_H
+
+#include <QMap>
+#include <QSharedPointer>
+
+class ctkXnatObject;
+class ctkXnatConnection;
+
+class ctkXnatObjectPrivate
+{
+
+public:
+
+  typedef QMap<QString,QString> PropertyMap;
+  typedef QMap<QString,QString>::Iterator PropertyMapIterator;
+  typedef QMap<QString,QString>::ConstIterator PropertyMapConstInterator;
+
+  explicit ctkXnatObjectPrivate(ctkXnatConnection* connection);
+  virtual ~ctkXnatObjectPrivate();
+
+  QWeakPointer<ctkXnatObject> selfPtr;
+
+private:
+
+  friend class ctkXnatObject;
+
+  QList<QSharedPointer<ctkXnatObject> > children;
+  QMap<QString,QString> properties;
+
+  QWeakPointer<ctkXnatObject> parent;
+  ctkXnatConnection* connection;
+};
+
+#endif // CTKXNATOBJECTPRIVATE_H

Libs/XNAT/Core/ctkXnatProject.cpp

@@ -22,39 +22,44 @@
 #include "ctkXnatProject.h"
 
 #include "ctkXnatConnection.h"
+#include "ctkXnatObjectPrivate.h"
 
-class ctkXnatProjectPrivate
+class ctkXnatProjectPrivate : public ctkXnatObjectPrivate
 {
 public:
-  QString id;
+
+  ctkXnatProjectPrivate(ctkXnatConnection* connection)
+    : ctkXnatObjectPrivate(connection)
+  {}
+
+  void reset()
+  {
+    secondaryId.clear();
+    piFirstName.clear();
+    piLastName.clear();
+    uri.clear();
+  }
+
   QString secondaryId;
-  QString name;
-  QString description;
   QString piFirstName;
   QString piLastName;
   QString uri;
 };
 
-ctkXnatProject::ctkXnatProject(ctkXnatObject* parent)
-: ctkXnatObject(parent)
-, d_ptr(new ctkXnatProjectPrivate())
+ctkXnatProject::ctkXnatProject(ctkXnatConnection* connection)
+  : ctkXnatObject(*new ctkXnatProjectPrivate(connection))
 {
 }
 
-ctkXnatProject::~ctkXnatProject()
+ctkXnatProject::Pointer ctkXnatProject::Create(ctkXnatConnection* connection)
 {
+  Pointer project(new ctkXnatProject(connection));
+  project->d_func()->selfPtr = project;
+  return project;
 }
 
-const QString& ctkXnatProject::id() const
+ctkXnatProject::~ctkXnatProject()
 {
-  Q_D(const ctkXnatProject);
-  return d->id;
-}
-
-void ctkXnatProject::setId(const QString& id)
-{
-  Q_D(ctkXnatProject);
-  d->id = id;
 }
 
 const QString& ctkXnatProject::secondaryId() const
@@ -69,30 +74,6 @@ void ctkXnatProject::setSecondaryId(const QString& secondaryId)
   d->secondaryId = secondaryId;
 }
 
-const QString& ctkXnatProject::name() const
-{
-  Q_D(const ctkXnatProject);
-  return d->name;
-}
-
-void ctkXnatProject::setName(const QString& name)
-{
-  Q_D(ctkXnatProject);
-  d->name = name;
-}
-
-const QString& ctkXnatProject::description() const
-{
-  Q_D(const ctkXnatProject);
-  return d->description;
-}
-
-void ctkXnatProject::setDescription(const QString& description)
-{
-  Q_D(ctkXnatProject);
-  d->description = description;
-}
-
 const QString& ctkXnatProject::piFirstName() const
 {
   Q_D(const ctkXnatProject);
@@ -129,27 +110,20 @@ void ctkXnatProject::setUri(const QString& uri)
   d->uri = uri;
 }
 
-void ctkXnatProject::fetch(ctkXnatConnection* connection)
+void ctkXnatProject::reset()
 {
-  return connection->fetch(this);
-}
-
-void ctkXnatProject::remove(ctkXnatConnection* connection)
-{
-  connection->remove(this);
-}
-
-QString ctkXnatProject::getKind() const
-{
-  return "subject";
+  Q_D(ctkXnatProject);
+  ctkXnatObject::reset();
 }
 
-bool ctkXnatProject::isModifiable(int /*parentIndex*/) const
+void ctkXnatProject::fetchImpl()
 {
-  return true;
+  Q_D(ctkXnatProject);
+  ctkXnatObject::Pointer self = d->selfPtr;
+  getConnection()->fetch(self.staticCast<ctkXnatProject>());
 }
 
-QString ctkXnatProject::getModifiableChildKind(int /*parentIndex*/) const
+void ctkXnatProject::remove()
 {
-  return "project";
+  //connection->remove(this);
 }

Libs/XNAT/Core/ctkXnatProject.h

@@ -31,34 +31,19 @@ class ctkXnatProjectPrivate;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatProject : public ctkXnatObject
 {
-  Q_OBJECT
 
-  Q_PROPERTY(QString ID READ id WRITE setId)
-  Q_PROPERTY(QString secondary_ID READ secondaryId WRITE setSecondaryId)
-  Q_PROPERTY(QString name READ name WRITE setName)
-  Q_PROPERTY(QString description READ description WRITE setDescription)
-  Q_PROPERTY(QString pi_firstname READ piFirstName WRITE setPiFirstName)
-  Q_PROPERTY(QString pi_lastname READ piLastName WRITE setPiLastName)
-  Q_PROPERTY(QString URI READ uri WRITE setUri)
+public:
 
-  typedef ctkXnatObject Superclass;
+  typedef QSharedPointer<ctkXnatProject> Pointer;
+  typedef QWeakPointer<ctkXnatProject> WeakPointer;
 
-public:
-  explicit ctkXnatProject(ctkXnatObject* parent = 0);
-  virtual ~ctkXnatProject();
+  static Pointer Create(ctkXnatConnection* connection);
 
-  const QString& id() const;
-  void setId(const QString& id);
+  virtual ~ctkXnatProject();
 
   const QString& secondaryId() const;
   void setSecondaryId(const QString& secondaryId);
 
-  const QString& name() const;
-  void setName(const QString& name);
-
-  const QString& description() const;
-  void setDescription(const QString& description);
-
   const QString& piFirstName() const;
   void setPiFirstName(const QString& piFirstName);
 
@@ -68,22 +53,20 @@ public:
   const QString& uri() const;
   void setUri(const QString& uri);
 
-  virtual void fetch(ctkXnatConnection* connection);
-  virtual void remove(ctkXnatConnection* connection);
+  virtual void reset();
+
+  virtual void remove();
 
-  virtual QString getKind() const;
+private:
 
-  using Superclass::isModifiable;
-  virtual bool isModifiable(int parentIndex) const;
+  friend class qRestResult;
 
-  using Superclass::getModifiableChildKind;
-  virtual QString getModifiableChildKind(int parentIndex) const;
+  explicit ctkXnatProject(ctkXnatConnection* connection = NULL);
 
-private:
-  QScopedPointer<ctkXnatProjectPrivate> d_ptr;
+  virtual void fetchImpl();
 
-  Q_DECLARE_PRIVATE(ctkXnatProject);
-  Q_DISABLE_COPY(ctkXnatProject);
+  Q_DECLARE_PRIVATE(ctkXnatProject)
+  Q_DISABLE_COPY(ctkXnatProject)
 };
 
 #endif

Libs/XNAT/Core/ctkXnatServer.cpp

@@ -21,23 +21,28 @@
 
 #include "ctkXnatServer.h"
 
+#include "ctkXnatObjectPrivate.h"
 #include "ctkXnatConnection.h"
 
-ctkXnatServer::ctkXnatServer(ctkXnatObject* parent)
-: ctkXnatObject(parent)
-{
-}
+#include <QDebug>
 
-ctkXnatServer::~ctkXnatServer()
+ctkXnatServer::ctkXnatServer(ctkXnatConnection* connection)
+  : ctkXnatObject(connection)
 {
 }
 
-void ctkXnatServer::fetch(ctkXnatConnection* connection)
+ctkXnatServer::Pointer ctkXnatServer::Create(ctkXnatConnection* connection)
 {
-  return connection->fetch(this);
+  Pointer server(new ctkXnatServer(connection));
+  server->d_func()->selfPtr = server;
+  return server;
 }
 
-QString ctkXnatServer::getKind() const
+void ctkXnatServer::fetchImpl()
 {
-  return "project";
+  Q_D(ctkXnatObject);
+  qDebug() << "Starting to fetch projects...";
+  ctkXnatObject::Pointer self = d->selfPtr;
+  return getConnection()->fetch(self.staticCast<ctkXnatServer>());
 }
+

Libs/XNAT/Core/ctkXnatServer.h

@@ -30,15 +30,21 @@ class ctkXnatConnection;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatServer : public ctkXnatObject
 {
-  Q_OBJECT
 
 public:
-  explicit ctkXnatServer(ctkXnatObject* parent = 0);
-  virtual ~ctkXnatServer();
 
-  virtual void fetch(ctkXnatConnection* connection);
+  typedef QSharedPointer<ctkXnatServer> Pointer;
+  typedef QWeakPointer<ctkXnatServer> WeakPointer;
 
-  virtual QString getKind() const;
+  static Pointer Create(ctkXnatConnection* connection);
+
+private:
+
+  ctkXnatServer(ctkXnatConnection* connection);
+
+  virtual void fetchImpl();
+
+  Q_DECLARE_PRIVATE(ctkXnatObject)
 
 };
 

Libs/XNAT/Core/ctkXnatSubject.cpp

@@ -21,23 +21,36 @@
 
 #include "ctkXnatSubject.h"
 
+#include "ctkXnatProject.h"
+
 #include "ctkXnatConnection.h"
-#include "ctkXnatSubject.h"
+#include "ctkXnatObjectPrivate.h"
 
-class ctkXnatSubjectPrivate
+class ctkXnatSubjectPrivate : public ctkXnatObjectPrivate
 {
 public:
-  QString id;
-  QString project;
-  QString label;
+
+  ctkXnatSubjectPrivate(ctkXnatConnection* connection)
+    : ctkXnatObjectPrivate(connection)
+  {}
+
+  void reset()
+  {
+    insertDate.clear();
+    insertUser.clear();
+    uri.clear();
+    projects.clear();
+  }
+
   QString insertDate;
   QString insertUser;
   QString uri;
+
+  QList<ctkXnatProject::WeakPointer> projects;
 };
 
-ctkXnatSubject::ctkXnatSubject(ctkXnatObject* parent)
-: ctkXnatObject(parent)
-, d_ptr(new ctkXnatSubjectPrivate())
+ctkXnatSubject::ctkXnatSubject(ctkXnatConnection* connection)
+: ctkXnatObject(*new ctkXnatSubjectPrivate(connection))
 {
 }
 
@@ -45,42 +58,6 @@ ctkXnatSubject::~ctkXnatSubject()
 {
 }
 
-const QString& ctkXnatSubject::id() const
-{
-  Q_D(const ctkXnatSubject);
-  return d->id;
-}
-
-void ctkXnatSubject::setId(const QString& id)
-{
-  Q_D(ctkXnatSubject);
-  d->id = id;
-}
-
-const QString& ctkXnatSubject::project() const
-{
-  Q_D(const ctkXnatSubject);
-  return d->project;
-}
-
-void ctkXnatSubject::setProject(const QString& project)
-{
-  Q_D(ctkXnatSubject);
-  d->project = project;
-}
-
-const QString& ctkXnatSubject::label() const
-{
-  Q_D(const ctkXnatSubject);
-  return d->label;
-}
-
-void ctkXnatSubject::setLabel(const QString& label)
-{
-  Q_D(ctkXnatSubject);
-  d->label = label;
-}
-
 const QString& ctkXnatSubject::insertDate() const
 {
   Q_D(const ctkXnatSubject);
@@ -117,21 +94,22 @@ void ctkXnatSubject::setUri(const QString& uri)
   d->uri = uri;
 }
 
-void ctkXnatSubject::fetch(ctkXnatConnection* connection)
+void ctkXnatSubject::reset()
 {
-  connection->fetch(this);
+  Q_D(ctkXnatSubject);
+  d->reset();
 }
 
-QString ctkXnatSubject::getKind() const
+void ctkXnatSubject::fetchImpl()
 {
-  return "experiment";
+  Q_D(ctkXnatSubject);
+  ctkXnatObject::Pointer self = d->selfPtr;
+  getConnection()->fetch(self.staticCast<ctkXnatSubject>());
 }
 
-bool ctkXnatSubject::isModifiable(int childIndex) const
+ctkXnatSubject::Pointer ctkXnatSubject::Create(ctkXnatConnection* connection)
 {
-  if (getChildren()[childIndex] == 0)
-  {
-    return false;
-  }
-  return getChildren()[childIndex]->isModifiable();
+  Pointer subject(new ctkXnatSubject(connection));
+  subject->d_func()->selfPtr = subject;
+  return subject;
 }

Libs/XNAT/Core/ctkXnatSubject.h

@@ -26,35 +26,23 @@
 
 #include "ctkXnatObject.h"
 
-class ctkXnatConnection;
-
+class ctkXnatProject;
 class ctkXnatSubjectPrivate;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatSubject : public ctkXnatObject
 {
-  Q_OBJECT
-
-  Q_PROPERTY(QString ID READ id WRITE setId)
-  Q_PROPERTY(QString project READ project WRITE setProject)
-  Q_PROPERTY(QString label READ label WRITE setLabel)
-  Q_PROPERTY(QString insert_date READ insertDate WRITE setInsertDate)
-  Q_PROPERTY(QString insert_user READ insertUser WRITE setInsertUser)
-  Q_PROPERTY(QString URI READ uri WRITE setUri)
-
-  typedef ctkXnatObject Superclass;
 
 public:
-  explicit ctkXnatSubject(ctkXnatObject* parent = 0);
-  virtual ~ctkXnatSubject();
 
-  const QString& id() const;
-  void setId(const QString& id);
+  typedef QSharedPointer<ctkXnatSubject> Pointer;
+  typedef QWeakPointer<ctkXnatSubject> WeakPointer;
 
-  const QString& project() const;
-  void setProject(const QString& project);
+  static Pointer Create(ctkXnatConnection* connection);
 
-  const QString& label() const;
-  void setLabel(const QString& label);
+  virtual ~ctkXnatSubject();
+
+  QSharedPointer<ctkXnatProject> getPrimaryProject() const;
+  QList<QSharedPointer<ctkXnatProject> > getProjects() const;
 
   const QString& insertDate() const;
   void setInsertDate(const QString& insertDate);
@@ -65,18 +53,18 @@ public:
   const QString& uri() const;
   void setUri(const QString& uri);
 
-  virtual void fetch(ctkXnatConnection* connection);
+  virtual void reset();
+
+private:
 
-  virtual QString getKind() const;
+  friend class qRestResult;
 
-  using Superclass::isModifiable;
-  virtual bool isModifiable(int parentIndex) const;
+  explicit ctkXnatSubject(ctkXnatConnection* connection = NULL);
 
-private:
-  QScopedPointer<ctkXnatSubjectPrivate> d_ptr;
+  virtual void fetchImpl();
 
-  Q_DECLARE_PRIVATE(ctkXnatSubject);
-  Q_DISABLE_COPY(ctkXnatSubject);
+  Q_DECLARE_PRIVATE(ctkXnatSubject)
+  Q_DISABLE_COPY(ctkXnatSubject)
 };
 
 #endif