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

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** 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.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qlinkedlist.h"

QT_BEGIN_NAMESPACE

QLinkedListData QLinkedListData::shared_null = {

    &QLinkedListData::shared_null, &QLinkedListData::shared_null,

    Q_BASIC_ATOMIC_INITIALIZER(1), 0, true

};

/*! \class QLinkedList

    \brief The QLinkedList class is a template class that provides linked lists.

    \ingroup tools

    \ingroup shared

    \reentrant

    QLinkedList\<T\> is one of Qt's generic \l{container classes}. It

    stores a list of values and provides iterator-based access as

    well as \l{constant time} insertions and removals.

    QList\<T\>, QLinkedList\<T\>, and QVector\<T\> provide similar

    functionality. Here's an overview:

    \list

    \i For most purposes, QList is the right class to use. Its

       index-based API is more convenient than QLinkedList's

       iterator-based API, and it is usually faster than

       QVector because of the way it stores its items in

       memory (see \l{Algorithmic Complexity} for details).

       It also expands to less code in your executable.

    \i If you need a real linked list, with guarantees of \l{constant

       time} insertions in the middle of the list and iterators to

       items rather than indexes, use QLinkedList.

    \i If you want the items to occupy adjacent memory positions,

       use QVector.

    \endlist

    Here's an example of a QLinkedList that stores integers and a

    QLinkedList that stores QTime values:

    \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 0

    QLinkedList stores a list of items. The default constructor

    creates an empty list. To insert items into the list, you can use

    operator<<():

    \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 1

    If you want to get the first or last item in a linked list, use

    first() or last(). If you want to remove an item from either end

    of the list, use removeFirst() or removeLast(). If you want to

    remove all occurrences of a given value in the list, use

    removeAll().

    A common requirement is to remove the first or last item in the

    list and do something with it. For this, QLinkedList provides

    takeFirst() and takeLast(). Here's a loop that removes the items

    from a list one at a time and calls \c delete on them:

    \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 2

    QLinkedList's value type must be an \l {assignable data type}. This

    covers most data types that are commonly used, but the compiler

    won't let you, for example, store a QWidget as a value; instead,

    store a QWidget *. A few functions have additional requirements;

    for example, contains() and removeAll() expect the value type to

    support \c operator==().  These requirements are documented on a

    per-function basis.

    If you want to insert, modify, or remove items in the middle of

    the list, you must use an iterator. QLinkedList provides both

    \l{Java-style iterators} (QLinkedListIterator and

    QMutableLinkedListIterator) and \l{STL-style iterators}

    (QLinkedList::const_iterator and QLinkedList::iterator). See the

    documentation for these classes for details.

    \sa QLinkedListIterator, QMutableLinkedListIterator, QList, QVector

*/

/*! \fn QLinkedList::QLinkedList()

    Constructs an empty list.

*/

/*! \fn QLinkedList::QLinkedList(const QLinkedList<T> &other)

    Constructs a copy of \a other.

    This operation occurs in \l{constant time}, because QLinkedList

    is \l{implicitly shared}. This makes returning a QLinkedList from

    a function very fast. If a shared instance is modified, it will

    be copied (copy-on-write), and this takes \l{linear time}.

    \sa operator=()

*/

/*! \fn QLinkedList::~QLinkedList()

    Destroys the list. References to the values in the list, and all

    iterators over this list, become invalid.

*/

/*! \fn QLinkedList<T> &QLinkedList::operator=(const QLinkedList<T> &other)

    Assigns \a other to this list and returns a reference to this

    list.

*/

/*! \fn bool QLinkedList::operator==(const QLinkedList<T> &other) const

    Returns true if \a other is equal to this list; otherwise returns

    false.

    Two lists are considered equal if they contain the same values in

    the same order.

    This function requires the value type to implement \c

    operator==().

    \sa operator!=()

*/

/*! \fn bool QLinkedList::operator!=(const QLinkedList<T> &other) const

    Returns true if \a other is not equal to this list; otherwise

    returns false.

    Two lists are considered equal if they contain the same values in

    the same order.

    This function requires the value type to implement \c

    operator==().

    \sa operator==()

*/

/*! \fn int QLinkedList::size() const

    Returns the number of items in the list.

    \sa isEmpty(), count()

*/

/*! \fn void QLinkedList::detach()

    \internal

*/

/*! \fn bool QLinkedList::isDetached() const

    \internal

*/

/*! \fn void QLinkedList::setSharable(bool sharable)

    \internal

*/

/*! \fn bool QLinkedList::isEmpty() const

    Returns true if the list contains no items; otherwise returns

    false.

    \sa size()

*/

/*! \fn void QLinkedList::clear()

    Removes all the items in the list.

    \sa removeAll()

*/

/*! \fn void QLinkedList::append(const T &value)

    Inserts \a value at the end of the list.

    Example:

    \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 3

    This is the same as list.insert(end(), \a value).

    \sa operator<<(), prepend(), insert()

*/

/*! \fn void QLinkedList::prepend(const T &value)

    Inserts \a value at the beginning of the list.

    Example:

    \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 4

    This is the same as list.insert(begin(), \a value).

    \sa append(), insert()

*/

/*! \fn int QLinkedList::removeAll(const T &value)

    Removes all occurrences of \a value in the list.

    Example:

    \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 5

    This function requires the value type to have an implementation of

    \c operator==().

    \sa insert()

*/

/*! 

    \fn bool QLinkedList::removeOne(const T &value)

    \since 4.4

    Removes the first occurrences of \a value in the list. Returns true on

    success; otherwise returns false.

    Example:

    \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 6

    This function requires the value type to have an implementation of

    \c operator==().

    \sa insert()

*/

/*! \fn bool QLinkedList::contains(const T &value) const

    Returns true if the list contains an occurrence of \a value;

    otherwise returns false.

    This function requires the value type to have an implementation of

    \c operator==().

    \sa QLinkedListIterator::findNext(), QLinkedListIterator::findPrevious()

*/

/*! \fn int QLinkedList::count(const T &value) const

    Returns the number of occurrences of \a value in the list.

    This function requires the value type to have an implementation of

    \c operator==().

    \sa contains()

*/

/*! \fn bool QLinkedList::startsWith(const T &value) const

    \since 4.5

    Returns true if the list is not empty and its first

    item is equal to \a value; otherwise returns false.

    \sa isEmpty(), first()

*/

/*! \fn bool QLinkedList::endsWith(const T &value) const

    \since 4.5

    Returns true if the list is not empty and its last

    item is equal to \a value; otherwise returns false.

    \sa isEmpty(), last()

*/

/*! \fn QLinkedList::iterator QLinkedList::begin()

    Returns an \l{STL-style iterator} pointing to the first item in

    the list.

    \sa constBegin(), end()

*/

/*! \fn QLinkedList::const_iterator QLinkedList::begin() const

    \overload

*/

/*! \fn QLinkedList::const_iterator QLinkedList::constBegin() const

    Returns a const \l{STL-style iterator} pointing to the first item

    in the list.

    \sa begin(), constEnd()

*/

/*! \fn QLinkedList::iterator QLinkedList::end()

    Returns an \l{STL-style iterator} pointing to the imaginary item

    after the last item in the list.

    \sa begin(), constEnd()

*/

/*! \fn QLinkedList::const_iterator QLinkedList::end() const

    \overload

*/

/*! \fn QLinkedList::const_iterator QLinkedList::constEnd() const

    Returns a const \l{STL-style iterator} pointing to the imaginary

    item after the last item in the list.

    \sa constBegin(), end()

*/

/*! \fn QLinkedList::iterator QLinkedList::insert(iterator before, const T &value)

    Inserts \a value in front of the item pointed to by the iterator

    \a before. Returns an iterator pointing at the inserted item.

    \sa erase()

*/

/*! \fn QLinkedList::iterator QLinkedList::erase(iterator pos)

    Removes the item pointed to by the iterator \a pos from the list,

    and returns an iterator to the next item in the list (which may be

    end()).

    \sa insert()

*/

/*! \fn QLinkedList::iterator QLinkedList::erase(iterator begin, iterator end)

    \overload

    Removes all the items from \a begin up to (but not including) \a

    end.

*/

/*! \typedef QLinkedList::Iterator

    Qt-style synonym for QLinkedList::iterator.

*/

/*! \typedef QLinkedList::ConstIterator

    Qt-style synonym for QLinkedList::const_iterator.

*/

/*!

    \typedef QLinkedList::size_type

    Typedef for int. Provided for STL compatibility.

*/

/*!

    \typedef QLinkedList::value_type

    Typedef for T. Provided for STL compatibility.

*/

/*!

    \typedef QLinkedList::pointer

    Typedef for T *. Provided for STL compatibility.

*/

/*!

    \typedef QLinkedList::const_pointer

    Typedef for const T *. Provided for STL compatibility.

*/

/*!

    \typedef QLinkedList::reference

    Typedef for T &. Provided for STL compatibility.

*/

/*!

    \typedef QLinkedList::const_reference

    Typedef for const T &. Provided for STL compatibility.

*/

/*!

    \typedef QLinkedList::difference_type

    Typedef for ptrdiff_t. Provided for STL compatibility.

*/

/*! \fn int QLinkedList::count() const

    Same as size().

*/

/*! \fn T& QLinkedList::first()

    Returns a reference to the first item in the list. This function

    assumes that the list isn't empty.

    \sa last(), isEmpty()

*/

/*! \fn const T& QLinkedList::first() const

    \overload

*/

/*! \fn T& QLinkedList::last()

    Returns a reference to the last item in the list. This function

    assumes that the list isn't empty.

    \sa first(), isEmpty()

*/

/*! \fn const T& QLinkedList::last() const

    \overload

*/

/*! \fn void QLinkedList::removeFirst()

    Removes the first item in the list.

    This is the same as erase(begin()).

    \sa removeLast(), erase()

*/

/*! \fn void QLinkedList::removeLast()

    Removes the last item in the list.

    \sa removeFirst(), erase()

*/

/*! \fn T QLinkedList::takeFirst()

    Removes the first item in the list and returns it.

    If you don't use the return value, removeFirst() is more

    efficient.

    \sa takeLast(), removeFirst()

*/

/*! \fn T QLinkedList::takeLast()

    Removes the last item in the list and returns it.

    If you don't use the return value, removeLast() is more

    efficient.

    \sa takeFirst(), removeLast()

*/

/*! \fn void QLinkedList::push_back(const T &value)

    This function is provided for STL compatibility. It is equivalent

    to append(\a value).

*/

/*! \fn void QLinkedList::push_front(const T &value)

    This function is provided for STL compatibility. It is equivalent

    to prepend(\a value).

*/

/*! \fn T& QLinkedList::front()

    This function is provided for STL compatibility. It is equivalent

    to first().

*/

/*! \fn const T& QLinkedList::front() const

    \overload

*/

/*! \fn T& QLinkedList::back()

    This function is provided for STL compatibility. It is equivalent

    to last().

*/

/*! \fn const T& QLinkedList::back() const

    \overload

*/

/*! \fn void QLinkedList::pop_front()