/*

* Copyright (c) 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:  Sensor server transaction queue.

*

*/

#include "sensrvdefines.h"

#include "sensrvtransactionqueue.h"

#include "sensrvtransaction.h"

#include "sensrvsession.h"

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

// 2-phase constructor

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

//

CSensrvTransactionQueue* CSensrvTransactionQueue::NewL(TBool aOwned)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::NewL()" ) ) );

    CSensrvTransactionQueue* self = new( ELeave ) CSensrvTransactionQueue(aOwned);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self); 

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::NewL - return 0x%x" ), self ) );

    return self;

    }

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

// C++ constructor

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

//

CSensrvTransactionQueue::CSensrvTransactionQueue(TBool aOwned)

    : iTransactionPtrList(_FOFF(TLinkableTransactionPtr,iLink)),

      iTransactionPtrIter(iTransactionPtrList),

      iOwned(aOwned)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::CSensrvTransactionQueue()" ) ) );

    // Nothing to do

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::CSensrvTransactionQueue - return" ) ) );

    }

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

// 2nd phase of construction

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

//

void CSensrvTransactionQueue::ConstructL()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::ConstructL()" ) ) );

    iHeap = &User::Heap();

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::ConstructL - return" ) ) );

    }

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

// Destructor

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

//

CSensrvTransactionQueue::~CSensrvTransactionQueue()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::~CSensrvTransactionQueue()" ) ) );

    TLinkableTransactionPtr* ptr = NULL;

    while (!iTransactionPtrList.IsEmpty())

        {

        ptr = iTransactionPtrList.First();

        iTransactionPtrList.Remove(*ptr);

        CSensrvTransaction* transaction = ptr->iTransaction;

        // If transactions are owned, they are all deleted. 

        if (iOwned)

            {

            transaction->SetErrorCode(KErrCancel);

            transaction->Complete();

            // Transactions are always created in same heap as queue with regular new,

            // so regular delete is ok

            delete transaction;

            }

        // Pointers are allocated directly on heap, so free them directly also just to be on safe side.

        if (iHeap)

            {

            iHeap->Free(ptr);

            }

        }

    // Reset to clear memory used by the list

    iTransactionPtrList.Reset();

    // iHeap is not owned

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::~CSensrvTransactionQueue - return" ) ) );

    }

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

// Adds transaction to the end of the queue

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

//

TInt CSensrvTransactionQueue::Add(CSensrvTransaction* aTransaction, TBool aLast)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Add(aTransaction: 0x%x, aLast: %d)" ), aTransaction, aLast ) );

    TInt err(KErrNone);

    if (aTransaction)

        {

        // Allocate linkable transaction pointer in same heap as queue

        TLinkableTransactionPtr* newPtr = reinterpret_cast<TLinkableTransactionPtr*>(iHeap->Alloc(sizeof(TLinkableTransactionPtr)));

        if (newPtr)

            {

            newPtr->iTransaction = aTransaction;

            if (aLast)

                {

                iTransactionPtrList.AddLast(*newPtr);

                }

            else

                {

                iTransactionPtrList.AddFirst(*newPtr);

                }

            }

        else

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Add - ERROR: No memory to add item" ) ) );

            err = KErrNoMemory;

            }

        }

    else

        {

        ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Add - ERROR: Attempted to add NULL transaction" ) ) );

        err = KErrArgument;

        }

#ifdef MEMORY_TRACE_DEBUG

    TInt count(0);

    if (!iTransactionPtrList.IsEmpty())

        {

        TLinkableTransactionPtr* ptr = NULL;

        iTransactionPtrIter.SetToFirst(); 

        while ((ptr = iTransactionPtrIter++) != NULL)

            {

            count++;

            // Do not print the entire queue if it has many items.

            if (count < 5)

                {

                MEMORY_TRACE( ( _L( "@TT: %d" ), ptr->iTransaction->Type() ) );

                }

            else if (count == 5)

                {

                MEMORY_TRACE( ( _L( "@..." ) ) );

                }

            };

        }

    MEMORY_TRACE( ( _L( "@Queue count %d" ), count ) );

#endif

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Add - return %d" ), err ) );

    return err;

    }

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

// Remove transaction from queue

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

//

void CSensrvTransactionQueue::Remove(CSensrvTransaction* aTransaction,

                                     TRemovalType aRemovalType)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Remove(aTransaction: 0x%x, %d)" ), aTransaction, aRemovalType ) );

    if (aTransaction)

        {

        TLinkableTransactionPtr* ptr = FindTransactionPtr(aTransaction);

        if (ptr)

            {

            RemovePtr(ptr, aRemovalType);

            }

        else

            {

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Remove - Attempted to remove nonexisting transaction" ) ) );

            }

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Remove - Attempted to remove NULL transaction" ) ) );

        }

    }

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

// Remove all of session's transactions from queue.

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

//

void CSensrvTransactionQueue::Remove(CSensrvSession* aSession)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Remove(aSession: 0x%x)" ), aSession ) );

    if (aSession)

        {

        TLinkableTransactionPtr* ptr = NULL;

        iTransactionPtrIter.SetToFirst(); 

        while ((ptr = iTransactionPtrIter++) != NULL)

            {

            if ( ptr->iTransaction->Message() )

                {

                if (ptr->iTransaction->Message()->Session() == aSession)    

                    {

                    RemovePtr(ptr, ERemovalTypeCancel);

                    }

                }

            };

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::Remove - Attempted to remove transactions for NULL session" ) ) );

        }

    }

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

// Remove all obsolete transactions from queue

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

//

TInt CSensrvTransactionQueue::RemoveObsolete(const TTime& aCutoffTime)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::RemoveObsolete(aCutoffTime: %LD)" ), aCutoffTime.Int64() ) );

    TInt count(0);

    TLinkableTransactionPtr* ptr = NULL;

    iTransactionPtrIter.SetToFirst(); 

    while ((ptr = iTransactionPtrIter++) != NULL)

        {

        if ( ptr->iTransaction->TimeStamp() <= aCutoffTime )

            {

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::RemoveObsolete - Removing obsolete transaction: 0x%x" ), ptr->iTransaction) );

            count++;

            RemovePtr(ptr, ERemovalTypeCancel);

            }

        };

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::RemoveObsolete - return %d" ), count ) );

    return count;

    }

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

// Remove all transactions from queue

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

//

void CSensrvTransactionQueue::RemoveAll()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::RemoveAll()" ) ) );

    TLinkableTransactionPtr* ptr = NULL;

    iTransactionPtrIter.SetToFirst(); 

    while ((ptr = iTransactionPtrIter++) != NULL)

        {

        RemovePtr(ptr, ERemovalTypeCancel);

        };

    }

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

// Gets pointer to first transaction in queue.

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

//

CSensrvTransaction* CSensrvTransactionQueue::First()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::First()" ) ) );

    CSensrvTransaction* retval = NULL;

    if (!iTransactionPtrList.IsEmpty())

        {

        retval = iTransactionPtrList.First()->iTransaction;

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::First - return 0x%x" ), retval ) );

    return retval;

    }

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

// Finds the queue item which contains pointer to specified transaction.

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

//

CSensrvTransactionQueue::TLinkableTransactionPtr* CSensrvTransactionQueue::FindTransactionPtr(CSensrvTransaction* aTransaction)

    {

    TLinkableTransactionPtr* ptr = NULL;

    if (aTransaction)

        {

        TBool found(EFalse);

        iTransactionPtrIter.SetToFirst(); 

        while (!found && (ptr = iTransactionPtrIter++) != NULL )

            {

            if ( ptr->iTransaction == aTransaction )

                {    

                COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::FindTransactionPtr - Pointer found" ) ) );

                found = ETrue;

                }

            };

        if (!found)

            {

            ptr = NULL;

            }

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransactionQueue::FindTransactionPtr - Pointer not found" ) ) );

        }

    return ptr;    

    }

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

// Removes linkable pointer object from queue.

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

//

void CSensrvTransactionQueue::RemovePtr(TLinkableTransactionPtr* aPtr, TRemovalType aRemovalType)

    {

    if (aPtr)

        {

        if (iOwned && aRemovalType != ERemovalTypeTransfer)

            {

            __ASSERT_ALWAYS(aRemovalType != ERemovalTypeUndefined, User::Panic(KSensrvPanicCategory, ESensrvPanicInvalidRemoveType));

            if (aRemovalType == ERemovalTypeCancel)

                {

                aPtr->iTransaction->SetErrorCode(KErrCancel);    

                }

            aPtr->iTransaction->Complete();

            // Owned queues are always owned by server main thread and transactions are

            // only removed from those queues within server main thread,

            // so regular delete is ok.

            delete aPtr->iTransaction;

            }

        iTransactionPtrList.Remove(*aPtr);

        iHeap->Free(aPtr);

        aPtr = NULL;

        }

    }