--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/inc/stringpool.h Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,291 @@
+// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __STRINGPOOL_H__
+#define __STRINGPOOL_H__
+
+#include <e32base.h>
+#include <stringtablesupport.h>
+#include <stringpoolerr.h>
+
+class RStringF;
+class RString;
+class RStringToken;
+class RStringTokenF;
+class MStringPoolCloseCallBack;
+class RStringBase;
+class CStringPoolImplementation;
+
+
+class MStringPoolCloseCallBack
+/**
+Abstract callback interface that alerts implementors to when a string pool
+closes.
+@publishedAll
+@released
+*/
+ {
+ ///Implement this function to perform some operation when the string pool is being closed
+ public:
+ /** Called when the string pool is about to close. */
+ virtual void StringPoolClosing()=0;
+ };
+
+/** The string pool handle object. A string pool can have several
+ distinct handles associated with it, each associated with a
+ different pre-loaded table. The difference between them is that
+ creating a string from an enum will interpret the enum as an
+ offset into the relevant pre-loaded table */
+class RStringPool
+/**
+String pool handle.
+
+A string pool can have several distinct handles associated with it, each associated
+with a different pre-loaded table. Creating a string from an enum value interprets
+the value as an offset into the relevant pre-loaded table.
+@publishedAll
+@released
+*/
+ {
+ public:
+ inline RStringPool();
+
+ IMPORT_C void OpenL();
+
+ IMPORT_C void OpenL(const TStringTable& aTable);
+
+ IMPORT_C void OpenL(const TStringTable& aTable,MStringPoolCloseCallBack& aCallBack);
+
+ IMPORT_C void Close();
+
+ IMPORT_C RStringF OpenFStringL(const TDesC8& aString) const;
+
+ IMPORT_C RString OpenStringL(const TDesC8& aString) const;
+
+ IMPORT_C RString String(RStringToken aString) const;
+
+ IMPORT_C RString String(TInt aIndex,const TStringTable& aTable) const;
+
+ IMPORT_C RStringF StringF(RStringTokenF aString) const;
+
+ IMPORT_C RStringF StringF(TInt aIndex,const TStringTable& aTable) const;
+
+ private:
+ friend class RStringBase;
+ friend class RString;
+ friend class RStringF;
+ friend class CStringPoolImplementation;
+
+ CStringPoolImplementation* iImplementation;
+ };
+
+/** A compact (4 byte) representation of a string in the string pool. This
+ class must be turned into a RStringBase (or one of its derived classes) before you can do anything
+ useful with it. It is only intended to be used when storing strings
+ in situations where space matters; normaly use RStringBase.
+ @see RStringBase
+*/
+class RStringTokenBase
+/**
+Base class for the RStringToken and RStringTokenF string representations.
+A compact (4 byte) representation of a string in the string pool. This
+class must be turned into a RStringBase (or one of its derived classes) before you can do anything
+useful with it. It is only intended to be used when storing strings
+in situations where space matters; normaly use RStringBase.
+@see RStringBase
+@publishedAll
+@released
+*/
+ {
+ public:
+ inline RStringTokenBase();
+
+ inline RStringTokenBase operator=(RStringBase aVal);
+
+ inline TBool IsNull() const;
+
+ protected:
+ friend class RStringPool;
+ friend class RStringBase;
+ friend class RStringTokenEither;
+ friend class CStringPoolImplementation;
+
+ TUint32 iVal;
+ };
+
+
+class RStringToken : public RStringTokenBase
+/**
+A compact (4 byte) representation of a string in the string pool.
+
+This class must be turned into a RString before you can do anything useful
+with it. It is only intended to be used when storing strings in situations
+where space matters. You should normally use RString.
+@publishedAll
+@released
+*/
+ {
+ public:
+ inline TBool operator==(RStringToken aVal) const;
+
+ inline TBool operator!=(RStringToken aVal) const;
+
+ inline RStringToken operator=(RString aVal);
+
+ friend class RStringPool;
+ friend class RString;
+ friend class CStringPoolImplementation;
+ };
+
+class RStringTokenF : public RStringTokenBase
+/**
+A compact (4 byte) representation of a RStringF string in the string pool.
+
+This class must be turned into a RStringF before you can do anything useful
+with it. It is only intended to be used when storing strings in situations
+where space matters. You should normally use RStringF.
+@publishedAll
+@released
+*/
+ {
+ public:
+ inline TBool operator==(RStringTokenF aVal) const;
+
+ inline TBool operator!=(RStringTokenF aVal) const;
+
+ inline RStringTokenF operator=(RStringF aVal);
+
+ friend class RStringPool;
+ friend class RStringF;
+ friend class CStringPoolImplementation;
+ };
+
+class RStringBase
+/**
+Base class for classes that represent a string in a string pool.
+
+There are sub-classes for folded and non-folded strings. Use this class when
+you want to receive a string, but have no intention of comparing it with anything.
+
+
+@see RStringPool
+@publishedAll
+@released
+*/
+ {
+ public:
+ inline RStringBase();
+
+ IMPORT_C void Close();
+
+ IMPORT_C RStringBase Copy();
+
+ IMPORT_C const TDesC8& DesC() const;
+
+ inline operator RStringTokenBase() const;
+
+ IMPORT_C TInt Index(const TStringTable& aTable) const;
+
+ IMPORT_C const TStringTable* OriginalTableRef() const;
+
+ inline RStringPool Pool() const;
+
+ protected:
+ friend class RStringPool;
+ friend class RStringTokenBase;
+
+ RStringPool iPool;
+ TUint32 iVal;
+ };
+
+class RString : public RStringBase
+/**
+A string that is stored in a string pool, with case-sensitive comparisons.
+
+To initialise values of this class, you need to use the operator() functions
+on the RStringPool.
+
+This class performs comparisons in a non-folded (case sensitive) manner.
+
+@see RStringPool
+@publishedAll
+@released
+*/
+ {
+ public:
+ inline RString Copy();
+
+ inline operator RStringToken() const;
+
+ inline TBool operator==(const RString& aVal) const;
+
+ inline TBool operator!=(const RString& aVal) const;
+
+ friend class RStringPool;
+ friend class RStringToken;
+ };
+
+class RStringF : public RStringBase
+/**
+A string that is stored in a string pool, with case-insensitive comparisons.
+
+To initialise values of this class, you need to use the operator() functions
+on the RStringPool.
+
+Comparisons with this class use folded (case insensitive) comparisons.
+@publishedAll
+@released
+*/
+ {
+ public:
+ inline RStringF Copy();
+
+ inline operator RStringTokenF() const;
+
+ inline TBool operator==(const RStringF& aVal) const;
+
+ inline TBool operator!=(const RStringF& aVal) const;
+
+ friend class RStringPool;
+ friend class RStringTokenF;
+ };
+
+/**
+A pointer to a string table.
+@publishedAll
+@released
+*/
+
+struct TStringTable
+ {
+ /// The number of elements in the table
+ /** The number of elements in the table. */
+ TUint iCount;
+ /// A pointer to an array of pointers to the strings
+ /** A pointer to an array of pointers to the strings. */
+ const void* const * iTable;
+
+ /// ETrue if the table should be considered case-sensitive.
+ /** Flag that is ETrue if the table should be considered case-sensitive, otherwise
+ EFalse. */
+ TBool iCaseSensitive;
+ };
+
+// Include the inline functions
+#include <stringpool.inl>
+
+#endif // __STRINGPOOL_H__
+
+