// 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.inl

 // 

 //

 // Global leaving operator new

 inline TAny* operator new(TUint aSize, TLeave)

 	{return User::AllocL(aSize);}

 inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize)

 	{return User::AllocL(aSize + aExtraSize);}

 #if !defined(__VC32__) || defined (__MSVCDOTNET__)

 inline TAny* operator new[](TUint aSize, TLeave)

 	{return User::AllocL(aSize);}

 #endif

 // class Mem

 inline TUint8* Mem::Copy(TAny* aTrg, const TAny* aSrc, TInt aLength)

 /**

 Copies data from a source location to a target location and returns a pointer 

 to the end of the copied data.

 The source and target areas can overlap.

 The copy operation is optimised so that if both source and target locations 

 are aligned on a word boundary, the operation performs the copy on a word 

 by word basis.

 @param aTrg    A pointer to the target location for the copy operation. 

 @param aSrc    A pointer to the source location for the copy operation. 

 @param aLength The number of bytes to be copied. This value must not

                be negative. 

 @return A pointer to a location aLength bytes beyond aTrg (i.e. the location 

         aTrg+aLength).

 @panic USER 90 In debug builds only, if aLength is negative. 

 */

 	{ return (TUint8*)memmove(aTrg, aSrc, aLength) + aLength; }

 inline TUint8* Mem::Move(TAny* aTrg, const TAny* aSrc, TInt aLength)

 /**

 Moves a block of data from a source location to a target location and returns 

 a pointer to the end of the moved data.

 The source and target areas can overlap.

 Both source and target locations must be aligned on a word boundary. 

 The specified length must also be a multiple of 4.

 @param aTrg    A pointer to the target location for the move operation. This 

                pointer must be word aligned. 

 @param aSrc    A pointer to the source location for the move operation. This

                pointer must be word aligned.

 @param aLength The number of bytes to be copied. This value must be a multiple 

                of 4.

 @return A pointer to a location aLength bytes beyond aTrg (i.e. the location 

         aTrg+aLength).

 @panic USER 93 In debug builds only, if aTrg is not word aligned.

 @panic USER 92 In debug builds only, if aSrc is not word aligned.

 @panic USER 91 In debug builds only, if aLength is not a multiple of 4.

 */

 	{ return (TUint8*)wordmove(aTrg, aSrc, aLength) + aLength; }

 inline void Mem::Fill(TAny* aTrg, TInt aLength, TChar aChar)

 /**

 Fills a specified block of data with a specified character, replacing

 any existing content.

 The function assumes that the fill character is a non-Unicode character.

 @param aTrg    A pointer to the location where filling is to start. 

 @param aLength The number of bytes to be filled. This value must not

                be negative. 

 @param aChar   The fill character.

 @panic USER 95 In debug builds only, if aLength is negative.  

 */

 	{ memset(aTrg, (TInt)(aChar.operator TUint()), aLength); }

 inline void Mem::FillZ(TAny* aTrg,TInt aLength)

 /**

 Fills a specified block of data with binary zeroes (i.e. 0x00), replacing any 

 existing content.

 @param aTrg    A pointer to the location where filling is to start. 

 @param aLength The number of bytes to be filled. This value must not

                be negative. 

 @panic USER 95 In debug builds only, if aLength is negative.  

 */

 	{ memclr(aTrg, aLength); }

 #if !(defined(__GCC32__) && defined(__MARM__))

 inline TInt Mem::Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL)

 /**

 Compares a block of data at one specified location with a block of data at 

 another specified location.

 The comparison proceeds on a byte for byte basis, the result of the comparison 

 is based on the difference of the first bytes to disagree.

 The data at the two locations are equal if they have the same length and content. 

 Where the lengths are different and the shorter section of data is the same 

 as the first part of the longer section of data, the shorter is considered 

 to be less than the longer.

 @param aLeft   A pointer to the first (or left) block of 8 bit data

                to be compared.

 @param aLeftL  The length of the first (or left) block of data to be compared,  

                i.e. the number of bytes.

 @param aRight  A pointer to the second (or right) block of 8 bit data to be 

                compared.

 @param aRightL The length of the second (or right) block of data to be compared 

                i.e. the number of bytes.

 @return Positive, if the first (or left) block of data is greater than the 

         second (or right) block of data.

         Negative, if the first (or left) block of data is less than the

         second (or right) block of data.

         Zero, if both the first (or left) and second (or right) blocks of data

         have the same length and the same content.

 */

 	{ return memcompare(aLeft, aLeftL, aRight, aRightL); }

 #endif

 // class RHeap

 inline TInt RHeap::SetBrk(TInt aBrk)

 	{ return ((RChunk*)&iChunkHandle)->Adjust(aBrk); }

 // class TChar

 #ifndef __KERNEL_MODE__

 inline void TChar::SetChar(TUint aChar)

 	{iChar=aChar;}

 inline void TChar::Fold()

 /**

 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.

 This function can be used when searching for a string in a text file or a 

 file in a directory. Folding performs the following conversions: converts 

 to lowercase, strips accents, converts all digits representing the values 

 0..9 to the ordinary digit characters '0'..'9', converts all spaces (standard, 

 non-break, fixed-width, ideographic, etc.) to the ordinary space character 

 (0x0020), converts Japanese characters in the hiragana syllabary to katakana, 

 and converts East Asian halfwidth and fullwidth variants to their ordinary 

 forms. You can choose to perform any subset of these operations by using the 

 other function overload.

 @see User::Fold

 */

 	{iChar=User::Fold(iChar);}

 inline void TChar::LowerCase()

 /**

 Converts the character to its lowercase form.

 Characters lacking a lowercase form are unchanged.

 @see User::LowerCase

 */

 	{iChar=User::LowerCase(iChar);}

 inline void TChar::UpperCase()

 /**

 Converts the character to its uppercase form.

 Characters lacking an uppercase form are unchanged.

 @see User::UpperCase

 */

 	{iChar=User::UpperCase(iChar);}

 #ifdef _UNICODE

 inline void TChar::Fold(TInt aFlags)

 /**

 Converts the character to a form which can be used in tolerant comparisons 

 allowing selection of the specific fold operations to be performed.

 @param aFlags Flags which define the operations to be performed. The values 

               are defined in the enum beginning with EFoldCase.

 @see TChar::EFoldCase

 @see User::Fold

 */

 	{iChar=User::Fold(iChar,aFlags);}

 inline void TChar::TitleCase()

 /**

 Converts the character to its titlecase form.

 The titlecase form of a character is identical to its uppercase form unless 

 a specific titlecase form exists. Characters lacking a titlecase form are 

 unchanged.

 */

 	{iChar=User::TitleCase(iChar);}

 #endif

 inline TBool TChar::Eos() const

 /**

 Tests whether the character is the C/C++ end-of-string character - 0.

 @return True, if the character is 0; false, otherwise.

 */

 	{return(iChar==0);}

 #endif // _UNICODE

 // Class TCallBack

 inline TCallBack::TCallBack()

 /**

 Default constructor.

 Sets the function pointer to Null.

 */

 	{iFunction=NULL;}

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

 	: iFunction(aFunction),iPtr(NULL)

 /**

 Constructs the callback object with the specified callback function.

 @param aFunction A pointer to the callback function. It takes an argument of

                  type TAny* and returns a TInt.

 				 It must be either a static member of a class or a function

 				 which is not a member of any class. 

 */

 	{}

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

 	: iFunction(aFunction),iPtr(aPtr)

 /**

 Constructs the callback object with the specified callback function and

 a pointer to any object.

 @param aFunction A pointer to the callback function. It takes an argument of

                  type TAny* and returns a TInt.

 				 It must be either a static member of a class or a function

 				 which is not a member of any class. 

 @param aPtr      A pointer which is always passed to the callback function.

 */

 	{}

 /**

 Calls the callback function.

 @return The value returned by the callback function. The meaning of this value

         depends entirely on the context in which the callback function

         is called.

         For example, when used with the CIdle class, a false (zero) value

         indicates that the callback function should not be 	called again.

         As another example, when used with the CPeriodic class, the return

         value is ignored and is irrelevant in that context.

 @see CIdle

 @see CPeriodic        

 */

 inline TInt TCallBack::CallBack() const

 	{ return (iFunction ? (*iFunction)(iPtr) : 0); }

 // Class TSglQue

 template <class T>

 inline TSglQue<T>::TSglQue()

 /**

 Constructs an empty list header and sets the offset value of the link object 

 to zero.

 In practice, never assume that the offset of the link object from the start 

 of a list element is zero, even if the link object is declared as the first 

 data member in the list element class.

 If this default constructor is used, then call the SetOffset() function of 

 the base class to ensure that the offset value is set correctly.

 @see TSglQueBase::SetOffset

 */

 	{}

 template <class T>

 inline TSglQue<T>::TSglQue(TInt aOffset)

 	: TSglQueBase(aOffset)

 /**

 Constructs an empty list header and sets the offset of the link object to the 

 specified value.

 @param aOffset The offset of the link object from the start of a list element. 

                 The macro _FOFF can be used to calculate this value.

 @panic USER 75, if aOffset is not divisible by four.

 @see _FOFF

 */

 	{}

 template <class T>

 inline void TSglQue<T>::AddFirst(T &aRef)

 /**

 Inserts the specified list element at the front of the singly linked list.

 If the list is not empty, the specified element becomes the first in the list. 

 What was previously the first element becomes the second in the list.

 @param aRef The list element to be inserted at the front of the singly linked 

             list.

 */

 	{DoAddFirst(&aRef);}

 template <class T>

 inline void TSglQue<T>::AddLast(T &aRef)

 /**

 Inserts the specified list element at the back of the singly linked list.

 If the list is not empty, the specified element becomes the last in the list. 

 What was previously the last element becomes the next to last element in the 

 list.

 @param aRef The list element to be inserted at the back of the singly linked 

             list.

 */

 	{DoAddLast(&aRef);}

 template <class T>

 inline TBool TSglQue<T>::IsFirst(const T *aPtr) const

 /**

 Tests whether the specified element is the first in the singly linked list.

 @param aPtr A pointer to the element whose position in the list is to be

             checked.

 @return True, if the element is the first in the list; false, otherwise.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead);}

 template <class T>

 inline TBool TSglQue<T>::IsLast(const T *aPtr) const

 /**

 Tests whether the specified element is the last in the singly linked list.

 @param aPtr A pointer to the element whose position in the list is 

             to be checked.

 @return True, if the element is the last in the list; false, otherwise.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)iLast);}

 template <class T>

 inline T *TSglQue<T>::First() const

 /**

 Gets a pointer to the first list element in the singly linked list.

 @return A pointer to the first list element in the singly linked list. If 

         the list is empty, this pointer is not necessarily NULL and must not

 		be assumed to point to a valid object.

 */

 	{return(PtrSub((T *)iHead,iOffset));}

 template <class T>

 inline T *TSglQue<T>::Last() const

 /**

 Gets a pointer to the last list element in the singly linked list.

 @return A pointer to the last list element in the singly linked list. If the 

         list is empty, this pointer is not necessarily NULL and must not be

 		assumed to point to a valid object.

 */

 	{return(PtrSub((T *)iLast,iOffset));}

 template <class T>

 inline void TSglQue<T>::Remove(T &aRef)

 /**

 Removes the specified element from the singly linked list.

 The singly linked list must not be empty.

 @param aRef A list element to be removed from the singly linked list.

 @panic USER 76, if the element to be removed is not in the list

 */

 	{DoRemove(&aRef);}

 // Class TDblQue

 template <class T>

 inline TDblQue<T>::TDblQue()

 /**

 Constructs an empty list header and sets the offset value of the link object 

 to zero.

 In practice, never assume that the offset of the link object from the start 

 of a list element is zero, even if the link object is declared as the first 

 data member in the list element class.

 If this default constructor is used, then call the SetOffset() function of 

 the base class to ensure that the offset value is set correctly.

 @see TDblQueBase::SetOffset()

 */

 	{}

 template <class T>

 inline TDblQue<T>::TDblQue(TInt aOffset)

 	: TDblQueBase(aOffset)

 /**

 Constructs an empty list header and sets the offset of the link object to the 

 specified value.

 @param aOffset The offset of the link object from the start of a list element. 

                 The macro _FOFF can be used to calculate this value.

 @panic USER 78. if aOffset is not divisble by 4.

 @see _FOFF

 */

 	{}

 template <class T>

 inline void TDblQue<T>::AddFirst(T &aRef)

 /**

 Inserts the specified list element at the front of the doubly linked list.

 If the list is not empty, the specified element becomes the first in the list. 

 What was previously the first element becomes the second in the list.

 @param aRef The list element to be inserted at the front of the doubly linked 

             list.

 */

 	{DoAddFirst(&aRef);}

 template <class T>

 inline void TDblQue<T>::AddLast(T &aRef)

 /**

 Inserts the specified list element at the back of the doubly linked list.

 If the list is not empty, the specified element becomes the last in the list. 

 What was previously the last element becomes the next to last element in the 

 list.

 @param aRef The list element to be inserted at the back of the doubly linked 

             list.

 */

 	{DoAddLast(&aRef);}

 template <class T>

 inline TBool TDblQue<T>::IsHead(const T *aPtr) const

 /**

 Tests whether the end of a list has been reached.

 A doubly linked list is circular; in following the chain of elements in a 

 list (e.g. using the iterator operator++ or operator--), the chain eventually 

 reaches the end of the list and aPtr corresponds to the header (although it 

 will not point to a valid T object).

 @param aPtr The pointer value to be checked. 

 @return True, if the end of the list has been reached. False, if the end of 

         the list has not been reached; aPtr points to an element in the list.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}

 template <class T>

 inline TBool TDblQue<T>::IsFirst(const T *aPtr) const

 /**

 Tests whether the specified element is the first in the doubly linked list.

 @param aPtr A pointer to the element whose position in the list is to be checked.

 @return True, if the element is the first in the list; false, otherwise.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}

 template <class T>

 inline TBool TDblQue<T>::IsLast(const T *aPtr) const

 /**

 Tests whether the specified element is the last in the doubly linked list.

 @param aPtr A pointer to the element whose position in the list is to be checked.

 @return True, if the element is the last in the list; false, otherwise.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}

 template <class T>

 inline T *TDblQue<T>::First() const

 /**

 Gets a pointer to the first list element in the doubly linked list.

 @return A pointer to the first list element in the doubly linked list. If 

         the list is empty, this pointer is not necessarily NULL and must not

 		be assumed to point to a valid object.

 */

 	{

 #if defined (_DEBUG)

 	__DbgTestEmpty();

 #endif

     return(PtrSub((T *)iHead.iNext,iOffset));

     }

 template <class T>

 inline T *TDblQue<T>::Last() const

 /**

 Gets a pointer to the last list element in the doubly linked list.

 @return A pointer to the last list element in the doubly linked list. If the 

         list is empty, this pointer is not necessarily NULL and must not be assumed 

         to point to a valid object.

 */

 	{

 #if defined (_DEBUG)

 	__DbgTestEmpty();

 #endif

 	return(PtrSub((T *)iHead.iPrev,iOffset));

 	}

 // Class TPriQue

 template <class T>

 inline TPriQue<T>::TPriQue()

 /**

 Default constructor.

 Constructs an empty list header and sets the offset value of the link

 object to zero.

 In practice, never assume that the offset of the link object from the start

 of a list element is zero, even if the link object is declared as the first

 data member in the list element class.

 If this default constructor is used, then call the SetOffset() function of

 the base class to ensure that the offset value is set correctly.

 @see TDblQueBase::SetOffset

 */

 	{}

 template <class T>

 inline TPriQue<T>::TPriQue(TInt aOffset)

 	: TDblQueBase(aOffset)

 /**

 Constructs an empty list header and sets the offset of the link object

 to the specified value.

 @param aOffset The offset of the link object from the start of a list element.

                 The macro _FOFF can be used to calculate this value.

 @panic USER 78 if aOffset is not divisible by four.		  

 */

 	{}

 template <class T>

 inline void TPriQue<T>::Add(T &aRef)

 /**

 Inserts the specified list element in descending priority order.

 If there is an existing list element with the same priority, then the new

 element is added after the existing element.

 @param aRef The list element to be inserted.

 */

 	{DoAddPriority(&aRef);}

 template <class T>

 inline TBool TPriQue<T>::IsHead(const T *aPtr) const

 /**

 Tests whether the end of a list has been reached.

 A doubly linked list is circular; in following the chain of elements in a list

 (e.g. using the iterator operator++ or operator--), the chain eventually

 reaches the end of the list and aPtr corresponds to the header (although it

 will not point to a valid T object).

 @param aPtr The pointer value to be checked.

 @return True, if the end of the list has been reached. False, if the end of the

         list has not been reached; aPtr points to an element in the list.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}

 template <class T>

 inline TBool TPriQue<T>::IsFirst(const T *aPtr) const

 /**

 Tests whether the specified element is the first in the linked list.

 @param aPtr A pointer to the element whose position in the list is to

             be checked.

 @return True, if the element is the first in the list; false, otherwise.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}

 template <class T>

 inline TBool TPriQue<T>::IsLast(const T *aPtr) const

 /**

 Tests whether the specified element is the last in the linked list.

 @param aPtr A pointer to the element whose position in the list is to

             be checked.

 @return True, if the element is the last in the list; false, otherwise.

 */

 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}

 template <class T>

 inline T *TPriQue<T>::First() const

 /**

 Gets a pointer to the first list element in the linked list.

 @return A pointer to the first list element in the linked list.

         If the list is empty, this pointer is not necessarily NULL and must

 		not be assumed to point to a valid object.

 */

 	{return(PtrSub((T *)iHead.iNext,iOffset));}

 template <class T>

 inline T *TPriQue<T>::Last() const

 /**

 Gets a pointer to the last list element in the linked list.

 @return A pointer to the last list element in the linked list.

         If the list is empty, this pointer is not necessarily NULL and must

 		not be assumed to point to a valid object.

 */

 	{return(PtrSub((T *)iHead.iPrev,iOffset));}

 // Class TDeltaQue

 template <class T>

 inline TDeltaQue<T>::TDeltaQue()

 /**

 Constructs an empty list header and sets the offset value of the link object 

 to zero.

 In practice, never assume that the offset of the link object from the start 

 of a list element is zero, even if the link object is declared as the first 

 data member in the list element class.

 If this default constructor is used, then call the TDblQueBase::SetOffset() 

 function in the base class to ensure that the offset value is set correctly.

 TDeltaQueBase::iFirstDelta is set to NULL.

 @see TDblQueBase::SetOffset

 */

 	{}

 template <class T>

 inline TDeltaQue<T>::TDeltaQue(TInt aOffset)

 	: TDeltaQueBase(aOffset)

 /**

 Constructs an empty list header and sets the offset of the link object to the 

 specified value.

 TDeltaQueBase::iFirstDelta is set to NULL.

 @param aOffset The offset of the link object from the start of a list element. 

                 The macro _FOFF can be used to calculate this value. 

 @panic USER 78, if aOffset is not divisible by four.

 @see _FOFF

 */

 	{}

 template <class T>

 inline void TDeltaQue<T>::Add(T &aRef,TInt aDelta)

 /**

 Adds the specified list element, having the specified 'distance' from the

 nominal zero point, into the list.

 The element is added into the list, the adjacent delta values adjusted, and 

 a suitable delta value assigned to the new element, so that the new element 

 is at the specified 'distance' from the nominal zero point.

 @param aRef   The list element to be inserted.

 @param aDelta The 'distance' from the nominal zero point.

 */

 	{DoAddDelta(&aRef,aDelta);}

 template <class T>

 inline void TDeltaQue<T>::Remove(T &aRef)

 /**

 Removes the specified list element from the linked list.

 The delta value of the element following the removed element is adjusted

 so that its 'distance' from the nominal zero point remains the same.

 @param aRef The list element to be removed.

 */

 	{DoRemove(&aRef);}

 template <class T>

 inline T *TDeltaQue<T>::RemoveFirst()

 /**

 Removes the first list element from the linked list if its delta value is zero 

 or negative.

 @return A pointer to the element removed from the linked list. This is NULL, 

         if the first element has a positive delta value.

 */

 	{return((T *) DoRemoveFirst());}

 // Class TSglQueIter

 template <class T>

 inline TSglQueIter<T>::TSglQueIter(TSglQueBase &aQue)

 	: TSglQueIterBase(aQue)

 /**

 Constructs the iterator for the specified singly linked list.

 The iterator can be constructed whether or not the list contains any elements.

 If the list does contain elements, the iterator pointer is set to the first one.

 If the list has no elements, the iterator pointer is not set and the conversion 

 operator T*() and the post increment operator ++ subsequently return NULL. 

 Once elements have been added to the list, use either the

 TSglQueIter::Set() function or the TSglQueIterBase::SetToFirst() function to set the 

 iterator pointer.

 @param aQue A reference to a singly linked list header.

 @see TSglQueIter::Set

 @see TSglQueIterBase::SetToFirst

 */

 	{}

 template <class T>

 inline void TSglQueIter<T>::Set(T &aLink)

 /**

 Sets the iterator to point to a specific element in the list.

 This function can be used to alter the pointer at any time during the iterator's 

 existence. The referenced element must be in the list, otherwise the result 

 is undefined.

 @param aLink A reference to the element from where iteration is to continue.

 */

 	{DoSet(&aLink);}

 template <class T>

 inline TSglQueIter<T>::operator T *()

 /**

 Gets a pointer to the iterator’s current element.

 The operator is normally used implicitly; e.g. some member functions of the

 list header class TSglQue require a pointer to an element (of type class T)

 as a parameter, but in practice an iterator is often passed instead.

 This operator performs the necessary conversion.

 */

 	{return((T *)DoCurrent());}

 template <class T>

 inline T *TSglQueIter<T>::operator++(TInt)

 /**

 Gets a pointer to the iterator's current element and then sets the iterator 

 to point to the next element.

 Repeated use of this operator allows successive elements to be accessed.

 @return A pointer to the current list element, if the iterator points to an 

         element. NULL, if the iterator does not point to an element; i.e. the

 		iterator pointer has reached the end of the list.

 */

 	{return((T *)DoPostInc());}

 // Class TDblQueIter

 template <class T>

 inline TDblQueIter<T>::TDblQueIter(TDblQueBase &aQue)

 	: TDblQueIterBase(aQue)

 /**

 Constructs the iterator for the specified doubly linked list

 The iterator can be constructed whether or not the list contains any elements.

 If the list does contain elements, the iterator pointer is set to the first one.

 If the list has no elements, the iterator pointer is not set and the conversion 

 operator T*(), the post increment operator++() and the post decrement operator 

 --() subsequently return NULL. Once elements have been added to the list, use 

 either the TDblQueIter::Set() function, the TDblQueIterBase::SetToFirst() 

 function or the TDblQueIterBase::SetToLast() function to set the iterator 

 pointer.

 @param aQue A reference to a doubly linked list header.

 @see TDblQueIter::Set

 @see TDblQueIterBase::SetToFirst

 @see TDblQueIterBase::SetToLast

 */

 	{}

 template <class T>

 inline void TDblQueIter<T>::Set(T &aLink)

 /**

 Sets the iterator to point to a specific element in the list.

 This function can be used to alter the pointer at any time during

 the iterator's existence. The referenced element must be in the list,

 otherwise the result is undefined.

 @param aLink A reference to the element from where iteration is to continue.

 */

 	{DoSet(&aLink);}

 template <class T>

 inline TDblQueIter<T>::operator T *()

 /**

 Gets a pointer to the iterator’s current element.

 The operator is normally used implicitly; e.g. some member functions of the

 list header class TDblQue require a pointer to an element (of type class T)

 as a parameter but in practice, an iterator is often passed instead.

 This operator performs the necessary conversion.

 @return A pointer to the current element, if the iterator points to an element

         in the list. NULL, if the iterator does not point to an element;

 		i.e. the iterator pointer has previously reached the end of the list

 		(see operator++) or the start of the list (see operator--) or

 		the list is empty. 

 */

 	{return((T *) DoCurrent());}

 template <class T>

 inline T *TDblQueIter<T>::operator++(TInt)

 /**

 Gets a pointer to the iterator's current element and then sets the iterator 

 to point to the next element.

 Repeated use of this operator allows successive 

 elements to be accessed in the forwards direction.

 @return A pointer to the current list element, if the iterator points to an 

         element. NULL, if the iterator does not point to an element;

 		i.e. the iterator pointer has reached the end of the list.

 */

 	{return((T *) DoPostInc());}

 template <class T>

 inline T *TDblQueIter<T>::operator--(TInt)

 /**

 Gets a pointer to the iterator's current element and then sets the iterator 

 to point to the previous element.

 Repeated use of this operator allows successive 

 elements to be accessed in the backwards direction.

 @return A pointer to the current element, if the iterator points to an element. 

         NULL, if the iterator does not point to an element; i.e. the iterator

 		pointer has reached the beginning of the list.

 */

 	{return((T *) DoPostDec());}

 // Class TKey

 inline void TKey::SetPtr(const TAny *aPtr)

 /**

 Sets the pointer to a sample element whose key is to be used for comparison.

 The element can be in an existing array or it can be located anywhere in

 addressable memory.

 The At() member function supplied by a derived class must return a pointer 

 to this sample element's key when passed an index value of KIndexPtr.

 SetPtr() must be called before calling User::BinarySearch() because this algorithm 

 uses the key of this sample element as the basis for searching the array.

 @param aPtr A pointer to a sample element.

 */

 	{iPtr=aPtr;}

 // Class TCharF

 inline TCharF::TCharF(TUint aChar)

 	: TChar(User::Fold(aChar))

 /**

 Constructs this 'fold character' object and initialises it with the specified 

 value.

 @param aChar The initialisation value.

 */

 	{}

 inline TCharF::TCharF(const TChar& aChar)

 	: TChar(User::Fold(aChar))

 /**

 Constructs this 'fold character' object and initialises it with the value of 

 the TChar object aChar.

 @param aChar The character object to use as the initialisation value.

 */

 	{}

 inline TCharF& TCharF::operator=(TUint aChar)

 /**

 Assigns an unsigned integer value to the 'fold character' object.

 @param aChar The value to assign.

 @return A reference to this 'fold character' object.

 */

 	{SetChar(User::Fold(aChar));return(*this);}

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

 /**

 Assigns the specified character object to this 'fold character' object.

 @param aChar The character object to assign.

 @return A reference to this 'fold character' object.

 */

 	{SetChar(User::Fold(aChar));return(*this);}

 // Class TCharLC

 inline TCharLC::TCharLC(TUint aChar)

 	: TChar(User::LowerCase(aChar))

 /**

 Constructs this 'character to lower case' object and initialises it with the 

 specified value.

 @param aChar The initialisation value.

 */

 	{}

 inline TCharLC::TCharLC(const TChar& aChar)

 	: TChar(User::LowerCase(aChar))

 /**

 Constructs this 'character to lower case' object and initialises it with the 

 value of the TChar object aChar.

 @param aChar The character object to use as the initialisation value.

 */

 	{}

 inline TCharLC& TCharLC::operator=(TUint aChar)

 /**

 Assigns an unsigned integer value to the 'character to lower case' object.

 @param aChar The value to assign.

 @return A reference to this 'character to lower case' object.

 */

 	{SetChar(User::LowerCase(aChar));return(*this);}

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

 /**

 Assigns the specified character object to this 'character to lower case'

 object.

 @param aChar The character object to assign.

 @return A reference to this 'character to lower case' object.

 */

 	{SetChar(User::LowerCase(aChar));return(*this);}

 // Class TCharUC

 inline TCharUC::TCharUC(TUint aChar)

 	: TChar(User::UpperCase(aChar))

 /**

 Constructs this 'character to upper case' object and initialises it with the 

 specified value.

 @param aChar The initialisation value.

 */

 	{}

 inline TCharUC::TCharUC(const TChar& aChar)

 	: TChar(User::UpperCase(aChar))

 /**

 Constructs this 'character to upper case' object and initialises it with the 

 value of the TChar object aChar.

 @param aChar The character object to use as the initialisation value.

 */

 	{}

 inline TCharUC& TCharUC::operator=(TUint aChar)

 /**

 Assigns an unsigned integer value to the 'character to upper case'  object.

 @param aChar The value to assign.

 @return A reference to this 'character to upper case'  object.

 */

 	{SetChar(User::UpperCase(aChar));return(*this);}

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

 /**

 Assigns the specified character object to this 'character to upper case' 

 object.

 @param aChar The character object to assign.

 @return A reference to this 'character to upper case'  object.

 */

 	{SetChar(User::UpperCase(aChar));return(*this);}

 // Class TDateTime

 inline TDateTime::TDateTime()

 	: iYear(1980),

 	  iMonth(EJanuary), 

 	  iDay(1),

 	  iHour(0),

 	  iMinute(0),

 	  iSecond(0),

 	  iMicroSecond(0)

 /**

 Constructs an uninitialised TDateTime object.

 */

 	{}           

 inline TInt TDateTime::Year() const

 /**

 Gets the year component of the date/time.

 A negative value indicates a BC date.

 @return The year

 */

 	{return(iYear);}

 inline TMonth TDateTime::Month() const

 /**

 Gets the month component of the date/time.

 @return The month. EJanuary to EDecember. Offset from zero, so add one before 

         displaying the month number.

 */

 	{return(iMonth);}

 inline TInt TDateTime::Day() const

 /**

 Gets the day component of the date/time.

 @return The day. Offset from zero, so add one before displaying the day number.

 */

 	{return(iDay);}

 inline TInt TDateTime::Hour() const

 /**

 Gets the hour component of the date/time.

 @return The hour.

 */

 	{return(iHour);}

 inline TInt TDateTime::Minute() const

 /**

 Gets the minute component of the date/time.

 @return The minute.

 */

 	{return(iMinute);}

 inline TInt TDateTime::Second() const

 /**

 Gets the second component of the date/time.

 @return The second.

 */

 	{return(iSecond);}

 inline TInt TDateTime::MicroSecond() const

 /**

 Gets the microsecond component of the date/time.

 @return The microsecond.

 */

 	{return(iMicroSecond);}

 // Class TTimeIntervalMicroSeconds

 inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds(const TInt64& aInterval)

 	: iInterval(aInterval)

 /**

 Constructs the object with the specified 64-bit interval value.

 @param aInterval The 64-bit interval value with which the object is to be

                  initialised.

 */

 	{}

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

 /**

 Assigns a 64-bit integer value to this object.

 @param aInterval The 64-bit integer interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

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

 /**

 Tests whether this TTimeIntervalMicroSeconds object is equal to the

 specified TTimeIntervalMicroSeconds object.

 @param aInterval The time interval to be compared with this time interval.

 @return True if the two time intervals are equal. False otherwise.

 */

 	{return(iInterval==aInterval.iInterval);}

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

 /**

 Tests whether this TTimeIntervalMicroSeconds object is not equal to the

 specified TTimeIntervalMicroSeconds object.

 @param aInterval The time interval to be compared with this time interval.

 @return True if the two time intervals are not equal. False otherwise.

 */

 	{return(iInterval!=aInterval.iInterval);}

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

 /**

 Tests whether this TTimeIntervalMicroSeconds object is greater than or equal to the

 specified TTimeIntervalMicroSeconds object.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is greater than or equal to the specified

         time interval. False otherwise.

 */

 	{return(iInterval>=aInterval.iInterval);}

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

 /**

 Tests whether this TTimeIntervalMicroSeconds object is less than or equal to the

 specified TTimeIntervalMicroSeconds object.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is less than or equal to the specified

         time interval. False otherwise.

 */

 	{return(iInterval<=aInterval.iInterval);}

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

 /**

 Tests whether this TTimeIntervalMicroSeconds object is greater than the

 specified TTimeIntervalMicroSeconds object.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is greater than the specified

         time interval. False otherwise.

 */

 	{return(iInterval>aInterval.iInterval);}

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

 /**

 Tests whether this TTimeIntervalMicroSeconds object is less than the

 specified TTimeIntervalMicroSeconds object.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is less than the specified

         time interval. False otherwise.

 */

 	{return(iInterval<aInterval.iInterval);}

 inline const TInt64& TTimeIntervalMicroSeconds::Int64() const

 /**

 Gets the time interval as a 64-bit integer value.

 @return This 64-bit integer time interval value.

 */

 	{return(iInterval);}

 // Class TTimeIntervalBase

 inline TTimeIntervalBase::TTimeIntervalBase()

 /**

 Default constructor.

 */

 	{}

 inline TTimeIntervalBase::TTimeIntervalBase(TInt aInterval)

 	: iInterval(aInterval)

 /**

 Constructor taking an interval value.

 @param aInterval The interval value.

 */

 	{}

 inline TBool TTimeIntervalBase::operator==(TTimeIntervalBase aInterval) const

 /**

 Tests whether this time interval is the same as the specified time interval.

 @param aInterval The time interval to be compared with this time interval.

 @return True if the two time intervals are equal. False otherwise.

 */

 	{return(iInterval==aInterval.iInterval);}

 inline TBool TTimeIntervalBase::operator!=(TTimeIntervalBase aInterval) const

 /**

 Tests whether this time interval is not the same as the specified

 time interval.

 @param aInterval The time interval to be compared with this time interval.

 @return True if the two time intervals differ. False otherwise.

 */

 	{return(iInterval!=aInterval.iInterval);}

 inline TBool TTimeIntervalBase::operator>=(TTimeIntervalBase aInterval) const

 /**

 Tests whether this time interval is greater than or equal to the

 specified time interval.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is greater than or equal to the specified

         time interval. False otherwise.

 */

 	{return(iInterval>=aInterval.iInterval);}

 inline TBool TTimeIntervalBase::operator<=(TTimeIntervalBase aInterval) const

 /**

 Tests whether this time interval is less than or equal to the

 specified time interval.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is less than or equal to the specified

         time interval. False otherwise.

 */

 	{return(iInterval<=aInterval.iInterval);}

 inline TBool TTimeIntervalBase::operator>(TTimeIntervalBase aInterval) const

 /**

 Tests whether this time interval is greater than the specified time interval.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is greater than the specified

         time interval. False otherwise.

 */

 	{return(iInterval>aInterval.iInterval);}

 inline TBool TTimeIntervalBase::operator<(TTimeIntervalBase aInterval) const

 /**

 Tests whether this time interval is less than the specified time interval.

 @param aInterval The time interval to be compared with this time interval.

 @return True if this time interval is less than the specified

         time interval. False otherwise.

 */

 	{return(iInterval<aInterval.iInterval);}

 inline TInt TTimeIntervalBase::Int() const

 /** 

 Gets the time interval as a 32 bit integer.

 @return The time interval as a 32 bit integer.

 */

 	{return(iInterval);}

 // Class TTimeIntervalMicroSeconds32

 inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32(TInt aInterval)

     : TTimeIntervalBase(aInterval)

 /**

 Constructs the object with the specified interval value.

 @param aInterval The interval value with which the object is to be initialised.

 */

 	{}

 inline TTimeIntervalMicroSeconds32& TTimeIntervalMicroSeconds32::operator=(TInt aInterval)

 /**

 Assigns a value to this object.

 @param aInterval The interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

 // Class TTimeIntervalSeconds

 inline TTimeIntervalSeconds::TTimeIntervalSeconds()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalSeconds::TTimeIntervalSeconds(TInt aInterval)

 	: TTimeIntervalBase(aInterval)

 /**

 Constructs the object with the specified interval value.

 @param aInterval The interval value with which the object is to be initialised.

 */

 	{}

 inline TTimeIntervalSeconds& TTimeIntervalSeconds::operator=(TInt aInterval)

 /**

 Assigns a value to this object.

 @param aInterval The interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

 // Class TTimeIntervalMinutes

 inline TTimeIntervalMinutes::TTimeIntervalMinutes()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalMinutes::TTimeIntervalMinutes(TInt aInterval)

 	: TTimeIntervalBase(aInterval)

 /**

 Constructs the object with the specified interval value.

 @param aInterval The interval value with which the object is to be initialised.

 */

 	{}

 inline TTimeIntervalMinutes& TTimeIntervalMinutes::operator=(TInt aInterval)

 /**

 Assigns a value to this object.

 @param aInterval The interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

 // Class TTimeIntervalHours

 inline TTimeIntervalHours::TTimeIntervalHours()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalHours::TTimeIntervalHours(TInt aInterval)

 	: TTimeIntervalBase(aInterval)

 /**

 Constructs the object with the specified interval value.

 @param aInterval The interval value with which the object is to be initialised.

 */

 	{}

 inline TTimeIntervalHours& TTimeIntervalHours::operator=(TInt aInterval)

 /**

 Assigns a value to this object.

 @param aInterval The interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

 // Class TTimeIntervalDays

 inline TTimeIntervalDays::TTimeIntervalDays()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalDays::TTimeIntervalDays(TInt aInterval)

 	: TTimeIntervalBase(aInterval)

 /**

 Constructs the object with the specified interval value.

 @param aInterval The interval value with which the object is to be initialised.

 */

 	{}

 inline TTimeIntervalDays& TTimeIntervalDays::operator=(TInt aInterval)

 /**

 Assigns a value to this object.

 @param aInterval The interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

 // Class TTimeIntervalMonths

 inline TTimeIntervalMonths::TTimeIntervalMonths()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalMonths::TTimeIntervalMonths(TInt aInterval)

 	: TTimeIntervalBase(aInterval)

 /**

 Constructs the object with the specified interval value.

 @param aInterval The interval value with which the object is to be initialised.

 */

 	{}

 inline TTimeIntervalMonths& TTimeIntervalMonths::operator=(TInt aInterval)

 /**

 Assigns a value to this object.

 @param aInterval The interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

 // Class TTimeIntervalYears

 inline TTimeIntervalYears::TTimeIntervalYears()

 /**

 Default constructor.

 Constructs an uninitialised object.

 */

 	{}

 inline TTimeIntervalYears::TTimeIntervalYears(TInt aInterval)

 	: TTimeIntervalBase(aInterval)

 /**

 Constructs the object with the specified interval value.

 @param aInterval The interval value with which the object is to be initialised.

 */

 	{}

 inline TTimeIntervalYears& TTimeIntervalYears::operator=(TInt aInterval)

 /**

 Assigns a value to this object.

 @param aInterval The interval value to be assigned.

 @return A reference to this object.

 */

 	{iInterval=aInterval;return(*this);}

 // Class TTime

 inline TTime::TTime()

 /**

 Default constructor.

 The object is initialised to an arbitrary value.

 */

 	{}

 inline TTime::TTime(const TInt64& aTime)

 	: iTime(aTime)

 /**

 Constructs the object from a 64-bit microsecond value.

 @param aTime Microsecond value to which to initialise the TTime object.

 */

 	{}

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

 /**

 Assigns a value contained in a 64-bit integer to this TTime object.

 @param aTime Microsecond value which to assign to the TTime object.

 @return This TTime object.

 */

 	{iTime=aTime;return(*this);}

 inline TBool TTime::operator==(TTime aTime) const

 /**

 Tests whether two date/times are equal.

 @param aTime The time to be compared with this TTime.

 @return True if the two TTimes are equal. False if not.

 */

 	{return(iTime==aTime.iTime);}

 inline TBool TTime::operator!=(TTime aTime) const

 /**

 Tests whether two date/times are not equal.

 @param aTime The date/time to be compared with this TTime.

 @return True if the two TTimes are different. False if the same.

 */

 	{return(iTime!=aTime.iTime);}

 inline TBool TTime::operator>=(TTime aTime) const

 /**

 Tests whether this date/time is later than or the same as the

 specified date/time.

 @param aTime The date/time to be compared with this date/time.

 @return True if this date/time is later than or the same as the

         specified date/time. False otherwise.

 */

 	{return(iTime>=aTime.iTime);}

 inline TBool TTime::operator<=(TTime aTime) const

 /**

 Tests whether this date/time is earlier than or the same as the

 specified date/time.

 @param aTime The date/time to be compared with this date/time.

 @return True if this date/time is earlier than or the same as the

         specified date/time. False otherwise.

 */

 	{return(iTime<=aTime.iTime);}

 inline TBool TTime::operator>(TTime aTime) const

 /**

 Tests whether this date/time is later than the specified date/time.

 @param aTime The date/time to be compared with this date/time.

 @return True if this date/time is later than the specified date/time.

         False otherwise.

 */

 	{return(iTime>aTime.iTime);}

 inline TBool TTime::operator<(TTime aTime) const

 /**

 Tests whether this date/time is earlier than the specified date/time.

 @param aTime The date/time to be compared with this date/time.

 @return True if this date/time is earlier than the specified date/time.

         False otherwise.

 */

 	{return(iTime<aTime.iTime);}

 inline const TInt64& TTime::Int64() const

 /**

 Gets the 64 bit integer representation of this TTime obect.

 @return The 64 bit integer representation.

 */

 	{return(iTime);}

 // Class TLexMark8

 inline TLexMark8::TLexMark8()

 	: iPtr(NULL)

 /**

 Default constructor.

 */

 	{}

 inline TLexMark8::TLexMark8(const TUint8 *aString) 

 	: iPtr(aString)

 	{}

 // Class TLex8

 inline TLex8::TLex8(const TUint8 *aString)

 /**

 Constructs the object with a pointer to a string.

 The extraction mark and next character members are initialised to point

 to the start of the string.

 @param aString String to be assigned.

 */

 	{Assign(TPtrC8(aString));}

 inline TLex8::TLex8(const TDesC8 &aDes)

 /**

 Constructs the object with a descriptor.

 The extraction mark and next character 

 members are initialised to point to the start of the string.

 @param aDes Descriptor to be assigned by reference.

 */

 	{Assign(aDes);}

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

 /**

 Allows strings to be assigned to a TLex8.

 @param aString String to be assigned to the TLex8. 

 @return TLex8 descriptor.

 */

 	{Assign(TPtrC8(aString));return(*this);}

 inline TLex8& TLex8::operator=(const TDesC8& aBuf)

 /**

 Allows descriptors to be assigned to a TLex8.

 @param aBuf Descriptor to be assigned to the TLex8.

 @return TLex8 descriptor.

 */

 	{Assign(aBuf);return(*this);}

 inline TBool TLex8::Eos() const

 /**

 Tests whether the next character position is at the end of the string.

 @return True if at end of string, false otherwise.

 */

 	{return(iNext==iEnd);}

 inline void TLex8::Mark()

 /**

 Sets the TLex8's next character position to its extraction mark.

 */

 	{Mark(iMark);}

 inline void TLex8::Mark(TLexMark8& aMark) const

 /**

 Sets the supplied extraction mark to the TLex8's next character position.

 @param aMark On return, this is set to the next character position.

 */

 	{aMark.iPtr=iNext;}

 inline void TLex8::UnGetToMark()

 /**

 Sets the next character position to the current extraction mark position.

 @panic USER 63, if the extraction mark is before the start or beyond the end

        of the string.

 */

     {UnGetToMark(iMark);}

 inline void TLex8::SkipAndMark(TInt aNumber)

 /**

 Moves the next character position a specified number of characters. 

 @param aNumber Number of characters to skip.

 @panic USER 61, if the skip moves the next character position either to before

        the start or beyond the end of the string.

 */

     {SkipAndMark(aNumber,iMark);}

 inline void TLex8::SkipSpaceAndMark()

 /**

 Moves the next character position past any white space and copies it to the 

 TLex8's extraction mark.

 Stops if at the end of the string.

 */

     {SkipSpaceAndMark(iMark);}

 inline TInt TLex8::TokenLength() const

 /**

 Gets the length of the token.

 This is the difference between the next character 

 position and the extraction mark.

 @return Length of the token.

 */

 	{return(iNext-iMark.iPtr);}

 inline TInt TLex8::MarkedOffset() const

 /**

 Gets the offset of the extraction mark from the start of the string.

 @return The offset of the extraction mark.

 */

     {return(iMark.iPtr-iBuf);}

 inline TInt TLex8::Val(TInt &aVal)

 /**

 Parses the string to extract a signed integer.

 @param aVal On return, contains the extracted integer.

 @return KErrNone if successful.

         KErrGeneral if the next character position is initially at the end of the string

         or no valid characters found initially.

         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.

         If error codes KErrGeneral or KErrOverflow are returned, the object's

         members are left unaltered.

 */

 	{return(Val((TInt32&)aVal));}

 inline TInt TLex8::Val(TUint &aVal,TRadix aRadix)

 /**

 Parses the string to extract an unsigned integer, using the specified radix.

 @param aVal   On return, contains the extracted integer.

 @param aRadix The radix to use when converting the number. The default radix

               for this function overload is decimal.

 @return KErrNone if successful.

         KErrGeneral if the next character position is initially at the end of the string

         or no valid characters found initially.

         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.

         If error codes KErrGeneral or KErrOverflow are returned, the object's

         members are left unaltered.

 */

 	{return(Val((TUint32&)aVal,aRadix));}

 inline void TLex8::Assign(const TLex8& aLex)

 /**

 Assigns a string to this object from another TLex8 object.

 @param aLex The object to be assigned.

 */

 	{new(this) TLex8(aLex);}

 // Class TLexMark16

 inline TLexMark16::TLexMark16()

 	: iPtr(NULL)

 /**

 Default constructor.

 */

 	{}

 inline TLexMark16::TLexMark16(const TUint16 *aString) 

 	: iPtr(aString)

 	{}

 // Class TLex16

 inline TLex16::TLex16(const TUint16 *aString)

 /**

 Constructs the object with a pointer to a string.

 The extraction mark and next character members are initialised to point

 to the start of the string.

 @param aString String to be assigned.

 */

 	{Assign(TPtrC16(aString));}

 inline TLex16::TLex16(const TDesC16 &aDes)

 /**

 Constructs the object with a descriptor.

 The extraction mark and next character 

 members are initialised to point to the start of the string.

 @param aDes Descriptor to be assigned by reference.

 */

 	{Assign(aDes);}

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

 /** 

 Allows strings to be assigned to a TLex16.

 @param aString String to be assigned to the TLex16. 

 @return TLex16 descriptor.

 */

 	{Assign(TPtrC16(aString));return(*this);}

 inline TLex16& TLex16::operator=(const TDesC16& aBuf)

 /**

 Allows descriptors to be assigned to a TLex16.

 @param aBuf Descriptor to be assigned to the TLex16.

 @return TLex8 descriptor.

 */

 	{Assign(aBuf);return(*this);}

 inline TBool TLex16::Eos() const

 /**

 Tests whether the next character position is at the end of the string.

 @return True if at end of string, false otherwise.

 */

 	{return(iNext==iEnd);}

 inline void TLex16::Mark(TLexMark16& aMark) const

 /**

 Sets the supplied extraction mark to the TLex16's next character position.

 @param aMark On return, set to the next character position.

 */

 	{aMark.iPtr=iNext;}

 inline void TLex16::Mark()

 /**

 Sets the TLex16's next character position to its extraction mark.

 */

 	{iMark.iPtr=iNext;}

 inline void TLex16::UnGetToMark()

 /**

 Sets the next character position to the current extraction mark position.

 @panic USER 68, if the specified mark is before the start or beyond the end

        of the string.

 */

     {UnGetToMark(iMark);}

 inline void TLex16::SkipAndMark(TInt aNumber)

 /**

 Moves the next character position a specified number of characters.

 @param aNumber Number of characters to skip. 

 @panic USER 68, if the skip moves the next character position either to before

        the start or beyond the end of the string.

 */

     {SkipAndMark(aNumber,iMark);}

 inline void TLex16::SkipSpaceAndMark()

 /**

 Moves the next character position past any white space and copies it to the 

 TLex16's extraction mark.

 Stops if at the end of the string.

 */

     {SkipSpaceAndMark(iMark);}

 inline TInt TLex16::TokenLength() const

 /**

 Gets the length of the token.

 This is the difference between the next character 

 position and the extraction mark.

 @return Length of the token.

 */

 	{return(iNext-iMark.iPtr);}

 inline TInt TLex16::MarkedOffset() const

 /**

 Gets the offset of the extraction mark from the start of the string.

 @return The offset of the extraction mark.

 */

     {return(iMark.iPtr-iBuf);}

 inline TInt TLex16::Val(TInt &aVal)

 /**

 Parses the string to extract a signed integer.

 @param aVal On return, contains the extracted integer.

 @return KErrNone if successful.

         KErrGeneral if the next character position is initially at the end of the string

         or no valid characters found initially.

         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.

         If error codes KErrGeneral or KErrOverflow are returned, the object's

         members are left unaltered.

 */

 	{return(Val((TInt32&)aVal));}

 inline TInt TLex16::Val(TUint &aVal,TRadix aRadix)

 /**

 Parses the string to extract an unsigned integer, using the specified radix.

 @param aVal   On return, contains the extracted integer.

 @param aRadix The radix to use when converting the number. The default radix

               for this function overload is decimal.

 @return KErrNone if successful.

         KErrGeneral if the next character position is initially at the end of the string

         or no valid characters found initially.

         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.

         If error codes KErrGeneral or KErrOverflow are returned, the object's

         members are left unaltered.

 */

 	{return(Val((TUint32&)aVal,aRadix));}

 inline void TLex16::Assign(const TLex16& aLex)

 /**

 Assigns a string to this object from another TLex16 object.

 @param aLex The object to be assigned.

 */

 	{new(this) TLex16(aLex);}

 // Class TLocale

 inline TLocale::TLocale(TInt)

 	{}

 inline TInt TLocale::RegionCode() const

 	{return(iRegionCode);}

 inline TInt TLocale::CountryCode() const

 /**

 Gets the code which is used to select country-specific locale data.

 The country code is the code used as the international dialling prefix.

 This code is also used to identify a country by the dialling software.

 @return The country code.

 */

 	{return(iCountryCode);}

 inline void TLocale::SetCountryCode(TInt aCode)

 /**

 Sets the value which is used to select country-specific locale data.

 This value can be retrieved by using TLocale::CountryCode(). The country code

 is the code used as the international dialling prefix. This code is also used

 to identify a country by the dialling software.

 @param aCode The country code.

 @see TLocale::CountryCode

 */

 	{iCountryCode=aCode;}

 inline TTimeIntervalSeconds TLocale::UniversalTimeOffset() const

 /**

 Gets the locale's universal time offset.

 @return Offset in seconds from universal time. Time zones east of universal 

 	    time have positive offsets. Time zones west of universal time have negative 

 	    offsets.

 @deprecated Use User::UTCOffset to get the current offset inclusive of daylight

 			savings time. This function returns the same value, for compatibility.

 */

 	{return(iUniversalTimeOffset);}

 inline TDateFormat TLocale::DateFormat() const

 /**

 Gets the date format.

 @return The date format.

 */

 	{return(iDateFormat);}

 inline void TLocale::SetDateFormat(TDateFormat aFormat)

 /**

 Sets the date format.

 @param aFormat The date format to be used.

 */

 	{iDateFormat=aFormat;}

 inline TTimeFormat TLocale::TimeFormat() const

 /**

 Gets the time format (12 or 24 hour).

 @return The time format.

 */

 	{return(iTimeFormat);}

 inline void TLocale::SetTimeFormat(TTimeFormat aFormat)

 /**

 Sets the time format (12 or 24 hour).

 @param aFormat The time format.

 */

 	{iTimeFormat=aFormat;}

 inline TLocalePos TLocale::CurrencySymbolPosition() const

 /**

 Gets the currency symbol position.

 For negative currency values, this position may be

 reversed using SetNegativeCurrencySymbolOpposite().

 @return The currency symbol position.

 @see TLocale::SetNegativeCurrencySymbolOpposite

 */

 	{return(iCurrencySymbolPosition);}

 inline void TLocale::SetCurrencySymbolPosition(TLocalePos aPos)

 /**

 Sets the currency symbol position.

 @param aPos The currency symbol position.

 */

 	{iCurrencySymbolPosition=aPos;}

 inline TBool TLocale::CurrencySpaceBetween() const

 /**

 Gets whether or not a space is inserted between the currency symbol and the 

 currency value.

 For negative currency values, the space can be removed using SetNegativeLoseSpace().

 @return True if a space is inserted; false if not.

 @see TLocale::SetNegativeLoseSpace

 */

 	{return(iCurrencySpaceBetween);}

 inline void TLocale::SetCurrencySpaceBetween(TBool aSpace)

 /**

 Sets whether a space is inserted between the currency symbol and the currency 

 amount.

 @param aSpace ETrue if a space is inserted; EFalse if not.

 */

 	{iCurrencySpaceBetween=aSpace;}

 inline TInt TLocale::CurrencyDecimalPlaces() const

 /**

 Gets the number of decimal places to which currency values are set.

 @return The number of decimal places.

 */

 	{return(iCurrencyDecimalPlaces);}

 inline void TLocale::SetCurrencyDecimalPlaces(TInt aPlaces)

 /**

 Sets the number of decimal places to which currency values should be set.

 @param aPlaces The number of decimal places.

 */

 	{iCurrencyDecimalPlaces=aPlaces;}

 inline TBool TLocale::CurrencyNegativeInBrackets() const

 /**

 @deprecated

 Gets whether negative currency values are enclosed in brackets rather than 

 being preceded by a minus sign. 

 This is deprecated, use NegativeCurrencyFormat() instead.

 @return True if negative currency is enclosed in brackets and has no minus 

         sign; false if negative currency has a minus sign and is not enclosed

 		in brackets.

 @see TLocale::NegativeCurrencyFormat

 */

 	{return((TBool)iNegativeCurrencyFormat);}			

 inline void TLocale::SetCurrencyNegativeInBrackets(TBool aBool)

 /** 

 @deprecated

 Sets whether negative currency values are enclosed in brackets rather than

 being preceded by a minus sign.

 This is deprecated, use SetNegativeCurrencyFormat() instead.

 @param aBool ETrue, if a negative currency value must be enclosed in brackets 

 	         without a minus sign; EFalse, if a negative currency value is

 			 preceded by a minus sign without any enclosing brackets.

 @see TLocale::SetNegativeCurrencyFormat

 */

 	{iNegativeCurrencyFormat=(aBool)?EInBrackets:ELeadingMinusSign;}

 inline TBool TLocale::CurrencyTriadsAllowed() const

 /**

 Gets whether triads are allowed in currency values. Triads are groups of 

 three digits separated by the thousands separator.

 @return True if triads are allowed; false if not.

 */

 	{return(iCurrencyTriadsAllowed);}

 inline void TLocale::SetCurrencyTriadsAllowed(TBool aBool)

 /**

 Sets whether triads are allowed in currency values.

 @param aBool ETrue if triads are allowed; EFalse if triads not allowed.

 */

 	{iCurrencyTriadsAllowed=aBool;}

 inline TChar TLocale::ThousandsSeparator() const

 /**

 Gets the character used to separate groups of three digits to the left of 

 the decimal separator.

 A thousands separator character is only displayed in currency values if currency 

 triads are allowed.

 @return The character used as the thousands separator.

 */

 	{return(iThousandsSeparator);}

 inline void TLocale::SetThousandsSeparator(const TChar& aChar)

 /**

 Sets the character to be used to separate groups of three digits to the left 

 of the decimal separator.

 A thousands separator character is only displayed in currency values if currency 

 triads are allowed.