/*
* Copyright (c) 2006 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:   Implementation of DevandTruSrvCertStoreEntryList
*
*/



#include "DevandTruSrvCertStoreEntryList.h"
#include "DevandTruSrvCertStoreEntry.h"
#include "DevTokenDataTypes.h"
#include "DevTokenUtil.h"


// ======== MEMBER FUNCTIONS ========

//CDevandTruSrvCertStoreEntryList

// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::NewLC()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreEntryList* CDevandTruSrvCertStoreEntryList::NewLC()
    {
    CDevandTruSrvCertStoreEntryList* self = new(ELeave) CDevandTruSrvCertStoreEntryList();
    CleanupStack::PushL(self);
    return self;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::NewL()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreEntryList* CDevandTruSrvCertStoreEntryList::NewL(RReadStream& aStream)
    {
    CDevandTruSrvCertStoreEntryList* self = new(ELeave) CDevandTruSrvCertStoreEntryList();
    CleanupStack::PushL(self);
    self->InternalizeL(aStream);
    CleanupStack::Pop();
    return self;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::CDevandTruSrvCertStoreEntryList()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreEntryList::CDevandTruSrvCertStoreEntryList()
    {
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::~CDevandTruSrvCertStoreEntryList()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreEntryList::~CDevandTruSrvCertStoreEntryList()
    {
    iEntries.ResetAndDestroy();
    iEntries.Close();
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::ExternalizeL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreEntryList::ExternalizeL(RWriteStream& aStream) const
    {
    TInt count = iEntries.Count();
    aStream.WriteInt32L(count);
    for (TInt i = 0 ; i < count ; ++i)
        {
        aStream << *iEntries[i];
        }
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::InternalizeL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreEntryList::InternalizeL(RReadStream& aStream)
    {
    TInt count = aStream.ReadInt32L();

    for (TInt i = 0 ; i < count ; ++i)
        {
        CDevandTruSrvCertStoreEntry* entry = CDevandTruSrvCertStoreEntry::NewLC(aStream);

        // Check certificate id is unique
        TInt handle = entry->CertInfo().CertificateId();
        if (IndexForHandle(handle) != KErrNotFound)
            {
            User::Leave(KErrCorrupt);
            }

        AppendL(entry);
        CleanupStack::Pop(entry);   
        }
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::Count()
// ---------------------------------------------------------------------------
//
TInt CDevandTruSrvCertStoreEntryList::Count() const
    {
    return iEntries.Count();
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::AppendL()
// ---------------------------------------------------------------------------
//
TInt CDevandTruSrvCertStoreEntryList::AppendL(CDevandTruSrvCertStoreEntry* aCertInfo)
    {
    assert(aCertInfo, EPanicCertStoreEntryListAppendArguments);
    User::LeaveIfError(iEntries.Append(aCertInfo));
    return iEntries.Count() - 1;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::Remove()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreEntry* CDevandTruSrvCertStoreEntryList::Remove(TInt aIndex)
    {
    CDevandTruSrvCertStoreEntry* entry = iEntries[aIndex];
    iEntries.Remove(aIndex);
    return entry;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::Replace()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreEntry* CDevandTruSrvCertStoreEntryList::Replace(TInt aIndex, CDevandTruSrvCertStoreEntry* aNewEntry)
    {
    assert(aNewEntry, EPanicCertStoreEntryListReplaceArguments);
    CDevandTruSrvCertStoreEntry* entry = iEntries[aIndex];
    iEntries[aIndex] = aNewEntry;
    return entry;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::IndexForHandle()
// ---------------------------------------------------------------------------
//
TInt CDevandTruSrvCertStoreEntryList::IndexForHandle(TInt aHandle) const
    {
    for (TInt i = 0 ; i < iEntries.Count() ; ++i)
        {
        CDevandTruSrvCertStoreEntry* entry = iEntries[i];
        if (entry->CertInfo().Reference() == aHandle)
            {
            return i;
            }
        }

    return KErrNotFound;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::LabelExists()
// ---------------------------------------------------------------------------
//
TBool CDevandTruSrvCertStoreEntryList::LabelExists(const TDesC& aLabel) const
    {
    for (TInt i = 0 ; i < iEntries.Count() ; ++i)
        {
        CDevandTruSrvCertStoreEntry* entry = iEntries[i];
        if (entry->CertInfo().Label() == aLabel)
            {
            return ETrue;
            }
        }

    return EFalse;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::GetByIndex()
// ---------------------------------------------------------------------------
//
const CDevandTruSrvCertStoreEntry& CDevandTruSrvCertStoreEntryList::GetByIndex(
    TInt aIndex) const
    {
    return *iEntries[aIndex];
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::GetByHandleL()
// ---------------------------------------------------------------------------
//
const CDevandTruSrvCertStoreEntry& CDevandTruSrvCertStoreEntryList::GetByHandleL(
    TInt aHandle) const
    {
    TInt index = IndexForHandle(aHandle);
    User::LeaveIfError(index);
    return GetByIndex(index);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreEntryList::NextFreeHandle()
// ---------------------------------------------------------------------------
//
TInt CDevandTruSrvCertStoreEntryList::NextFreeHandle() const 
    {
    TInt count = iEntries.Count();
    TInt maxHandle = -1;
    for (TInt i = 0; i < count; i++)
        {
        CDevandTruSrvCertStoreEntry* entry = iEntries[i];
        if (entry->CertInfo().Reference() > maxHandle)
            {
            maxHandle = entry->CertInfo().Reference();
            }
        }

    return maxHandle + 1;
    }

//EOF