qmemarray.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                          Q t   A r r a y   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 QMEMARRAY_H
#define QMEMARRAY_H

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

namespace FX {

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

namespace QGArray {
typedef int Optimization;
}

template<typename type, class allocator> class QMemArray : private std::vector<type, allocator>
{
    typedef std::vector<type, allocator> Base;
private:
    type *extArray;
    FXuval extArrayLen;
    bool noDeleteExtArray;
    typename Base::const_iterator int_retIndex(const type &d) const
    {
        typename Base::const_iterator it;
        for(it=begin(); it!=end(); ++it)
            if(*it==d) return it;
        return it;
    }
public:
    typedef type * Iterator;
    typedef type * iterator;
    typedef const type * ConstIterator;
    typedef const type * const_iterator;
    typedef type ValueType;
    QMemArray() : extArray(0), extArrayLen(0), noDeleteExtArray(false), Base() { }
    ~QMemArray()
    {
        if(extArray && !noDeleteExtArray)
        {
            delete[] extArray;
            extArray=0;
        }
    }
    QMemArray(FXuval size) : extArray(0), extArrayLen(0), noDeleteExtArray(false), Base(size) { }
    QMemArray(type *a, FXuval n, bool _noDeleteExtArray=true) : extArray(a), extArrayLen(n), noDeleteExtArray(_noDeleteExtArray) { }
    QMemArray(const QMemArray<type, allocator> &o) : extArray(o.extArray), extArrayLen(o.extArrayLen), noDeleteExtArray(o.noDeleteExtArray), Base(o) { }
    QMemArray<type, allocator> &operator=(const QMemArray<type, allocator> &o) { extArray=o.extArray; extArrayLen=o.extArrayLen; noDeleteExtArray=o.noDeleteExtArray; Base::operator=(o); return *this; }
    FXADDMOVEBASECLASS(QMemArray, Base)

    using Base::capacity;
    //using Base::clear;
    using Base::empty;
    using Base::reserve;

    type *data() const { return (extArray) ? extArray : const_cast<type *>(&Base::front()); }
    operator const type *() const { return data(); }
    FXuval size() const { return (extArray) ? extArrayLen : Base::size(); }
    FXuval count() const { return (extArray) ? extArrayLen : Base::size(); }
    bool isEmpty() const { return isNull(); }
    bool isNull() const { return (extArray) ? extArrayLen!=0 : Base::empty(); }
    bool resize(FXuval size) { FXEXCEPTION_STL1 { Base::resize(size); } FXEXCEPTION_STL2; return true; }
    bool resize(FXuval size, QGArray::Optimization optim) { Base::resize(size); return true; }
    bool truncate(FXuval pos) { FXEXCEPTION_STL1 { Base::resize(pos); } FXEXCEPTION_STL2; return true; }
    void swap(QMemArray<type, allocator> &o)
    {
        Base::swap(o);
        type *_extArray=o.extArray;
        FXuval _extArrayLen=o.extArrayLen;
        bool _noDeleteExtArray=o.noDeleteExtArray;
        o.extArray=extArray;
        o.extArrayLen=extArrayLen;
        o.noDeleteExtArray=noDeleteExtArray;
        extArray=_extArray;
        extArrayLen=_extArrayLen;
        noDeleteExtArray=_noDeleteExtArray;
    }
    bool fill(const type &val, int newsize=-1)
    {
        if(-1!=newsize) resize(newsize);
        for(FXuval n=0; n<size(); n++)
        {
            at(n)=val;
        }
        return true;
    }
    FXDEPRECATEDEXT void detach() { }
    FXDEPRECATEDEXT QMemArray<type, allocator> copy() const { return *this; }
    FXDEPRECATEDEXT QMemArray<type, allocator> &assign(const QMemArray<type, allocator> &o) { Base::operator=(o); return *this; }
    FXDEPRECATEDEXT QMemArray<type, allocator> &assign(const type *a, FXuval n) { return setRawData(a, n); }
    FXDEPRECATEDEXT QMemArray<type, allocator> &duplicate(const QMemArray<type, allocator> &o) { Base::operator=(o); return *this; }
    FXDEPRECATEDEXT QMemArray<type, allocator> &duplicate(const type *a, FXuval n) { return setRawData(a, n); }
    QMemArray<type, allocator> &setRawData(const type *a, FXuval n, bool _noDeleteExtArray=false)
    {
        extArray=const_cast<type *>(a); extArrayLen=n;
        noDeleteExtArray=_noDeleteExtArray;
        return *this;
    }
    void resetRawData(const type *a, FXuval n) { extArray=0; extArrayLen=0; noDeleteExtArray=false; }
    FXival find(const type &val, FXuval i=0) const
    {
        for(; i<size(); i++)
        {
            if(at(i)==val) return i;
        }
        return -1;
    }
    FXival contains(const type &val) const
    {
        FXuval count=0;
        for(FXuval n=0; n<size(); n++)
        {
            if(at(n)==val) count++;
        }
        return count;
    }
private:
    static bool sortPredicate(const type &a, const type &b)
    {
        return a<b;
    }
public:
    void sort()
    {
        if(extArray) throw "Not implemented for external arrays";
        std::sort(Base::begin(), Base::end(), sortPredicate);
    }
    int bsearch(const type &val) const
    {   // God damn std::binary_search doesn't return the position :(
        int lbound=0, ubound=(int)size()-1, c;
        while(lbound<=ubound)
        {
            c=(lbound+ubound)/2;
            const type &cval=at(c);
            if(val==cval)
                return c;
            else if(val<cval)
                ubound=c-1;
            else
                lbound=c+1;
        }
        return -1;
    }
    type &at(FXuval i) const { return (extArray) ? extArray[i] : const_cast<type &>(Base::at(i)); }
    type &operator[](FXuint i) const { return at(i); }
    type &operator[](int i) const { return at((FXuval) i); }
    bool operator==(const QMemArray<type, allocator> &o) const
    {
        if(extArray) throw "Not implemented for external arrays";
        const Base &me=*this;
        return me==o;
    }
    bool operator!=(const QMemArray<type, allocator> &o) const
    {
        if(extArray) throw "Not implemented for external arrays";
        const Base &me=*this;
        return me!=o;
    }
    Iterator begin() { return data(); }
    Iterator end() { return data()+size(); }
    ConstIterator begin() const { return data(); }
    ConstIterator end() const { return data()+size(); }

    void push_back(const type &v) { FXEXCEPTION_STL1 { Base::push_back(v); } FXEXCEPTION_STL2; }
    void append(const type &v) { push_back(v); }
    using Base::pop_back;
};

namespace QMemArrayImpl
{
    template<bool isPOD, typename type, class allocator> struct Serialise
    {
        Serialise(FXStream &s, const QMemArray<type, allocator> &a)
        {
            FXulong mysize=a.size();
            s << mysize;
            for(FXuval i=0; i<mysize; i++)
                s << a.at(i);
        }
    };
    template<typename type, class allocator> struct Serialise<true, type, allocator>
    {
        Serialise(FXStream &s, const QMemArray<type, allocator> &a)
        {
            FXulong mysize=a.size();
            s << mysize;
            s.save(a.data(), (unsigned long) mysize);
        }
    };
    template<bool isPOD, typename type, class allocator> struct Deserialise
    {
        Deserialise(FXStream &s, QMemArray<type, allocator> &a)
        {
            FXulong mysize;
            s >> mysize;
            a.resize((FXuval)mysize);
            for(FXuval i=0; i<mysize; i++)
                s >> a.at(i);
        }
    };
    template<typename type, class allocator> struct Deserialise<true, type, allocator>
    {
        Deserialise(FXStream &s, QMemArray<type, allocator> &a)
        {
            FXulong mysize;
            s >> mysize;
            a.resize((FXuval)mysize);
            s.load(a.data(), (unsigned long) mysize);
        }
    };
}

template<typename type, class allocator> FXStream &operator<<(FXStream &s, const QMemArray<type, allocator> &a)
{
    QMemArrayImpl::Serialise<Generic::TraitsBasic<type>::isPOD, type, allocator>(s, a);
    return s;
}
template<typename type, class allocator> FXStream &operator>>(FXStream &s, QMemArray<type, allocator> &a)
{
    QMemArrayImpl::Deserialise<Generic::TraitsBasic<type>::isPOD, type, allocator>(s, a);
    return s;
}

#define QArray QMemArray

} // namespace

#endif

---

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