TB9.2 Example Applications: examples/Base/HashTableExample/hashtableexample.cpp Source File

00001 // Copyright (c) 2007-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 // This example program demonstrates the use of hash table classes.
+00015 //
+00016 
+00017 
+00018 
+00022 #include "hashtableexample.h"
+00023 #include <e32hashtab.h>
+00024 #include <e32math.h>
+00025 
+00029 CHashTableExample::CHashTableExample()
+00030         {
+00031         }
+00032 
+00033 void CHashTableExample::ConstructL()
+00034         {
+00035         iConsole = Console::NewL(KTitle, TSize(KConsFullScreen, KConsFullScreen));
+00036         iConsole->Printf(KWelcome);
+00037         iConsole->Printf(KPressAKeyMsg );
+00038         iConsole->Getch();
+00039         }
+00040 
+00044 CHashTableExample::~CHashTableExample()
+00045         {
+00046         delete iConsole;
+00047         iPointerArray.ResetAndDestroy();
+00048         }
+00049 
+00055 CHashTableExample* CHashTableExample::NewL()
+00056         {
+00057         CHashTableExample* self=new(ELeave)CHashTableExample();
+00058         CleanupStack::PushL(self);
+00059         self->ConstructL();
+00060         CleanupStack::Pop(self);
+00061         return self;
+00062         }
+00063     
+00068 void CHashTableExample::ConstructDefaultHashSet()
+00069         {
+00070         // Construct hash set using default hash and identity functions for integer
+00071         RHashSet<TInt> hashSetInt();
+00072   
+00073         // Construct hash set using default hash and identity functions for 8bit descriptor
+00074         RHashSet<TDesC8> hashSetDes8();
+00075   
+00076         // Construct hash set using default hash and identity functions for 16bit descriptor
+00077         RHashSet<TDesC16> hashSetDes16();
+00078   
+00079         iConsole->Printf(KHashSet);
+00080         iConsole->Printf(KConstruct);
+00081         iConsole->Printf(KConstructDefaultHashSet);
+00082         } 
+00083    
+00087 struct TMyOwnObject
+00088         {
+00089         TInt iVar1;
+00090         TInt iVar2;
+00091         };
+00092  
+00099 TUint32 MyHashFunction(const TMyOwnObject& aObject)
+00100         {
+00101         return  DefaultHash::Integer(aObject.iVar1) + DefaultHash::Integer(aObject.iVar2 );
+00102         }
+00103     
+00111 TBool MyIdentityFunction(const TMyOwnObject& aObject1, const TMyOwnObject& aObject2)
+00112         {
+00113         return aObject1.iVar1 == aObject2.iVar1 && aObject1.iVar2 != aObject2.iVar2;
+00114         }
+00115     
+00120 void CHashTableExample::ConstructOwnHashSet()
+00121         {
+00122         // Creates an object of custom hash function by using our created structure
+00123         THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);
+00124 
+00125         // Creates an object of identity function by using our created structure
+00126         TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);        
+00127  
+00128         // Construct hash set by providing custom hash and identity function
+00129         RHashSet<TMyOwnObject> ownHashSet(ownHashFunction, ownIdentityFunction);
+00130         iConsole->Printf(KConstructOwnHashSet);
+00131         }
+00132  
+00143 void CHashTableExample::OperationsToHashSetL()  
+00144         {
+00145         // Declare a const integer value for the initial item to be stored
+00146     const TInt startItem=1;
+00147     
+00148     // Declare a const integer value for the last item to be stored     
+00149         const TInt endItem=100;
+00150         TInt itemToBeFound=120;
+00151         TInt itemToBeRemoved=200;
+00152         TInt64 items=1;
+00153   
+00154         iConsole->Printf(KOperation);
+00155         
+00156         // Creates an object of hash set using the template class RHashSet 
+00157         RHashSet<TInt> hashSet;
+00158         
+00159         // Push hash set on to the cleanup stack
+00160         CleanupClosePushL(hashSet);
+00161  
+00162         // Insert random items to hash set
+00163         for (TInt i=startItem; i<=endItem; ++i)
+00164                 {
+00165                 TInt res = Math::Rand(items);
+00166                 hashSet.InsertL(res);
+00167                 }
+00168    
+00169         iConsole->Printf(KInsertItemsToHashSet);
+00170   
+00171         // Search the set for a specified item 
+00172         TInt* result= hashSet.Find(itemToBeFound);
+00173         
+00174         // result is NULL if specified item is not found in the set
+00175         if(result)
+00176                 {
+00177                 iConsole->Printf(KItemPresentInHashSet);
+00178                 }
+00179         else
+00180                 {
+00181                 iConsole->Printf(KItemNotPresentInHashSet);
+00182                 }
+00183  
+00184         // Creates an object of TIter to iterate over the elements of hash set
+00185         RHashSet<TInt>::TIter hashSetIter(hashSet);
+00186   
+00187         // Iterate over the items in the set
+00188         // Creates an iterator object of type TIter
+00189         for ( ; ;)
+00190                 {
+00191                 const TInt* res = hashSetIter.Next();
+00192                 
+00193                 // Next() moves the iterator to the next item and returns it
+00194                 // Returns NULL if there are no more items 
+00195                 if (!res)
+00196                         {
+00197                         break;
+00198                         }
+00199                 }
+00200   
+00201         iConsole->Printf(KIterateItemsFromHashSet);
+00202 
+00203         // Remove an item from hash set
+00204         TInt res = hashSet.Remove(itemToBeRemoved);
+00205         // Check if the item was successfully removed
+00206         if(res)
+00207                 {
+00208                 iConsole->Printf(KItemPresentInHashSet);
+00209                 }
+00210         else
+00211                 {
+00212                 iConsole->Printf(KItemNotPresentInHashSet);
+00213                 }
+00214   
+00215         iConsole->Printf(KRemoveItemsFromHashSet);
+00216   
+00217         // Close and cleanup hash set
+00218         CleanupStack::PopAndDestroy(&hashSet);
+00219         
+00220         iConsole->Printf(KPressAKey);
+00221         iConsole->Getch();
+00222         }
+00223   
+00228 void CHashTableExample::ConstructDefaultPtrHashSet()
+00229         {
+00230         // Construct hash set of pointers using default hash and identity functions for integer
+00231         RPtrHashSet<TInt> ptrHashSetInt();
+00232   
+00233         // Construct hash set of pointers using default hash and identity functions for 8bit descriptor
+00234         RPtrHashSet<TDesC8> ptrHashSetDes8();
+00235   
+00236         // Construct hash set of pointers using default hash and identity functions for 16bit descriptor
+00237         RPtrHashSet<TDesC16> ptrHashSetDes16();
+00238  
+00239         iConsole->Printf(KPtrHashSet);
+00240         iConsole->Printf(KConstruct);
+00241         iConsole->Printf(KConstructDefaultPtrHashSet);
+00242         }
+00243   
+00248 void CHashTableExample::ConstructOwnPtrHashSet()
+00249         {
+00250         // Creates an object of custom hash function by using our created structure
+00251         THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);
+00252  
+00253         // Creates an object of identity relation by using our created structure
+00254         TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);        
+00255  
+00256         // Construct hash set of pointers by providing custom hash and identity functions
+00257         RPtrHashSet<TMyOwnObject> ownPtrHashSet(ownHashFunction, ownIdentityFunction);
+00258         iConsole->Printf(KConstructOwnPtrHashSet);      
+00259         }
+00260  
+00266 void FindNumberInWords(const TInt& aNum, TDes& aDes)
+00267         {
+00268         TInt number = aNum;
+00269         const TInt bufferSize=256;
+00270         const TText* numbers[] = {_S("zero"), _S("one"), _S("two"),_S("three"),_S("four"),_S("five"),_S("six"),_S("seven"), 
+00271                                                         _S("eight"),_S("nine"),_S("ten"),_S("eleven"),_S("twelve"),_S("thirteen"), 
+00272                                                         _S("fourteen"),_S("fifteen"), _S("sixteen"),_S( "seventeen"),_S( "eighteen"),
+00273                                                         _S("nineteen"),_S( "twenty"),_S( "thirty"),_S( "forty"),_S( "fifty"),_S("sixty"),
+00274                                                         _S("seventy"),_S( "eighty"), _S("ninety"), _S("hundred"), _S("thousand")  };
+00275                            
+00276         // Converts the words if the number is less than 20
+00277         if (number<20)
+00278                 {
+00279                 aDes.Copy(reinterpret_cast<const TUint16*> (numbers[number]));
+00280                 }
+00281     
+00282         // Converts the words if the number between 20 and 100 
+00283         if (number<100 && number>=20)
+00284                 {
+00285                 TInt tens = number/10;
+00286                 TInt units = number%10;
+00287                 aDes.Copy(reinterpret_cast<const TUint16*> (numbers[tens-2+20]));
+00288                 if (units)
+00289                         {
+00290                         aDes.Append(' ');
+00291                         aDes.Append(TPtrC16(reinterpret_cast<const TUint16*> (numbers[units])));
+00292                         }
+00293                 }
+00294    
+00295         // Converts the words if the number is between 100 and 1000 
+00296         if (number<1000 && number>=100)
+00297                 {
+00298                 TInt hundreds = number/100;
+00299                 aDes.Copy(reinterpret_cast<const TUint16*> (numbers[hundreds]));
+00300                 aDes.Append(' ');
+00301                 aDes.Append(TPtrC16(reinterpret_cast<const TUint16*> (numbers[28])));
+00302                 number%=100;
+00303                 if (number)
+00304                         {
+00305                         TBuf<bufferSize> buf;
+00306                         TDes& des1= buf;
+00307                         FindNumberInWords(number, des1);
+00308                         aDes.Append(KAnd);
+00309                         aDes+=des1;
+00310                         }
+00311                 }
+00312   
+00313         // Converts the words if the number is greater than or equal to 1000
+00314         if(number>=1000)
+00315                 {
+00316                 TInt hundreds = number/1000;
+00317                 aDes.Copy(reinterpret_cast<const TUint16*> (numbers[hundreds]));
+00318                 aDes.Append(' ');
+00319                 aDes.Append(TPtrC16(reinterpret_cast<const TUint16*> (numbers[29])));
+00320                 number%=1000;
+00321                 if (number)
+00322                         {
+00323                         TBuf<bufferSize> buf;
+00324                         TDes& des1= buf;
+00325                         FindNumberInWords(number, des1);
+00326                         aDes.Append(KAnd);
+00327                         aDes+=des1;
+00328                         }
+00329                 }
+00330         }
+00331  
+00342 void CHashTableExample::OperationsToPtrHashSetL()       
+00343         {
+00344         //      
+00345         iConsole->Printf(KOperation);
+00346     
+00347     // First, set up some sample data to store in the hash
+00348     // We're going to use strings for the numbers 0 to 1999 
+00349         
+00350         // Populate a string array temporarily with the sample data
+00351         // We'll use the array to populate the set, and later on use it also
+00352         // to populate a map
+00353     const TInt KMaxItem=1200;
+00354     const TInt KMaxBufferSize=256;
+00355     TInt i=0;
+00356         for (i=0; i<KMaxItem; ++i)
+00357                 {
+00358                 HBufC* hbuf = HBufC::NewLC(KMaxBufferSize);
+00359                 TPtr buf = hbuf->Des();
+00360                 // FindNumberInWords gets a string representation of the specified integer
+00361                 FindNumberInWords(i, buf);              
+00362                 iPointerArray.AppendL(hbuf);
+00363                 CleanupStack::Pop(hbuf);
+00364                 }
+00365         
+00366         // Now create a set and populate it with the data from the array
+00367 
+00368         // Creates an object of hash set of pointers for 16 bit data using the template class RPtrHashSet
+00369         RPtrHashSet<TDesC16> ptrHashSet;        
+00370         // Push hash set of pointers on to the cleanup stack
+00371         CleanupClosePushL(ptrHashSet);
+00372         // Insert items to hash set of pointers from 16 bit descriptor array
+00373         for (i=0; i<KMaxItem; ++i)
+00374                 {
+00375                 ptrHashSet.InsertL(iPointerArray[i]);
+00376                 }  
+00377         iConsole->Printf(KInsertItemsToPtrHashSet);
+00378   
+00379         // Search the set for a specified item 
+00380         TDesC16* item1 = ptrHashSet.Find(KFindItem);
+00381         // item1 is NULL if KFindItem is not found in the set
+00382         if (item1)
+00383                 {
+00384                 iConsole->Printf(KItemPresentInPtrHashSet);
+00385                 }
+00386         else
+00387                 {
+00388                 iConsole->Printf(KItemNotPresentInPtrHashSet);
+00389                 }       
+00390  
+00391         // Iterate over the items in the set
+00392         // Creates an iterator object of type TIter
+00393         RPtrHashSet<TDesC16>::TIter ptrHashSetIter(ptrHashSet);
+00394         // Loop through the items 
+00395         for ( ; ; )
+00396                 {
+00397                 const TDesC16* resNext = ptrHashSetIter.Next();
+00398                 // Next() moves the iterator to the next item and returns it
+00399                 // Returns NULL if there are no more items  
+00400                 if (!resNext)
+00401                         { 
+00402                         break;
+00403                         }
+00404                 }
+00405         iConsole->Printf(KIterateItemsFromPtrHashSet);
+00406         
+00407         // Remove an item from hash set
+00408         TInt err = ptrHashSet.Remove(&KRemoveItem);
+00409         // Check if the item was successfully removed
+00410         if (err == KErrNone)
+00411                 {
+00412                 iConsole->Printf(KItemPresentInPtrHashSet);
+00413                 }
+00414         else
+00415                 {
+00416                 iConsole->Printf(KItemNotPresentInPtrHashSet);
+00417                 }       
+00418         iConsole->Printf(KRemoveItemsFromPtrHashSet);
+00419   
+00420         // Close and cleanup hash set of pointers
+00421         CleanupStack::PopAndDestroy(&ptrHashSet);
+00422  
+00423         iConsole->Printf(KPressAKey);
+00424         iConsole->Getch();
+00425         }
+00426  
+00431 void CHashTableExample::ConstructDefaultHashMap()
+00432         {
+00433         // Construct hash map using default hash and identity functions for integer
+00434         RHashMap<TInt, TInt> hashMapInt();
+00435   
+00436         // Construct hash map using default hash and identity functions for 8 bit descriptor
+00437         RHashMap<TDesC8, TDesC8> hashMapDes8();
+00438   
+00439         // Construct hash map using default hash and identity functions for 16bit descriptor
+00440         RHashMap<TDesC16, TDesC16> hashMapDes16();
+00441   
+00442         iConsole->Printf(KHashMap);
+00443         iConsole->Printf(KConstruct);
+00444         iConsole->Printf(KConstructDeafultHashMap);     
+00445         }
+00446 
+00451 void CHashTableExample::ConstructOwnHashMap()
+00452         {
+00453         // Creates an object of custom hash function by using our created structure
+00454         THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);
+00455  
+00456         // Creates an object of identity function by using our created structure
+00457         TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);
+00458  
+00459         // Construct hash map by providing custom hash and identity function    
+00460         RHashMap<TMyOwnObject, TMyOwnObject> ownHashMap(ownHashFunction, ownIdentityFunction);
+00461         iConsole->Printf(KConstructOwnHashMap);         
+00462         }
+00463    
+00474 void CHashTableExample::OperationsToHashMapL()
+00475         {
+00476         TInt maxItem=300;
+00477         TInt itemToBeFound=150;
+00478         TInt itemToBeRemoved=200;
+00479         TInt64 items;
+00480         
+00481         iConsole->Printf(KOperation);
+00482   
+00483         // Creates an object of hash map using the template class RHashMap
+00484         RHashMap<TInt, TInt> hashMap;
+00485         
+00486         // Push hash map on to the cleanup stack
+00487         CleanupClosePushL(hashMap);
+00488     
+00489         // Insert items to hash map
+00490         for (TInt i=0; i<maxItem; i++)
+00491                 {
+00492                 TInt res = Math::Rand(items);
+00493                 hashMap.InsertL(res*res, res);
+00494                 }
+00495         
+00496         iConsole->Printf(KInsertItemsToHashMap);
+00497   
+00498         // Search the map for a specified item
+00499         TInt* result= hashMap.Find(itemToBeFound);
+00500         
+00501         // result is NULL if specified item is not found in the map
+00502         if(result)
+00503                 {
+00504                 iConsole->Printf(KItemPresentInHashMap);
+00505                 }
+00506         else
+00507                 {
+00508                 iConsole->Printf(KItemNotPresentInHashMap);
+00509                 }
+00510   
+00511         // Iterate over the items in the map
+00512         // Creates an iterator object of type TIter
+00513         RHashMap<TInt, TInt>::TIter hashMapIter(hashMap);
+00514         
+00515         for ( ; ; )
+00516                 {
+00517                 const TInt* resNext = hashMapIter.NextKey();
+00518                 if (!resNext)
+00519                         { 
+00520                         break;
+00521                         }
+00522                 }
+00523 
+00524         iConsole->Printf(KIterateItemsFromHashMap);
+00525  
+00526         // Remove an item from hash map
+00527         TInt res = hashMap.Remove(itemToBeRemoved);
+00528         
+00529         // Check if the item was successfully removed
+00530         if(res)
+00531                 {
+00532                 iConsole->Printf(KItemPresentInHashMap);
+00533                 }
+00534         else
+00535                 {
+00536                 iConsole->Printf(KItemNotPresentInHashMap);
+00537                 }
+00538  
+00539         iConsole->Printf(KRemoveItemsFromHashMap);
+00540   
+00541         // Close and cleanup hash map
+00542         CleanupStack::PopAndDestroy(&hashMap);
+00543   
+00544         iConsole->Printf(KPressAKey);
+00545         iConsole->Getch();
+00546         }
+00547 
+00552 void CHashTableExample::ConstructDefaultPtrHashMap()
+00553         {
+00554         // Construct hash map of pointers using default hash and identity functions for integer
+00555         RPtrHashMap<TInt, TInt> ptrHashMapInt();
+00556   
+00557         // Construct hash map of pointers using default hash and identity functions for 8bit descriptor
+00558         RPtrHashMap<TDesC8, TDesC8> ptrHashMapDes8();
+00559   
+00560         // Construct hash map of pointers using default hash and identity functions for 16bit descriptor
+00561         RPtrHashMap<TDesC16, TDesC16> ptrHashMapDes16();
+00562      
+00563         iConsole->Printf(KPtrHashMap);
+00564         iConsole->Printf(KConstruct);
+00565         iConsole->Printf(KConstructDeafultPtrHashMap);  
+00566         }
+00567  
+00572 void CHashTableExample::ConstructOwnPtrHashMap()
+00573         {
+00574         // Creates an object of custom hash function by using our created structure
+00575         THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);
+00576   
+00577         // Creates an object of identity function by using our created structure
+00578         TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);
+00579   
+00580         // Construct hash map of pointers by providing custom hash and identity function
+00581         RPtrHashMap<TMyOwnObject, TMyOwnObject> ownPtrHashMap(ownHashFunction, ownIdentityFunction);
+00582         iConsole->Printf(KConstructOwnPtrHashMap);
+00583         }
+00584  
+00595 void CHashTableExample::OperationsToPtrHashMapL()
+00596         {
+00597         TInt i;
+00598         TInt maxItem=200;
+00599  
+00600         iConsole->Printf(KOperation);
+00601 
+00602         // Creates an object of hash map of pointers using the template class RPtrHashMap
+00603         RPtrHashMap<TDesC16, TDesC16> ptrHashMap;
+00604         
+00605         // Push hash map of pointers on to the cleanup stack
+00606         CleanupClosePushL(ptrHashMap);
+00607    
+00608         // Insert items to hash map of pointers 
+00609         for (i=0; i<maxItem; ++i)
+00610                 {
+00611             ptrHashMap.InsertL(iPointerArray[i], iPointerArray[i+1]);
+00612                 }
+00613   
+00614         iConsole->Printf(KInsertItemsToPtrHashMap);
+00615   
+00616         // Search the set for a specified item 
+00617         TDesC16* item1= ptrHashMap.Find(KFindItem);
+00618         
+00619         // item1 is NULL if KFindItem is not found in the map
+00620         if(item1)
+00621                 {
+00622                 iConsole->Printf(KItemPresentInPtrHashMap);
+00623                 }
+00624         else
+00625                 {
+00626                 iConsole->Printf(KItemNotPresentInPtrHashMap);
+00627                 }
+00628 
+00629         // Iterate over the items in the map
+00630         // Creates an iterator object of type TIter
+00631         RPtrHashMap<TDesC16, TDesC16>::TIter ptrHashMapIter(ptrHashMap);
+00632  
+00633         for ( ; ; )
+00634                 {
+00635                 const TDesC16* resNext = ptrHashMapIter.NextKey();
+00636                 // Next() moves the iterator to the next item and returns it
+00637                 // Returns NULL if there are no more items 
+00638                 if (!resNext)
+00639                         { 
+00640                         break;
+00641                         }
+00642                 }
+00643         
+00644         iConsole->Printf(KIterateItemsFromPtrHashMap);
+00645 
+00646         // Remove an item from hash map of pointers 
+00647     TInt res = ptrHashMap.Remove(&KRemoveItem);
+00648     
+00649     // Check if the item was successfully removed
+00650         if(res)
+00651                 {
+00652                 iConsole->Printf(KItemPresentInPtrHashMap);
+00653                 }
+00654         else
+00655                 {
+00656                 iConsole->Printf(KItemNotPresentInPtrHashMap);
+00657                 }       
+00658 
+00659         iConsole->Printf(KRemoveItemsFromPtrHashMap);
+00660         iConsole->Printf(KExitMsg); 
+00661         iConsole->Getch();      
+00662   
+00663         // Close and Cleanup hash map of pointers
+00664         CleanupStack::PopAndDestroy(&ptrHashMap);
+00665         }
+00666  
+00667 void MainL()
+00668         {
+00669         CHashTableExample* app= CHashTableExample::NewL();
+00670         CleanupStack::PushL(app);
+00671  
+00672         // Hash set 
+00673         app->ConstructDefaultHashSet();
+00674         app->ConstructOwnHashSet();
+00675         app->OperationsToHashSetL();
+00676   
+00677         // Hash set of pointers
+00678         app->ConstructDefaultPtrHashSet();
+00679         app->ConstructOwnPtrHashSet();
+00680         app->OperationsToPtrHashSetL();
+00681   
+00682         // Hash map
+00683         app->ConstructDefaultHashMap();
+00684         app->ConstructOwnHashMap();
+00685         app->OperationsToHashMapL();
+00686  
+00687         // Hash map of pointers
+00688         app->ConstructDefaultPtrHashMap();
+00689         app->ConstructOwnPtrHashMap();
+00690         app->OperationsToPtrHashMapL();
+00691  
+00692         CleanupStack::PopAndDestroy(app);
+00693         } 
+00694 
+00695 GLDEF_C TInt E32Main()
+00696         {
+00697         __UHEAP_MARK;
+00698 
+00699         CTrapCleanup* cleanup = CTrapCleanup::New();
+00700         if(cleanup == NULL)
+00701                 {
+00702                 return KErrNoMemory;
+00703                 }
+00704         TRAPD(err, MainL());
+00705         if(err !=KErrNone)
+00706                 {
+00707                 User::Panic(KFailed, err);
+00708                 }       
+00709         delete cleanup;
+00710 
+00711         __UHEAP_MARKEND;
+00712         return KErrNone;
+00713         }
+00714   
+00715   
+00716   
+00717   
+00718  
+00719  
+00720  
+