QSharedPtrify dbcmd creation.

src/libtomahawk/database/Database.cpp

@@ -53,17 +53,16 @@
 #define MAX_WORKER_THREADS 16
 
 
-DatabaseCommand*
+dbcmd_ptr
 DatabaseCommandFactory::newInstance()
 {
-    DatabaseCommand* command = create();
+    dbcmd_ptr command = dbcmd_ptr( create() );
+
     emit created( command );
     return command;
 }
 
 
-
-
 Database* Database::s_instance = 0;
 
 
@@ -260,7 +259,7 @@ void
 Database::registerCommand( DatabaseCommandFactory* commandFactory )
 {
     // this is ugly, but we don't have virtual static methods in C++ :(
-    QScopedPointer<DatabaseCommand> command( commandFactory->newInstance() );
+    dbcmd_ptr command = commandFactory->newInstance();
 
     const QString commandName = command->commandname();
     const QString className = command->metaObject()->className();
@@ -294,7 +293,7 @@ Database::commandFactoryByCommandName(const QString& commandName )
 
 
 
-DatabaseCommand*
+dbcmd_ptr
 Database::createCommandInstance( const QString& commandName )
 {
     DatabaseCommandFactory* factory = commandFactoryByCommandName( commandName );
@@ -302,21 +301,21 @@ Database::createCommandInstance( const QString& commandName )
     if( !factory )
     {
          tLog() << "Unknown database command" << commandName;
-         return 0;
+         return dbcmd_ptr();
     }
 
     return factory->newInstance();
 }
 
 
-DatabaseCommand*
+dbcmd_ptr
 Database::createCommandInstance(const QVariant& op, const source_ptr& source)
 {
     const QString commandName = op.toMap().value( "command" ).toString();
 
-    DatabaseCommand* command = createCommandInstance( commandName );
+    dbcmd_ptr command = createCommandInstance( commandName );
     command->setSource( source );
-    QJson::QObjectHelper::qvariant2qobject( op.toMap(), command );
+    QJson::QObjectHelper::qvariant2qobject( op.toMap(), command.data() );
     return command;
 }
 

src/libtomahawk/database/Database.h

@@ -36,16 +36,19 @@ class DatabaseWorker;
 class IdThreadWorker;
 
 
+typedef QSharedPointer< DatabaseCommand> dbcmd_ptr;
+
+
 class DLLEXPORT DatabaseCommandFactory : public QObject
 {
 Q_OBJECT
 
 public:
     virtual ~DatabaseCommandFactory() {};
-    DatabaseCommand* newInstance();
+    dbcmd_ptr newInstance();
 
 signals:
-    void created( DatabaseCommand* command );
+    void created( const dbcmd_ptr& command );
 
 protected:
     virtual DatabaseCommand* create() const = 0;
@@ -55,7 +58,7 @@ template <class COMMAND>
 class DatabaseCommandFactoryImplementation : public DatabaseCommandFactory
 {
 protected:
-  virtual COMMAND* create() const { return new COMMAND(); };
+    virtual COMMAND* create() const { return new COMMAND(); };
 };
 
 /*
@@ -83,7 +86,7 @@ public:
 
     DatabaseImpl* impl();
 
-    DatabaseCommand* createCommandInstance( const QVariant& op, const Tomahawk::source_ptr& source );
+    dbcmd_ptr createCommandInstance( const QVariant& op, const Tomahawk::source_ptr& source );
 
     // Template implementations need to stay in header!
     template<typename T> void registerCommand()
@@ -114,7 +117,7 @@ private:
     void registerCommand( DatabaseCommandFactory* commandFactory );
     DatabaseCommandFactory* commandFactoryByClassName( const QString& className );
     DatabaseCommandFactory* commandFactoryByCommandName( const QString& commandName );
-    DatabaseCommand* createCommandInstance( const QString& commandName );
+    dbcmd_ptr createCommandInstance( const QString& commandName );
 
     bool m_ready;
 

src/libtomahawk/network/DbSyncConnection.cpp

@@ -199,11 +199,10 @@ DBSyncConnection::handleMsg( msg_ptr msg )
     // a db sync op msg
     if ( msg->is( Msg::DBOP ) )
     {
-        DatabaseCommand* cmd = Database::instance()->createCommandInstance( m, m_source );
-        if ( cmd )
+        dbcmd_ptr cmd = Database::instance()->createCommandInstance( m, m_source );
+        if ( !cmd.isNull() )
         {
-            QSharedPointer<DatabaseCommand> cmdsp = QSharedPointer<DatabaseCommand>(cmd);
-            m_source->addCommand( cmdsp );
+            m_source->addCommand( cmd );
         }
 
         if ( !msg->is( Msg::FRAGMENT ) ) // last msg in this batch