/****************************************************************************
**
** Copyright (C) 1992-2004 Trolltech AS. All rights reserved.
**
** This file is part of the compatibility classes of the Qt Toolkit.
**
** Licensees holding valid Qt Preview licenses may use this file in
** accordance with the Qt Preview License Agreement provided with the
** Software.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
** information about Qt Commercial License Agreements.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#ifndef QPTRVECTOR_H
#define QPTRVECTOR_H

#include "qgvector.h"

template<class type>
class QPtrVector
#ifdef qdoc
        : public QPtrCollection
#else
        : public QGVector
#endif
{
public:
    QPtrVector()                                { }
    QPtrVector(uint size) : QGVector(size) { }
    QPtrVector(const QPtrVector<type> &v) : QGVector(v) { }
    ~QPtrVector()                                { clear(); }
    QPtrVector<type> &operator=(const QPtrVector<type> &v)
                        { return static_cast<QPtrVector<type> &>(QGVector::operator=(v)); }
    bool operator==(const QPtrVector<type> &v) const { return QGVector::operator==(v); }
    type **data()   const                { return static_cast<type **>(QGVector::data()); }
    uint  size()    const                { return QGVector::size(); }
    uint  count()   const                { return QGVector::count(); }
    bool  isEmpty() const                { return QGVector::count() == 0; }
    bool  isNull()  const                { return QGVector::size() == 0; }
    bool  resize(uint size)                { return QGVector::resize(size); }
    bool  insert(uint i, const type *d){ return QGVector::insert(i,Item(d)); }
    bool  remove(uint i)                { return QGVector::remove(i); }
    type *take(uint i)                { return static_cast<type *>(QGVector::take(i)); }
    void  clear()                        { QGVector::clear(); }
    bool  fill(const type *d, int size=-1)
                                        { return QGVector::fill(Item(d),size);}
    void  sort()                        { QGVector::sort(); }
    int          bsearch(const type *d) const{ return QGVector::bsearch(Item(d)); }
    int          findRef(const type *d, uint i=0) const
                                        { return QGVector::findRef(Item(d),i);}
    int          find(const type *d, uint i= 0) const
                                        { return QGVector::find(Item(d),i); }
    uint  containsRef(const type *d) const
                                { return QGVector::containsRef(Item(d)); }
    uint  contains(const type *d) const
                                        { return QGVector::contains(Item(d)); }
    type *operator[](int i) const        { return static_cast<type *>(QGVector::at(i)); }
    type *at(uint i) const                { return static_cast<type *>(QGVector::at(i)); }
    void  toList(QGList *list) const        { QGVector::toList(list); }

#ifdef qdoc
protected:
    virtual int compareItems(QPtrCollection::Item d1, QPtrCollection::Item d2);
    virtual QDataStream& read(QDataStream &s, QPtrCollection::Item &d);
    virtual QDataStream& write(QDataStream &s, QPtrCollection::Item d) const;
#endif

private:
    void  deleteItem(Item d);
};

#if !defined(Q_BROKEN_TEMPLATE_SPECIALIZATION)
template<> inline void QPtrVector<void>::deleteItem(QPtrCollection::Item)
{
}
#endif

template<class type> inline void QPtrVector<type>::deleteItem(QPtrCollection::Item d)
{
    if (del_item) delete static_cast<type *>(d);
}

#endif // QVECTOR_H
