// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// $Header$

// Noticed lots of classes want to 'pile' up objects (as in stack 'em) but

// all create their own 'class'. Stuff that for a game of soldiers...

// here's a templated class that serves all!

// mjd, mark@mjdss.com, july 2002

// 

//

#include "CPile.h"

//-----------------------------------------------------------------------------

//	the NewL calls default values (e.g. 16) in ConstructL

template <class T>

CPile<T> * CPile<T>::NewL()

{

CPile* self = NewLC();

CleanupStack::Pop();

return self; 

}

//-----------------------------------------------------------------------------

//	the NewL calls passes desired default size to ConstructL

template <class T>

CPile<T> * CPile<T>::NewL(const TInt &aElements)

{

CPile *self = NewLC(aElements);

CleanupStack::Pop();

return self; 

}

//-----------------------------------------------------------------------------

template <class T>

CPile<T> * CPile<T>::NewLC(const TInt &aElements)

{

CPile *self = new (ELeave) CPile();

CleanupStack::PushL(self);

self->ConstructL(aElements);

return self;

}

//-----------------------------------------------------------------------------

//	destroy the pile of T!

//	not forgetting to delete the stacks contents first!

template <class T>

CPile<T>::~CPile()

{

iPile->ResetAndDestroy();

delete iPile;

iPile = NULL;

}

//-----------------------------------------------------------------------------

//	would be nice to be able to easily specify in the constructor

//	the size of the initial stack...

//	mjd: added in the aElements which is now passed (via default) from NewL

template <class T>

void CPile<T>::ConstructL(const TInt &aElements)

{

iPile = new (ELeave) CArrayPtrSeg<T>(aElements);

}

//-----------------------------------------------------------------------------

//	ok, push an object of class T onto the stack

template <class T>

void CPile<T>::PushL(T *aT)

{

iPile->AppendL(aT);

}

//-----------------------------------------------------------------------------

//	pop an object of class T off the top of the pile (stack) or

//	NULL if nothing to get...

//	note: Count is always 1 more than actual contents of stack...

template <class T>

T *CPile<T>::Pop()

{

TInt count = Count();

if (count > 0)

  {

  T *t = At(--count);

  iPile->Delete(count);

  return t;

  }

else

  return NULL;

}

//-----------------------------------------------------------------------------

//	zap the objcet of class T sitting at the top of the stack

template <class T>

void CPile<T>::Skim()

{

T *t = Pop();

delete t;

}

//-----------------------------------------------------------------------------

//	zap all objects of class T sitting on the stack

template <class T>

void CPile<T>::Empty()

{

while (iPile->Count())

  Skim();

}

//-----------------------------------------------------------------------------

//	How many do we have - this SHOULD be a property!

template <class T>

TInt CPile<T>::Count() const

{

return iPile->Count();

}

//-----------------------------------------------------------------------------

//	get the n'th item in the list 

//	indexed from 0 so [0] is valid.

template <class T>

T *CPile<T>::At(const TInt &aIndex) const

{

if ((aIndex >= 0) || (aIndex < Count()))

	return iPile->At(aIndex);

return NULL;

}

//-----------------------------------------------------------------------------

//	get the [n]'th item in the list 

template <class T>

T *CPile<T>::operator[](const TInt &aIndex) const

{

return At(aIndex);

}

//-----------------------------------------------------------------------------

template <class T>

T *CPile<T>::Peek()

{

TInt count = Count();

if (count > 0)

  {

  T *t = At(--count);

  return t;

  }

return NULL;

}

//-----------------------------------------------------------------------------

//	Template Specialization requirements: CLogFile

//-----------------------------------------------------------------------------

CPile<CLogFile> * CPile<CLogFile>::NewL()

{

CPile *self = NewLC();

CleanupStack::Pop();

return self; 

}

//-----------------------------------------------------------------------------

CPile<CLogFile> *CPile<CLogFile>::NewLC(const TInt &aElements)

{

CPile *self = new (ELeave) CPile();

CleanupStack::PushL(self);

self->ConstructL(aElements);

return self;

}

//-----------------------------------------------------------------------------

void CPile<CLogFile>::ConstructL(const TInt &aElements)

{

iPile = new (ELeave) CArrayPtrSeg<CLogFile>(aElements);

}

//-----------------------------------------------------------------------------

void CPile<CLogFile>::PushL(CLogFile *aT)

{

iPile->AppendL(aT);

}

//-----------------------------------------------------------------------------

CLogFile *CPile<CLogFile>::Pop()

{

TInt count = Count();

if (count > 0)

  {

  CLogFile *t = At(--count);

  iPile->Delete(count);

  return t;

  }

else

  return NULL;

}

//-----------------------------------------------------------------------------

CLogFile *CPile<CLogFile>::At(const TInt &aIndex) const

{

if ((aIndex >= 0) || (aIndex < Count()))

	return (CLogFile *)iPile->At(aIndex);

	//return (CLogFile *) &iPile[aIndex];

return NULL;

}

//-----------------------------------------------------------------------------

TInt CPile<CLogFile>::Count() const

{

return iPile->Count();

}

//-----------------------------------------------------------------------------

CPile<CLogFile>::~CPile()

{

iPile->ResetAndDestroy();

delete iPile;

iPile = NULL;

}

//-----------------------------------------------------------------------------

//	Template Specialization requirements:	CCmdFile

//-----------------------------------------------------------------------------

CPile<CCmdFile> *CPile<CCmdFile>::NewL()

{

CPile *self = NewLC();

CleanupStack::Pop();

return self; 

}

//-----------------------------------------------------------------------------

CPile<CCmdFile> *CPile<CCmdFile>::NewLC(const TInt &aElements)

{

CPile *self = new (ELeave) CPile();

CleanupStack::PushL(self);

self->ConstructL(aElements);

return self;

}

//-----------------------------------------------------------------------------

CPile<CCmdFile>::~CPile()

{

iPile->ResetAndDestroy();

delete iPile;

iPile = NULL;

}

//-----------------------------------------------------------------------------

void CPile<CCmdFile>::ConstructL(const TInt &aElements)

{

iPile = new (ELeave) CArrayPtrSeg<CCmdFile>(aElements);

}

//-----------------------------------------------------------------------------

TInt CPile<CCmdFile>::Count() const

{

return iPile->Count();

}

//-----------------------------------------------------------------------------

CCmdFile *CPile<CCmdFile>::At(const TInt &aIndex) const

{

if ((aIndex >= 0) || (aIndex < Count()))

	return (CCmdFile *)iPile->At(aIndex);

	//return (CCmdFile *) &iPile[aIndex];

return NULL;

}

//-----------------------------------------------------------------------------

void CPile<CCmdFile>::PushL(CCmdFile *aT)

{

iPile->AppendL(aT);

}

//-----------------------------------------------------------------------------

CCmdFile *CPile<CCmdFile>::Pop()

{

TInt count = Count();

if (count > 0)

  {

  CCmdFile *t = At(--count);

  iPile->Delete(count);

  return t;

  }

else

  return NULL;

}

//-----------------------------------------------------------------------------

void CPile<CCmdFile>::Skim()

{

CCmdFile *t = Pop();

delete t;

}

//-----------------------------------------------------------------------------

void CPile<CCmdFile>::Empty()

{

while (iPile->Count())

  Skim();

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//	Template Specialization requirements:	CIFControl

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

CPile<CIFControl> *CPile<CIFControl>::NewL()

{

CPile *self = NewLC();

CleanupStack::Pop();

return self; 

}

//-----------------------------------------------------------------------------

CPile<CIFControl> *CPile<CIFControl>::NewLC(const TInt &aElements)

{

CPile *self = new (ELeave) CPile();

CleanupStack::PushL(self);

self->ConstructL(aElements);

return self;

}

//-----------------------------------------------------------------------------

void CPile<CIFControl>::ConstructL(const TInt &aElements)

{

iPile = new (ELeave) CArrayPtrSeg<CIFControl>(aElements);

}

//-----------------------------------------------------------------------------

CIFControl *CPile<CIFControl>::At(const TInt &aIndex) const

{

if ((aIndex >= 0) || (aIndex < Count()))

	return (CIFControl *)iPile->At(aIndex);

return NULL;

}

//-----------------------------------------------------------------------------

void CPile<CIFControl>::PushL(CIFControl *aT)

{

iPile->AppendL(aT);

}

//-----------------------------------------------------------------------------

TInt CPile<CIFControl>::Count() const

{

return iPile->Count();

}

//-----------------------------------------------------------------------------

CIFControl *CPile<CIFControl>::Pop()

{

TInt count = Count();

if (count > 0)

  {

  CIFControl *t = At(--count);

  iPile->Delete(count);

  return t;

  }

return NULL;

}

void CPile<CIFControl>::Skim()

{

	CIFControl *t = Pop();

	delete t;

}

//-----------------------------------------------------------------------------

CIFControl *CPile<CIFControl>::Peek()

{

TInt count = Count();

if (count > 0)

  {

  CIFControl *t = At(--count);

  return t;

  }

return NULL;

}

//-----------------------------------------------------------------------------

CPile<CIFControl>::~CPile()

{

iPile->ResetAndDestroy();

delete iPile;

iPile = NULL;

}

//-----------------------------------------------------------------------------

//  End of File  

//-----------------------------------------------------------------------------