/****************************************************************************
** $Id: qintcache.h,v 2.4.2.2 1998/08/27 08:14:01 hanord Exp $
**
** Definition of QIntCache template/macro class
**
** Created : 950209
**
** Copyright (C) 1992-1998 Troll Tech AS. All rights reserved.
**
** This file is part of Qt Free Edition, version 1.42.
**
** See the file LICENSE included in the distribution for the usage
** and distribution terms, or http://www.troll.no/free-license.html.
**
** IMPORTANT NOTE: You may NOT copy this file or any part of it into
** your own programs or libraries.
**
** Please see http://www.troll.no/pricing.html for information about
** Qt Professional Edition, which is this same library but with a
** license which allows creation of commercial/proprietary software.
**
*****************************************************************************/
#ifndef QINTCACHE_H
#define QINTCACHE_H
#ifndef QT_H
#include "qgcache.h"
#endif // QT_H
#if defined(USE_MACROCLASS)
#include "qgeneric.h"
#if !defined(name2)
#define name2(a,b) name2_xx(a,b)
#define name2_xx(a,b) a##b
#endif
#if defined(DEFAULT_MACROCLASS)
#define QIntCachedeclare QIntCacheMdeclare
#define QIntCache QIntCacheM
#endif
#define QIntCacheM(type) name2(QIntCacheM_,type)
#define QIntCacheMdeclare(type) \
class Q_EXPORTM QIntCacheM(type) : public QGCache \
{ \
public: \
QIntCacheM(type)( const QIntCacheM(type) &c ) : QGCache(c) {} \
QIntCacheM(type)( int maxCost=100, int size=17 ) \
: QGCache( maxCost, size, FALSE, FALSE, TRUE ) {} \
~QIntCacheM(type)() { clear(); } \
QIntCacheM(type) &operator=( const QIntCacheM(type) &c ) \
{ return (QIntCacheM(type)&)QGCache::operator=(c); } \
int maxCost() const { return QGCache::maxCost(); } \
int totalCost() const { return QGCache::totalCost(); } \
void setMaxCost( int m ) { QGCache::setMaxCost(m); } \
uint count() const { return QGCache::count(); } \
uint size() const { return QGCache::size(); } \
bool isEmpty() const { return QGCache::count() == 0; } \
bool insert( long k, const type *d, int c=1, int p=0 ) \
{ return QGCache::insert((const char*)k,(GCI)d,c,p); }\
bool remove( long k ) { return QGCache::remove((const char *)k); } \
type *take( long k ) { return (type *)QGCache::take((const char *)k);}\
void clear() { QGCache::clear(); } \
type *find( long k, bool ref=TRUE ) const \
{ return (type *)QGCache::find( (const char *)k,ref);}\
type *operator[]( long k ) const \
{ return (type *)QGCache::find( (const char *)k); } \
void statistics() const { QGCache::statistics(); } \
private: \
void deleteItem( GCI d ) { if ( del_item ) delete (type *)d; } \
}
#if defined(DEFAULT_MACROCLASS)
#define QIntCacheIteratordeclare QIntCacheIteratorMdeclare
#define QIntCacheIterator QIntCacheIteratorM
#endif
#define QIntCacheIteratorM(type) name2(QIntCacheIteratorM_,type)
#define QIntCacheIteratorMdeclare(type) \
class Q_EXPORTM QIntCacheIteratorM(type) : public QGCacheIterator \
{ \
public: \
QIntCacheIteratorM(type)( const QIntCacheM(type) &c ) \
: QGCacheIterator( (QGCache &)c ) {} \
QIntCacheIteratorM(type)( const QIntCacheIteratorM(type) &ci ) \
: QGCacheIterator( (QGCacheIterator &)ci ) {} \
QIntCacheIteratorM(type) &operator=( const QIntCacheIteratorM(type)&ci ) \
{ return (QIntCacheIteratorM(type)&)QGCacheIterator::operator=(ci); } \
uint count() const { return QGCacheIterator::count(); } \
bool isEmpty() const { return QGCacheIterator::count() == 0; } \
bool atFirst() const { return QGCacheIterator::atFirst(); } \
bool atLast() const { return QGCacheIterator::atLast(); } \
type *toFirst() { return (type *)QGCacheIterator::toFirst(); } \
type *toLast() { return (type *)QGCacheIterator::toLast(); } \
operator type *() const { return (type *)QGCacheIterator::get(); } \
type *current() const { return (type *)QGCacheIterator::get(); } \
const char *currentKey() const \
{ return QGCacheIterator::getKey();} \
type *operator()() { return (type *)QGCacheIterator::operator()();} \
type *operator++() { return (type *)QGCacheIterator::operator++();} \
type *operator+=(uint j) { return (type *)QGCacheIterator::operator+=(j);}\
type *operator--() { return (type *)QGCacheIterator::operator--();} \
type *operator-=(uint j) { return (type *)QGCacheIterator::operator-=(j);}\
}
#endif // USE_MACROCLASS
#if defined(USE_TEMPLATECLASS)
#if defined(DEFAULT_TEMPLATECLASS)
#undef QIntCache
#define QIntCache QIntCacheT
#endif
template<class type> class Q_EXPORT QIntCacheT : public QGCache
{
public:
QIntCacheT( const QIntCacheT<type> &c ) : QGCache(c) {}
QIntCacheT( int maxCost=100, int size=17 )
: QGCache( maxCost, size, FALSE, FALSE, TRUE ) {}
~QIntCacheT() { clear(); }
QIntCacheT<type> &operator=( const QIntCacheT<type> &c )
{ return (QIntCacheT<type>&)QGCache::operator=(c); }
int maxCost() const { return QGCache::maxCost(); }
int totalCost() const { return QGCache::totalCost(); }
void setMaxCost( int m) { QGCache::setMaxCost(m); }
uint count() const { return QGCache::count(); }
uint size() const { return QGCache::size(); }
bool isEmpty() const { return QGCache::count() == 0; }
bool insert( long k, const type *d, long c=1, int p=0 )
{ return QGCache::insert((const char*)k,(GCI)d,c,p); }
bool remove( long k ) { return QGCache::remove((const char *)k); }
type *take( long k ) { return (type *)QGCache::take((const char *)k);}
void clear() { QGCache::clear(); }
type *find( long k, bool ref=TRUE ) const
{ return (type *)QGCache::find( (const char *)k,ref);}
type *operator[]( long k ) const
{ return (type *)QGCache::find( (const char *)k); }
void statistics() const { QGCache::statistics(); }
private:
void deleteItem( GCI d ){ if ( del_item ) delete (type *)d; }
};
#if defined(DEFAULT_TEMPLATECLASS)
#undef QIntCacheIterator
#define QIntCacheIterator QIntCacheIteratorT
#endif
template<class type> class Q_EXPORT QIntCacheIteratorT : public QGCacheIterator
{
public:
QIntCacheIteratorT( const QIntCacheT<type> &c )
: QGCacheIterator( (QGCache &)c ) {}
QIntCacheIteratorT( const QIntCacheIteratorT<type> &ci )
: QGCacheIterator((QGCacheIterator &)ci) {}
QIntCacheIteratorT<type> &operator=( const QIntCacheIteratorT<type>&ci )
{ return ( QIntCacheIteratorT<type>&)QGCacheIterator::operator=( ci );}
uint count() const { return QGCacheIterator::count(); }
bool isEmpty() const { return QGCacheIterator::count() == 0; }
bool atFirst() const { return QGCacheIterator::atFirst(); }
bool atLast() const { return QGCacheIterator::atLast(); }
type *toFirst() { return (type *)QGCacheIterator::toFirst(); }
type *toLast() { return (type *)QGCacheIterator::toLast(); }
operator type *() const { return (type *)QGCacheIterator::get(); }
type *current() const { return (type *)QGCacheIterator::get(); }
long currentKey() const { return (long)QGCacheIterator::getKey();}
type *operator()() { return (type *)QGCacheIterator::operator()();}
type *operator++() { return (type *)QGCacheIterator::operator++(); }
type *operator+=(uint j) { return (type *)QGCacheIterator::operator+=(j);}
type *operator--() { return (type *)QGCacheIterator::operator--(); }
type *operator-=(uint j) { return (type *)QGCacheIterator::operator-=(j);}
};
#endif // USE_TEMPLATECLASS
#endif // QINTCACHE_H
| Copyright © 1998 Troll Tech | Trademarks | Qt version 1.42
|