Release-1.2.11-20011021

1 files changed, 475 insertions, 0 deletions

diff --git a/qtools/qintdict.doc b/qtools/qintdict.doc
new file mode 100644
index 0000000..0a77398
--- /dev/null
+++ b/qtools/qintdict.doc
@@ -0,0 +1,475 @@
+/****************************************************************************
+** $Id$
+**
+** QIntDict and QIntDictIterator class documentation
+**
+** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+**
+** This file is part 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.
+**
+**********************************************************************/
+
+
+/*****************************************************************************
+  QIntDict documentation
+ *****************************************************************************/
+
+/*!
+  \class QIntDict qintdict.h
+  \brief The QIntDict class is a template class that provides a dictionary based on \c long keys.
+
+  \ingroup collection
+  \ingroup tools
+
+  QIntDict is implemented as a template class. Define a
+  template instance QIntDict\<X\> to create a dictionary that operates on
+  pointers to X, or X*.
+
+  A dictionary is a collection that associates an item with a key.
+  The key is used for inserting and looking up an item.  QIntDict has
+  \c long keys.
+
+  The dictionary has very fast insertion and lookup.
+
+  Example:
+  \code
+    #include <qintdict.h>
+    #include <stdio.h>
+
+    void main()
+    {
+	QIntDict<char> dict;		// maps long ==> char*
+
+	dict.insert( 33, "France" );
+	dict.insert(  7, "Russia" );
+	dict.insert( 49, "Norway" );
+
+	printf( "%s\n", dict[49] );
+	printf( "%s\n", dict[33] );
+	printf( "%s\n", dict[7] );
+
+	if ( !dict[39] )
+	    printf( "39 not defined\n" );
+    }
+  \endcode
+
+  Program output:
+  \code
+	Norway
+	France
+	Russia
+	39 not defined
+  \endcode
+
+  The dictionary in our example maps \c long keys to \c char* items.
+  QIntDict implements the \link operator[] [] operator\endlink to lookup
+  an item.
+
+  QIntDict is implemented by QGDict as a hash array with a fixed number of
+  entries. Each array entry points to a singly linked list of buckets, in
+  which the dictionary items are stored.
+
+  When an item is inserted with a key, the key is converted (hashed) to
+  an integer index into the hash array using the \c mod operation. The
+  item is inserted before the first bucket in the list of buckets.
+
+  Looking up an item is normally very fast. The key is again hashed to an
+  array index. Then QIntDict scans the list of buckets and returns the item
+  found or null if the item was not found.  You cannot insert null pointers
+  into a dictionary.
+
+  The size of the hash array is very important. In order to get good
+  performance, you should use a suitably large \link primes.html prime
+  number\endlink.  Suitable means equal to or larger than the maximum
+  expected number of dictionary items.
+
+  Items with equal keys are allowed.  When inserting two items with the
+  same key, only the last inserted item will be visible (last in, first out)
+  until it is removed.
+
+  Example:
+  \code
+    #include <qintdict.h>
+    #include <stdio.h>
+
+    void main()
+    {
+	QIntDict<char> dict;		// maps long ==> char*
+
+	dict.insert( 7, "Russia" );
+	dict.insert( 7, "USSR" );
+
+	printf( "%s\n", dict[7] );
+	dict.remove( 7 );		// Gorbie was here
+	printf( "%s\n", dict[7] );
+    }
+  \endcode
+
+  Program output:
+  \code
+	USSR
+	Russia
+  \endcode
+
+  The QIntDictIterator class can traverse the dictionary contents, but only
+  in an arbitrary order.  Multiple iterators may independently traverse the
+  same dictionary.
+
+  Calling setAutoDelete(TRUE) for a dictionary tells it to delete items
+  that are removed .  The default is to not delete items when they are
+  removed.
+
+  When inserting an item into a dictionary, only the pointer is copied, not
+  the item itself. This is called a shallow copy. It is possible to make the
+  dictionary copy all of the item's data (known as a deep copy) when an
+  item is inserted.  insert() calls the virtual function
+  QCollection::newItem() for the item to be inserted.
+  Inherit a dictionary and reimplement it if you want deep copies.
+
+  When removing a dictionary item, the virtual function
+  QCollection::deleteItem() is called.  QIntDict's default implementation
+  is to delete the item if auto-deletion is enabled.
+
+  \sa QIntDictIterator, QDict, QAsciiDict, QPtrDict,
+      \link collection.html Collection Classes\endlink
+*/
+
+
+/*!
+  \fn QIntDict::QIntDict( int size )
+  Constructs a dictionary using an internal hash array with the size
+  \e size.
+
+  Setting \e size to a suitably large \link primes.html prime number\endlink
+  (equal to or greater than the expected number of entries) makes the hash
+  distribution better and hence the loopup faster.
+*/
+
+/*!
+  \fn QIntDict::QIntDict( const QIntDict<type> &dict )
+  Constructs a copy of \e dict.
+
+  Each item in \e dict are inserted into this dictionary.
+  Only the pointers are copied (shallow copy).
+*/
+
+/*!
+  \fn QIntDict::~QIntDict()
+  Removes all items from the dictionary and destroys it.
+
+  All iterators that access this dictionary will be reset.
+
+  \sa setAutoDelete()
+*/
+
+/*!
+  \fn QIntDict<type> &QIntDict::operator=(const QIntDict<type> &dict)
+  Assigns \e dict to this dictionary and returns a reference to this
+  dictionary.
+
+  This dictionary is first cleared, then each item in \e dict is inserted
+  into this dictionary.
+  Only the pointers are copied (shallow copy), unless newItem() has been
+  reimplemented.
+*/
+
+/*!
+  \fn uint QIntDict::count() const
+  Returns the number of items in the dictionary.
+  \sa isEmpty()
+*/
+
+/*!
+  \fn uint QIntDict::size() const
+  Returns the size of the internal hash array (as specified in the
+  constructor).
+  \sa count()
+*/
+
+/*!
+  \fn void QIntDict::resize( uint newsize )
+  Changes the size of the hashtable the \a newsize.
+  The contents of the dictionary are preserved,
+  but all iterators on the dictionary become invalid.
+*/
+
+/*!
+  \fn bool QIntDict::isEmpty() const
+  Returns TRUE if the dictionary is empty, i.e. count() == 0. Returns FALSE
+  otherwise.
+  \sa count()
+*/
+
+/*!
+  \fn void QIntDict::insert( long key, const type *item )
+  Inserts the \e key with the \e item into the dictionary.
+
+  The key does not have to be a unique dictionary key.  If multiple items
+  are inserted with the same key, only the last item will be visible.
+
+  Null items are not allowed.
+
+  \sa replace()
+*/
+
+/*!
+  \fn void QIntDict::replace( long key, const type *item )
+  Replaces an item which has a key equal to \e key with \e item.
+
+  If the item does not already exist, it will be inserted.
+
+  Null items are not allowed.
+
+  Equivalent to:
+  \code
+    QIntDict<char> dict;
+	...
+    if ( dict.find(key) )
+	dict.remove( key );
+    dict.insert( key, item );
+  \endcode
+
+  If there are two or more items with equal keys, then the last inserted
+  of these will be replaced.
+
+  \sa insert()
+*/
+
+/*!
+  \fn bool QIntDict::remove( long key )
+  Removes the item associated with \e key from the dictionary.
+  Returns TRUE if successful, or FALSE if the key does not exist in the
+  dictionary.
+
+  If there are two or more items with equal keys, then the last inserted
+  of these will be removed.
+
+  The removed item is deleted if \link QCollection::setAutoDelete()
+  auto-deletion\endlink is enabled.
+
+  All dictionary iterators that refer to the removed item will be set to
+  point to the next item in the dictionary traversing order.
+
+  \sa take(), clear(), setAutoDelete()
+*/
+
+/*!
+  \fn type *QIntDict::take( long key )
+  Takes the item associated with \e key out of the dictionary without
+  deleting it (even if \link QCollection::setAutoDelete()
+  auto-deletion\endlink is enabled).
+
+  If there are two or more items with equal keys, then the last inserted
+  of these will be taken.
+
+  Returns a pointer to the item taken out, or null if the key does not
+  exist in the dictionary.
+
+  All dictionary iterators that refer to the taken item will be set to
+  point to the next item in the dictionary traversing order.
+
+  \sa remove(), clear(), setAutoDelete()
+*/
+
+/*!
+  \fn void QIntDict::clear()
+  Removes all items from the dictionary.
+
+  The removed items are deleted if \link QCollection::setAutoDelete()
+  auto-deletion\endlink is enabled.
+
+  All dictionary iterators that access this dictionary will be reset.
+
+  \sa remove(), take(), setAutoDelete()
+*/
+
+/*!
+  \fn type *QIntDict::find( long key ) const
+  Returns the item associated with \e key, or null if the key does not
+  exist in the dictionary.
+
+  This function uses an internal hashing algorithm to optimize lookup.
+
+  If there are two or more items with equal keys, then the last inserted
+  of these will be found.
+
+  Equivalent to the [] operator.
+
+  \sa operator[]()
+*/
+
+/*!
+  \fn type *QIntDict::operator[]( long key ) const
+  Returns the item associated with \e key, or null if the key does not
+  exist in the dictionary.
+
+  This function uses an internal hashing algorithm to optimize lookup.
+
+  If there are two or more items with equal keys, then the last inserted
+  of these will be found.
+
+  Equivalent to the find() function.
+
+  \sa find()
+*/
+
+/*!
+  \fn void QIntDict::statistics() const
+  Debugging-only function that prints out the dictionary distribution
+  using qDebug().
+*/
+
+
+/*****************************************************************************
+  QIntDictIterator documentation
+ *****************************************************************************/
+
+/*!
+  \class QIntDictIterator qintdict.h
+  \brief The QIntDictIterator class provides an iterator for QIntDict collections.
+
+  \ingroup collection
+  \ingroup tools
+
+  QIntDictIterator is implemented as a template class.
+  Define a template instance QIntDictIterator\<X\> to create a
+  dictionary iterator that operates on QIntDict\<X\> (dictionary of X*).
+
+  Example:
+  \code
+    #include <qintdict.h>
+    #include <stdio.h>
+
+    void main()
+    {
+	QIntDict<char> dict;		// maps long ==> char*
+
+	dict.insert( 33, "France" );
+	dict.insert(  7, "Russia" );
+	dict.insert( 49, "Norway" );
+
+	QIntDictIterator<char> it( dict ); // iterator for dict
+
+        while ( it.current() ) {
+	    printf( "%d -> %s\n", it.currentKey(), it.current() );
+	    ++it;
+	}
+    }
+  \endcode
+
+  Program output:
+  \code
+	7 -> Russia
+	49 -> Norway
+	33 -> France
+  \endcode
+
+  Note that the traversal order is arbitrary, you are not guaranteed the
+  order above.
+
+  Multiple iterators may independently traverse the same dictionary.
+  A QIntDict knows about all iterators that are operating on the dictionary.
+  When an item is removed from the dictionary, QIntDict update all
+  iterators that are referring the removed item to point to the next item
+  in the traversing order.
+
+  \sa QIntDict, \link collection.html Collection Classes\endlink
+*/
+
+/*!
+  \fn QIntDictIterator::QIntDictIterator( const QIntDict<type> &dict )
+  Constructs an iterator for \e dict.  The current iterator item is
+  set to point on the first item in the \e dict.
+*/
+
+/*!
+  \fn QIntDictIterator::~QIntDictIterator()
+  Destroys the iterator.
+*/
+
+/*!
+  \fn uint QIntDictIterator::count() const
+  Returns the number of items in the dictionary this iterator operates on.
+  \sa isEmpty()
+*/
+
+/*!
+  \fn bool QIntDictIterator::isEmpty() const
+  Returns TRUE if the dictionary is empty, i.e. count() == 0. Returns FALSE
+  otherwise.
+  \sa count()
+*/
+
+/*!
+  \fn type *QIntDictIterator::toFirst()
+  Sets the current iterator item to point to the first item in the
+  dictionary and returns a pointer to the item.
+  If the dictionary is  empty it sets the current item to null and 
+  returns null.
+*/
+
+/*!
+  \fn QIntDictIterator::operator type *() const
+  Cast operator. Returns a pointer to the current iterator item.
+  Same as current().
+*/
+
+/*!
+  \fn type *QIntDictIterator::current() const
+  Returns a pointer to the current iterator item.
+*/
+
+/*!
+  \fn long QIntDictIterator::currentKey() const
+  Returns the key for the current iterator item.
+*/
+
+/*!
+  \fn type *QIntDictIterator::operator()()
+  Makes the succeeding item current and returns the original current item.
+
+  If the current iterator item was the last item in the dictionary or if it
+  was null, null is returned.
+*/
+
+/*!
+  \fn type *QIntDictIterator::operator++()
+  Prefix ++ makes the succeeding item current and returns the new current
+  item.
+
+  If the current iterator item was the last item in the dictionary or if it
+  was null, null is returned.
+*/
+
+/*!
+  \fn type *QIntDictIterator::operator+=( uint jump )
+  Sets the current item to the item \e jump positions after the current item,
+  and returns a pointer to that item.
+
+  If that item is beyond the last item or if the dictionary is  empty,
+  it sets the current item to null and returns null.
+*/