summaryrefslogtreecommitdiffstats
path: root/doc/html/tqvaluevector-h.html
diff options
context:
space:
mode:
Diffstat (limited to 'doc/html/tqvaluevector-h.html')
-rw-r--r--doc/html/tqvaluevector-h.html620
1 files changed, 620 insertions, 0 deletions
diff --git a/doc/html/tqvaluevector-h.html b/doc/html/tqvaluevector-h.html
new file mode 100644
index 000000000..b0be7c3f0
--- /dev/null
+++ b/doc/html/tqvaluevector-h.html
@@ -0,0 +1,620 @@
+<!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/tqvaluevector.h:1 -->
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>tqvaluevector.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>tqvaluevector.h</h1>
+
+<p>This is the verbatim text of the tqvaluevector.h include file. It is provided only for illustration; the copyright remains with Trolltech.
+<hr>
+<pre>
+/****************************************************************************
+** $Id: qt/tqvaluevector.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 [email protected].
+**
+** 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 TQT_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;
+TQ_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;
+TQ_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;
+TQ_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;
+TQ_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;
+TQ_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;
+TQ_INLINE_TEMPLATES TQ_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 TQT_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 TQT_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 TQT_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;
+TQ_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;
+TQ_INLINE_TEMPLATES void TQValueVector&lt;T&gt;::detachInternal()
+{
+ sh-&gt;deref();
+ sh = new TQValueVectorPrivate&lt;T&gt;( *sh );
+}
+
+template &lt;class T&gt;
+TQ_INLINE_TEMPLATES TQ_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;
+TQ_INLINE_TEMPLATES TQ_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 TQT_NO_DATASTREAM
+template&lt;class T&gt;
+TQ_INLINE_TEMPLATES TQDataStream&amp; operator&gt;&gt;( TQDataStream&amp; s, TQValueVector&lt;T&gt;&amp; v )
+{
+ v.clear();
+ TQ_UINT32 c;
+ s &gt;&gt; c;
+ v.resize( c );
+ for( TQ_UINT32 i = 0; i &lt; c; ++i )
+ {
+ T t;
+ s &gt;&gt; t;
+ v[i] = t;
+ }
+ return s;
+}
+
+template&lt;class T&gt;
+TQ_INLINE_TEMPLATES TQDataStream&amp; operator&lt;&lt;( TQDataStream&amp; s, const TQValueVector&lt;T&gt;&amp; v )
+{
+ s &lt;&lt; (TQ_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 // TQT_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>