examples/SFExamples/Symbian_OS_Explained_Hercules-v9_Example_Code/src/arraytest.cpp

// 
// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// 
#include <e32base.h>
#include <e32cons.h>

//#include "client.h"
//#include "client-server.h"

_LIT(KTextExampleCode,"Symbian OS Example Code");
_LIT(KTextOK,"Test Passed OK!\n");
_LIT(KTextPressAnyKey,"[Press any key]");


/*void TestClientServerL()
{
        __UHEAP_MARK; // Checks for memory leaks (see Chapter 17)
        
        CConsoleBase* console=Console::NewL(KTextExampleCode,TSize(KConsFullScreen,KConsFullScreen));
        CleanupStack::PushL(console);
        
        RHerculesSession session;
        User::LeaveIfError(session.Connect());
        CleanupClosePushL(session); // Closes the session a leave occurs
                
        ASSERT(session.SlayNemeanLion(KNemeanLionDes, KNemeanLionVal)==KErrNone);
                        
        TVersion version(1,0,0);
        THydraData hydraData;
        hydraData.iHydraVersion = version;
        hydraData.iHeadCount = KHydraHeadCount;
        ASSERT(session.SlayHydra(hydraData)==KErrNone);
        
        // ... Check hydraData, which was modified by the server
        ASSERT(hydraData.iHeadCount==KNoHeads);
                
        TInt count=KInitialCount;
        if (session.CaptureCeryneianHind(count)!=KErrNone)
                ASSERT(EFalse);
        
        // ... Check count which was set by the server
        if (count!=KCapturedCount)
                ASSERT(EFalse);
        
        CHerculesData* data = CHerculesData::NewLC(KHercules, KHeracles, KHerculesDataVal);
        if (session.SlayErymanthianBoar(*data)!=KErrNone)
                ASSERT(EFalse);

        TRequestStatus status;
        session.CleanAugeanStables(status);
        User::WaitForRequest(status);
        ASSERT(KErrNone==status.Int());
        
        TBuf8<12> myBuf(KHercules); // Server reads this data and updates it asynchronously
        session.SlayStymphalianBirds(KBirdCount, myBuf, status);
        User::WaitForRequest(status);
        // ... Inspect the contents of myBuf, modified by the server
        ASSERT(myBuf.Compare(KHercules)==0);
        
        CleanupStack::PopAndDestroy(2, &session); // data, session
        
        
        console->Printf(KTextOK);
        console->Printf(KTextPressAnyKey);
        console->Getch(); // get and ignore character
        CleanupStack::PopAndDestroy(console);
        __UHEAP_MARKEND;
}
*/


enum THerculeanLabours
{
ESlayNemeanLion = 1,
ESlayHydra,
ECaptureCeryneianHind,
ESlayErymanthianBoar,
ECleanAugeanStables,
ECancelCleanAugeanStables,
ESlayStymphalianBirds,
ECancelSlayStymphalianBirds,
ECaptureCretanBull,
ECaptureMaresOfDiomedes,
EObtainGirdleOfHippolyta,
ECaptureOxenOfGeryon,
ETakeGoldenApplesOfHesperides,
ECaptureCerberus
};

enum TTaskManagerPanic
{
EInvalidTaskId = 1,
};

const TInt KTaskArrayGranularity = 4;

_LIT8(KTaskEntry, "\n\tTask: ");

class TTask
{
public:
        TTask(THerculeanLabours aLabour);
public:
        static TInt CompareTaskNumbers(const TTask& aTask1, const TTask& aTask2);
        static TBool MatchTasks(const TTask& aTask1, const TTask& aTask2);
public:
        TTask(const TTask&);
        TTask& operator=(const TTask&);
public:
        inline const TDesC8& LabourName() const {return (iLabourName);};
        inline THerculeanLabours Labour() const {return (iLabour);};    
private:
        void Initialize();
        TTask();        //      Prevent default construction of uninitialized task
private:
        THerculeanLabours iLabour;
        TPtrC8 iLabourName;
};


class CHerculeanTaskManager : public CBase
{
public:
        virtual ~CHerculeanTaskManager();
        static CHerculeanTaskManager* NewLC();
public:
        void AppendTaskL(THerculeanLabours aTaskNumber);
        void DeleteTask(THerculeanLabours aTaskNumber); 
        void GetTask(THerculeanLabours aTaskNumber, TTask& aTask);
        void ListTasksAscendingL(RBuf8& aTaskList);
        void ListTasksL(RBuf8& aTaskList);
public:
        inline TInt TaskCount() const {return (iTaskArray.Count());};
private:
        void SortTasksAscending();
        TInt GetTaskListLength();
private:
        CHerculeanTaskManager();
        void ConstructL();
private:
        RArray<TTask> iTaskArray;
};

void Panic(TTaskManagerPanic aPanicCode)
{
_LIT(KTaskManagerPanic, "TTaskManager");
User::Panic(KTaskManagerPanic, aPanicCode);
}

TTask::TTask(THerculeanLabours aLabour)
: iLabour(aLabour)
{
__ASSERT_ALWAYS( ((aLabour>=ESlayNemeanLion)&&(aLabour<=ECaptureCerberus)), Panic(EInvalidTaskId));
Initialize();
}

TTask::TTask(const TTask& aTask)
: iLabour(aTask.iLabour)
{
        iLabourName.Set(aTask.iLabourName);
}

TTask& TTask::operator=(const TTask& aTask)
{
        iLabour=aTask.iLabour;
        iLabourName.Set(aTask.iLabourName);
        return (*this);
}

void TTask::Initialize()
{
        switch (iLabour)
        {
                case (ESlayNemeanLion):
                {
                _LIT8(KSlayNemeanLion, "SlayNemeanLion");
                iLabourName.Set(KSlayNemeanLion);
                }
                break;
                case (ESlayHydra):
                {
                _LIT8(KSlayHydra, "SlayHydra");
                iLabourName.Set(KSlayHydra);
                }
                break;
                case (ECaptureCeryneianHind):
                {
                _LIT8(KCaptureCeryneianHind, "CaptureCeryneianHind");
                iLabourName.Set(KCaptureCeryneianHind);
                }
                break;
                case (ESlayErymanthianBoar):
                {
                _LIT8(KSlayErymanthianBoar, "SlayErymanthianBoar");
                iLabourName.Set(KSlayErymanthianBoar);
                }
                break;
                case (ECleanAugeanStables):
                {
                _LIT8(KCleanAugeanStables, "CleanAugeanStables");
                iLabourName.Set(KCleanAugeanStables);
                }
                break;
                case (ECancelCleanAugeanStables):
                {
                _LIT8(KCancelCleanAugeanStables, "CancelCleanAugeanStables");
                iLabourName.Set(KCancelCleanAugeanStables);
                }
                break;
                case (ESlayStymphalianBirds):
                {
                _LIT8(KSlayStymphalianBirds, "SlayStymphalianBirds");
                iLabourName.Set(KSlayStymphalianBirds);
                }
                break;
                case (ECancelSlayStymphalianBirds):
                {
                _LIT8(KCancelSlayStymphalianBirds, "CancelSlayStymphalianBirds");
                iLabourName.Set(KCancelSlayStymphalianBirds);
                }
                break;
                case (ECaptureCretanBull):
                {
                _LIT8(KCaptureCretanBull, "CaptureCretanBull");
                iLabourName.Set(KCaptureCretanBull);
                }
                break;
                case (ECaptureMaresOfDiomedes):
                {
                _LIT8(KCaptureMaresOfDiomedes, "CaptureMaresOfDiomedes");
                iLabourName.Set(KCaptureMaresOfDiomedes);
                }
                break;
                case (EObtainGirdleOfHippolyta):
                {
                _LIT8(KObtainGirdleOfHippolyta, "ObtainGirdleOfHippolyta");
                iLabourName.Set(KObtainGirdleOfHippolyta);
                }
                break;
                case (ECaptureOxenOfGeryon):
                {
                _LIT8(KCaptureOxenOfGeryon, "CaptureOxenOfGeryon");
                iLabourName.Set(KCaptureOxenOfGeryon);
                }
                break;
                case (ETakeGoldenApplesOfHesperides):
                {
                _LIT8(KTakeGoldenApplesOfHesperides, "TakeGoldenApplesOfHesperides");
                iLabourName.Set(KTakeGoldenApplesOfHesperides);
                }
                break;
                case (ECaptureCerberus):
                {
                _LIT8(KCaptureCerberus, "CaptureCerberus");
                iLabourName.Set(KCaptureCerberus);
                }
                break;
                default:
                        ASSERT(EFalse); // Should never get here
        }
}


// If aTask1.iLabour < aTask2.iLabour return -ve value
// If aTask1.iLabour > aTask2.iLabour return +ve value
// If aTask1.iLabour == aTask2.iLabour return zero

/*static*/ TInt TTask::CompareTaskNumbers(const TTask& aTask1, const TTask& aTask2)
{
if (aTask1.iLabour > aTask2.iLabour)
        return (1);
else if (aTask1.iLabour < aTask2.iLabour)
        return (-1);
else
        {
        ASSERT(aTask1.iLabour==aTask2.iLabour);
        return (0);
        }
}

/*static*/ TBool TTask::MatchTasks(const TTask& aTask1, const TTask& aTask2)
{
        if (aTask1.iLabour==aTask2.iLabour)
        {
                ASSERT(aTask1.iLabourName.Compare(aTask2.iLabourName)==0);
                return ETrue;
        }
        
        return (EFalse);
}


/*static*/ CHerculeanTaskManager* CHerculeanTaskManager::NewLC()
{
        CHerculeanTaskManager* me = new (ELeave) CHerculeanTaskManager();
        CleanupStack::PushL(me);
        me->ConstructL();
        return (me);
}

CHerculeanTaskManager::CHerculeanTaskManager()
: iTaskArray(KTaskArrayGranularity)
{}

void CHerculeanTaskManager::ConstructL()
{// Nothing to do
}

CHerculeanTaskManager::~CHerculeanTaskManager()
{
        iTaskArray.Close();
}


void CHerculeanTaskManager::AppendTaskL(THerculeanLabours aTaskNumber)
{
        TTask tempTask(aTaskNumber);
        User::LeaveIfError(iTaskArray.Append(tempTask));
}


// Deletes all tasks of aTaskNumber from the array
void CHerculeanTaskManager::DeleteTask(THerculeanLabours aTaskNumber)
{
        TTask tempTask(aTaskNumber);
        TInt foundIndex = iTaskArray.Find(tempTask, TTask::MatchTasks);
        while (foundIndex!=KErrNotFound)
        {
                iTaskArray.Remove(foundIndex);
                foundIndex = iTaskArray.Find(tempTask, TTask::MatchTasks);
        }
}       

void CHerculeanTaskManager::GetTask(THerculeanLabours aTaskNumber, TTask& aTask)
{
        TTask tempTask(aTaskNumber);
        TInt foundIndex = iTaskArray.Find(tempTask, TTask::MatchTasks);
        aTask = iTaskArray[foundIndex];
}

// aTaskList is an empty RBuf
// Lists the tasks as they found in the array
void CHerculeanTaskManager::ListTasksL(RBuf8& aTaskList)
{
//      Get length of descriptor data required
        TInt listLength = GetTaskListLength();
        ASSERT(listLength>=0);
        
        aTaskList.CreateL(listLength);
        
        TInt count=iTaskArray.Count();
        for (TInt index = 0; index<count; index++)
        {
                TTask task = iTaskArray[index];
                aTaskList.Append(KTaskEntry);
                aTaskList.Append(task.LabourName());
        }       
}

// aTaskList is an empty RBuf
// Sorts the tasks into numerical order starting from the lowest value of iLabour
void CHerculeanTaskManager::ListTasksAscendingL(RBuf8& aTaskList)
{
        SortTasksAscending();
        ListTasksL(aTaskList);
}

void CHerculeanTaskManager::SortTasksAscending()
{
        iTaskArray.Sort(TTask::CompareTaskNumbers);
}

// Returns the number of bytes required for a list of tasks
TInt CHerculeanTaskManager::GetTaskListLength()
{
        TInt taskEntryLength = KTaskEntry().Length();
        
        TInt listLength = 0;
        TInt count=iTaskArray.Count();
        for (TInt index = 0; index<count; index++)
        {
                TTask task = iTaskArray[index];
                listLength+=task.LabourName().Length();
                listLength+=taskEntryLength;
        }
        
        return (listLength);
}


void TestArraysL()
{
        __UHEAP_MARK;
        CConsoleBase* console=Console::NewL(KTextExampleCode,TSize(KConsFullScreen,KConsFullScreen));   
        CleanupStack::PushL(console);   
        
        CHerculeanTaskManager* taskManager = CHerculeanTaskManager::NewLC();
        
        taskManager->AppendTaskL(ESlayHydra);
        taskManager->AppendTaskL(ESlayNemeanLion);
        taskManager->AppendTaskL(ECaptureCeryneianHind);
        taskManager->AppendTaskL(ECleanAugeanStables);
        taskManager->AppendTaskL(ECaptureCerberus);
        taskManager->AppendTaskL(ECaptureMaresOfDiomedes);
        taskManager->AppendTaskL(ESlayHydra);
        taskManager->AppendTaskL(ESlayNemeanLion);
        taskManager->AppendTaskL(ECaptureOxenOfGeryon);
        taskManager->AppendTaskL(ESlayErymanthianBoar);
        
        ASSERT(taskManager->TaskCount()==10);
        RBuf8 taskBuf;
        
        taskManager->ListTasksL(taskBuf);
        taskBuf.Zero();
        taskBuf.ReAllocL(0);
        
        taskManager->DeleteTask(ESlayHydra);
        ASSERT(taskManager->TaskCount()==8);
        
        taskManager->ListTasksAscendingL(taskBuf);
        taskBuf.Zero();
        taskBuf.ReAlloc(0); // Free buffer
        
        taskManager->AppendTaskL(ECleanAugeanStables);
        taskManager->AppendTaskL(ECancelCleanAugeanStables);
        ASSERT(taskManager->TaskCount()==10);
                
        taskManager->ListTasksAscendingL(taskBuf);
        taskBuf.Zero();
        taskBuf.ReAlloc(0); // Free buffer
        
        CleanupStack::PopAndDestroy(taskManager);
        
        console->Printf(KTextOK);
        console->Printf(KTextPressAnyKey);
        console->Getch(); // get and ignore character
        CleanupStack::PopAndDestroy(console);   
        __UHEAP_MARKEND;
}



TInt E32Main()
        {
        __UHEAP_MARK;
        
        CTrapCleanup* theCleanupStack = CTrapCleanup::New();

        TRAPD(err, TestArraysL());
        
//      TRAPD(err, TestClientServerL());        
        
        // Delay to allow the server thread to shutdown and test for memory leaks
        User::After(500000); 
        
        ASSERT(KErrNone==err);
        delete theCleanupStack;
        
        __UHEAP_MARKEND;
        return (err);
        }

---