Symaptic: os/ossrv/lowlevellibsandfws/apputils/src/BADESCA.CPP@260cb5ec6c19

     1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Written by DavidW, October 1996

    15 // Descriptor arrays

    16 //

    17 //

    19 #include <badesca.h>

    22 // Class to provide an interface for Sort function - two variants

    23 // for 8 and 16-bit descriptors.  (should this be templated? -PNJ)

    26 NONSHARABLE_CLASS(TKeyDesC8Array) : public TKeyArrayFix

    27 	{

    28 public:

    29 	TKeyDesC8Array(TKeyCmpText aType);

    30 private: // from TKey

    31 	TInt Compare(TInt aLeft,TInt aRight) const;

    32 	};

    34 TKeyDesC8Array::TKeyDesC8Array(TKeyCmpText aType)

    35 	: TKeyArrayFix(0,aType,0)

    36 	{

    37 	}

    39 TInt TKeyDesC8Array::Compare(TInt aLeft,TInt aRight) const

    40 	{

    41 	TDesC8* left=(*(TDesC8**)At(aLeft));

    42 	TDesC8* right=(*(TDesC8**)At(aRight));

    43 	switch (iCmpType)

    44 		{

    45 	case ECmpFolded:

    46 		return(left->CompareF(*right));

    47 	case ECmpCollated:

    48 		return(left->CompareC(*right));

    49 	default:

    50 		break;

    51 		}

    52 	return(left->Compare(*right));

    53 	}

    56 NONSHARABLE_CLASS(TKeyDesC16Array) : public TKeyArrayFix

    57 	{

    58 public:

    59 	TKeyDesC16Array(TKeyCmpText aType);

    60 private: // from TKey

    61 	TInt Compare(TInt aLeft,TInt aRight) const;

    62 	};

    64 TKeyDesC16Array::TKeyDesC16Array(TKeyCmpText aType)

    65 	: TKeyArrayFix(0,aType,0)

    66 	{

    67 	}

    69 TInt TKeyDesC16Array::Compare(TInt aLeft,TInt aRight) const

    70 	{

    71 	TDesC16* left=(*(TDesC16**)At(aLeft));

    72 	TDesC16* right=(*(TDesC16**)At(aRight));

    73 	switch (iCmpType)

    74 		{

    75 	case ECmpFolded:

    76 		return(left->CompareF(*right));

    77 	case ECmpCollated:

    78 		return(left->CompareC(*right));

    79 	default:

    80 		break;

    81 		}

    82 	return(left->Compare(*right));

    83 	}

    87 // CDesCxArray implementation...

    90 EXPORT_C CDesC8Array::CDesC8Array(TBufRep aRep,TInt aGranularity)

    91     : CArrayFixBase(aRep,sizeof(HBufC8*),aGranularity)

    92     {

    93     }

    95 EXPORT_C CDesC8Array::~CDesC8Array()

    96 /** Frees all resources owned by the object, prior to its destruction. In particular,

    97 it deletes all descriptors from the array and frees the memory allocated to

    98 the array buffer. */

    99     {

   100 	Reset();

   101     }

   103 EXPORT_C void CDesC8Array::Reset()

   104 /** Deletes all descriptors from the array and frees the memory allocated to the

   105 array buffer.

   107 @see CDesC8Array::Delete() */

   108 	{

   109 	Delete(0,Count());

   110 	}

   112 EXPORT_C void CDesC8Array::Delete(TInt aIndex)

   113 	{

   114 	Delete(aIndex,1);

   115 	}

   117 /**

   118  *

   119  * Deletes one or more logically contiguous descriptor elements from the

   120  * array.

   121  *

   122  * The deletion starts at the specified position.Deleting descriptor

   123  * elements from the array frees the memory occupied by the associated

   124  * heap descriptors and removes their pointers from the array buffer but

   125  * does not cause the array buffer to be automatically compressed. Call

   126  * the Compress() function to return excess space in the array buffer to

   127  * the heap.

   128  *

   129  * @param     " TInt aPos "

   130  *            The starting position in the array from which

   131  *            descriptor elements are to be deleted. The position is

   132  *            relative to zero, i.e. zero implies the first

   133  *            descriptor element. This value must not be negative

   134  *            and must not be greater than the number of descriptor

   135  *            elements currently in the array, otherwise the

   136  *            functions raise an E32USER-CBase 21 panic.

   137  * @param     " TInt aCount "

   138  *            If specified, the number of contiguous descriptor

   139  *            elements to be deleted from the array. This value must

   140  *            not be negative otherwise the function raises an

   141  *            E32USER-CBase 22 panic. This value plus the value of

   142  *            the starting position must not be greater than the

   143  *            number of descriptor elements in the array, otherwise

   144  *            the function raises an E32USER-CBase 29 panic. This

   145  *            value must not be negative otherwise the function

   146  *            raises an E32USER-CBase 22 panic. This value plus the

   147  *            value of the starting position must not be greater

   148  *            than the number of descriptor elements in the array,

   149  *            otherwise the function raises an E32USER-CBase 29

   150  *            panic. If not specified, one element is assumed.

   151  */

   152 EXPORT_C void CDesC8Array::Delete(TInt aIndex,TInt aCount)

   153 	{

   154 	TInt count=aCount;

   155 	for (TInt ii=aIndex; count--; ii++)

   156 		User::Free(*(HBufC8**)At(ii));

   157 	CArrayFixBase::Delete(aIndex,aCount);

   158 	}

   160 EXPORT_C TInt CDesC8Array::MdcaCount() const

   161 /** Returns the number of descriptor elements in the array. The function implements

   162 the interface MDesC8Array::MdcaCount().

   164 @return The number of descriptor elements. */

   165     {

   166     return Count();

   167     }

   169 EXPORT_C TPtrC8 CDesC8Array::MdcaPoint(TInt anIndex) const

   170 /** Indexes into a descriptor array. The function implements the interface

   171 MDesC8Array::MdcaPoint().

   173 @param aIndex The position of the descriptor element within the array. The

   174 position is relative to zero; i.e. zero implies the first descriptor element

   175 in the array. This value must be non-negative and less than the number of

   176 descriptors currently within the array otherwise the operator panics with

   177 EArrayIndexOutOfRange.

   178 @return A non-modifiable pointer descriptor representing the descriptor element

   179 located at position aIndex within the array. */

   180 	{

   181 	HBufC8* temp=(*(HBufC8**)At(anIndex));

   182 	return (TPtrC8)(*temp);

   183 	}

   185 EXPORT_C void CDesC8Array::AppendL(const TDesC8& aPtr)

   186 /** Appends a descriptor onto the end of any existing descriptor elements in the

   187 array.

   189 @param aPtr A reference to the descriptor to be appended to the array.

   190 @leave KErrNoMemory There is insufficient memory available. If the function

   191 leaves, the array is left in the state it was in before the call. */

   192 	{

   193 	InsertL(Count(),aPtr);

   194 	}

   196 EXPORT_C void CDesC8Array::InsertL(TInt aPos,const TDesC8& aPtr)

   197 /** Inserts a descriptor into the array at the specified position.

   199 If the specified position is the same as the current number of descriptor

   200 elements in the array, this has the effect of appending the element.

   202 @param aPos The position within the array where the descriptor element is

   203 to be inserted. The position is relative to zero, i.e. zero implies the first

   204 descriptor element. This value must not be negative and must not be greater

   205 than the number of descriptor elements currently in the array, otherwise the

   206 function rasises an E32USER-CBase 21 panic.

   207 @param aPtr The descriptor to be inserted into the array.

   208 @leave KErrNoMemory There is insufficient memory available. If the function

   209 leaves, the array is left in the state it was in before the call. */

   210 	{

   211 	HBufC8* bufPtr=aPtr.AllocLC();

   212    	CArrayFixBase::InsertL(aPos,&bufPtr);

   213 	CleanupStack::Pop();

   214 	}

   216 EXPORT_C TInt CDesC8Array::InsertIsqL(const TDesC8& aPtr,TKeyCmpText aTextComparisonType)

   217 /** Inserts a descriptor into the array at a position which maintains the

   218 sequence of the descriptors.

   220 The sequence is determined by comparing descriptors using one of the TDesC

   221 comparison functions. The enumeration aTextComparisonType governs how the

   222 descriptors are to be compared.

   224 The array should already be in sequence, otherwise the position of the new

   225 descriptor element is unpredictable. Descriptor elements which are the same

   226 are not permitted.

   228 @param aPtr A reference to the descriptor to be inserted into the array.

   229 @param aTextComparisonType An enumeration which determines the type of

   230 comparison to be made between descriptors for the purpose of choosing the

   231 insertion position.  If no parameter is explicitly passed, ECmpFolded is used

   232 by default.

   233 @leave KErrAlreadyExists A descriptor with the same data (i.e. the same length

   234 and the same content) already exists within the array.

   235 @leave KErrNoMemory There is insufficient memory available. If the function

   236 leaves, the array is left in the state it was in before the call.

   237 @return The position within the array of the inserted descriptor. */

   238 	{

   239 	HBufC8* bufPtr=aPtr.AllocLC();

   240 	TKeyDesC8Array key(aTextComparisonType);

   241    	TInt found=CArrayFixBase::InsertIsqL(&bufPtr,key);

   242 	CleanupStack::Pop();

   243 	return(found);

   244 	}

   246 EXPORT_C TInt CDesC8Array::InsertIsqAllowDuplicatesL(const TDesC8& aPtr,TKeyCmpText aTextComparisonType)

   247 /** Inserts a descriptor into the array at a position which maintains the

   248 sequence of the descriptors - allows duplicates.

   250 The sequence is determined by comparing descriptors using one of the TDesC

   251 comparison functions. The enumeration aTextComparisonType governs how the

   252 descriptors are to be compared.

   254 The array should already be in sequence, otherwise the position of the new

   255 descriptor element is unpredictable. Descriptor elements which are the same

   256 are permitted; if the descriptor aPtr is a duplicate of an existing descriptor

   257 within the array, then the new descriptor element is positioned after the

   258 existing descriptor element.

   260 @param aPtr A reference to the descriptor to be inserted into the array.

   261 @param aTextComparisonType An enumeration which determines the type of comparison

   262 to be made between descriptors for the purpose of choosing the insertion position.

   263 If no parameter is explicitly passed, ECmpFolded is used by default.

   264 @leave KErrNoMemory There is insufficient memory available. If the function

   265 leaves, the array is left in the state it was in before the call.

   266 @return The position within the array of the inserted descriptor. */

   267 	{

   268 	HBufC8* bufPtr=aPtr.AllocLC();

   269 	TKeyDesC8Array key(aTextComparisonType);

   270    	TInt found=CArrayFixBase::InsertIsqAllowDuplicatesL(&bufPtr,key);

   271 	CleanupStack::Pop();

   272 	return(found);

   273 	}

   275 EXPORT_C void CDesC8Array::Sort(TKeyCmpText aTextComparisonType)

   276 /** Sorts the descriptor elements into sequence.

   278 The sequence is determined by comparing descriptors using one of the member

   279 functions of the descriptor base class TDesC.

   281 @param aTextComparisonType An enumeration which defines the type of comparison

   282 to be made between descriptors. By default the comparison type is ECmpFolded. */

   283 	{

   284 	TKeyDesC8Array key(aTextComparisonType);

   285 	CArrayFixBase::Sort(key);

   286 	}

   288 EXPORT_C TInt CDesC8Array::Find(const TDesC8& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType) const

   289 /** Finds the position of a descriptor element within the array which matches the

   290 specified descriptor using a sequential search.

   292 The array is searched sequentially for a matching descriptor element, starting

   293 with the first descriptor element in the array. Descriptors are compared using

   294 one of the TDesC comparison functions. The enumeration aTextComparisonType

   295 governs how the descriptors are to be compared.

   297 Where an array has duplicate descriptor elements, the function only supplies

   298 the position of the first descriptor element.

   300 @param aPtr A reference to a descriptor to be used for comparison.

   301 @param aPos If the descriptor element is found, this reference is set to the

   302 position of that descriptor element within the array. The position is relative

   303 to zero, (i.e. the first descriptor element in the array is at position 0).

   304 If the descriptor element is not found and the array is not empty, then the

   305 value of the reference is set to the number of descriptor elements in the

   306 array. If the descriptor element is not found and the array is empty, then

   307 the reference is set to zero.

   308 @param aTextComparisonType An enumeration which determines the type of comparison

   309 to be made between descriptors. If no parameter is explicitly passed, ECmpFolded

   310 is used by default.

   311 @return Zero, if a matching descriptor element is found. Non-zero, if no matching

   312 descriptor element can be found. */

   313 	{

   314 	TKeyDesC8Array key(aTextComparisonType);

   315 	const TDesC8* tmp=(&aPtr);

   316 	return(CArrayFixBase::Find(&tmp,key,aPos));

   317 	}

   319 EXPORT_C TInt CDesC8Array::FindIsq(const TDesC8& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType) const

   320 /** Finds the position of a descriptor element within the array which matches

   321 the specified descriptor using a binary search technique. The array must

   322 be in sequence, otherwise the outcome is unpredictable.

   324 Descriptors are compared using one of the TDesC comparison functions. The

   325 enumeration aTextComparisonType governs how the descriptors are to be compared.

   327 Where an array has duplicate descriptor elements, the function cannot guarantee

   328 which matching descriptor element it will return; except that it will find

   329 one of them.

   331 @param aPtr A reference to a descriptor to be used for comparison.

   332 @param aPos If the descriptor element is found, the reference is set to the

   333 position of that descriptor element within the array. The position is relative

   334 to zero, (i.e. the first descriptor element in the array is at position 0).

   335 If the descriptor element is not found and the array is not empty, then the

   336 reference is set to the position of the first descriptor element in the array

   337 whose content is greater than the content of aPtr. If the descriptor element

   338 is not found and the array is empty, then the reference is set to zero.

   339 @param aTextComparisonType An enumeration which determines the type of comparison

   340 to be made between descriptors. If no parameter is explicitly passed, ECmpFolded

   341 is used by default.

   342 @return Zero, if a matching descriptor element is found. Non-zero, if no matching

   343 descriptor element can be found. */

   344 	{

   345 	TKeyDesC8Array key(aTextComparisonType);

   346 	const TDesC8* tmp=(&aPtr);

   347 	return(CArrayFixBase::FindIsq(&tmp,key,aPos));

   348 	}

   351 /**

   352  *

   353  * Constructs a flat descriptor array with the specified granularity.

   354  *

   355  * No memory is allocated to the array buffer by this constructor.

   356  *

   357  * @param     "TInt aGranularity"

   358  *            The granularity of the array. This value must be

   359  *            positive otherwise the constructor raises an

   360  *            E32USER-CBase 18 panic.

   361  */

   362 EXPORT_C CDesC8ArrayFlat::CDesC8ArrayFlat(TInt aGranularity)

   363     : CDesC8Array((TBufRep)CBufFlat::NewL,aGranularity)

   364     {

   365 	__DECLARE_NAME(_S("CDesC8ArrayFlat"));

   366 	}

   368 EXPORT_C CDesC8ArrayFlat::~CDesC8ArrayFlat()

   369 /** Frees all resources owned by the object, prior to its destruction. */

   370     {}

   372 EXPORT_C CDesC8ArraySeg::CDesC8ArraySeg(TInt aGranularity)

   373     : CDesC8Array((TBufRep)CBufSeg::NewL,aGranularity)

   374 /** Constructs a segmented descriptor array with the specified granularity.

   376 No memory is allocated to the array buffer by this constructor.

   378 @param aGranularity The granularity of the array. This value must be positive

   379 otherwise the constructor raises an E32USER-CBase 18 panic. */

   380     {

   381 	__DECLARE_NAME(_S("CDesC8ArraySeg"));

   382     }

   384 EXPORT_C CDesC8ArraySeg::~CDesC8ArraySeg()

   385 /** Frees all resources owned by the object, prior to its destruction. */

   386     {}

   389 // 16-bit equivalents to the above.

   392 EXPORT_C CDesC16Array::CDesC16Array(TBufRep aRep,TInt aGranularity)

   393     : CArrayFixBase(aRep,sizeof(HBufC16*),aGranularity)

   394     {

   395     }

   397 EXPORT_C CDesC16Array::~CDesC16Array()

   398 /** Frees all resources owned by the object, prior to its destruction. In particular,

   399 it deletes all descriptors from the array and frees the memory allocated to

   400 the array buffer. */

   401     {

   402 	Reset();

   403     }

   405 EXPORT_C void CDesC16Array::Reset()

   406 /** Deletes all descriptors from the array and frees the memory allocated to the

   407 array buffer.

   409 @see CDesC16Array::Delete() */

   410 	{

   411 	Delete(0,Count());

   412 	}

   414 EXPORT_C void CDesC16Array::Delete(TInt aIndex)

   415 	{

   416 	Delete(aIndex,1);

   417 	}

   419 /**

   420  *

   421  * Deletes one or more logically contiguous descriptor elements from the

   422  * array.

   423  *

   424  * The deletion starts at the specified position.Deleting descriptor

   425  * elements from the array frees the memory occupied by the associated

   426  * heap descriptors and removes their pointers from the array buffer but

   427  * does not cause the array buffer to be automatically compressed. Call

   428  * the Compress() function to return excess space in the array buffer to

   429  * the heap.

   430  *

   431  * @param     " TInt aPos "

   432  *            The starting position in the array from which

   433  *            descriptor elements are to be deleted. The position is

   434  *            relative to zero, i.e. zero implies the first

   435  *            descriptor element. This value must not be negative

   436  *            and must not be greater than the number of descriptor

   437  *            elements currently in the array, otherwise the

   438  *            functions raise an E32USER-CBase 21 panic.

   439  * @param     " TInt aCount "

   440  *            If specified, the number of contiguous descriptor

   441  *            elements to be deleted from the array. This value must

   442  *            not be negative otherwise the function raises an

   443  *            E32USER-CBase 22 panic. This value must not be

   444  *            negative otherwise the function raises an

   445  *            E32USER-CBase 22 panic. This value must not be

   446  *            negative otherwise the function raises an

   447  *            E32USER-CBase 22 panic. This value plus the value of

   448  *            the starting position must not be greater than the

   449  *            number of descriptor elements in the array, otherwise

   450  *            the function raises an E32USER-CBase 29 panic. If not

   451  *            specified, one element is assumed.

   452  */

   453 EXPORT_C void CDesC16Array::Delete(TInt aIndex,TInt aCount)

   454 	{

   455 	TInt count=aCount;

   456 	for (TInt ii=aIndex; count--; ii++)

   457 		User::Free(*(HBufC16**)At(ii));

   458 	CArrayFixBase::Delete(aIndex,aCount);

   459 	}

   461 EXPORT_C TInt CDesC16Array::MdcaCount() const

   462 /** Returns the number of descriptor elements in the array. The function implements

   463 the function interface MDesC16Array::MdcaCount().

   465 @return The number of descriptor elements. */

   466     {

   467     return Count();

   468     }

   470 EXPORT_C TPtrC16 CDesC16Array::MdcaPoint(TInt anIndex) const

   471 /** Indexes into a descriptor array. The function implements the interface MDesC16Array::MdcaPoint().

   473 	@param aIndex The position of the descriptor element within the array. The

   474 	position is relative to zero; i.e. zero implies the first descriptor element

   475 	in the array. This value must be non-negative and less than the number of

   476 	descriptors currently within the array otherwise the operator panics with

   477 	EArrayIndexOutOfRange.

   478 	@return A non-modifiable pointer descriptor representing the descriptor element

   479 	located at position aIndex within the array. */

   480 	{

   481 	HBufC16* temp=(*(HBufC16**)At(anIndex));

   482 	return (TPtrC16)(*temp);

   483 	}

   485 EXPORT_C void CDesC16Array::AppendL(const TDesC16& aPtr)

   486 /** Appends a descriptor onto the end of any existing descriptor elements in the

   487 array.

   489 @param aPtr A reference to the descriptor to be appended to the array. */

   490 	{

   491 	InsertL(Count(),aPtr);

   492 	}

   494 EXPORT_C void CDesC16Array::InsertL(TInt aPos,const TDesC16& aPtr)

   495 /** Inserts a descriptor into the array at the specified position.

   497 If the specified position is the same as the current number of descriptor

   498 elements in the array, this has the effect of appending the element.

   500 @param aPos The position within the array where the descriptor element is

   501 to be inserted. The position is relative to zero, i.e. zero implies the first

   502 descriptor element. This value must not be negative and must not be greater

   503 than the number of descriptor elements currently in the array, otherwise the

   504 function raises an E32USER-CBase 21 panic.

   505 @param aPtr The descriptor to be inserted into the array. */

   506 	{

   507 	HBufC16* bufPtr=aPtr.AllocLC();

   508    	CArrayFixBase::InsertL(aPos,&bufPtr);

   509 	CleanupStack::Pop();

   510 	}

   512 EXPORT_C TInt CDesC16Array::InsertIsqL(const TDesC16& aPtr,TKeyCmpText aTextComparisonType)

   513 /** Inserts a descriptor into the array at a position which maintains the sequence

   514 of the descriptors.

   516 The sequence is determined by comparing descriptors using one of the TDesC

   517 comparison functions. The enumeration aTextComparisonType governs how the

   518 descriptors are to be compared.

   520 The array should already be in sequence, otherwise the position of the new

   521 descriptor element is unpredictable. Descriptor elements which are the same

   522 are not permitted.

   524 @param aPtr A reference to the descriptor to be inserted into the array.

   525 @param aTextComparisonType An enumeration which determines the type of comparison

   526 to be made between descriptors for the purpose of choosing the insertion position.

   527 If no parameter is explicitly passed, ECmpFolded is used by default.

   528 @return The position within the array of the inserted descriptor. */

   529 	{

   530 	HBufC16* bufPtr=aPtr.AllocLC();

   531 	TKeyDesC16Array key(aTextComparisonType);

   532    	TInt found=CArrayFixBase::InsertIsqL(&bufPtr,key);

   533 	CleanupStack::Pop();

   534 	return(found);

   535 	}

   537 EXPORT_C TInt CDesC16Array::InsertIsqAllowDuplicatesL(const TDesC16& aPtr,TKeyCmpText aTextComparisonType)

   538 /** Inserts a descriptor into the array at a position which maintains the sequence

   539 of the descriptors; allows duplicates.

   541 The sequence is determined by comparing descriptors using one of the TDesC

   542 comparison functions. The enumeration aTextComparisonType governs how the

   543 descriptors are to be compared.

   545 The array should already be in sequence, otherwise the position of the new

   546 descriptor element is unpredictable. Descriptor elements which are the same

   547 are permitted; if the descriptor aPtr is a duplicate of an existing descriptor

   548 within the array, then the new descriptor element is positioned after the

   549 existing descriptor element.

   551 @param aPtr A reference to the descriptor to be inserted into the array.

   552 @param aTextComparisonType An enumeration which determines the type of comparison

   553 to be made between descriptors for the purpose of choosing the insertion position.

   554 If no parameter is explicitly passed, ECmpFolded is used by default.

   555 @return The position within the array of the inserted descriptor. */

   556 	{

   557 	HBufC16* bufPtr=aPtr.AllocLC();

   558 	TKeyDesC16Array key(aTextComparisonType);

   559    	TInt found=CArrayFixBase::InsertIsqAllowDuplicatesL(&bufPtr,key);

   560 	CleanupStack::Pop();

   561 	return(found);

   562 	}

   564 EXPORT_C void CDesC16Array::Sort(TKeyCmpText aTextComparisonType)

   565 /** Sorts the descriptor elements into sequence.

   567 The sequence is determined by comparing descriptors using one of the member

   568 functions of the descriptor base class TDesC.

   570 @param aTextComparisonType An enumeration which defines the type of comparison

   571 to be made between descriptors. By default the comparison type is ECmpFolded. */

   572 	{

   573 	TKeyDesC16Array key(aTextComparisonType);

   574 	CArrayFixBase::Sort(key);

   575 	}

   577 EXPORT_C TInt CDesC16Array::Find(const TDesC16& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType) const

   578 /** Finds the position of a descriptor element within the array which matches the

   579 specified descriptor, using a sequential search.

   581 The array is searched sequentially for a matching descriptor element, starting

   582 with the first descriptor element in the array. Descriptors are compared using

   583 one of the TDesC comparison functions. The enumeration aTextComparisonType

   584 governs how the descriptors are to be compared.

   586 Where an array has duplicate descriptor elements, the function only supplies

   587 the position of the first descriptor element.

   589 @param aPtr A reference to a descriptor to be used for comparison.

   590 @param aPos If the descriptor element is found, this reference is set to the

   591 position of that descriptor element within the array. The position is relative

   592 to zero, (i.e. the first descriptor element in the array is at position 0).

   593 If the descriptor element is not found and the array is not empty, then the

   594 value of the reference is set to the number of descriptor elements in the

   595 array. If the descriptor element is not found and the array is empty, then

   596 the reference is set to zero.

   597 @param aTextComparisonType An enumeration which determines the type of comparison

   598 to be made between descriptors. If no parameter is explicitly passed,ECmpFolded

   599 is used by default.

   600 @return Zero, if a matching descriptor element is found. Non-zero, if no matching

   601 descriptor element can be found. */

   602 	{

   603 	TKeyDesC16Array key(aTextComparisonType);

   604 	const TDesC16* tmp=(&aPtr);

   605 	return(CArrayFixBase::Find(&tmp,key,aPos));

   606 	}

   608 EXPORT_C TInt CDesC16Array::FindIsq(const TDesC16& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType) const

   609 /** Finds the position of a descriptor element within the array which matches the

   610 specified descriptor, using a binary search technique. The array must

   611 be in sequence, otherwise the outcome is unpredictable.

   613 Descriptors are compared using one of the TDesC comparison functions. The

   614 enumeration aTextComparisonType governs how the descriptors are to be compared.

   616 Where an array has duplicate descriptor elements, the function cannot guarantee

   617 which matching descriptor element it will return; except that it will find

   618 one of them.

   620 @param aPtr A reference to a descriptor to be used for comparison.

   621 @param aPos If the descriptor element is found, the reference is set to the

   622 position of that descriptor element within the array. The position is relative

   623 to zero, (i.e. the first descriptor element in the array is at position 0).

   624 If the descriptor element is not found and the array is not empty, then the

   625 reference is set to the position of the first descriptor element in the array

   626 whose content is greater than the content of aPtr. If the descriptor element

   627 is not found and the array is empty, then the reference is set to zero.

   628 @param aTextComparisonType An enumeration which determines the type of comparison

   629 to be made between descriptors. If no parameter is explicitly passed, ECmpFolded

   630 is used by default.

   631 @return Zero, if a matching descriptor element is found. Non-zero, if no matching

   632 descriptor element can be found. */

   633 	{

   634 	TKeyDesC16Array key(aTextComparisonType);

   635 	const TDesC16* tmp=(&aPtr);

   636 	return(CArrayFixBase::FindIsq(&tmp,key,aPos));

   637 	}

   639 /**

   640  *

   641  * Constructs a flat descriptor array with the specified granularity.

   642  *

   643  * No memory is allocated to the array buffer by this constructor.

   644  *

   645  * @param     "TInt aGranularity"

   646  *            The granularity of the array. This value must be

   647  *            positive otherwise the constructor raises an

   648  *            E32USER-CBase 18 panic.

   649  */

   650 EXPORT_C CDesC16ArrayFlat::CDesC16ArrayFlat(TInt aGranularity)

   651     : CDesC16Array((TBufRep)CBufFlat::NewL,aGranularity)

   652     {

   653 	__DECLARE_NAME(_S("CDesC16ArrayFlat"));

   654     }

   656 EXPORT_C CDesC16ArrayFlat::~CDesC16ArrayFlat()

   657 /** Frees all resources owned by the object, prior to its destruction. */

   658     {}

   660 EXPORT_C CDesC16ArraySeg::CDesC16ArraySeg(TInt aGranularity)

   661     : CDesC16Array((TBufRep)CBufSeg::NewL,aGranularity)

   662 /** Construct a segmented descriptor array with the specified granularity.

   664 No memory is allocated to the array buffer by this C++ constructor.

   666 @param aGranularity The granularity of the array. This value must be positive

   667 otherwise the constructor raises an E32USER-CBase 18 panic. */

   668     {

   669 	__DECLARE_NAME(_S("CDesC16ArraySeg"));

   670     }

   672 EXPORT_C CDesC16ArraySeg::~CDesC16ArraySeg()

   673 /** Frees all resources owned by the object, prior to its destruction. */

   674     {}

   676 //

   677 //	class CPtrC8Array

   678 //

   680 EXPORT_C CPtrC8Array::CPtrC8Array(TInt aGranularity)

   681 	: CArrayFixFlat<TPtrC8>(aGranularity)

   682 /** Constructs an array of 8 bit non-modifiable descriptors with the specified

   683 granularity. The length of all elements in the array buffer is the length

   684 of a TPtrC8 object.

   686 No memory is allocated to the array buffer by this constructor.

   688 @param aGranularity The granularity of the array. This value must be positive

   689 otherwise the constructor raises an E32USER-CBase 18 panic. */

   690 	{

   691 	__DECLARE_NAME(_S("CPtrC8Array"));

   692 	}

   694 EXPORT_C CPtrC8Array::~CPtrC8Array()

   695 /** Frees all resources owned by the object, prior to its destruction. */

   696 	{}

   698 EXPORT_C TInt CPtrC8Array::MdcaCount() const

   699 /** Returns the number of elements in the array. The function implements the pure

   700 virtual function MDesC8Array::MdcaCount().

   702 @return The number of elements. */

   703 	{

   704 	return(Count());

   705 	}

   707 EXPORT_C TPtrC8 CPtrC8Array::MdcaPoint(TInt aIndex) const

   708 /** Indexes into the descriptor array. The function implements the pure virtual

   709 function MDesC8Array::MdcaPoint().

   711 @param aIndex The position of the descriptor element within the array. The

   712 position is relative to zero; i.e. zero implies the first descriptor element

   713 in the array. This value must be non-negative and must be less than the number

   714 of elements currently in the array otherwise the operator raises a E32USER-CBase

   715 21 panic.

   716 @return A non-modifiable pointer descriptor for the data represented by the

   717 element at position aIndex within the array. */

   718 	{

   719 	return(At(aIndex));

   720 	}

   722 EXPORT_C void CPtrC8Array::CopyL(const MDesC8Array& aArray)

   723 /** Copies a descriptor array into this array, deleting any pre-existing elements.

   725 The function constructs TPtrC8 elements for each descriptor element in the

   726 specified descriptor array.

   728 @param aArray A reference to any descriptor array which satisfies the protocol

   729 defined by this mixin class. */

   730 	{

   731 	Reset();

   732 	TInt count=aArray.MdcaCount();

   733 	for (TInt i=0;i<count;++i)

   734 		AppendL(aArray.MdcaPoint(i));

   735 	}

   737 //

   738 //	class CPtrC16Array

   739 //

   741 EXPORT_C CPtrC16Array::CPtrC16Array(TInt aGranularity)

   742 	: CArrayFixFlat<TPtrC16>(aGranularity)

   743 /** Constructs an array of 16 bit non-modifiable descriptors with the specified

   744 granularity. The length of all elements in the array buffer is the length

   745 of a TPtrC16 object.

   747 No memory is allocated to the array buffer by constructor.

   749 @param aGranularity The granularity of the array. This value must be positive

   750 otherwise the constructor raises an E32USER-CBase 18 panic. */

   751 	{

   752 	__DECLARE_NAME(_S("CPtrC16Array"));

   753 	}

   755 EXPORT_C CPtrC16Array::~CPtrC16Array()

   756 /** Frees all resources owned by the object, prior to its destruction. */

   757 	{}

   759 EXPORT_C TInt CPtrC16Array::MdcaCount() const

   760 /** Returns the number of elements in the array. The function implements the pure

   761 virtual function MDesC16Array::MdcaCount().

   763 @return The number of elements. */

   764 	{

   765 	return(Count());

   766 	}

   768 EXPORT_C TPtrC16 CPtrC16Array::MdcaPoint(TInt aIndex) const

   769 /** Indexes into the descriptor array. The function implements the pure virtual

   770 function MDesC16Array::MdcaPoint().

   772 @param aIndex The position of the descriptor element within the array. The

   773 position is relative to zero; i.e. zero implies the first descriptor element

   774 in the array. This value must be non-negative and must be less than the number

   775 of elements currently in the array otherwise the operator raises a E32USER-CBase

   776 21 panic.

   777 @return A non-modifiable pointer descriptor for the data represented by the

   778 element at position aIndex within the array. */

   779 	{

   780 	return(At(aIndex));

   781 	}

   783 EXPORT_C void CPtrC16Array::CopyL(const MDesC16Array& aArray)

   784 /** Copies a descriptor array into this array, deleting any pre-existing elements.

   786 The function constructs TPtrC16 elements for each descriptor element in the

   787 specified descriptor array.

   789 @param aArray A reference to any descriptor array which satisfies the protocol

   790 defined by this mixin class. */

   791 	{

   792 	Reset();

   793 	TInt count=aArray.MdcaCount();

   794 	for (TInt i=0;i<count;++i)

   795 		AppendL(aArray.MdcaPoint(i));

   796 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--