Sophie

Sophie

distrib > Mandriva > 8.2 > i586 > media > contrib > by-pkgid > 112b0974ad288f6cd55bf971ee6026a9 > files > 2003

libqt3-devel-3.0.2-2mdk.i586.rpm

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- /tmp/qt-3.0-reggie-28534/qt-x11-free-3.0.2/include/qvaluelist.h:1 -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>qvaluelist.h Include File</title>
<style type="text/css"><!--
h3.fn,span.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>qvaluelist.h</h1>

<p>This is the verbatim text of the qvaluelist.h include file. It is provided only for illustration; the copyright remains with Trolltech.
<hr>
<pre>
/****************************************************************************
** $Id:  qt/qvaluelist.h   3.0.2   edited Oct 12 12:18 $
**
** Definition of QValueList class
**
** Created : 990406
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** 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
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#ifndef QVALUELIST_H
#define QVALUELIST_H

#ifndef QT_H
#include "qtl.h"
#include "qshared.h"
#include "qdatastream.h"
#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 Q_EXPORT QValueListNode
{
public:
    QValueListNode( const T&amp; t ) : data( t ) { }
    QValueListNode() { }
#if defined(Q_TEMPLATEDLL)
    // Workaround MS bug in memory de/allocation in DLL vs. EXE
    virtual ~QValueListNode() { }
#endif

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

template&lt;class T&gt;
class Q_EXPORT QValueListIterator
{
 public:
    /**
     * Typedefs
     */
    typedef QValueListNode&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
     */
    QValueListIterator() : node( 0 ) {}
    QValueListIterator( NodePtr p ) : node( p ) {}
    QValueListIterator( const QValueListIterator&lt;T&gt;&amp; it ) : node( it.node ) {}

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

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

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

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

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

template&lt;class T&gt;
class Q_EXPORT QValueListConstIterator
{
 public:
    /**
     * Typedefs
     */
    typedef QValueListNode&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
     */
    QValueListConstIterator() : node( 0 ) {}
    QValueListConstIterator( NodePtr p ) : node( p ) {}
    QValueListConstIterator( const QValueListConstIterator&lt;T&gt;&amp; it ) : node( it.node ) {}
    QValueListConstIterator( const QValueListIterator&lt;T&gt;&amp; it ) : node( it.node ) {}

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

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

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

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

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

template &lt;class T&gt;
class Q_EXPORT QValueListPrivate : public QShared
{
public:
    /**
     * Typedefs
     */
    typedef QValueListIterator&lt;T&gt; Iterator;
    typedef QValueListConstIterator&lt;T&gt; ConstIterator;
    typedef QValueListNode&lt;T&gt; Node;
    typedef QValueListNode&lt;T&gt;* NodePtr;
    typedef size_t size_type;

    /**
     * Functions
     */
    QValueListPrivate() { node = new Node; node-&gt;next = node-&gt;prev = node; nodes = 0; }
    QValueListPrivate( const QValueListPrivate&lt;T&gt;&amp; _p ) : QShared() {
	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++ );
    }

    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
    ~QValueListPrivate() {
	NodePtr p = node-&gt;next;
	while( p != node ) {
	    NodePtr x = p-&gt;next;
	    delete p;
	    p = x;
	}
	delete node;
    }

    Iterator insert( 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;
    }

    Iterator remove( 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 );
    }

    NodePtr find( 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;
    }

    int findIndex( 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;
    }

    uint 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;
    }

    uint remove( const T&amp; 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;
    }

    NodePtr 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;
    }

    void 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;
    }

    NodePtr node;
    size_type nodes;
};

#ifdef QT_CHECK_RANGE
# if !defined( QT_NO_DEBUG ) &amp;&amp; defined( QT_CHECK_VALUELIST_RANGE )
#  define QT_CHECK_INVALID_LIST_ELEMENT if ( empty() ) qWarning( "QValueList: 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 Q_EXPORT QValueList
{
public:
    /**
     * Typedefs
     */
    typedef QValueListIterator&lt;T&gt; iterator;
    typedef QValueListConstIterator&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
     */
    QValueList() { sh = new QValueListPrivate&lt;T&gt;; }
    QValueList( const QValueList&lt;T&gt;&amp; l ) { sh = l.sh; sh-&gt;ref(); }
#ifndef QT_NO_STL
    QValueList( const Q_TYPENAME std::list&lt;T&gt;&amp; l )
    {
	sh = new QValueListPrivate&lt;T&gt;;
	qCopy( l.begin(), l.end(), std::back_inserter( *this ) );
    }
#endif
    ~QValueList() { sh-&gt;derefAndDelete(); }

    QValueList&lt;T&gt;&amp; operator= ( const QValueList&lt;T&gt;&amp; l )
    {
	l.sh-&gt;ref();
	sh-&gt;derefAndDelete();
	sh = l.sh;
	return *this;
    }
#ifndef QT_NO_STL
    QValueList&lt;T&gt;&amp; operator= ( const Q_TYPENAME std::list&lt;T&gt;&amp; l )
    {
	detach();
	qCopy( l.begin(), l.end(), std::back_inserter( *this ) );
	return *this;
    }
    bool operator== ( const Q_TYPENAME 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 QValueList&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;
    }

    bool operator!= ( const QValueList&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 ); }
    iterator end() { detach(); return iterator( sh-&gt;node ); }
    const_iterator end() 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() { if ( sh-&gt;count == 1 ) sh-&gt;clear(); else { sh-&gt;deref(); sh = new QValueListPrivate&lt;T&gt;; } }

    QValueList&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 )
    {
	while ( first != last )
	    erase( first++ );
	return 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 )
    {
	for ( ; n &gt; 0; --n )
	    insert( pos, x );
    }
    // Some compilers (incl. vc++) would instantiate this function even if
    // it is not used; this would constrain QValueList to classes that provide
    // an operator&lt;
    /*
    void sort()
    {
	qHeapSort( *this );
    }
    */

    QValueList&lt;T&gt; operator+ ( const QValueList&lt;T&gt;&amp; l ) const
    {
	QValueList&lt;T&gt; l2( *this );
	for( const_iterator it = l.begin(); it != l.end(); ++it )
	    l2.append( *it );
	return l2;
    }

    QValueList&lt;T&gt;&amp; operator+= ( const QValueList&lt;T&gt;&amp; l )
    {
	for( const_iterator it = l.begin(); it != l.end(); ++it )
	    append( *it );
	return *this;
    }


    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; }

    QValueList&lt;T&gt;&amp; operator+= ( const T&amp; x )
    {
	append( x );
	return *this;
    }
    typedef QValueListIterator&lt;T&gt; Iterator;
    typedef QValueListConstIterator&lt;T&gt; ConstIterator;
    typedef T ValueType;

protected:
    /**
     * Helpers
     */
    void detach() { if ( sh-&gt;count &gt; 1 ) { sh-&gt;deref(); sh = new QValueListPrivate&lt;T&gt;( *sh ); } }

    /**
     * Variables
     */
    QValueListPrivate&lt;T&gt;* sh;
};

#ifndef QT_NO_DATASTREAM
template&lt;class T&gt;
inline QDataStream&amp; operator&gt;&gt;( QDataStream&amp; s, QValueList&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 );
    }
    return s;
}

template&lt;class T&gt;
inline QDataStream&amp; operator&lt;&lt;( QDataStream&amp; s, const QValueList&lt;T&gt;&amp; l )
{
    s &lt;&lt; (Q_UINT32)l.size();
    QValueListConstIterator&lt;T&gt; it = l.begin();
    for( ; it != l.end(); ++it )
	s &lt;&lt; *it;
    return s;
}
#endif // QT_NO_DATASTREAM
#endif // QVALUELIST_H
</pre>
<!-- eof -->
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2001 
<a href="http://www.trolltech.com">Trolltech</a><td><a href="http://www.trolltech.com/trademarks.html">Trademarks</a>
<td align=right><div align=right>Qt version 3.0.2</div>
</table></div></address></body>
</html>

Perl :: Catalyst :: PostgreSQL :: RPM Valid HTML 4.01 Transitional