开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
qlist.h
资源名称：rootfs-7-9.tar.gz　[点击查看]
上传用户：detong
上传日期：2022-06-22
资源大小：20675k
文件大小：23k
源码类别：

系统编程

开发平台：

Unix_Linux

qlist.h：源码内容
  1. /****************************************************************************
  2. **
  3. ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
  4. ** Contact: Qt Software Information (qt-info@nokia.com)
  5. **
  6. ** This file is part of the QtCore module of the Qt Toolkit.
  7. **
  8. ** Commercial Usage
  9. ** Licensees holding valid Qt Commercial licenses may use this file in
  10. ** accordance with the Qt Commercial License Agreement provided with the
  11. ** Software or, alternatively, in accordance with the terms contained in
  12. ** a written agreement between you and Nokia.
  13. **
  14. **
  15. ** GNU General Public License Usage
  16. ** Alternatively, this file may be used under the terms of the GNU
  17. ** General Public License versions 2.0 or 3.0 as published by the Free
  18. ** Software Foundation and appearing in the file LICENSE.GPL included in
  19. ** the packaging of this file.  Please review the following information
  20. ** to ensure GNU General Public Licensing requirements will be met:
  21. ** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
  22. ** http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
  23. ** exception, Nokia gives you certain additional rights. These rights
  24. ** are described in the Nokia Qt GPL Exception version 1.3, included in
  25. ** the file GPL_EXCEPTION.txt in this package.
  26. **
  27. ** Qt for Windows(R) Licensees
  28. ** As a special exception, Nokia, as the sole copyright holder for Qt
  29. ** Designer, grants users of the Qt/Eclipse Integration plug-in the
  30. ** right for the Qt/Eclipse Integration to link to functionality
  31. ** provided by Qt Designer and its related libraries.
  32. **
  33. ** If you are unsure which license is appropriate for your use, please
  34. ** contact the sales department at qt-sales@nokia.com.
  35. **
  36. ****************************************************************************/
  38. #ifndef QLIST_H
  39. #define QLIST_H
  41. #include <QtCore/qiterator.h>
  42. #include <QtCore/qatomic.h>
  43. #include <QtCore/qalgorithms.h>
  45. #ifndef QT_NO_STL
  46. #include <iterator>
  47. #include <list>
  48. #endif
  50. #include <new>
  52. QT_BEGIN_HEADER
  54. QT_BEGIN_NAMESPACE
  56. QT_MODULE(Core)
  58. template <typename T> class QVector;
  59. template <typename T> class QSet;
  61. struct Q_CORE_EXPORT QListData {
  62.     struct Data {
  63.         QBasicAtomicInt ref;
  64.         int alloc, begin, end;
  65.         uint sharable : 1;
  66.         void *array[1];
  67.     };
  68.     enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };
  70.     Data *detach(); // remove in 5.0
  71.     Data *detach2();
  72.     void realloc(int alloc);
  73.     static Data shared_null;
  74.     Data *d;
  75.     void **erase(void **xi);
  76.     void **append();
  77.     void **append(const QListData &l);
  78.     void **prepend();
  79.     void **insert(int i);
  80.     void remove(int i);
  81.     void remove(int i, int n);
  82.     void move(int from, int to);
  83.     inline int size() const { return d->end - d->begin; }
  84.     inline bool isEmpty() const { return d->end  == d->begin; }
  85.     inline void **at(int i) const { return d->array + d->begin + i; }
  86.     inline void **begin() const { return d->array + d->begin; }
  87.     inline void **end() const { return d->array + d->end; }
  88. };
  90. template <typename T>
  91. class QList
  92. {
  93.     struct Node { void *v;
  94. #if defined(Q_CC_BOR)
  95.         Q_INLINE_TEMPLATE T &t();
  96. #else
  97.         Q_INLINE_TEMPLATE T &t()
  98.         { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
  99.                                        ? v : this); }
  100. #endif
  101.     };
  103.     union { QListData p; QListData::Data *d; };
  105. public:
  106.     inline QList() : d(&QListData::shared_null) { d->ref.ref(); }
  107.     inline QList(const QList<T> &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
  108.     ~QList();
  109.     QList<T> &operator=(const QList<T> &l);
  110.     bool operator==(const QList<T> &l) const;
  111.     inline bool operator!=(const QList<T> &l) const { return !(*this == l); }
  113.     inline int size() const { return p.size(); }
  115.     inline void detach() { if (d->ref != 1) detach_helper(); }
  116.     inline bool isDetached() const { return d->ref == 1; }
  117.     inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
  119.     inline bool isEmpty() const { return p.isEmpty(); }
  121.     void clear();
  123.     const T &at(int i) const;
  124.     const T &operator[](int i) const;
  125.     T &operator[](int i);
  127.     void append(const T &t);
  128.     void prepend(const T &t);
  129.     void insert(int i, const T &t);
  130.     void replace(int i, const T &t);
  131.     void removeAt(int i);
  132.     int removeAll(const T &t);
  133.     bool removeOne(const T &t);
  134.     T takeAt(int i);
  135.     T takeFirst();
  136.     T takeLast();
  137.     void move(int from, int to);
  138.     void swap(int i, int j);
  139.     int indexOf(const T &t, int from = 0) const;
  140.     int lastIndexOf(const T &t, int from = -1) const;
  141.     QBool contains(const T &t) const;
  142.     int count(const T &t) const;
  144.     class const_iterator;
  146.     class iterator {
  147.     public:
  148.         Node *i;
  149.         typedef std::random_access_iterator_tag  iterator_category;
  150.         typedef ptrdiff_t  difference_type;
  151.         typedef T value_type;
  152.         typedef T *pointer;
  153.         typedef T &reference;
  155.         inline iterator() : i(0) {}
  156.         inline iterator(Node *n) : i(n) {}
  157.         inline iterator(const iterator &o): i(o.i){}
  158.         inline T &operator*() const { return i->t(); }
  159.         inline T *operator->() const { return &i->t(); }
  160.         inline T &operator[](int j) const { return i[j].t(); }
  161.         inline bool operator==(const iterator &o) const { return i == o.i; }
  162.         inline bool operator!=(const iterator &o) const { return i != o.i; }
  163.         inline bool operator<(const iterator& other) const { return i < other.i; }
  164.         inline bool operator<=(const iterator& other) const { return i <= other.i; }
  165.         inline bool operator>(const iterator& other) const { return i > other.i; }
  166.         inline bool operator>=(const iterator& other) const { return i >= other.i; }
  167. #ifndef QT_STRICT_ITERATORS
  168.         inline bool operator==(const const_iterator &o) const
  169.             { return i == o.i; }
  170.         inline bool operator!=(const const_iterator &o) const
  171.             { return i != o.i; }
  172.         inline bool operator<(const const_iterator& other) const
  173.             { return i < other.i; }
  174.         inline bool operator<=(const const_iterator& other) const
  175.             { return i <= other.i; }
  176.         inline bool operator>(const const_iterator& other) const
  177.             { return i > other.i; }
  178.         inline bool operator>=(const const_iterator& other) const
  179.             { return i >= other.i; }
  180. #endif
  181.         inline iterator &operator++() { ++i; return *this; }
  182.         inline iterator operator++(int) { Node *n = i; ++i; return n; }
  183.         inline iterator &operator--() { i--; return *this; }
  184.         inline iterator operator--(int) { Node *n = i; i--; return n; }
  185.         inline iterator &operator+=(int j) { i+=j; return *this; }
  186.         inline iterator &operator-=(int j) { i-=j; return *this; }
  187.         inline iterator operator+(int j) const { return iterator(i+j); }
  188.         inline iterator operator-(int j) const { return iterator(i-j); }
  189.         inline int operator-(iterator j) const { return i - j.i; }
  190.     };
  191.     friend class iterator;
  193.     class const_iterator {
  194.     public:
  195.         Node *i;
  196.         typedef std::random_access_iterator_tag  iterator_category;
  197.         typedef ptrdiff_t difference_type;
  198.         typedef T value_type;
  199.         typedef const T *pointer;
  200.         typedef const T &reference;
  202.         inline const_iterator() : i(0) {}
  203.         inline const_iterator(Node *n) : i(n) {}
  204.         inline const_iterator(const const_iterator &o): i(o.i) {}
  205. #ifdef QT_STRICT_ITERATORS
  206.         inline explicit const_iterator(const iterator &o): i(o.i) {}
  207. #else
  208.         inline const_iterator(const iterator &o): i(o.i) {}
  209. #endif
  210.         inline const T &operator*() const { return i->t(); }
  211.         inline const T *operator->() const { return &i->t(); }
  212.         inline const T &operator[](int j) const { return i[j].t(); }
  213.         inline bool operator==(const const_iterator &o) const { return i == o.i; }
  214.         inline bool operator!=(const const_iterator &o) const { return i != o.i; }
  215.         inline bool operator<(const const_iterator& other) const { return i < other.i; }
  216.         inline bool operator<=(const const_iterator& other) const { return i <= other.i; }
  217.         inline bool operator>(const const_iterator& other) const { return i > other.i; }
  218.         inline bool operator>=(const const_iterator& other) const { return i >= other.i; }
  219.         inline const_iterator &operator++() { ++i; return *this; }
  220.         inline const_iterator operator++(int) { Node *n = i; ++i; return n; }
  221.         inline const_iterator &operator--() { i--; return *this; }
  222.         inline const_iterator operator--(int) { Node *n = i; i--; return n; }
  223.         inline const_iterator &operator+=(int j) { i+=j; return *this; }
  224.         inline const_iterator &operator-=(int j) { i-=j; return *this; }
  225.         inline const_iterator operator+(int j) const { return const_iterator(i+j); }
  226.         inline const_iterator operator-(int j) const { return const_iterator(i-j); }
  227.         inline int operator-(const_iterator j) const { return i - j.i; }
  228.     };
  229.     friend class const_iterator;
  231.     // stl style
  232.     inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); }
  233.     inline const_iterator begin() const { return reinterpret_cast<Node *>(p.begin()); }
  234.     inline const_iterator constBegin() const { return reinterpret_cast<Node *>(p.begin()); }
  235.     inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
  236.     inline const_iterator end() const { return reinterpret_cast<Node *>(p.end()); }
  237.     inline const_iterator constEnd() const { return reinterpret_cast<Node *>(p.end()); }
  238.     iterator insert(iterator before, const T &t);
  239.     iterator erase(iterator pos);
  240.     iterator erase(iterator first, iterator last);
  242.     // more Qt
  243.     typedef iterator Iterator;
  244.     typedef const_iterator ConstIterator;
  245.     inline int count() const { return p.size(); }
  246.     inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); }
  247.     inline const T& first() const { Q_ASSERT(!isEmpty()); return *begin(); }
  248.     T& last() { Q_ASSERT(!isEmpty()); return *(--end()); }
  249.     const T& last() const { Q_ASSERT(!isEmpty()); return *(--end()); }
  250.     inline void removeFirst() { Q_ASSERT(!isEmpty()); erase(begin()); }
  251.     inline void removeLast() { Q_ASSERT(!isEmpty()); erase(--end()); }
  252.     QList<T> mid(int pos, int length = -1) const;
  254.     T value(int i) const;
  255.     T value(int i, const T &defaultValue) const;
  257.     // stl compatibility
  258.     inline void push_back(const T &t) { append(t); }
  259.     inline void push_front(const T &t) { prepend(t); }
  260.     inline T& front() { return first(); }
  261.     inline const T& front() const { return first(); }
  262.     inline T& back() { return last(); }
  263.     inline const T& back() const { return last(); }
  264.     inline void pop_front() { removeFirst(); }
  265.     inline void pop_back() { removeLast(); }
  266.     inline bool empty() const { return isEmpty(); }
  267.     typedef int size_type;
  268.     typedef T value_type;
  269.     typedef value_type *pointer;
  270.     typedef const value_type *const_pointer;
  271.     typedef value_type &reference;
  272.     typedef const value_type &const_reference;
  273.     typedef ptrdiff_t difference_type;
  275. #ifdef QT3_SUPPORT
  276.     inline QT3_SUPPORT iterator remove(iterator pos) { return erase(pos); }
  277.     inline QT3_SUPPORT int remove(const T &t) { return removeAll(t); }
  278.     inline QT3_SUPPORT int findIndex(const T& t) const { return indexOf(t); }
  279.     inline QT3_SUPPORT iterator find(const T& t)
  280.     { int i = indexOf(t); return (i == -1 ? end() : (begin()+i)); }
  281.     inline QT3_SUPPORT const_iterator find (const T& t) const
  282.     { int i = indexOf(t); return (i == -1 ? end() : (begin()+i)); }
  283.     inline QT3_SUPPORT iterator find(iterator from, const T& t)
  284.     { int i = indexOf(t, from - begin()); return i == -1 ? end() : begin()+i; }
  285.     inline QT3_SUPPORT const_iterator find(const_iterator from, const T& t) const
  286.     { int i = indexOf(t, from - begin()); return i == -1 ? end() : begin()+i; }
  287. #endif
  289.     // comfort
  290.     QList<T> &operator+=(const QList<T> &l);
  291.     inline QList<T> operator+(const QList<T> &l) const
  292.     { QList n = *this; n += l; return n; }
  293.     inline QList<T> &operator+=(const T &t)
  294.     { append(t); return *this; }
  295.     inline QList<T> &operator<< (const T &t)
  296.     { append(t); return *this; }
  297.     inline QList<T> &operator<<(const QList<T> &l)
  298.     { *this += l; return *this; }
  300.     QVector<T> toVector() const;
  301.     QSet<T> toSet() const;
  303.     static QList<T> fromVector(const QVector<T> &vector);
  304.     static QList<T> fromSet(const QSet<T> &set);
  306. #ifndef QT_NO_STL
  307.     static inline QList<T> fromStdList(const std::list<T> &list)
  308.     { QList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
  309.     inline std::list<T> toStdList() const
  310.     { std::list<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }
  311. #endif
  313. private:
  314.     void detach_helper();
  315.     void free(QListData::Data *d);
  317.     void node_construct(Node *n, const T &t);
  318.     void node_destruct(Node *n);
  319.     void node_copy(Node *from, Node *to, Node *src);
  320.     void node_destruct(Node *from, Node *to);
  321. };
  323. #if defined(Q_CC_BOR)
  324. template <typename T>
  325. Q_INLINE_TEMPLATE T &QList<T>::Node::t()
  326. { return QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic ? *(T*)v:*(T*)this; }
  327. #endif
  329. template <typename T>
  330. Q_INLINE_TEMPLATE void QList<T>::node_construct(Node *n, const T &t)
  331. {
  332.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t);
  333.     else if (QTypeInfo<T>::isComplex) new (n) T(t);
  334.     else *reinterpret_cast<T*>(n) = t;
  335. }
  337. template <typename T>
  338. Q_INLINE_TEMPLATE void QList<T>::node_destruct(Node *n)
  339. {
  340.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v);
  341.     else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T();
  342. }
  344. template <typename T>
  345. Q_INLINE_TEMPLATE void QList<T>::node_copy(Node *from, Node *to, Node *src)
  346. {
  347.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
  348.         while(from != to)
  349.             (from++)->v = new T(*reinterpret_cast<T*>((src++)->v));
  350.     else if (QTypeInfo<T>::isComplex)
  351.         while(from != to)
  352.             new (from++) T(*reinterpret_cast<T*>(src++));
  353. }
  355. template <typename T>
  356. Q_INLINE_TEMPLATE void QList<T>::node_destruct(Node *from, Node *to)
  357. {
  358.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
  359.         while(from != to) --to, delete reinterpret_cast<T*>(to->v);
  360.     else if (QTypeInfo<T>::isComplex)
  361.         while (from != to) --to, reinterpret_cast<T*>(to)->~T();
  362. }
  364. template <typename T>
  365. Q_INLINE_TEMPLATE QList<T> &QList<T>::operator=(const QList<T> &l)
  366. {
  367.     if (d != l.d) {
  368.         l.d->ref.ref();
  369.         if (!d->ref.deref())
  370.             free(d);
  371.         d = l.d;
  372.         if (!d->sharable)
  373.             detach_helper();
  374.     }
  375.     return *this;
  376. }
  377. template <typename T>
  378. inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
  379. { Node *n = reinterpret_cast<Node *>(p.insert(before.i-reinterpret_cast<Node *>(p.begin())));
  380.  node_construct(n,t); return n; }
  381. template <typename T>
  382. inline typename QList<T>::iterator QList<T>::erase(iterator it)
  383. { node_destruct(it.i);
  384.  return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i))); }
  385. template <typename T>
  386. inline const T &QList<T>::at(int i) const
  387. { Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::at", "index out of range");
  388.  return reinterpret_cast<Node *>(p.at(i))->t(); }
  389. template <typename T>
  390. inline const T &QList<T>::operator[](int i) const
  391. { Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::operator[]", "index out of range");
  392.  return reinterpret_cast<Node *>(p.at(i))->t(); }
  393. template <typename T>
  394. inline T &QList<T>::operator[](int i)
  395. { Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::operator[]", "index out of range");
  396.   detach(); return reinterpret_cast<Node *>(p.at(i))->t(); }
  397. template <typename T>
  398. inline void QList<T>::removeAt(int i)
  399. { if(i >= 0 && i < p.size()) { detach();
  400.  node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i); } }
  401. template <typename T>
  402. inline T QList<T>::takeAt(int i)
  403. { Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::take", "index out of range");
  404.  detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = n->t(); node_destruct(n);
  405.  p.remove(i); return t; }
  406. template <typename T>
  407. inline T QList<T>::takeFirst()
  408. { T t = first(); removeFirst(); return t; }
  409. template <typename T>
  410. inline T QList<T>::takeLast()
  411. { T t = last(); removeLast(); return t; }
  413. template <typename T>
  414. Q_OUTOFLINE_TEMPLATE void QList<T>::append(const T &t)
  415. {
  416.     detach();
  417.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
  418.         node_construct(reinterpret_cast<Node *>(p.append()), t);
  419.     } else {
  420.         const T cpy(t);
  421.         node_construct(reinterpret_cast<Node *>(p.append()), cpy);
  422.     }
  423. }
  425. template <typename T>
  426. inline void QList<T>::prepend(const T &t)
  427. {
  428.     detach();
  429.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
  430.         node_construct(reinterpret_cast<Node *>(p.prepend()), t);
  431.     } else {
  432.         const T cpy(t);
  433.         node_construct(reinterpret_cast<Node *>(p.prepend()), cpy);
  434.     }
  435. }
  437. template <typename T>
  438. inline void QList<T>::insert(int i, const T &t)
  439. {
  440.     detach();
  441.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
  442.         node_construct(reinterpret_cast<Node *>(p.insert(i)), t);
  443.     } else {
  444.         const T cpy(t);
  445.         node_construct(reinterpret_cast<Node *>(p.insert(i)), cpy);
  446.     }
  447. }
  449. template <typename T>
  450. inline void QList<T>::replace(int i, const T &t)
  451. {
  452.     Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::replace", "index out of range");
  453.     detach();
  454.     if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
  455.         reinterpret_cast<Node *>(p.at(i))->t() = t;
  456.     } else {
  457.         const T cpy(t);
  458.         reinterpret_cast<Node *>(p.at(i))->t() = cpy;
  459.     }
  460. }
  462. template <typename T>
  463. inline void QList<T>::swap(int i, int j)
  464. {
  465.     Q_ASSERT_X(i >= 0 && i < p.size() && j >= 0 && j < p.size(),
  466.                 "QList<T>::swap", "index out of range");
  467.     detach();
  468.     void *t = d->array[d->begin + i];
  469.     d->array[d->begin + i] = d->array[d->begin + j];
  470.     d->array[d->begin + j] = t;
  471. }
  473. template <typename T>
  474. inline void QList<T>::move(int from, int to)
  475. {
  476.     Q_ASSERT_X(from >= 0 && from < p.size() && to >= 0 && to < p.size(),
  477.                "QList<T>::move", "index out of range");
  478.     detach();
  479.     p.move(from, to);
  480. }
  482. template<typename T>
  483. Q_OUTOFLINE_TEMPLATE QList<T> QList<T>::mid(int pos, int length) const
  484. {
  485.     if (length < 0)
  486.         length = size() - pos;
  487.     if (pos == 0 && length == size())
  488.         return *this;
  489.     QList<T> cpy;
  490.     if (pos + length > size())
  491.         length = size() - pos;
  492.     for (int i = pos; i < pos + length; ++i)
  493.         cpy += at(i);
  494.     return cpy;
  495. }
  497. template<typename T>
  498. Q_OUTOFLINE_TEMPLATE T QList<T>::value(int i) const
  499. {
  500.     if (i < 0 || i >= p.size()) {
  501.         return T();
  502.     }
  503.     return reinterpret_cast<Node *>(p.at(i))->t();
  504. }
  506. template<typename T>
  507. Q_OUTOFLINE_TEMPLATE T QList<T>::value(int i, const T& defaultValue) const
  508. {
  509.     return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t());
  510. }
  512. template <typename T>
  513. Q_OUTOFLINE_TEMPLATE void QList<T>::detach_helper()
  514. {
  515.     Node *n = reinterpret_cast<Node *>(p.begin());
  516.     QListData::Data *x = p.detach2();
  517.     node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
  518.     if (!x->ref.deref())
  519.         free(x);
  520. }
  522. template <typename T>
  523. Q_OUTOFLINE_TEMPLATE QList<T>::~QList()
  524. {
  525.     if (d && !d->ref.deref())
  526.         free(d);
  527. }
  529. template <typename T>
  530. Q_OUTOFLINE_TEMPLATE bool QList<T>::operator==(const QList<T> &l) const
  531. {
  532.     if (p.size() != l.p.size())
  533.         return false;
  534.     if (d == l.d)
  535.         return true;
  536.     Node *i = reinterpret_cast<Node *>(p.end());
  537.     Node *b = reinterpret_cast<Node *>(p.begin());
  538.     Node *li = reinterpret_cast<Node *>(l.p.end());
  539.     while (i != b) {
  540.         --i; --li;
  541.         if (!(i->t() == li->t()))
  542.             return false;
  543.     }
  544.     return true;
  545. }
  547. // ### Qt 5: rename freeData() to avoid confusion with std::free()
  548. template <typename T>
  549. Q_OUTOFLINE_TEMPLATE void QList<T>::free(QListData::Data *data)
  550. {
  551.     node_destruct(reinterpret_cast<Node *>(data->array + data->begin),
  552.                   reinterpret_cast<Node *>(data->array + data->end));
  553.     if (data->ref == 0)
  554.         qFree(data);
  555. }
  558. template <typename T>
  559. Q_OUTOFLINE_TEMPLATE void QList<T>::clear()
  560. {
  561.     *this = QList<T>();
  562. }
  564. template <typename T>
  565. Q_OUTOFLINE_TEMPLATE int QList<T>::removeAll(const T &_t)
  566. {
  567.     detach();
  568.     const T t = _t;
  569.     int removedCount=0, i=0;
  570.     Node *n;
  571.     while (i < p.size())
  572.         if ((n = reinterpret_cast<Node *>(p.at(i)))->t() == t) {
  573.             node_destruct(n);
  574.             p.remove(i);
  575.             ++removedCount;
  576.         } else {
  577.             ++i;
  578.         }
  579.     return removedCount;
  580. }
  582. template <typename T>
  583. Q_OUTOFLINE_TEMPLATE bool QList<T>::removeOne(const T &_t)
  584. {
  585.     detach();
  586.     int index = indexOf(_t);
  587.     if (index != -1) {
  588.         removeAt(index);
  589.         return true;
  590.     }
  591.     return false;
  592. }
  594. template <typename T>
  595. Q_OUTOFLINE_TEMPLATE typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst,
  596.                                                                  typename QList<T>::iterator alast)
  597. {
  598.     for (Node *n = afirst.i; n < alast.i; ++n)
  599.         node_destruct(n);
  600.     int idx = afirst - begin();
  601.     p.remove(idx, alast - afirst);
  602.     return begin() + idx;
  603. }
  605. template <typename T>
  606. Q_OUTOFLINE_TEMPLATE QList<T> &QList<T>::operator+=(const QList<T> &l)
  607. {
  608.     detach();
  609.     Node *n = reinterpret_cast<Node *>(p.append(l.p));
  610.     node_copy(n, reinterpret_cast<Node *>(p.end()), reinterpret_cast<Node *>(l.p.begin()));
  611.     return *this;
  612. }
  614. template <typename T>
  615. Q_OUTOFLINE_TEMPLATE int QList<T>::indexOf(const T &t, int from) const
  616. {
  617.     if (from < 0)
  618.         from = qMax(from + p.size(), 0);
  619.     if (from < p.size()) {
  620.         Node *n = reinterpret_cast<Node *>(p.at(from -1));
  621.         Node *e = reinterpret_cast<Node *>(p.end());
  622.         while (++n != e)
  623.             if (n->t() == t)
  624.                 return n - reinterpret_cast<Node *>(p.begin());
  625.     }
  626.     return -1;
  627. }
  629. template <typename T>
  630. Q_OUTOFLINE_TEMPLATE int QList<T>::lastIndexOf(const T &t, int from) const
  631. {
  632.     if (from < 0)
  633.         from += p.size();
  634.     else if (from >= p.size())
  635.         from = p.size()-1;
  636.     if (from >= 0) {
  637.         Node *b = reinterpret_cast<Node *>(p.begin());
  638.         Node *n = reinterpret_cast<Node *>(p.at(from + 1));
  639.         while (n-- != b) {
  640.             if (n->t() == t)
  641.                 return n - b;
  642.         }
  643.     }
  644.     return -1;
  645. }
  647. template <typename T>
  648. Q_OUTOFLINE_TEMPLATE QBool QList<T>::contains(const T &t) const
  649. {
  650.     Node *b = reinterpret_cast<Node *>(p.begin());
  651.     Node *i = reinterpret_cast<Node *>(p.end());
  652.     while (i-- != b)
  653.         if (i->t() == t)
  654.             return QBool(true);
  655.     return QBool(false);
  656. }
  658. template <typename T>
  659. Q_OUTOFLINE_TEMPLATE int QList<T>::count(const T &t) const
  660. {
  661.     int c = 0;
  662.     Node *b = reinterpret_cast<Node *>(p.begin());
  663.     Node *i = reinterpret_cast<Node *>(p.end());
  664.     while (i-- != b)
  665.         if (i->t() == t)
  666.             ++c;
  667.     return c;
  668. }
  670. Q_DECLARE_SEQUENTIAL_ITERATOR(List)
  671. Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(List)
  673. QT_END_NAMESPACE
  675. QT_END_HEADER
  677. #endif // QLIST_H