DynamicArray.h

// $Id: DynamicArray.h 21 2010-09-05 04:18:17Z cschwarz1 $

#ifndef BASE_DYNAMICARRAY_H
#define BASE_DYNAMICARRAY_H

#include <cstdio>   // sprintf
#include <stdexcept>

namespace base {

    template<class T> class DynamicArray {
    public:
        typedef size_t size_type;

        DynamicArray() {
            _array = NULL;
            _size = _used = 0;
        }

        DynamicArray(const DynamicArray<T> &src) {
            _array = NULL;
            _size = _used = 0;
            *this = src;
        }

        ~DynamicArray() {
            if (_array)
                free(_array);
        }


        void add(T item) {
            if (_used >= _size) {
                T         *array;
                size_type  newsize;

                newsize = _used + 16;
                array = static_cast<T*>(_array ? realloc(_array, newsize * sizeof(T)) : malloc(newsize * sizeof(T)));
                if (!array)
                    throw std::bad_alloc();
                _array = array;
                _size = newsize;
            }
            _array[_used++] = item;
        }

        void clear() {
            _used = 0;
        }


        T *data() const {
            return _array;
        }


        bool empty() const {
            return !_used;
        }


        void erase(size_type pos, size_type count = 1) {
            if (pos < _used) {
                if (pos + count > _used)
                    count = _used - pos;
                if (count) {
                    if (pos + count < _used)
                        memmove(_array + pos, _array + pos + count, (_used - (pos + count)) * sizeof(T));
                    _used -= count;
                }
            }
        }


        T get(size_type pos) const {
            if (!_array || pos >= _used) {
                char msg[64];

                sprintf(msg, "DynamicArray index out of range: %u >= %u", pos, _used);
                throw std::out_of_range(msg);
            }
            return _array[pos];
        }


        void set(size_type pos, T item) {
            if (!_array || pos >= _used) {
                char msg[64];

                sprintf(msg, "DynamicArray index out of range: %u >= %u", pos, _used);
                throw std::out_of_range(msg);
            }
            _array[pos] = item;
        }


        size_type size() const {
            return _used;
        }


        T operator[](size_type pos) const {
            return get(pos);
        }


        T &operator[](size_type pos) {
            if (!_array || pos >= _used) {
                char msg[64];

                sprintf(msg, "DynamicArray index out of range: %u >= %u", pos, _used);
                throw std::out_of_range(msg);
            }
            return _array[pos];
        }

        DynamicArray<T> &operator=(const DynamicArray<T> &src) {
            T         *newdata;
            size_type  newsize;

            newdata = src.data();
            newsize = src.size();
            if (newsize > _size) {
                T *array;

                array = static_cast<T*>(_array ? realloc(_array, newsize * sizeof(T)) : malloc(newsize * sizeof(T)));
                if (!array)
                    throw std::bad_alloc();
                _array = array;
                _size = newsize;
            }
            for (_used = 0; _used < size; _used++)
                _array[_used] = newdata[_used];
            return *this;
        }

    private:
        T         *_array; 
        size_type  _size;  
        size_type  _used;  
    };
}

#endif