TDE
/
tqt3
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tqt3
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f27c2533f7'
${ noResults }
tqt3/doc/html/qvaluelist-h.html

715 lines
22 KiB
Raw Normal View History Unescape

Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
Update to latest tqt3 automated conversion
13 years ago
<!-- /home/espenr/tmp/qt-3.3.8-espenr-2499/qt-x11-free-3.3.8/include/ntqvaluelist.h:1 -->
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
Update to latest tqt3 automated conversion
13 years ago
<title>ntqvaluelist.h Include File</title>
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
<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>
Update to latest tqt3 automated conversion
13 years ago
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><h1 align=center>ntqvaluelist.h</h1>
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
Update to latest tqt3 automated conversion
13 years ago
<p>This is the verbatim text of the ntqvaluelist.h include file. It is provided only for illustration; the copyright remains with Trolltech.
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
<hr>
<pre>
/****************************************************************************
Update to latest tqt3 automated conversion
13 years ago
** $Id: qt/ntqvaluelist.h 3.3.8 edited Jan 11 14:38 $
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
**
** 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
Sync with latest script
13 years ago
** Public Licensing requirements will be met:
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
** 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
Update to latest tqt3 automated conversion
13 years ago
#include "ntqtl.h"
#include "ntqshared.h"
#include "ntqdatastream.h"
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
#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 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 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
*/
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 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
*/
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;
Q_INLINE_TEMPLATES TQValueListPrivate&lt;T&gt;::TQValueListPrivate()
{
node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0;
}
template &lt;class T&gt;
Q_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;
Q_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;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::insert( Q_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;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::Iterator TQValueListPrivate&lt;T&gt;::remove( Q_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;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueListPrivate&lt;T&gt;::NodePtr TQValueListPrivate&lt;T&gt;::find( Q_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;
Q_INLINE_TEMPLATES int TQValueListPrivate&lt;T&gt;::findIndex( Q_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;
Q_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;
Q_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;
Q_INLINE_TEMPLATES Q_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;
Q_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( QT_NO_DEBUG ) &amp;&amp; defined( QT_CHECK_VALUELIST_RANGE )
Automated conversion from qt3
13 years ago
# define QT_CHECK_INVALID_LIST_ELEMENT if ( empty() ) tqWarning( "TQValueList: Warning invalid element" )
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
# 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 QT_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 QT_NO_STL
TQValueList( const std::list&lt;T&gt;&amp; l )
{
sh = new TQValueListPrivate&lt;T&gt;;
Automated update from Qt3
13 years ago
tqCopy( l.begin(), l.end(), std::back_inserter( *this ) );
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
}
#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 QT_NO_STL
TQValueList&lt;T&gt;&amp; operator= ( const std::list&lt;T&gt;&amp; l )
{
detach();
Automated update from Qt3
13 years ago
tqCopy( l.begin(), l.end(), std::back_inserter( *this ) );
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
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;
Q_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;
Q_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;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueList&lt;T&gt;::iterator TQValueList&lt;T&gt;::erase( Q_TYPENAME TQValueList&lt;T&gt;::iterator first, Q_TYPENAME TQValueList&lt;T&gt;::iterator last )
{
while ( first != last )
erase( first++ );
return last;
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueList&lt;T&gt;::insert( Q_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;
Q_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;
Q_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;
Q_INLINE_TEMPLATES void TQValueList&lt;T&gt;::detachInternal()
{
sh-&gt;deref(); sh = new TQValueListPrivate&lt;T&gt;( *sh );
}
#ifndef QT_NO_DATASTREAM
template &lt;class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueList&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 TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueList&lt;T&gt;&amp; l )
{
s &lt;&lt; (Q_UINT32)l.size();
TQValueListConstIterator&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
Update to latest tqt3 automated conversion
13 years ago
#include "ntqwinexport.h"
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
13 years ago
#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>