// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // Hexadecimal trees - declaration

 //

 #ifndef HEXTREE_H

 #define HEXTREE_H

 #include <e32std.h>

 /**

 Base class that provides the implementation for RHexTree, which is just a thin

 template.

 An instance of this class can have up to eight 16-way prefix trees, with heights

 from 1 to 8. All the values are stored in the leaves. To find a value from a

 32-bit key, first the key is decomposed into 8 hexadecimal digits and then the

 prefix tree with height matching the number of digits in the key (ignoring zeros

 to the left) is traversed using the sequence of digits in the key as the

 indexing string. Offsets are internally used instead of pointers to allow

 instances to be placed in a heap shared between several processes.

 */

 class RHexTreeBase

     {

 public:

     IMPORT_C void ResetAndDestroy();

 protected:

     IMPORT_C RHexTreeBase(RHeap* aHeap);

     IMPORT_C TInt SetAt(TUint aKey, TAny* aValue);

     IMPORT_C TAny* At(TUint aKey) const;

 private:

     TInt SetAt(TUint aKey, TAny* aLeaf, TInt aHeight);

     TInt SetAt(TUint aKey, TAny* aLeaf, TInt aHeight, TAny* aNode, TInt aLevel);

     TAny* At(TUint aKey, TInt aHeight) const;

     void ResetAndDestroy(TInt aHeight, TAny* aNode, TInt aLevel);

 private:

     enum { EMaxNumHexDigits = 8 };

 private:

     RHeap* iHeap;

     TInt iRootOffsets[EMaxNumHexDigits];

     };

 /**

 An associative array implementation optimised for the case where the keys are

 32-bit codes with spatial locality of reference. The values can be of any

 self-contained data type (that is, without destructor or clean-up functions).

 It allows multiple-readers, single-writer concurrent access from different

 processes in an SMP-safe manner without locking, excluding deletion of

 individual key-value pairs.

 */

 template<class T>

 class RHexTree : public RHexTreeBase

     {

 public:

     inline RHexTree(RHeap* aHeap);

     inline TInt SetAt(TUint aKey, T* aValue);

     inline const T* At(TUint aKey) const;

     inline T* At(TUint aKey);

     };

 #include <hextree.inl>

 #endif // HEXTREE_H