/*

* Copyright (c) 2006 - 2007 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:  DRM Queue

*

*/

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

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

// CDrmQueue

// Constructor

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

//

template< class T > inline DRM::CDrmQueue< T >::CDrmQueue() : CBase()

    {

    }

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

// ~CDrmQueue

// Destructor

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

//

template< class T > inline DRM::CDrmQueue< T >::~CDrmQueue()

    {

    T* payload = PopFront();

    // Empty the queue:

    while( payload )

        {

        delete payload;

        payload = PopFront();

        }

    iSemaphore.Close();

    }

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

// CDrmQueue::ConstructL()

// (other items were commented in a header).

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

//

template< class T > inline void DRM::CDrmQueue< T >::ConstructL()

    {

    User::LeaveIfError( iSemaphore.CreateLocal(1) );

    }

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

// CDrmQueue::NewLC

// (other items were commented in a header).

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

//

template< class T > inline DRM::CDrmQueue< T >* DRM::CDrmQueue< T >::NewLC()

    {

    DRM::CDrmQueue< T >* self( new( ELeave ) DRM::CDrmQueue< T >() );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CDrmQueue::NewL

// (other items were commented in a header).

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

//

template< class T > inline DRM::CDrmQueue< T >* DRM::CDrmQueue< T >::NewL()

    {

    DRM::CDrmQueue< T >* self( DRM::CDrmQueue< T >::NewLC() );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDrmRightsInfoImpl::AppendToQueue

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

//

template< class T > inline void DRM::CDrmQueue< T >::AppendToQueueL( T* aData )

    {

    CleanupStack::PushL( aData );

    QueueData* data( new (ELeave) QueueData );

    // insert the data into the queue object

    data->iData = aData;

    data->iNext = NULL;

    CleanupStack::Pop( aData );

    // Critical area start:

    iSemaphore.Wait();

    if( !iLast )

        {

        iFirst = data;

        iLast = iFirst;

        }

    else

        {

        iLast->iNext = data;

        iLast = data;

        }

    // Critical area end

    iSemaphore.Signal();

    }

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

// CDrmRightsInfoImpl::PopFront

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

//

template< class T > inline T* DRM::CDrmQueue< T >::PopFront()

    {

    QueueData* data = NULL;

    T* payload = NULL;

    // If there is nothing in the queue return NULL

    if( !iFirst )

        {

        return payload;

        }

    // Critical area start:

    iSemaphore.Wait();

    data = iFirst;

    // Set the first and the next

    iFirst = iFirst->iNext;

    // reset the pointer on data

    data->iNext = NULL;

    // if there is no next in iFirst, this is the last or if there is no iFirst

    if( !iFirst || !iFirst->iNext )

        {

        iLast = iFirst;

        }

    // Critical Area End

    iSemaphore.Signal();

    payload = data->iData;

    delete data;

    data = NULL;

    return payload;

    }

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

// CDrmRightsInfoImpl::PopItem

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

//

template< class T > inline T* DRM::CDrmQueue< T >::PopItem( TInt aId )

    {

    QueueData* current( iFirst );

    QueueData* previous( NULL );

    T* payload( NULL );

    // If there is nothing in the queue return NULL

    if( !iFirst )

        {

        return payload;

        }

    // Critical area start:

    iSemaphore.Wait();

    // Iterate over all items in the queue

    while ( current )

        {

        if ( aId == current->iData->iOperationId )

            {

            payload = current->iData;

            current->iData = NULL;

            if ( previous )

                {

                // Previous present. So its member iNext must be updated.

                previous->iNext = current->iNext;

                }

            else

                {

                // previous not present, so current was first,

                // and iFirst must be updated.

                iFirst = current->iNext;

                }

            if ( !current->iNext )

                {

                // Current was last item. So iLast must be updated.

                iLast = previous;

                }

            current->iNext = NULL;

            delete current;

            break;

            }

        previous = current;

        current = current->iNext;

        }

    // Critical Area End

    iSemaphore.Signal();

    return payload;

    }

//  End of File