examples/SFExamples/Symbian_OS_Explained_Hercules-v9_Example_Code/testcode/task.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:
// 
// task.cpp

#include "task.h"

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):
                        {
                        _LIT(KSlayNemeanLion, "SlayNemeanLion");
                        iLabourName.Set(KSlayNemeanLion);
                        }
                break;
                case (ESlayHydra):
                        {
                        _LIT(KSlayHydra, "SlayHydra");
                        iLabourName.Set(KSlayHydra);
                        }
                break;
                case (ECaptureCeryneianHind):
                        {
                        _LIT(KCaptureCeryneianHind, "CaptureCeryneianHind");
                        iLabourName.Set(KCaptureCeryneianHind);
                        }
                break;
                case (ESlayErymanthianBoar):
                        {
                        _LIT(KSlayErymanthianBoar, "SlayErymanthianBoar");
                        iLabourName.Set(KSlayErymanthianBoar);
                        }
                break;
                case (ECleanAugeanStables):
                        {
                        _LIT(KCleanAugeanStables, "CleanAugeanStables");
                        iLabourName.Set(KCleanAugeanStables);
                        }
                break;
                case (ECancelCleanAugeanStables):
                        {
                        _LIT(KCancelCleanAugeanStables, "CancelCleanAugeanStables");
                        iLabourName.Set(KCancelCleanAugeanStables);
                        }
                break;
                case (ESlayStymphalianBirds):
                        {
                        _LIT(KSlayStymphalianBirds, "SlayStymphalianBirds");
                        iLabourName.Set(KSlayStymphalianBirds);
                        }
                break;
                case (ECancelSlayStymphalianBirds):
                        {
                        _LIT(KCancelSlayStymphalianBirds, "CancelSlayStymphalianBirds");
                        iLabourName.Set(KCancelSlayStymphalianBirds);
                        }
                break;
                case (ECaptureCretanBull):
                        {
                        _LIT(KCaptureCretanBull, "CaptureCretanBull");
                        iLabourName.Set(KCaptureCretanBull);
                        }
                break;
                case (ECaptureMaresOfDiomedes):
                        {
                        _LIT(KCaptureMaresOfDiomedes, "CaptureMaresOfDiomedes");
                        iLabourName.Set(KCaptureMaresOfDiomedes);
                        }
                break;
                case (EObtainGirdleOfHippolyta):
                        {
                        _LIT(KObtainGirdleOfHippolyta, "ObtainGirdleOfHippolyta");
                        iLabourName.Set(KObtainGirdleOfHippolyta);
                        }
                break;
                case (ECaptureOxenOfGeryon):
                        {
                        _LIT(KCaptureOxenOfGeryon, "CaptureOxenOfGeryon");
                        iLabourName.Set(KCaptureOxenOfGeryon);
                        }
                break;
                case (ETakeGoldenApplesOfHesperides):
                        {
                        _LIT(KTakeGoldenApplesOfHesperides, "TakeGoldenApplesOfHesperides");
                        iLabourName.Set(KTakeGoldenApplesOfHesperides);
                        }
                break;
                case (ECaptureCerberus):
                        {
                        _LIT(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(RBuf     & 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.Append(KNewLine);
                }       
        }

// aTaskList is an empty RBuf
// Sorts the tasks into numerical order starting from the lowest value of iLabour
void CHerculeanTaskManager::ListTasksAscendingL(RBuf    & 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()) + (KNewLine().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);
        }

---