qptrlist.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                 Q t   P o i n t e r   L i s t   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 QPTRLIST_H
#define QPTRLIST_H

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

#include "qvaluelist.h"
#include "FXException.h"
#include "FXStream.h"

namespace FX {

typedef FXuint uint;

template<class type, class allocator=FX::aligned_allocator<type *, 0> > class QPtrListIterator;
template<class type, class allocator=FX::aligned_allocator<type *, 0> > class QPtrList;
template<class type, class allocator> class QPtrList : protected std::list<type *, allocator>
{
public:     // For other stuff to access
    typedef std::list<type *, allocator> Base;
private:
    bool autodel;
    typename Base::iterator int_idx(uint i)
    {
        typename Base::iterator it=Base::begin();
        while(i--) ++it;
        return it;
    }
public:
    explicit QPtrList(bool wantAutoDel=false) : autodel(wantAutoDel), Base() {}
    explicit QPtrList(Base &l) : autodel(false), Base(l) {}
    ~QPtrList() { clear(); }
    FXADDMOVEBASECLASS(QPtrList, Base)
    bool autoDelete() const { return autodel; }
    void setAutoDelete(bool a) { autodel=a; }

    uint count() const { return (uint) Base::size(); }
    bool isEmpty() const { return Base::empty(); }
    bool insert(uint i, const type *d) { FXEXCEPTION_STL1 { Base::insert(int_idx(i), d); } FXEXCEPTION_STL2; return true; }
    bool insertAtIter(QPtrListIterator<type, allocator> &it, const type *d);
    void inSort(const type *d)
    {
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            if(compareItems(*it, d)>=0)
            {
                FXEXCEPTION_STL1 { Base::insert(it, d); } FXEXCEPTION_STL2;
            }
        }
    }
    void prepend(const type *d) { FXEXCEPTION_STL1 { Base::push_front(const_cast<type *>(d)); } FXEXCEPTION_STL2; }
    void append(const type *d) { FXEXCEPTION_STL1 { Base::push_back(const_cast<type *>(d)); } FXEXCEPTION_STL2; }
    bool remove(uint i)
    {
        if(isEmpty()) return false;
        typename Base::iterator it=int_idx(i);
        deleteItem(*it);
        Base::erase(it);
        return true;
    }
    bool remove(const type *d)
    {
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            if(0==compareItems(*it, const_cast<type *>(d)))
            {
                deleteItem(*it);
                Base::erase(it);
                return true;
            }
        }
        return false;
    }
    bool removeRef(const type *d)
    {
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            if(*it==d)
            {
                deleteItem(*it);
                Base::erase(it);
                return true;
            }
        }
        return false;
    }
    bool removeByIter(QPtrListIterator<type, allocator> &it);
    bool removeFirst()
    {
        if(isEmpty()) return false;
        typename Base::iterator it=Base::begin();
        deleteItem(*it);
        Base::pop_front();
        return true;
    }
    bool removeLast()
    {
        if(isEmpty()) return false;
        typename Base::iterator it=--Base::end();
        deleteItem(*it);
        Base::pop_back();
        return true;
    }
    type *take(uint i)
    {
        if(isEmpty()) return 0; // Fails for non-pointer types
        typename Base::iterator it=int_idx(i);
        type *ret=*it;
        Base::erase(it);
        return ret;
    }
    bool take(const type *d)
    {
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            if(0==compareItems(*it, const_cast<type *>(d)))
            {
                Base::erase(it);
                return true;
            }
        }
        return false;
    }
    bool takeByIter(QPtrListIterator<type, allocator> &it);
    bool takeRef(const type *d)
    {
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            if(*it==d)
            {
                Base::erase(it);
                return true;
            }
        }
        return false;
    }
    bool takeFirst()
    {
        if(isEmpty()) return false;
        typename Base::iterator it=Base::begin();
        Base::pop_front();
        return true;
    }
    bool takeLast()
    {
        if(isEmpty()) return false;
        typename Base::iterator it=--Base::end();
        Base::pop_back();
        return true;
    }
    void clear()
    {
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            deleteItem(*it);
        }
        Base::clear();
    }
private:
    template<class type2> struct swapPolicy
    {
        template<class L, class I> void swap(L &list, I &a, I &b) const
        {   // Simply swap the pointers
            type2 temp=*a;
            *a=*b;
            *b=temp;
        }
    };
    template<class type2> struct comparePolicyFunc
    {
        bool (*comparer)(type2 a, type2 b);
        template<class L, class I> bool compare(L &list, I &a, I &b) const
        {
            return comparer(*a, *b);
        }
    };
    template<class type2> struct comparePolicyMe
    {
        template<class L, class I> bool compare(L &list, I &a, I &b) const
        {
            return ((QPtrList<type2> &) *this).compareItems(*a, *b)==-1;
        }
    };
public:
    template<typename SortFuncSpec> void sort(SortFuncSpec sortfunc)
    {   // Would use Base::sort but this is faster
        QValueListQSort<type *, Pol::itMove, swapPolicy, comparePolicyFunc> sorter((QValueList<type *> &) *this);
        //sorter.comparer=sortfunc;
        sorter.run();
    }
    void sort()
    {
        QValueListQSort<type *, Pol::itMove, swapPolicy, comparePolicyMe> sorter((QValueList<type *> &) *this);
        sorter.run();
    }
    int find(const type *d)
    {
        int idx=0;
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it, ++idx)
        {
            if(0==compareItems(*it, d)) return idx;
        }
        return -1;
    }
    int findRef(const type *d)
    {
        int idx=0;
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it, ++idx)
        {
            if(*it==d) return idx;
        }
        return -1;
    }
    uint contains(const type *d) const
    {
        uint count=0;
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            if(0==compareItems(*it, d)) count++;
        }
        return count;
    }
    uint containsRef(const type *d) const
    {
        uint count=0;
        for(typename Base::iterator it=Base::begin(); it!=Base::end(); ++it)
        {
            if(*it==d) count++;
        }
        return count;
    }
    bool replace(uint i, const type *d)
    {
        if(isEmpty()) return false;
        typename Base::iterator it=int_idx(i);
        *it=d;
        //list<type *>::erase(list<type *>::begin()+i);
        //list<type *>::insert(list<type *>::begin()+i, d);
        return true;
    }
    bool replaceAtIter(QPtrListIterator<type, allocator> &it, const type *d);
    type *at(uint i) { return Base::empty() ? 0 : *int_idx(i); }
    type *getFirst() const { return Base::empty() ? 0 : Base::front(); }
    type *getLast() const { return Base::empty() ? 0 : Base::back(); }
    type *first() { return Base::empty() ? 0 : Base::front(); }
    type *last() { return Base::empty() ? 0 : Base::back(); }
    virtual int compareItems(type *a, type *b) const { return (a<b) ? -1 : (a==b) ? 0 : -1; }

    Base &int_list() { return static_cast<Base &>(*this); }
    typename Base::iterator int_begin() { return Base::begin(); }
    typename Base::iterator int_end() { return Base::end(); }

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

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

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

template<class type, class allocator> class QPtrListIterator : private std::list<type *, allocator>::iterator
{
    typedef std::list<type *, allocator> Base;
    mutable bool dead;
    QPtrList<type, allocator> *mylist;
protected:
    type *retptr() const
    {
        if(dead) return 0;
        typename Base::iterator &me=const_cast<QPtrListIterator<type, allocator> &>(*this);
        if(mylist->int_end()==me) { dead=true; return 0; }
        return *me;
    }
public:
    typename Base::iterator &int_getIterator() { return static_cast<typename Base::iterator &>(*this); }
    QPtrListIterator() : dead(true), mylist(0) { }
    QPtrListIterator(const QPtrList<type, allocator> &l) : dead(false), mylist(&const_cast<QPtrList<type, allocator> &>(l)), Base::iterator(const_cast<QPtrList<type, allocator> &>(l).int_begin()) { retptr(); }
    QPtrListIterator(const QPtrListIterator<type, allocator> &l) : dead(l.dead), mylist(l.mylist), Base::iterator(l) { }
    QPtrListIterator<type, allocator> &operator=(const QPtrListIterator<type, allocator> &it)
    {
        dead=it.dead; mylist=it.mylist;
        typename Base::iterator &me=*this;
        me=it;
        return *this;
    }
    bool operator==(const QPtrListIterator &o) const { return static_cast<typename Base::iterator const &>(*this)==o; }
    bool operator!=(const QPtrListIterator &o) const { return static_cast<typename Base::iterator const &>(*this)!=o; }
    bool operator<(const QPtrListIterator &o) const { return static_cast<typename Base::iterator const &>(*this)<o; }
    bool operator>(const QPtrListIterator &o) const { return static_cast<typename Base::iterator const &>(*this)>o; }
    uint count() const   { return mylist->count(); }
    bool isEmpty() const { return mylist->isEmpty(); }
    bool atFirst() const
    {
        typename Base::iterator &me=const_cast<QPtrListIterator<type, allocator> &>(*this);
        return mylist->int_begin()==me;
    }
    bool atLast() const
    {
        typename Base::iterator next=*this;
        ++next;
        return mylist->int_end()==next;
    }
    type *toFirst()
    {
        typename Base::iterator &me=const_cast<QPtrListIterator<type, allocator> &>(*this);
        me=mylist->int_begin(); dead=false;
        return retptr();
    }
    type *toLast()
    {
        typename Base::iterator &me=const_cast<QPtrListIterator<type, allocator> &>(*this);
        me=mylist->int_end(); dead=false;
        if(!mylist->isEmpty()) --me;
        return retptr();
    }
    QPtrListIterator<type, allocator> &makeDead()
    {
        typename Base::iterator &me=const_cast<QPtrListIterator<type, allocator> &>(*this);
        me=mylist->int_end();
        dead=true;
        return *this;
    }
    type *operator*() const { return retptr(); }
    type *current() const { return retptr(); }
    type *operator++()
    {
        if(!dead)
        {
            typename Base::iterator &me=int_getIterator(); ++me;
        }
        return retptr();
    }
    type *operator+=(uint j)
    {
        if(!dead)
        {
            typename Base::iterator &me=*this;
            typename Base::iterator myend=mylist->int_end();
            for(uint n=0; n<j && me!=myend; n++)
                ++me;
        }
        return retptr();
    }
    type *operator--()
    {
        if(!dead)
        {
            typename Base::iterator &me=*this;
            if(mylist->int_begin()==me)
            {
                me=mylist->int_end();
                dead=true;
            }
            else --me;
        }
        return retptr();
    }
    type *operator-=(uint j)
    {
        if(!dead)
        {
            typename Base::iterator &me=*this;
            typename Base::iterator myend=mylist->int_begin();
            for(uint n=0; n<j && !dead; n++)
            {
                if(myend==me)
                {
                    me=mylist->int_end();
                    dead=true;
                }
                else --me;
            }
        }
        return retptr();
    }
};

template<class type, class allocator> inline bool QPtrList<type, allocator>::insertAtIter(QPtrListIterator<type, allocator> &it, const type *d)
{
    FXEXCEPTION_STL1 { Base::insert(it.int_getIterator(), const_cast<type *>(d));} FXEXCEPTION_STL2;
    return true;
}

template<class type, class allocator> inline bool QPtrList<type, allocator>::removeByIter(QPtrListIterator<type, allocator> &it)
{
    deleteItem(*it.int_getIterator());
    Base::erase(it.int_getIterator());
    return true;
}

template<class type, class allocator> inline bool QPtrList<type, allocator>::takeByIter(QPtrListIterator<type, allocator> &it)
{
    Base::erase(it.int_getIterator());
    return true;
}

template<class type, class allocator> inline bool QPtrList<type, allocator>::replaceAtIter(QPtrListIterator<type, allocator> &it, const type *d)
{
    *it.int_getIterator()=const_cast<type *>(d);
    return true;
}

#define QList QPtrList
#define QListIterator QPtrListIterator

template<class type, class allocator> FXStream &operator<<(FXStream &s, const QPtrList<type, allocator> &i)
{
    FXuint mysize=i.count();
    s << mysize;
    for(QPtrListIterator<type, allocator> it(i); it.current(); ++it)
    {
        s << *it.current();
    }
    return s;
}
template<class type, class allocator> FXStream &operator>>(FXStream &s, QPtrList<type, allocator> &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;
}

template<class type, class allocator=FX::aligned_allocator<type *, 0> > class QQuickListIterator;
template<class type, class allocator=FX::aligned_allocator<type *, 0> > class QQuickList;
template<class type, class allocator> class QQuickList : protected QPtrList<type, allocator>
{
    typedef QPtrList<type, allocator> Base;
    friend class QQuickListIterator<type, allocator>;
public:
    QQuickList() : QPtrList<type, allocator>(true) { }
#ifndef HAVE_CPP0XRVALUEREFS
#ifdef HAVE_CONSTTEMPORARIES
    QQuickList(const QQuickList &_o) : QPtrList<type, allocator>(true)
    {
        QQuickList &o=const_cast<QQuickList &>(_o);
#else
    QQuickList(QQuickList &o) : QPtrList<type, allocator>(true)
    {
#endif
#else
private:
    QQuickList(const QQuickList &);     // disable copy constructor
public:
    QQuickList(QQuickList &&o) : QPtrList<type, allocator>(true)
    {
#endif
        Base::splice(Base::begin(), o, o.begin(), o.end());
    }
#ifndef HAVE_CPP0XRVALUEREFS
    QQuickList &operator=(QQuickList &o)
#else
private:
    QQuickList &operator=(QQuickList &o);
public:
    QQuickList &&operator=(QQuickList &&o)
#endif
    {
        clear();
        Base::splice(Base::begin(), o, o.begin(), o.end());
        return *this;
    }
#ifndef HAVE_CPP0XRVALUEREFS
#ifdef HAVE_CONSTTEMPORARIES
    explicit QQuickList(const QPtrList<type, allocator> &_o) : QPtrList<type, allocator>(true)
    {
        QPtrList<type, allocator> &o=const_cast<QPtrList<type, allocator> &>(_o);
#else
    explicit QQuickList(QPtrList<type, allocator> &o) : QPtrList<type, allocator>(true)
    {
#endif
#else
    explicit QQuickList(QPtrList<type, allocator> &&o) : QPtrList<type, allocator>(true)
    {
#endif
        Base::splice(Base::begin(), o, o.begin(), o.end());
    }
    const QPtrList<type, allocator> &asPtrList() const throw()
    {
        return static_cast<QPtrList<type, allocator> &>(*this);
    }
    using QPtrList<type, allocator>::count;
    using QPtrList<type, allocator>::isEmpty;
    using QPtrList<type, allocator>::insert;
    using QPtrList<type, allocator>::insertAtIter;
    using QPtrList<type, allocator>::inSort;
    using QPtrList<type, allocator>::prepend;
    using QPtrList<type, allocator>::append;
    using QPtrList<type, allocator>::remove;
    using QPtrList<type, allocator>::removeRef;
    using QPtrList<type, allocator>::removeByIter;
    using QPtrList<type, allocator>::removeFirst;
    using QPtrList<type, allocator>::removeLast;
    using QPtrList<type, allocator>::take;
    using QPtrList<type, allocator>::takeRef;
    using QPtrList<type, allocator>::clear;
    using QPtrList<type, allocator>::sort;
    using QPtrList<type, allocator>::find;
    using QPtrList<type, allocator>::findRef;
    using QPtrList<type, allocator>::contains;
    using QPtrList<type, allocator>::containsRef;
    using QPtrList<type, allocator>::replace;
    using QPtrList<type, allocator>::at;
    using QPtrList<type, allocator>::getFirst;
    using QPtrList<type, allocator>::getLast;
    using QPtrList<type, allocator>::first;
    using QPtrList<type, allocator>::last;
    using QPtrList<type, allocator>::compareItems;
    using QPtrList<type, allocator>::int_list;
    using QPtrList<type, allocator>::int_begin;
    using QPtrList<type, allocator>::int_end;

    friend FXStream &operator<<(FXStream &s, const QQuickList<type> &_i)
    {
        const QPtrList<type, allocator> &i=_i;
        s << i;
        return s;
    }
    friend FXStream &operator>>(FXStream &s, QQuickList<type> &_i)
    {
        QPtrList<type, allocator> &i=_i;
        s >> i;
        return s;
    }
};

template<class type, class allocator> class QQuickListIterator : public QPtrListIterator<type, allocator>
{
public:
    QQuickListIterator(const QQuickList<type, allocator> &l) : QPtrListIterator<type, allocator>(l) { }
};

} // namespace

#endif

---

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