1 /****************************************************************************

     2 ** 

     3 **

     4 ** Definition of QAsciiDict template class

     5 **

     6 ** Created : 920821

     7 **

     8 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.

     9 **

    10 ** This file is part of the tools module of the Qt GUI Toolkit.

    11 **

    12 ** This file may be distributed under the terms of the Q Public License

    13 ** as defined by Trolltech AS of Norway and appearing in the file

    14 ** LICENSE.QPL included in the packaging of this file.

    15 **

    16 ** This file may be distributed and/or modified under the terms of the

    17 ** GNU General Public License version 2 as published by the Free Software

    18 ** Foundation and appearing in the file LICENSE.GPL included in the

    19 ** packaging of this file.

    20 **

    21 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition

    22 ** licenses may use this file in accordance with the Qt Commercial License

    23 ** Agreement provided with the Software.

    24 **

    25 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE

    26 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

    27 **

    28 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for

    29 **   information about Qt Commercial License Agreements.

    30 ** See http://www.trolltech.com/qpl/ for QPL licensing information.

    31 ** See http://www.trolltech.com/gpl/ for GPL licensing information.

    32 **

    33 ** Contact info@trolltech.com if any conditions of this licensing are

    34 ** not clear to you.

    35 **

    36 **********************************************************************/

    37 

    38 #ifndef QASCIIDICT_H

    39 #define QASCIIDICT_H

    40 

    41 #ifndef QT_H

    42 #include "qgdict.h"

    43 #endif // QT_H

    44 

    45 

    46 template<class type> class Q_EXPORT QAsciiDict : public QGDict

    47 {

    48 public:

    49     QAsciiDict(int size=17, bool caseSensitive=TRUE, bool copyKeys=TRUE )

    50 	: QGDict(size,AsciiKey,caseSensitive,copyKeys) {}

    51     QAsciiDict( const QAsciiDict<type> &d ) : QGDict(d) {}

    52    ~QAsciiDict()			{ clear(); }

    53     QAsciiDict<type> &operator=(const QAsciiDict<type> &d)

    54 			{ return (QAsciiDict<type>&)QGDict::operator=(d); }

    55     uint  count()   const		{ return QGDict::count(); }

    56     uint  size()    const		{ return QGDict::size(); }

    57     bool  isEmpty() const		{ return QGDict::count() == 0; }

    58 

    59     void  insert( const char *k, const type *d )

    60 					{ QGDict::look_ascii(k,(Item)d,1); }

    61     void  replace( const char *k, const type *d )

    62 					{ QGDict::look_ascii(k,(Item)d,2); }

    63     bool  remove( const char *k )	{ return QGDict::remove_ascii(k); }

    64     type *take( const char *k )		{ return (type *)QGDict::take_ascii(k); }

    65     type *find( const char *k ) const

    66 		{ return (type *)((QGDict*)this)->QGDict::look_ascii(k,0,0); }

    67     type *operator[]( const char *k ) const

    68 		{ return (type *)((QGDict*)this)->QGDict::look_ascii(k,0,0); }

    69 

    70     void  clear()			{ QGDict::clear(); }

    71     void  resize( uint n )		{ QGDict::resize(n); }

    72     void  statistics() const		{ QGDict::statistics(); }

    73 private:

    74     void  deleteItem( Item d );

    75 };

    76 

    77 #if defined(Q_DELETING_VOID_UNDEFINED)

    78 template<> inline void QAsciiDict<void>::deleteItem( Item )

    79 {

    80 }

    81 #endif

    82 

    83 template<class type> inline void QAsciiDict<type>::deleteItem( QCollection::Item d )

    84 {

    85     if ( del_item ) delete (type *)d;

    86 }

    87 

    88 

    89 template<class type> class Q_EXPORT QAsciiDictIterator : public QGDictIterator

    90 {

    91 public:

    92     QAsciiDictIterator(const QAsciiDict<type> &d)

    93 	: QGDictIterator((QGDict &)d) {}

    94    ~QAsciiDictIterator()      {}

    95     uint  count()   const     { return dict->count(); }

    96     bool  isEmpty() const     { return dict->count() == 0; }

    97     type *toFirst()	      { return (type *)QGDictIterator::toFirst(); }

    98     operator type *() const   { return (type *)QGDictIterator::get(); }

    99     type   *current() const   { return (type *)QGDictIterator::get(); }

   100     const char *currentKey() const { return QGDictIterator::getKeyAscii(); }

   101     type *operator()()	      { return (type *)QGDictIterator::operator()(); }

   102     type *operator++()	      { return (type *)QGDictIterator::operator++(); }

   103     type *operator+=(uint j)  { return (type *)QGDictIterator::operator+=(j);}

   104 };

   105 

   106 

   107 #endif // QASCIIDICT_H