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.
tqt3/doc/html/qvaluevector-h.html

621 lines
15 KiB

<!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/ntqvaluevector.h:1 -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>ntqvaluevector.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>ntqvaluevector.h</h1>
<p>This is the verbatim text of the ntqvaluevector.h include file. It is provided only for illustration; the copyright remains with Trolltech.
<hr>
<pre>
/****************************************************************************
** $Id: qt/ntqvaluevector.h 3.3.8 edited Jan 11 14:38 $
**
** Definition of TQValueVector class
**
** 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 TQVALUEVECTOR_H
#define TQVALUEVECTOR_H
#ifndef QT_H
#include "ntqtl.h"
#include "ntqshared.h"
#include "ntqdatastream.h"
#endif // QT_H
#ifndef QT_NO_STL
#include &lt;vector&gt;
#endif
template &lt;class T&gt;
class TQValueVectorPrivate : public TQShared
{
public:
typedef T value_type;
typedef T* pointer;
TQValueVectorPrivate()
: start( 0 ), finish( 0 ), end( 0 )
{
}
TQValueVectorPrivate( const TQValueVectorPrivate&lt;T&gt;&amp; x );
TQValueVectorPrivate( size_t size );
void derefAndDelete() // work-around for hp-cc
{
if ( deref() )
delete this;
}
#if defined(Q_TEMPLATEDLL)
// Workaround MS bug in memory de/allocation in DLL vs. EXE
virtual
#endif
~TQValueVectorPrivate()
{
delete[] start;
}
size_t size() const
{
return finish - start;
}
bool empty() const
{
return start == finish;
}
size_t capacity() const
{
return end - start;
}
void insert( pointer pos, const T&amp; x );
void insert( pointer pos, size_t n, const T&amp; x );
void reserve( size_t n );
void clear()
{
delete[] start;
start = 0;
finish = 0;
end = 0;
}
pointer start;
pointer finish;
pointer end;
private:
pointer growAndCopy( size_t n, pointer s, pointer f );
TQValueVectorPrivate&lt;T&gt;&amp; operator=( const TQValueVectorPrivate&lt;T&gt;&amp; x );
};
template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( const TQValueVectorPrivate&lt;T&gt;&amp; x )
: TQShared()
{
size_t i = x.size();
if ( i &gt; 0 ) {
start = new T[ i ];
finish = start + i;
end = start + i;
#if defined(__xlC__) &amp;&amp; __xlC__ &lt; 0x400 // xlC 3.6 confused by const
tqCopy( (pointer)x.start, (pointer)x.finish, start );
#else
tqCopy( x.start, x.finish, start );
#endif
} else {
start = 0;
finish = 0;
end = 0;
}
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueVectorPrivate&lt;T&gt;::TQValueVectorPrivate( size_t size )
{
if ( size &gt; 0 ) {
start = new T[size];
finish = start + size;
end = start + size;
} else {
start = 0;
finish = 0;
end = 0;
}
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, const T&amp; x )
{
const size_t lastSize = size();
const size_t n = lastSize !=0 ? 2*lastSize : 1;
const size_t offset = pos - start;
pointer newStart = new T[n];
pointer newFinish = newStart + offset;
tqCopy( start, pos, newStart );
*newFinish = x;
tqCopy( pos, finish, ++newFinish );
delete[] start;
start = newStart;
finish = newStart + lastSize + 1;
end = newStart + n;
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::insert( pointer pos, size_t n, const T&amp; x )
{
if ( size_t( end - finish ) &gt;= n ) {
// enough room
const size_t elems_after = finish - pos;
pointer old_finish = finish;
if ( elems_after &gt; n ) {
tqCopy( finish - n, finish, finish );
finish += n;
tqCopyBackward( pos, old_finish - n, old_finish );
tqFill( pos, pos + n, x );
} else {
pointer filler = finish;
size_t i = n - elems_after;
for ( ; i &gt; 0; --i, ++filler )
*filler = x;
finish += n - elems_after;
tqCopy( pos, old_finish, finish );
finish += elems_after;
tqFill( pos, old_finish, x );
}
} else {
// not enough room
const size_t lastSize = size();
const size_t len = lastSize + TQMAX( lastSize, n );
pointer newStart = new T[len];
pointer newFinish = tqCopy( start, pos, newStart );
// fill up inserted space
size_t i = n;
for ( ; i &gt; 0; --i, ++newFinish )
*newFinish = x;
newFinish = tqCopy( pos, finish, newFinish );
delete[] start;
start = newStart;
finish = newFinish;
end = newStart + len;
}
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVectorPrivate&lt;T&gt;::reserve( size_t n )
{
const size_t lastSize = size();
pointer tmp = growAndCopy( n, start, finish );
start = tmp;
finish = tmp + lastSize;
end = start + n;
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVectorPrivate&lt;T&gt;::pointer TQValueVectorPrivate&lt;T&gt;::growAndCopy( size_t n, pointer s, pointer f )
{
pointer newStart = new T[n];
tqCopy( s, f, newStart );
delete[] start;
return newStart;
}
template &lt;class T&gt; class TQDeepCopy;
template &lt;class T&gt;
class TQValueVector
{
public:
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type* iterator;
typedef const value_type* const_iterator;
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
TQValueVector()
{
sh = new TQValueVectorPrivate&lt;T&gt;;
}
TQValueVector( const TQValueVector&lt;T&gt;&amp; v )
{
sh = v.sh;
sh-&gt;ref();
}
TQValueVector( size_type n, const T&amp; val = T() );
#ifndef QT_NO_STL
TQValueVector( std::vector&lt;T&gt;&amp; v ) // ### remove in 4.0
{
sh = new TQValueVectorPrivate&lt;T&gt;( v.size() );
tqCopy( v.begin(), v.end(), begin() );
}
TQValueVector( const std::vector&lt;T&gt;&amp; v )
{
sh = new TQValueVectorPrivate&lt;T&gt;( v.size() );
tqCopy( v.begin(), v.end(), begin() );
}
#endif
~TQValueVector()
{
sh-&gt;derefAndDelete();
}
TQValueVector&lt;T&gt;&amp; operator= ( const TQValueVector&lt;T&gt;&amp; v )
{
v.sh-&gt;ref();
sh-&gt;derefAndDelete();
sh = v.sh;
return *this;
}
#ifndef QT_NO_STL
TQValueVector&lt;T&gt;&amp; operator= ( const std::vector&lt;T&gt;&amp; v )
{
clear();
resize( v.size() );
tqCopy( v.begin(), v.end(), begin() );
return *this;
}
#endif
size_type size() const { return sh-&gt;size(); }
bool empty() const { return sh-&gt;empty(); }
size_type capacity() const
{
return size_type( sh-&gt;capacity() );
}
iterator begin()
{
detach();
return sh-&gt;start;
}
const_iterator begin() const
{
return sh-&gt;start;
}
const_iterator constBegin() const
{
return sh-&gt;start;
}
iterator end()
{
detach();
return sh-&gt;finish;
}
const_iterator end() const
{
return sh-&gt;finish;
}
const_iterator constEnd() const
{
return sh-&gt;finish;
}
reference at( size_type i, bool* ok = 0 )
{
detach();
if ( ok )
*ok = ( i &lt; size() );
return *( begin() + i );
}
const_reference at( size_type i, bool* ok = 0 ) const
{
if ( ok )
*ok = ( i &lt; size() );
return *( begin() + i );
}
reference operator[]( size_type i )
{
detach();
return *( begin() + i );
}
const_reference operator[]( size_type i ) const
{
return *( begin() + i );
}
reference front()
{
Q_ASSERT( !empty() );
detach();
return *begin();
}
const_reference front() const
{
Q_ASSERT( !empty() );
return *begin();
}
reference back()
{
Q_ASSERT( !empty() );
detach();
return *( end() - 1 );
}
const_reference back() const
{
Q_ASSERT( !empty() );
return *( end() - 1 );
}
void push_back( const T&amp; x )
{
detach();
if ( sh-&gt;finish == sh-&gt;end ) {
sh-&gt;reserve( size()+size()/2+1 );
}
*sh-&gt;finish = x;
++sh-&gt;finish;
}
void pop_back()
{
detach();
if ( empty() )
return;
--sh-&gt;finish;
}
iterator insert( iterator pos, const T&amp; x );
iterator insert( iterator pos, size_type n, const T&amp; x );
void reserve( size_type n )
{
if ( capacity() &lt; n ) {
detach();
sh-&gt;reserve( n );
}
}
void resize( size_type n, const T&amp; val = T() )
{
if ( n &lt; size() )
erase( begin() + n, end() );
else
insert( end(), n - size(), val );
}
void clear()
{
detach();
sh-&gt;clear();
}
iterator erase( iterator pos )
{
detach();
if ( pos + 1 != end() )
tqCopy( pos + 1, sh-&gt;finish, pos );
--sh-&gt;finish;
return pos;
}
iterator erase( iterator first, iterator last )
{
detach();
tqCopy( last, sh-&gt;finish, first );
sh-&gt;finish = sh-&gt;finish - ( last - first );
return first;
}
// ### remove in TQt 4.0
bool operator==( const TQValueVector&lt;T&gt;&amp; x )
{
return size()==x.size() ? tqEqual( constBegin(), constEnd(), x.begin()) : FALSE;
}
bool operator==( const TQValueVector&lt;T&gt;&amp; x ) const
{
return size()==x.size() ? tqEqual( begin(), end(), x.begin() ) : FALSE;
}
typedef T ValueType;
typedef ValueType *Iterator;
typedef const ValueType *ConstIterator;
size_type count() const { return size(); }
bool isEmpty() const { return empty(); }
reference first() { return front(); }
const_reference first() const { return front(); }
reference last() { return back(); }
const_reference last() const { return back(); }
void append( const T&amp; x ) { push_back( x ); }
protected:
void detach()
{
if ( sh-&gt;count &gt; 1 ) { detachInternal(); }
}
void detachInternal();
TQValueVectorPrivate&lt;T&gt;* sh;
private:
friend class TQDeepCopy&lt; TQValueVector&lt;T&gt; &gt;;
};
template &lt;class T&gt;
Q_INLINE_TEMPLATES TQValueVector&lt;T&gt;::TQValueVector( size_type n, const T&amp; val )
{
sh = new TQValueVectorPrivate&lt;T&gt;( n );
tqFill( begin(), end(), val );
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void TQValueVector&lt;T&gt;::detachInternal()
{
sh-&gt;deref();
sh = new TQValueVectorPrivate&lt;T&gt;( *sh );
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;T&gt;::insert( iterator pos, const T&amp; x )
{
size_type offset = pos - sh-&gt;start;
detach();
if ( pos == end() ) {
if ( sh-&gt;finish == sh-&gt;end )
push_back( x );
else {
*sh-&gt;finish = x;
++sh-&gt;finish;
}
} else {
if ( sh-&gt;finish == sh-&gt;end ) {
sh-&gt;insert( pos, x );
} else {
*sh-&gt;finish = *(sh-&gt;finish - 1);
++sh-&gt;finish;
tqCopyBackward( pos, sh-&gt;finish - 2, sh-&gt;finish - 1 );
*pos = x;
}
}
return begin() + offset;
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME TQValueVector&lt;T&gt;::iterator TQValueVector&lt;T&gt;::insert( iterator pos, size_type n, const T&amp; x )
{
if ( n != 0 ) {
size_type offset = pos - sh-&gt;start;
detach();
pos = begin() + offset;
sh-&gt;insert( pos, n, x );
}
return pos;
}
#ifndef QT_NO_DATASTREAM
template&lt;class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueVector&lt;T&gt;&amp; v )
{
v.clear();
Q_UINT32 c;
s &gt;&gt; c;
v.resize( c );
for( Q_UINT32 i = 0; i &lt; c; ++i )
{
T t;
s &gt;&gt; t;
v[i] = t;
}
return s;
}
template&lt;class T&gt;
Q_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueVector&lt;T&gt;&amp; v )
{
s &lt;&lt; (Q_UINT32)v.size();
// ### use typename TQValueVector&lt;T&gt;::const_iterator once all supported
// ### compilers know about the 'typename' keyword.
const T* it = v.begin();
for( ; it != v.end(); ++it )
s &lt;&lt; *it;
return s;
}
#endif // QT_NO_DATASTREAM
#define Q_DEFINED_QVALUEVECTOR
#include "ntqwinexport.h"
#endif // TQVALUEVECTOR_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>