--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/porting/src/list.h	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,374 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the qt3to4 porting application 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$
+**
+****************************************************************************/
+
+#ifndef LIST_H
+#define LIST_H
+
+#include "smallobject.h"
+#include <QtGlobal>
+
+QT_BEGIN_NAMESPACE
+
+template <typename T>
+class List
+{
+    struct Data
+    {
+        int alloc, size;
+        T array[1];
+    };
+    pool *p;
+    Data *d;
+
+public:
+    inline List(pool *_pool) : p(_pool), d(0) { d = malloc(16); d->size = 0; d->alloc = 16; }
+
+    inline List(const List &v) : d(0) { operator=(v); }
+    inline ~List() { d = 0; }
+    List &operator=(const List &v);
+
+    bool operator==(const List &v) const;
+    inline bool operator!=(const List &v) const { return !(*this == v); }
+
+    inline int size() const { return d->size; }
+    inline bool isEmpty() const { return d->size == 0; }
+
+    inline int capacity() const { return d->alloc; }
+    void reserve(int alloc);
+
+    inline T* data() { return d->array; }
+    inline const T* data() const { return d->array; }
+    void clear();
+
+    const T &at(int i) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+    void append(const T &t);
+    void prepend(const T &t);
+    void insert(int i, const T &t);
+    void insert(int i, int n, const T &t);
+    void replace(int i, const T &t);
+    void remove(int i);
+    void remove(int i, int n);
+
+    List &fill(const T &t, int size = -1);
+
+    int indexOf(const T &t, int from = 0) const;
+    int lastIndexOf(const T &t, int from = -1) const;
+    bool contains(const T &t) const;
+    int count(const T &t) const;
+
+    // STL-style
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    inline iterator begin() { return d->array; }
+    inline const_iterator begin() const { return d->array; }
+    inline iterator end() { return d->array + d->size; }
+    inline const_iterator end() const { return d->array + d->size; }
+    iterator insert(iterator before, int n, const T &x);
+    inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
+    iterator erase(iterator begin, iterator end);
+    inline iterator erase(iterator pos) { return erase(pos, pos+1); }
+
+    // more Qt
+    inline int count() const { return d->size; }
+    inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); }
+    inline const T& first() const { Q_ASSERT(!isEmpty()); return *begin(); }
+    inline T& last() { Q_ASSERT(!isEmpty()); return *(end()-1); }
+    inline const T& last() const { Q_ASSERT(!isEmpty()); return *(end()-1); }
+
+    T value(int i) const;
+    T value(int i, const T &defaultValue) const;
+
+    // STL compatibility
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+#ifndef QT_NO_STL
+    typedef ptrdiff_t difference_type;
+#else
+    typedef int difference_type;
+#endif
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    typedef int size_type;
+    inline void push_back(const T &t) { append(t); }
+    inline void push_front(const T &t) { prepend(t); }
+    void pop_back() { Q_ASSERT(!isEmpty()); erase(end()-1); }
+    void pop_front() { Q_ASSERT(!isEmpty()); erase(begin()); }
+    inline bool empty() const
+    { return d->size == 0; }
+    inline T& front() { return first(); }
+    inline const_reference front() const { return first(); }
+    inline reference back() { return last(); }
+    inline const_reference back() const { return last(); }
+
+    //comfort
+    List &operator+=(const List &l);
+    inline List operator+(const List &l) const
+    { List n = *this; n += l; return n; }
+    inline void operator+=(const T &t)
+    { append(t); }
+    inline List &operator<< (const T &t)
+    { append(t); return *this; }
+
+private:
+    Data *malloc(int alloc);
+};
+
+template <typename T>
+inline void List<T>::clear()
+{ d->size = 0; }
+
+template <typename T>
+inline const T &List<T>::at(int i) const
+{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::at", "index out of range");
+  return d->array[i]; }
+template <typename T>
+inline const T &List<T>::operator[](int i) const
+{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::operator[]", "index out of range");
+  return d->array[i]; }
+template <typename T>
+inline T &List<T>::operator[](int i)
+{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::operator[]", "index out of range");
+  return d->array[i]; }
+template <typename T>
+inline void List<T>::insert(int i, const T &t)
+{ Q_ASSERT_X(i >= 0 && i <= d->size, "List<T>::insert", "index out of range");
+  insert(begin()+i, 1, t); }
+template <typename T>
+inline void List<T>::insert(int i, int n, const T &t)
+{ Q_ASSERT_X(i >= 0 && i <= d->size, "List<T>::insert", "index out of range");
+  insert(begin() + i, n, t); }
+template <typename T>
+inline void List<T>::remove(int i, int n)
+{ Q_ASSERT_X(i >= 0 && i + n <= d->size, "List<T>::remove", "index out of range");
+  erase(begin() + i, begin() + i + n); }
+template <typename T>
+inline void List<T>::remove(int i)
+{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::remove", "index out of range");
+  erase(begin() + i, begin() + i + 1); }
+template <typename T>
+inline void List<T>::prepend(const T &t)
+{ insert(begin(), 1, t); }
+template <typename T>
+inline void List<T>::replace(int i, const T &t)
+{ Q_ASSERT_X(i >= 0 && i < d->size, "List<T>::replace", "index out of range");
+  data()[i] = t; }
+
+template <typename T>
+List<T> &List<T>::operator=(const List<T> &v)
+{
+    p = v.p;
+    d = malloc(v.d->alloc);
+    memcpy(d, v.d, sizeof(Data) + (v.d->size - 1) * sizeof(T));
+    return *this;
+}
+
+template <typename T>
+inline typename List<T>::Data *List<T>::malloc(int alloc)
+{
+    return static_cast<Data *>(p->allocate(sizeof(Data) + (alloc - 1) * sizeof(T)));
+}
+
+template <typename T>
+void List<T>::reserve(int alloc)
+{
+    if (alloc <= d->alloc)
+        return;
+    alloc <<= 2;
+    d = static_cast<Data *>(p->reallocate(d, sizeof(Data) + d->alloc * sizeof(T),
+                                          sizeof(Data) + (alloc - 1) * sizeof(T)));
+    d->alloc = alloc;
+}
+
+template<typename T>
+T List<T>::value(int i) const
+{
+    if(i < 0 || i >= d->size) {
+        return T();
+    }
+    return d->array[i];
+}
+template<typename T>
+T List<T>::value(int i, const T& defaultValue) const
+{
+    return ((i < 0 || i >= d->size) ? defaultValue : d->array[i]);
+}
+
+template <typename T>
+void List<T>::append(const T &t)
+{
+    reserve(d->size + 1);
+    d->array[d->size++] = t;
+}
+
+
+template <typename T>
+typename List<T>::iterator List<T>::insert(iterator before, size_type n, const T& t)
+{
+    int p = before - d->array;
+    if (n != 0) {
+        reserve(d->size + n);
+        T *b = d->array+p;
+        T *i = b+n;
+        memmove(i, b, (d->size-p)*sizeof(T));
+        while (i != b)
+            *(--i) = t;
+    }
+    d->size += n;
+    return d->array+p;
+}
+
+template <typename T>
+typename List<T>::iterator List<T>::erase(iterator begin, iterator end)
+{
+    int f = begin - d->array;
+    int l = end - d->array;
+    int n = l - f;
+    memmove(d->array + f, d->array + l, (d->size-l)*sizeof(T));
+    d->size -= n;
+    return d->array + f;
+}
+
+template <typename T>
+bool List<T>::operator==(const List<T> &v) const
+{
+    if (d->size != v.d->size)
+        return false;
+    T* b = d->array;
+    T* i = b + d->size;
+    T* j = v.d->array + d->size;
+    while (i != b)
+        if (!(*--i == *--j))
+            return false;
+    return true;
+}
+
+template <typename T>
+List<T> &List<T>::fill(const T &t, int size)
+{
+    resize(size < 0 ? d->size : size);
+    if (d->size) {
+        T* i = d->array + d->size;
+        T* b = d->array;
+        while (i != b)
+            *--i = t;
+    }
+    return *this;
+}
+
+template <typename T>
+List<T> &List<T>::operator+=(const List &l)
+{
+    int newSize = d->size + l.d->size;
+    reserve(newSize);
+
+    T *w = d->array + newSize;
+    T *i = l.d->array + l.d->size;
+    T *b = l.d->array;
+    while (i != b)
+        *--w = *--i;
+    d->size = newSize;
+    return *this;
+}
+
+template <typename T>
+int List<T>::indexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from = qMax(from + d->size, 0);
+    if (from < d->size) {
+        T* n = d->array + from - 1;
+        T* e = d->array + d->size;
+        while (++n != e)
+            if (*n == t)
+                return n - d->array;
+    }
+    return -1;
+}
+
+template <typename T>
+int List<T>::lastIndexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from += d->size;
+    else if (from >= d->size)
+        from = d->size-1;
+    if (from >= 0) {
+        T* b = d->array;
+        T* n = d->array + from + 1;
+        while (n != b) {
+            if (*--n == t)
+                return n - b;
+        }
+    }
+    return -1;
+}
+
+template <typename T>
+bool List<T>::contains(const T &t) const
+{
+    T* b = d->array;
+    T* i = d->array + d->size;
+    while (i != b)
+        if (*--i == t)
+            return true;
+    return false;
+}
+
+template <typename T>
+int List<T>::count(const T &t) const
+{
+    int c = 0;
+    T* b = d->array;
+    T* i = d->array + d->size;
+    while (i != b)
+        if (*--i == t)
+            ++c;
+    return c;
+}
+
+QT_END_NAMESPACE
+
+#endif // LIST_H