diff -r c55016431358 -r 0a7b44b10206 symport/bafl/inc/stringpool.h --- /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 +#include +#include + +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 + +#endif // __STRINGPOOL_H__ + +