/***************************************************************************

 *   Copyright (c) 2009 Mark Kretschmann <kretschmann@kde.org>             *

 *   Copyright (c) 2009 Ian Monroe <ian@monroe.nu>                         *

 *   Copyright (c) 2009 Max Howell <max@last.fm>                           *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 *   This program is distributed in the hope that it will be useful,       *

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *

 *   GNU General Public License for more details.                          *

 *                                                                         *

 *   You should have received a copy of the GNU General Public License     *

 *   along with this program; if not, write to the                         *

 *   Free Software Foundation, Inc.,                                       *

 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *

 ***************************************************************************/

#ifndef AMAROK_SMART_POINTER_LIST_H

#define AMAROK_SMART_POINTER_LIST_H

#include <QList>   //baseclass

#include <QObject> //baseclass

class SmartPointerListDaddy : public QObject

{

    Q_OBJECT

    QList<QObject*>& m_list;

public:

    SmartPointerListDaddy( QList<QObject*>* list ) : m_list( *list )

    {}

private slots:

    void onDestroyed()

    {

        m_list.removeAll( sender() );

    }

};

/** QList has no virtual functions, so we inherit privately and define the

  * interface exactly to ensure users can't write code that breaks the 

  * class's internal behaviour.

  *

  * I deliberately didn't define clear. I worried people would assume it 

  * deleted the pointers. Or assume it didn't. I didn't expose a few other 

  * functions for that reason.

  *

  * non-const iterator functions are not exposed as they access the QList

  * baseclass, and then the Daddy wouldn't be watching newly inserted items.

  *

  * --mxcl

  * Exposed clear. This class doesn't have a QPtrList autodelete functionality

  * ever, so if people think that, they're really confused! -- Ian Monroe

  *

  */

template <class T> class SmartPointerList : private QList<T*>

{

    class SmartPointerListDaddy* m_daddy;

public:

    SmartPointerList() : m_daddy( new SmartPointerListDaddy( (QList<QObject*>*)this ) )

    {}

    ~SmartPointerList()

    {

        delete m_daddy;

    }

    SmartPointerList( const SmartPointerList<T>& that )

            : QList<T*>()

            , m_daddy( new SmartPointerListDaddy( (QList<QObject*>*)this ) )

    {

        QListIterator<T*> i( that );

        while (i.hasNext())

            append( i.next() );

    }

    SmartPointerList& operator=( const SmartPointerList<T>& that )

    {    

        QListIterator<T*> i( *this);

        while (i.hasNext())

            QObject::disconnect( m_daddy, 0, i.next(), 0 );

        QList<T*>::operator=( that );

        if (this != &that) {

            QListIterator<T*> i( that );

            while (i.hasNext())

                m_daddy->connect( i.next(), SIGNAL(destroyed()), SLOT(onDestroyed()) );

        }

        return *this;

    }

    // keep same function names as Qt

    void append( T* o )

    {

        m_daddy->connect( o, SIGNAL(destroyed()), SLOT(onDestroyed()) );

        QList<T*>::append( o );

    }

    void prepend( T* o )

    {

        m_daddy->connect( o, SIGNAL(destroyed()), SLOT(onDestroyed()) );

        QList<T*>::prepend( o );

    }

    SmartPointerList& operator+=( T* o )

    {

        append( o );

        return *this;

    }

    SmartPointerList& operator<<( T* o )

    {

        return operator+=( o );

    }

    SmartPointerList operator+( const SmartPointerList that )

    {

        SmartPointerList<T> copy = *this;

        QListIterator<T*> i( that );

        while (i.hasNext())

            copy.append( i.next() );

        return copy;

    }

    SmartPointerList& operator+=( const SmartPointerList that )

    {

        QListIterator<T*> i( that );

        while (i.hasNext())

            append( i.next() );

        return *this;

    }

    void push_back( T* o )

    {

        append( o );

    }

    void push_front( T* o )

    {

        prepend( o );

    }

    void replace( int i, T* o )

    {

        QList<T*>::replace( i, o );

        m_daddy->connect( o, SIGNAL(destroyed()), SLOT(onDestroyed()) );

    }

    /** this is a "safe" class. We always bounds check */

    inline T* operator[]( int index ) const { return QList<T*>::value( index ); }

    inline T* at( int index ) const { return QList<T*>::value( index ); }

    // make public safe functions again

    using QList<T*>::back;

    using QList<T*>::constBegin;

    using QList<T*>::constEnd;

    using QList<T*>::const_iterator;

    using QList<T*>::contains;

    using QList<T*>::count;

    using QList<T*>::empty;

    using QList<T*>::erase;

    using QList<T*>::first;

    using QList<T*>::front;

    using QList<T*>::indexOf;

    using QList<T*>::insert;

    using QList<T*>::isEmpty;    

    using QList<T*>::last;

    using QList<T*>::lastIndexOf;

    using QList<T*>::mid;        

    using QList<T*>::move;

    using QList<T*>::pop_back;

    using QList<T*>::pop_front;

    using QList<T*>::size;

    using QList<T*>::swap;

    using QList<T*>::value;

    using QList<T*>::operator!=;

    using QList<T*>::operator==;

    // can't use using directive here since we only want the const versions

    typename QList<T*>::const_iterator begin() const { return QList<T*>::constBegin(); }

    typename QList<T*>::const_iterator end() const { return QList<T*>::constEnd(); }

    // it can lead to poor performance situations if we don't disconnect

    // but I think it's not worth making this class more complicated for such 

    // an edge case

    using QList<T*>::clear;

    using QList<T*>::removeAll;

    using QList<T*>::removeAt;

    using QList<T*>::removeFirst;

    using QList<T*>::removeLast;

    using QList<T*>::removeOne;

    using QList<T*>::takeAt;

    using QList<T*>::takeFirst;

    using QList<T*>::takeLast;

};

#endif //HEADER_GUARD