qptrvector.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                 Q t   P o i n t e r   V e c t o r   T h u n k                 *
*                                                                               *
*********************************************************************************
* Copyright (C) 2003 by Niall Douglas.   All Rights Reserved.                   *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code is distributed in the hope that it will be useful,                  *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef QPTRVECTOR_H
#define QPTRVECTOR_H

#if _MSC_VER==1200
#pragma warning(disable: 4786)
#endif

#include <vector>
#include <algorithm>
#include "fxdefs.h"
#include "FXStream.h"
#include "FXException.h"

namespace FX {

typedef FXuint uint;

template<class type> class QPtrVectorIterator;
template<class type> class QPtrVector : private std::vector<type *>
{
    bool autodel;
public:
    explicit QPtrVector(bool wantAutoDel=false) : autodel(wantAutoDel), std::vector<type *>() {}
    explicit QPtrVector(std::vector<type *> &l) : autodel(false), std::vector<type *>(l) {}
    ~QPtrVector()   { clear(); }
    FXADDMOVEBASECLASS(QPtrVector, std::vector<type *>)
    bool autoDelete() const { return autodel; }
    void setAutoDelete(bool a) { autodel=a; }

    type **data() const { return &std::vector<type *>::front(); }
    using std::vector<type *>::size;
    using std::vector<type *>::capacity;
    using std::vector<type *>::reserve;
    uint count() const { return (uint) std::vector<type *>::size(); }
    bool isEmpty() const { return std::vector<type *>::empty(); }
    bool insert(uint i, const type *d) { FXEXCEPTION_STL1 { std::vector<type *>::insert(std::vector<type *>::begin()+i, const_cast<type *>(d)); } FXEXCEPTION_STL2; return true; }
    bool insertAtIter(QPtrVectorIterator<type> &it, const type *d);
    void inSort(const type *d)
    {
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            if(compareItems(*it, const_cast<type *>(d))>=0)
            {
                FXEXCEPTION_STL1 { std::vector<type *>::insert(it, const_cast<type *>(d)); } FXEXCEPTION_STL2;
            }
        }
    }
    void append(const type *d) { FXEXCEPTION_STL1 { push_back(const_cast<type *>(d)); } FXEXCEPTION_STL2; }
    bool extend(uint no)
    {
        uint cs=(uint) std::vector<type *>::size();
        if(cs<no)
        {
            std::vector<type *>::resize(no);
            return true;
        }
        return false;
    }
    bool remove(uint i)
    {
        if(isEmpty()) return false;
        typename std::vector<type *>::iterator it=std::vector<type *>::begin()+i;
        deleteItem(*it);
        erase(it);
        return true;
    }
    bool remove(const type *d)
    {
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            if(0==compareItems(*it, const_cast<type *>(d)))
            {
                deleteItem(*it);
                erase(it);
                return true;
            }
        }
        return false;
    }
    bool removeRef(const type *d)
    {
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            if(*it==d)
            {
                deleteItem(*it);
                erase(it);
                return true;
            }
        }
        return false;
    }
    bool removeByIter(QPtrVectorIterator<type> &it);
    bool removeLast()
    {
        if(isEmpty()) return false;
        typename std::vector<type *>::iterator it=--std::vector<type *>::end();
        deleteItem(*it);
        std::vector<type *>::pop_back();
        return true;
    }
    type *take(uint i)
    {
        if(isEmpty()) return 0; // Fails for non-pointer types
        typename std::vector<type *>::iterator it=std::vector<type *>::begin()+i;
        type *ret=*it;
        std::vector<type *>::erase(it);
        return ret;
    }
    bool take(const type *d)
    {
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            if(0==compareItems(*it, const_cast<type *>(d)))
            {
                std::vector<type *>::erase(it);
                return true;
            }
        }
        return false;
    }
    bool takeRef(const type *d)
    {
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            if(*it==d)
            {
                std::vector<type *>::erase(it);
                return true;
            }
        }
        return false;
    }
    bool takeByIter(QPtrVectorIterator<type> &it);
    bool takeLast()
    {
        if(isEmpty()) return false;
        typename std::vector<type *>::iterator it=--std::vector<type *>::end();
        std::vector<type *>::pop_back();
        return true;
    }
    void clear()
    {
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            deleteItem(*it);
        }
        std::vector<type *>::clear();
    }
private:
    struct SortPredicate
    {
        QPtrVector *me;
        SortPredicate(QPtrVector *_me) : me(_me) { }
        bool operator()(type *a, type *b)
        {
            return me->compareItems(a, b)==-1;
        }
    };
public:
    template<class SortFunc> void sort(SortFunc sortfunc)
    {
        std::sort(std::vector<type *>::begin(), std::vector<type *>::end(), sortfunc);
    }
    void sort()
    {
        std::sort(std::vector<type *>::begin(), std::vector<type *>::end(), SortPredicate(this));
    }
    int find(const type *d)
    {
        int idx=0;
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it, ++idx)
        {
            if(0==compareItems(*it, const_cast<type *>(d))) return idx;
        }
        return -1;
    }
    int findRef(const type *d)
    {
        int idx=0;
        for(typename std::vector<type *>::iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it, ++idx)
        {
            if(*it==d) return idx;
        }
        return -1;
    }
    uint contains(const type *d) const
    {
        uint count=0;
        for(typename std::vector<type *>::const_iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            if(0==compareItems(const_cast<type *>(*it), const_cast<type *>(d))) count++;
        }
        return count;
    }
    uint containsRef(const type *d) const
    {
        uint count=0;
        for(typename std::vector<type *>::const_iterator it=std::vector<type *>::begin(); it!=std::vector<type *>::end(); ++it)
        {
            if(*it==d) count++;
        }
        return count;
    }
    bool replace(uint i, const type *d, bool callDeleteItem=true)
    {
        if(isEmpty()) return false;
        typename std::vector<type *>::iterator it=std::vector<type *>::begin()+i;
        if(callDeleteItem)
            deleteItem(*it);
        *it=const_cast<type *>(d);
        //list<type *>::erase(list<type *>::begin()+i);
        //list<type *>::insert(list<type *>::begin()+i, d);
        return true;
    }
    bool replaceAtIter(QPtrVectorIterator<type> &it, const type *d, bool callDeleteItem=true);
    type *at(uint i) const { return std::vector<type *>::empty() ? 0 : *(std::vector<type *>::begin()+i); }
    type *operator[](uint i) const { return at(i); }
    type *operator[](int i) const { return at((uint) i); }
    type *getFirst() const { return std::vector<type *>::empty() ? 0 : std::vector<type *>::front(); }
    type *getLast() const { return std::vector<type *>::empty() ? 0 : std::vector<type *>::back(); }
    type *first() { return std::vector<type *>::empty() ? 0 : std::vector<type *>::front(); }
    type *last() { return std::vector<type *>::empty() ? 0 : std::vector<type *>::back(); }
    virtual int compareItems(type *a, type *b) const { return (a<b) ? -1 : (a==b) ? 0 : -1; }

    typename std::vector<type *> &int_vector() { return static_cast<std::vector<type *> &>(*this); }
    typename std::vector<type *>::iterator int_begin() { return std::vector<type *>::begin(); }
    typename std::vector<type *>::iterator int_end() { return std::vector<type *>::end(); }

protected:
    virtual void deleteItem(type *d);
};

// Don't delete void *
template<> inline void QPtrVector<void>::deleteItem(void *)
{
}

template<class type> inline void QPtrVector<type>::deleteItem(type *d)
{
    if(autodel) delete d;
}

template<class type> class QPtrVectorIterator
{   // std::vector::iterator is a ptr on some implementations, so play it safe
    typename std::vector<type *>::iterator me;
    mutable bool dead;
    QPtrVector<type> *myvector;
protected:
    type *retptr() const
    {
        if(dead) return 0;
        if(myvector->int_end()==me) { dead=true; return 0; }
        return *me;
    }
public:
    typename std::vector<type *>::iterator &int_getIterator() { return me; }
    QPtrVectorIterator() : dead(true), myvector(0) { }
    QPtrVectorIterator(const QPtrVector<type> &l) : dead(false), myvector(&const_cast<QPtrVector<type> &>(l)), me(const_cast<QPtrVector<type> &>(l).int_begin()) { }
    QPtrVectorIterator(const QPtrVectorIterator<type> &l) : dead(l.dead), myvector(l.myvector), me(l) { }
    QPtrVectorIterator<type> &operator=(const QPtrVectorIterator<type> &it)
    {
        dead=it.dead; myvector=it.myvector;
        me=it.me;
        return *this;
    }
    bool operator==(const QPtrVectorIterator &o) const { return me==o.me; }
    bool operator!=(const QPtrVectorIterator &o) const { return me!=o.me; }
    bool operator<(const QPtrVectorIterator &o) const { return me<o.me; }
    bool operator>(const QPtrVectorIterator &o) const { return me>o.me; }
    uint count() const   { return myvector->count(); }
    bool isEmpty() const { return myvector->isEmpty(); }
    bool atFirst() const
    {
        return myvector->int_begin()==me;
    }
    bool atLast() const
    {
        typename std::vector<type *>::iterator next(me);
        ++next;
        return myvector->int_end()==next;
    }
    type *toFirst()
    {
        me=myvector->int_begin(); dead=false;
        return retptr();
    }
    type *toLast()
    {
        me=myvector->int_end(); dead=false;
        if(!myvector->isEmpty()) --me;
        return retptr();
    }
    QPtrVectorIterator<type> &makeDead()
    {
        me=myvector->int_end();
        dead=true;
        return *this;
    }
    operator type *() const { return retptr(); }
    type *operator*() { return retptr(); }
    type *current() const { return retptr(); }
    type *operator()() { return retptr(); }
    type *operator++()
    {
        ++me;
        return retptr();
    }
    type *operator+=(uint j)
    {
        typename std::vector<type *>::difference_type left=myvector->int_end()-me;
        if(j>left) dead=true; else me+=j;
        return retptr();
    }
    type *operator--()
    {
        if(myvector->int_begin()==me) dead=true; else --me;
        return retptr();
    }
    type *operator-=(uint j)
    {
        typename std::vector<type *>::difference_type left=me-myvector->int_begin();
        if(j>left+1) dead=true; else me-=j;
        return retptr();
    }
};

template<class type> inline bool QPtrVector<type>::insertAtIter(QPtrVectorIterator<type> &it, const type *d)
{
    FXEXCEPTION_STL1 { std::vector<type *>::insert(it.int_getIterator(), const_cast<type *>(d));} FXEXCEPTION_STL2;
    return true;
}

template<class type> inline bool QPtrVector<type>::removeByIter(QPtrVectorIterator<type> &it)
{
    deleteItem(*it.int_getIterator());
    std::vector<type *>::erase(it.int_getIterator());
    return true;
}

template<class type> inline bool QPtrVector<type>::takeByIter(QPtrVectorIterator<type> &it)
{
    std::vector<type *>::erase(it.int_getIterator());
    return true;
}

template<class type> inline bool QPtrVector<type>::replaceAtIter(QPtrVectorIterator<type> &it, const type *d, bool callDeleteItem)
{
    if(callDeleteItem)
        deleteItem(*it);
    *it.int_getIterator()=const_cast<type *>(d);
    return true;
}

#define QVector QPtrVector
#define QVectorIterator QPtrVectorIterator

template<class type> FXStream &operator<<(FXStream &s, const QPtrVector<type> &i)
{
    FXuint mysize=i.count();
    s << mysize;
    for(QPtrVectorIterator<type> it(i); it.current(); ++it)
    {
        s << *it.current();
    }
    return s;
}
template<class type> FXStream &operator>>(FXStream &s, QPtrVector<type> &i)
{
    FXuint mysize;
    s >> mysize;
    i.clear();
    for(uint n=0; n<mysize; n++)
    {
        type *item;
        FXERRHM(item=new type);
        s >> *item;
        i.append(item);
    }
    return s;
}

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.