examples/Base/ArraysAndLists/linkedlist/deltaque/src/timerentry.cpp

Go to the documentation of this file.

/*
Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: Contains definition of functions defined in the CTimerEntry class.  
*/




#include "timerentry.h"

CTimerEntry* CTimerEntry::NewL(CConsoleBase* aConsole)
        {
        CTimerEntry* self = new (ELeave) CTimerEntry(aConsole);
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop(self);
        return self;
        }

void CTimerEntry::ConstructL()
        {
        // Construct the timer object.
        CTimer::ConstructL();
        // Add the object to the active scheduler.
        CActiveScheduler::Add(this);
        }

CTimerEntry::CTimerEntry(CConsoleBase* aConsole):
                                                                                                // Constructor of the timer object.
                                                                                                CTimer(CActive::EPriorityStandard),
                                                                                                // Create the iterator object.
                                                                                                iIterator(iQueue),
                                                                                                // Set count to -1.
                                                                                                iCount(-1),
                                                                                                // Set increment operation as
                                                                                                // the default operation.
                                                                                                iOp(EInsert),
                                                                                                iConsole(aConsole),
                                                                                                iWaitFlag(ETrue)
        {
        }

void CTimerEntry::RunL()
        {
        // Call the arbitrator function.
        ArbitratorL();
        // Print the contents of the queue.
        PrintQue();
        // Maintain an outstanding request.
        IssueRequest();
        }


void CTimerEntry::IssueRequest()
        {
        // Get a random number for number of seconds to wait.
        // Issue the wait request.
        TUint waitTime = KWaitTime;
        if (iWaitFlag)
                {
                waitTime = Math::Random() % KMaxTimeToWait;
                // Make sure that time to wait is not zero;
                waitTime++;
                }
        CTimer::After((waitTime) * 1000000);
        }

void CTimerEntry::ArbitratorL()
        {
        // The increment operation.
        // Add elements to the list.
        if(iOp == EInsert)
                {
                // Get the tick count.
                TInt tc = (TInt)User::TickCount();
                // Try to add an element to the list.
                TBool redo = AddToQueueL(tc);
                // The queue is full.
                if(!redo)
                        {
                        _LIT(KTextQueFull,"Queue is full!\n");
                        iConsole->Printf(KTextQueFull);
                        // Stop adding elements to the queue.
                        // Set iWaitFlag to EFalse.
                        // The timer will wait for 1 second before removing an element
                        // from the queue.
                        iWaitFlag = EFalse;
                        }
                }
        // The decrement operation.
        // Remove elements from the list.
        else
                {
                // Try to remove an element from the list.
                TBool redo = RemoveFromQueue();
                // The queue is empty.
                if(!redo)
                        {
                        _LIT(KTextQueEmpty,"Queue is empty!\n");
                        iConsole->Printf(KTextQueEmpty);
                        // Stop removing elements from the queue.
                        // Set iWaitFlag to ETrue.
                        // The timer will wait for a random interval of time
                        // before adding an element to the queue.
                        iWaitFlag = ETrue;
                        }
                }
        }

TBool CTimerEntry::AddToQueueL(TInt aTicks)
        {
        // Check if the queue is full.
        if(iCount >=  (KMaxEntry - 1))
                        {
                        iOp = ERemove;
                        return EFalse;
                        }

        // Add the tick count to the delta queue.
        _LIT(KTextAddTick,"Added %d to the queue\n");
        iConsole->Printf(KTextAddTick,aTicks);
        iCount++;

        TTimerEntry* ptr = new (ELeave) TTimerEntry;
        iQueue.Add(*ptr,aTicks);

        return ETrue;
        }

void CTimerEntry::PrintQue()
        {
        _LIT(KTextCont,"Contents of the List:\n***\nINDEX\tDELTA\n");
        iConsole->Printf(KTextCont);
        // Set the iterator to the first node of the list.
        iIterator.SetToFirst();
        // Iterate the list and print all TDigit objects
        TTimerEntry *ptr = iIterator++;
        // List index.
        TInt ix = 0;
        while (ptr != NULL)
                {
                _LIT(KTextFormat,"%d\t\t%d\n");
                iConsole->Printf(KTextFormat,ix,ptr->iLink.iDelta);
                ptr = iIterator++;
                ix++;
                }
        _LIT(KTextEnd,"***\n");
        iConsole->Printf(KTextEnd);
        }

TBool CTimerEntry::RemoveFromQueue()
        {
        // Check if the queue is empty.
        if(iCount <  0)
                        {
                        iOp = EInsert;
                        return EFalse;
                        }

        iIterator.SetToFirst();

        // The index of the node to be removed in the list.
        TInt pos = 0;

        // Get a random value for position.
        if(iCount > 0)
                {
                pos = Math::Random() % iCount;
                }

        // Iterate the list until the node pointed to by
        // the pos variable is reached.
        for(TInt ix = 1; ix <= pos; ix++)
                {
                iIterator++;
                }

        TTimerEntry* ptr = iIterator;

        _LIT(KTextRemove,"Removed an element from the queue. Index: %d\n");
        iConsole->Printf(KTextRemove,pos);

        // Remove an element from the delta queue.
        iQueue.Remove(*ptr);
        delete ptr;

        iCount--;

        return ETrue;
        }

CTimerEntry::~CTimerEntry()
        {
        // Cancel any outstanding request.
        Cancel();
        // Delete the elements from the list
        if(iIterator)
                {
                iIterator.SetToFirst();
                // Iterate the list and delete all TDigit objects
                TTimerEntry *ptr = iIterator++;
                while (ptr != NULL)
                        {
                        delete ptr;
                        ptr = iIterator++;
                        }
                }
        }

void CTimerEntry::DoCancel()
        {
        // Call DoCancel() on the base class.
        CTimer::DoCancel();
        }

---