#ifndef __VECTORX_AMV
	#define __VECTORX_AMV

#include "vector.h"

namespace amv	{

template <class type>
class vectorx: public vector<type> {
public:

	//Constructores:
	vectorx();
	explicit vectorx(vector<type>::size_type sourceSize, const type &sourceValue=type());
	template <class In>
	vectorx(In itB, In itE):
	vector<type>(itB,itE)
		{
		}
	vectorx(const vectorx<type> &v);
	//~vectorx();

	void resizeI(vector<type>::size_type newSize, const type &pad=type());

	//Operaciones de cola:
	void push_front(const type &newObject);
	void pop_front();

};

//Constructores:

template <class type>
inline vectorx<type>::vectorx(): vector<type>()
{ 
}

template <class type>
inline vectorx<type>::vectorx(vector<type>::size_type sourceSize, const type &sourceValue):
vector<type>(sourceSize,sourceValue)
{
}

template <class type>
inline vectorx<type>::vectorx(const vectorx<type> &v):
vector<type>(v)
{
}
/*
template <class type>
inline vectorx<type>::~vectorx()
{
//llamar al destructor de vector?
}
*/
template <class type>
inline void vectorx<type>::resizeI(vector<type>::size_type newSize, const type &pad)
{
if(!newSize)
	{
	alloc.deallocate(ptr);
	ptr=0;
	m_size=0;
	return;
	}
if(newSize==m_size)
	return;

size_type i;
if(!ptr)
	{
	*this=vectorx<type>(newSize,pad);
	return;
	}

type *pNewPtr=alloc.allocate(newSize), *pTemp=pNewPtr, *pTemp1=ptr;

pTemp+=newSize-1;
pTemp1+=m_size-1;

if(newSize>m_size)
	{
	for(i=0; i<m_size; ++i)
		{
		alloc.construct(pTemp,*pTemp1);
		--pTemp;
		--pTemp1;
		}
	for(; i<newSize; ++i)
		{
		alloc.construct(pTemp,pad);
		--pTemp;
		}
	}
else
	{
	for(i=0; i<newSize; ++i)
		{
		alloc.construct(pTemp,*pTemp1);
		--pTemp;
		--pTemp1;
		}
	}		

alloc.deallocate(ptr);
ptr=pNewPtr;
m_size=newSize;
}


//Operaciones de cola:

template <class type>
inline void vectorx<type>::push_front(const type &newObject)
{
type *newPtr=alloc.allocate(m_size+1);
type *pTemp1=newPtr+1, *pTemp2=ptr, *pEnd=ptr+m_size;
*newPtr=newObject;
while(pTemp2!=pEnd)
	*pTemp1++=*pTemp2++;
alloc.deallocate(ptr);
ptr=newPtr;
++m_size;
}

template <class type>
inline void vectorx<type>::pop_front()
{
type *newPtr=alloc.allocate(--m_size);
type *pTemp1=newPtr, *pTemp2=ptr+1, *pEnd=newPtr+m_size;
while(pTemp1!=pEnd)
	*pTemp1++=*pTemp2++;
alloc.deallocate(ptr);
ptr=newPtr;
}

}

#endif