TpArray.h

Go to the documentation of this file.

// $Id: TpArray.h 182 2006-06-07 17:48:14Z bingmann $

#ifndef VGS_TpArray_H
#define VGS_TpArray_H

#include <stdlib.h>
#include <assert.h>

namespace VGServer {

template <typename Tp>
class TpArray
{
public:
    // *** STL-like typedefs

    typedef TpArray<Tp> tparray;

    typedef Tp value_type;

    typedef value_type& reference;

    typedef const value_type& const_reference;

    typedef value_type* pointer;

    typedef const value_type const_pointer;

    typedef Tp* iterator;

    typedef const Tp* const_iterator;

    typedef unsigned int size_type;

private:
    Tp*         _begin;

    Tp*         _end;

    Tp*         _finish;

public:
    inline TpArray()
        : _begin(NULL), _end(NULL), _finish(NULL)
    {
    }

    explicit inline TpArray(size_type _reserve)
        : _begin(NULL), _end(NULL), _finish(NULL)
    {
        if (_reserve) reserve(0);
    }
    
    inline TpArray(const tparray &other)
        : _begin(NULL), _end(NULL), _finish(NULL)
    {
        reserve(other.size());
        iterator i = begin();
        for(const_iterator o = other.begin(); o != other.end(); o++, i++) {
            // reads: create a new object at the position i within our array by
            // copy-constructing a Tp object from the other array.
            new (i) value_type (*o);
        }
        set_size(other.size());
    }

    inline ~TpArray()
    {
        clear();
        if (_begin)
        {
            free(_begin);
            _begin = NULL;
        }
    }

    inline tparray& operator= (const tparray& other)
    {
        if (*this != other)
        {
            clear();
            reserve(other.size());
            iterator i = begin();
            for(const_iterator o = other.begin(); o != other.end(); o++, i++) {
                // reads: create a new object at the position i within our array by
                // copy-constructing a Tp object from the other array.
                new (i) value_type (*o);
            }
            set_size(other.size());
        }
        return *this;
    }

    inline size_type capacity() const
    { return size_type(_finish - _begin); }
    
    inline size_type size() const
    { return size_type(_end - _begin); }

    inline bool empty() const
    { return begin() == end(); }

    inline void reserve(size_type n)
    {
        if (capacity() < n)
        {
            size_type used = size();
            
            // calculate a new capacity
            size_type newcap = capacity();
            while(newcap < n) {
                if (newcap < 512) newcap = 512;
                else if (newcap < 1024*1024) newcap = 2 * newcap;
                else newcap += 1024*1024;
            }

            // reallocate memory and set new pointers
            _begin = static_cast<Tp*>(realloc(_begin, newcap * sizeof(Tp)));
            _end = _begin + used;
            _finish = _begin + newcap;
        }
    }

    inline void set_size(size_type n)
    { assert(n <= capacity()); _end = _begin + n; }

    inline iterator begin()
    { return iterator(_begin); }

    inline const_iterator begin() const
    { return const_iterator(_begin); }

    inline iterator end()
    { return iterator(_end); }

    inline const_iterator end() const
    { return const_iterator(_end); }

    inline void clear()
    {
        for(iterator i = begin(); i != end(); i++) {
            i->~Tp();
        }
        _end = _begin;
    }

    inline reference operator[](size_type n)
    { assert(n < size()); return *(begin() + n); }

    inline const_reference operator[](size_type n) const
    { assert(n < size()); return *(begin() + n); }

    inline reference last()
    { assert(size() > 0); return *(end() - 1); }

    inline const_reference last() const
    { assert(size() > 0); return *(end() - 1); }

    inline reference new_back()
    {
        if (capacity() < size() + 1) reserve(size() + 1);

        pointer newobj = new (_end) value_type();
        _end++;
        return *newobj;
    }

    inline void push_back(const_reference obj)
    {
        if (capacity() < size() + 1) reserve(size() + 1);

        new (_end) value_type(obj);
        _end++;
    }

    inline void swap(tparray &other)
    {
        std::swap(_begin, other._begin);
        std::swap(_end, other._end);
        std::swap(_finish, other._finish);
    }
};

} // namespace VGServer

#endif // VGS_TpArray_H

---