/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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

*/

#include "tadditionalstoremapping.h"

////////////////////////////////////////////////////////////////////////////////

//CFileCertStoreMapping

/////////////////////////////////////////////////////////////////////////////////

CFileCertStoreMapping* CFileCertStoreMapping::NewL()

	{

	CFileCertStoreMapping* self = CFileCertStoreMapping::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

CFileCertStoreMapping* CFileCertStoreMapping::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CFileCertStoreMapping::ConstructL()

	{

	iCertificateApps = new(ELeave) RArray<TUid>();

	}

CFileCertStoreMapping::CFileCertStoreMapping()

	{	

	}

CFileCertStoreMapping::~CFileCertStoreMapping()

	{

	if (iEntry)

		{

		iEntry->Release();

		}

	if (iCertificateApps)

		{

		iCertificateApps->Close();

		delete iCertificateApps;

		}

	}

void CFileCertStoreMapping::SetEntry(CCTCertInfo* aCertInfo)

	{

	if (iEntry)

		{

		iEntry->Release();

		}

	iEntry = aCertInfo;

	}

void CFileCertStoreMapping::SetCertificateApps(RArray<TUid>* aCertificateApps)

	{

	iCertificateApps->Close();

	delete iCertificateApps;

	iCertificateApps = aCertificateApps;

	}

void CFileCertStoreMapping::SetId(TStreamId aId)

	{

	iId = aId;

	}

CCTCertInfo* CFileCertStoreMapping::Entry() const

	{

	return iEntry;

	}

const RArray<TUid>& CFileCertStoreMapping::CertificateApps() const

	{

	return *iCertificateApps;

	}

TBool CFileCertStoreMapping::IsApplicable(const TUid& aApplication) const

	{

	TInt count = iCertificateApps->Count();

	for (TInt i = 0; i < count; i++)

		{

		TUid app = (*iCertificateApps)[i];

		if (app == aApplication)

				{

				return ETrue;

				}

		}

	return EFalse;

	}

TBool CFileCertStoreMapping::Trusted() const

	{

	return iTrusted;

	}

void CFileCertStoreMapping::SetTrusted(TBool aTrusted)

	{

	iTrusted = aTrusted;

	}

TStreamId CFileCertStoreMapping::Id() const

	{

	return iId;

	}

void CFileCertStoreMapping::ExternalizeL(RWriteStream& aStream) const

	{

	if (!iTempRemoved)

		{

		aStream << *iEntry;

		TInt count = iCertificateApps->Count();

		aStream.WriteInt32L(count);

		for (TInt i = 0; i < count; i++)

			{

			aStream << (*iCertificateApps)[i];

			}

		aStream.WriteUint8L(iTrusted);

		aStream << iId;			

		}

	}

void CFileCertStoreMapping::SetTempRemoved(TBool aFlag)

	{

	iTempRemoved=aFlag;

	}

TBool CFileCertStoreMapping::IsTempRemoved()

	{

	return iTempRemoved;

	}

#include "tadditionalstoremappings.h"

/////////////////////////////////////////////////////////////////////////////////

//CFileCertStoreMappings

/////////////////////////////////////////////////////////////////////////////////

CFileCertStoreMappings::~CFileCertStoreMappings()

	{

	if (iMappings)

		{

		iMappings->ResetAndDestroy();

		delete iMappings;

		}

	}

TInt CFileCertStoreMappings::Count()

	{

	return iMappings->Count();

	}

void CFileCertStoreMappings::AddL(CFileCertStoreMapping* aEntry)

	{

	User::LeaveIfError(iMappings->Append(aEntry));

	}

TInt CFileCertStoreMappings::Remove(const CCTCertInfo& aCertInfo)

	{

	TInt index = Index(aCertInfo);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	CFileCertStoreMapping* mapping = (*iMappings)[index];

	iMappings->Remove(index);

	delete mapping;

	return KErrNone;

	}

TInt CFileCertStoreMappings::SetTempRemove(const CCTCertInfo& aCertInfo, TBool aFlag)

	{

	TInt index = Index(aCertInfo);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	(*iMappings)[index]->SetTempRemoved(aFlag);

	return KErrNone;		

	}

void CFileCertStoreMappings::ExternalizeL(RWriteStream& aStream) const

	{

	TInt count = iMappings->Count();

	TInt realCount=count;

	TInt i=0;

	for (i = 0; i < count; i++)

		{

		if ((*iMappings)[i]->IsTempRemoved())

			{

			realCount--;

			}

		}

	aStream.WriteInt32L(realCount);

	for (i = 0; i < count; i++)

		{

		aStream << *(*iMappings)[i];

		}

	}

void CFileCertStoreMappings::ReplaceL()

	{

	RStoreWriteStream stream;

	stream.ReplaceLC(iStore, iStreamId);

	ExternalizeL(stream);

	stream.CommitL();

	CleanupStack::PopAndDestroy();

	}

TInt CFileCertStoreMappings::Index(const CCTCertInfo& aCertInfo)

	{

	TInt count = iMappings->Count();

	TInt ix = KErrNotFound;

	for (TInt i = 0; i < count; i++)

		{

		CFileCertStoreMapping* mapping = (*iMappings)[i];

		if (aCertInfo==*(mapping->Entry()))

			{

			ix = i;

			break;

			}

		}

	return ix;

	}

CFileCertStoreMapping* CFileCertStoreMappings::Mapping(TInt aIndex)

	{

	return (*iMappings)[aIndex];

	}

TStreamId CFileCertStoreMappings::StreamId() const

	{

	return iStreamId;

	}

CFileCertStoreMappings::CFileCertStoreMappings(TStreamId aStreamId, 

													   CPermanentFileStore& aStore)

	:iStreamId(aStreamId), iStore(aStore)

	{

	}

/////////////////////////////////////////////////////////////////////////////////

//CFileCertStoreMappings

/////////////////////////////////////////////////////////////////////////////////

CFileCertStoreMappings* CFileCertStoreMappings::NewL(TStreamId aStreamId, 

													 CPermanentFileStore& aStore)

	{

	CFileCertStoreMappings* self = new(ELeave) CFileCertStoreMappings(aStreamId, aStore);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

const CCTCertInfo& CFileCertStoreMappings::Entry(TInt aIndex)

	{

	CFileCertStoreMapping* mapping = (*iMappings)[aIndex];

	return *mapping->Entry();

	}

const CCTCertInfo& CFileCertStoreMappings::EntryByHandleL(TInt aHandle) const

	{

	TInt count = iMappings->Count();

	for (TInt i = 0; i < count; i++)

		{

		CFileCertStoreMapping* mapping = (*iMappings)[i];

		if (aHandle==mapping->Entry()->Handle().iObjectId)

			{

			return *mapping->Entry();

			}

		}

	User::Leave(KErrNotFound);

	CCTCertInfo* info = NULL; // This is to shut up a compiler warning

	return *info;

	}

TInt CFileCertStoreMappings::NextHandle() const 

	{

	TInt count = iMappings->Count();

	TInt maxHandle = -1;

	for (TInt i = 0; i < count; i++)

		{

		CFileCertStoreMapping* mapping = (*iMappings)[i];

		if (mapping->Entry()->Handle().iObjectId > maxHandle)

			{

			maxHandle = mapping->Entry()->Handle().iObjectId;

			}

		}

	return ++maxHandle;

	}

void CFileCertStoreMappings::ConstructL()

	{

	iMappings = new(ELeave) RPointerArray<CFileCertStoreMapping>;

	}