/*
* Copyright (c) 2002 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:  This implementation represents one entry in an array
*               where one mapping contains certificate info 
*               with trusted settings
*
*/


// INCLUDE FILES

#include "WimCertStoreMapping.h"
#include "WimTrace.h"

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

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::NewL()
// NewL constructor which uses NewLC constructor
// -----------------------------------------------------------------------------
//
CWimCertStoreMapping* CWimCertStoreMapping::NewL()
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::NewL()" ) );
    CWimCertStoreMapping* self = CWimCertStoreMapping::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::NewLC()
// NewLC constructor pushes pointer to cleanup stack
// -----------------------------------------------------------------------------
//
CWimCertStoreMapping* CWimCertStoreMapping::NewLC()
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::NewLC()" ) );
    CWimCertStoreMapping* self = new( ELeave ) CWimCertStoreMapping();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::ConstructL()
// Create an array for certificate applications in this mapping
// -----------------------------------------------------------------------------
//
void CWimCertStoreMapping::ConstructL()
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::ConstructL()" ) );
    iCertificateApps = new( ELeave ) RArray<TUid>();
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::CWimCertStoreMapping()
// Default constructor.
// -----------------------------------------------------------------------------
//
CWimCertStoreMapping::CWimCertStoreMapping()
    {   
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::~CWimCertStoreMapping()
// Destructor
// -----------------------------------------------------------------------------
//
CWimCertStoreMapping::~CWimCertStoreMapping()
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::~CWimCertStoreMapping()" ) );
    // CCTCertInfo class release is done in CWimCertInfo class
    iEntry = NULL;

    if ( iCertificateApps )
        {
        iCertificateApps->Close();
        delete iCertificateApps;
        }
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::SetEntryL()
// Sets given certificate info into mapping entry
// -----------------------------------------------------------------------------
//
void CWimCertStoreMapping::SetEntryL( CCTCertInfo* aCertInfo )
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::SetEntryL()" ) );
    __ASSERT_ALWAYS( aCertInfo, User::Leave( KErrArgument ) );
    
    if ( iEntry )
        {
        iEntry->Release();
        }
    iEntry = aCertInfo;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::SetCertificateAppsL()
// Sets certificate applications to mapping entry
// -----------------------------------------------------------------------------
//
void CWimCertStoreMapping::SetCertificateAppsL( RArray<TUid>* aCertificateApps )
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::SetCertificateAppsL()" ) );
    TInt count = aCertificateApps->Count();
    for ( TInt i = 0; i < count; i++ )
        {
        __ASSERT_ALWAYS( &aCertificateApps[i], User::Leave( KErrArgument ) );
        }
    iCertificateApps->Close();
    delete iCertificateApps;
    iCertificateApps = aCertificateApps;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::Entry() const
// Returns the certificate part of mapping 
// -----------------------------------------------------------------------------
//
CCTCertInfo* CWimCertStoreMapping::Entry() const
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::Entry()" ) );
    return iEntry;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::CertificateApps()
// Returns an array of applications from mapping entry the certificate supports
// -----------------------------------------------------------------------------
//
const RArray<TUid>& CWimCertStoreMapping::CertificateApps() const
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::CertificateApps()" ) );
    return *iCertificateApps;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::IsApplicable()
// Returns boolean value indicating if given applicaton is supported by
// the certificate of mapping entry
// -----------------------------------------------------------------------------
//
TBool CWimCertStoreMapping::IsApplicable( const TUid& aApplication ) const
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::IsApplicable()" ) );
    TInt count = iCertificateApps->Count();
    for ( TInt i = 0; i < count; i++ )
        {
        TUid app = ( *iCertificateApps )[i];
        if ( app == aApplication )
            {
            return ETrue;
            }
        }
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::Trusted()
// Returns boolean value indicating if the certificate in mapping 
// entry is trusted
// -----------------------------------------------------------------------------
//
TBool CWimCertStoreMapping::Trusted() const
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::Trusted()" ) );
    return iTrusted;
    }

// -----------------------------------------------------------------------------
// CWimCertStoreMapping::SetTrusted()
// Sets mapping entry to state of trusted or not trusted ( true/false )
// -----------------------------------------------------------------------------
//
void CWimCertStoreMapping::SetTrusted( TBool aTrusted )
    {
    _WIMTRACE ( _L( "CWimCertStoreMapping::SetTrusted()" ) );
    iTrusted = aTrusted;
    }