// Copyright (c) 1994-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 "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:

 // e32\include\e32std.h

 // 

 //

 #ifndef __E32STD_H__

 #define __E32STD_H__

 #ifdef __KERNEL_MODE__

 #error !! Including e32std.h in kernel code !!

 #endif

 #include <e32cmn.h>

 /**

 @publishedAll

 @released

 */

 class TFunctor

 	{

 public:

 	IMPORT_C virtual void operator()() =0;

 	};

 /**

 @publishedAll

 @released

 Encapsulates a general call-back function.

 The class encapsulates:

 1. a pointer to a function which takes an argument of type TAny* and returns 

    a TInt.

 2. a pointer which is passed to the function every time it is called.

    The pointer can point to any object. It can also be NULL.

 The callback function can be a static function of a class,

 e.g. TInt X::Foo(TAny *) or it can be a function which is not a member of

 any class, e.g. TInt Foo(TAny *).

 When used with the CIdle and the CPeriodic classes, the callback function

 is intended to be called repeatedly; the encapsulated pointer is passed on

 each call. Typically, the pointer refers to an object which records the state

 of the task across each call. When used with CIdle, the callback function

 should also return a true (non-zero) value if it is intended to be called

 again, otherwise it should return a false (zero) value.

 @see CIdle

 @see CPeriodic

 */

 class TCallBack

 	{

 public:

 	inline TCallBack();

 	inline TCallBack(TInt (*aFunction)(TAny* aPtr));

 	inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);

 	inline TInt CallBack() const;

 public:

 	/**

 	A pointer to the callback function.

 	*/

 	TInt (*iFunction)(TAny* aPtr);

 	/**

 	A pointer that is passed to the callback function when

 	the function is called.

 	*/

 	TAny* iPtr;

 	};

 /**

 @publishedAll

 @released

 An object embedded within a class T so that objects of type T can form part 

 of a singly linked list.

 A link object encapsulates a pointer to the next link object in the list.

 @see TSglQue

 */

 class TSglQueLink

 	{

 #if defined _DEBUG

 public:

 	inline TSglQueLink() : iNext(NULL)

 	/**

 	An explicitly coded default constructor that is only defined for DEBUG builds.

 	It sets the pointer to the next link object to NULL.

 	@see iNext

 	*/

 	{}

 #endif

 private:

 	IMPORT_C void Enque(TSglQueLink* aLink);

 public:

 	/**

 	A pointer to the next link object in the list.

 	*/

 	TSglQueLink* iNext;

 	friend class TSglQueBase;

 	};

 /**

 @publishedAll

 @released

 A base class that provides implementation for the link object of a doubly

 linked list.

 It also encapsulates pointers both to the next and the previous link 

 objects in the doubly linked list.

 The class is abstract and is not intended to be instantiated.

 @see TDblQueLink

 */

 class TDblQueLinkBase

 	{

 public:

 	inline TDblQueLinkBase() : iNext(NULL)

 	/**

 	Default constructor.

 	It sets the pointer to the next link object to NULL.

 	@see iNext

 	*/

 	{}

 	IMPORT_C void Enque(TDblQueLinkBase* aLink);

 	IMPORT_C void AddBefore(TDblQueLinkBase* aLink);

 public:

 	/**

 	A pointer to the next link object in the list.

 	*/

 	TDblQueLinkBase* iNext;

 	/**

 	A pointer to the previous link object in the list.

 	*/

 	TDblQueLinkBase* iPrev;

 	};

 /**

 @publishedAll

 @released

 An object embedded within a class T so that objects of type T can form part 

 of a doubly linked list.

 */

 class TDblQueLink : public TDblQueLinkBase

 	{

 public:

 	IMPORT_C void Deque();

 	};

 /**

 @publishedAll

 @released

 An object embedded within a class T so that objects of type T can form part

 of an ordered doubly linked list.

 Objects are added to the doubly linked list in descending priority order.

 */

 class TPriQueLink : public TDblQueLink

 	{

 public:

 	/**

 	The priority value.

     Objects are added to the doubly linked list in descending order of this value.

 	*/

 	TInt iPriority;

 	};

 /**

 @publishedAll

 @released

 An object embedded within a class T so that objects of type T can form part 

 of a delta doubly linked list.

 */

 class TDeltaQueLink : public TDblQueLinkBase

 	{

 public:

 	/**

 	The delta value.

 	*/

 	TInt iDelta;

 	};

 /**

 @publishedAll

 @released

 An object embedded within a class T so that objects of type T can form part 

 of a doubly linked list sorted by tick count.

 */

 class TTickCountQueLink : public TDblQueLink

 	{

 public:

 	/**

 	The tick count.

 	*/

 	TUint iTickCount;

 	};

 /**

 @publishedAll

 @released

 A base class that provides implementation for the singly linked list header. 

 It also encapsulates the offset value of a link object.

 The class is abstract and is not intended to be instantiated.

 @see TSglQue

 */

 class TSglQueBase

 	{

 public:

 	IMPORT_C TBool IsEmpty() const;

 	IMPORT_C void SetOffset(TInt aOffset);

 	IMPORT_C void Reset();

 protected:

 	IMPORT_C TSglQueBase();

 	IMPORT_C TSglQueBase(TInt aOffset);

 	IMPORT_C void DoAddFirst(TAny* aPtr);

 	IMPORT_C void DoAddLast(TAny* aPtr);

 	IMPORT_C void DoRemove(TAny* aPtr);

 protected:

 	/**

 	A pointer to the first element in the list.

 	*/

 	TSglQueLink* iHead;

 	/**

 	A pointer to the last element in the list.

 	*/

 	TSglQueLink* iLast;

 	/**

 	The offset of a component link object within elements that form the list.

 	*/

 	TInt iOffset;

 private:

 	TSglQueBase(const TSglQueBase& aQue);

 	TSglQueBase &operator=(const TSglQueBase& aQue);

 	friend class TSglQueIterBase;

 	};

 /**

 @publishedAll

 @released

 A base class that provides implementation for the doubly linked list header. 

 It also encapsulates the offset value of a link object.

 The class is abstract and is not intended to be instantiated.

 @see TDblQue

 */

 class TDblQueBase

 	{

 public:

 	IMPORT_C TBool IsEmpty() const;

 	IMPORT_C void SetOffset(TInt aOffset);

 	IMPORT_C void Reset();

 protected:

 	IMPORT_C TDblQueBase();

 	IMPORT_C TDblQueBase(TInt aOffset);

 	IMPORT_C void DoAddFirst(TAny* aPtr);

 	IMPORT_C void DoAddLast(TAny* aPtr);

 	IMPORT_C void DoAddPriority(TAny* aPtr);

 	IMPORT_C void __DbgTestEmpty() const;

 protected:

 	/**

 	The head, or anchor point of the queue.

 	*/

 	TDblQueLink iHead;

 	/**

 	The offset of a component link object within elements that form the list.

 	*/

 	TInt iOffset;

 private:

 	TDblQueBase(const TDblQueBase& aQue);

 	TDblQueBase& operator=(const TDblQueBase& aQue);

 	friend class TDblQueIterBase;

 	};

 /**

 @publishedAll

 @released

 A base class that provides implementation for the TDeltaQue template class.

 The class is abstract and is not intended to be instantiated.

 @see TDeltaQue

 */

 class TDeltaQueBase : public TDblQueBase

 	{

 public:

 	IMPORT_C TBool CountDown();

 	IMPORT_C TBool CountDown(TInt aValue);

 	IMPORT_C TBool FirstDelta(TInt& aValue);

 	IMPORT_C void Reset();

 protected:

 	IMPORT_C TDeltaQueBase();

 	IMPORT_C TDeltaQueBase(TInt aOffset);

 	IMPORT_C void DoAddDelta(TAny* aPtr,TInt aDelta);

 	IMPORT_C void DoRemove(TAny* aPtr);

 	IMPORT_C TAny* DoRemoveFirst();

 protected:

 	/**

 	Pointer to the delta value in the first link element.

 	*/

 	TInt* iFirstDelta;

 	};

 /**

 @publishedAll

 @released

 A templated class that provides the behaviour for managing a singly linked 

 list.

 It also acts as the head of the list, maintaining the pointers into the list.

 The template parameter defines the type of element that forms the singly linked 

 list and is the class that acts as host to the link object.

 @see TSglQueLink

 */

 template <class T>

 class TSglQue : public TSglQueBase

 	{

 public:

 	inline TSglQue();

 	inline explicit TSglQue(TInt aOffset);

 	inline void AddFirst(T& aRef);

 	inline void AddLast(T& aRef);

 	inline TBool IsFirst(const T* aPtr) const;

 	inline TBool IsLast(const T* aPtr) const;

 	inline T* First() const;

 	inline T* Last() const;

 	inline void Remove(T& aRef);

 	};

 /**

 @publishedAll

 @released

 A templated class that provides the behaviour for managing a doubly linked 

 list. 

 It also acts as the head of the list, maintaining the pointers into the list.

 The template parameter defines the type of element that forms the doubly linked 

 list and is the class that acts as host to the link object.

 @see TDblQueLink

 */

 template <class T>

 class TDblQue : public TDblQueBase

 	{

 public:

 	inline TDblQue();

 	inline explicit TDblQue(TInt aOffset);

 	inline void AddFirst(T& aRef);

 	inline void AddLast(T& aRef);

 	inline TBool IsHead(const T* aPtr) const;

 	inline TBool IsFirst(const T* aPtr) const;

 	inline TBool IsLast(const T* aPtr) const;

 	inline T* First() const;

 	inline T* Last() const;

 	};

 /**

 @publishedAll

 @released

 A templated class that provides the behaviour for managing a doubly linked

 list in which the elements are added in descending priority order.

 Priority is defined by the value of the TPriQueLink::iPriority member of

 the link element.

 The template parameter defines the type of element that forms the doubly linked

 list and is the class that acts as host to the link object.

 @see TPriQueLink

 @see TPriQueLink::iPriority

 */

 template <class T>

 class TPriQue : public TDblQueBase

 	{

 public:

 	inline TPriQue();

 	inline explicit TPriQue(TInt aOffset);

 	inline void Add(T& aRef);

 	inline TBool IsHead(const T* aPtr) const;

 	inline TBool IsFirst(const T* aPtr) const;

 	inline TBool IsLast(const T* aPtr) const;

 	inline T* First() const;

 	inline T* Last() const;

 	};

 /**

 @publishedAll

 @released

 A templated class that provides the behaviour for managing a doubly linked 

 list in which elements represent values which are increments, or deltas, on 

 the value represented by a preceding element.

 The list is ordered so that the head of the queue represents a nominal zero 

 point.

 The delta value of a new element represents its 'distance' from the nominal 

 zero point. The new element is added into the list, and the delta values of 

 adjacent elements (and of the new element, if necessary) are adjusted, so 

 that the sum of all deltas, up to and including the new element, is the same 

 as the new element's intended 'distance' from the nominal zero point.

 A common use for a list of this type is as a queue of timed events, where 

 the delta values represent the intervals between the events.

 The delta value is defined by the value of the TDeltaQueLink::iDelta member 

 of the link element.

 The template parameter defines the type of element that forms the doubly linked 

 list and is the class that acts as host to the link object.

 @see TDeltaQueLink

 @see TDeltaQueLink::iDelta

 */

 template <class T>

 class TDeltaQue : public TDeltaQueBase

 	{

 public:

 	inline TDeltaQue();

 	inline explicit TDeltaQue(TInt aOffset);

 	inline void Add(T& aRef,TInt aDelta);

 	inline void Remove(T& aRef);

 	inline T* RemoveFirst();

 	};

 // Forward declaration

 class TTickCountQueLink;

 /**

 @internalComponent

 @released

 A class that provides the behaviour for managing a doubly linked list

 in which elements are added in order of the time until their tick count.

 A common use for a list of this type is as a queue of timed events, where 

 the tick counts are the expiry times of the events.

 The tick count is defined by the value of the TTickCountQueLink::iTickCount

 member of the link element.

 @see TTickCountQueLink

 @see TTickCountQueLink::iTickCount

 */

 class TTickCountQue : public TDblQueBase

 	{

 public:

 	TTickCountQue();

 	void Add(TTickCountQueLink& aRef);

 	TTickCountQueLink* First() const;

 	TTickCountQueLink* RemoveFirst();

 	TTickCountQueLink* RemoveFirst(TUint aTickCount);

 	};

 /**

 @publishedAll

 @released

 A base class that provides implementation for the singly linked list iterator. 

 It also encapsulates a pointer to the current link link list element.

 The class is abstract and is not intended to be instantiated.

 */

 class TSglQueIterBase

 	{

 public:

 	IMPORT_C void SetToFirst();

 protected:

 	IMPORT_C TSglQueIterBase(TSglQueBase& aQue);

 	IMPORT_C TAny* DoPostInc();

 	IMPORT_C TAny* DoCurrent();

 	IMPORT_C void DoSet(TAny* aLink);

 protected:

 	TInt iOffset;

 	TSglQueLink* iHead;

 	TSglQueLink* iNext;

 	};

 /**

 @publishedAll

 @released

 A templated class that provides the behaviour for iterating through a set of 

 singly linked list elements.

 The template parameter defines the type of element that forms the singly linked 

 list. The class defined in the template parameter contains the link object.

 */

 template <class T>

 class TSglQueIter : public TSglQueIterBase

 	{

 public:

 	inline TSglQueIter(TSglQueBase& aQue);

 	inline void Set(T& aLink);

 	inline operator T*();

 	inline T* operator++(TInt);

 	};

 /**

 @publishedAll

 @released

 A base class that provides implementation for the doubly linked list iterator.

 It also encapsulates a pointer to the current link list element.

 The class is abstract and is not intended to be instantiated.

 */

 class TDblQueIterBase

 	{

 public:

 	IMPORT_C void SetToFirst();

 	IMPORT_C void SetToLast();

 protected:

 	IMPORT_C TDblQueIterBase(TDblQueBase& aQue);

 	IMPORT_C TAny* DoPostInc();

 	IMPORT_C TAny* DoPostDec();

 	IMPORT_C TAny* DoCurrent();

 	IMPORT_C void DoSet(TAny* aLink);

 protected:

 	/**

 	The offset of a component link object within elements that form the list.

 	*/

 	TInt iOffset;

 	/**

 	Pointer to the anchor for the list.

 	*/

 	TDblQueLinkBase* iHead;

 	/**

 	Pointer to the current element.

 	*/

 	TDblQueLinkBase* iNext;

 	};

 /**

 @publishedAll

 @released

 A templated class that provides the behaviour for iterating through a set of 

 doubly linked list elements.

 The template parameter defines the type of element that forms the doubly linked 

 list. The class defined in the template parameter contains the link object.

 */

 template <class T>

 class TDblQueIter : public TDblQueIterBase

 	{

 public:

 	inline TDblQueIter(TDblQueBase& aQue);

 	inline void Set(T& aLink);

 	inline operator T*();

 	inline T* operator++(TInt);

 	inline T* operator--(TInt);

 	};

 /**

 @publishedAll

 @released

 Governs the type of comparison to be made between descriptor keys or between 

 text keys.

 @see TKeyArrayFix

 @see TKeyArrayVar

 @see TKeyArrayPak

 */

 enum TKeyCmpText

 	{

 	/**

 	For a Unicode build, this is the same as ECmpNormal16.

 	For a non-Unicode build, this is the same as ECmpNormal8.

 	Using the build independent names (i.e. TPtrC, TPtr, TBufC, TBuf or TText) 

 	allows the compiler to chose the correct variant according to the build.

 	*/

 	ECmpNormal,

 	/**

 	For descriptor keys, the key is assumed to be the 8 bit variant, derived

 	from TDesc8. A simple comparison is done between the content of the

 	descriptors; the data is not folded and collation rules are not applied for

 	the purpose of the comparison.

 	For text keys, the key is assumed to be the 8 bit variant, of type TText8. 

 	A normal comparison is done between the text data; the data is not folded 

 	and collation rules are not applied for the purpose of the comparison.

 	*/

 	ECmpNormal8,

 	/**

 	For descriptor keys, the key is assumed to be the 16 bit variant, derived

 	from TDesc16. A simple comparison is done between the content of the

 	descriptors; the data is not folded and collation rules are not applied for

 	the purpose of the comparison.

 	For text keys, the key is assumed to be the 16 bit variant, of type

 	TText16. A normal comparison is done between the text data; the data is

 	not folded 	and collation rules are not applied for the purpose of the

 	comparison.

 	*/

 	ECmpNormal16,

 	/**

 	For a Unicode build, this is the same as EcmpFolded16.

     For a non-Unicode build, this is the same as EcmpFolded8.

     Using the build independent names (i.e. TPtrC, TPtr, TBufC, TBuf or TText)

     allows the compiler to chose the correct variant according to the build. 

 	*/

 	ECmpFolded,

 	/**

 	For descriptor keys, the key is assumed to be the 8 bit variant,

 	derived from TDesc8. The descriptor contents are folded for the purpose

 	of the comparison.

     For text keys, the key is assumed to be the 8 bit variant, of type

     TText8. The text data is folded for the purpose of the comparison.

 	*/

 	ECmpFolded8,

 	/**

 	For descriptor keys, the key is assumed to be the 16 bit variant,

 	derived from TDesc16. The descriptor contents are folded for the purpose

 	of the comparison.

     For text keys, the key is assumed to be the 16 bit variant, of type

     TText16. The text data is folded for the purpose of the comparison.

 	*/

 	ECmpFolded16,

 	/**

 	For a Unicode build, this is the same as EcmpCollated16.

     For a non-Unicode build, this is the same as EcmpCollated8.

     Using the build independent names (i.e. TPtrC, TPtr, TBufC, TBuf or TText)

     allows the compiler to chose the correct variant according to the build.

 	*/

 	ECmpCollated,

 	/**

 	For descriptor keys, the key is assumed to be the 8 bit variant,

 	derived from TDesc8. Collation rules are applied for the purpose of

 	the comparison.

     For text keys, the key is assumed to be the 8 bit variant, of type 

     TText8. Collation rules are applied for the purpose of the comparison.

 	*/

 	ECmpCollated8,

 	/**

 	For descriptor keys, the key is assumed to be the 16 bit variant,

 	derived from TDesc16. Collation rules are applied for the purpose of

 	the comparison.

     For text keys, the key is assumed to be the 16 bit variant,

     of type TText16. Collation rules are applied for the purpose of

     the comparison.

 	*/

 	ECmpCollated16

 	};

 /**

 @publishedAll

 @released

 Governs the type of comparison to be made between numeric keys.

 @see TKeyArrayFix

 @see TKeyArrayVar

 @see TKeyArrayPak

 */

 enum TKeyCmpNumeric

 	{

 	/**

 	The key is assumed to be of type TInt8.

 	*/

 	ECmpTInt8=((ECmpCollated16+1)<<1),

 	/**

 	The key is assumed to be of type TInt16.

 	*/

 	ECmpTInt16,

 	/**

 	The key is assumed to be of type TInt32.

 	*/

 	ECmpTInt32,

 	/**

 	The key is assumed to be of type TInt.

 	*/

 	ECmpTInt,

 	/**

 	The key is assumed to be of type TUint8.

 	*/

 	ECmpTUint8,

 	/**

 	The key is assumed to be of type TUint16.

 	*/

 	ECmpTUint16,

 	/**

 	The key is assumed to be of type TUint32.

 	*/

 	ECmpTUint32,

 	/**

 	The key is assumed to be of type TUint.

 	*/

 	ECmpTUint,

 	/**

 	The key is assumed to be of type TInt64.

 	*/

 	ECmpTInt64

 	};

 /**

 @publishedAll

 @released

 Defines the characteristics of a key used to access the elements of an array.

 The class is abstract and cannot be instantiated. A derived class must be 

 defined and implemented.

 The classes TKeyArrayFix, TKeyArrayVar and TKeyArrayPak, derived from TKey, 

 are already supplied to implement keys for the fixed length element, variable 

 length element and packed arrays.

 A derived class would normally be written to define the characteristics of 

 a key for a non standard array.

 @see TKeyArrayFix

 @see TKeyArrayVar

 @see TKeyArrayPak

 */

 class TKey

 	{

 public:

 	inline void SetPtr(const TAny* aPtr);

 	IMPORT_C virtual TInt Compare(TInt aLeft,TInt aRight) const;

 	IMPORT_C virtual TAny* At(TInt anIndex) const;

 protected:

 	IMPORT_C TKey();

 	IMPORT_C TKey(TInt aOffset,TKeyCmpText aType);

 	IMPORT_C TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);

 	IMPORT_C TKey(TInt aOffset,TKeyCmpNumeric aType);

 protected:

 	TInt iKeyOffset;

 	TInt iKeyLength;

 	TInt iCmpType;

 	const TAny* iPtr;

 	};

 /**

 @publishedAll

 @released

 Defines the basic behaviour for swapping two elements of an array.

 The class is abstract. A derived class must be defined and implemented to 

 use the functionality.

 A derived class can define how to swap two elements of an array. In practice, 

 this means providing an implementation for the virtual function Swap().

 To support this, the derived class is also likely to need a pointer to the 

 array itself and suitable constructors and/or other member functions to set 

 such a pointer.

 */

 class TSwap

 	{

 public:

 	IMPORT_C TSwap();

 	IMPORT_C virtual void Swap(TInt aLeft,TInt aRight) const;

 	};

 /**

 @publishedAll

 @released

 Folds a specified character and provides functions to fold additional

 characters after construction of the object.

 Folding converts the character to a form which can be used in tolerant

 comparisons without control over the operations performed. Tolerant comparisons

 are those which ignore character differences like case and accents. 

 Note that folding is locale-independent behaviour. It is also important to 

 note that there can be no guarantee that folding is in any way culturally 

 appropriate, and should not be used for matching characters in

 natural language.

 @see User::Fold

 */

 class TCharF : public TChar

 	{

 public:

 	inline TCharF(TUint aChar);

 	inline TCharF(const TChar& aChar);

 	inline TCharF& operator=(TUint aChar);

 	inline TCharF& operator=(const TChar& aChar);

 	};

 /**

 @publishedAll

 @released

 Converts a specified character to lower case and provides functions to convert 

 additional characters after construction of the object.

 */

 class TCharLC : public TChar

 	{

 public:

 	inline TCharLC(TUint aChar);

 	inline TCharLC(const TChar& aChar);

 	inline TCharLC& operator=(TUint aChar);

 	inline TCharLC& operator=(const TChar& aChar);

 	};

 /**

 @publishedAll

 @released

 Converts a specified character to upper case and provides functions to convert 

 additional characters after construction of the object.

 */

 class TCharUC : public TChar

 	{

 public:

 	inline TCharUC(TUint aChar);

 	inline TCharUC(const TChar& aChar);

 	inline TCharUC& operator=(TUint aChar);

 	inline TCharUC& operator=(const TChar& aChar);

 	};

 /**

 @publishedAll

 @released

 Defines the character representation of a real number type such

 as a TReal or a TRealX.

 An object of this type is used by functions that convert real values to

 character format, for example, the descriptor functions:

 Num(), AppendNum() and Format().

 There are three constructors for constructing a suitable object.

 The data members of the class, however, are public and can be

 explicitly set after construction.

 */

 class TRealFormat

 	{

 public:

 	IMPORT_C TRealFormat();

 	IMPORT_C TRealFormat(TInt aWidth);

 	IMPORT_C TRealFormat(TInt aWidth,TInt aDecimalPlaces);

 public:

     /**

     Governs the format of the character representation of the real number.

     This is set to one of the defined format types.

     One or more of the defined format flags can subsequently be ORed into this member.

     @see KRealFormatFixed

     @see KRealFormatExponent

     @see KRealFormatGeneral

     @see KRealFormatNoExponent

     @see KRealFormatCalculator

     @see KExtraSpaceForSign

     @see KAllowThreeDigitExp

     @see KDoNotUseTriads

     @see KGeneralLimit

     @see KUseSigFigs

     */

 	TInt iType;

 	/**

 	Defines the maximum number of characters required to represent the number.

 	*/

 	TInt iWidth;

 	/**

 	Defines either the number of characters to be used to represent the decimal

 	portion of the number, or the maximum number of significant digits in

 	the character representation of the number.

     The interpretation depends on the chosen format as defined by iType.

 	@see TRealFormat::iType

 	*/

 	TInt iPlaces;

 	/**

 	Defines the character to be used to separate the integer portion of

 	a number representation from its decimal portion.

     In general, the character used for this purpose is a matter of local

     convention. The TLocale::DecimalSeparator() function can supply the

     desired character.

     @see TLocale

 	*/

 	TChar iPoint;

 	/**

 	Defines the character to be used to delimit groups of three digits in

 	the integer part of the number.

     In general, the character used for this purpose is a matter of local

     convention. The TLocale::ThousandsSeparator() function can supply the

     desired character.

     @see TLocale

 	*/

 	TChar iTriad;

 	/**

 	Defines the threshold number of digits above which triad separation is to

 	occur. A value of zero disables triad separation and no triad separation

 	character (i.e. the character held in iTriad) is inserted into the

 	resulting character representation regardless of the number of characters.

     For example, a value of 1 causes the number 1000 to be represented by the

     characters "1,000" whereas a value of 4 causes the same number to be

     represented by the characters "1000" (This assumes the ‘,’ triad separation

     character).

     Note that no triad separation occurs if the flag KDoNotUseTriads is set in

     the iType data member.

 	@see TRealFormat::iTriad

 	@see KDoNotUseTriads

 	*/

 	TInt iTriLen;

 	};

 /**

 @publishedAll

 @released

 Defines the extraction mark used by the TLex8 class to indicate the current 

 lexical element being analysed.

 In practice, objects of this type are accessed through the TLexMark typedef.

 @see TLexMark

 @see TLex8

 */

 class TLexMark8

 	{

 public:

 	inline TLexMark8();

 private:

 	inline TLexMark8(const TUint8* aString);

 	const TUint8* iPtr;

 	friend class TLex8;

 	__DECLARE_TEST;

 	};

 class TRealX;

 /**

 @publishedAll

 @released

 Provides general string-parsing functions suitable for numeric format

 conversions and syntactical-element parsing.

 The class is the 8-bit variant for non-Unicode strings and 8-bit wide

 characters.

 An instance of this class stores a string, maintaining an extraction mark 

 to indicate the current lexical element being analysed and a pointer to the 

 next character to be examined.

 Objects of this type are normally accessed through the build independent type 

 TLex.

 @see TLex

 */

 class TLex8

 	{

 public:

 	IMPORT_C TLex8();

 	inline TLex8(const TUint8* aString);

 	inline TLex8(const TDesC8& aDes);

 	inline TLex8& operator=(const TUint8* aString);

 	inline TLex8& operator=(const TDesC8& aDes);

 	inline TBool Eos() const;

 	inline void Mark(TLexMark8& aMark) const;

 	inline void Mark();

 	IMPORT_C void Inc();

 	IMPORT_C void Inc(TInt aNumber);

 	IMPORT_C TChar Get();

 	IMPORT_C TChar Peek() const;

 	IMPORT_C void UnGet();

 	inline void UnGetToMark();

 	IMPORT_C void UnGetToMark(const TLexMark8 aMark);

 	IMPORT_C void SkipSpace();

 	inline void SkipAndMark(TInt aNumber);

 	IMPORT_C void SkipAndMark(TInt aNumber, TLexMark8& aMark);

 	inline void SkipSpaceAndMark();

 	IMPORT_C void SkipSpaceAndMark(TLexMark8& aMark);

 	IMPORT_C void SkipCharacters();

 	inline TInt TokenLength() const;

 	IMPORT_C TInt TokenLength(const TLexMark8 aMark) const;

 	IMPORT_C TPtrC8 MarkedToken() const;

 	IMPORT_C TPtrC8 MarkedToken(const TLexMark8 aMark) const;

 	IMPORT_C TPtrC8 NextToken();

 	IMPORT_C TPtrC8 Remainder() const;

 	IMPORT_C TPtrC8 RemainderFromMark() const;

 	IMPORT_C TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;

 	IMPORT_C TInt Offset() const;

 	inline TInt MarkedOffset() const;

 	IMPORT_C TInt MarkedOffset(const TLexMark8 aMark) const;

 	IMPORT_C TInt Val(TInt8& aVal);

 	IMPORT_C TInt Val(TInt16& aVal);

 	IMPORT_C TInt Val(TInt32& aVal);

 	IMPORT_C TInt Val(TInt64& aVal);

 	inline TInt Val(TInt& aVal);

 	IMPORT_C TInt Val(TUint8& aVal,TRadix aRadix);

 	IMPORT_C TInt Val(TUint16& aVal,TRadix aRadix);

 	IMPORT_C TInt Val(TUint32& aVal,TRadix aRadix);

 	IMPORT_C TInt Val(TInt64& aVal, TRadix aRadix);

 	inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);

 	IMPORT_C TInt BoundedVal(TInt32& aVal,TInt aLimit);

 	IMPORT_C TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);

 	IMPORT_C TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);

 	IMPORT_C TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);

 	IMPORT_C TInt Val(TReal32& aVal);

 	IMPORT_C TInt Val(TReal32& aVal,TChar aPoint);

 	IMPORT_C TInt Val(TReal64& aVal);

 	IMPORT_C TInt Val(TReal64& aVal,TChar aPoint);

 	inline void Assign(const TLex8& aLex);

 	IMPORT_C void Assign(const TUint8* aString);

 	IMPORT_C void Assign(const TDesC8& aDes);

 	TInt Val(TRealX& aVal);

 	TInt Val(TRealX& aVal, TChar aPoint);

 	/** @deprecated Use BoundedVal(TInt32& aVal,TInt aLimit) */

 	inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };

 	/** @deprecated Use BoundedVal(TInt64& aVal,const TInt64& aLimit) */

 	inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };

 	/** @deprecated Use BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit) */

 	inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };

 	/** @deprecated Use BoundedVal(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) */

 	inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };

 private:

 	void Scndig(TInt& aSig, TInt& aExp, TUint64& aDl);

 	void ScndigAfterPoint(TInt& aSig, TUint64& aDl);

 	void ValidateMark(const TLexMark8 aMark) const;

 private:

 	const TUint8* iNext;

 	const TUint8* iBuf;

 	const TUint8* iEnd;

 	TLexMark8 iMark;

 	__DECLARE_TEST;

 	};

 /**

 @publishedAll

 @released

 Defines the extraction mark used by the TLex16 class to indicate the current 

 lexical element being analysed.

 In practice, objects of this type are accessed through the TLexMark typedef.

 @see TLexMark

 @see TLex16

 */

 class TLexMark16

 	{

 public:

 	inline TLexMark16();

 private:

 	inline TLexMark16(const TUint16* aString);

 	const TUint16* iPtr;

 	friend class TLex16;	

 	__DECLARE_TEST;

 	};

 /**

 @publishedAll

 @released

 Provides general string-parsing functions suitable for numeric format

 conversions and syntactical-element parsing. 

 The class is the 16-bit variant for Unicode strings and 16-bit wide

 characters.

 An instance of this class stores a string, maintaining an extraction mark 

 to indicate the current lexical element being analysed and a pointer to the 

 next character to be examined.

 Objects of this type are normally accessed through the build independent type 

 TLex.

 @see TLex

 */

 class TLex16

 	{

 public:

 	IMPORT_C TLex16();

 	inline TLex16(const TUint16* aString);

 	inline TLex16(const TDesC16& aDes);

 	inline TLex16& operator=(const TUint16* aString);

 	inline TLex16& operator=(const TDesC16& aDes);

 	inline TBool Eos() const;

 	inline void Mark();

 	inline void Mark(TLexMark16& aMark) const;

 	IMPORT_C void Inc();

 	IMPORT_C void Inc(TInt aNumber);

 	IMPORT_C TChar Get();

 	IMPORT_C TChar Peek() const;

 	IMPORT_C void UnGet();

 	inline void UnGetToMark();

 	IMPORT_C void UnGetToMark(const TLexMark16 aMark);

 	IMPORT_C void SkipSpace();

 	inline void SkipAndMark(TInt aNumber);

 	IMPORT_C void SkipAndMark(TInt aNumber, TLexMark16& aMark);

 	IMPORT_C void SkipSpaceAndMark(TLexMark16& aMark);

 	inline void SkipSpaceAndMark();

 	IMPORT_C void SkipCharacters();

 	inline TInt TokenLength() const;

 	IMPORT_C TInt TokenLength(const TLexMark16 aMark) const;

 	IMPORT_C TPtrC16 MarkedToken() const;

 	IMPORT_C TPtrC16 MarkedToken(const TLexMark16 aMark) const;

 	IMPORT_C TPtrC16 NextToken();

 	IMPORT_C TPtrC16 Remainder() const;

 	IMPORT_C TPtrC16 RemainderFromMark() const;

 	IMPORT_C TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;

 	IMPORT_C TInt Offset() const;

 	inline TInt MarkedOffset() const;

 	IMPORT_C TInt MarkedOffset(const TLexMark16 aMark) const;

 	IMPORT_C TInt Val(TInt8& aVal);

 	IMPORT_C TInt Val(TInt16& aVal);

 	IMPORT_C TInt Val(TInt32& aVal);

 	IMPORT_C TInt Val(TInt64& aVal);

 	inline TInt Val(TInt& aVal);

 	IMPORT_C TInt Val(TUint8& aVal,TRadix aRadix);

 	IMPORT_C TInt Val(TUint16& aVal,TRadix aRadix);

 	IMPORT_C TInt Val(TUint32& aVal,TRadix aRadix);

 	IMPORT_C TInt Val(TInt64& aVal, TRadix aRadix);

 //	inline TInt Val(TInt64& aVal, TRadix aRadix) {return Val(aVal,aRadix);}

 	inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);

 	IMPORT_C TInt BoundedVal(TInt32& aVal,TInt aLimit);

 	IMPORT_C TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);

 	IMPORT_C TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);

 	IMPORT_C TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);

 	IMPORT_C TInt Val(TReal32& aVal);

 	IMPORT_C TInt Val(TReal32& aVal,TChar aPoint);

 	IMPORT_C TInt Val(TReal64& aVal);

 	IMPORT_C TInt Val(TReal64& aVal,TChar aPoint);

 	inline void Assign(const TLex16& aLex);

 	IMPORT_C void Assign(const TUint16* aString);

 	IMPORT_C void Assign(const TDesC16& aDes);		

 	TInt Val(TRealX& aVal);

 	TInt Val(TRealX& aVal, TChar aPoint);

 	/** @deprecated Use BoundedVal(TInt32& aVal,TInt aLimit) */

 	inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };

 	/** @deprecated Use BoundedVal(TInt64& aVal,const TInt64& aLimit) */

 	inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };

 	/** @deprecated Use BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit) */

 	inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };

 	/** @deprecated Use BoundedVal(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) */

 	inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };

 private:

 	void Scndig(TInt& aSig, TInt& aExp, TUint64& aDl);

 	void ValidateMark(const TLexMark16 aMark) const;

 private:

 	const TUint16* iNext;

 	const TUint16* iBuf;

 	const TUint16* iEnd;

 	TLexMark16 iMark;

 	__DECLARE_TEST;

 	};

 #if defined(_UNICODE)

 /**

 @publishedAll

 @released

 Provides access to general string-parsing functions suitable for numeric format 

 conversions and syntactical-element parsing.

 It maps directly to either a TLex16 for a Unicode build or a TLex8 for a non-Unicode 

 build.

 The build independent type should always be used unless an explicit 16 bit 

 or 8 bit build variant is required.

 @see TLex16

 @see TLex8

 */

 typedef TLex16 TLex;

 /**

 @publishedAll

 @released

 Defines the extraction mark used by the TLex classes to indicate the current 

 lexical element being analysed. 

 It maps directly to either a TLexMark16 for a Unicode build or a TLexMark8 

 for a non-Unicode build.

 The build independent type should always be used unless an explicit 16 bit 

 or 8 bit build variant is required.

 */

 typedef TLexMark16 TLexMark;

 #else

 /**

 @publishedAll

 @released

 Provides access to general string-parsing functions suitable for numeric format 

 conversions and syntactical-element parsing.

 It maps directly to either a TLex16 for a Unicode build or a TLex8 for a non-Unicode 

 build.

 The build independent type should always be used unless an explicit 16 bit 

 or 8 bit build variant is required.

 @see TLex16

 @see TLex8

 */

 typedef TLex8 TLex;

 /**

 @publishedAll

 @released

 Defines the extraction mark used by the TLex classes to indicate the current 

 lexical element being analysed. 

 It maps directly to either a TLexMark16 for a Unicode build or a TLexMark8 

 for a non-Unicode build.

 The build independent type should always be used unless an explicit 16 bit 

 or 8 bit build variant is required.

 */

 typedef TLexMark8 TLexMark;

 #endif

 /**

 @publishedAll

 @released

 Packages a Uid type together with a checksum.

 @see TUidType

 */

 class TCheckedUid

 	{

 public:

 	IMPORT_C TCheckedUid();

 	IMPORT_C TCheckedUid(const TUidType& aUidType);

 	IMPORT_C TCheckedUid(const TDesC8& aPtr);

 	IMPORT_C void Set(const TUidType& aUidType);

 	IMPORT_C void Set(const TDesC8& aPtr);

 	IMPORT_C TPtrC8 Des() const;

 	inline const TUidType& UidType() const;

 protected:

 	IMPORT_C TUint Check() const;

 private:

 	TUidType iType;

 	TUint iCheck;

 	};

 /**

 @publishedAll

 @released

 A date and time object in which the individual components are accessible in

 human-readable form.

 The individual components are: year, month, day, hour, minute,

 second and microsecond.

 These components are stored as integers and all except the year are checked for

 validity when a TDateTime is constructed or assigned new values.

 This class only supports getting and setting the entire date/time or any component 

 of it. It does not support adding or subtracting intervals to or from a time. 

 For functions which manipulate times, use class TTime.

 @see TTime

 */

 class TDateTime

 	{

 public:

 	inline TDateTime();

 	IMPORT_C TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);

 	IMPORT_C TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);

 	IMPORT_C TInt SetYear(TInt aYear);

 	IMPORT_C TInt SetYearLeapCheck(TInt aYear);

 	IMPORT_C TInt SetMonth(TMonth aMonth);

 	IMPORT_C TInt SetDay(TInt aDay);

 	IMPORT_C TInt SetHour(TInt aHour);

 	IMPORT_C TInt SetMinute(TInt aMinute);

 	IMPORT_C TInt SetSecond(TInt aSecond);

 	IMPORT_C TInt SetMicroSecond(TInt aMicroSecond);

 	inline TInt Year() const;

 	inline TMonth Month() const;

 	inline TInt Day() const;

 	inline TInt Hour() const;

 	inline TInt Minute() const;

 	inline TInt Second() const;

 	inline TInt MicroSecond() const;

 private:

 	TInt iYear;

 	TMonth iMonth;

 	TInt iDay;

 	TInt iHour;

 	TInt iMinute;

 	TInt iSecond;

 	TInt iMicroSecond;

 	};

 /**

 @publishedAll

 @released

 Represents a time interval of a millionth of a second stored as

 a 64-bit integer. 

 It supports the initialisation, setting and getting of an interval and provides

 standard comparison operations. Objects of this class can be added to and

 subtracted from TTime objects.

 @see TTime

 */

 class TTimeIntervalMicroSeconds

 	{

 public:

 	inline TTimeIntervalMicroSeconds();

 	inline TTimeIntervalMicroSeconds(const TInt64& aInterval);

 	inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);

 	inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;

 	inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;

 	inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;

 	inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;

 	inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;

 	inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;

 	inline const TInt64& Int64() const;

 private:

 	TInt64 iInterval;

 	};

 /**

 @publishedAll

 @released

 Provides a base class for all time interval classes using

 a 32-bit representation. 

 It supports retrieving the interval and provides various operations for

 comparing intervals. Its concrete derived classes can be added to and

 subtracted from a TTime.

 The comparison operators simply compare the integer representations of the 

 two intervals. They do not take account of different time interval units. 

 So, for example, when comparing for equality an interval of three hours with 

 an interval of three days, the result is true.

 @see TTime

 */

 class TTimeIntervalBase

 	{

 public:

 	inline TBool operator==(TTimeIntervalBase aInterval) const;

 	inline TBool operator!=(TTimeIntervalBase aInterval) const;

 	inline TBool operator>=(TTimeIntervalBase aInterval) const;

 	inline TBool operator<=(TTimeIntervalBase aInterval) const;

 	inline TBool operator>(TTimeIntervalBase aInterval) const;

 	inline TBool operator<(TTimeIntervalBase aInterval) const;

 	inline TInt Int() const;

 protected:

 	inline TTimeIntervalBase();

 	inline TTimeIntervalBase(TInt aInterval);

 protected:

 	TInt iInterval;

 	};

 /**

 @publishedAll

 @released

 Represents a microsecond time interval stored in 32 rather than 64 bits.

 Its range is +-2147483647, which is +-35 minutes, 47 seconds. Comparison and 

 interval retrieval functions are provided by the base class TTimeIntervalBase.

 */

 class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase

 	{

 public:

 	inline TTimeIntervalMicroSeconds32();

 	inline TTimeIntervalMicroSeconds32(TInt aInterval);

 	inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);

 	};

 /**

 @publishedAll

 @released

 Represents a time interval in seconds.

 Comparison and interval retrieval functions 

 are provided by the base class TTimeIntervalBase.

 The range of values which it can represent is +-2147483647, which is equal to

 +-24855 days (approximately 68 years).

 */

 class TTimeIntervalSeconds : public TTimeIntervalBase

 	{

 public:

 	inline TTimeIntervalSeconds();

 	inline TTimeIntervalSeconds(TInt aInterval);

 	inline TTimeIntervalSeconds& operator=(TInt aInterval);

 	};

 /**

 @publishedAll

 @released

 Represents a time interval in minutes.

 Comparison and interval retrieval functions 

 are provided by the base class TTimeIntervalBase.

 */

 class TTimeIntervalMinutes : public TTimeIntervalBase

 	{

 public:

 	inline TTimeIntervalMinutes();

 	inline TTimeIntervalMinutes(TInt aInterval);

 	inline TTimeIntervalMinutes& operator=(TInt aInterval);

 	};

 /**

 @publishedAll

 @released

 Represents a time interval in hours.

 Comparison and interval retrieval functions 

 are provided by the base class TTimeIntervalBase.

 */

 class TTimeIntervalHours : public TTimeIntervalBase

 	{

 public:

 	inline TTimeIntervalHours();

 	inline TTimeIntervalHours(TInt aInterval);

 	inline TTimeIntervalHours& operator=(TInt aInterval);

 	};

 /**

 @publishedAll

 @released

 Represents a time interval in days.

 Comparison and interval retrieval functions 

 are provided by the base class TTimeIntervalBase.

 */

 class TTimeIntervalDays : public TTimeIntervalBase

 	{

 public:

 	inline TTimeIntervalDays();

 	inline TTimeIntervalDays(TInt aInterval);

 	inline TTimeIntervalDays& operator=(TInt aInterval);

 	};

 /**

 @publishedAll

 @released

 Represents a time interval in months.

 Comparison and interval retrieval functions 

 are provided by the base class TTimeIntervalBase.

 */

 class TTimeIntervalMonths : public TTimeIntervalBase

 	{

 public:

 	inline TTimeIntervalMonths();

 	inline TTimeIntervalMonths(TInt aInterval);

 	inline TTimeIntervalMonths& operator=(TInt aInterval);

 	};

 /**

 @publishedAll

 @released

 Represents a time interval in years.

 Comparison and interval retrieval functions 

 are provided by the base class TTimeIntervalBase.

 */

 class TTimeIntervalYears : public TTimeIntervalBase

 	{

 public:

 	inline TTimeIntervalYears();

 	inline TTimeIntervalYears(TInt aInterval);

 	inline TTimeIntervalYears& operator=(TInt aInterval);

 	};

 /**

 @publishedAll

 @released

 An enumeration one or both of whose enumerator values may be returned

 by TTime::Parse().

 @see TTime::Parse

 */

 enum {

      /**

      Indicates that a time is present.

      @see TTime::Parse

      */

      EParseTimePresent=0x1,

      /**

      Indicates that a date is present.

      @see TTime::Parse

      */

      EParseDatePresent=0x2

      };

 class TLocale;

 /**

 @publishedAll

 @released

 Stores and manipulates the date and time. 

 It represents a date and time as a number of microseconds since midnight, 

 January 1st, 1 AD nominal Gregorian. BC dates are represented by negative 

 TTime values. A TTime object may be constructed from a TInt64, a TDateTime 

 a string literal, or by default, which initialises the time to an arbitrary 

 value. To access human-readable time information, the TTime may be converted 

 from a TInt64 into a TDateTime, which represents the date and time as seven 

 numeric fields and provides functions to extract these fields. Alternatively, 

 to display the time as text, the time may be formatted and placed into a

 descriptor using a variety of formatting commands and which may or may not

 honour the system's locale settings. The conversion between time and text may

 be performed the other way around, so that a descriptor can be parsed and

 converted into a TTime value.

 In addition to setting and getting the date and time and converting between 

 text and time, TTime provides functions to get intervals between times and 

 standard comparison and arithmetic operators which enable time intervals to 

 be added or subtracted to or from the time.

 @see TInt64

 @see TDateTime

 */

 class TTime

 	{

 public:

 	inline TTime();

 	inline TTime(const TInt64& aTime);

 	IMPORT_C TTime(const TDesC& aString);

 	IMPORT_C TTime(const TDateTime& aDateTime);

 	inline TTime& operator=(const TInt64& aTime);

 	IMPORT_C TTime& operator=(const TDateTime& aDateTime);

 	IMPORT_C void HomeTime();

 	IMPORT_C void UniversalTime();

 	IMPORT_C TInt Set(const TDesC& aString);

 	IMPORT_C TInt HomeTimeSecure();

 	IMPORT_C TInt UniversalTimeSecure();

 	IMPORT_C TDateTime DateTime() const;

 	IMPORT_C TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;

 	IMPORT_C TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;

 	IMPORT_C TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;

 	IMPORT_C TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;

 	IMPORT_C TTimeIntervalDays DaysFrom(TTime aTime) const;

 	IMPORT_C TTimeIntervalMonths MonthsFrom(TTime aTime) const;

 	IMPORT_C TTimeIntervalYears YearsFrom(TTime aTime) const;

 	IMPORT_C TInt DaysInMonth() const;

 	IMPORT_C TDay DayNoInWeek() const;

 	IMPORT_C TInt DayNoInMonth() const;

 	IMPORT_C TInt DayNoInYear() const;

 	IMPORT_C TInt DayNoInYear(TTime aStartDate) const;

 	IMPORT_C TInt WeekNoInYear() const;

 	IMPORT_C TInt WeekNoInYear(TTime aStartDate) const;

 	IMPORT_C TInt WeekNoInYear(TFirstWeekRule aRule) const;

 	IMPORT_C TInt WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const;

 	IMPORT_C void FormatL(TDes& aDes,const TDesC& aFormat) const;

 	IMPORT_C void FormatL(TDes& aDes,const TDesC& aFormat,const TLocale& aLocale) const;

 	IMPORT_C void RoundUpToNextMinute();

 	IMPORT_C TInt Parse(const TDesC& aDes,TInt aCenturyOffset=0);

 	IMPORT_C TTime operator+(TTimeIntervalYears aYear) const;

 	IMPORT_C TTime operator+(TTimeIntervalMonths aMonth) const;

 	IMPORT_C TTime operator+(TTimeIntervalDays aDay) const;

 	IMPORT_C TTime operator+(TTimeIntervalHours aHour) const;

 	IMPORT_C TTime operator+(TTimeIntervalMinutes aMinute) const;

 	IMPORT_C TTime operator+(TTimeIntervalSeconds aSecond) const;  	

 	IMPORT_C TTime operator+(TTimeIntervalMicroSeconds aMicroSecond) const;

 	IMPORT_C TTime operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const;

 	IMPORT_C TTime operator-(TTimeIntervalYears aYear) const;

 	IMPORT_C TTime operator-(TTimeIntervalMonths aMonth) const;

 	IMPORT_C TTime operator-(TTimeIntervalDays aDay) const;

 	IMPORT_C TTime operator-(TTimeIntervalHours aHour) const;

 	IMPORT_C TTime operator-(TTimeIntervalMinutes aMinute) const;

 	IMPORT_C TTime operator-(TTimeIntervalSeconds aSecond) const;  	

 	IMPORT_C TTime operator-(TTimeIntervalMicroSeconds aMicroSecond) const;

 	IMPORT_C TTime operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const;

 	IMPORT_C TTime& operator+=(TTimeIntervalYears aYear);

 	IMPORT_C TTime& operator+=(TTimeIntervalMonths aMonth);

 	IMPORT_C TTime& operator+=(TTimeIntervalDays aDay);

 	IMPORT_C TTime& operator+=(TTimeIntervalHours aHour);

 	IMPORT_C TTime& operator+=(TTimeIntervalMinutes aMinute);

 	IMPORT_C TTime& operator+=(TTimeIntervalSeconds aSecond);	

 	IMPORT_C TTime& operator+=(TTimeIntervalMicroSeconds aMicroSecond);

 	IMPORT_C TTime& operator+=(TTimeIntervalMicroSeconds32 aMicroSecond);

 	IMPORT_C TTime& operator-=(TTimeIntervalYears aYear);

 	IMPORT_C TTime& operator-=(TTimeIntervalMonths aMonth);

 	IMPORT_C TTime& operator-=(TTimeIntervalDays aDay);

 	IMPORT_C TTime& operator-=(TTimeIntervalHours aHour);

 	IMPORT_C TTime& operator-=(TTimeIntervalMinutes aMinute);

 	IMPORT_C TTime& operator-=(TTimeIntervalSeconds aSecond);	

 	IMPORT_C TTime& operator-=(TTimeIntervalMicroSeconds aMicroSecond);

 	IMPORT_C TTime& operator-=(TTimeIntervalMicroSeconds32 aMicroSecond);

 	inline TBool operator==(TTime aTime) const;

 	inline TBool operator!=(TTime aTime) const;

 	inline TBool operator>=(TTime aTime) const;

 	inline TBool operator<=(TTime aTime) const;

 	inline TBool operator>(TTime aTime) const;

 	inline TBool operator<(TTime aTime) const;

 	inline const TInt64& Int64() const;

 private:

 	static TTime Convert(const TDateTime& aDateTime);

 private:

 	TInt64 iTime;

 	__DECLARE_TEST;

 	};

 /**

 @publishedAll

 @released

 A utility class whose functions may be used by the other date/time related 

 classes.

 */

 class Time

 	{

 public:

 	IMPORT_C static TTime NullTTime();

 	IMPORT_C static TTime MaxTTime();

 	IMPORT_C static TTime MinTTime();

 	IMPORT_C static TInt DaysInMonth(TInt aYear, TMonth aMonth);

 	IMPORT_C static TBool IsLeapYear(TInt aYear);

 	IMPORT_C static TInt LeapYearsUpTo(TInt aYear);

 	};

 /**

 @publishedAll

 @released

 Gets a copy of the current locale's full text name for a day of the week.

 After construction or after a call to Set(), the copy of the text can be accessed 

 and manipulated using the standard descriptor member functions provided by 

 the base class.

 @see KMaxDayName

 */

 class TDayName : public TBuf<KMaxDayName>

 	{

 public:

 	IMPORT_C TDayName();

 	IMPORT_C TDayName(TDay aDay);

 	IMPORT_C void Set(TDay aDay);

 	};

 /**

 @publishedAll

 @released

 Gets a copy of the current locale's abbreviated text name for a day of the 

 week.

 After construction or after a call to Set(), the copy of the abbreviated text 

 can be accessed and manipulated using the standard descriptor member functions 

 provided by the base class.

 The abbreviated day name cannot be assumed to be one character. In English, 

 it is 3 characters (Mon, Tue, Wed etc.), but the length can vary from locale 

 to locale, with a maximum length of KMaxDayNameAbb.

 @see KMaxDayNameAbb

 */

 class TDayNameAbb : public TBuf<KMaxDayNameAbb>

 	{

 public:

 	IMPORT_C TDayNameAbb();

 	IMPORT_C TDayNameAbb(TDay aDay);

 	IMPORT_C void Set(TDay aDay);

 	};

 /**

 @publishedAll

 @released

 Gets a copy of the current locale's full text name for a month.

 After construction or after a call to Set(), the copy of the text can be accessed 

 and manipulated using the standard descriptor member functions provided by 

 the base class.

 @see KMaxMonthName

 */

 class TMonthName : public TBuf<KMaxMonthName>

 	{

 public:

 	IMPORT_C TMonthName();

 	IMPORT_C TMonthName(TMonth aMonth);

 	IMPORT_C void Set(TMonth aMonth);

 	};

 /**

 @publishedAll

 @released

 Gets a copy of the current locale's abbreviated text name for a month.

 After construction or after a call to Set(), the copy of the abbreviated text 

 can be accessed and manipulated using the standard descriptor member functions 

 provided by the base class.

 @see KMaxMonthNameAbb

 */

 class TMonthNameAbb : public TBuf<KMaxMonthNameAbb>

 	{

 public:

 	IMPORT_C TMonthNameAbb();

 	IMPORT_C TMonthNameAbb(TMonth aMonth);

 	IMPORT_C void Set(TMonth aMonth);

 	};

 /**

 @publishedAll

 @released

 Gets a copy of the current locale's date suffix text for a specific day in 

 the month.

 The text is the set of characters which can be appended to dates of the month 

 (e.g. in English, st for 1st, nd for 2nd etc).

 After construction or after a call to Set(), the copy of the suffix text can 

 be accessed and manipulated using the standard descriptor member functions 

 provided by the base class.

 */

 class TDateSuffix : public TBuf<KMaxSuffix>

 	{

 public:

 	IMPORT_C TDateSuffix();

 	IMPORT_C TDateSuffix(TInt aDateSuffix);

 	IMPORT_C void Set(TInt aDateSuffix);

 	};

 /**

 @publishedAll

 @released

 Current locale's am/pm text

 This class retrieves a copy of the current locale's text identifying time 

 before and after noon. In English, this is am and pm.

 After construction or after a call to Set(), the copy of the text can be accessed 

 and manipulated using the standard descriptor member functions provided by 

 the base class.

 */

 class TAmPmName : public TBuf<KMaxAmPmName>

 	{

 public:

 	IMPORT_C TAmPmName();

 	IMPORT_C TAmPmName(TAmPm aSelector);

 	IMPORT_C void Set(TAmPm aSelector);

 	};

 /**

 @publishedAll

 @released

 Gets a copy of the currency symbol(s) in use by the current locale.

 After construction or after a call to TCurrencySymbol::Set(), the copy of 

 the currency symbol(s) can be accessed and manipulated using the standard 

 descriptor member functions provided by the base class.

 */

 class TCurrencySymbol : public TBuf<KMaxCurrencySymbol>

 	{

 public:

 	IMPORT_C TCurrencySymbol();

 	IMPORT_C void Set();

 	};

 /**

 @publishedAll

 @released

 Contains a format list that defines the short date format.

 An instance of this class should be passed as the second argument

 to TTime::FormatL().

 The string does not include any time components. The content of the long 

 date format specification is taken from the system-wide settings.

 For example, in the English locale, the short date format would be something

 like 14/1/2000.

 This class is used as follows:

 @code

 TTime now;

 now.HomeTime();

 TBuf<KMaxShortDateFormatSpec*2> buffer;

 now.FormatL(buffer,TShortDateFormatSpec());

 @endcode

 @see KMaxShortDateFormatSpec

 @see TTime::FormatL

 */

 class TShortDateFormatSpec : public TBuf<KMaxShortDateFormatSpec> // to be passed into TTime::FormatL

 	{

 public:

 	IMPORT_C TShortDateFormatSpec();

 	IMPORT_C void Set();

 	};

 /**

 @publishedAll

 @released

 Contains a format list that defines the long date format.

 An instance of this class should be passed as the second argument

 to TTime::FormatL(). 

 The string does not include any time components. The content of the long 

 date format specification is taken from the system-wide settings.

 For example, in the English locale, the long date format would be

 something like 14th January 2000.

 This class is used as follows:

 @code

 TTime now;

 now.HomeTime();

 TBuf<KMaxLongDateFormatSpec*2> buffer;

 now.FormatL(buffer,TLongDateFormatSpec());

 @endcode

 @see KMaxLongDateFormatSpec

 @see TTime::FormatL

 */

 class TLongDateFormatSpec : public TBuf<KMaxLongDateFormatSpec> // to be passed into TTime::FormatL

 	{

 public:

 	IMPORT_C TLongDateFormatSpec();

 	IMPORT_C void Set();

 	};

 /**

 @publishedAll

 @released

 Contains a format list that defines the time string format. 

 An instance of this class should be passed as the second argument

 to TTime::FormatL().

 The string does not include any time components. The content of the time format 

 specification is taken from the system-wide settings.

 This class is used as follows:

 @code

 TTime now;

 now.HomeTime();

 TBuf<KMaxTimeFormatSpec*2> buffer;

 now.FormatL(buffer,TTimeFormatSpec());

 @endcode

 @see KMaxTimeFormatSpec

 @see TTime::FormatL

 */

 class TTimeFormatSpec : public TBuf<KMaxTimeFormatSpec> // to be passed into TTime::FormatL

 	{

 public:

 	IMPORT_C TTimeFormatSpec();

 	IMPORT_C void Set();

 	};

 /**

 @publishedAll

 @released

 Sets and gets the system's locale settings.

 Symbian OS maintains the locale information internally. On

 construction, this object is initialized with the system information

 for all locale items.

 */

 class TLocale

 	{

 public:

     /**

     Indicates how negative currency values are formatted.

     */

 	enum TNegativeCurrencyFormat

 		{

 	    /**

 	    A minus sign is inserted before the currency symbol and value.

 	    */

 		ELeadingMinusSign,

 		/**

 		The currency value and symbol are enclosed in brackets (no minus sign

 		is used).

 		*/

 		EInBrackets, //this one must be non-zero for binary compatibility with the old TBool TLocale::iCurrencyNegativeInBrackets which was exposed in the binary interface because it was accessed via *inline* functions

 	    /**

 	    A minus sign is inserted after the currency symbol and value.

         */

 		ETrailingMinusSign,

         /**

         A minus sign is inserted between the currency symbol and the value.

         */

 		EInterveningMinusSign

 		};

 	/**

 	Flags for negative currency values formatting

 	*/

 	enum 

 		{

 		/** 

 		If this flag is set and the currency value being formatted is negative,

 		if there is a space between the currency symbol and the value,

 		that space is lost. 

 		*/

 		EFlagNegativeLoseSpace = 0x00000001,

 		/**   

 		If this flag is set and the currency value being formatted is negative,

 		the position of the currency symbol is placed in the opposite direction 

 		from the position set for the positive currency value. 

 		*/

 		EFlagNegativeCurrencySymbolOpposite=0x00000002

 		};

 	/** Indicates how the device universal time is maintained */

 	enum TDeviceTimeState

 		{

 		/** Universal time is maintained by the device RTC and the user selection 

 		of the locale of the device indicating offset from GMT and daylight saving*/

 		EDeviceUserTime,

 		/** Universal time and offset from GMT is supplied by the mobile network

 		and maintained by device RTC */

 		ENITZNetworkTimeSync

 		};

 public:

 	IMPORT_C TLocale();

 	inline TLocale(TInt);

 	IMPORT_C void Refresh();

 	IMPORT_C TInt Set() const;

 	IMPORT_C void FormatCurrency(TDes& aText, TInt aAmount);

 	IMPORT_C void FormatCurrency(TDes& aText, TInt64 aAmount);

 	IMPORT_C void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt aAmount); 

 	IMPORT_C void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt64 aAmount); 

 	inline TInt CountryCode() const;

 	inline void SetCountryCode(TInt aCode);

 	inline TTimeIntervalSeconds UniversalTimeOffset() const;

 	inline TDateFormat DateFormat() const;

 	inline void SetDateFormat(TDateFormat aFormat);

 	inline TTimeFormat TimeFormat() const;

 	inline void SetTimeFormat(TTimeFormat aFormat);

 	inline TLocalePos CurrencySymbolPosition() const;

 	inline void SetCurrencySymbolPosition(TLocalePos aPos);

 	inline TBool CurrencySpaceBetween() const;

 	inline void SetCurrencySpaceBetween(TBool aSpace);

 	inline TInt CurrencyDecimalPlaces() const;

 	inline void SetCurrencyDecimalPlaces(TInt aPlaces);

 	inline TBool CurrencyNegativeInBrackets() const;        // These two functions are deprecated

 	inline void SetCurrencyNegativeInBrackets(TBool aBool); // They are here to maintain compatibility. Use the New functions -> NegativeCurrencyFormat setter/getter. 

  	inline TBool CurrencyTriadsAllowed() const;  

 	inline void SetCurrencyTriadsAllowed(TBool aBool);

 	inline TChar ThousandsSeparator() const;

 	inline void SetThousandsSeparator(const TChar& aChar);

 	inline TChar DecimalSeparator() const;

 	inline void SetDecimalSeparator(const TChar& aChar);

 	inline TChar DateSeparator(TInt aIndex) const;

 	inline void SetDateSeparator(const TChar& aChar,TInt aIndex);

 	inline TChar TimeSeparator(TInt aIndex) const;

 	inline void SetTimeSeparator(const TChar& aChar,TInt aIndex);

 	inline TBool AmPmSpaceBetween() const;

 	inline void SetAmPmSpaceBetween(TBool aSpace);

 	inline TLocalePos AmPmSymbolPosition() const;

 	inline void SetAmPmSymbolPosition(TLocalePos aPos);

 	inline TUint DaylightSaving() const;

 	inline TBool QueryHomeHasDaylightSavingOn() const;

 	inline TDaylightSavingZone HomeDaylightSavingZone() const;

 	inline TUint WorkDays() const;

 	inline void SetWorkDays(TUint aMask);

 	inline TDay StartOfWeek() const;

 	inline void SetStartOfWeek(TDay aDay);

 	inline TClockFormat ClockFormat() const;

 	inline void SetClockFormat(TClockFormat aFormat);

 	inline TUnitsFormat UnitsGeneral() const;

 	inline void SetUnitsGeneral(TUnitsFormat aFormat);

 	inline TUnitsFormat UnitsDistanceShort() const;

 	inline void SetUnitsDistanceShort(TUnitsFormat aFormat);

 	inline TUnitsFormat UnitsDistanceLong() const;

 	inline void SetUnitsDistanceLong(TUnitsFormat aFormat);

 	inline TNegativeCurrencyFormat NegativeCurrencyFormat() const;

 	inline void SetNegativeCurrencyFormat(TNegativeCurrencyFormat aNegativeCurrencyFormat);

 	inline TBool NegativeLoseSpace() const;

 	inline void SetNegativeLoseSpace(TBool aBool);

 	inline TBool NegativeCurrencySymbolOpposite() const;

 	inline void SetNegativeCurrencySymbolOpposite(TBool aBool);

 	inline TLanguage LanguageDowngrade(TInt aIndex) const;	 // 0 <= aIndex < 3

 	inline void SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage);

 	inline TDigitType DigitType() const;

 	inline void SetDigitType(TDigitType aDigitType);

 	inline TDeviceTimeState DeviceTime() const;

  	inline void SetDeviceTime(TDeviceTimeState aState);

  	inline TInt RegionCode() const;

 	void SetDefaults(); /**< @internalComponent */

 private:

 	friend class TExtendedLocale;

 private:

 	TInt iCountryCode;

 	TTimeIntervalSeconds iUniversalTimeOffset;

 	TDateFormat iDateFormat;

 	TTimeFormat iTimeFormat;

 	TLocalePos iCurrencySymbolPosition;

 	TBool iCurrencySpaceBetween;

 	TInt iCurrencyDecimalPlaces;

 	TNegativeCurrencyFormat iNegativeCurrencyFormat; //	replaced TBool iCurrencyNegativeInBrackets

 	TBool iCurrencyTriadsAllowed;

 	TChar iThousandsSeparator;

 	TChar iDecimalSeparator;

 	TChar iDateSeparator[KMaxDateSeparators];

 	TChar iTimeSeparator[KMaxTimeSeparators];

 	TLocalePos iAmPmSymbolPosition;

 	TBool iAmPmSpaceBetween;

 	TUint iDaylightSaving;

 	TDaylightSavingZone iHomeDaylightSavingZone;

 	TUint iWorkDays;

 	TDay iStartOfWeek;

 	TClockFormat iClockFormat;

 	TUnitsFormat iUnitsGeneral;

 	TUnitsFormat iUnitsDistanceShort;

 	TUnitsFormat iUnitsDistanceLong;

 	TUint iExtraNegativeCurrencyFormatFlags;

 	TUint16 iLanguageDowngrade[3];

 	TUint16 iRegionCode;

 	TDigitType iDigitType;

  	TDeviceTimeState iDeviceTimeState;

  	TInt iSpare[0x1E];

 	};

 /** 

 @publishedAll

 @released

 TLocaleAspect

 Enumeration used with TExtendedLocale::LoadLocaleAspect to select which

 locale information is to be replaced from the contents of the Locale

 DLL being loaded.

 ELocaleLanguageSettings - Replaces everything that should change with

                           language selection e.g. Month names, Day names,

                           etc,

 ELocaleLocaleSettings - Replaces the currently selected currency symbol,

                         TLocale settings, and FAT utility functions

 ELocaleTimeAndDateSettings - Replaces the current time and date display

                              format settings.

 ELocaleCollateSettings - Replaces the "system" preferred Charset

                          (because that's where the collation table

                          is!). The "Default" charset will remain

                          unchanged until after the next power

                          off/on cycle

 */

 enum TLocaleAspect

 	{

 	ELocaleLanguageSettings = 0x01,

 	ELocaleCollateSetting = 0x02,

 	ELocaleLocaleSettings = 0x04,

 	ELocaleTimeDateSettings = 0x08,

 	};

 /**

 @internalComponent

 */

 struct SLocaleLanguage

 	{

 	TLanguage 		iLanguage;

 	const TText*	iDateSuffixTable;

 	const TText*	iDayTable;

 	const TText*	iDayAbbTable;

 	const TText*	iMonthTable;

 	const TText*	iMonthAbbTable;

 	const TText*	iAmPmTable;

 	const TText16* const*	iMsgTable;

 	};

 /**

 @internalComponent

 */

 struct SLocaleLocaleSettings

 	{

 	TText	iCurrencySymbol[KMaxCurrencySymbol+1];

 	TAny*	iLocaleExtraSettingsDllPtr;

 	};

 /**

 @internalComponent

 */

 struct SLocaleTimeDateFormat

 	{

 	TText	iShortDateFormatSpec[KMaxShortDateFormatSpec+1];

 	TText	iLongDateFormatSpec[KMaxLongDateFormatSpec+1];

 	TText	iTimeFormatSpec[KMaxTimeFormatSpec+1];

 	TAny*	iLocaleTimeDateFormatDllPtr;

 	};

 struct LCharSet;

 /**

 @publishedAll

 @released

 Extended locale class

 This class holds a collection of locale information. It contains a TLocale internally.

 It has methods to load a locale DLL and to set the system wide locale information.

 */

 class TExtendedLocale

 	{

 public:

 	// Default constructor, create an empty instance

 	IMPORT_C TExtendedLocale();

 	// Initialise to (or restore from!) current system wide locale

 	// settings

 	IMPORT_C void LoadSystemSettings();

 	// Overwrite current system wide locale settings with the current

 	// contents of this TExtendedLocale

 	IMPORT_C TInt SaveSystemSettings();

 	//load a complete locale data from a single locale dll

 	IMPORT_C TInt LoadLocale(const TDesC& aLocaleDllName);

 	//load a complete locale data from three locale dlls, which are language lcoale dll, region locale dll, and collation locale dll.

 	IMPORT_C TInt LoadLocale(const TDesC& aLanguageLocaleDllName, const TDesC& aRegionLocaleDllName, const TDesC& aCollationLocaleDllName);	

 	// Load an additional Locale DLL and over-ride a selected subset

 	// (currently ELocaleLanguageSettings to select an alternative set

 	// of language specific text strings, ELocaleCollateSetting to

 	// select a new system collation table,

 	// ELocaleOverRideMatchCollationTable to locally select an

 	// alternative collation order for matching text strings, or

 	// ELocaleOverRideSortCollationTable for ordering text strings)

 	// of settings with its contents

 	IMPORT_C TInt LoadLocaleAspect(TUint aAspectGroup, const TDesC& aLocaleDllName);

 	//load a locale aspect from a locale dll. 

 	//Such as load language locale aspect from locale language dll; 

 	//load region locale aspect from locale region dll; 

 	//load collation locale aspect from locale collation dll. 

 	//There are in all three aspect, which are langauge, region, and collation.

 	IMPORT_C TInt LoadLocaleAspect(const TDesC& aLocaleDllName);

 	// Set the currency Symbol

 	IMPORT_C TInt SetCurrencySymbol(const TDesC &aSymbol);

 	// Get the name of the DLL holding the data for a particular set

 	// of Locale properties

 	IMPORT_C TInt GetLocaleDllName(TLocaleAspect aLocaleDataSet, TDes& aDllName);

 	// Get the preferred collation method.

 	// Note that some Charsets may contain more than one Collation

 	// method (e.g "dictionary" v "phonebook" ordering) so an optional

 	// index parameter can be used to select between them

 	IMPORT_C TCollationMethod GetPreferredCollationMethod(TInt index = 0) ;

 	//Get the Currency Symbol

 	IMPORT_C TPtrC GetCurrencySymbol();

 	//Get the Long Date Format

 	IMPORT_C TPtrC GetLongDateFormatSpec();

 	//Get the Short Date Format

 	IMPORT_C TPtrC GetShortDateFormatSpec();

 	//Get the Time Format

 	IMPORT_C TPtrC GetTimeFormatSpec();

 	// Retrieve a reference to the encapsulated TLocale

 	inline TLocale*	GetLocale();

 private:

 	TInt DoLoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList);

 	void DoUpdateLanguageSettings(TLibraryFunction* aExportList);

 	void DoUpdateLocaleSettings(TLibraryFunction* aExportList);

 	void DoUpdateTimeDateFormat(TLibraryFunction* aExportList);

 #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL	

 	void DoUpdateLanguageSettingsV2(TLibraryFunction* aExportList);

 	void DoUpdateLocaleSettingsV2(TLibraryFunction* aExportList);		

 	TInt CheckLocaleDllName(const TDesC& aLocaleDllName, TInt& languageID);

 	void AddExtension(TDes& aFileName, TInt aExtension);	

 #endif

 private:

 	TLocale					iLocale;

 	SLocaleLanguage			iLanguageSettings;

 	SLocaleLocaleSettings	iLocaleExtraSettings;

 	SLocaleTimeDateFormat	iLocaleTimeDateFormat;

 	const LCharSet*			iDefaultCharSet;

 	const LCharSet*			iPreferredCharSet;

 	};

 /**

 @publishedAll

 @released

 Geometric rectangle.

 The class represents a rectangle whose sides are parallel with the axes of 

 the co-ordinate system. 

 The co-ordinates of the top-left and bottom-right corners are used to set 

 the dimensions of the rectangle. The bottom right co-ordinate is outside the 

 rectangle. Thus TRect(TPoint(2,2),TSize(4,4)) is equal

 to TRect(TPoint(2,2),TPoint(6,6)), 

 and in both cases you get a 4x4 pixel rectangle on the screen.

 Functions are provided to initialise and manipulate the rectangle and to extract 

 information about it.

 */

 class TRect

 	{

 public:

 	enum TUninitialized { EUninitialized };

 	/**

 	Constructs a default rectangle.

 	This initialises the co-ordinates of its top 

 	left and bottom right corners to (0,0).

 	*/

 	TRect(TUninitialized) {}

 	IMPORT_C TRect();

 	IMPORT_C TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);

 	IMPORT_C TRect(const TPoint& aPointA,const TPoint& aPointB);

 	IMPORT_C TRect(const TPoint& aPoint,const TSize& aSize);

 	IMPORT_C TRect(const TSize& aSize);

 	IMPORT_C TBool operator==(const TRect& aRect) const;

 	IMPORT_C TBool operator!=(const TRect& aRect) const;

 	IMPORT_C void SetRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);

 	IMPORT_C void SetRect(const TPoint& aPointTL,const TPoint& aPointBR);

 	IMPORT_C void SetRect(const TPoint& aPoint,const TSize& aSize);

 	IMPORT_C void Move(TInt aDx,TInt aDy);

 	IMPORT_C void Move(const TPoint& aOffset);

 	IMPORT_C void Resize(TInt aDx,TInt aDy);

 	IMPORT_C void Resize(const TSize& aSize);

 	IMPORT_C void Shrink(TInt aDx,TInt aDy);

 	IMPORT_C void Shrink(const TSize& aSize);

 	IMPORT_C void Grow(TInt aDx,TInt aDy);

 	IMPORT_C void Grow(const TSize& aSize);

 	IMPORT_C void BoundingRect(const TRect& aRect);

 	IMPORT_C TBool IsEmpty() const;

 	IMPORT_C TBool Intersects(const TRect& aRect) const;

 	IMPORT_C void Intersection(const TRect& aRect);

 	IMPORT_C void Normalize();

 	IMPORT_C TBool Contains(const TPoint& aPoint) const;

 	IMPORT_C TSize Size() const;

 	IMPORT_C TInt Width() const;

 	IMPORT_C TInt Height() const;

 	IMPORT_C TBool IsNormalized() const;

 	IMPORT_C TPoint Center() const;

 	IMPORT_C void SetSize(const TSize& aSize);

 	IMPORT_C void SetWidth(TInt aWidth);

 	IMPORT_C void SetHeight(TInt aHeight);

 private:

 	void Adjust(TInt aDx,TInt aDy);

 public:

 	/**

 	The x and y co-ordinates of the top left hand corner of the rectangle.

 	*/

 	TPoint iTl;

 	/**

 	The x and y co-ordinates of the bottom right hand corner of the rectangle.

 	*/

 	TPoint iBr;

 	};

 /**

 @publishedAll

 @released

 Clipping region - abstract base class. 

 This abstract base class represents a 2-dimensional area which is used by 

 Graphics, the graphics window server, and the text window server to define 

 regions of the display which need to be updated, or regions within which all 

 operations must occur. 

 A TRegion is defined in terms of an array of TRects and the more complex the 

 region, the more TRects are required to represent it.

 A clipping region initially has space allocated for five rectangles.

 If manipulations result in a region which requires more than this, an attempt

 is made to allocate more rectangles. If this cannot be done, an error flag

 is set, and all subsequent operations involving the region have no effect

 (except possibly to propagate the error flag to other regions).

 The CheckError() member function allows 

 the error flag to be tested; Clear() can be used to clear it.

 The redraw logic of application programs may use the TRegion in various ways:

 1. minimally, they pass it to the graphics context as the clipping region; when 

    a graphics context is activated to a window, the clipping region is set up 

    automatically

 2. if they wish to avoid redrawing objects which are outside the general area 

    of the region, they may use TRegion::BoundingRect() to return the rectangle 

    which bounds the clipping region, and draw only primitives that lie within 

    that rectangle

 3. if they wish to exercise finer control, they may extract the individual rectangles 

    that comprise the clipping region using Operator[]().

 Application programs may also manipulate clipping regions in order to constrain 

 parts of their redrawing to narrower areas of the screen than the clipping 

 region offered by the window server. To do this, functions that allow clipping 

 region manipulation may be used; for example, adding or removing rectangles 

 or finding the intersection or union of two regions.

 */

 class TRegion

 	{

 public:

 	inline TInt Count() const;

 	inline const TRect* RectangleList() const;

 	inline TBool CheckError() const;

 	IMPORT_C TBool IsEmpty() const;

 	IMPORT_C TRect BoundingRect() const;

 	IMPORT_C const TRect& operator[](TInt aIndex) const;

 	IMPORT_C void Copy(const TRegion& aRegion);

 	IMPORT_C void AddRect(const TRect& aRect);

 	IMPORT_C void SubRect(const TRect& aRect,TRegion* aSubtractedRegion=NULL);

 	IMPORT_C void Offset(TInt aXoffset,TInt aYoffset);

 	IMPORT_C void Offset(const TPoint& aOffset);

 	IMPORT_C void Union(const TRegion& aRegion);

 	IMPORT_C void Intersection(const TRegion& aRegion,const TRegion& aRegion2);

 	IMPORT_C void Intersect(const TRegion& aRegion);

 	IMPORT_C void SubRegion(const TRegion& aRegion,TRegion* aSubtractedRegion=NULL);

 	IMPORT_C void ClipRect(const TRect& aRect);

 	IMPORT_C void Clear();

 	IMPORT_C void Tidy();

 	IMPORT_C TInt Sort();

 	IMPORT_C TInt Sort(const TPoint& aOffset);

 	IMPORT_C void ForceError();