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

/**
 @file 
 @internalTechnology
*/

#include "vc.h"

#include <elements/vc.h>
#include <elements/metadata.h> //Should we decouple STypeId from NetMeta (circular dependency)?


#ifdef _DEBUG
// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module
// (if it could happen through user error then you should give it an explicit, documented, category + code)
_LIT(KSpecAssert_ElemVirtualCtorv, "ElemVirtualCtorv");
#endif

using namespace Meta;
using namespace VC;


#ifdef _DEBUG
	_LIT(KNetCtorPanic, "NetCtor");
#endif
enum TNetCtorPanic
	{
	EConstructorTableHasRepetitions = 0,
	EConstructorTableIsNotSorted = 1
	};

const TInt KConstructorTableArrayGranularity = 8;

EXPORT_C CVirtualCtorBase::CVirtualCtorBase()
:	iCtorTableList(KConstructorTableArrayGranularity,_FOFF(TCtorTable,iInterfaceId))
	{
	}

EXPORT_C CVirtualCtorBase::~CVirtualCtorBase()
	{
	iCtorTableList.Close();
	}

#if defined(_DEBUG)
//This fn is only a debug mode helper function.
//It may not:
//1) be exported in a header file
//2) be exported as IMPORT_C/EXPORT_C
//3) modify the object being debugged in any way

//We assume that elements of the array may never be NULL
TBool __Debug_NoRepetitions(const TImplementationProxy* aFirstEntry, TInt aLength)
	{
	__ASSERT_DEBUG(aLength>=0, User::Panic(KSpecAssert_ElemVirtualCtorv, 1));

	if (aLength<=1)
		{
		return ETrue;
		}

	for (TInt i = 0; i < aLength; ++i)
		{
		for (TInt j = i + 1; j < aLength; ++j)
			{
			if ((aFirstEntry+i)->iImplementationUid.iUid == (aFirstEntry+j)->iImplementationUid.iUid)
				{
				return EFalse;
				}
			}
		}

	return ETrue;
	}

//We assume that elements of the array may never be NULL
TBool __Debug_IsSorted(const TImplementationProxy* aFirstEntry, TInt aLength)
	{
	__ASSERT_DEBUG(aLength>=0, User::Panic(KSpecAssert_ElemVirtualCtorv, 2));

	if (aLength<=1)
		{
		return ETrue;
		}

	const TImplementationProxy* thisEntry = aFirstEntry + 1;

	TReal trend = thisEntry->iImplementationUid.iUid - aFirstEntry->iImplementationUid.iUid;

	for (TInt i = 1; i < aLength; ++i)
		{
		TReal next = (thisEntry++)->iImplementationUid.iUid;
		TReal prev = (aFirstEntry++)->iImplementationUid.iUid;
		if (((next - prev) * trend) < 0)
			{
			return EFalse;
			}
		}
	return ETrue;
	}
#endif

EXPORT_C void CVirtualCtorBase::RegisterInterfaceL(TUid aInterfaceId, TInt aNumCtors, const TImplementationProxy* aCtorTable)
	{
	TInt dummyIndex;
	const TCtorTable* table = FindCtorTable(aInterfaceId, dummyIndex);
	if(table != NULL)
		{
		table->iRegisteredCount++;
		}
	else
		{
		//Repetitions are not allowed. It is a serious programming mistake.
		__ASSERT_DEBUG(__Debug_NoRepetitions(aCtorTable,aNumCtors), User::Panic(KNetCtorPanic, EConstructorTableHasRepetitions));

		//The disadvantage of a binary search is that the array needs to be sorted
		//(in this case at compile time) or there will be a significant speed penalty.

		//We assert here (and not log only) to protect binary compatibility of future tables.
		__ASSERT_DEBUG(__Debug_IsSorted(aCtorTable,aNumCtors), User::Panic(KNetCtorPanic, EConstructorTableIsNotSorted));

		iCtorTableList.InsertInUnsignedKeyOrderL(TCtorTable(aInterfaceId, aNumCtors, aCtorTable));
		}
	}

EXPORT_C void CVirtualCtorBase::DeregisterInterface(TUid aInterfaceId)
	{
	TInt index;
	const TCtorTable* table = FindCtorTable(aInterfaceId, index);
	if(table != NULL)
		{
		if(--(table->iRegisteredCount) == 0)
			{
			iCtorTableList.Remove(index);
			}
		}
	}

EXPORT_C TBool CVirtualCtorBase::IsInterfaceRegistered(TUid aInterfaceId) const
	{
	TInt idx;
	const CVirtualCtorBase::TCtorTable* table = FindCtorTable(aInterfaceId,idx);
	return table!=NULL;
	}

const CVirtualCtorBase::TCtorTable* CVirtualCtorBase::FindCtorTable(TUid aInterfaceId, TInt& aIndex) const
	{
	return (KErrNone==iCtorTableList.FindInUnsignedKeyOrder(TCtorTable(aInterfaceId,0,0),aIndex))? &iCtorTableList[aIndex] : NULL;
	}

EXPORT_C TProxyNewLPtr CVirtualCtorBase::FindRawCtor(const Meta::STypeId& aType) const
	{
	TInt aIndex;
	const TCtorTable* ctorTable;
	if((ctorTable = FindCtorTable(aType.iUid, aIndex)) != NULL)
		{
		//In our case the only advantage of binary search over linear search is speed.
		//The number of comparisons required for a binary search on N lelments is on average log2(N),
		//while for linear search it is obviously N/2.
		//For example, for an array of 40 entries, binary search will on average require 6 comparisons
		//against 20 for linear. For an array with 1000 entries the proportion is around 1%.

		//For very small arrays the speed gain is insigniffcant, but we have decided that
		//advantages from searching of even medium sized arrays compensate disadvantages related to
		//forced sorting.

		//Currently there is no support for binary search of const (compile time) arrays like TFixedArray.
		//We use this "workaround" below to be able to use supported binary search on our const arrays.
		TImplementationProxy* entries = const_cast<TImplementationProxy*>(ctorTable->iCtorTable);
		RArray<TImplementationProxy> array(sizeof(TImplementationProxy),entries,ctorTable->iNumCtors);
		TImplementationProxy tester = {aType.iType,NULL};
		__ASSERT_COMPILE(_FOFF(TImplementationProxy,iImplementationUid)==0); //We rely on the fact that the key offset is 0
		return (KErrNone==array.FindInUnsignedKeyOrder(tester,aIndex))? array[aIndex].iNewLFuncPtr : NULL;
		}
	return NULL;
	}

EXPORT_C TAny* CVirtualCtorInPlace::New(const Meta::STypeId& aType, TDes8& aBuff) const
    {
	TInPlaceNewPtr newFn = FindCtor(aType);
	if(newFn)
		{
		return newFn(aBuff);
		}
	return NULL;
    }