/*

* Copyright (c) 2005-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:  LRU priority list for the file cache

*

*/

#include "rsfwlruprioritylist.h"

#include "rsfwlrulistnode.h"

#include "rsfwfileentry.h"

#include "mdebug.h"

#include "rsfwvolumetable.h"

#include "rsfwvolume.h"

#include "rsfwfileengine.h"

#include "rsfwfiletable.h"

// ----------------------------------------------------------------------------

// CRsfwLruPriorityList::CRsfwLruPriorityList

// 

// ----------------------------------------------------------------------------

//

CRsfwLruPriorityList::CRsfwLruPriorityList()

    : iHdr(CRsfwLruListNode::iOffset),iIter(iHdr) //construct header & iterator

    {}

// ----------------------------------------------------------------------------

// CRsfwLruPriorityList::~CRsfwLruPriorityList

// 

// ----------------------------------------------------------------------------

//

CRsfwLruPriorityList::~CRsfwLruPriorityList()

    {

    CRsfwLruListNode* node;

    iIter.SetToFirst();

    node = iIter++;

    while (node)

        {

        node->iLink.Deque();

        delete node;

        node = iIter++;

        }

    }    

// ----------------------------------------------------------------------------

// CRsfwLruPriorityList::AddNodeL

// 

// ----------------------------------------------------------------------------

//

void CRsfwLruPriorityList::AddNodeL(CRsfwFileEntry *aFe, TInt aPriority) 

    {

    CRsfwLruListNode* currentNode;

    iIter.SetToFirst();

    currentNode = iIter++;

    while (currentNode) 

        {

        if (currentNode->iEntryPtr->Fid() == aFe->Fid()) 

            {

            DEBUGSTRING(("LRU list: '%d' already exists on the list",

                         aFe->Fid().iNodeId));

            return;

            }  

        currentNode = iIter++;

        }

    // Inserts the specified list element in descending priority order.

    // If there is an existing list element with the same priority, 

    // then the new element is added after the existing element.

    CRsfwLruListNode* newNode = CRsfwLruListNode::NewL(aFe, aPriority);

    iHdr.Add(*newNode);

    DEBUGSTRING(("LRU list: added fid '%d' to the list",

                     aFe->Fid().iNodeId));

    }

// ----------------------------------------------------------------------------

// CRsfwLruPriorityList::RemoveNode

// 

// ----------------------------------------------------------------------------

//

TInt CRsfwLruPriorityList::RemoveNode(CRsfwFileEntry *aFe)

    {

    DEBUGSTRING(("CRsfwLruPriorityList::RemoveNode"));

    // When file is opened, it must be removed from LRU list 

    // as it is not candidate for removal from cache. 

    // Returns KErrNotFound if the file is not found at all

    TInt err = KErrNotFound;

    CRsfwLruListNode* currentNode;

    iIter.SetToFirst();

    currentNode = iIter++;

    while (currentNode) 

        {

        if (currentNode->iEntryPtr->Fid() == aFe->Fid()) 

            {

            currentNode->iLink.Deque();

            delete currentNode;

            err = KErrNone;

            DEBUGSTRING(("LRU list: removed fid '%d' from the list",

                             aFe->Fid().iNodeId));

            break;             

            }  

        currentNode = iIter++;

        }

    return err;

    }

// ----------------------------------------------------------------------------

// CRsfwLruPriorityList::GetAndRemoveFirstEntry

// 

// ----------------------------------------------------------------------------

//

CRsfwFileEntry* CRsfwLruPriorityList::GetAndRemoveFirstEntry() 

    {

    CRsfwLruListNode* firstNode = iHdr.First();

    CRsfwFileEntry* firstEntry = NULL;

    if (iHdr.IsHead(firstNode)) 

        {

        return NULL; // the head has been reached, and must not be removed  

        }

    if (firstNode) 

        {

        firstEntry = firstNode->iEntryPtr;

        firstNode->iLink.Deque();

        delete firstNode;

        }

    DEBUGSTRING(("LRU list: first fid on the list removed, '%d'",

                      firstEntry->Fid().iNodeId));        

    return firstEntry;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::ExternalizeL

// ----------------------------------------------------------------------------

//

void CRsfwLruPriorityList::ExternalizeL(RWriteStream& aStream)

    {    

    // start from the end!

    iIter.SetToLast();

    CRsfwLruListNode* currentNode = iIter--;

    while (currentNode) 

        {

        CRsfwFileEntry* currentEntry = currentNode->iEntryPtr;

        if (currentEntry)

            {

            TFid fid = currentEntry->Fid();

            aStream.WriteInt32L(fid.iNodeId);

            aStream.WriteInt32L(fid.iVolumeId);            

            }

        currentNode = iIter--;

        }  

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::InternalizeL

// ----------------------------------------------------------------------------

//

void CRsfwLruPriorityList::InternalizeL(RReadStream& aStream, CRsfwVolumeTable* aVolumeTable)

    {

    if ( !aVolumeTable )

        {

        User::Leave(KErrArgument);

        }

    // reset existing list

    iHdr.Reset();

    // get stream size

    MStreamBuf* streamBuf = aStream.Source();

    TInt streamSize = streamBuf->SizeL();    

    TInt i;

    // note i+8 as one entry takes two TInt32 (2 times 4 bytes)

    for ( i = 0; i < streamSize; i = i+8 )

        {

        TFid fid;

        fid.iNodeId = aStream.ReadInt32L();

        fid.iVolumeId = aStream.ReadInt32L();

        // check whether there is no trash in the data being internalized

        if (fid.iVolumeId >= 0 && fid.iVolumeId < KMaxVolumes && fid.iNodeId > 0)

            {

            // find existing CRsfwFileEntry object based on TFid

            CRsfwVolume* volume = aVolumeTable->iVolumes[fid.iVolumeId];

            if ( volume )

                {

                CRsfwFileEntry* entry = volume->iFileEngine->iFileTable->Root()->Lookup(fid);

                if ( entry )

                    {

                    AddNodeL(entry, ECachePriorityNormal);

                    }

                }            

            }

        else

            {

            DEBUGSTRING(("LRU List: wrong item on the list being internalized!"));

            }

        }

    }