File: qvaluelist-h.html

package info (click to toggle)
qt-x11-free 3%3A3.3.7-4
links: PTS
area: main
in suites: etch-m68k
size: 81,780 kB
ctags: 71,547
sloc: cpp: 456,244; ansic: 127,131; sh: 31,095; yacc: 2,948; xml: 766; perl: 495; lex: 458; makefile: 455; sql: 29; lisp: 13
file content (711 lines) | stat: -rw-r--r-- 21,602 bytes
parent folder | download | duplicates (2)
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- /home/harald/tmp/qt-3.3.7-harald-4508/qt-x11-free-3.3.7/include/qvaluelist.h:1 -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>qvaluelist.h Include File</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
a:visited { color: #672967; text-decoration: none }
body { background: #ffffff; color: black; }
--></style>
</head>
<body>

<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr bgcolor="#E5E5E5">
<td valign=center>
 <a href="index.html">
<font color="#004faf">Home</font></a>
 | <a href="classes.html">
<font color="#004faf">All&nbsp;Classes</font></a>
 | <a href="mainclasses.html">
<font color="#004faf">Main&nbsp;Classes</font></a>
 | <a href="annotated.html">
<font color="#004faf">Annotated</font></a>
 | <a href="groups.html">
<font color="#004faf">Grouped&nbsp;Classes</font></a>
 | <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><h1 align=center>qvaluelist.h</h1>

<p>This is the verbatim text of the qvaluelist.h include file. It is provided only for illustration; the copyright remains with Trolltech.
<hr>
<pre>
/****************************************************************************
** $Id: qt/qvaluelist.h   3.3.7   edited Aug 31 2005 $
**
** Definition of QValueList class
**
** Created : 990406
**
** Copyright (C) 1992-2005 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#ifndef QVALUELIST_H
#define QVALUELIST_H

#ifndef QT_H
#include "qtl.h"
#include "qshared.h"
#include "qdatastream.h"
#endif // QT_H

#ifndef QT_NO_STL
#include &lt;iterator&gt;
#include &lt;list&gt;
#endif

//#define QT_CHECK_VALUELIST_RANGE

#if defined(Q_CC_MSVC)
#pragma warning(disable:4284) // "return type for operator -&gt; is not a UDT"
#endif

template &lt;class T&gt;
class QValueListNode
{
public:
    QValueListNode( const T&amp; t ) : data( t ) { }
    QValueListNode() { }
#if defined(Q_TEMPLATEDLL)
    // Workaround MS bug in memory de/allocation in DLL vs. EXE
    virtual ~QValueListNode() { }
#endif

    QValueListNode&lt;T&gt;* next;
    QValueListNode&lt;T&gt;* prev;
    T data;
};

template&lt;class T&gt;
class QValueListIterator
{
 public:
    /**
     * Typedefs
     */
    typedef QValueListNode&lt;T&gt;* NodePtr;
#ifndef QT_NO_STL
    typedef std::bidirectional_iterator_tag  iterator_category;
#endif
    typedef T        value_type;
    typedef size_t size_type;
#ifndef QT_NO_STL
    typedef ptrdiff_t  difference_type;
#else
    typedef int difference_type;
#endif
    typedef T*   pointer;
    typedef T&amp; reference;

    /**
     * Variables
     */
    NodePtr node;

    /**
     * Functions
     */
    QValueListIterator() : node( 0 ) {}
    QValueListIterator( NodePtr p ) : node( p ) {}
    QValueListIterator( const QValueListIterator&lt;T&gt;&amp; it ) : node( it.node ) {}

    bool operator==( const QValueListIterator&lt;T&gt;&amp; it ) const { return node == it.node; }
    bool operator!=( const QValueListIterator&lt;T&gt;&amp; it ) const { return node != it.node; }
    const T&amp; operator*() const { return node-&gt;data; }
    T&amp; operator*() { return node-&gt;data; }
    // UDT for T = x*
    // T* operator-&gt;() const { return &amp;node-&gt;data; }

    QValueListIterator&lt;T&gt;&amp; operator++() {
	node = node-&gt;next;
	return *this;
    }

    QValueListIterator&lt;T&gt; operator++(int) {
	QValueListIterator&lt;T&gt; tmp = *this;
	node = node-&gt;next;
	return tmp;
    }

    QValueListIterator&lt;T&gt;&amp; operator--() {
	node = node-&gt;prev;
	return *this;
    }

    QValueListIterator&lt;T&gt; operator--(int) {
	QValueListIterator&lt;T&gt; tmp = *this;
	node = node-&gt;prev;
	return tmp;
    }

    QValueListIterator&lt;T&gt;&amp; operator+=( int j ) {
	while ( j-- )
	    node = node-&gt;next;
	return *this;
    }

    QValueListIterator&lt;T&gt;&amp; operator-=( int j ) {
	while ( j-- )
	    node = node-&gt;prev;
	return *this;
    }

};

template&lt;class T&gt;
class QValueListConstIterator
{
 public:
    /**
     * Typedefs
     */
    typedef QValueListNode&lt;T&gt;* NodePtr;
#ifndef QT_NO_STL
    typedef std::bidirectional_iterator_tag  iterator_category;
#endif
    typedef T        value_type;
    typedef size_t size_type;
#ifndef QT_NO_STL
    typedef ptrdiff_t  difference_type;
#else
    typedef int difference_type;
#endif
    typedef const T*   pointer;
    typedef const T&amp; reference;

    /**
     * Variables
     */
    NodePtr node;

    /**
     * Functions
     */
    QValueListConstIterator() : node( 0 ) {}
    QValueListConstIterator( NodePtr p ) : node( p ) {}
    QValueListConstIterator( const QValueListConstIterator&lt;T&gt;&amp; it ) : node( it.node ) {}
    QValueListConstIterator( const QValueListIterator&lt;T&gt;&amp; it ) : node( it.node ) {}

    bool operator==( const QValueListConstIterator&lt;T&gt;&amp; it ) const { return node == it.node; }
    bool operator!=( const QValueListConstIterator&lt;T&gt;&amp; it ) const { return node != it.node; }
    const T&amp; operator*() const { return node-&gt;data; }
    // UDT for T = x*
    // const T* operator-&gt;() const { return &amp;node-&gt;data; }

    QValueListConstIterator&lt;T&gt;&amp; operator++() {
	node = node-&gt;next;
	return *this;
    }

    QValueListConstIterator&lt;T&gt; operator++(int) {
	QValueListConstIterator&lt;T&gt; tmp = *this;
	node = node-&gt;next;
	return tmp;
    }

    QValueListConstIterator&lt;T&gt;&amp; operator--() {
	node = node-&gt;prev;
	return *this;
    }

    QValueListConstIterator&lt;T&gt; operator--(int) {
	QValueListConstIterator&lt;T&gt; tmp = *this;
	node = node-&gt;prev;
	return tmp;
    }
};

template &lt;class T&gt;
class QValueListPrivate : public QShared
{
public:
    /**
     * Typedefs
     */
    typedef QValueListIterator&lt;T&gt; Iterator;
    typedef QValueListConstIterator&lt;T&gt; ConstIterator;
    typedef QValueListNode&lt;T&gt; Node;
    typedef QValueListNode&lt;T&gt;* NodePtr;
    typedef size_t size_type;

    /**
     * Functions
     */
    QValueListPrivate();
    QValueListPrivate( const QValueListPrivate&lt;T&gt;&amp; _p );

    void derefAndDelete() // ### hack to get around hp-cc brain damage
    {
	if ( deref() )
	    delete this;
    }

#if defined(Q_TEMPLATEDLL)
    // Workaround MS bug in memory de/allocation in DLL vs. EXE
    virtual
#endif
    ~QValueListPrivate();

    Iterator insert( Iterator it, const T&amp; x );
    Iterator remove( Iterator it );
    NodePtr find( NodePtr start, const T&amp; x ) const;
    int findIndex( NodePtr start, const T&amp; x ) const;
    uint contains( const T&amp; x ) const;
    uint remove( const T&amp; x );
    NodePtr at( size_type i ) const;
    void clear();

    NodePtr node;
    size_type nodes;
};

template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueListPrivate&lt;T&gt;::QValueListPrivate()
{
    node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueListPrivate&lt;T&gt;::QValueListPrivate( const QValueListPrivate&lt;T&gt;&amp; _p )
    : QShared()
{
    node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0;
    Iterator b( _p.node-&gt;next );
    Iterator e( _p.node );
    Iterator i( node );
    while( b != e )
	insert( i, *b++ );
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueListPrivate&lt;T&gt;::~QValueListPrivate() {
    NodePtr p = node-&gt;next;
    while( p != node ) {
	NodePtr x = p-&gt;next;
	delete p;
	p = x;
    }
    delete node;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate&lt;T&gt;::Iterator QValueListPrivate&lt;T&gt;::insert( Q_TYPENAME QValueListPrivate&lt;T&gt;::Iterator it, const T&amp; x )
{
    NodePtr p = new Node( x );
    p-&gt;next = it.node;
    p-&gt;prev = it.node-&gt;prev;
    it.node-&gt;prev-&gt;next = p;
    it.node-&gt;prev = p;
    nodes++;
    return p;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate&lt;T&gt;::Iterator QValueListPrivate&lt;T&gt;::remove( Q_TYPENAME QValueListPrivate&lt;T&gt;::Iterator it )
{
    Q_ASSERT ( it.node != node );
    NodePtr next = it.node-&gt;next;
    NodePtr prev = it.node-&gt;prev;
    prev-&gt;next = next;
    next-&gt;prev = prev;
    delete it.node;
    nodes--;
    return Iterator( next );
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate&lt;T&gt;::NodePtr QValueListPrivate&lt;T&gt;::find( Q_TYPENAME QValueListPrivate&lt;T&gt;::NodePtr start, const T&amp; x ) const
{
    ConstIterator first( start );
    ConstIterator last( node );
    while( first != last) {
	if ( *first == x )
	    return first.node;
	++first;
    }
    return last.node;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES int QValueListPrivate&lt;T&gt;::findIndex( Q_TYPENAME QValueListPrivate&lt;T&gt;::NodePtr start, const T&amp; x ) const
{
    ConstIterator first( start );
    ConstIterator last( node );
    int pos = 0;
    while( first != last) {
	if ( *first == x )
	    return pos;
	++first;
	++pos;
    }
    return -1;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES uint QValueListPrivate&lt;T&gt;::contains( const T&amp; x ) const
{
    uint result = 0;
    Iterator first = Iterator( node-&gt;next );
    Iterator last = Iterator( node );
    while( first != last) {
	if ( *first == x )
	    ++result;
	++first;
    }
    return result;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES uint QValueListPrivate&lt;T&gt;::remove( const T&amp; _x )
{
    const T x = _x;
    uint result = 0;
    Iterator first = Iterator( node-&gt;next );
    Iterator last = Iterator( node );
    while( first != last) {
	if ( *first == x ) {
	    first = remove( first );
	    ++result;
	} else
	    ++first;
    }
    return result;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME QValueListPrivate&lt;T&gt;::NodePtr QValueListPrivate&lt;T&gt;::at( size_type i ) const
{
    Q_ASSERT( i &lt;= nodes );
    NodePtr p = node-&gt;next;
    for( size_type x = 0; x &lt; i; ++x )
	p = p-&gt;next;
    return p;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES void QValueListPrivate&lt;T&gt;::clear()
{
    nodes = 0;
    NodePtr p = node-&gt;next;
    while( p != node ) {
	NodePtr next = p-&gt;next;
	delete p;
	p = next;
    }
    node-&gt;next = node-&gt;prev = node;
}

#ifdef QT_CHECK_RANGE
# if !defined( QT_NO_DEBUG ) &amp;&amp; defined( QT_CHECK_VALUELIST_RANGE )
#  define QT_CHECK_INVALID_LIST_ELEMENT if ( empty() ) qWarning( "QValueList: Warning invalid element" )
#  define QT_CHECK_INVALID_LIST_ELEMENT_FATAL Q_ASSERT( !empty() );
# else
#  define QT_CHECK_INVALID_LIST_ELEMENT
#  define QT_CHECK_INVALID_LIST_ELEMENT_FATAL
# endif
#else
# define QT_CHECK_INVALID_LIST_ELEMENT
# define QT_CHECK_INVALID_LIST_ELEMENT_FATAL
#endif

template &lt;class T&gt; class QDeepCopy;

template &lt;class T&gt;
class QValueList
{
public:
    /**
     * Typedefs
     */
    typedef QValueListIterator&lt;T&gt; iterator;
    typedef QValueListConstIterator&lt;T&gt; const_iterator;
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type&amp; reference;
    typedef const value_type&amp; const_reference;
    typedef size_t size_type;
#ifndef QT_NO_STL
    typedef ptrdiff_t  difference_type;
#else
    typedef int difference_type;
#endif

    /**
     * API
     */
    QValueList() { sh = new QValueListPrivate&lt;T&gt;; }
    QValueList( const QValueList&lt;T&gt;&amp; l ) { sh = l.sh; sh-&gt;ref(); }
#ifndef QT_NO_STL
    QValueList( const std::list&lt;T&gt;&amp; l )
    {
	sh = new QValueListPrivate&lt;T&gt;;
	qCopy( l.begin(), l.end(), std::back_inserter( *this ) );
    }
#endif
    ~QValueList() { sh-&gt;derefAndDelete(); }

    QValueList&lt;T&gt;&amp; operator= ( const QValueList&lt;T&gt;&amp; l )
    {
	l.sh-&gt;ref();
	sh-&gt;derefAndDelete();
	sh = l.sh;
	return *this;
    }
#ifndef QT_NO_STL
    QValueList&lt;T&gt;&amp; operator= ( const std::list&lt;T&gt;&amp; l )
    {
	detach();
	qCopy( l.begin(), l.end(), std::back_inserter( *this ) );
	return *this;
    }
    bool operator== ( const std::list&lt;T&gt;&amp; l ) const
    {
	if ( size() != l.size() )
	    return FALSE;
	const_iterator it2 = begin();
#if !defined(Q_CC_MIPS)
	typename
#endif
	std::list&lt;T&gt;::const_iterator it = l.begin();
	for ( ; it2 != end(); ++it2, ++it )
	if ( !((*it2) == (*it)) )
	    return FALSE;
	return TRUE;
    }
#endif
    bool operator== ( const QValueList&lt;T&gt;&amp; l ) const;
    bool operator!= ( const QValueList&lt;T&gt;&amp; l ) const { return !( *this == l ); }
    iterator begin() { detach(); return iterator( sh-&gt;node-&gt;next ); }
    const_iterator begin() const { return const_iterator( sh-&gt;node-&gt;next ); }
    const_iterator constBegin() const { return const_iterator( sh-&gt;node-&gt;next ); }
    iterator end() { detach(); return iterator( sh-&gt;node ); }
    const_iterator end() const { return const_iterator( sh-&gt;node ); }
    const_iterator constEnd() const { return const_iterator( sh-&gt;node ); }
    iterator insert( iterator it, const T&amp; x ) { detach(); return sh-&gt;insert( it, x ); }
    uint remove( const T&amp; x ) { detach(); return sh-&gt;remove( x ); }
    void clear();

    // ### 4.0: move out of class
    QValueList&lt;T&gt;&amp; operator&lt;&lt; ( const T&amp; x )
    {
	append( x );
	return *this;
    }

    size_type size() const { return sh-&gt;nodes; }
    bool empty() const { return sh-&gt;nodes == 0; }
    void push_front( const T&amp; x ) { detach(); sh-&gt;insert( begin(), x ); }
    void push_back( const T&amp; x ) { detach(); sh-&gt;insert( end(), x ); }
    iterator erase( iterator pos ) { detach(); return sh-&gt;remove( pos ); }
    iterator erase( iterator first, iterator last );
    reference front() { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *begin(); }
    const_reference front() const { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *begin(); }
    reference back() { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *(--end()); }
    const_reference back() const { QT_CHECK_INVALID_LIST_ELEMENT_FATAL; return *(--end()); }
    void pop_front() { QT_CHECK_INVALID_LIST_ELEMENT; erase( begin() ); }
    void pop_back() {
	QT_CHECK_INVALID_LIST_ELEMENT;
	iterator tmp = end();
	erase( --tmp );
    }
    void insert( iterator pos, size_type n, const T&amp; x );
    // Some compilers (incl. vc++) would instantiate this function even if
    // it is not used; this would constrain QValueList to classes that provide
    // an operator&lt;
    /*
    void sort()
    {
	qHeapSort( *this );
    }
    */

    QValueList&lt;T&gt; operator+ ( const QValueList&lt;T&gt;&amp; l ) const;
    QValueList&lt;T&gt;&amp; operator+= ( const QValueList&lt;T&gt;&amp; l );

    iterator fromLast() { detach(); return iterator( sh-&gt;node-&gt;prev ); }
    const_iterator fromLast() const { return const_iterator( sh-&gt;node-&gt;prev ); }

    bool isEmpty() const { return ( sh-&gt;nodes == 0 ); }

    iterator append( const T&amp; x ) { detach(); return sh-&gt;insert( end(), x ); }
    iterator prepend( const T&amp; x ) { detach(); return sh-&gt;insert( begin(), x ); }

    iterator remove( iterator it ) { detach(); return sh-&gt;remove( it ); }

    T&amp; first() { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh-&gt;node-&gt;next-&gt;data; }
    const T&amp; first() const { QT_CHECK_INVALID_LIST_ELEMENT; return sh-&gt;node-&gt;next-&gt;data; }
    T&amp; last() { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh-&gt;node-&gt;prev-&gt;data; }
    const T&amp; last() const { QT_CHECK_INVALID_LIST_ELEMENT; return sh-&gt;node-&gt;prev-&gt;data; }

    T&amp; operator[] ( size_type i ) { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return sh-&gt;at(i)-&gt;data; }
    const T&amp; operator[] ( size_type i ) const { QT_CHECK_INVALID_LIST_ELEMENT; return sh-&gt;at(i)-&gt;data; }
    iterator at( size_type i ) { QT_CHECK_INVALID_LIST_ELEMENT; detach(); return iterator( sh-&gt;at(i) ); }
    const_iterator at( size_type i ) const { QT_CHECK_INVALID_LIST_ELEMENT; return const_iterator( sh-&gt;at(i) ); }
    iterator find ( const T&amp; x ) { detach(); return iterator( sh-&gt;find( sh-&gt;node-&gt;next, x) ); }
    const_iterator find ( const T&amp; x ) const { return const_iterator( sh-&gt;find( sh-&gt;node-&gt;next, x) ); }
    iterator find ( iterator it, const T&amp; x ) { detach(); return iterator( sh-&gt;find( it.node, x ) ); }
    const_iterator find ( const_iterator it, const T&amp; x ) const { return const_iterator( sh-&gt;find( it.node, x ) ); }
    int findIndex( const T&amp; x ) const { return sh-&gt;findIndex( sh-&gt;node-&gt;next, x) ; }
    size_type contains( const T&amp; x ) const { return sh-&gt;contains( x ); }

    size_type count() const { return sh-&gt;nodes; }

    QValueList&lt;T&gt;&amp; operator+= ( const T&amp; x )
    {
	append( x );
	return *this;
    }
    typedef QValueListIterator&lt;T&gt; Iterator;
    typedef QValueListConstIterator&lt;T&gt; ConstIterator;
    typedef T ValueType;

protected:
    /**
     * Helpers
     */
    void detach() { if ( sh-&gt;count &gt; 1 ) detachInternal(); }

    /**
     * Variables
     */
    QValueListPrivate&lt;T&gt;* sh;

private:
    void detachInternal();

    friend class QDeepCopy&lt; QValueList&lt;T&gt; &gt;;
};

template &lt;class T&gt;
Q_INLINE_TEMPLATES bool QValueList&lt;T&gt;::operator== ( const QValueList&lt;T&gt;&amp; l ) const
{
    if ( size() != l.size() )
	return FALSE;
    const_iterator it2 = begin();
    const_iterator it = l.begin();
    for( ; it != l.end(); ++it, ++it2 )
	if ( !( *it == *it2 ) )
	    return FALSE;
    return TRUE;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES void QValueList&lt;T&gt;::clear()
{
    if ( sh-&gt;count == 1 ) sh-&gt;clear(); else { sh-&gt;deref(); sh = new QValueListPrivate&lt;T&gt;; }
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME QValueList&lt;T&gt;::iterator QValueList&lt;T&gt;::erase( Q_TYPENAME QValueList&lt;T&gt;::iterator first, Q_TYPENAME QValueList&lt;T&gt;::iterator last )
{
    while ( first != last )
	erase( first++ );
    return last;
}


template &lt;class T&gt;
Q_INLINE_TEMPLATES void QValueList&lt;T&gt;::insert( Q_TYPENAME QValueList&lt;T&gt;::iterator pos, size_type n, const T&amp; x )
{
    for ( ; n &gt; 0; --n )
	insert( pos, x );
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueList&lt;T&gt; QValueList&lt;T&gt;::operator+ ( const QValueList&lt;T&gt;&amp; l ) const
{
    QValueList&lt;T&gt; l2( *this );
    for( const_iterator it = l.begin(); it != l.end(); ++it )
	l2.append( *it );
    return l2;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueList&lt;T&gt;&amp; QValueList&lt;T&gt;::operator+= ( const QValueList&lt;T&gt;&amp; l )
{
    QValueList&lt;T&gt; copy = l;
    for( const_iterator it = copy.begin(); it != copy.end(); ++it )
	append( *it );
    return *this;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES void QValueList&lt;T&gt;::detachInternal()
{
    sh-&gt;deref(); sh = new QValueListPrivate&lt;T&gt;( *sh );
}

#ifndef QT_NO_DATASTREAM
template &lt;class T&gt;
Q_INLINE_TEMPLATES QDataStream&amp; operator&gt;&gt;( QDataStream&amp; s, QValueList&lt;T&gt;&amp; l )
{
    l.clear();
    Q_UINT32 c;
    s &gt;&gt; c;
    for( Q_UINT32 i = 0; i &lt; c; ++i )
    {
	T t;
	s &gt;&gt; t;
	l.append( t );
	if ( s.atEnd() )
	    break;
    }
    return s;
}

template &lt;class T&gt;
Q_INLINE_TEMPLATES QDataStream&amp; operator&lt;&lt;( QDataStream&amp; s, const QValueList&lt;T&gt;&amp; l )
{
    s &lt;&lt; (Q_UINT32)l.size();
    QValueListConstIterator&lt;T&gt; it = l.begin();
    for( ; it != l.end(); ++it )
	s &lt;&lt; *it;
    return s;
}
#endif // QT_NO_DATASTREAM

#define Q_DEFINED_QVALUELIST
#define Q_DEFINED_QVALUELIST
#include "qwinexport.h"
#endif // QVALUELIST_H
</pre>
<!-- eof -->
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2005
<a href="troll.html">Trolltech</a><td align=center><a href="trademarks.html">Trademarks</a>
<td align=right><div align=right>Qt 3.3.7</div>
</table></div></address></body>
</html>