Symaptic: os/ossrv/lowlevellibsandfws/apputils/src/StringPoolImplementation.h@260cb5ec6c19

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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #ifndef __STRINGPOOLIMPLEMENTATION_H__

    17 #define __STRINGPOOLIMPLEMENTATION_H__

    19 #include <e32base.h>

    20 #include <stringpool.h>

    21 #include <stringtablesupport.h>

    23 /**

    24 This is an 8 bit value with every bit set except bit 5 (value

    25 32). The ASCII codes of upper and lower case characters differ by

    26 32.

    27 @internalComponent

    28 */

    29 const TUint KCaseInsensitive = 223;

    31 /**

    32 @internalComponent

    33 */

    34 const TInt KHashModulo = 32;

    36 /**

    37 Bit 0 represents if it is a table (set) or not (unset).

    38 Bit 1 represents case sensitivity (set) or not (unset)

    40 For non-static table values (dynamic strings), the remaining bits

    41 are interpreted as a pointer to a CStringPoolNode (which is assumed

    42 to be word aligned).

    44 Bits 2-20 represent the table index.

    45 Bits 21-31 represent the table uid (that is the address of the table).

    46 */

    48 /**

    49 Bit 1 is used in tokens to indicate case sensitivity. So mask it

    50 out to get the node.

    51 @internalComponent

    52 */

    53 const TUint KTokenToNode = 0xfffffffd;

    55 /**

    56 Determine if this id corresponds to a table.

    57 @internalComponent

    58 */

    59 #define IS_TABLE_ENTRY(tableId)(tableId & 0x01)

    61 /**

    62 Obtain the Table Index.

    63 @internalComponent

    64 */

    65 #define TABLE_INDEX(val)((val & 0xffffc)>>2)

    67 /**

    68 Obtain the Table UID.

    69 @internalComponent

    70 */

    71 #define TABLE_UID(val)(val>>20)

    73 /**

    74 This is used to mark the reference count of a node so that is will not be deleted when closed

    75 @internalComponent

    76 */

    77 const TUint KMarkedForNoDeleted = 0xffff;

    81 class RStringTokenEither;

    83 /**

    84 @internalComponent

    85 */

    86 struct TStringIdMap

    87 	{

    88 	TInt32 iSourceTableVal;

    89 	TInt32 iTargetTableVal;

    90 	};

    93 /**

    94 Internal node class

    95 @internalComponent

    96 */

    97 NONSHARABLE_CLASS(CStringPoolNode) : public CBase

    98 	{

    99 public:

   100 	~CStringPoolNode();

   102  public:

   103 	HBufC8* iDes;

   104 	TUint16 iRefcount;

   105 	TUint8  iHash;

   106 	};

   108 /**

   109 @internalComponent

   110 */

   111 NONSHARABLE_CLASS(CStringPoolImplementation) : public CBase

   112 	{

   113 public:

   114 	CStringPoolImplementation();

   115 	// Destructor

   116 	~CStringPoolImplementation();

   118 	// Constructs a string pool

   119 	static CStringPoolImplementation* NewL();

   121 	// USed for cleaning up when a OpenTableL leaves

   122 	static void CleanupHashCS(TAny* aImplementation);

   123 	static void CleanupHashCI(TAny* aImplementation);

   124 	static void CleanupIdMap(TAny* aImplementation);

   125 	static void CleanUpHash(RPointerArray <RStringTokenEither>* aHashCleanup, CArrayFixSeg<RStringTokenEither>* hash[KHashModulo]);

   127 	// Adds a table to the pool. (Note this currently only works once)

   128 	void AddTableL(const TStringTable& aTable);

   129 	void AddCallBackL( MStringPoolCloseCallBack& aCallBack);

   132 	// Find FirstVal given duplicate val

   133 	TInt32 FindFirstValFromDuplicate(TInt32 aDuplicateVal) const;

   135 	// Find table index Val given first val & table UID

   136 	TInt FindTableIndexFromFirstVal(TInt32 aDuplicateVal, TInt aTableUid) const;

   139 	TInt16 TableUid(const TStringTable& aTable) const;

   141 	const TStringTable& TableRef(TInt32 aVal) const;

   143 	// Looks up a particular index in the pre-loaded tables

   144 	const TDesC8& TableLookup(TInt aIndex, TInt aTableUid) const;

   146 	// Finds or creates a string. Increments the reference count if needed.

   147 	RStringTokenEither OpenL( const TDesC8& aString, TBool aCaseInsensitive);

   149 	// Closes a string (decrements the reference count and deletes if 0

   150 	void Close(RStringTokenEither aString);

   152 	// Increments the reference count on a string

   153 	void IncrementCount(RStringTokenEither aString);

   155 	inline RStringPool Handle();

   157 private:

   159 	// Check for any undeletable string and delete them now

   160 	void DeleteUndeletableStrings(CArrayFixSeg<RStringTokenEither>* aArray[KHashModulo], TInt i);

   162 private:

   164 	// Finds a string in the pool.

   165 	RStringTokenEither FindDes( const TDesC8& aString, TBool aCaseInsensitive);

   167 	// Calculates a hash for a descriptor

   168 	TUint Hash( const TDesC8& ) const;

   170 	static TBool CompareCS(const TDesC8& s1, const TDesC8& s2);

   171 	static TBool CompareCI(const TDesC8& s1, const TDesC8& s2);

   173  private:

   174 	// The table.

   175 	CArrayFixSeg<RStringTokenEither>* iCSHashTable[KHashModulo];

   176 	CArrayFixSeg<RStringTokenEither>* iCIHashTable[KHashModulo];

   177 	RPointerArray<TStringTable> iTablePtrs;	// Stores array of tables, where the index is the table UID

   178 	RArray <TStringIdMap> iStringMapList;

   179 	RArray <TStringIdMap> iStringMapListReverse;

   181 	// For rolling back when a leave occurs during CreateTableL

   182 	RPointerArray <TStringIdMap> iRollbackMapList;

   183 	RPointerArray <RStringTokenEither> iRollbackHashListCS;

   184 	RPointerArray <RStringTokenEither> iRollbackHashListCI;

   185 	RPointerArray<MStringPoolCloseCallBack> iCallBacks;

   186 	};

   188 /**

   189 An internal version of the string token class. This class can hold

   190 either folding or non-folding versions, and it is up to the user

   191 to get it right.

   192 @internalComponent

   193 */

   194 class RStringTokenEither : public RStringTokenBase

   195 	{

   196  public:

   197 	inline RStringTokenEither();

   199 	inline RStringTokenEither(TUint32 aVal);

   201 	/** Comparison operator

   202 		@param aVal The string to compare. */

   203 	inline TBool operator==(RStringTokenEither aVal) const;

   205 	/** Comparison operator

   206 		@param aVal The string to compare. */

   207 	inline TBool operator!=(RStringTokenEither aVal) const;

   209 	/** Assignment operator; makes a string token from a string.

   210 		@param aVal The string to copy */

   211 	inline RStringTokenEither operator=(RStringBase aVal);

   213 	friend class RStringPool;

   214 	friend class RStringEither;

   215 	friend class CStringPoolImplementation;

   216 	};

   218 class RStringEither : public RStringBase

   219 /**

   220 @internalComponent

   221 */

   222 	{

   223 	public:

   224 	RStringEither(CStringPoolImplementation* aPool, RStringTokenEither aVal);

   225 	};

   227 class StringUtils

   228 /**

   229 @internalComponent

   230 */

   231 	{

   232  public:

   233 	static inline TBool IsTableEntry(TInt aVal);

   234 	static inline TInt TableIndex(TInt aVal);

   235 	static inline TInt16 TableUid(TInt aVal);

   236 	static inline CStringPoolNode* NodePtr(TInt aVal);

   237 	static TInt ValFromIndex(TInt aIndex, TUint16 aTableId);

   238 	static TInt ValFromIndexF(TInt aIndex, TUint16 aTableId);

   239 	static TInt ValFromIndex(TInt aIndex, TUint16 aTableId, TBool aCaseSensitive);

   241 	static void LogIt(TRefByValue<const TDesC8> aFmt, ...);

   242 	static void LogIt1(TRefByValue<const TDesC8> aFmt);

   243 	};

   245 #define _LOGGING

   247 #if defined (_DEBUG) && defined (_LOGGING)

   249 /**

   250 HTTP Logging macros

   251 @internalComponent

   252 */

   253 #define __LOG(C)			StringUtils::LogIt1(C);

   254 #define __LOG1(C, X)		StringUtils::LogIt(C, X);

   255 #define __LOG2(C, X, Y)		StringUtils::LogIt(C, X, Y);

   256 #define __LOG3(C, X, Y, Z)	StringUtils::LogIt(C, X, Y, Z);

   258 #else

   260 /**

   261 NULL macros

   262 @internalComponent

   263 */

   264 #define __LOG(C)

   265 #define __LOG1(C, X)

   266 #define __LOG2(C, X, Y)

   267 #define __LOG3(C, X, Y, Z)

   268 #endif // !_DEBUG

   271 inline TBool StringUtils::IsTableEntry(TInt aVal)

   272 	{

   273 	return IS_TABLE_ENTRY(aVal);

   274 	}

   276 inline TInt StringUtils::TableIndex(TInt aVal)

   277 	{

   278 	return TABLE_INDEX(aVal);

   279 	}

   281 inline TInt16 StringUtils::TableUid(TInt aVal)

   282 	{

   283 	return (TInt16) TABLE_UID(aVal);

   284 	}

   286 inline CStringPoolNode* StringUtils::NodePtr(TInt aVal)

   287 	{

   288 	return reinterpret_cast<CStringPoolNode*>(aVal & KTokenToNode);

   289 	}

   291 inline RStringEither::RStringEither(CStringPoolImplementation* aPool,

   292 							 RStringTokenEither aVal)

   293 	{

   294 	iPool = aPool->Handle();

   295 	iVal = aVal.iVal;

   296 	}

   298 inline RStringPool CStringPoolImplementation::Handle()

   299 	{

   300 	RStringPool p;

   301 	p.iImplementation = this;

   302 	return p;

   303 	}

   305 inline RStringTokenEither::RStringTokenEither()

   306 	{

   307 	}

   309 inline RStringTokenEither::RStringTokenEither(TUint32 aVal)

   310 	{

   311 	iVal = aVal;

   312 	}

   314 inline TBool RStringTokenEither::operator==(RStringTokenEither aVal) const

   315 	{

   316 	return iVal == aVal.iVal;

   317 	}

   319 inline TBool RStringTokenEither::operator!=(RStringTokenEither aVal) const

   320 	{

   321 	return iVal != aVal.iVal;

   322 	}

   324 inline RStringTokenEither RStringTokenEither::operator=(RStringBase aVal)

   325 	{

   326 	RStringTokenBase b = aVal;

   327 	iVal = b.iVal;

   328 	return *this;

   329 	}

   332 #endif // __STRINGPOOLIMPLEMENTATION_H__

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