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.
qt3/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/qvaluevector.h:1 -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>qvaluevector.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>qvaluevector.h</h1>
<p>This is the verbatim text of the qvaluevector.h include file. It is provided only for illustration; the copyright remains with Trolltech.
<hr>
<pre>
/****************************************************************************
** $Id: qt/qvaluevector.h 3.3.8 edited Jan 11 14:38 $
**
** Definition of QValueVector class
**
** Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.
**
** This file is part of the tools module of the Qt 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 Qt 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.QPL
** included in the packaging of this file. Licensees holding valid Qt
** Commercial 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 WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#ifndef QVALUEVECTOR_H
#define QVALUEVECTOR_H
#ifndef QT_H
#include "qtl.h"
#include "qshared.h"
#include "qdatastream.h"
#endif // QT_H
#ifndef QT_NO_STL
#include &lt;vector&gt;
#endif
template &lt;class T&gt;
class QValueVectorPrivate : public QShared
{
public:
typedef T value_type;
typedef T* pointer;
QValueVectorPrivate()
: start( 0 ), finish( 0 ), end( 0 )
{
}
QValueVectorPrivate( const QValueVectorPrivate&lt;T&gt;&amp; x );
QValueVectorPrivate( 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
~QValueVectorPrivate()
{
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 );
QValueVectorPrivate&lt;T&gt;&amp; operator=( const QValueVectorPrivate&lt;T&gt;&amp; x );
};
template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueVectorPrivate&lt;T&gt;::QValueVectorPrivate( const QValueVectorPrivate&lt;T&gt;&amp; x )
: QShared()
{
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
qCopy( (pointer)x.start, (pointer)x.finish, start );
#else
qCopy( x.start, x.finish, start );
#endif
} else {
start = 0;
finish = 0;
end = 0;
}
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueVectorPrivate&lt;T&gt;::QValueVectorPrivate( 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 QValueVectorPrivate&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;
qCopy( start, pos, newStart );
*newFinish = x;
qCopy( pos, finish, ++newFinish );
delete[] start;
start = newStart;
finish = newStart + lastSize + 1;
end = newStart + n;
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void QValueVectorPrivate&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 ) {
qCopy( finish - n, finish, finish );
finish += n;
qCopyBackward( pos, old_finish - n, old_finish );
qFill( 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;
qCopy( pos, old_finish, finish );
finish += elems_after;
qFill( pos, old_finish, x );
}
} else {
// not enough room
const size_t lastSize = size();
const size_t len = lastSize + QMAX( lastSize, n );
pointer newStart = new T[len];
pointer newFinish = qCopy( start, pos, newStart );
// fill up inserted space
size_t i = n;
for ( ; i &gt; 0; --i, ++newFinish )
*newFinish = x;
newFinish = qCopy( pos, finish, newFinish );
delete[] start;
start = newStart;
finish = newFinish;
end = newStart + len;
}
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void QValueVectorPrivate&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 QValueVectorPrivate&lt;T&gt;::pointer QValueVectorPrivate&lt;T&gt;::growAndCopy( size_t n, pointer s, pointer f )
{
pointer newStart = new T[n];
qCopy( s, f, newStart );
delete[] start;
return newStart;
}
template &lt;class T&gt; class QDeepCopy;
template &lt;class T&gt;
class QValueVector
{
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
QValueVector()
{
sh = new QValueVectorPrivate&lt;T&gt;;
}
QValueVector( const QValueVector&lt;T&gt;&amp; v )
{
sh = v.sh;
sh-&gt;ref();
}
QValueVector( size_type n, const T&amp; val = T() );
#ifndef QT_NO_STL
QValueVector( std::vector&lt;T&gt;&amp; v ) // ### remove in 4.0
{
sh = new QValueVectorPrivate&lt;T&gt;( v.size() );
qCopy( v.begin(), v.end(), begin() );
}
QValueVector( const std::vector&lt;T&gt;&amp; v )
{
sh = new QValueVectorPrivate&lt;T&gt;( v.size() );
qCopy( v.begin(), v.end(), begin() );
}
#endif
~QValueVector()
{
sh-&gt;derefAndDelete();
}
QValueVector&lt;T&gt;&amp; operator= ( const QValueVector&lt;T&gt;&amp; v )
{
v.sh-&gt;ref();
sh-&gt;derefAndDelete();
sh = v.sh;
return *this;
}
#ifndef QT_NO_STL
QValueVector&lt;T&gt;&amp; operator= ( const std::vector&lt;T&gt;&amp; v )
{
clear();
resize( v.size() );
qCopy( 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() )
qCopy( pos + 1, sh-&gt;finish, pos );
--sh-&gt;finish;
return pos;
}
iterator erase( iterator first, iterator last )
{
detach();
qCopy( last, sh-&gt;finish, first );
sh-&gt;finish = sh-&gt;finish - ( last - first );
return first;
}
// ### remove in Qt 4.0
bool operator==( const QValueVector&lt;T&gt;&amp; x )
{
return size()==x.size() ? qEqual( constBegin(), constEnd(), x.begin()) : FALSE;
}
bool operator==( const QValueVector&lt;T&gt;&amp; x ) const
{
return size()==x.size() ? qEqual( 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();
QValueVectorPrivate&lt;T&gt;* sh;
private:
friend class QDeepCopy&lt; QValueVector&lt;T&gt; &gt;;
};
template &lt;class T&gt;
Q_INLINE_TEMPLATES QValueVector&lt;T&gt;::QValueVector( size_type n, const T&amp; val )
{
sh = new QValueVectorPrivate&lt;T&gt;( n );
qFill( begin(), end(), val );
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES void QValueVector&lt;T&gt;::detachInternal()
{
sh-&gt;deref();
sh = new QValueVectorPrivate&lt;T&gt;( *sh );
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME QValueVector&lt;T&gt;::iterator QValueVector&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;
qCopyBackward( pos, sh-&gt;finish - 2, sh-&gt;finish - 1 );
*pos = x;
}
}
return begin() + offset;
}
template &lt;class T&gt;
Q_INLINE_TEMPLATES Q_TYPENAME QValueVector&lt;T&gt;::iterator QValueVector&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 QDataStream&amp; operator&gt;&gt;( QDataStream&amp; s, QValueVector&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 QDataStream&amp; operator&lt;&lt;( QDataStream&amp; s, const QValueVector&lt;T&gt;&amp; v )
{
s &lt;&lt; (Q_UINT32)v.size();
// ### use typename QValueVector&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 "qwinexport.h"
#endif // QVALUEVECTOR_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>Qt 3.3.8</div>
</table></div></address></body>
</html>