arraytest.cpp

hercules v9 symbian os application development

#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);
	}