// Copyright (c) 1997-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:
//

#include <cntdef.h>
#include "CNTSTD.H"

//
// class CContactIdArray
//

EXPORT_C CContactIdArray* CContactIdArray::NewL()
/** Allocates and constructs a new contact ID array. 

@return Pointer to the newly created contact ID array. */
	{ // static 
	CContactIdArray* self=CContactIdArray::NewLC();
	CleanupStack::Pop(); // self
	return self;
	}

EXPORT_C CContactIdArray* CContactIdArray::NewLC()
/** Allocates and constructs a new contact ID array. 

The pointer to the object is left on the cleanup stack.

@return Pointer to the newly created contact ID array. */
	{ // static 
	CContactIdArray* self=new(ELeave) CContactIdArray;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

EXPORT_C CContactIdArray* CContactIdArray::NewL(const CContactIdArray* aArray)
/** Allocates and constructs a new contact ID array and then copies the contents of 
aArray into it. 

@param aArray Pointer to the contact ID array to copy.
@return Pointer to the newly created contact ID array. */
	{
	CContactIdArray* self=CContactIdArray::NewLC(aArray);
	CleanupStack::Pop(); // self
	return self;
	}

EXPORT_C CContactIdArray* CContactIdArray::NewLC(const CContactIdArray* aArray)
/** Allocates and constructs a new contact ID array and then copies the contents of 
aArray into it. 

The pointer to the object is left on the cleanup stack.

@param aArray Pointer to the contact ID array to copy.
@return Pointer to the newly created contact ID array. */
	{
	CContactIdArray* self=CContactIdArray::NewLC();
	self->CloneL(aArray);
	return self;
	}
	
/** Allocates and constructs a new contact ID array based on a RReadStream. 

The pointer to the object is left on the cleanup stack.

@param aStream RReadStream containing object to internalize.
@return Pointer to the newly created contact ID array 
@internalTechnology 
*/
CContactIdArray* CContactIdArray::NewLC(RReadStream& aStream)
	{
	CContactIdArray* self=CContactIdArray::NewLC();
	self->InternalizeL(aStream);	
	return self;
	}	

void CContactIdArray::CloneL(const CContactIdArray* aArray)
	{
	const TInt arrayCount = aArray->Count();
	for(TInt loop=0;loop<arrayCount;loop++)
		AddL((*aArray)[loop]);
	}

CContactIdArray::CContactIdArray()
	{}

void CContactIdArray::ConstructL()
	{
	iIds=new(ELeave) CArrayFixFlat<TContactItemId>(4);
	}

EXPORT_C CContactIdArray::~CContactIdArray()
/** The destructor frees all resources owned by the array, prior to its destruction. */
	{
	delete iIds;
	}

EXPORT_C TInt CContactIdArray::Find(TContactItemId aId) const
/** Finds the index of the specified contact ID within the array.

@param aId The contact ID to find.
@return If the contact ID is found, its index within the array. KErrNotFound 
if the ID is not found. */
	{
	TInt pos;
	TKeyArrayFix key(0,ECmpTInt);
	if (iIds->Find(aId,key,pos)==KErrNone)
		return pos;
	return KErrNotFound;
	}

EXPORT_C void CContactIdArray::AddL(TContactItemId aId)
/** Appends a contact ID to the array.

@param aId The contact ID to append to the array. */
	{
//	__ASSERT_DEBUG(Find(aId)<=KErrNotFound,Panic(ECntPanicDuplicateIds));
	iIds->AppendL(aId);
	}


EXPORT_C void CContactIdArray::MoveL(TInt aOldIndex,TInt aNewIndex)
/** Moves a contact ID within the array.

Note: both indexes must be valid or a panic occurs.

@param aOldIndex The index of the ID to move.
@param aNewIndex The new index for the contact ID. */
	{
	/*
	This function has unexpected behaviour. From the function prototype
	one would expect this to provide simple swap functionality. However,
	in fact, this function performs a slightly more complicated task: 
	it actually deletes the item at aOldIndex and moves it *after* the 
	item at aNewIndex. This behaviour is subtley different from a 'swap'
	(see the example at the end of this comment).
	
	This means that the only time this kind of code could be used:-

	const TContactItemId id = (*iIds)[aOldIndex];
	(*iIds)[aOldIndex] = (*iIds)[aNewIndex];
	(*iIds)[aNewIndex] = id;

	is when Abs(aNewIndex - aOldIndex) = 1, which is rare in the simple
	testing that has been performed.

	An example of the function pre and post execution is below

	CContactIdArray::MoveL(aOld = 2, aNew = 7)
	CContactIdArray::MoveL - Before operation...
	iIds[0] = 5
	iIds[1] = 6
	iIds[2] = 7
	iIds[3] = 4
	iIds[4] = 1
	iIds[5] = 2
	iIds[6] = 3
	iIds[7] = 8

	CContactIdArray::MoveL - After operation...
	iIds[0] = 5
	iIds[1] = 6
	iIds[2] = 4
	iIds[3] = 1
	iIds[4] = 2
	iIds[5] = 3
	iIds[6] = 8
	iIds[7] = 7
	*/

	if	(aOldIndex==aNewIndex)
		return;

	if	(aNewIndex>aOldIndex && aNewIndex<Count())
		++aNewIndex;
	TContactItemId id=(*iIds)[aOldIndex];
	iIds->InsertL(aNewIndex,id);
	if	(aOldIndex>aNewIndex)
		++aOldIndex;
	Remove(aOldIndex);
	}

EXPORT_C void CContactIdArray::ReverseOrder()
/** Reverses the order of the whole array. */
	{
	TInt count=Count();
	TInt end=count/2;
	TInt index2=count-1;
	for(TInt index=0;index<end;index++)
		{
		TContactItemId id=(*iIds)[index];
		(*iIds)[index]=(*iIds)[index2];
		(*iIds)[index2]=id;
		index2--;
		}
	}

EXPORT_C void CContactIdArray::InternalizeL(RReadStream& aStream)
/** Internalises a CContactIdArray object from a read stream. The presence of this 
function means that the standard templated operator>>() (defined in s32strm.h) 
is available to internalise objects of this class.

@param aStream Stream from which the object should be internalised. */
	{
	TContactItemId anitem;
	TInt count;
	count=aStream.ReadInt32L();
	for (TInt i=0;i<count;i++)
		{
		aStream >> anitem;
		iIds->AppendL(anitem);
		}
	}

EXPORT_C void CContactIdArray::ExternalizeL(RWriteStream& aStream) const 
/** Externalises a CContactIdArray object to a write stream. The presence of this 
function means that the standard templated operator<<() (defined in s32strm.h) 
is available to externalise objects of this class. 

@param aStream Stream to which the object should be externalised. */
	{
	TInt count;
	TContactItemId anitem;
	count=iIds->Count();
	aStream.WriteInt32L(count);
	for (TInt i=0;i<count;i++)
		{
		anitem=(*iIds)[i];
		aStream << anitem;
		}
	}
	
/* Sorts the array into ascending order.  
This function is intended for internal use only.*/	
void CContactIdArray::Sort()
	{
	TKeyArrayFix key(0,ECmpTInt);
	iIds->Sort(key);     
	}