source: trunk/src/qt3support/tools/q3glist.cpp@ 595

/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/

#include "q3glist.h"
#include "q3gvector.h"
#include "qdatastream.h"
#include "q3valuelist.h"

QT_BEGIN_NAMESPACE

/*!
  \class Q3LNode
  \reentrant
  \brief The Q3LNode class is an internal class for the Q3PtrList template collection.

  \internal

  Q3LNode is a doubly-linked list node. It has three pointers:
  \list 1
  \i Pointer to the previous node.
  \i Pointer to the next node.
  \i Pointer to the actual data.
  \endlist

  It might sometimes be practical to have direct access to the list nodes
  in a Q3PtrList, but it is seldom required.

  Be very careful if you want to access the list nodes. The heap can
  easily get corrupted if you make a mistake.

  \sa Q3PtrList::currentNode(), Q3PtrList::removeNode(), Q3PtrList::takeNode()
*/

/*!
  \fn Q3PtrCollection::Item Q3LNode::getData()
  Returns a pointer (\c void*) to the actual data in the list node.
*/


/*!
  \class Q3GList
  \reentrant
  \brief The Q3GList class is an internal class for implementing Qt collection classes.

  \internal

  Q3GList is a strictly internal class that acts as a base class for
  several collection classes; Q3PtrList, Q3PtrQueue and Q3PtrStack.

  Q3GList has some virtual functions that can be reimplemented to
  customize the subclasses, namely compareItems(), read() and
  write. Normally, you do not have to reimplement any of these
  functions.  If you still want to reimplement them, see the QStrList
  class (qstrlist.h) for an example.
*/


/* Internal helper class for Q3GList. Contains some optimization for
   the typically case where only one iterators is activre on the list.
 */
class Q3GListIteratorList
{
public:
    Q3GListIteratorList()
        : list(0), iterator(0) {
    }
    ~Q3GListIteratorList() {
        notifyClear( true );
        delete list;
    }

    void add( Q3GListIterator* i ) {
        if ( !iterator ) {
            iterator = i;
        } else if ( list ) {
            list->push_front( i );
        } else {
            list = new Q3ValueList<Q3GListIterator*>;
            list->push_front( i );
        }
    }

    void remove( Q3GListIterator* i ) {
        if ( iterator == i ) {
            iterator = 0;
        } else if ( list ) {
            list->remove( i );
            if ( list->isEmpty() ) {
                delete list;
                list = 0;
            }
        }
    }

    void notifyClear( bool zeroList ) {
        if ( iterator ) {
            if ( zeroList )
                iterator->list = 0;
            iterator->curNode = 0;
        }
        if ( list ) {
            for ( Q3ValueList<Q3GListIterator*>::Iterator i = list->begin(); i != list->end(); ++i ) {
                if ( zeroList )
                    (*i)->list = 0;
                (*i)->curNode = 0;
            }
        }
    }

    void notifyRemove( Q3LNode* n, Q3LNode* curNode ) {
        if ( iterator ) {
            if ( iterator->curNode == n )
                iterator->curNode = curNode;
        }
        if ( list ) {
            for ( Q3ValueList<Q3GListIterator*>::Iterator i = list->begin(); i != list->end(); ++i ) {
                if ( (*i)->curNode == n )
                    (*i)->curNode = curNode;
            }
        }
    }

private:
    Q3ValueList<Q3GListIterator*>* list;
    Q3GListIterator* iterator;
};



/*****************************************************************************
  Default implementation of virtual functions
 *****************************************************************************/

/*!
  Documented as Q3PtrList::compareItems().

  Compares \a item1 with \a item2.
*/
int Q3GList::compareItems( Q3PtrCollection::Item item1, Q3PtrCollection::Item item2 )
{
    return item1 != item2;                      // compare pointers
}

#ifndef QT_NO_DATASTREAM
/*!
    \overload
  Reads a collection/list item from the stream \a s and returns a reference
  to the stream.

  The default implementation sets \a item to 0.

  \sa write()
*/

QDataStream &Q3GList::read( QDataStream &s, Q3PtrCollection::Item &item )
{
    item = 0;
    return s;
}

/*!
    \overload
  Writes a collection/list item to the stream \a s and
  returns a reference to the stream.

  The default implementation does nothing.

  \sa read()
*/

QDataStream &Q3GList::write( QDataStream &s, Q3PtrCollection::Item ) const
{
    return s;
}
#endif // QT_NO_DATASTREAM

/*****************************************************************************
  Q3GList member functions
 *****************************************************************************/

/*!
  Constructs an empty list.
*/

Q3GList::Q3GList()
{
    firstNode = lastNode = curNode = 0;         // initialize list
    numNodes  = 0;
    curIndex  = -1;
    iterators = 0;                              // initialize iterator list
}

/*!
  Constructs a copy of \a list.
*/

Q3GList::Q3GList( const Q3GList & list )
    : Q3PtrCollection( list )
{
    firstNode = lastNode = curNode = 0;         // initialize list
    numNodes  = 0;
    curIndex  = -1;
    iterators = 0;                              // initialize iterator list
    Q3LNode *n = list.firstNode;
    while ( n ) {                               // copy all items from list
        append( n->data );
        n = n->next;
    }
}

/*!
  Removes all items from the list and destroys the list.
*/

Q3GList::~Q3GList()
{
    clear();
    delete iterators;
    // Workaround for GCC 2.7.* bug. Compiler constructs 'static' Q3GList
    // instances twice on the same address and therefore tries to destruct
    // twice on the same address! This is insane but let's try not to crash
    // here.
    iterators = 0;
}


/*!
  Assigns \a list to this list.
*/

Q3GList& Q3GList::operator=( const Q3GList &list )
{
    if ( &list == this )
        return *this;

    clear();
    if ( list.count() > 0 ) {
        Q3LNode *n = list.firstNode;
        while ( n ) {                           // copy all items from list
            append( n->data );
            n = n->next;
        }
        curNode  = firstNode;
        curIndex = 0;
    }
    return *this;
}

/*!
  Compares this list with \a list. Returns true if the lists
  contain the same data, otherwise false.
*/

bool Q3GList::operator==( const Q3GList &list ) const
{
    if ( count() != list.count() )
        return false;

    if ( count() == 0 )
        return true;

    Q3LNode *n1 = firstNode;
    Q3LNode *n2 = list.firstNode;
    while ( n1 && n2 ) {
        // should be mutable
        if ( ( (Q3GList*)this )->compareItems( n1->data, n2->data ) != 0 )
            return false;
        n1 = n1->next;
        n2 = n2->next;
    }

    return true;
}

/*!
  \fn uint Q3GList::count() const

  Returns the number of items in the list.
*/


/*!
  Returns the node at position \a index.  Sets this node to current.
*/

Q3LNode *Q3GList::locate( uint index )
{
    if ( index == (uint)curIndex )              // current node ?
        return curNode;
    if ( !curNode && firstNode ) {              // set current node
        curNode  = firstNode;
        curIndex = 0;
    }
    register Q3LNode *node;
    int  distance = index - curIndex;           // node distance to cur node
    bool forward;                               // direction to traverse

    if ( index >= numNodes )
        return 0;

    if ( distance < 0 )
        distance = -distance;
    if ( (uint)distance < index && (uint)distance < numNodes - index ) {
        node =  curNode;                        // start from current node
        forward = index > (uint)curIndex;
    } else if ( index < numNodes - index ) {    // start from first node