examples/Base/HashTableExample/hashtableexample.cpp

Go to the documentation of this file.

/*
Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: This example program demonstrates the use of hash table classes.  
*/



#include "hashtableexample.h"
#include <e32hashtab.h>
#include <e32math.h>

CHashTableExample::CHashTableExample()
        {
        }

void CHashTableExample::ConstructL()
        {
        iConsole = Console::NewL(KTitle, TSize(KConsFullScreen, KConsFullScreen));
        iConsole->Printf(KWelcome);
        iConsole->Printf(KPressAKeyMsg );
        iConsole->Getch();
        }

CHashTableExample::~CHashTableExample()
        {
        delete iConsole;
        iPointerArray.ResetAndDestroy();
        }

CHashTableExample* CHashTableExample::NewL()
        {
        CHashTableExample* self=new(ELeave)CHashTableExample();
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop(self);
        return self;
        }
    
void CHashTableExample::ConstructDefaultHashSet()
        {
        // Construct hash set using default hash and identity functions for integer
        RHashSet<TInt> hashSetInt();
  
        // Construct hash set using default hash and identity functions for 8bit descriptor
        RHashSet<TDesC8> hashSetDes8();
  
        // Construct hash set using default hash and identity functions for 16bit descriptor
        RHashSet<TDesC16> hashSetDes16();
  
        iConsole->Printf(KHashSet);
        iConsole->Printf(KConstruct);
        iConsole->Printf(KConstructDefaultHashSet);
        } 
   
struct TMyOwnObject
        {
        TInt iVar1;
        TInt iVar2;
        };
 
TUint32 MyHashFunction(const TMyOwnObject& aObject)
        {
        return  DefaultHash::Integer(aObject.iVar1) + DefaultHash::Integer(aObject.iVar2 );
        }
    
TBool MyIdentityFunction(const TMyOwnObject& aObject1, const TMyOwnObject& aObject2)
        {
        return aObject1.iVar1 == aObject2.iVar1 && aObject1.iVar2 != aObject2.iVar2;
        }
    
void CHashTableExample::ConstructOwnHashSet()
        {
        // Creates an object of custom hash function by using our created structure
        THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);

        // Creates an object of identity function by using our created structure
        TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);        
 
        // Construct hash set by providing custom hash and identity function
        RHashSet<TMyOwnObject> ownHashSet(ownHashFunction, ownIdentityFunction);
        iConsole->Printf(KConstructOwnHashSet);
        }
 
void CHashTableExample::OperationsToHashSetL()  
        {
        // Declare a const integer value for the initial item to be stored
    const TInt startItem=1;
    
    // Declare a const integer value for the last item to be stored     
        const TInt endItem=100;
        TInt itemToBeFound=120;
        TInt itemToBeRemoved=200;
        TInt64 items=1;
  
        iConsole->Printf(KOperation);
        
        // Creates an object of hash set using the template class RHashSet 
        RHashSet<TInt> hashSet;
        
        // Push hash set on to the cleanup stack
        CleanupClosePushL(hashSet);
 
        // Insert random items to hash set
        for (TInt i=startItem; i<=endItem; ++i)
                {
                TInt res = Math::Rand(items);
                hashSet.InsertL(res);
                }
   
        iConsole->Printf(KInsertItemsToHashSet);
  
        // Search the set for a specified item 
        TInt* result= hashSet.Find(itemToBeFound);
        
        // result is NULL if specified item is not found in the set
        if(result)
                {
                iConsole->Printf(KItemPresentInHashSet);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInHashSet);
                }
 
        // Creates an object of TIter to iterate over the elements of hash set
        RHashSet<TInt>::TIter hashSetIter(hashSet);
  
        // Iterate over the items in the set
        // Creates an iterator object of type TIter
        for ( ; ;)
                {
                const TInt* res = hashSetIter.Next();
                
                // Next() moves the iterator to the next item and returns it
                // Returns NULL if there are no more items 
                if (!res)
                        {
                        break;
                        }
                }
  
        iConsole->Printf(KIterateItemsFromHashSet);

        // Remove an item from hash set
        TInt res = hashSet.Remove(itemToBeRemoved);
        // Check if the item was successfully removed
        if(res)
                {
                iConsole->Printf(KItemPresentInHashSet);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInHashSet);
                }
  
        iConsole->Printf(KRemoveItemsFromHashSet);
  
        // Close and cleanup hash set
        CleanupStack::PopAndDestroy(&hashSet);
        
        iConsole->Printf(KPressAKey);
        iConsole->Getch();
        }
  
void CHashTableExample::ConstructDefaultPtrHashSet()
        {
        // Construct hash set of pointers using default hash and identity functions for integer
        RPtrHashSet<TInt> ptrHashSetInt();
  
        // Construct hash set of pointers using default hash and identity functions for 8bit descriptor
        RPtrHashSet<TDesC8> ptrHashSetDes8();
  
        // Construct hash set of pointers using default hash and identity functions for 16bit descriptor
        RPtrHashSet<TDesC16> ptrHashSetDes16();
 
        iConsole->Printf(KPtrHashSet);
        iConsole->Printf(KConstruct);
        iConsole->Printf(KConstructDefaultPtrHashSet);
        }
  
void CHashTableExample::ConstructOwnPtrHashSet()
        {
        // Creates an object of custom hash function by using our created structure
        THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);
 
        // Creates an object of identity relation by using our created structure
        TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);        
 
        // Construct hash set of pointers by providing custom hash and identity functions
        RPtrHashSet<TMyOwnObject> ownPtrHashSet(ownHashFunction, ownIdentityFunction);
        iConsole->Printf(KConstructOwnPtrHashSet);      
        }
 
void FindNumberInWords(const TInt& aNum, TDes& aDes)
        {
        TInt number = aNum;
        const TInt bufferSize=256;
        const TText* numbers[] = {_S("zero"), _S("one"), _S("two"),_S("three"),_S("four"),_S("five"),_S("six"),_S("seven"), 
                                                        _S("eight"),_S("nine"),_S("ten"),_S("eleven"),_S("twelve"),_S("thirteen"), 
                                                        _S("fourteen"),_S("fifteen"), _S("sixteen"),_S( "seventeen"),_S( "eighteen"),
                                                        _S("nineteen"),_S( "twenty"),_S( "thirty"),_S( "forty"),_S( "fifty"),_S("sixty"),
                                                        _S("seventy"),_S( "eighty"), _S("ninety"), _S("hundred"), _S("thousand")  };
                           
        // Converts the words if the number is less than 20
        if (number<20)
                {
                aDes.Copy(reinterpret_cast<const TUint16*> (numbers[number]));
                }
    
        // Converts the words if the number between 20 and 100 
        if (number<100 && number>=20)
                {
                TInt tens = number/10;
                TInt units = number%10;
                aDes.Copy(reinterpret_cast<const TUint16*> (numbers[tens-2+20]));
                if (units)
                        {
                        aDes.Append(' ');
                        aDes.Append(TPtrC16(reinterpret_cast<const TUint16*> (numbers[units])));
                        }
                }
   
        // Converts the words if the number is between 100 and 1000 
        if (number<1000 && number>=100)
                {
                TInt hundreds = number/100;
                aDes.Copy(reinterpret_cast<const TUint16*> (numbers[hundreds]));
                aDes.Append(' ');
                aDes.Append(TPtrC16(reinterpret_cast<const TUint16*> (numbers[28])));
                number%=100;
                if (number)
                        {
                        TBuf<bufferSize> buf;
                        TDes& des1= buf;
                        FindNumberInWords(number, des1);
                        aDes.Append(KAnd);
                        aDes+=des1;
                        }
                }
  
        // Converts the words if the number is greater than or equal to 1000
        if(number>=1000)
                {
                TInt hundreds = number/1000;
                aDes.Copy(reinterpret_cast<const TUint16*> (numbers[hundreds]));
                aDes.Append(' ');
                aDes.Append(TPtrC16(reinterpret_cast<const TUint16*> (numbers[29])));
                number%=1000;
                if (number)
                        {
                        TBuf<bufferSize> buf;
                        TDes& des1= buf;
                        FindNumberInWords(number, des1);
                        aDes.Append(KAnd);
                        aDes+=des1;
                        }
                }
        }
 
void CHashTableExample::OperationsToPtrHashSetL()       
        {
        //      
        iConsole->Printf(KOperation);
    
    // First, set up some sample data to store in the hash
    // We're going to use strings for the numbers 0 to 1999 
        
        // Populate a string array temporarily with the sample data
        // We'll use the array to populate the set, and later on use it also
        // to populate a map
    const TInt KMaxItem=1200;
    const TInt KMaxBufferSize=256;
    TInt i=0;
        for (i=0; i<KMaxItem; ++i)
                {
                HBufC* hbuf = HBufC::NewLC(KMaxBufferSize);
                TPtr buf = hbuf->Des();
                // FindNumberInWords gets a string representation of the specified integer
                FindNumberInWords(i, buf);              
                iPointerArray.AppendL(hbuf);
                CleanupStack::Pop(hbuf);
                }
        
        // Now create a set and populate it with the data from the array

        // Creates an object of hash set of pointers for 16 bit data using the template class RPtrHashSet
        RPtrHashSet<TDesC16> ptrHashSet;        
        // Push hash set of pointers on to the cleanup stack
        CleanupClosePushL(ptrHashSet);
        // Insert items to hash set of pointers from 16 bit descriptor array
        for (i=0; i<KMaxItem; ++i)
                {
                ptrHashSet.InsertL(iPointerArray[i]);
                }  
        iConsole->Printf(KInsertItemsToPtrHashSet);
  
        // Search the set for a specified item 
        TDesC16* item1 = ptrHashSet.Find(KFindItem);
        // item1 is NULL if KFindItem is not found in the set
        if (item1)
                {
                iConsole->Printf(KItemPresentInPtrHashSet);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInPtrHashSet);
                }       
 
        // Iterate over the items in the set
        // Creates an iterator object of type TIter
        RPtrHashSet<TDesC16>::TIter ptrHashSetIter(ptrHashSet);
        // Loop through the items 
        for ( ; ; )
                {
                const TDesC16* resNext = ptrHashSetIter.Next();
                // Next() moves the iterator to the next item and returns it
                // Returns NULL if there are no more items  
                if (!resNext)
                        { 
                        break;
                        }
                }
        iConsole->Printf(KIterateItemsFromPtrHashSet);
        
        // Remove an item from hash set
        TInt err = ptrHashSet.Remove(&KRemoveItem);
        // Check if the item was successfully removed
        if (err == KErrNone)
                {
                iConsole->Printf(KItemPresentInPtrHashSet);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInPtrHashSet);
                }       
        iConsole->Printf(KRemoveItemsFromPtrHashSet);
  
        // Close and cleanup hash set of pointers
        CleanupStack::PopAndDestroy(&ptrHashSet);
 
        iConsole->Printf(KPressAKey);
        iConsole->Getch();
        }
 
void CHashTableExample::ConstructDefaultHashMap()
        {
        // Construct hash map using default hash and identity functions for integer
        RHashMap<TInt, TInt> hashMapInt();
  
        // Construct hash map using default hash and identity functions for 8 bit descriptor
        RHashMap<TDesC8, TDesC8> hashMapDes8();
  
        // Construct hash map using default hash and identity functions for 16bit descriptor
        RHashMap<TDesC16, TDesC16> hashMapDes16();
  
        iConsole->Printf(KHashMap);
        iConsole->Printf(KConstruct);
        iConsole->Printf(KConstructDeafultHashMap);     
        }

void CHashTableExample::ConstructOwnHashMap()
        {
        // Creates an object of custom hash function by using our created structure
        THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);
 
        // Creates an object of identity function by using our created structure
        TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);
 
        // Construct hash map by providing custom hash and identity function    
        RHashMap<TMyOwnObject, TMyOwnObject> ownHashMap(ownHashFunction, ownIdentityFunction);
        iConsole->Printf(KConstructOwnHashMap);         
        }
   
void CHashTableExample::OperationsToHashMapL()
        {
        TInt maxItem=300;
        TInt itemToBeFound=150;
        TInt itemToBeRemoved=200;
        TInt64 items;
        
        iConsole->Printf(KOperation);
  
        // Creates an object of hash map using the template class RHashMap
        RHashMap<TInt, TInt> hashMap;
        
        // Push hash map on to the cleanup stack
        CleanupClosePushL(hashMap);
    
        // Insert items to hash map
        for (TInt i=0; i<maxItem; i++)
                {
                TInt res = Math::Rand(items);
                hashMap.InsertL(res*res, res);
                }
        
        iConsole->Printf(KInsertItemsToHashMap);
  
        // Search the map for a specified item
        TInt* result= hashMap.Find(itemToBeFound);
        
        // result is NULL if specified item is not found in the map
        if(result)
                {
                iConsole->Printf(KItemPresentInHashMap);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInHashMap);
                }
  
        // Iterate over the items in the map
        // Creates an iterator object of type TIter
        RHashMap<TInt, TInt>::TIter hashMapIter(hashMap);
        
        for ( ; ; )
                {
                const TInt* resNext = hashMapIter.NextKey();
                if (!resNext)
                        { 
                        break;
                        }
                }

        iConsole->Printf(KIterateItemsFromHashMap);
 
        // Remove an item from hash map
        TInt res = hashMap.Remove(itemToBeRemoved);
        
        // Check if the item was successfully removed
        if(res)
                {
                iConsole->Printf(KItemPresentInHashMap);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInHashMap);
                }
 
        iConsole->Printf(KRemoveItemsFromHashMap);
  
        // Close and cleanup hash map
        CleanupStack::PopAndDestroy(&hashMap);
  
        iConsole->Printf(KPressAKey);
        iConsole->Getch();
        }

void CHashTableExample::ConstructDefaultPtrHashMap()
        {
        // Construct hash map of pointers using default hash and identity functions for integer
        RPtrHashMap<TInt, TInt> ptrHashMapInt();
  
        // Construct hash map of pointers using default hash and identity functions for 8bit descriptor
        RPtrHashMap<TDesC8, TDesC8> ptrHashMapDes8();
  
        // Construct hash map of pointers using default hash and identity functions for 16bit descriptor
        RPtrHashMap<TDesC16, TDesC16> ptrHashMapDes16();
     
        iConsole->Printf(KPtrHashMap);
        iConsole->Printf(KConstruct);
        iConsole->Printf(KConstructDeafultPtrHashMap);  
        }
 
void CHashTableExample::ConstructOwnPtrHashMap()
        {
        // Creates an object of custom hash function by using our created structure
        THashFunction32<TMyOwnObject> ownHashFunction(MyHashFunction);
  
        // Creates an object of identity function by using our created structure
        TIdentityRelation<TMyOwnObject> ownIdentityFunction(MyIdentityFunction);
  
        // Construct hash map of pointers by providing custom hash and identity function
        RPtrHashMap<TMyOwnObject, TMyOwnObject> ownPtrHashMap(ownHashFunction, ownIdentityFunction);
        iConsole->Printf(KConstructOwnPtrHashMap);
        }
 
void CHashTableExample::OperationsToPtrHashMapL()
        {
        TInt i;
        TInt maxItem=200;
 
        iConsole->Printf(KOperation);

        // Creates an object of hash map of pointers using the template class RPtrHashMap
        RPtrHashMap<TDesC16, TDesC16> ptrHashMap;
        
        // Push hash map of pointers on to the cleanup stack
        CleanupClosePushL(ptrHashMap);
   
        // Insert items to hash map of pointers 
        for (i=0; i<maxItem; ++i)
                {
            ptrHashMap.InsertL(iPointerArray[i], iPointerArray[i+1]);
                }
  
        iConsole->Printf(KInsertItemsToPtrHashMap);
  
        // Search the set for a specified item 
        TDesC16* item1= ptrHashMap.Find(KFindItem);
        
        // item1 is NULL if KFindItem is not found in the map
        if(item1)
                {
                iConsole->Printf(KItemPresentInPtrHashMap);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInPtrHashMap);
                }

        // Iterate over the items in the map
        // Creates an iterator object of type TIter
        RPtrHashMap<TDesC16, TDesC16>::TIter ptrHashMapIter(ptrHashMap);
 
        for ( ; ; )
                {
                const TDesC16* resNext = ptrHashMapIter.NextKey();
                // Next() moves the iterator to the next item and returns it
                // Returns NULL if there are no more items 
                if (!resNext)
                        { 
                        break;
                        }
                }
        
        iConsole->Printf(KIterateItemsFromPtrHashMap);

        // Remove an item from hash map of pointers 
    TInt res = ptrHashMap.Remove(&KRemoveItem);
    
    // Check if the item was successfully removed
        if(res)
                {
                iConsole->Printf(KItemPresentInPtrHashMap);
                }
        else
                {
                iConsole->Printf(KItemNotPresentInPtrHashMap);
                }       

        iConsole->Printf(KRemoveItemsFromPtrHashMap);
        iConsole->Printf(KExitMsg); 
        iConsole->Getch();      
  
        // Close and Cleanup hash map of pointers
        CleanupStack::PopAndDestroy(&ptrHashMap);
        }
 
void MainL()
        {
        CHashTableExample* app= CHashTableExample::NewL();
        CleanupStack::PushL(app);
 
        // Hash set 
        app->ConstructDefaultHashSet();
        app->ConstructOwnHashSet();
        app->OperationsToHashSetL();
  
        // Hash set of pointers
        app->ConstructDefaultPtrHashSet();
        app->ConstructOwnPtrHashSet();
        app->OperationsToPtrHashSetL();
  
        // Hash map
        app->ConstructDefaultHashMap();
        app->ConstructOwnHashMap();
        app->OperationsToHashMapL();
 
        // Hash map of pointers
        app->ConstructDefaultPtrHashMap();
        app->ConstructOwnPtrHashMap();
        app->OperationsToPtrHashMapL();
 
        CleanupStack::PopAndDestroy(app);
        } 

GLDEF_C TInt E32Main()
        {
        __UHEAP_MARK;

        CTrapCleanup* cleanup = CTrapCleanup::New();
        if(cleanup == NULL)
                {
                return KErrNoMemory;
                }
        TRAPD(err, MainL());
        if(err !=KErrNone)
                {
                User::Panic(KFailed, err);
                }       
        delete cleanup;

        __UHEAP_MARKEND;
        return KErrNone;
        }
  
  
  
  
 
 
 

---