--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/qtools/qintdict.doc Thu Jan 21 17:29:01 2010 +0000
@@ -0,0 +1,475 @@
+/****************************************************************************
+**
+**
+** 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.
+*/