Using +RArray<class T>

Freeing all +memory before the array goes out of scope

By convention, class +names starting with the letter R do not allocate memory on +the heap. RArray <class T> is an exception and +this should be remembered when using the class.

If an array is declared +on the program stack, then its Close() or Reset() member +function must be called to ensure that allocated memory is freed.

Similarly, +if RArray<class T> is a data member of another class, +then the destructor of that class must call Close() or Reset().

Packaging the +algorithm for ordering array objects

A RArray<class +T> array allows its contained objects to be ordered. The array provides +the behaviour for inserting and sorting instances of the template class T. +To help with this, the template class T must provide an algorithm +for deciding how two class T objects are ordered. This algorithm +is implemented by a function which must be wrapped in a TLinearOrder<class +T> package.

The function implementing the algorithm can be +a static member of the class T but need not necessarily be +so.

Here, we aim to build an array of TMyTest objects +ordered in a way which makes sense for the TMyTest class.

class TMyTest + { +public : + TMyTest(TInt anAint,TInt aBint); + static TInt Compare(const TMyTest& aFirst, const TMyTest& Second); +public: + TInt a; + TInt b; + };

In this example , the algorithm is implemented by a static +function called Compare(). It takes const references to two TMyTest objects +and returns zero if the objects are equal, a negative value if aFirst is +less than aSecond and a positive value if aFirst is +greater than aSecond.

TInt TMyTest::Compare(const TMyTest& aFirst,const TMyTest& aSecond) + { + if (aFirst.b < aSecond.b) + return -1; + if (aFirst.b > aSecond.b) + return 1; + return 0; + }

Construct three TMyTest objects and then +construct an array object for an array of TMyTest objects; +the array has default granularity.

TMyTest one(1,1); +TMyTest two(2,2); +TMyTest three(3,3); +... +RArray<TMyTest> x;

There are at least three ways of proceeding, +some of which are more efficient than others.

Explicitly build a TLinearOrder<TMyTest> and +pass this as a parameter to InsertInOrder().

... +TLinearOrder<TMyTest> order(TMyTest::Compare); +... +x.InsertInOrder(one,order); +...

Construct a temporary TLinearOrder<TMyTest> on +the call to InsertInOrder().

... +x.InsertInOrder(one,TLinearOrder<TMyTest>(TMyTest::Compare)); +...

Implicitly construct +a temporary TLinearOrder<TMyTest> on the call to InsertOrder().

... +x.InsertInOrder(one,TMyTest::Compare); +...

This applies to all member functions of RArray<class + T> which take a TLinearOrder<class T> argument.

Packaging the +algorithm for matching array objects

One of the Find() member +functions of RArray<class T> takes a TIdentityRelation<class + T> as an argument. This packages a function which implements +an algorithm for deciding whether two class T objects match.

The +packaging technique is the same as for the previous section. As an example, +we can extend the class TMyTest used in Packaging the algorithm for ordering array objects by adding another +static function called Match().

class TMyTest + { +public : + TMyTest(TInt anAint,TInt aBint); + static TInt Compare(const TMyTest& aFirst, const TMyTest& Second); + static TBool Match(const TMyTest& aFirst, const TMyTest& Second); +public: + TInt a; + TInt b; + };

A typical implementation for Match() might +be:

TBool TMyTest::Match(const TMyTest& aFirst,const TMyTest& aSecond) + { + if ((aFirst.a == aSecond.a) && (aFirst.b == aSecond.b)) + return ETrue; + return EFalse; + }

So, given an array:

RArray<TMyTest> x;RArray<TMyTest> x;

populated with a number TMyTest objects, we can packageTMyTest's +matching function in at least three ways.

Explicitly build a TIdentityRelation<TMyTest> and +pass this as a parameter to Find(); for example:

... +TIdentityRelation<TMyTest> matcher(TMyTest::Match); +... +TMyTest hunter(9,9); +TInt index = x.Find(hunter,order); +if (index == KErrNotFound) + { + ... + } +...

Construct a temporary TIdentityRelation<TMyTest> on +the call to Find().

... +TMyTest hunter(9,9); +TInt index = x.Find(hunter,TIdentityRelation<TMyTest>(TMyTest::Match)); +if (index == KErrNotFound) + { + ... + } +...

Implicitly construct +a temporary TIdentityRelation<TMyTest> on the call to Find().

... +TMyTest hunter(9,9); +TInt index = x.Find(hunter,TMyTest::Match); +if (index == KErrNotFound) + { + ... + } +...