/home/andref/projetos/epos--/include/ep_vector.h

#ifndef EP_VECTOR_H_
#define EP_VECTOR_H_

#include <utility/malloc.h>
#include <algorithm.h>

const unsigned int ADAPTION_RATE = 4;

enum VecType {
        GROWABLE,
        ADAPTABLE,
        STATIC
};

template <class Heritor, class Contained>
struct VectorPrivate {
        VectorPrivate(unsigned int s, unsigned int c) : size(s), capacity(c) {
                elements = (Contained*) malloc(sizeof(Contained) * capacity);
        }

        inline void pushBack(const Contained& contained) { static_cast<Heritor&>(*this).pushBack(contained); }
        inline Contained& popBack() { return static_cast<Heritor&>(*this).popBack(); }

        void enlarge() {
                capacity *= ADAPTION_RATE;
                Contained* newElements = (Contained*) malloc(
                                sizeof(Contained) * capacity);

                copy(&elements[0], &elements[size], newElements);
                free(elements);

                elements = newElements;
        }

        void minimize() {
                capacity /= ADAPTION_RATE;
                Contained* newElements = (Contained*) malloc(
                                sizeof(Contained) * capacity);

                copy(&elements[0], &elements[size], newElements);
                free(elements);

                elements = newElements;
        }

        Contained* elements;
        unsigned int size;
        unsigned int capacity;
};

template <VecType tp, class Contained>
struct VecBehaviour :
                public VectorPrivate<VecBehaviour<tp, Contained>, Contained > {};

template<class Contained>
struct VecBehaviour<GROWABLE, Contained> :
                public VectorPrivate<VecBehaviour<GROWABLE, Contained>, Contained> {

        inline VecBehaviour() : VectorPrivate<VecBehaviour<GROWABLE, Contained>, Contained>(0, 1) {}
        inline VecBehaviour(unsigned int s, unsigned int c) : VectorPrivate<VecBehaviour<GROWABLE, Contained>, Contained>(s, c) {}

        inline void pushBack(const Contained& contained) {
                if (this->size == this->capacity) this->enlarge();
                this->elements[this->size++] = contained;
        }

        inline Contained& popBack() {
                --this->size;
                return this->elements[this->size];
        }
};

template<class Contained>
struct VecBehaviour<ADAPTABLE, Contained> :
                public VectorPrivate<VecBehaviour<ADAPTABLE, Contained>, Contained> {

        inline VecBehaviour() : VectorPrivate<VecBehaviour<ADAPTABLE, Contained>, Contained>(0, 1) {}
        inline VecBehaviour(unsigned int s, unsigned int c) : VectorPrivate<VecBehaviour<ADAPTABLE, Contained>, Contained>(s, c) {}

        inline void pushBack(const Contained& contained) {
                if (this->size == this->capacity) this->enlarge();
                this->elements[this->size++] = contained;
        }

        inline Contained& popBack() {
                --this->size;
                if (this->size <= this->capacity/ADAPTION_RATE) this->minimize();
                return this->elements[this->size];
        }
};

template<class Contained>
struct VecBehaviour<STATIC, Contained> :
                public VectorPrivate<VecBehaviour<STATIC, Contained>, Contained> {

        inline VecBehaviour() : VectorPrivate<VecBehaviour<STATIC, Contained>, Contained>(0, 1) {}
        inline VecBehaviour(unsigned int s, unsigned int c) : VectorPrivate<VecBehaviour<STATIC, Contained>, Contained>(s, c) {}

        inline void pushBack(const Contained& contained) {
                this->elements[this->size++] = contained;
        }

        inline Contained& popBack() {
                --this->size;
                return this->elements[this->size];
        }
};

template <class Contained, VecType tp = GROWABLE>
class Vector {
public:
        template<class ItTp>
        struct Incrementor {
                Incrementor(ItTp* p) : pointer(p) {}

                inline Incrementor operator+(int sum) {
                        pointer += sum;
                        return Incrementor(pointer);
                }


                inline Incrementor operator++(int) {
                        return Incrementor(pointer++);
                }

                inline void operator++() {
                        ++pointer;
                }

                inline void operator--() {
                        --pointer;
                }


                inline Incrementor operator--(int) {
                        return Incrementor(pointer--);
                }

                inline ItTp& operator*() const {
                        return *pointer;
                }

                inline bool operator==(const Incrementor& comparable) const {
                        return (comparable.pointer == pointer);
                }

                inline bool operator!=(const Incrementor& comparable) const {
                        return !operator==(comparable);
                }

                ItTp* pointer;
        };

        typedef Incrementor<Contained> Iterator;
        typedef Incrementor<const Contained> ConstIterator;

        Vector() : _p() {}

        Vector(unsigned int capacity) : _p(0, capacity) {}

        ~Vector() {
                free(_p.elements);
        }

        inline void pushBack(const Contained& contained) {
                _p.pushBack(contained);
        }

        inline Contained& popBack() {
                return _p.popBack();
        }

        inline Contained& getFront() const {
                return _p.elements[0];
        }

        inline Contained& getBack() const {
                return _p.elements[_p.size - 1];
        }

        template<class IteratorTp>
        Contained& remove(const IteratorTp& it) {
                Contained* element = &*it;

                if (element == &getBack()) return popBack();

                shift(element, _p.elements[_p.size], -1);
        }

        inline unsigned int capacity() const {
                return _p.capacity;
        }

        inline unsigned int size() const {
                return _p.size;
        }

        inline bool isEmpty() const {
                return (size() == 0);
        }

        Iterator begin() {
                return Iterator(&_p.elements[0]);
        }

        Iterator end() {
                return begin() + _p.size;
        }

        ConstIterator begin() const {
                return Iterator(&_p.elements[0]);
        }

        ConstIterator end() const {
                return begin() + _p.size;
        }

protected:
        VecBehaviour<tp, Contained> _p;
};

#endif

---