/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 */


#ifndef VECTOR_H
#define VECTOR_H

#include <stddef.h>
#include <limits.h>

#include "assert.H"
#include "memory_handler.H"
#include "utilities.H"
#include "system_size.H"

#define PTRDIFF_T_MAX INT_MAX
#define PTRDIFF_T_MIN INT_MIN

template <class T> 
class BaseVector
{
protected:
    T* first;
    T* last;
    BaseVector() : first(0), last(0) {}
    BaseVector(BaseVector<T>&) {}
public:
    size_t size() const      { return last - first; }
    int isEmpty() const      { return size() == 0; }
    int isNotEmpty() const   { return size() != 0; }
    T* begin() const         { return first; }
    T* end() const           { return last; }
    int operator==(const BaseVector<T>& x) const
    {
	return size() == x.size() && equal(begin(), end(), x.begin());
    }
    int operator!=(const BaseVector<T>& x) const { return !(*this == x); }
    T& operator[](ptrdiff_t n) 
    { 
//	assert(0 <= n && n < size());
	return begin()[n];
    }
};

template <class T> 
class SimpleVector : public BaseVector<T>
{
protected:
    void allocate(size_t n)
    {
	first = Allocator<T>()(n);
	last = first + n;
    }
public:
    SimpleVector() {}
    SimpleVector(size_t n)   { allocate(n); }
    SimpleVector(const SimpleVector<T>& x)
    {
	allocate(x.size());
	move(x.begin(), x.end(), begin());
    }
    SimpleVector<T>& operator=(const SimpleVector<T>& x)
    {
	if (this != &x) {
	    if (size() != x.size()) {
		delete [] first;
		allocate(x.size());
	    }
	    move(x.begin(), x.end(), begin());
	}
	return *this;
    }
    ~SimpleVector()          { delete [] first; }
};

template <class T> 
class Vector : public BaseVector<T>
{
protected:
    T* endOfStorage;
    void rawAllocate(size_t n, size_t m)
    {
	first = (T*)memalloc(sizeof(T) * m);
	last = first + n;
	endOfStorage = first + m;
    }
    size_t storageSize() { return endOfStorage - first; }
    int isFull() { return last == endOfStorage; }
    void reallocate()
    {
	T* oldFirst = begin();
	T* oldLast = end();
	rawAllocate(size(), 
		    storageSize() ? 2 * storageSize() : INITIAL_VECTOR_SIZE);
	move(oldFirst, oldLast, PointerToRawStorage<T>(begin()));
	forEach(oldFirst, oldLast, ExplicitDestructor<T>());
	::delete(oldFirst);
    }
public:
    Vector() : endOfStorage(0) {}
    Vector(const Vector<T>& x)
    {
	rawAllocate(x.size(), x.size());
	move(x.begin(), x.end(), PointerToRawStorage<T>(begin()));
    } 
    Vector(const BaseVector<T>& x)
    {
	rawAllocate(x.size(), x.size());
	move(x.begin(), x.end(), PointerToRawStorage<T>(begin()));
    }
    Vector<T>& operator=(const Vector<T>& x)
    {
	if (this != &x) {
	    forEach(begin(), end(), ExplicitDestructor<T>());
	    if (size() < x.size()) {
		::delete(begin()); 
		rawAllocate(x.size(), x.size());
	    }
	    move(x.begin(), x.end(), PointerToRawStorage<T>(begin()));
	}
	return *this;
    }
    Vector<T>& operator=(const BaseVector<T>& x)
    {
	if (this != &x) {
	    forEach(begin(), end(), ExplicitDestructor<T>());
	    if (size() < x.size()) {
		::delete(begin()); 
		rawAllocate(x.size(), x.size());
	    }
	    move(x.begin(), x.end(), PointerToRawStorage<T>(begin()));
	}
	return *this;
    }
    ~Vector()                
    { 
	forEach(begin(), end(), ExplicitDestructor<T>());
	::delete(begin());
    }
    void insertAtEnd(T& x)
    {
	if (isFull()) reallocate();
	PointerToRawStorage<T>(last++) = x;
    }
    void deleteFromEnd()
    {
	if(isNotEmpty())
	    ExplicitDestructor<T>()(*--last);
    }
    void insert(T* position, T& x)
    {
	if (isFull()) reallocate();
	if (position != last) {
	    PointerToRawStorage<T>(last) = *(last - 1);
	    moveBackward(position, last - 1, last);
	}
	*position = x;
	last++;
    }
    void erase(T* position)
    {
	if (position != end()) {
	    move(position + 1, end(), position);
	    ExplicitDestructor<T>()(*--last);
	}
    }
};

#endif