TB10.1 Example Applications: examples/Base/ArraysAndLists/DynamicArrays/DynamicArrays.cpp Source File

00001 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
-00002 // All rights reserved.
-00003 // This component and the accompanying materials are made available
-00004 // under the terms of "Eclipse Public License v1.0"
-00005 // which accompanies this distribution, and is available
-00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
-00007 //
-00008 // Initial Contributors:
-00009 // Nokia Corporation - initial contribution.
-00010 //
-00011 // Contributors:
-00012 //
-00013 // Description:
-00014 // Examples to demonstrate arrays
-00015 //
-00016 
-00017 #include "CommonFramework.h"
-00018 #include <e32math.h>
-00019 #include <e32std.h>
-00020 
-00021 _LIT(KMsgNewLine,"\n");
-00022 _LIT(KMsgPressAnyKey," (press any key to continue)\n");
-00023 _LIT(KFormat1,"X%u");
-00024 
-00025 const TText* firstElement =  _S("DynamicArray: first");
-00026 const TText* secondElement = _S("Example Code: second");
-00027 const TText* thirdElement =  _S("ArrayKeys Ex: third");
-00028 
-00029 //
-00030 // A T type class used in the example demonstrating the:
-00031 // CArrayFixFlat class
-00032 //
-00033 class TElement
-00034         {
-00035 public :
-00036         TElement();
-00037 public :
-00038         TBuf<4> iData;
-00039         };
-00040 
-00041 TElement::TElement()
-00042         {
-00043         _LIT(KTextBase,"BASE");
-00044         iData = KTextBase;
-00045         }
-00046 
-00047 class CArrayElement
-00048         {
-00049 public :
-00050         CArrayElement();
-00051         TBool operator==(const CArrayElement& aElement) const;
-00052 public :
-00053         TBuf<4> iData;
-00054         };
-00055 
-00056 CArrayElement::CArrayElement()
-00057         {
-00058         _LIT(KTextBase,"BASE");
-00059         iData = KTextBase;
-00060         }
-00061 
-00062 TBool CArrayElement::operator==(const CArrayElement& aElement) const
-00063         {
-00064         return (iData == aElement.iData);
-00065         }
-00066 
-00067 //
-00068 // A CBase derived class used in the example demonstrating the CArrayPtrFlat
-00069 // array
-00070 //
-00071 class CElement : public CBase
-00072         {
-00073 public :
-00074         CElement();
-00075         ~CElement();
-00076         void SetTextL(const TDesC& aText);
-00077 public :
-00078         HBufC* iBuf;
-00079         };
-00080 
-00081 CElement::CElement()
-00082         {
-00083         }
-00084 
-00085 CElement::~CElement()
-00086         {
-00087         delete iBuf;
-00088         }
-00089 
-00094 void CElement::SetTextL(const TDesC& aText)
-00095         {
-00096         if (!iBuf)
-00097                 {
-00098                 // The buffer is not created.
-00099                 // Hence, create the heap buffer.
-00100                 // Set the length of CElement::iBuf to the length of aText.
-00101                 iBuf  = HBufC::NewL(aText.Length());
-00102                 }
-00103 
-00104         else if(iBuf->Length() != aText.Length() )
-00105                 {
-00106                 // The Buffer exists but is a different size to the input text.
-00107                 iBuf = iBuf->ReAllocL(aText.Length());
-00108                 }
-00109         // Copy the contents of aText to iBuf.
-00110         *iBuf = aText;
-00111         }
-00112 
-00113 TInt Order64Bit(const TInt64& aLeft, const TInt64& aRight)
-00114      {
-00115      if (aLeft<aRight)
-00116          return -1;
-00117     if (aLeft==aRight)
-00118          return 0;
-00119      return 1;
-00120      }
-00121 
-00128 class TIntPtrElement
-00129         {
-00130 public :
-00131         TIntPtrElement();
-00132         void SetIntPtr(TInt* aPtr);
-00133 public :
-00134         TBuf<4> iData;
-00139         TInt* iIntPtr;
-00140         };
-00141 
-00145 TIntPtrElement::TIntPtrElement()
-00146         {
-00147         _LIT(KTextBase,"BASE");
-00148         iData = KTextBase;
-00149         }
-00150 
-00155 void TIntPtrElement::SetIntPtr(TInt* aPtr)
-00156         {
-00157         iIntPtr = aPtr;
-00158         }
-00166 class TKeyTIntPtr : public TKeyArrayFix
-00167         {
-00168 public:
-00169         TKeyTIntPtr(TInt aOffset, TKeyCmpText aType);
-00170         TKeyTIntPtr(TInt aOffset, TKeyCmpNumeric aType);
-00171         TAny* At(TInt aIndex);
-00172         };
-00173 
-00179 TKeyTIntPtr::TKeyTIntPtr(TInt aOffset, TKeyCmpText aType):TKeyArrayFix(aOffset,aType)
-00180         {
-00181         }
-00182 
-00187 TKeyTIntPtr::TKeyTIntPtr(TInt aOffset, TKeyCmpNumeric aType):TKeyArrayFix(aOffset,aType)
-00188         {
-00189         }
-00190 
-00197 TAny* TKeyTIntPtr::At(TInt aIndex)
-00198         {
-00199         if (aIndex==KIndexPtr)
-00200         {
-00201         return((TUint8 *)iPtr+iKeyOffset);
-00202         }
-00203         // Get the address of the array element.
-00204         TIntPtrElement* ptr = (TIntPtrElement *)(iBase->Ptr(aIndex*sizeof(TIntPtrElement)).Ptr()+iKeyOffset);
-00205         // The TIntPtrElement::iIntPtr points to the key.
-00206         // Return the key.
-00207         return(ptr->iIntPtr);
-00208         }
-00209 
-00214 void PrintFixIntPtrArray(CArrayFixFlat<TIntPtrElement>& aFixFlat)
-00215         {
-00216         _LIT(KMsgContentsIntPtr,"Contents of the array of TIntPtrElement objects.\n");
-00217         console->Printf(KMsgContentsIntPtr);
-00218         for (TInt forix = 0; forix < aFixFlat.Count(); forix++)
-00219                 {
-00220                 console->Printf(KMsgNewLine);
-00221                 _LIT(KMsgBuf,"Index: %d\n Descriptor:");
-00222                 console->Printf(KMsgBuf,forix);
-00223                 console->Printf(aFixFlat[forix].iData);
-00224                 _LIT(KMsgInt,"\t\tInteger Value: %d");
-00225                 console->Printf(KMsgInt,*(aFixFlat[forix].iIntPtr));
-00226                 }
-00227         console->Printf(KMsgNewLine);
-00228         }
-00229 
-00234 void PrintFixArray(CArrayFixFlat<TElement>& aFixFlat)
-00235         {
-00236         for (TInt forix = 0; forix < aFixFlat.Count(); forix++)
-00237                 {
-00238                 console->Printf(KMsgNewLine);
-00239                 console->Printf(aFixFlat[forix].iData);
-00240                 }
-00241         console->Printf(KMsgNewLine);
-00242         }
-00243 
-00248 void PrintPtrArray(CArrayPtrFlat<CElement>* aPtrFlat)
-00249         {
-00250         _LIT(KCommonFormat4,"\n%S");
-00251         for (TInt forix = 0; forix < aPtrFlat->Count(); forix++)
-00252                 {
-00253                 console->Printf(KCommonFormat4,((*aPtrFlat)[forix])->iBuf);
-00254                 }
-00255         }
-00256 
-00260 class TMySwap : public TSwap
-00261         {
-00262 public:
-00263         TMySwap(CArrayFixFlat<TElement>* aArray);
-00264         void Swap(TInt aLeft,TInt aRight);
-00265 private:
-00266                                 // The Swap() function is defined for this array.
-00267         CArrayFixFlat<TElement>* iArray;
-00268         };
-00269 
-00273 TMySwap::TMySwap(CArrayFixFlat<TElement>* aArray):iArray(aArray)
-00274         {
-00275         }
-00276 
-00282 void TMySwap::Swap(TInt aLeft,TInt aRight)
-00283         {
-00284         TBuf<4> tbuf(iArray->At(aLeft).iData);
-00285         iArray->At(aLeft).iData.Copy(iArray->At(aRight).iData);
-00286         iArray->At(aRight).iData.Copy(tbuf);
-00287         }
-00288 
-00294 void DemoPakArrayFindL(CArrayPak<TText>& aPakFlat)
-00295         {
-00296         // Append TText strings to the aPakFlat array.
-00297 
-00298         // The length of the string to be appended is increased by one
-00299         // to insert the '\0' character at the end of the TText string.
-00300         // This is needed as the '\0' character is absent in descriptors.
-00301         aPakFlat.AppendL(*firstElement,(User::StringLength(firstElement)+1)*sizeof(TText));
-00302 
-00303         // Insert the second element into the array.
-00304         aPakFlat.AppendL(*secondElement,(User::StringLength(secondElement)+1)*sizeof(TText));
-00305 
-00306         // Insert the third element into the array.
-00307         aPakFlat.AppendL(*thirdElement,(User::StringLength(thirdElement)+1)*sizeof(TText));
-00308 
-00309         // Print the array elements.
-00310         _LIT(KCommonFormat7,"Array Contents");
-00311         console->Printf(KCommonFormat7);
-00312         console->Printf(KMsgPressAnyKey);
-00313         console->Getch();
-00314 
-00315         TInt length = aPakFlat.Count();
-00316         for(TInt ix = 0; ix < length; ix++)
-00317                 {
-00318                 console->Printf(TPtrC(&aPakFlat[ix]));
-00319                 console->Printf(KMsgNewLine);
-00320                 }
-00321 
-00322         // Find an element in the array.
-00323         _LIT(KMsgFind,"\n--->Find");
-00324         console->Printf(KMsgFind);
-00325         _LIT(KMsgFindElement,"\nSearching the array for:");
-00326         console->Printf(KMsgFindElement);
-00327 
-00328         // The descriptor, buf contains the string "Code".
-00329         // The CArrayPak::Find() function will try to find this string in the array.
-00330         console->Printf(TPtrC(thirdElement));
-00331 
-00332         // The key to find the element.
-00333         // The length of the key is set to 12.
-00334         // Thus, first 12 characters of all strings are compared with the key.
-00335         TKeyArrayPak keypak(0,ECmpNormal,12);
-00336 
-00337         // Initialise the index to -1.
-00338         TInt index = -1;
-00339 
-00340         // Perform the search.
-00341         if(aPakFlat.Find(*thirdElement,keypak,index) == 0)
-00342                 {
-00343                 // Successful search.
-00344                 // The index variable holds the index of the element found.
-00345                 _LIT(KElementFound,"\nElement found at %d\n");
-00346                 console->Printf(KElementFound,index);
-00347                 }
-00348         else
-00349                 {
-00350                 // Unsuccessful search.
-00351                 // The element is not found.
-00352                 _LIT(KElementNotFound,"\nElement not found");
-00353                 console->Printf(KElementNotFound);
-00354                 }
-00355         }
-00356 
-00362 void DemoVarArraySortL(CArrayVar<TText>& aVarFlat)
-00363         {
-00364         // Append TText strings to the aVarFlat array.
-00365 
-00366         // The length of the string to be appended is increased by one
-00367         // to insert the '\0' character at the end of the TText string.
-00368         // This is needed as the '\0' character is absent in descriptors.
-00369         aVarFlat.AppendL(*firstElement,(User::StringLength(firstElement)+1)*sizeof(TText));
-00370 
-00371         // Insert the second and third elements into the array.
-00372         aVarFlat.AppendL(*secondElement,(User::StringLength(secondElement)+1)*sizeof(TText));
-00373         aVarFlat.AppendL(*thirdElement,(User::StringLength(thirdElement)+1)*sizeof(TText));
-00374 
-00375         // Print the array elements.
-00376         _LIT(KCommonFormat6,"Array Contents [Before Sort]");
-00377         console->Printf(KCommonFormat6);
-00378 
-00379         console->Printf(KMsgPressAnyKey);
-00380         console->Getch();
-00381 
-00382         TInt length = aVarFlat.Count();
-00383         for(TInt ix = 0; ix < length; ix++)
-00384                 {
-00385                 console->Printf(TPtrC(&aVarFlat[ix]));
-00386                 console->Printf(KMsgNewLine);
-00387                 }
-00388 
-00389         // The key to find the element.
-00390         // The length of the key is set to 12.
-00391         // Thus, first 12 characters of the string are compared with the key.
-00392         TKeyArrayVar keyvar(0,ECmpFolded,12);
-00393 
-00394         // Sort the array using the TKeyArrayVar key.
-00395         aVarFlat.Sort(keyvar);
-00396 
-00397         // Print the sorted array elements.
-00398         _LIT(KMsgSort,"\n--->Sort");
-00399         console->Printf(KMsgSort);
-00400         console->Printf(KMsgPressAnyKey);
-00401         console->Getch();
-00402 
-00403         for(TInt ix = 0; ix < length; ix++)
-00404                 {
-00405                 console->Printf(TPtrC(&aVarFlat[ix]));
-00406                 console->Printf(KMsgNewLine);
-00407                 }
-00408         }
-00413 void DemoFlatArrayL(CArrayFixFlat<TElement>& aFixFlat)
-00414         {
-00415         TElement theElement;
-00416 
-00417         TInt value;
-00418         for (value = 0; value < 3; value++)
-00419                 {
-00420                 theElement.iData.Format(KFormat1,value);
-00421                 aFixFlat.AppendL(theElement);
-00422                 }
-00423 
-00424                                 // Show length of each element.
-00425                                 // The length of each element of the array is the size of the
-00426                                 // TElement class.
-00427         _LIT(KCommonFormat2,"\nLength()=%d");
-00428         console->Printf(KCommonFormat2,aFixFlat.Length());
-00429 
-00430                                 // Show number of elements.
-00431         _LIT(KCommonFormat3,"\nCount()=%d");
-00432         console->Printf(KCommonFormat3,aFixFlat.Count());
-00433 
-00434                                 // Show each element
-00435         PrintFixArray(aFixFlat);
-00436                                 //
-00437                                 // InsertL  * * * * * * * * *
-00438                                 //
-00439         _LIT(KMsgInsert,"\n\n--->InsertL");
-00440         console->Printf(KMsgInsert);
-00441         _LIT(KMsgPressAnyKey," (press any key to continue)\n");
-00442         console->Printf(KMsgPressAnyKey);
-00443         console->Getch();
-00444 
-00445                                 // Insert elements
-00446                                 // ... at the beginning,
-00447         _LIT(KMsgBEG,"BEG");
-00448         theElement.iData = KMsgBEG;
-00449         aFixFlat.InsertL(0,theElement);
-00450 
-00451                                 // ... near the middle,
-00452         _LIT(KMsgMID,"MID");
-00453         theElement.iData = KMsgMID;
-00454         aFixFlat.InsertL(2,theElement);
-00455 
-00456                                 // ... at the end.
-00457                                 // This is the same as using the AppendL() function
-00458         _LIT(KMsgEND,"END");
-00459         theElement.iData = KMsgEND;
-00460         aFixFlat.InsertL(aFixFlat.Count(),theElement);
-00461 
-00462                                 // Show number of elements
-00463         _LIT(KCommonFormat5,"Count()=%d");
-00464         console->Printf(KCommonFormat5,aFixFlat.Count());
-00465 
-00466                                 // Show each element
-00467         PrintFixArray(aFixFlat);
-00468 
-00469                                 // Define the key to sort the array.
-00470                                 // The data member of the TElement class, iData, is the key.
-00471         TKeyArrayFix keyfix(_FOFF(TElement,iData),ECmpFolded);
-00472 
-00473                                 // Sort the array.
-00474         aFixFlat.Sort(keyfix);
-00475 
-00476                                 // Print the sorted array.
-00477         _LIT(KMsgSort,"\n--->Sort");
-00478         console->Printf(KMsgSort);
-00479         console->Printf(KMsgPressAnyKey);
-00480         console->Getch();
-00481 
-00482         PrintFixArray(aFixFlat);
-00483 
-00484                                 //
-00485                                 // Delete  * * * * * * * * *
-00486                                 //
-00487         _LIT(KMsgDelete,"\n\n--->Delete");
-00488         console->Printf(KMsgDelete);
-00489         console->Printf(KMsgPressAnyKey);
-00490         console->Getch();
-00491 
-00492                                 // Delete the 2nd, 4th and 5th elements. Note:
-00493                                 //
-00494                                 //  1. We use position to identify the elements (i.e. offset)
-00495                                 //  2. As elements are deleted, the position of other
-00496                                 //       elements changes.
-00497 
-00498         aFixFlat.Delete(1);             // delete the 2nd
-00499         aFixFlat.Delete(2,2);   // delete what are now the 3rd and 4th
-00500 
-00501         aFixFlat.Compress();    // compress the array
-00502 
-00503                                 // Show number of elements
-00504         console->Printf(KCommonFormat5,aFixFlat.Count());
-00505 
-00506                                 // Show each element
-00507         PrintFixArray(aFixFlat);
-00508                                 //
-00509                                 // Reset  * * * * * * * * *
-00510                                 //
-00511         _LIT(KMsgReset,"\n\n--->Reset");
-00512         console->Printf(KMsgReset);
-00513         console->Printf(KMsgPressAnyKey);
-00514         console->Getch();
-00515 
-00516                                 // reset the array (i.e. empty it)
-00517         aFixFlat.Reset();
-00518 
-00519                                 // Show number of elements
-00520         console->Printf(KCommonFormat5,aFixFlat.Count());
-00521 
-00522                                 // Show each element
-00523         PrintFixArray(aFixFlat);
-00524 
-00525                                 //
-00526                                 // ExpandL & ExtendL  * * * * * * * * *
-00527                                 //
-00528         _LIT(KMsgExpandExtend,"\n\n--->ExpandL & ExtendL");
-00529         console->Printf(KMsgExpandExtend);
-00530         console->Printf(KMsgPressAnyKey);
-00531         console->Getch();
-00532 
-00533                                 // re-build the array
-00534         _LIT(KFormat6,"%u");
-00535         for (value = 0; value < 3; value++)
-00536                 {
-00537                 theElement.iData.Format(KFormat6,value);
-00538                 aFixFlat.AppendL(theElement);
-00539                 }
-00540                                 // Expand by constructing a new element at position 1.
-00541                                 // Extend the array.
-00542                                 //
-00543                                 // Note the use of the TElement default constructor
-00544                                 // in both cases
-00545         aFixFlat.ExpandL(1);
-00546         aFixFlat.ExtendL();
-00547 
-00548                                 // Show number of elements
-00549         console->Printf(KCommonFormat5,aFixFlat.Count());
-00550 
-00551                                 // Show each element
-00552         PrintFixArray(aFixFlat);
-00553 
-00554                                 //
-00555                                 // ResizeL * * * * * * * * * * * *
-00556                                 //
-00557         _LIT(KMsgResize,"\n\n--->ResizeL");
-00558         console->Printf(KMsgResize);
-00559         console->Printf(KMsgPressAnyKey);
-00560         console->Getch();
-00561 
-00562                                 // Resize the array so that it only contains
-00563                                 // one element
-00564         aFixFlat.ResizeL(1);
-00565 
-00566                                 // Resize so that it contains 3 elements.
-00567                                 // The two new elements are bit-wise copies
-00568                                 // of a TElement object constructed using
-00569                                 // its default constructor.
-00570         aFixFlat.ResizeL(3);
-00571 
-00572                                 // Resize so that it contains 5 elements.
-00573                                 // The two new elements are bit-wise copies of
-00574                                 // the TElement object passed through
-00575                                 // the reference.
-00576         _LIT(KMsgXXX,"XXX");
-00577         theElement.iData = KMsgXXX;
-00578         aFixFlat.ResizeL(5,theElement);
-00579 
-00580                                 // Show number of elements
-00581         console->Printf(KCommonFormat5,aFixFlat.Count());
-00582 
-00583                                 // Show each element
-00584         PrintFixArray(aFixFlat);
-00585 
-00586                                 //
-00587                                 // SetReserveL * * * * * * * * * * * *
-00588                                 //
-00589         _LIT(KMsgSetReserve,"\n\n--->SetReserveL");
-00590         console->Printf(KMsgSetReserve);
-00591         console->Printf(KMsgPressAnyKey);
-00592         console->Getch();
-00593 
-00594                                 // Reserve sufficient space to append another
-00595                                 // five elements.
-00596                                 // This function may leave if there is
-00597                                 // insufficient memory.
-00598                                 // NOTE: this does NOT increase the number of
-00599                                 //         elements in the array.
-00600         aFixFlat.SetReserveL(5);
-00601 
-00602                                 // We can now append five elements and be sure that
-00603                                 // no leave will occur.
-00604         _LIT(KMsgDoubleAtoE,"AABBCCDDEE");
-00605         TBufC<10> source(KMsgDoubleAtoE);
-00606         TInt forix;
-00607         for (forix = 0; forix < source.Length(); forix+=2)
-00608                 {
-00609                 theElement.iData = source.Mid(forix,2);
-00610                 aFixFlat.AppendL(theElement);
-00611                 }
-00612 
-00613                                 // Show number of elements
-00614         console->Printf(KCommonFormat5,aFixFlat.Count());
-00615 
-00616                                 // Show each element
-00617         PrintFixArray(aFixFlat);
-00618 
-00619                                 // An object of the TMySwap class.
-00620                                 // It is used to swap two elements of the array.
-00621         TMySwap swap(&aFixFlat);
-00622 
-00623                                 // Swap the first and the last element of the array.
-00624         swap.Swap(0,(aFixFlat.Count() - 1));
-00625 
-00626                                 // Print the array.
-00627         _LIT(KMsgSwap,"\n--->Swap [First and Last element]");
-00628         console->Printf(KMsgSwap);
-00629         console->Printf(KMsgPressAnyKey);
-00630         console->Getch();
-00631 
-00632         PrintFixArray(aFixFlat);
-00633         console->Printf(KMsgPressAnyKey);
-00634         console->Getch();
-00635         }
-00636 
-00641 void DemoPtrArrayL(CArrayPtrFlat<CElement>& aPtrFlat)
-00642         {
-00643         CElement*  ptr;
-00644         ptr = new (ELeave) CElement;
-00645         _LIT(KMsgFirstElement,"First Element");
-00646         ptr->SetTextL(KMsgFirstElement);
-00647         aPtrFlat.AppendL(ptr);
-00648 
-00649 
-00650         ptr = new (ELeave) CElement;
-00651         _LIT(KMsgSecondElement,"Second Element");
-00652         ptr->SetTextL(KMsgSecondElement);
-00653         aPtrFlat.AppendL(ptr);
-00654 
-00655 
-00656         ptr = new (ELeave) CElement;
-00657         _LIT(KMsgThirdElement,"Third Element");
-00658         ptr->SetTextL(KMsgThirdElement);
-00659         aPtrFlat.AppendL(ptr);
-00660 
-00661 
-00662                                 // Show length of each element
-00663         _LIT(KCommonFormat2,"\nLength()=%d");
-00664         console->Printf(KCommonFormat2,aPtrFlat.Length());
-00665 
-00666                                 // Show number of elements
-00667         _LIT(KCommonFormat3,"\nCount()=%d");
-00668         console->Printf(KCommonFormat3,aPtrFlat.Count());
-00669 
-00670                                 // Show each element
-00671         PrintPtrArray(&aPtrFlat);
-00672                                 //
-00673                                 // InsertL  * * * * * * * * *
-00674                                 //
-00675         _LIT(KMsgInsert,"\n\n--->InsertL");
-00676         console->Printf(KMsgInsert);
-00677         console->Printf(KMsgPressAnyKey);
-00678         console->Getch();
-00679 
-00680                                 // Insert an element at the beginning
-00681                                 // of the array.
-00682 
-00683         ptr = new (ELeave) CElement;
-00684         _LIT(KMsgInsertedBeg,"Inserted @ beginning Element");
-00685         ptr->SetTextL(KMsgInsertedBeg);
-00686         aPtrFlat.InsertL(0,ptr);
-00687 
-00688                                 // Show number of elements
-00689         _LIT(KCommonFormat5,"Count()=%d");
-00690         console->Printf(KCommonFormat5,aPtrFlat.Count());
-00691 
-00692                                 // Show each element
-00693         PrintPtrArray(&aPtrFlat);
-00694 
-00695                                 //
-00696                                 // Delete  * * * * * * * * *
-00697                                 //
-00698         _LIT(KMsgDelete,"\n\n--->Delete");
-00699         console->Printf(KMsgDelete);
-00700         console->Printf(KMsgPressAnyKey);
-00701         console->Getch();
-00702 
-00703                                 // Delete the last two elements from the array BUT
-00704                                 // first we must get a reference to those elements
-00705                                 // (pointers to CElement objects) otherwise
-00706                                 // the CElement objects are orphaned.
-00707                                 //
-00708                                 // Here, we destroy those CElement objects.
-00709                                 //
-00710                                 // There are two alternative ways of indexing into
-00711                                 // the array, using either At() or the [] operator
-00712 
-00713                                 // NOTE that the code below could be compressed to:
-00714                                 //
-00715                                 // delete (*ptrflat)[aPtrFlat.Count()-1];
-00716                                 // delete (*ptrflat)[aPtrFlat.Count()-2];
-00717                                 // aPtrFlat.Delete(aPtrFlat.Count()-2,2);
-00718 
-00719         TInt index = -1;
-00720         index = aPtrFlat.Count();
-00721 
-00722         ptr = aPtrFlat[--index];
-00723         aPtrFlat.Delete(index);
-00724         delete ptr;
-00725 
-00726         ptr = aPtrFlat.At(--index);
-00727         aPtrFlat.Delete(index);
-00728         delete ptr;
-00729 
-00730                                 // Show number of elements
-00731         console->Printf(KCommonFormat5,aPtrFlat.Count());
-00732 
-00733                                 // Show each element
-00734         PrintPtrArray(&aPtrFlat);
-00735 
-00736                                 //
-00737                                 // At & the [] operator * * * * * * * * * * * *
-00738                                 //
-00739         _LIT(KMsgAt,"\n\n--->At() and the operator []");
-00740         console->Printf(KMsgAt);
-00741         console->Printf(KMsgPressAnyKey);
-00742         console->Getch();
-00743 
-00744                                 // Make a change to the object pointed to by the first element in the array
-00745         _LIT(KMsgNewTextFirst,"New text for the first CElement");
-00746         _LIT(KMsgNewTextSecond,"New text for the second CElement");
-00747         aPtrFlat[0]->SetTextL(KMsgNewTextFirst);
-00748         aPtrFlat.At(1)->SetTextL(KMsgNewTextSecond);
-00749 
-00750                                 // Show number of elements
-00751         console->Printf(KCommonFormat5,aPtrFlat.Count());
-00752 
-00753                                 // Show each element
-00754         PrintPtrArray(&aPtrFlat);
-00755 
-00756                                 //
-00757                                 // ResetAndDestroy  * * * * * * * * *
-00758                                 //
-00759         _LIT(KMsgResetDestroy,"\n\n--->ResetAndDestroy");
-00760         console->Printf(KMsgResetDestroy);
-00761         console->Printf(KMsgPressAnyKey);
-00762         console->Getch();
-00763 
-00764                                 // destroy all of the CElement objects and reset the
-00765                                 // array.
-00766         aPtrFlat.ResetAndDestroy();
-00767 
-00768                                 // Show number of elements
-00769         console->Printf(KCommonFormat3,aPtrFlat.Count());
-00770 
-00771                                 // Show each element
-00772         PrintPtrArray(&aPtrFlat);
-00773 
-00774         console->Printf(KMsgNewLine);
-00775         }
-00776 
-00782 void DemoTKeyDerivedL(CArrayFixFlat<TIntPtrElement>& aFixFlat)
-00783         {
-00784         TIntPtrElement theIntPtrElement;
-00785 
-00786         // Create pointers to integers.
-00787         TInt* ptrInt1 = new(ELeave)TInt(10);
-00788         CleanupStack::PushL(ptrInt1);
-00789         TInt* ptrInt2 = new(ELeave)TInt(0);
-00790         CleanupStack::PushL(ptrInt2);
-00791         TInt* ptrInt3 = new(ELeave)TInt(5);
-00792         CleanupStack::PushL(ptrInt3);
-00793 
-00794         // Create an array of pointers.
-00795         TInt* ptrInt[3] = {ptrInt1,ptrInt2,ptrInt3};
-00796 
-00797         // Append elements into the ptrElementArray array.
-00798         TInt value;
-00799         for (value = 0; value < 3; value++)
-00800                 {
-00801                 theIntPtrElement.iData.Format(KFormat1,value);
-00802                 theIntPtrElement.SetIntPtr(ptrInt[value]);
-00803                 aFixFlat.AppendL(theIntPtrElement);
-00804                 }
-00805 
-00806         // Print the contents of the array.
-00807         PrintFixIntPtrArray(aFixFlat);
-00808 
-00809                                 // Define the key to find an element in the array.
-00810                                 // Use the TKey derived class, TKeyTIntPtr to do this.
-00811         TKeyTIntPtr keyIntPtr(_FOFF(TIntPtrElement,iIntPtr),ECmpTInt);
-00812 
-00813         _LIT(KMsgFind,"\n--->Find");
-00814         console->Printf(KMsgFind);
-00815         console->Printf(KMsgPressAnyKey);
-00816         console->Getch();
-00817 
-00818         // Initialise to -1.
-00819         // Its value will be set to 0 if the Search is successful.
-00820         TInt index = -1;
-00821 
-00822         // Perform the search.
-00823         TInt res = aFixFlat.Find        (
-00824                                                                 theIntPtrElement, // The object whose
-00825                                                                 // key is used for comparison.
-00826                                                                 keyIntPtr, // The key object that
-00827                                                                 // defines the property of the key.
-00828                                                                 index
-00829                                                                 );
-00830 
-00831         if(res == 0)
-00832                 {
-00833                 // The index variable holds the index of the element found.
-00834                 _LIT(KElementFound,"\nElement found at index: %d\n");
-00835                 console->Printf(KElementFound,index);
-00836                 }
-00837 
-00838         else
-00839                 {
-00840                 // The element is not found.
-00841                 _LIT(KElementNotFound,"\nElement not found");
-00842                 console->Printf(KElementNotFound);
-00843                 }
-00844 
-00845         CleanupStack::PopAndDestroy(3, ptrInt1); // ptrInt3, ptrInt2 and ptrInt1.
-00846         }
-00847 
-00852 void DemoRArrayL(RArray<CArrayElement>& aArray)
-00853         {
-00854         CArrayElement arrayElement;
-00855 
-00856                         //
-00857                         // AppendL  * * * * * * * * *
-00858                         //
-00859         _LIT(KMsgAppend,"\n\n--->AppendL");
-00860         console->Printf(KMsgAppend);
-00861 
-00862         console->Printf(KMsgPressAnyKey);
-00863         console->Getch();
-00864 
-00865         TInt value;
-00866         for (value = 0; value < 3; value++)
-00867                 {
-00868                 // Formats and copies text into this descriptor, replacing any existing data.
-00869                 arrayElement.iData.Format(KFormat1,value);
-00870                 aArray.AppendL(arrayElement); // leaves with one of the system wide error codes, if the operation fails.
-00871                 }
-00872 
-00873                                 // Show number of elements
-00874         _LIT(KCommonFormat3,"\nCount()=%d");
-00875         console->Printf(KCommonFormat3,aArray.Count());
-00876 
-00877                                 // Show each element
-00878         TInt forix;
-00879         _LIT(KCommonFormat4,"\n%S");
-00880         for (forix = 0; forix < aArray.Count(); forix++)
-00881                 {
-00882                 console->Printf(KCommonFormat4,&(aArray)[forix].iData);
-00883                 }
-00884 
-00885                         //
-00886                         // InsertL  * * * * * * * * *
-00887                         //
-00888         _LIT(KMsgInsert,"\n\n--->InsertL");
-00889         console->Printf(KMsgInsert);
-00890         console->Printf(KMsgPressAnyKey);
-00891         console->Getch();
-00892 
-00893                                 // Inserts objects into the array at a specified position.
-00894                                 // It increases the size of the dynamic array.
-00895                                 // This function leaves with one of the system error codes, if the operation fails.
-00896 
-00897                                 // Insert arrayElements
-00898                                 // ... at the beginning,
-00899         _LIT(KMsgBEG,"BEG");
-00900         arrayElement.iData = KMsgBEG;
-00901         aArray.InsertL(arrayElement, 0);
-00902 
-00903                                 // ... near the middle,
-00904         _LIT(KMsgMID,"MID");
-00905         arrayElement.iData = KMsgMID;
-00906         aArray.InsertL(arrayElement, 2);
-00907 
-00908                                 // ... at the end.
-00909                                 // This is the same as using the AppendL() function
-00910         _LIT(KMsgEND,"END");
-00911         arrayElement.iData = KMsgEND;
-00912         aArray.InsertL(arrayElement,aArray.Count());
-00913 
-00914                                 // Show number of elements
-00915         _LIT(KCommonFormat5,"Count()=%d");
-00916         console->Printf(KCommonFormat5,aArray.Count());
-00917 
-00918                         //
-00919                         // Access elements  * * * * * * * * *
-00920                         //
-00921         _LIT(KMsgAccess,"\n\n--->Access");
-00922         console->Printf(KMsgAccess);
-00923         console->Printf(KMsgPressAnyKey);
-00924         console->Getch();
-00925 
-00926                                 // Show each element
-00927         for (forix = 0; forix < aArray.Count(); forix++)
-00928                 console->Printf(KCommonFormat4,&(aArray)[forix].iData);
-00929 
-00930                         //
-00931                         // Delete  * * * * * * * * *
-00932                         //
-00933         _LIT(KMsgDelete,"\n\n--->Delete");
-00934         console->Printf(KMsgDelete);
-00935         console->Printf(KMsgPressAnyKey);
-00936         console->Getch();
-00937 
-00938         TInt index2;
-00939         index2 = aArray.Count();
-00940 
-00941                         // Removes the objects at a specified position from the array.
-00942                         // It shrinks the array.
-00943 
-00944                         // Delete the last element
-00945         arrayElement = (aArray)[--index2];
-00946         aArray.Remove(index2);
-00947 
-00948                     // Show number of elements
-00949         console->Printf(KCommonFormat5,aArray.Count());
-00950 
-00951                         // Show each element
-00952         for (forix = 0; forix < aArray.Count(); forix++)
-00953                 console->Printf(KCommonFormat4,&(aArray)[forix].iData);
-00954 
-00955                         //
-00956                         // Find  * * * * * * * * *
-00957                         //
-00958         _LIT(KMsgFind,"\n\n--->Find in various ways");
-00959         console->Printf(KMsgFind);
-00960         console->Printf(KMsgPressAnyKey);
-00961         console->Getch();
-00962 
-00963         TInt pos =0;
-00964 
-00965                         // Find a particular element in different ways.
-00966         arrayElement = (aArray)[--index2];
-00967 
-00968         _LIT(KCommonFormat6,"\nElement %S is found at position %d");
-00969 
-00970         // Finds the first object in the array which matches the specified object using a sequential search and a matching algorithm.
-00971         pos=aArray.Find(arrayElement, TIdentityRelation<CArrayElement>());
-00972                         console->Printf(KCommonFormat6, &(aArray)[pos].iData, pos);
-00973 
-00974         // Finds the last object in the array which matches the specified object using a sequential search and a matching algorithm.
-00975         pos=aArray.FindReverse(arrayElement, TIdentityRelation<CArrayElement>());
-00976                         console->Printf(KCommonFormat6, &(aArray)[pos].iData, pos);
-00977 
-00978         // Finds the object in the array which matches the specified object using a binary search technique.It assumes that objects are in signed key order
-00979         pos=aArray.FindInSignedKeyOrder(arrayElement);
-00980                                 console->Printf(KCommonFormat6,&(aArray)[pos].iData, pos);
-00981 
-00982         //      Finds the object in the array which matches the specified object using a binary search technique. It assumes that objects are in unsigned key order.
-00983         pos=aArray.FindInUnsignedKeyOrder(arrayElement);
-00984                                 console->Printf(KCommonFormat6,&(aArray)[pos].iData, pos);
-00985 
-00986         // Finds the object in the array which matches the specified object using a binary search technique.In case of more than one matching element, finds last
-00987         // match as specified in the second parameter.It assumes that objects are in signed key order
-00988         pos=aArray.SpecificFindInSignedKeyOrder(arrayElement, EArrayFindMode_Last);
-00989                         console->Printf(KCommonFormat6,&(aArray)[pos].iData, pos);
-00990 
-00991         // Finds the object in the array which matches the specified object using a binary search technique.In case of more than one matching element, finds last
-00992         // match as specified in the second parameter.It assumes that objects are in unsigned key order
-00993         pos=aArray.SpecificFindInUnsignedKeyOrder(arrayElement, EArrayFindMode_Last);
-00994                                 console->Printf(KCommonFormat6,&(aArray)[pos].iData, pos);
-00995 
-00996                         // Closes the array and frees all memory allocated to the array
-00997         aArray.Close();
-00998         }
-00999 
-01000 void DemoRArraySort()
-01001         {
-01002                         //
-01003                         // Sort  * * * * * * * * *
-01004                         //
-01005         _LIT(KSortFind,"\n\n--->Sort");
-01006         console->Printf(KSortFind);
-01007         console->Printf(KMsgPressAnyKey);
-01008         console->Getch();
-01009 
-01010         TLinearOrder<TInt64> Int64Order(Order64Bit);
-01011         TInt count=10;
-01012 
-01013                         // Construct two arrays of 64-bit signed integer type objects.
-01014                         // Append random objects to first array.
-01015                         // Sort all objects of first array in the second array
-01016 
-01017         RArray<TInt64> firstArray(count);
-01018     RArray<TInt64> secondArray(count);
-01019 
-01020     for (TInt j=0; j<count; j++)
-01021                 {
-01022         TInt64 x=(TInt64)(((TUint)Math::Random() %count));
-01023 
-01024         firstArray.Append(x);
-01025         secondArray.InsertInOrderAllowRepeats(x,Int64Order);
-01026                 }
-01027 
-01028         // Show the initial array elements of first array.
-01029         _LIT(KInitialArrayElements,"\nInitial array elements are:");
-01030         console->Printf(KInitialArrayElements);
-01031 
-01032         _LIT(KCommonFormat7," %d");
-01033         TInt forix;
-01034         for (forix = 0; forix < count; forix++)
-01035                 console->Printf(KCommonFormat7,firstArray[forix]);
-01036 
-01037         // Sorts the objects within the array using the specified TLinearOrder
-01038         secondArray.Sort(Int64Order);
-01039 
-01040         // Show sorted array elements of second array
-01041         _LIT(KSortedArrayElements,"\nSorted array elements are:");
-01042         console->Printf(KSortedArrayElements);
-01043         for (forix = 0; forix < count; forix++)
-01044                 console->Printf(KCommonFormat7,secondArray[forix]);
-01045 
-01046         console->Getch();
-01047         console->Printf(KMsgNewLine);
-01048 
-01049                 // Closes both the arrays and frees all the memory allocated to these arrays
-01050     firstArray.Close();
-01051         secondArray.Close();
-01052         }
-01053 
-01054 void DemoRPointerArrayL(RPointerArray<CElement>& aPointerArray)
-01055         {
-01056         CElement*  elementptr;
-01057 
-01058                         //
-01059                         // AppendL  * * * * * * * * *
-01060                         //
-01061         _LIT(KMsgAppend,"\n\n--->AppendL");
-01062         console->Printf(KMsgAppend);
-01063         console->Printf(KMsgPressAnyKey);
-01064         console->Getch();
-01065 
-01066                         // Append the first element.
-01067         elementptr = new (ELeave) CElement;
-01068         _LIT(KMsgFirstElement,"First Element");
-01069         elementptr->SetTextL(KMsgFirstElement);
-01070         aPointerArray.AppendL(elementptr);
-01071 
-01072                         // Append the second element.
-01073         elementptr = new (ELeave) CElement;
-01074         _LIT(KMsgSecondElement,"Second Element");
-01075         elementptr->SetTextL(KMsgSecondElement);
-01076         aPointerArray.AppendL(elementptr);
-01077 
-01078                         // Append the third element.
-01079         elementptr = new (ELeave) CElement;
-01080         _LIT(KMsgThirdElement,"Third Element");
-01081         elementptr->SetTextL(KMsgThirdElement);
-01082         aPointerArray.AppendL(elementptr);
-01083 
-01084                                 // Show number of elements
-01085         _LIT(KCommonFormat3,"\nCount()=%d");
-01086         console->Printf(KCommonFormat3,aPointerArray.Count());
-01087 
-01088                                 // Show each element
-01089         _LIT(KCommonFormat4,"\n%S");
-01090         TInt forix;
-01091         for (forix = 0; forix < aPointerArray.Count(); forix++)
-01092                 {
-01093                 console->Printf(KCommonFormat4,aPointerArray[forix]->iBuf);
-01094                 }
-01095 
-01096                         //
-01097                         // InsertL  * * * * * * * * *
-01098                         //
-01099         _LIT(KMsgInsert,"\n\n--->InsertL");
-01100         console->Printf(KMsgInsert);
-01101         console->Printf(KMsgPressAnyKey);
-01102         console->Getch();
-01103 
-01104                                 // Inserts objects into the array at a specified position.
-01105                                 // It increases the size of the dynamic array.
-01106 
-01107                                 // Insert an element at the beginning
-01108                                 // of the array
-01109         elementptr = new (ELeave) CElement;
-01110         _LIT(KMsgInsertedBeg,"Inserted @ beginning Element");
-01111         elementptr->SetTextL(KMsgInsertedBeg);
-01112         aPointerArray.InsertL(elementptr, 0);
-01113 
-01114                                 // Show number of elements
-01115         _LIT(KCommonFormat5,"Count()=%d");
-01116         console->Printf(KCommonFormat5,aPointerArray.Count());
-01117 
-01118                         //
-01119                         // Access  * * * * * * * * *
-01120                         //
-01121                         // Show each element
-01122         for (forix = 0; forix < aPointerArray.Count(); forix++)
-01123                 {
-01124                 console->Printf(KCommonFormat4,aPointerArray[forix]->iBuf);
-01125                 }
-01126 
-01127                         //
-01128                         // Delete  * * * * * * * * *
-01129                         //
-01130         _LIT(KMsgDelete,"\n\n--->Delete");
-01131         console->Printf(KMsgDelete);
-01132         console->Printf(KMsgPressAnyKey);
-01133         console->Getch();
-01134 
-01135                         // Delete the last elements from the array BUT
-01136                         // first we must get a reference to the element
-01137                         // (pointers to CElement objects) otherwise
-01138                         // the CElement objects are orphaned.
-01139                         //
-01140                         // Here, we destroy the CElement object. It shrinks the array.
-01141                         //
-01142                         // Use [] operator for indexing in to the array.
-01143         TInt index1;
-01144         index1 = aPointerArray.Count();
-01145 
-01146         elementptr = aPointerArray[--index1];
-01147         aPointerArray.Remove(index1);
-01148         delete elementptr;
-01149 
-01150                                 // Show number of elements
-01151         console->Printf(KCommonFormat5,aPointerArray.Count());
-01152 
-01153                                 // Show each element
-01154         for (forix = 0; forix < aPointerArray.Count(); forix++)
-01155                 {
-01156                 console->Printf(KCommonFormat4,aPointerArray[forix]->iBuf);
-01157                 }
-01158 
-01159                         //
-01160                         // Find  * * * * * * * * *
-01161                         //
-01162         _LIT(KMsgFind,"\n--->Find");
-01163         console->Printf(KMsgFind);
-01164         console->Printf(KMsgPressAnyKey);
-01165         console->Getch();
-01166 
-01167         elementptr = aPointerArray[index1-2];
-01168 
-01169         _LIT(KCommonFormat8,"\nElement found at position %d");
-01170 
-01171         // Finds the first object pointer in the array which matches the specified object pointer, using a sequential search.
-01172         TInt result=aPointerArray.Find(elementptr);
-01173                 console->Printf(KCommonFormat8, result);
-01174 
-01175         // Finds the last object pointer in the array which matches the specified object pointer, using a sequential search.
-01176         result=aPointerArray.FindReverse(elementptr);
-01177                 console->Printf(KCommonFormat8, result);
-01178 
-01179         // Finds the object pointer in the array that matches the specified object pointer, using a binary search technique.
-01180         // It assumes that object pointers in the array are in address order.
-01181         result=aPointerArray.FindInAddressOrder(elementptr);
-01182                 console->Printf(KCommonFormat8, result);
-01183 
-01184                         //
-01185                         // Sort  * * * * * * * * *
-01186                         //
-01187         _LIT(KSortFind,"\n\n--->Sort");
-01188         console->Printf(KSortFind);
-01189         console->Printf(KMsgPressAnyKey);
-01190         console->Getch();
-01191 
-01192                         // ResetAndDestroy  * * * * * * * * *
-01193                         //
-01194         _LIT(KMsgResetDestroy,"\n\n--->ResetAndDestroy");
-01195         console->Printf(KMsgResetDestroy);
-01196         console->Printf(KMsgPressAnyKey);
-01197         console->Getch();
-01198 
-01199                                 // Empties the array and deletes the referenced objects.
-01200                                 // It frees all memory allocated to the array and resets the internal state so that it is ready to be reused.
-01201         aPointerArray.ResetAndDestroy();
-01202         }
-01203 
-01204 void DemoSortRPointerArray()
-01205         {
-01206                         // Construct two arrays of TAny pointer objects.
-01207                         // Append random objects to first pointer array.
-01208                         // Sort all objects of first array in the second pointer array.
-01209         RPointerArray<TAny> firstpointerarray;
-01210         RPointerArray<TAny> secondpointerarray;
-01211 
-01212         TInt count = 10;
-01213         for (TInt i=0; i<count; i++)
-01214                 {
-01215                 TAny* x=(TAny*)(((TUint)Math::Random() %count));
-01216                 firstpointerarray.Append(x);
-01217                 secondpointerarray.InsertInAddressOrderAllowRepeats(x);
-01218                 }
-01219 
-01220         // Show initial array elements of first array
-01221         _LIT(KInitialArrayElements,"\nInitial array elements are:");
-01222         console->Printf(KInitialArrayElements);
-01223 
-01224         _LIT(KCommonFormat7,"Array Contents %d \n");
-01225         TInt forix;
-01226         for (forix = 0; forix < count; forix++)
-01227                 {
-01228                 console->Printf(KCommonFormat7,firstpointerarray[forix]);
-01229                 }
-01230 
-01231         // Sorts the object pointers within the array into address order
-01232         secondpointerarray.SortIntoAddressOrder();
-01233 
-01234         // Show sorted array elements of second array
-01235         _LIT(KSortedArrayElements,"\nSorted array elements are:");
-01236         console->Printf(KSortedArrayElements);
-01237         for (forix = 0; forix < count; forix++)
-01238                 {
-01239                 console->Printf(KCommonFormat7,secondpointerarray[forix]);
-01240                 }
-01241 
-01242         // Closes the arrays and frees all memory allocated to it
-01243         firstpointerarray.Close();
-01244         secondpointerarray.Close();
-01245         }
-01246 // Do the example
-01247 LOCAL_C void doExampleL()
-01248         {
-01249         //************************************************************
-01250         // Demonstrate a general fixed length array using
-01251         // a flat buffer
-01252         //************************************************************
-01253 
-01254         CArrayFixFlat<TElement>* fixflat;
-01255                                 // Construct array of TElement objects where the iData
-01256                                 // data member of each element contains "X0", "X1", etc
-01257                                 // Uses the AppendL() function to add the members
-01258                                 // and the [] operator to access elements.
-01259         fixflat = new (ELeave) CArrayFixFlat<TElement>(3);
-01260         CleanupStack::PushL(fixflat);
-01261 
-01262                                 // Demonstrate the CArrayFixFlat array.
-01263         DemoFlatArrayL(*fixflat);
-01264 
-01265                                 // Delete the fixflat array.
-01266         CleanupStack::PopAndDestroy(fixflat); // fixflat
-01267         //************************************************************
-01268         // Demonstrate an array of pointers to CBase
-01269         // derived objects. Uses the specialised array CArrayPtrFlat
-01270         //************************************************************
-01271         _LIT(KMsgArrayOfPointers,"\nARRAYS OF POINTERS (to CBase derived objects)\n");
-01272         console->Printf(KMsgArrayOfPointers);
-01273 
-01274         CArrayPtrFlat<CElement>* ptrflat;
-01275 
-01276                                 // Construct an array of four CElement objects each
-01277                                 // containing the text "First" "second" etc
-01278                                 // Uses the AppendL() function to add the members
-01279                                 // and the [] operator to access elements.
-01280         ptrflat = new (ELeave) CArrayPtrFlat<CElement>(16);
-01281         CleanupStack::PushL(ptrflat);
-01282 
-01283                                 // Demonstrate the CArrayPtrFlat array.
-01284         DemoPtrArrayL(*ptrflat);
-01285 
-01286                                 // Delete the array.
-01287         CleanupStack::PopAndDestroy(ptrflat); // ptrflat
-01288 
-01289         //************************************************************
-01290         // Demonstrate Variable and Packed arrays
-01291         // Use TKey to sort these arrays
-01292         //************************************************************
-01293         _LIT(KMsgVarArray,"\n\nVAR ARRAY\n\n");
-01294         console->Printf(KMsgVarArray);
-01295 
-01296                                 // Create a Var array.
-01297         CArrayVarFlat<TText>* varflat = new (ELeave) CArrayVarFlat<TText>(3);
-01298         CleanupStack::PushL(varflat);
-01299 
-01300                                 // Demonstrate the CArrayVarFlat array.
-01301         DemoVarArraySortL(*varflat);
-01302 
-01303                                 // Delete the array.
-01304         CleanupStack::PopAndDestroy(varflat); // varflat
-01305 
-01306         _LIT(KMsgPakArray,"\n\nPAK ARRAY\n\n");
-01307         console->Printf(KMsgPakArray);
-01308 
-01309                                 // Create a TKeyArrayPak array.
-01310         CArrayPakFlat<TText>* pakflat = new (ELeave) CArrayPakFlat<TText>(3);
-01311         CleanupStack::PushL(pakflat);
-01312 
-01313                                 // Demonstrate the CArrayPakFlat array.
-01314         DemoPakArrayFindL(*pakflat);
-01315 
-01316                                 // Delete the array.
-01317         CleanupStack::PopAndDestroy(pakflat);  // pakflat,
-01318 
-01319         //************************************************************
-01320         // Demonstrate the CArrayFix::Find() function using the
-01321         // TKey derived class TKeyTIntPtr.
-01322         //************************************************************
-01323         _LIT(KMsgTKeyDerived,"\nTKEY DERIVED CLASS\n");
-01324         console->Printf(KMsgPressAnyKey);
-01325         console->Getch();
-01326 
-01327         console->Printf(KMsgTKeyDerived);
-01328         CArrayFixFlat<TIntPtrElement>* ptrElementArray;
-01329                                         // Construct array of TIntPtrElement objects where the iData
-01330                                         // data member of each element contains "X0", "X1", etc
-01331                                         // Uses the AppendL() function to add the members
-01332                                         // and the [] operator to access elements.
-01333         ptrElementArray = new (ELeave) CArrayFixFlat<TIntPtrElement>(3);
-01334         CleanupStack::PushL(ptrElementArray);
-01335 
-01336                                         // Demonstrate the use of TKey derived class.
-01337         DemoTKeyDerivedL(*ptrElementArray);
-01338 
-01339         CleanupStack::PopAndDestroy(ptrElementArray); // ptrElementArray,
-01340 
-01341         //*****************************************************************
-01342         // Demonstrate an array of type RArray for elements of the same size
-01343         //*****************************************************************
-01344 
-01345         _LIT(KMsgForRArray,"\n*******Arrays of fixed length objects******");
-01346         console->Printf(KMsgForRArray);
-01347 
-01348         RArray<CArrayElement>* array;
-01349 
-01350                                 // Construct array of CArrayElement objects where the iData
-01351                                 // data member of each element contains "X0", "X1", etc.
-01352                                 // The elements of the array are instances of a class,
-01353                                 // so this is a template class. Refer to the definition of
-01354                                 // element CArrayElement above.
-01355                                 // Uses the AppendL() function to add the members
-01356                                 // and the [] operator to access elements.
-01357     array = new (ELeave) RArray<CArrayElement>(16);     // Initialise the array granularity to 16
-01358         CleanupStack::PushL(array);
-01359                                 // Demonstrate the use of RArray.
-01360     DemoRArrayL(*array);
-01361 
-01362         CleanupStack::PopAndDestroy(array);
-01363                                 // Demonstrates sorting of the RArray.
-01364         DemoRArraySort();
-01365 
-01366 
-01367         //******************************************************************************
-01368         // Demonstrate a simple and efficient array of pointers to objects RPointerArray
-01369         //******************************************************************************
-01370 
-01371         _LIT(KMsgForRPointerArray,"\n*******Array of pointers to objects******");
-01372         console->Printf(KMsgForRPointerArray);
-01373 
-01374         RPointerArray<CElement>* ptrarray;
-01375 
-01376                                 // Construct an array of four CElement objects each
-01377                                 // containing the text "First", "Second" etc
-01378                                 // Uses the AppendL() function to add the members
-01379                                 // and the [] operator to access elements.
-01380                                 // It leaves with one of the system wide error codes, if the operation fails.
-01381     ptrarray = new (ELeave) RPointerArray<CElement>(16); // Initialise the array granularity to 16
-01382     CleanupStack::PushL(array);
-01383                                 // Demonstrate the use of RPointerArray.
-01384     DemoRPointerArrayL(*ptrarray);
-01385         CleanupStack::PopAndDestroy(ptrarray);
-01386                                 // Demonstrates sorting of the RPointerArray.
-01387         DemoSortRPointerArray();
-01388         }
-01389 
-