Subversion Repositories spk

#ifndef EXT_ARRAY_INCLUDED
#define EXT_ARRAY_INCLUDED

#include <memory.h>

namespace ext
{

template <class Ty>
class array
{
        public:
                typedef size_t size_type;
                typedef Ty value_type;
                typedef Ty* value_type_ptr;
                typedef Ty& reference;
                typedef const Ty& const_reference;
                typedef int difference_type;
                
                class const_iterator
                {
                        protected:
                                value_type *m_ptr;
                                
                        public:
                                const_iterator() { }
                                const_iterator(value_type *ptr) { m_ptr=ptr; }
                                const_iterator(const const_iterator& other) { m_ptr=other.m_ptr; }
                                
                                const_iterator& operator ++()   {       m_ptr++; return *this; }
                                const_iterator operator ++(int) {       m_ptr++; return const_iterator(m_ptr - 1); }
                                
                                const_iterator& operator --()   {       m_ptr--; return *this; }
                                const_iterator operator --(int) {       m_ptr--; return const_iterator(m_ptr + 1); }
                                
                                const_reference operator * () const { return *m_ptr; }
                                const_reference operator -> () const { return *m_ptr; }
                                
                                bool operator ==(const_iterator& right) const { return right.m_ptr==m_ptr; }
                                bool operator !=(const_iterator& right) const { return right.m_ptr!=m_ptr; }
                                
                                const_iterator operator + (int i) { return const_iterator(m_ptr + i); }
                };
                
                class iterator : public const_iterator
                {
                        public:
                                iterator() { }
                                iterator(value_type *ptr) : const_iterator(ptr) { }
                                iterator(const iterator& other) : const_iterator(other) { }
                                
                                iterator& operator ++() {       m_ptr++; return *this; }
                                iterator operator ++(int)       {       m_ptr++; return iterator(m_ptr - 1); }
                                
                                iterator& operator --() {       m_ptr--; return *this; }
                                iterator operator --(int)       {       m_ptr--; return iterator(m_ptr + 1); }
                                
                                reference operator * () { return *m_ptr; }
                                reference operator -> () { return *m_ptr; }
                                
                                iterator operator + (int i) { return iterator(m_ptr + i); }
                };
                
        protected:
                value_type *m_first, *m_last, *m_end;
                
        private:
                static const int DEFAULT_GROWBY = 100;
                size_type m_growby;
                
        public:
                size_type size() const { return m_last - m_first; }
                size_type capacity() const { return m_end - m_first; }
                
                size_type growby() const { return m_growby; }
                void growby(size_type grow) { m_growby=grow > 0 ? grow : DEFAULT_GROWBY; }
                
                array() { growby(DEFAULT_GROWBY); m_first=0; clear(); }
                array(size_type size) { growby(DEFAULT_GROWBY); m_first=0; clear(); resize(size); }
                ~array() { delete[] m_first; }
                
                void reserve(size_type newsize)
                {       
                        if(newsize > capacity()){
                                size_t oldsize=size();
                                value_type *newbuf=new value_type[newsize];
                                memcpy(newbuf, m_first, oldsize * sizeof(value_type));
                                delete[] m_first;
                                m_first=newbuf;
                                m_end=m_first + newsize;
                                m_last=m_first + oldsize;
                        }
                }
                
                void resize(size_type newsize)
                {
                        if(newsize==0) return;
                        reserve(newsize);
                        m_last=m_first + newsize;
                }
                
                void resize(size_type newsize, value_type value)
                {
                        resize(newsize);
                        value_type_ptr pos=m_first;
                        for(value_type_ptr pos=m_first; pos < m_last; pos++){
                                *pos=value;
                        }
                }
                
                void clear()
                {
                        delete m_first;
                        m_first=0; m_last=0; m_end=0;
                }
                
                reference operator[](difference_type offset) { return *(m_first + offset); }
                const_reference operator[](difference_type offset) const { return *(m_first + offset); }
                
                reference at(difference_type offset) { return *(m_first + offset); }
                const_reference at(difference_type offset) const { return *(m_first + offset); }
                
                iterator begin() { return iterator(m_first); }
                iterator end() { return iterator(m_last); }
                
                const_iterator begin() const { return const_iterator(m_first); }
                const_iterator end() const { return const_iterator(m_last); }
                
                reference front() { return *begin(); }
                reference back() { return *(--end()); }
                
                const_reference front() const { return *begin(); }
                const_reference back() const { return *(end() - 1); }
                
                iterator push_back(const_reference val)
                {
                        if(size() == capacity())
                                reserve(capacity() + growby());
                        *m_last=val;
                        return iterator(m_last++);
                }
                
                void pop_back()
                {
                        if(size())
                                m_last--;
                }
                
                typedef int compare_callback (const void *, const void *);
                
                void sort(compare_callback *callback)
                {
                        qsort(m_first, size(), sizeof(value_type), callback);
                }
                
                void append(array<value_type>& other)
                {
                        reserve(size() + other.size());
                        memcpy(m_first + size(), other.m_first, other.size() * sizeof(value_type));
                        m_last+=other.size();
                }
                
                iterator find(const_reference what)
                {
                        iterator it;
                        for(it=begin(); it!=end(); ++it){
                                if(*it==what)
                                        break;
                        }
                        return it;
                }
                
                iterator erase(iterator& where)
                {
                        if(where==end()) return where;
                        iterator src=where + 1;
                        iterator dest=where;
                        while(src!=end()){
                                *dest=*src;
                                ++dest; ++src;
                        }
                        m_last--;
                        return where;
                }
};

}; // namespace ext

#endif // !defined(EXT_ARRAY_INCLUDED)