template <class T>
Vector<T>::Vector(void)
: mEntries(0), mlpVectorTable(0), mlpMemPool(0)
{
}

template <class T>
Vector<T>::~Vector()
{
	vectorDelete();
}

void FAR *operator new(size_t /*size*/,int /*n*/,void FAR *lpData)
{
  return lpData;
}

template <class T>
LONG Vector<T>::size(void)const
{
	return mEntries;
}

template <class T>
LONG Vector<T>::size(LONG numEntries)
{
  vectorDelete();
  if(0==(mEntries=numEntries))return 0L;
  vectorNew();
  return mEntries;
}

template <class T>
T &Vector<T>::operator[](LONG itemIndex)
{
	assert(itemIndex<mEntries);
	if(itemIndex>=mEntries)return *((T*)0);
	return *((T FAR *)*(mlpVectorTable+itemIndex));
}

template <class T>
WORD Vector<T>::operator==(const Vector<T> &someVector)const
{
	if(mEntries!=someVector.mEntries)return FALSE;
	for(Index i=0;i<mEntries;i++)
	{
		if(!(*((T FAR *)*(mlpVectorTable+i))==
			 *((T FAR *)*(someVector.mlpVectorTable+i))))return FALSE;
	}
	return TRUE;
}

template <class T>
WORD Vector<T>::operator=(const Vector<T> &someVector)
{
	vectorDelete();
	if(0==(mEntries=someVector.mEntries))return FALSE;
	vectorNew();
	for(Index i=0;i<mEntries;i++)
	{
	 *((T FAR *)*(mlpVectorTable+i))=
			 *((T FAR *)*(someVector.mlpVectorTable+i));
	}
	return TRUE;
}

template <class T>
WORD Vector<T>::operator=(Block<T> &someBlock)
{
	LONG blockSize(someBlock.size());

	if(!blockSize)return FALSE;
	size(blockSize);
	for(Index i=0;i<blockSize;i++)operator[](i)=someBlock[i];
	return TRUE;
}

//template <class T>
//Vector<T>::operator T*()
//{
//	return (T FAR *)mlpMemPool;
//}

template <class T>
void Vector<T>::vectorNew(void)
{
	mlpVectorTable=(T HUGE **)::GlobalLock(::GlobalAlloc(GMEM_ZEROINIT|GMEM_FIXED,mEntries*sizeof(T FAR *)));
	assert(0!=mlpVectorTable);
	mlpMemPool=(T HUGE *)::GlobalLock(::GlobalAlloc(GMEM_ZEROINIT|GMEM_FIXED,mEntries*sizeof(T)));
	assert(0!=mlpMemPool);
	for(Index i=0;i<mEntries;i++)
	{
	  *(mlpVectorTable+i)=(T FAR *)(mlpMemPool+i);
	  new (0,(void FAR *)(mlpMemPool+i)) T;
	  assert(0!=*(mlpVectorTable+i));
	}
}

template <class T>
void Vector<T>::vectorDelete(void)
{
	if(!mlpVectorTable)return;
	if(!mlpMemPool)return;
	for(Index i=0;i<mEntries;i++)(*(mlpVectorTable+i))->~T();
#if defined(__FLAT__)
	::GlobalUnlock(::GlobalHandle(mlpMemPool));
	::GlobalFree(::GlobalHandle(mlpMemPool));
	::GlobalUnlock(::GlobalHandle(mlpVectorTable));
	::GlobalFree(mlpVectorTable);
#else
	::GlobalUnlock((HGLOBAL)(FP_SEG(mlpMemPool)-1));
	::GlobalFree((HGLOBAL)(FP_SEG(mlpMemPool)-1));
	::GlobalUnlock((HGLOBAL)(FP_SEG(mlpVectorTable)-1));
	::GlobalFree((HGLOBAL)(FP_SEG(mlpVectorTable)-1));
#endif
	mlpVectorTable=0;
	mlpMemPool=0;
}