tqt3/doc/html/tqvaluelist-h.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- /home/espenr/tmp/qt-3.3.8-espenr-2499/qt-x11-free-3.3.8/include/tqvaluelist.h:1 -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>tqvaluelist.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>tqvaluelist.h</h1>

<p>This is the verbatim text of the tqvaluelist.h include file. It is provided only for illustration; the copyright remains with Trolltech.
<hr>
<pre>
/****************************************************************************
** $Id: qt/tqvaluelist.h   3.3.8   edited Jan 11 14:38 $
**
** Definition of TQValueList class
**
** Created : 990406
**
** Copyright (C) 1992-2007 Trolltech ASA.  All rights reserved.
**
** This file is part of the tools module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Alternatively you may (at your option) use any
** later version of the GNU General Public License if such license has
** been publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file.  Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/

#ifndef TQVALUELIST_H
#define TQVALUELIST_H

#ifndef QT_H
#include "ntqtl.h"
#include "ntqshared.h"
#include "ntqdatastream.h"
#endif // QT_H

#ifndef TQT_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 TQValueListNode
{
public:
    TQValueListNode( const T&amp; t ) : data( t ) { }
    TQValueListNode() { }
#if defined(Q_TEMPLATEDLL)
    // Workaround MS bug in memory de/allocation in DLL vs. EXE
    virtual ~TQValueListNode() { }
#endif

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

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

    /**
     * Variables
     */
    NodePtr node;

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

    bool operator==( const TQValueListIterator&lt;T&gt;&amp; it ) const { return node == it.node; }
    bool operator!=( const TQValueListIterator&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; }

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

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

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

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

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

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

};

template&lt;class T&gt;
class TQValueListConstIterator
{
 public:
    /**
     * Typedefs
     */
    typedef TQValueListNode&lt;T&gt;* NodePtr;
#ifndef TQT_NO_STL
    typedef std::bidirectional_iterator_tag  iterator_category;
#endif
    typedef T        value_type;
    typedef size_t size_type;
#ifndef TQT_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
     */
    TQValueListConstIterator() : node( 0 ) {}
    TQValueListConstIterator( NodePtr p ) : node( p ) {}
    TQValueListConstIterator( const TQValueListConstIterator&lt;T&gt;&amp; it ) : node( it.node ) {}
    TQValueListConstIterator( const TQValueListIterator&lt;T&gt;&amp; it ) : node( it.node ) {}

    bool operator==( const TQValueListConstIterator&lt;T&gt;&amp; it ) const { return node == it.node; }
    bool operator!=( const TQValueListConstIterator&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; }

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

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

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

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

template &lt;class T&gt;
class TQValueListPrivate : public TQShared
{
public:
    /**
     * Typedefs
     */
    typedef TQValueListIterator&lt;T&gt; Iterator;
    typedef TQValueListConstIterator&lt;T&gt; ConstIterator;
    typedef TQValueListNode&lt;T&gt; Node;
    typedef TQValueListNode&lt;T&gt;* NodePtr;
    typedef size_t size_type;

    /**
     * Functions
     */
    TQValueListPrivate();
    TQValueListPrivate( const TQValueListPrivate&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
    ~TQValueListPrivate();

    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;
TQ_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate()
{
    node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0;
}

template &lt;class T&gt;
TQ_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate( const TQValueListPrivate&lt;T&gt;&amp; _p )
    : TQShared()
{
    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;
TQ_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::~TQValueListPrivate() {
    NodePtr p = node-&gt;next;
    while( p != node ) {
	NodePtr x = p-&gt;next;
	delete p;
	p = x;
    }
    delete node;
}

template &lt;class T&gt;
TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::insert( TQ_TYPENAME TQValueListPrivate&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;
TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::remove( TQ_TYPENAME TQValueListPrivate&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;
TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPrivate&lt;T&gt;::find( TQ_TYPENAME TQValueListPrivate&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;
TQ_INLINE_TEMPLATES int TQValueListPrivate&lt;T&gt;::findIndex( TQ_TYPENAME TQValueListPrivate&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;
TQ_INLINE_TEMPLATES uint TQValueListPrivate&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;
TQ_INLINE_TEMPLATES uint TQValueListPrivate&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;
TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPrivate&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;
TQ_INLINE_TEMPLATES void TQValueListPrivate&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( TQT_NO_DEBUG ) &amp;&amp; defined( QT_CHECK_VALUELIST_RANGE )
#  define QT_CHECK_INVALID_LIST_ELEMENT if ( empty() ) tqWarning( "TQValueList: 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 TQDeepCopy;

template &lt;class T&gt;
class TQValueList
{
public:
    /**
     * Typedefs
     */
    typedef TQValueListIterator&lt;T&gt; iterator;
    typedef TQValueListConstIterator&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 TQT_NO_STL
    typedef ptrdiff_t  difference_type;
#else
    typedef int difference_type;
#endif

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

    TQValueList&lt;T&gt;&amp; operator= ( const TQValueList&lt;T&gt;&amp; l )
    {
	l.sh-&gt;ref();
	sh-&gt;derefAndDelete();
	sh = l.sh;
	return *this;
    }
#ifndef TQT_NO_STL
    TQValueList&lt;T&gt;&amp; operator= ( const std::list&lt;T&gt;&amp; l )
    {
	detach();
	tqCopy( 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 TQValueList&lt;T&gt;&amp; l ) const;
    bool operator!= ( const TQValueList&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
    TQValueList&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 TQValueList to classes that provide
    // an operator&lt;
    /*
    void sort()
    {
	qHeapSort( *this );
    }
    */

    TQValueList&lt;T&gt; operator+ ( const TQValueList&lt;T&gt;&amp; l ) const;
    TQValueList&lt;T&gt;&amp; operator+= ( const TQValueList&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; }

    TQValueList&lt;T&gt;&amp; operator+= ( const T&amp; x )
    {
	append( x );
	return *this;
    }
    typedef TQValueListIterator&lt;T&gt; Iterator;
    typedef TQValueListConstIterator&lt;T&gt; ConstIterator;
    typedef T ValueType;

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

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

private:
    void detachInternal();

    friend class TQDeepCopy&lt; TQValueList&lt;T&gt; &gt;;
};

template &lt;class T&gt;
TQ_INLINE_TEMPLATES bool TQValueList&lt;T&gt;::operator== ( const TQValueList&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;
TQ_INLINE_TEMPLATES void TQValueList&lt;T&gt;::clear()
{
    if ( sh-&gt;count == 1 ) sh-&gt;clear(); else { sh-&gt;deref(); sh = new TQValueListPrivate&lt;T&gt;; }
}

template &lt;class T&gt;
TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueList&lt;T&gt;::iterator TQValueList&lt;T&gt;::erase( TQ_TYPENAME TQValueList&lt;T&gt;::iterator first, TQ_TYPENAME TQValueList&lt;T&gt;::iterator last )
{
    while ( first != last )
	erase( first++ );
    return last;
}


template &lt;class T&gt;
TQ_INLINE_TEMPLATES void TQValueList&lt;T&gt;::insert( TQ_TYPENAME TQValueList&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;
TQ_INLINE_TEMPLATES TQValueList&lt;T&gt; TQValueList&lt;T&gt;::operator+ ( const TQValueList&lt;T&gt;&amp; l ) const
{
    TQValueList&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;
TQ_INLINE_TEMPLATES TQValueList&lt;T&gt;&amp; TQValueList&lt;T&gt;::operator+= ( const TQValueList&lt;T&gt;&amp; l )
{
    TQValueList&lt;T&gt; copy = l;
    for( const_iterator it = copy.begin(); it != copy.end(); ++it )
	append( *it );
    return *this;
}

template &lt;class T&gt;
TQ_INLINE_TEMPLATES void TQValueList&lt;T&gt;::detachInternal()
{
    sh-&gt;deref(); sh = new TQValueListPrivate&lt;T&gt;( *sh );
}

#ifndef TQT_NO_DATASTREAM
template &lt;class T&gt;
TQ_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueList&lt;T&gt;&amp; l )
{
    l.clear();
    TQ_UINT32 c;
    s &gt;&gt; c;
    for( TQ_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;
TQ_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueList&lt;T&gt;&amp; l )
{
    s &lt;&lt; (TQ_UINT32)l.size();
    TQValueListConstIterator&lt;T&gt; it = l.begin();
    for( ; it != l.end(); ++it )
	s &lt;&lt; *it;
    return s;
}
#endif // TQT_NO_DATASTREAM

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