/*
* Copyright (c) 2002-2010 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:  Memory management function for WimServer to handle WIMI memory
*
*/


// INCLUDE FILES
#include    "WimMemMgmt.h"
#include    "Wimi.h"        // WIMI definitions
#include    "WimConsts.h"
#include    "WimTrace.h"
#include    "WimCleanup.h"


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

// -----------------------------------------------------------------------------
// CWimMemMgmt::CWimMemMgmt
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CWimMemMgmt::CWimMemMgmt()
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::CWimMemMgmt | Begin"));
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CWimMemMgmt::ConstructL()
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::ConstructL | Begin"));
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWimMemMgmt* CWimMemMgmt::NewL()
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::NewL | Begin"));
    CWimMemMgmt* self = new( ELeave ) CWimMemMgmt;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// Destructor
CWimMemMgmt::~CWimMemMgmt()
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::~CWimMemMgmt | Begin"));

    TInt refsCount = iRefs.Count();
    for( TInt index = 0; index < refsCount; ++index )
        {
        TWimiAllocRef* allocRef = iRefs[ index ];
        if( allocRef )
            {
            if( allocRef->refType == EWimiRefpt )
                {
                _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::~CWimMemMgmt | -ref 0x%08x"), allocRef->ref);
                free_WIMI_Ref_t( allocRef->ref );
                }
            else
                {
                _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::~CWimMemMgmt | -refLst 0x%08x"), allocRef->refLst);
                free_WIMI_RefList_t( allocRef->refLst );
                }
            }
        }
    iRefs.ResetAndDestroy();

    if( iWimRef )
        {
        _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::~CWimMemMgmt, -ref 0x%08x"), iWimRef);
        free_WIMI_Ref_t( iWimRef );
        }
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::SetWIMRef
// Sets active memory reference to iWimRef member variable.
// -----------------------------------------------------------------------------
//
void CWimMemMgmt::SetWIMRef( WIMI_Ref_pt aWimRef )
    {
    __ASSERT_DEBUG( iWimRef == NULL, User::Invariant() );
    _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::SetWIMRef, +ref 0x%08x"), aWimRef);
    iWimRef = aWimRef;
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::GetWIMRef
// Fetches active reference.
// -----------------------------------------------------------------------------
//
WIMI_Ref_pt CWimMemMgmt::WimRef()
    {
    _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::GetWIMRef, iWimRef 0x%08x"), iWimRef);
    return iWimRef;
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::AppendWIMRefLstL
// Creates and appends a new WIMI_Alloc_Ref item to iRefs array.
// -----------------------------------------------------------------------------
//
void CWimMemMgmt::AppendWIMRefLstL( WIMI_RefList_t aRefLst )
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::AppendWIMRefLstL | Begin"));
    CleanupPushWimRefListL( aRefLst ); // take ownership first
    TWimiAllocRef* allocRef = new( ELeave ) TWimiAllocRef;
    CleanupStack::PushL( allocRef );
    allocRef->refLst = aRefLst;
    allocRef->refType = EWimiRefListt;
    iRefs.AppendL( allocRef );
    _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::AppendWIMRefLstL, +refLst 0x%08x"), aRefLst);
    CleanupStack::Pop( 2, aRefLst );    // allocRef, aRefLst
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::AppendWIMRefL
// Creates and appends a new WIMI_Alloc_Ref item to iRefs array.
// -----------------------------------------------------------------------------
//
void CWimMemMgmt::AppendWIMRefL( WIMI_Ref_pt aRef )
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::AppendWIMRefL | Begin"));
    CleanupPushWimRefL( aRef );    // take ownership first
    TWimiAllocRef* allocRef = new( ELeave ) TWimiAllocRef;
    CleanupStack::PushL( allocRef );
    allocRef->ref = aRef;
    allocRef->refType = EWimiRefpt;
    iRefs.AppendL( allocRef );
    _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::AppendWIMRefL, +ref 0x%08x"), aRef);
    CleanupStack::Pop( 2, aRef );   // allocRef, aRef
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::FreeRef
// Removes reference from the list and releases allocated memory.
// -----------------------------------------------------------------------------
//
void CWimMemMgmt::FreeRef( WIMI_Ref_pt aRef )
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::FreeRef | Begin"));
    TInt count = iRefs.Count();
    for( TInt index = 0; index < count; index++ )
        {
        TWimiAllocRef* allocRef = iRefs[ index ];
        if ( allocRef && ( allocRef->ref == aRef ) && ( allocRef->refType == EWimiRefpt ) )
            {
			_WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::FreeRef, -ref 0x%08x"), aRef);
            iRefs.Remove( index );
            iRefs.Compress();
            free_WIMI_Ref_t( aRef );
            delete allocRef;
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::FreeWIMRefs
// Frees the reference(s) pointed by a client.
// -----------------------------------------------------------------------------
//
void CWimMemMgmt::FreeWIMRefs( const RMessage2& aMessage )
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::FreeWIMRefsL | Begin"));
    TUint wimCount = aMessage.Int1();
    WIMI_Ref_pt ref = reinterpret_cast< WIMI_Ref_pt >( aMessage.Int0() );
    _WIMTRACE3(_L("WIM | WIMServer | CWimMemMgmt::FreeWIMRefsL | ref 0x%08x, wimCount %d"),
            ref, wimCount);

    for( TUint8 wimIndex = 0; wimIndex < wimCount; wimIndex++ )
        {
        _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::FreeWIMRefsL | index=%d"), wimIndex);
        FreeRef( ref );
        }

    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::FreeWIMRefsL | End"));
    aMessage.Complete( KErrNone );
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::FreeRefLst
// Frees the list of reference(s) pointed by a client.
// -----------------------------------------------------------------------------
//
void CWimMemMgmt::FreeRefLst( const RMessage2& aMessage )
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::FreeRefLst | Begin"));
    WIMI_Ref_pt* refList = ( WIMI_Ref_pt* )aMessage.Int0();
    TInt count = iRefs.Count();
    for( TUint8 index = 0; index < count; index++ )
        {
        TWimiAllocRef* allocRef = iRefs[ index ];
        if ( allocRef && ( allocRef->refLst == refList ) && ( allocRef->refType == EWimiRefListt ))
            {
            _WIMTRACE2(_L("WIM | WIMServer | CWimMemMgmt::FreeRefLst, -refList 0x%08x"), refList);
            iRefs.Remove( index );
            iRefs.Compress();
            free_WIMI_RefList_t( refList );
            delete allocRef;
            aMessage.Complete( KErrNone );
            return;
            }
        }
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::FreeRefLst | not found") );
    aMessage.Complete( KErrNotFound );
    }

// -----------------------------------------------------------------------------
// CWimMemMgmt::ValidateWIMRefL
// -----------------------------------------------------------------------------
//
TBool CWimMemMgmt::ValidateWIMRefL( WIMI_Ref_pt aRef )
    {
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::ValidateWIMRefL | Begin"));
    TInt count = iRefs.Count();
    for( TUint8 index = 0; index < count; index++ )
        {
        TWimiAllocRef* allocRef = iRefs[ index ];
        if( allocRef && ( allocRef->ref == aRef ) )
            {
            _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::ValidateWIMRefL, valid"));
            return ETrue;
            }
        }
    _WIMTRACE(_L("WIM | WIMServer | CWimMemMgmt::ValidateWIMRefL, invalid"));
    return EFalse;
    }

//  End of File