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

 // Object index

 // 

 //

 #include "WSOBJIX.H"

 #include "OBJECT.H"

 #include "server.h"

 #include "panics.h"

 const TInt KNewObjectInitialCount = 1;

 CWsObjectIx::CWsObjectIx() : iObjectArray(8), iNewObjectCount(KNewObjectInitialCount)

 	{

 	}

 CWsObjectIx::~CWsObjectIx()

 	{

 	TInt count=iObjectArray.Count();

 	if (count==0)

 		return;

 	TWsObject* ptr=&iObjectArray[0];

 	const TWsObject* end=ptr+count;

 	for (;ptr<end;ptr++)

 		{

 		CWsObject* obj=ptr->iObject;

 		if (obj)

 			{

 			ptr->iObject=NULL;

 			obj->CloseObject();

 			}

 		}

 	iObjectArray.Reset();

 	}

 void CWsObjectIx::ConstructL()

 	{

 	// Insert a dummy object into the first slot to avoid

 	// having a null handle

 	TWsObject nullObject(NULL,0);

 	iObjectArray.AppendL(nullObject);

 	}

 /** Adds the object to the list.

 If there is an empty slot (i.e. a slot that was previously used but has been freed) the

 object is put in that slot else a new slot is created at the end of the array.

 @param anObj The object to add to the list.

 @return The handle to be used by the client to identify this object.

 @internalComponent

 @released

 */

 TInt CWsObjectIx::AddL(CWsObject* anObj)

 	{

 	TWsObject* ptr=&iObjectArray[0];

 	const TWsObject* base=ptr;

 	TInt index=iObjectArray.Count();

 	const TWsObject* end=ptr+index;

 	WS_ASSERT_DEBUG(base->iObject==NULL, EWsPanicObjectIndexError);

 	// Search for an empty slot

 	while(++ptr<end)

 		{

 		if (ptr->iObject==NULL)

 			{

 			ptr->iObject=anObj;

 			index=ptr-base;

 			break;

 			}

 		}

 	// create a new handle for the object

 	TUint handleCount = ((iNewObjectCount<<TWsObject::ECountPosition) + TWsObject::ECountInc) & TWsObject::ECountMask;

 	if (ptr==end)

 		{

 		// No available empty slot, so append this object to the queue

 		if (index==TWsObject::ECountInc)

 			{

 			User::LeaveNoMemory();	//Things will go wrong later if we ever have more 64K objects

 			}	

 		TWsObject newObject(anObj,handleCount);

 		iObjectArray.AppendL(newObject);

 		ptr=&iObjectArray[index];

 		}

 	// assign the object a unique server-side handle (combination of handle count & object type)

 	ptr->iHandle = handleCount | anObj->Type();

 	// increment the object counter

 	if (++iNewObjectCount==TWsObject::ECountWrapAround)

 		iNewObjectCount = KNewObjectInitialCount;

 	// return to the client their unique handle for the object (combination of handle count & slot number)

 	return (handleCount + index);

 	}	 

 void CWsObjectIx::Tidy()

 	{

 	TInt count=iObjectArray.Count()-1;

 	while(count>0)	// Don't delete object [0]

 		{

 		if (iObjectArray[count].iObject!=NULL)

 			break;

 		iObjectArray.Delete(count--);

 		}

 	}

 void CWsObjectIx::Remove(CWsObject* anObj)

 	{

 	const TWsObject* ptr=FirstObject();

 	const TWsObject* end=ptr+iObjectArray.Count();

 	WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);

 	while(++ptr<end)

 		{

 		if (ptr->iObject==anObj)

 			{

 			Remove(ptr);

 			Tidy();

 			return;

 			}

 		}

 	}

 void CWsObjectIx::Remove(const TWsObject* aObject)

 	{

 	WS_ASSERT_DEBUG(aObject->iObject!=NULL, EWsPanicObjectIndexError);

 	WS_ASSERT_DEBUG((aObject->iHandle&TWsObject::ETypeMask)==(TUint)aObject->iObject->Type(), EWsPanicObjectIndexError);

 	const_cast<TWsObject*>(aObject)->iObject=NULL;

 	}

 CWsObject* CWsObjectIx::HandleToObject(TInt aHandle) const

 	{

 	TInt slot=aHandle&TWsObject::ESlotMask;

 	if (slot<0 || slot>=iObjectArray.Count())

 		return(NULL);

 	const TWsObject* object=&iObjectArray[slot];

 	if ((object->iHandle&TWsObject::ECountMask)==((TUint)aHandle&TWsObject::ECountMask))

 		{

 		return object->iObject;

 		}

 	return(NULL);

 	}

 const TWsObject* CWsObjectIx::FirstObject() const

 	{

 	return(&iObjectArray[0]);

 	}

 TInt CWsObjectIx::At(const CWsObject* anObj)

 	{

 	const TWsObject* base=FirstObject();

 	const TWsObject* ptr=base;

 	const TWsObject* end=base+iObjectArray.Count();

 	WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);

 	while(++ptr<end)

 		{

 		if (ptr->iObject==anObj && (ptr->iHandle&TWsObject::ETypeMask)==(TUint)anObj->Type())

 			return(ptr-base);

 		}

 	return(KErrNotFound);

 	}

 TInt CWsObjectIx::Count() const

 	{

 	const TWsObject* ptr=FirstObject();

 	const TWsObject* end=ptr+iObjectArray.Count();

 	WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);

 	TInt count=0;

 	while(++ptr<end)

 		{

 		if (ptr->iObject && ptr->iObject->Type()!=WS_HANDLE_CLIENT)

 			count++;

 		}

 	return(count);

 	}

 TInt CWsObjectIx::Length() const

 	{

 	return(iObjectArray.Count());

 	}