CArrayFix in Base Kernel_Architecture

class CArrayFix : public CArrayFixBase;

Description

A thin templated base class for arrays of fixed length objects.

The public functions provide standard array behaviour.

The class is always derived from and is never instantiated explicitly.

Derivation

CBase - Base class for all classes to be instantiated on the heap.

CArrayFixBase - Base class for arrays of fixed length objects.

CArrayFix - A thin templated base class for arrays of fixed length objects.

Members

Defined in CArrayFix:

AppendL(const T &)Appends a single element onto the end of the array.
AppendL(const T &,TInt)Appends replicated copies of an element onto the end of the array.
AppendL(const T *,TInt)Appends one or more elements onto the end of the array.
Array()constConstructs and returns a TArray<T> object.
At(TInt)Gets a non-const reference to the element located at the specified position with...
At(TInt)constGets a const reference to the element located at the specified position within t...
Back(TInt)Gets a pointer to the beginning of a contiguous region.
Back(TInt)constGets a pointer to the (const) beginning of a contiguous region.
End(TInt)Gets a pointer to the first byte following the end of the contiguous region cont...
End(TInt)constGets a pointer to the (const) first byte following the end of the contiguous reg...
ExpandL(TInt)Expands the array by one element at the specified position.
ExtendL()Expands the array by one element at the end of the array.
Find(const T &,TKeyArrayFix &,TInt &)constFinds the position of an element within the array, based on the matching of keys...
FindIsq(const T &,TKeyArrayFix &,TInt &)constFinds the position of an element within the array, based on the matching of keys...
InsertIsqAllowDuplicatesL(const T &,TKeyArrayFix &)Inserts a single element into the array at a position determined by a key, allow...
InsertIsqL(const T &,TKeyArrayFix &)Inserts a single element into the array at a position determined by a key.
InsertL(TInt,const T &)Inserts an element into the array at the specified position.
InsertL(TInt,const T &,TInt)Inserts replicated copies of an element into the array at the specified position...
InsertL(TInt,const T *,TInt)Inserts one or more elements into the array at the specified position.
ResizeL(TInt)Changes the size of the array so that it contains the specified number of elemen...
ResizeL(TInt,const T &)Changes the size of the array so that it contains the specified number of elemen...
operator[](TInt)Gets a non-const reference to the element located at the specified position with...
operator[](TInt)constGets a const reference to the element located at the specified position within t...

Inherited from CArrayFixBase:

Compress()Compresses the array.
Count()constGets the number of elements held in the array.
Delete(TInt)Deletes a single element from the array at a specified position.
Delete(TInt,TInt)Deletes one or more contiguous elements from the array, starting at a specific p...
Length()constGets the length of an element.
Reset()Deletes all elements from the array and frees the memory allocated to the array ...
Sort(TKeyArrayFix &)Sorts the elements of the array into key sequence.

Inherited from CBase:

Delete(CBase *)Deletes the specified object.
Extension_(TUint,TAny *&,TAny *)Extension function
operator new(TUint)Allocates the object from the heap and then initialises its contents to binary z...
operator new(TUint,TAny *)Initialises the object to binary zeroes.
operator new(TUint,TLeave)Allocates the object from the heap and then initialises its contents to binary z...
operator new(TUint,TLeave,TUint)Allocates the object from the heap and then initialises its contents to binary z...
operator new(TUint,TUint)Allocates the object from the heap and then initialises its contents to binary z...

inline const T& operator[](TInt anIndex) const;

Description

Gets a const reference to the element located at the specified position within the array.

Note that if a pointer to the returned referenced class T object is taken, be aware that the pointer value becomes invalid once elements have been added to, or removed from the array. Always refresh the pointer.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

const T &

A const reference to the required element.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline T& operator[](TInt anIndex);

Description

Gets a non-const reference to the element located at the specified position within the array.

Note that if a pointer to the returned referenced class T object is taken, be aware that the pointer value becomes invalid once elements have been added to, or removed from the array. Always refresh the pointer.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

T &

A non-const reference to the required element.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline const T& At(TInt anIndex) const;

Description

Gets a const reference to the element located at the specified position within the array.

Note that if a pointer to the returned referenced class T object is taken, be aware that the pointer value becomes invalid once elements have been added to, or removed from the array. Always refresh the pointer.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

const T &

A const reference to the required element.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline const T* End(TInt anIndex) const;

Description

Gets a pointer to the (const) first byte following the end of the contiguous region containing the element at the specified position within the array.

For arrays implemented using flat buffers, the pointer always points to the first byte following the end of the buffer.

For arrays implemented using segmented buffers, the pointer always points to the first byte following the end of the segment which contains the element.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

const T *

A pointer to the constant byte following the end of the contiguous region.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline const T* Back(TInt anIndex) const;

Description

Gets a pointer to the (const) beginning of a contiguous region.

For arrays implemented using flat buffers, the function always returns a pointer to the beginning of the buffer.

For arrays implemented using segmented buffers, the function returns a pointer to the beginning of the segment for all elements in that segment except the first. If the element at position anIndex is the first in a segment, then the function returns a pointer the beginning of the previous segment.

For the first element in the array, the function returns a NULL pointer.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

const T *

A pointer to the (const) beginning of the contiguous region.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline T& At(TInt anIndex);

Description

Gets a non-const reference to the element located at the specified position within the array.

Note that if a pointer to the returned referenced class T object is taken, be aware that the pointer value becomes invalid once elements have been added to, or removed from the array. Always refresh the pointer.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

T &

A non-const reference to the required element.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline T* End(TInt anIndex);

Description

Gets a pointer to the first byte following the end of the contiguous region containing the element at the specified position within the array.

For arrays implemented using flat buffers, the pointer always points to the first byte following the end of the buffer.

For arrays implemented using segmented buffers, the pointer always points to the first byte following the end of the segment which contains the element.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

T *

A pointer to the byte following the end of the contiguous region.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline T* Back(TInt anIndex);

Description

Gets a pointer to the beginning of a contiguous region.

For arrays implemented using flat buffers, the function always returns a pointer to the beginning of the buffer.

For arrays implemented using segmented buffers, the function returns a pointer to the beginning of the segment for all elements in that segment except the first. If the element at position anIndex is the first in a segment, then the function returns a pointer the beginning of the previous segment.

For the first element in the array, the function returns a NULL pointer.

Parameters


                                 						TInt anIndex

The position of the element within the array. The position is relative to zero; i.e. zero implies the first element in the array.

Return value

T *

A pointer to the beginning of the contiguous region.

Panic codes

E32USER-CBase

21, if anIndex is negative or greater than or equal to the number of objects currently within the array.

inline void AppendL(const T &aRef);

Description

Appends a single element onto the end of the array.

Parameters

const T &aRef

A reference to the class T element to be appended.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

inline void AppendL(const T *aPtr, TInt aCount);

Description

Appends one or more elements onto the end of the array.

Parameters

`const T *aPtr`	A pointer to a contiguous set of type <class T> objects to be appended.
`TInt aCount`	The number of contiguous objects of type <class T> located at aPtr to be appended.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

Panic codes

E32USER-CBase

23, if aCount is negative.

inline void AppendL(const T &aRef, TInt aReplicas);

Description

Appends replicated copies of an element onto the end of the array.

Parameters

`const T &aRef`	A reference to the <class T> object to be replicated and appended.
`TInt aReplicas`	The number of copies of the aRef element to be appended.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

Panic codes

E32USER-CBase

28 if aReplicas is negative.

inline T& ExpandL(TInt anIndex);

Description

Expands the array by one element at the specified position.

It:

1. expands the array by one element at the specified position

2. constructs a new element at that position

3. returns a reference to the new element.

All existing elements from position anIndex to the end of the array are moved up, so that the element originally at position anIndex is now at position anIndex + 1 etc.

The new element of type class T is constructed at position anIndex, using the default constructor of that class.

Parameters


                                 						TInt anIndex

The position within the array where the array is to be expanded and the new class T object is to be constructed.

Return value

T &

A reference to the newly constructed class T object at position anIndex within the array.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

Panic codes

E32USER-CBase

21 if anIndex is negative or greater than the number of elements currently in the array.

inline T& ExtendL();

Description

Expands the array by one element at the end of the array.

It:

1. expands the array by one element at the end of the array, i.e. at position CArrayFixBase::Count()const

2. constructs a new element at that position

3. returns a reference to the new element.

The new element of type class T is constructed at the end of the array, using the default constructor of that class.

Return value

T &

A reference to the newly constructed class T object at the end of the array.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

Description

Finds the position of an element within the array, based on the matching of keys, using a sequential search.

The array is searched sequentially for an element whose key matches the key of the supplied class T object. The search starts with the first element in the array.

Note that where an array has elements with duplicate keys, the function only supplies the position of the first element in the array with that key.

Parameters

`const T &aRef`	A reference to an object of type class T whose key is used for comparison.
`TKeyArrayFix &aKey`	A reference to a key object defining the properties of the key.
`TInt &anIndex`	A reference to a TInt supplied by the caller. On return, if the element is found, the reference is set to the position of that element within the array. The position is relative to zero, (i.e. the first element in the array is at position 0). If the element is not found and the array is not empty, then the value of the reference is set to the number of elements in the array. If the element is not found and the array is empty, then the reference is set to zero.

Return value


                                 						TInt

Zero, if the element with the specified key is found. Non-zero, if the element with the specified key is not found.

inline TInt FindIsq(const T &aRef, TKeyArrayFix &aKey, TInt &anIndex) const;

Description

Finds the position of an element within the array, based on the matching of keys, using a binary search technique.

The array is searched, using a binary search technique, for an element whose key matches the key of the supplied class T object.

The array must be in key order.

Note that where an array has elements with duplicate keys, the function cannot guarantee which element, with the given key value, it will return, except that it will find one of them.

Parameters

`const T &aRef`	A reference to an object of type class T whose key is used for comparison.
`TKeyArrayFix &aKey`	A reference to a key object defining the properties of the key.
`TInt &anIndex`	A reference to a TInt supplied by the caller. On return, if the element is found, the reference is set to the position of that element within the array. The position is relative to zero, (i.e. the first element in the array is at position 0). If the element is not found and the array is not empty, then the reference is set to the position of the first element in the array with a key which is greater than the key of the object aRef. If the element is not found and the array is empty, then the reference is set to zero.

Return value


                                 						TInt

Zero, if the element with the specified key is found. Non-zero, if the element with the specified key is not found.

inline void InsertL(TInt anIndex, const T &aRef);

Description

Inserts an element into the array at the specified position.

Note that passing a value of anIndex which is the same as the current number of elements in the array, has the effect of appending the element.

Parameters

`TInt anIndex`	The position within the array where the element is to be inserted. The position is relative to zero, i.e. zero implies that elements are inserted at the beginning of the array.
`const T &aRef`	A reference to the class T object to be inserted into the array at position anIndex.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

Panic codes

E32USER-CBase

21 if anIndex is negative, or is greater than the number of elements currently in the array.

inline void InsertL(TInt anIndex, const T *aPtr, TInt aCount);

Description

Inserts one or more elements into the array at the specified position.

The objects to be added must all be contiguous.

Note that passing a value of anIndex which is the same as the current number of elements in the array, has the effect of appending the element.

Parameters

`TInt anIndex`	The position within the array where the elements are to be inserted. The position is relative to zero, i.e. zero implies that elements are inserted at the beginning of the array.
`const T *aPtr`	A pointer to the first of the contiguous elements of type class T to be inserted into the array at position anIndex.
`TInt aCount`	The number of contiguous elements of type class T located at aPtr to be inserted into the array.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

Panic codes

`E32USER-CBase`	21 if anIndex is negative or is greater than the number of elements currently in the array.
`E32USER-CBase`	23 if aCount is negative.

inline void InsertL(TInt anIndex, const T &aRef, TInt aReplicas);

Description

Inserts replicated copies of an element into the array at the specified position.

Note that passing a value of anIndex which is the same as the current number of elements in the array, has the effect of appending the element.

Parameters

`TInt anIndex`	The position within the array where elements are to be inserted. The position is relative to zero, i.e. zero implies that elements are inserted at the beginning of the array.
`const T &aRef`	A reference to the class T object to be replicated and inserted into the array at position anIndex.
`TInt aReplicas`	The number of copies of the aRef element to be inserted into the array.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

Panic codes

`E32USER-CBase`	21, if anIndex is negative or is greater than the number of elements currently in the array.
`E32USER-CBase`	28, if aReplicas is negative.

inline TInt InsertIsqL(const T &aRef, TKeyArrayFix &aKey);

Description

Inserts a single element into the array at a position determined by a key.

The array MUST already be in key sequence (as defined by the key), otherwise the position of the new element is unpredictable, or duplicates may occur.

Elements with duplicate keys are not permitted.

Parameters

`const T &aRef`	A reference to the element of type <class T> to be inserted into the array.
`TKeyArrayFix &aKey`	A reference to a key object defining the properties of the key.

Return value


                                 						TInt

The position within the array of the newly inserted element.

Leave codes

`KErrAlreadyExists`	An element with the same key already exists within the array. NB the array MUST already be in key sequence, otherwise the function may insert a duplicate and fail to leave with this value.
`KErrNoMemory`	The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

inline TInt InsertIsqAllowDuplicatesL(const T &aRef, TKeyArrayFix &aKey);

Description

Inserts a single element into the array at a position determined by a key, allowing duplicates.

The array MUST already be in key sequence (as defined by the key), otherwise the position of the new element is unpredictable.

If the new element's key is a duplicate of an existing element's key, then the new element is positioned after the existing element.

Parameters

`const T &aRef`	A reference to the element of type <class T> to be inserted into the array.
`TKeyArrayFix &aKey`	A reference to a key object defining the properties of the key.

Return value


                                 						TInt

The position within the array of the newly inserted element.

Leave codes

KErrNoMemory

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves, in which case the array is left in the state it was in before the call.

inline void ResizeL(TInt aCount);

Description

Changes the size of the array so that it contains the specified number of elements.

The following describes the effects of calling this function:

1. If aCount is less than the current number of elements in the array, then the array is shrunk. The elements at positions aCount and above are discarded. The array buffer is not compressed.

2. If aCount is greater than the current number of elements in the array, then the array is extended.

3. New elements are replicated copies of an object of type <class T>, constructed using the default constructor of that class.

The new elements are positioned after the existing elements in the array.

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves. The leave code is one of the system wide error codes. If the function leaves, the array is left in the state it was in before the call.

Parameters


                                 						TInt aCount

The number of elements the array is to contain after the resizing operation.

Panic codes

E32USER-CBase

24, if aCount is negative.

inline void ResizeL(TInt aCount, const T &aRef);

Description

Changes the size of the array so that it contains the specified number of elements.

The following describes the effects of calling this function:

1. If aCount is less than the current number of elements in the array, then the array is shrunk. The elements at positions aCount and above are discarded. The array buffer is not compressed.

2. If aCount is greater than the current number of elements in the array, then the array is extended.

3. New elements are replicated copies of aRef.

The new elements are positioned after the existing elements in the array.

The function may attempt to expand the array buffer. If there is insufficient memory available, the function leaves. The leave code is one of the system wide error codes. If the function leaves, the array is left in the state it was in before the call.

Parameters

`TInt aCount`	The number of elements the array is to contain after the resizing operation.
`const T &aRef`	A reference to an object of type <class T>, copies of which are used as the new elements of the array, if the array is extended.

Panic codes

E32USER-CBase

24, if aCount is negative.

inline const TArray< T > Array() const;

Description

Constructs and returns a TArray<T> object.

Return value

const TArray< T >

A TArray<T> object representing this array.

Class CArrayFix

Description

Derivation

Members

Member functions

operator[](TInt)const

Description

Parameters

Return value

Panic codes

operator[](TInt)

Description

Parameters

Return value

Panic codes

At(TInt)const

Description

Parameters

Return value

Panic codes

End(TInt)const

Description

Parameters

Return value

Panic codes

Back(TInt)const

Description

Parameters

Return value

Panic codes

At(TInt)

Description

Parameters

Return value

Panic codes

End(TInt)

Description

Parameters

Return value

Panic codes

Back(TInt)

Description

Parameters

Return value

Panic codes

AppendL(const T &)

Description

Parameters

Leave codes

AppendL(const T *,TInt)

Description

Parameters

Leave codes

Panic codes

AppendL(const T &,TInt)

Description

Parameters

Leave codes

Panic codes

ExpandL(TInt)

Description

Parameters

Return value

Leave codes

Panic codes

ExtendL()

Description

Return value

Leave codes

See also:

Find(const T &,TKeyArrayFix &,TInt &)const

Description

Parameters

Return value

FindIsq(const T &,TKeyArrayFix &,TInt &)const

Description

Parameters

Return value

InsertL(TInt,const T &)

Description

Class `CArrayFix`

`operator[](TInt)const`

`operator[](TInt)`

`At(TInt)const`

`End(TInt)const`

`Back(TInt)const`

`At(TInt)`

`End(TInt)`

`Back(TInt)`

`AppendL(const T &)`

`AppendL(const T *,TInt)`

`AppendL(const T &,TInt)`

`ExpandL(TInt)`

`ExtendL()`

`Find(const T &,TKeyArrayFix &,TInt &)const`

`FindIsq(const T &,TKeyArrayFix &,TInt &)const`

`InsertL(TInt,const T &)`

`InsertL(TInt,const T *,TInt)`

`InsertL(TInt,const T &,TInt)`

`InsertIsqL(const T &,TKeyArrayFix &)`

`InsertIsqAllowDuplicatesL(const T &,TKeyArrayFix &)`

`ResizeL(TInt)`

`ResizeL(TInt,const T &)`

`Array()const`