This document covers the important issues involved in using an RArray.

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()
`
.

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.

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

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

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

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

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 package
`
TMyTest
`
's
matching function in at least three ways.

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

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

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

Copyright ©2010 Nokia Corporation and/or its subsidiary(-ies).

All rights
reserved. Unless otherwise stated, these materials are provided under the terms of the Eclipse Public License
v1.0.