/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbServers module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#ifndef HBDOUBLELINKEDLIST_INLINE_P_H

#define HBDOUBLELINKEDLIST_INLINE_P_H

/*!

    @hbserver

    \class HbDLink

    \brief HbDLink implements a linkage linkage in a doubly-linked list

*/

template<class ElemType> inline

HbDLink<ElemType>::HbDLink()

        : mNext(0), mPrev(0)

{

}

template<class ElemType> inline

ElemType*

HbDLink<ElemType>::next() const

{

    return mNext;

}

template<class ElemType> inline

ElemType*

HbDLink<ElemType>::prev() const

{

    return mPrev;

}

template<class ElemType> inline

void

HbDLink<ElemType>::setNext(ElemType *element)

{

    mNext = element;

}

template<class ElemType> inline

void

HbDLink<ElemType>::setPrev(ElemType *element)

{

    mPrev = element;

}

/*!

    @hbserver

    \class HbDLinkList

    \brief HbDLinkList implements a generic doubly link list of ElemType.

    HbDlinkList class use for List Recently Used policy implementation.

*/

/*!

    \fn HbDLinkList::HbDLinkList()

    Constructor

    Constructs a HbDLinkList obect

    \a dLink ia a pointer to HbDLink member of ElemType to use for this list.

 */

template<class ElemType> inline

HbDLinkList<ElemType>::HbDLinkList(HbDLink<ElemType> ElemType:: *dLink)

        : listFront(0), listBack(0), mDLink(dLink)

{

}

/*!

    \fn HbDLinkList::~HbDLinkList()

    Destructor

 */

template<class ElemType> inline

HbDLinkList<ElemType>::~HbDLinkList()

{

    // remove links before remove.

    if ((listFront != 0) || (listBack != 0)) {

        removeAll();

    }

}

/*!

    \fn HbDLinkList::insertBack()

    insert a node after the last node

    \a newItem denotes the item to be inserted after the last node

 */

template<class ElemType> inline

void

HbDLinkList<ElemType>::insertBack(ElemType* newItem)

{

    if (newItem == 0) {

        return;

    }

    if (listBack == 0) {

        insertFrontIfListEmpty(newItem);

    } else {

        insertAfter(newItem, listBack);

    }

}

/*!

    \fn HbDLinkList::removeFront()

    remove the front node

 */

template<class ElemType> inline

ElemType*

HbDLinkList<ElemType>::removeFront()

{

    ElemType* itemToRemove = listFront;

    if (itemToRemove != 0) {

        removeNode(itemToRemove);

    } else {

        return 0;

    }

    return itemToRemove;

}

/*!

    \fn HbDLinkList::removeNode()

    remove a particular node

    /a itemToRemove denotesthe cache item to be removed from the list

 */

template<class ElemType> inline

void

HbDLinkList<ElemType>::removeNode(ElemType* itemToRemove)

{

    if (!itemToRemove) {

        return;

    }

    if (itemToRemove == listFront) {

        listFront = (listFront->*mDLink).next();

        if (listFront) {

            (listFront->*mDLink).mPrev = 0;

        } else {

            listBack = 0;

        }

    } else if (itemToRemove == listBack) {

        listBack = (listBack->*mDLink).prev();

        if (listBack) {

            (listBack->*mDLink).mNext = 0;

        }

    } else {

        ((itemToRemove->*mDLink).prev()->*mDLink).mNext = (itemToRemove->*mDLink).next();

        ((itemToRemove->*mDLink).next()->*mDLink).mPrev = (itemToRemove->*mDLink).prev();

    }

    (itemToRemove->*mDLink).mNext = 0;

    (itemToRemove->*mDLink).mPrev = 0;

}

/*!

    \fn HbDLinkList::removeAll()

    remove all the items in the list.

 */

template<class ElemType> inline

void

HbDLinkList<ElemType>::removeAll()

{

    while (listFront) {

        removeFront();

    }

}

/*!

    \fn HbDLinkList::isEmpty()

    Check if list is empty

 */

template<class ElemType> inline

bool

HbDLinkList<ElemType>::isEmpty() const

{

    if (listFront != 0)

        return false;

    else

        return true;

}

/*!

    \fn HbDLinkList::front()

    Return the node at the front of list

 */

template<class ElemType> inline

ElemType*

HbDLinkList<ElemType>:: front() const

{

    return listFront;

}

/*!

    \fn HbDLinkList::front()

    Return the last node in the list

 */

template<class ElemType> inline

ElemType*

HbDLinkList<ElemType>:: back() const

{

    return listBack;

}

/*!

    \fn HbDLinkList::insertFrontIfListEmpty()

    This is a private function. We are only interested in inserting at the back of list.

    However, when a list is empty both front and back point to the same item.

    \a newItem denotes the cache item to be inserted at the front of the list

 */

template<class ElemType> inline

void

HbDLinkList<ElemType>::insertFrontIfListEmpty(ElemType* newItem)

{

    if (listFront == 0) {

        listFront = newItem;

        listBack = newItem;

    }

}

/*!

    \fn HbDLinkList::insertAfter()

    insert a node after a given node

    \a newItem denotes the new cache item to be inserted

    \a lastItem denotes the cache item after which the new item is to be inserted

 */

template<class ElemType> inline

void

HbDLinkList<ElemType>::insertAfter(ElemType *newItem, ElemType *lastItem)

{

    (newItem->*mDLink).mNext = (lastItem->*mDLink).next() ;

    (newItem->*mDLink).mPrev = lastItem;

    if ((lastItem->*mDLink).next() == 0) {

        listBack = newItem;

    } else {

        ((lastItem->*mDLink).mNext->*mDLink).mPrev = newItem;

    }

    (lastItem->*mDLink).mNext = newItem;

}

#endif