sl@0: // Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of the License "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // e32\include\e32std.inl
sl@0: // 
sl@0: //
sl@0: 
sl@0: // Global leaving operator new
sl@0: inline TAny* operator new(TUint aSize, TLeave)
sl@0: 	{return User::AllocL(aSize);}
sl@0: inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize)
sl@0: 	{return User::AllocL(aSize + aExtraSize);}
sl@0: #if !defined(__VC32__) || defined (__MSVCDOTNET__)
sl@0: inline TAny* operator new[](TUint aSize, TLeave)
sl@0: 	{return User::AllocL(aSize);}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // class Mem
sl@0: inline TUint8* Mem::Copy(TAny* aTrg, const TAny* aSrc, TInt aLength)
sl@0: /**
sl@0: Copies data from a source location to a target location and returns a pointer 
sl@0: to the end of the copied data.
sl@0: 	
sl@0: The source and target areas can overlap.
sl@0: 	
sl@0: The copy operation is optimised so that if both source and target locations 
sl@0: are aligned on a word boundary, the operation performs the copy on a word 
sl@0: by word basis.
sl@0: 	
sl@0: @param aTrg    A pointer to the target location for the copy operation. 
sl@0: @param aSrc    A pointer to the source location for the copy operation. 
sl@0: @param aLength The number of bytes to be copied. This value must not
sl@0:                be negative. 
sl@0: 
sl@0: @return A pointer to a location aLength bytes beyond aTrg (i.e. the location 
sl@0:         aTrg+aLength).
sl@0: 
sl@0: @panic USER 90 In debug builds only, if aLength is negative. 
sl@0: */
sl@0: 	{ return (TUint8*)memmove(aTrg, aSrc, aLength) + aLength; }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TUint8* Mem::Move(TAny* aTrg, const TAny* aSrc, TInt aLength)
sl@0: /**
sl@0: Moves a block of data from a source location to a target location and returns 
sl@0: a pointer to the end of the moved data.
sl@0: 	
sl@0: The source and target areas can overlap.
sl@0: 	
sl@0: Both source and target locations must be aligned on a word boundary. 
sl@0: The specified length must also be a multiple of 4.
sl@0: 	
sl@0: @param aTrg    A pointer to the target location for the move operation. This 
sl@0:                pointer must be word aligned. 
sl@0: @param aSrc    A pointer to the source location for the move operation. This
sl@0:                pointer must be word aligned.
sl@0: @param aLength The number of bytes to be copied. This value must be a multiple 
sl@0:                of 4.
sl@0: 			   
sl@0: @return A pointer to a location aLength bytes beyond aTrg (i.e. the location 
sl@0:         aTrg+aLength).
sl@0: 
sl@0: @panic USER 93 In debug builds only, if aTrg is not word aligned.
sl@0: @panic USER 92 In debug builds only, if aSrc is not word aligned.
sl@0: @panic USER 91 In debug builds only, if aLength is not a multiple of 4.
sl@0: */
sl@0: 	{ return (TUint8*)wordmove(aTrg, aSrc, aLength) + aLength; }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void Mem::Fill(TAny* aTrg, TInt aLength, TChar aChar)
sl@0: /**
sl@0: Fills a specified block of data with a specified character, replacing
sl@0: any existing content.
sl@0: 	
sl@0: The function assumes that the fill character is a non-Unicode character.
sl@0: 	
sl@0: @param aTrg    A pointer to the location where filling is to start. 
sl@0: @param aLength The number of bytes to be filled. This value must not
sl@0:                be negative. 
sl@0: @param aChar   The fill character.
sl@0: 
sl@0: @panic USER 95 In debug builds only, if aLength is negative.  
sl@0: */
sl@0: 	{ memset(aTrg, (TInt)(aChar.operator TUint()), aLength); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void Mem::FillZ(TAny* aTrg,TInt aLength)
sl@0: /**
sl@0: Fills a specified block of data with binary zeroes (i.e. 0x00), replacing any 
sl@0: existing content.
sl@0: 	
sl@0: @param aTrg    A pointer to the location where filling is to start. 
sl@0: @param aLength The number of bytes to be filled. This value must not
sl@0:                be negative. 
sl@0: 	
sl@0: @panic USER 95 In debug builds only, if aLength is negative.  
sl@0: */
sl@0: 	{ memclr(aTrg, aLength); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: #if !(defined(__GCC32__) && defined(__MARM__))
sl@0: inline TInt Mem::Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL)
sl@0: /**
sl@0: Compares a block of data at one specified location with a block of data at 
sl@0: another specified location.
sl@0: 
sl@0: The comparison proceeds on a byte for byte basis, the result of the comparison 
sl@0: is based on the difference of the first bytes to disagree.
sl@0: 
sl@0: The data at the two locations are equal if they have the same length and content. 
sl@0: Where the lengths are different and the shorter section of data is the same 
sl@0: as the first part of the longer section of data, the shorter is considered 
sl@0: to be less than the longer.
sl@0: 
sl@0: @param aLeft   A pointer to the first (or left) block of 8 bit data
sl@0:                to be compared.
sl@0: @param aLeftL  The length of the first (or left) block of data to be compared,  
sl@0:                i.e. the number of bytes.
sl@0: @param aRight  A pointer to the second (or right) block of 8 bit data to be 
sl@0:                compared.
sl@0: @param aRightL The length of the second (or right) block of data to be compared 
sl@0:                i.e. the number of bytes.
sl@0:                
sl@0: @return Positive, if the first (or left) block of data is greater than the 
sl@0:         second (or right) block of data.
sl@0:         Negative, if the first (or left) block of data is less than the
sl@0:         second (or right) block of data.
sl@0:         Zero, if both the first (or left) and second (or right) blocks of data
sl@0:         have the same length and the same content.
sl@0: */
sl@0: 	{ return memcompare(aLeft, aLeftL, aRight, aRightL); }
sl@0: #endif
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // class RHeap
sl@0: inline TInt RHeap::SetBrk(TInt aBrk)
sl@0: 	{ return ((RChunk*)&iChunkHandle)->Adjust(aBrk); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // class TChar
sl@0: #ifndef __KERNEL_MODE__
sl@0: inline void TChar::SetChar(TUint aChar)
sl@0: 	{iChar=aChar;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TChar::Fold()
sl@0: /**
sl@0: Converts the character to a form which can be used in tolerant comparisons 
sl@0: without control over the operations performed. 
sl@0: 
sl@0: Tolerant comparisons are those which ignore character differences like case 
sl@0: and accents.
sl@0: 
sl@0: This function can be used when searching for a string in a text file or a 
sl@0: file in a directory. Folding performs the following conversions: converts 
sl@0: to lowercase, strips accents, converts all digits representing the values 
sl@0: 0..9 to the ordinary digit characters '0'..'9', converts all spaces (standard, 
sl@0: non-break, fixed-width, ideographic, etc.) to the ordinary space character 
sl@0: (0x0020), converts Japanese characters in the hiragana syllabary to katakana, 
sl@0: and converts East Asian halfwidth and fullwidth variants to their ordinary 
sl@0: forms. You can choose to perform any subset of these operations by using the 
sl@0: other function overload.
sl@0: 
sl@0: @see User::Fold
sl@0: */
sl@0: 	{iChar=User::Fold(iChar);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TChar::LowerCase()
sl@0: /**
sl@0: Converts the character to its lowercase form.
sl@0: 
sl@0: Characters lacking a lowercase form are unchanged.
sl@0: 
sl@0: @see User::LowerCase
sl@0: */
sl@0: 	{iChar=User::LowerCase(iChar);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TChar::UpperCase()
sl@0: /**
sl@0: Converts the character to its uppercase form.
sl@0: 
sl@0: Characters lacking an uppercase form are unchanged.
sl@0: 
sl@0: @see User::UpperCase
sl@0: */
sl@0: 	{iChar=User::UpperCase(iChar);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: #ifdef _UNICODE
sl@0: inline void TChar::Fold(TInt aFlags)
sl@0: /**
sl@0: Converts the character to a form which can be used in tolerant comparisons 
sl@0: allowing selection of the specific fold operations to be performed.
sl@0: 
sl@0: @param aFlags Flags which define the operations to be performed. The values 
sl@0:               are defined in the enum beginning with EFoldCase.
sl@0: 
sl@0: @see TChar::EFoldCase
sl@0: @see User::Fold
sl@0: */
sl@0: 	{iChar=User::Fold(iChar,aFlags);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TChar::TitleCase()
sl@0: /**
sl@0: Converts the character to its titlecase form.
sl@0: 
sl@0: The titlecase form of a character is identical to its uppercase form unless 
sl@0: a specific titlecase form exists. Characters lacking a titlecase form are 
sl@0: unchanged.
sl@0: */
sl@0: 	{iChar=User::TitleCase(iChar);}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TChar::Eos() const
sl@0: /**
sl@0: Tests whether the character is the C/C++ end-of-string character - 0.
sl@0: 
sl@0: @return True, if the character is 0; false, otherwise.
sl@0: */
sl@0: 	{return(iChar==0);}
sl@0: #endif // _UNICODE
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TCallBack
sl@0: inline TCallBack::TCallBack()
sl@0: /**
sl@0: Default constructor.
sl@0: 	
sl@0: Sets the function pointer to Null.
sl@0: */
sl@0: 	{iFunction=NULL;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCallBack::TCallBack(TInt (*aFunction)(TAny *aPtr))
sl@0: 	: iFunction(aFunction),iPtr(NULL)
sl@0: /**
sl@0: Constructs the callback object with the specified callback function.
sl@0: 
sl@0: @param aFunction A pointer to the callback function. It takes an argument of
sl@0:                  type TAny* and returns a TInt.
sl@0: 				 It must be either a static member of a class or a function
sl@0: 				 which is not a member of any class. 
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCallBack::TCallBack(TInt (*aFunction)(TAny *aPtr),TAny *aPtr)
sl@0: 	: iFunction(aFunction),iPtr(aPtr)
sl@0: /**
sl@0: Constructs the callback object with the specified callback function and
sl@0: a pointer to any object.
sl@0: 
sl@0: @param aFunction A pointer to the callback function. It takes an argument of
sl@0:                  type TAny* and returns a TInt.
sl@0: 				 It must be either a static member of a class or a function
sl@0: 				 which is not a member of any class. 
sl@0: @param aPtr      A pointer which is always passed to the callback function.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Calls the callback function.
sl@0: 	
sl@0: @return The value returned by the callback function. The meaning of this value
sl@0:         depends entirely on the context in which the callback function
sl@0:         is called.
sl@0:         For example, when used with the CIdle class, a false (zero) value
sl@0:         indicates that the callback function should not be 	called again.
sl@0:         As another example, when used with the CPeriodic class, the return
sl@0:         value is ignored and is irrelevant in that context.
sl@0: 
sl@0: @see CIdle
sl@0: @see CPeriodic        
sl@0: */
sl@0: inline TInt TCallBack::CallBack() const
sl@0: 	{ return (iFunction ? (*iFunction)(iPtr) : 0); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TSglQue
sl@0: template <class T>
sl@0: inline TSglQue<T>::TSglQue()
sl@0: /**
sl@0: Constructs an empty list header and sets the offset value of the link object 
sl@0: to zero.
sl@0: 
sl@0: In practice, never assume that the offset of the link object from the start 
sl@0: of a list element is zero, even if the link object is declared as the first 
sl@0: data member in the list element class.
sl@0: 
sl@0: If this default constructor is used, then call the SetOffset() function of 
sl@0: the base class to ensure that the offset value is set correctly.
sl@0: 
sl@0: @see TSglQueBase::SetOffset
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TSglQue<T>::TSglQue(TInt aOffset)
sl@0: 	: TSglQueBase(aOffset)
sl@0: /**
sl@0: Constructs an empty list header and sets the offset of the link object to the 
sl@0: specified value.
sl@0: 
sl@0: @param aOffset The offset of the link object from the start of a list element. 
sl@0:                 The macro _FOFF can be used to calculate this value.
sl@0: 				
sl@0: @panic USER 75, if aOffset is not divisible by four.
sl@0: 
sl@0: @see _FOFF
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TSglQue<T>::AddFirst(T &aRef)
sl@0: /**
sl@0: Inserts the specified list element at the front of the singly linked list.
sl@0: 
sl@0: If the list is not empty, the specified element becomes the first in the list. 
sl@0: What was previously the first element becomes the second in the list.
sl@0: 
sl@0: @param aRef The list element to be inserted at the front of the singly linked 
sl@0:             list.
sl@0: */
sl@0: 	{DoAddFirst(&aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TSglQue<T>::AddLast(T &aRef)
sl@0: /**
sl@0: Inserts the specified list element at the back of the singly linked list.
sl@0: 
sl@0: If the list is not empty, the specified element becomes the last in the list. 
sl@0: What was previously the last element becomes the next to last element in the 
sl@0: list.
sl@0: 
sl@0: @param aRef The list element to be inserted at the back of the singly linked 
sl@0:             list.
sl@0: */
sl@0: 	{DoAddLast(&aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TSglQue<T>::IsFirst(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the specified element is the first in the singly linked list.
sl@0: 
sl@0: @param aPtr A pointer to the element whose position in the list is to be
sl@0:             checked.
sl@0: 
sl@0: @return True, if the element is the first in the list; false, otherwise.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TSglQue<T>::IsLast(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the specified element is the last in the singly linked list.
sl@0: 
sl@0: @param aPtr A pointer to the element whose position in the list is 
sl@0:             to be checked.
sl@0: 
sl@0: @return True, if the element is the last in the list; false, otherwise.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)iLast);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TSglQue<T>::First() const
sl@0: /**
sl@0: Gets a pointer to the first list element in the singly linked list.
sl@0: 
sl@0: @return A pointer to the first list element in the singly linked list. If 
sl@0:         the list is empty, this pointer is not necessarily NULL and must not
sl@0: 		be assumed to point to a valid object.
sl@0: */
sl@0: 	{return(PtrSub((T *)iHead,iOffset));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TSglQue<T>::Last() const
sl@0: /**
sl@0: Gets a pointer to the last list element in the singly linked list.
sl@0: 
sl@0: @return A pointer to the last list element in the singly linked list. If the 
sl@0:         list is empty, this pointer is not necessarily NULL and must not be
sl@0: 		assumed to point to a valid object.
sl@0: */
sl@0: 	{return(PtrSub((T *)iLast,iOffset));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TSglQue<T>::Remove(T &aRef)
sl@0: /**
sl@0: Removes the specified element from the singly linked list.
sl@0: 
sl@0: The singly linked list must not be empty.
sl@0: 
sl@0: @param aRef A list element to be removed from the singly linked list.
sl@0: 
sl@0: @panic USER 76, if the element to be removed is not in the list
sl@0: */
sl@0: 	{DoRemove(&aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TDblQue
sl@0: template <class T>
sl@0: inline TDblQue<T>::TDblQue()
sl@0: /**
sl@0: Constructs an empty list header and sets the offset value of the link object 
sl@0: to zero.
sl@0: 
sl@0: In practice, never assume that the offset of the link object from the start 
sl@0: of a list element is zero, even if the link object is declared as the first 
sl@0: data member in the list element class.
sl@0: 
sl@0: If this default constructor is used, then call the SetOffset() function of 
sl@0: the base class to ensure that the offset value is set correctly.
sl@0: 
sl@0: @see TDblQueBase::SetOffset()
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TDblQue<T>::TDblQue(TInt aOffset)
sl@0: 	: TDblQueBase(aOffset)
sl@0: /**
sl@0: Constructs an empty list header and sets the offset of the link object to the 
sl@0: specified value.
sl@0: 
sl@0: @param aOffset The offset of the link object from the start of a list element. 
sl@0:                 The macro _FOFF can be used to calculate this value.
sl@0: 				
sl@0: @panic USER 78. if aOffset is not divisble by 4.
sl@0: 				  
sl@0: @see _FOFF
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TDblQue<T>::AddFirst(T &aRef)
sl@0: /**
sl@0: Inserts the specified list element at the front of the doubly linked list.
sl@0: 
sl@0: If the list is not empty, the specified element becomes the first in the list. 
sl@0: What was previously the first element becomes the second in the list.
sl@0: 
sl@0: @param aRef The list element to be inserted at the front of the doubly linked 
sl@0:             list.
sl@0: */
sl@0: 	{DoAddFirst(&aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TDblQue<T>::AddLast(T &aRef)
sl@0: /**
sl@0: Inserts the specified list element at the back of the doubly linked list.
sl@0: 
sl@0: If the list is not empty, the specified element becomes the last in the list. 
sl@0: What was previously the last element becomes the next to last element in the 
sl@0: list.
sl@0: 
sl@0: @param aRef The list element to be inserted at the back of the doubly linked 
sl@0:             list.
sl@0: */
sl@0: 	{DoAddLast(&aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TDblQue<T>::IsHead(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the end of a list has been reached.
sl@0: 
sl@0: A doubly linked list is circular; in following the chain of elements in a 
sl@0: list (e.g. using the iterator operator++ or operator--), the chain eventually 
sl@0: reaches the end of the list and aPtr corresponds to the header (although it 
sl@0: will not point to a valid T object).
sl@0: 
sl@0: @param aPtr The pointer value to be checked. 
sl@0: 
sl@0: @return True, if the end of the list has been reached. False, if the end of 
sl@0:         the list has not been reached; aPtr points to an element in the list.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TDblQue<T>::IsFirst(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the specified element is the first in the doubly linked list.
sl@0: 
sl@0: @param aPtr A pointer to the element whose position in the list is to be checked.
sl@0: 
sl@0: @return True, if the element is the first in the list; false, otherwise.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TDblQue<T>::IsLast(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the specified element is the last in the doubly linked list.
sl@0: 
sl@0: @param aPtr A pointer to the element whose position in the list is to be checked.
sl@0: 
sl@0: @return True, if the element is the last in the list; false, otherwise.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TDblQue<T>::First() const
sl@0: /**
sl@0: Gets a pointer to the first list element in the doubly linked list.
sl@0: 
sl@0: @return A pointer to the first list element in the doubly linked list. If 
sl@0:         the list is empty, this pointer is not necessarily NULL and must not
sl@0: 		be assumed to point to a valid object.
sl@0: */
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgTestEmpty();
sl@0: #endif
sl@0:     return(PtrSub((T *)iHead.iNext,iOffset));
sl@0:     }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TDblQue<T>::Last() const
sl@0: /**
sl@0: Gets a pointer to the last list element in the doubly linked list.
sl@0: 
sl@0: @return A pointer to the last list element in the doubly linked list. If the 
sl@0:         list is empty, this pointer is not necessarily NULL and must not be assumed 
sl@0:         to point to a valid object.
sl@0: */
sl@0: 	{
sl@0: #if defined (_DEBUG)
sl@0: 	__DbgTestEmpty();
sl@0: #endif
sl@0: 	return(PtrSub((T *)iHead.iPrev,iOffset));
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TPriQue
sl@0: template <class T>
sl@0: inline TPriQue<T>::TPriQue()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an empty list header and sets the offset value of the link
sl@0: object to zero.
sl@0: 
sl@0: In practice, never assume that the offset of the link object from the start
sl@0: of a list element is zero, even if the link object is declared as the first
sl@0: data member in the list element class.
sl@0: 
sl@0: If this default constructor is used, then call the SetOffset() function of
sl@0: the base class to ensure that the offset value is set correctly.
sl@0: 
sl@0: @see TDblQueBase::SetOffset
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TPriQue<T>::TPriQue(TInt aOffset)
sl@0: 	: TDblQueBase(aOffset)
sl@0: /**
sl@0: Constructs an empty list header and sets the offset of the link object
sl@0: to the specified value.
sl@0: 
sl@0: @param aOffset The offset of the link object from the start of a list element.
sl@0:                 The macro _FOFF can be used to calculate this value.
sl@0: 				
sl@0: @panic USER 78 if aOffset is not divisible by four.		  
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TPriQue<T>::Add(T &aRef)
sl@0: /**
sl@0: Inserts the specified list element in descending priority order.
sl@0: 
sl@0: If there is an existing list element with the same priority, then the new
sl@0: element is added after the existing element.
sl@0: 
sl@0: @param aRef The list element to be inserted.
sl@0: */
sl@0: 	{DoAddPriority(&aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TPriQue<T>::IsHead(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the end of a list has been reached.
sl@0: 
sl@0: A doubly linked list is circular; in following the chain of elements in a list
sl@0: (e.g. using the iterator operator++ or operator--), the chain eventually
sl@0: reaches the end of the list and aPtr corresponds to the header (although it
sl@0: will not point to a valid T object).
sl@0: 
sl@0: @param aPtr The pointer value to be checked.
sl@0: 
sl@0: @return True, if the end of the list has been reached. False, if the end of the
sl@0:         list has not been reached; aPtr points to an element in the list.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TPriQue<T>::IsFirst(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the specified element is the first in the linked list.
sl@0: 
sl@0: @param aPtr A pointer to the element whose position in the list is to
sl@0:             be checked.
sl@0: 
sl@0: @return True, if the element is the first in the list; false, otherwise.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TBool TPriQue<T>::IsLast(const T *aPtr) const
sl@0: /**
sl@0: Tests whether the specified element is the last in the linked list.
sl@0: 
sl@0: @param aPtr A pointer to the element whose position in the list is to
sl@0:             be checked.
sl@0: 
sl@0: @return True, if the element is the last in the list; false, otherwise.
sl@0: */
sl@0: 	{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TPriQue<T>::First() const
sl@0: /**
sl@0: Gets a pointer to the first list element in the linked list.
sl@0: 
sl@0: @return A pointer to the first list element in the linked list.
sl@0:         If the list is empty, this pointer is not necessarily NULL and must
sl@0: 		not be assumed to point to a valid object.
sl@0: */
sl@0: 	{return(PtrSub((T *)iHead.iNext,iOffset));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TPriQue<T>::Last() const
sl@0: /**
sl@0: Gets a pointer to the last list element in the linked list.
sl@0: 
sl@0: @return A pointer to the last list element in the linked list.
sl@0:         If the list is empty, this pointer is not necessarily NULL and must
sl@0: 		not be assumed to point to a valid object.
sl@0: */
sl@0: 	{return(PtrSub((T *)iHead.iPrev,iOffset));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TDeltaQue
sl@0: template <class T>
sl@0: inline TDeltaQue<T>::TDeltaQue()
sl@0: /**
sl@0: Constructs an empty list header and sets the offset value of the link object 
sl@0: to zero.
sl@0: 
sl@0: In practice, never assume that the offset of the link object from the start 
sl@0: of a list element is zero, even if the link object is declared as the first 
sl@0: data member in the list element class.
sl@0: 
sl@0: If this default constructor is used, then call the TDblQueBase::SetOffset() 
sl@0: function in the base class to ensure that the offset value is set correctly.
sl@0: 
sl@0: TDeltaQueBase::iFirstDelta is set to NULL.
sl@0: 
sl@0: @see TDblQueBase::SetOffset
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TDeltaQue<T>::TDeltaQue(TInt aOffset)
sl@0: 	: TDeltaQueBase(aOffset)
sl@0: /**
sl@0: Constructs an empty list header and sets the offset of the link object to the 
sl@0: specified value.
sl@0: 
sl@0: TDeltaQueBase::iFirstDelta is set to NULL.
sl@0: 
sl@0: @param aOffset The offset of the link object from the start of a list element. 
sl@0:                 The macro _FOFF can be used to calculate this value. 
sl@0: 
sl@0: @panic USER 78, if aOffset is not divisible by four.
sl@0: 				  
sl@0: @see _FOFF
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TDeltaQue<T>::Add(T &aRef,TInt aDelta)
sl@0: /**
sl@0: Adds the specified list element, having the specified 'distance' from the
sl@0: nominal zero point, into the list.
sl@0: 
sl@0: The element is added into the list, the adjacent delta values adjusted, and 
sl@0: a suitable delta value assigned to the new element, so that the new element 
sl@0: is at the specified 'distance' from the nominal zero point.
sl@0: 
sl@0: @param aRef   The list element to be inserted.
sl@0: @param aDelta The 'distance' from the nominal zero point.
sl@0: */
sl@0: 	{DoAddDelta(&aRef,aDelta);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TDeltaQue<T>::Remove(T &aRef)
sl@0: /**
sl@0: Removes the specified list element from the linked list.
sl@0: 
sl@0: The delta value of the element following the removed element is adjusted
sl@0: so that its 'distance' from the nominal zero point remains the same.
sl@0: 
sl@0: @param aRef The list element to be removed.
sl@0: */
sl@0: 	{DoRemove(&aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TDeltaQue<T>::RemoveFirst()
sl@0: /**
sl@0: Removes the first list element from the linked list if its delta value is zero 
sl@0: or negative.
sl@0: 
sl@0: @return A pointer to the element removed from the linked list. This is NULL, 
sl@0:         if the first element has a positive delta value.
sl@0: */
sl@0: 	{return((T *) DoRemoveFirst());}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TSglQueIter
sl@0: template <class T>
sl@0: inline TSglQueIter<T>::TSglQueIter(TSglQueBase &aQue)
sl@0: 	: TSglQueIterBase(aQue)
sl@0: /**
sl@0: Constructs the iterator for the specified singly linked list.
sl@0: 
sl@0: The iterator can be constructed whether or not the list contains any elements.
sl@0: 
sl@0: If the list does contain elements, the iterator pointer is set to the first one.
sl@0: 
sl@0: If the list has no elements, the iterator pointer is not set and the conversion 
sl@0: operator T*() and the post increment operator ++ subsequently return NULL. 
sl@0: Once elements have been added to the list, use either the
sl@0: TSglQueIter::Set() function or the TSglQueIterBase::SetToFirst() function to set the 
sl@0: iterator pointer.
sl@0: 
sl@0: @param aQue A reference to a singly linked list header.
sl@0: 
sl@0: @see TSglQueIter::Set
sl@0: @see TSglQueIterBase::SetToFirst
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TSglQueIter<T>::Set(T &aLink)
sl@0: /**
sl@0: Sets the iterator to point to a specific element in the list.
sl@0: 
sl@0: This function can be used to alter the pointer at any time during the iterator's 
sl@0: existence. The referenced element must be in the list, otherwise the result 
sl@0: is undefined.
sl@0: 
sl@0: @param aLink A reference to the element from where iteration is to continue.
sl@0: */
sl@0: 	{DoSet(&aLink);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TSglQueIter<T>::operator T *()
sl@0: /**
sl@0: Gets a pointer to the iterator’s current element.
sl@0: 
sl@0: The operator is normally used implicitly; e.g. some member functions of the
sl@0: list header class TSglQue require a pointer to an element (of type class T)
sl@0: as a parameter, but in practice an iterator is often passed instead.
sl@0: This operator performs the necessary conversion.
sl@0: */
sl@0: 	{return((T *)DoCurrent());}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TSglQueIter<T>::operator++(TInt)
sl@0: /**
sl@0: Gets a pointer to the iterator's current element and then sets the iterator 
sl@0: to point to the next element.
sl@0: 
sl@0: Repeated use of this operator allows successive elements to be accessed.
sl@0: 
sl@0: @return A pointer to the current list element, if the iterator points to an 
sl@0:         element. NULL, if the iterator does not point to an element; i.e. the
sl@0: 		iterator pointer has reached the end of the list.
sl@0: */
sl@0: 	{return((T *)DoPostInc());}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TDblQueIter
sl@0: template <class T>
sl@0: inline TDblQueIter<T>::TDblQueIter(TDblQueBase &aQue)
sl@0: 	: TDblQueIterBase(aQue)
sl@0: /**
sl@0: Constructs the iterator for the specified doubly linked list
sl@0: 
sl@0: The iterator can be constructed whether or not the list contains any elements.
sl@0: 
sl@0: If the list does contain elements, the iterator pointer is set to the first one.
sl@0: 
sl@0: If the list has no elements, the iterator pointer is not set and the conversion 
sl@0: operator T*(), the post increment operator++() and the post decrement operator 
sl@0: --() subsequently return NULL. Once elements have been added to the list, use 
sl@0: either the TDblQueIter::Set() function, the TDblQueIterBase::SetToFirst() 
sl@0: function or the TDblQueIterBase::SetToLast() function to set the iterator 
sl@0: pointer.
sl@0: 
sl@0: @param aQue A reference to a doubly linked list header.
sl@0: 
sl@0: @see TDblQueIter::Set
sl@0: @see TDblQueIterBase::SetToFirst
sl@0: @see TDblQueIterBase::SetToLast
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline void TDblQueIter<T>::Set(T &aLink)
sl@0: /**
sl@0: Sets the iterator to point to a specific element in the list.
sl@0: 
sl@0: This function can be used to alter the pointer at any time during
sl@0: the iterator's existence. The referenced element must be in the list,
sl@0: otherwise the result is undefined.
sl@0: 
sl@0: @param aLink A reference to the element from where iteration is to continue.
sl@0: */
sl@0: 	{DoSet(&aLink);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline TDblQueIter<T>::operator T *()
sl@0: /**
sl@0: Gets a pointer to the iterator’s current element.
sl@0: 
sl@0: The operator is normally used implicitly; e.g. some member functions of the
sl@0: list header class TDblQue require a pointer to an element (of type class T)
sl@0: as a parameter but in practice, an iterator is often passed instead.
sl@0: This operator performs the necessary conversion.
sl@0: 
sl@0: @return A pointer to the current element, if the iterator points to an element
sl@0:         in the list. NULL, if the iterator does not point to an element;
sl@0: 		i.e. the iterator pointer has previously reached the end of the list
sl@0: 		(see operator++) or the start of the list (see operator--) or
sl@0: 		the list is empty. 
sl@0: */
sl@0: 	{return((T *) DoCurrent());}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TDblQueIter<T>::operator++(TInt)
sl@0: /**
sl@0: Gets a pointer to the iterator's current element and then sets the iterator 
sl@0: to point to the next element.
sl@0: 
sl@0: Repeated use of this operator allows successive 
sl@0: elements to be accessed in the forwards direction.
sl@0: 
sl@0: @return A pointer to the current list element, if the iterator points to an 
sl@0:         element. NULL, if the iterator does not point to an element;
sl@0: 		i.e. the iterator pointer has reached the end of the list.
sl@0: */
sl@0: 	{return((T *) DoPostInc());}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T>
sl@0: inline T *TDblQueIter<T>::operator--(TInt)
sl@0: /**
sl@0: Gets a pointer to the iterator's current element and then sets the iterator 
sl@0: to point to the previous element.
sl@0: 
sl@0: Repeated use of this operator allows successive 
sl@0: elements to be accessed in the backwards direction.
sl@0: 
sl@0: @return A pointer to the current element, if the iterator points to an element. 
sl@0:         NULL, if the iterator does not point to an element; i.e. the iterator
sl@0: 		pointer has reached the beginning of the list.
sl@0: */
sl@0: 	{return((T *) DoPostDec());}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TKey
sl@0: inline void TKey::SetPtr(const TAny *aPtr)
sl@0: /**
sl@0: Sets the pointer to a sample element whose key is to be used for comparison.
sl@0: 	
sl@0: The element can be in an existing array or it can be located anywhere in
sl@0: addressable memory.
sl@0: 	
sl@0: The At() member function supplied by a derived class must return a pointer 
sl@0: to this sample element's key when passed an index value of KIndexPtr.
sl@0: 	
sl@0: SetPtr() must be called before calling User::BinarySearch() because this algorithm 
sl@0: uses the key of this sample element as the basis for searching the array.
sl@0: 	
sl@0: @param aPtr A pointer to a sample element.
sl@0: */
sl@0: 	{iPtr=aPtr;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TCharF
sl@0: inline TCharF::TCharF(TUint aChar)
sl@0: 	: TChar(User::Fold(aChar))
sl@0: /**
sl@0: Constructs this 'fold character' object and initialises it with the specified 
sl@0: value.
sl@0: 
sl@0: @param aChar The initialisation value.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharF::TCharF(const TChar& aChar)
sl@0: 	: TChar(User::Fold(aChar))
sl@0: /**
sl@0: Constructs this 'fold character' object and initialises it with the value of 
sl@0: the TChar object aChar.
sl@0: 
sl@0: @param aChar The character object to use as the initialisation value.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharF& TCharF::operator=(TUint aChar)
sl@0: /**
sl@0: Assigns an unsigned integer value to the 'fold character' object.
sl@0: 
sl@0: @param aChar The value to assign.
sl@0: 
sl@0: @return A reference to this 'fold character' object.
sl@0: */
sl@0: 	{SetChar(User::Fold(aChar));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharF& TCharF::operator=(const TChar& aChar)
sl@0: /**
sl@0: Assigns the specified character object to this 'fold character' object.
sl@0: 
sl@0: @param aChar The character object to assign.
sl@0: 
sl@0: @return A reference to this 'fold character' object.
sl@0: */
sl@0: 	{SetChar(User::Fold(aChar));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TCharLC
sl@0: inline TCharLC::TCharLC(TUint aChar)
sl@0: 	: TChar(User::LowerCase(aChar))
sl@0: /**
sl@0: Constructs this 'character to lower case' object and initialises it with the 
sl@0: specified value.
sl@0: 
sl@0: @param aChar The initialisation value.
sl@0: 
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharLC::TCharLC(const TChar& aChar)
sl@0: 	: TChar(User::LowerCase(aChar))
sl@0: /**
sl@0: Constructs this 'character to lower case' object and initialises it with the 
sl@0: value of the TChar object aChar.
sl@0: 
sl@0: @param aChar The character object to use as the initialisation value.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharLC& TCharLC::operator=(TUint aChar)
sl@0: /**
sl@0: Assigns an unsigned integer value to the 'character to lower case' object.
sl@0: 
sl@0: @param aChar The value to assign.
sl@0: 
sl@0: @return A reference to this 'character to lower case' object.
sl@0: */
sl@0: 	{SetChar(User::LowerCase(aChar));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharLC& TCharLC::operator=(const TChar& aChar)
sl@0: /**
sl@0: Assigns the specified character object to this 'character to lower case'
sl@0: object.
sl@0: 
sl@0: @param aChar The character object to assign.
sl@0: 
sl@0: @return A reference to this 'character to lower case' object.
sl@0: */
sl@0: 	{SetChar(User::LowerCase(aChar));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TCharUC
sl@0: inline TCharUC::TCharUC(TUint aChar)
sl@0: 	: TChar(User::UpperCase(aChar))
sl@0: /**
sl@0: Constructs this 'character to upper case' object and initialises it with the 
sl@0: specified value.
sl@0: 
sl@0: @param aChar The initialisation value.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharUC::TCharUC(const TChar& aChar)
sl@0: 	: TChar(User::UpperCase(aChar))
sl@0: /**
sl@0: Constructs this 'character to upper case' object and initialises it with the 
sl@0: value of the TChar object aChar.
sl@0: 
sl@0: @param aChar The character object to use as the initialisation value.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharUC& TCharUC::operator=(TUint aChar)
sl@0: /**
sl@0: Assigns an unsigned integer value to the 'character to upper case'  object.
sl@0: 
sl@0: @param aChar The value to assign.
sl@0: 
sl@0: @return A reference to this 'character to upper case'  object.
sl@0: */
sl@0: 	{SetChar(User::UpperCase(aChar));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TCharUC& TCharUC::operator=(const TChar& aChar)
sl@0: /**
sl@0: Assigns the specified character object to this 'character to upper case' 
sl@0: object.
sl@0: 
sl@0: @param aChar The character object to assign.
sl@0: 
sl@0: @return A reference to this 'character to upper case'  object.
sl@0: */
sl@0: 	{SetChar(User::UpperCase(aChar));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TDateTime
sl@0: inline TDateTime::TDateTime()
sl@0: 	: iYear(1980),
sl@0: 	  iMonth(EJanuary), 
sl@0: 	  iDay(1),
sl@0: 	  iHour(0),
sl@0: 	  iMinute(0),
sl@0: 	  iSecond(0),
sl@0: 	  iMicroSecond(0)
sl@0: /**
sl@0: Constructs an uninitialised TDateTime object.
sl@0: */
sl@0: 	{}           
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TDateTime::Year() const
sl@0: /**
sl@0: Gets the year component of the date/time.
sl@0: 
sl@0: A negative value indicates a BC date.
sl@0: 
sl@0: @return The year
sl@0: */
sl@0: 	{return(iYear);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TMonth TDateTime::Month() const
sl@0: /**
sl@0: Gets the month component of the date/time.
sl@0: 
sl@0: @return The month. EJanuary to EDecember. Offset from zero, so add one before 
sl@0:         displaying the month number.
sl@0: */
sl@0: 	{return(iMonth);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TDateTime::Day() const
sl@0: /**
sl@0: Gets the day component of the date/time.
sl@0: 
sl@0: @return The day. Offset from zero, so add one before displaying the day number.
sl@0: */
sl@0: 	{return(iDay);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TDateTime::Hour() const
sl@0: /**
sl@0: Gets the hour component of the date/time.
sl@0: 
sl@0: @return The hour.
sl@0: */
sl@0: 	{return(iHour);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TDateTime::Minute() const
sl@0: /**
sl@0: Gets the minute component of the date/time.
sl@0: 
sl@0: @return The minute.
sl@0: */
sl@0: 	{return(iMinute);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TDateTime::Second() const
sl@0: /**
sl@0: Gets the second component of the date/time.
sl@0: 
sl@0: @return The second.
sl@0: */
sl@0: 	{return(iSecond);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TDateTime::MicroSecond() const
sl@0: /**
sl@0: Gets the microsecond component of the date/time.
sl@0: 
sl@0: @return The microsecond.
sl@0: */
sl@0: 	{return(iMicroSecond);}
sl@0: 
sl@0: // Class TTimeIntervalMicroSeconds
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds(const TInt64& aInterval)
sl@0: 	: iInterval(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified 64-bit interval value.
sl@0: 
sl@0: @param aInterval The 64-bit interval value with which the object is to be
sl@0:                  initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMicroSeconds& TTimeIntervalMicroSeconds::operator=(const TInt64& aInterval)
sl@0: /**
sl@0: Assigns a 64-bit integer value to this object.
sl@0: 
sl@0: @param aInterval The 64-bit integer interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalMicroSeconds::operator==(const TTimeIntervalMicroSeconds& aInterval) const
sl@0: /**
sl@0: Tests whether this TTimeIntervalMicroSeconds object is equal to the
sl@0: specified TTimeIntervalMicroSeconds object.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if the two time intervals are equal. False otherwise.
sl@0: */
sl@0: 	{return(iInterval==aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalMicroSeconds::operator!=(const TTimeIntervalMicroSeconds& aInterval) const
sl@0: /**
sl@0: Tests whether this TTimeIntervalMicroSeconds object is not equal to the
sl@0: specified TTimeIntervalMicroSeconds object.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if the two time intervals are not equal. False otherwise.
sl@0: */
sl@0: 	{return(iInterval!=aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalMicroSeconds::operator>=(const TTimeIntervalMicroSeconds& aInterval) const
sl@0: /**
sl@0: Tests whether this TTimeIntervalMicroSeconds object is greater than or equal to the
sl@0: specified TTimeIntervalMicroSeconds object.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is greater than or equal to the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval>=aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalMicroSeconds::operator<=(const TTimeIntervalMicroSeconds& aInterval) const
sl@0: /**
sl@0: Tests whether this TTimeIntervalMicroSeconds object is less than or equal to the
sl@0: specified TTimeIntervalMicroSeconds object.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is less than or equal to the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval<=aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalMicroSeconds::operator>(const TTimeIntervalMicroSeconds& aInterval) const
sl@0: /**
sl@0: Tests whether this TTimeIntervalMicroSeconds object is greater than the
sl@0: specified TTimeIntervalMicroSeconds object.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is greater than the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval>aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalMicroSeconds::operator<(const TTimeIntervalMicroSeconds& aInterval) const
sl@0: /**
sl@0: Tests whether this TTimeIntervalMicroSeconds object is less than the
sl@0: specified TTimeIntervalMicroSeconds object.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is less than the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval<aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline const TInt64& TTimeIntervalMicroSeconds::Int64() const
sl@0: /**
sl@0: Gets the time interval as a 64-bit integer value.
sl@0: 
sl@0: @return This 64-bit integer time interval value.
sl@0: */
sl@0: 	{return(iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalBase
sl@0: inline TTimeIntervalBase::TTimeIntervalBase()
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalBase::TTimeIntervalBase(TInt aInterval)
sl@0: 	: iInterval(aInterval)
sl@0: /**
sl@0: Constructor taking an interval value.
sl@0: 
sl@0: @param aInterval The interval value.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalBase::operator==(TTimeIntervalBase aInterval) const
sl@0: /**
sl@0: Tests whether this time interval is the same as the specified time interval.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if the two time intervals are equal. False otherwise.
sl@0: */
sl@0: 	{return(iInterval==aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalBase::operator!=(TTimeIntervalBase aInterval) const
sl@0: /**
sl@0: Tests whether this time interval is not the same as the specified
sl@0: time interval.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if the two time intervals differ. False otherwise.
sl@0: */
sl@0: 	{return(iInterval!=aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalBase::operator>=(TTimeIntervalBase aInterval) const
sl@0: /**
sl@0: Tests whether this time interval is greater than or equal to the
sl@0: specified time interval.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is greater than or equal to the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval>=aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalBase::operator<=(TTimeIntervalBase aInterval) const
sl@0: /**
sl@0: Tests whether this time interval is less than or equal to the
sl@0: specified time interval.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is less than or equal to the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval<=aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalBase::operator>(TTimeIntervalBase aInterval) const
sl@0: /**
sl@0: Tests whether this time interval is greater than the specified time interval.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is greater than the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval>aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTimeIntervalBase::operator<(TTimeIntervalBase aInterval) const
sl@0: /**
sl@0: Tests whether this time interval is less than the specified time interval.
sl@0: 
sl@0: @param aInterval The time interval to be compared with this time interval.
sl@0: 
sl@0: @return True if this time interval is less than the specified
sl@0:         time interval. False otherwise.
sl@0: */
sl@0: 	{return(iInterval<aInterval.iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TTimeIntervalBase::Int() const
sl@0: /** 
sl@0: Gets the time interval as a 32 bit integer.
sl@0: 
sl@0: @return The time interval as a 32 bit integer.
sl@0: */
sl@0: 	{return(iInterval);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalMicroSeconds32
sl@0: inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32(TInt aInterval)
sl@0:     : TTimeIntervalBase(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified interval value.
sl@0: 
sl@0: @param aInterval The interval value with which the object is to be initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMicroSeconds32& TTimeIntervalMicroSeconds32::operator=(TInt aInterval)
sl@0: /**
sl@0: Assigns a value to this object.
sl@0: 
sl@0: @param aInterval The interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalSeconds
sl@0: inline TTimeIntervalSeconds::TTimeIntervalSeconds()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalSeconds::TTimeIntervalSeconds(TInt aInterval)
sl@0: 	: TTimeIntervalBase(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified interval value.
sl@0: 
sl@0: @param aInterval The interval value with which the object is to be initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalSeconds& TTimeIntervalSeconds::operator=(TInt aInterval)
sl@0: /**
sl@0: Assigns a value to this object.
sl@0: 
sl@0: @param aInterval The interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalMinutes
sl@0: inline TTimeIntervalMinutes::TTimeIntervalMinutes()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMinutes::TTimeIntervalMinutes(TInt aInterval)
sl@0: 	: TTimeIntervalBase(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified interval value.
sl@0: 
sl@0: @param aInterval The interval value with which the object is to be initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMinutes& TTimeIntervalMinutes::operator=(TInt aInterval)
sl@0: /**
sl@0: Assigns a value to this object.
sl@0: 
sl@0: @param aInterval The interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalHours
sl@0: inline TTimeIntervalHours::TTimeIntervalHours()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: inline TTimeIntervalHours::TTimeIntervalHours(TInt aInterval)
sl@0: 	: TTimeIntervalBase(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified interval value.
sl@0: 
sl@0: @param aInterval The interval value with which the object is to be initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalHours& TTimeIntervalHours::operator=(TInt aInterval)
sl@0: /**
sl@0: Assigns a value to this object.
sl@0: 
sl@0: @param aInterval The interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalDays
sl@0: inline TTimeIntervalDays::TTimeIntervalDays()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalDays::TTimeIntervalDays(TInt aInterval)
sl@0: 	: TTimeIntervalBase(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified interval value.
sl@0: 
sl@0: @param aInterval The interval value with which the object is to be initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalDays& TTimeIntervalDays::operator=(TInt aInterval)
sl@0: /**
sl@0: Assigns a value to this object.
sl@0: 
sl@0: @param aInterval The interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalMonths
sl@0: inline TTimeIntervalMonths::TTimeIntervalMonths()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMonths::TTimeIntervalMonths(TInt aInterval)
sl@0: 	: TTimeIntervalBase(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified interval value.
sl@0: 
sl@0: @param aInterval The interval value with which the object is to be initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalMonths& TTimeIntervalMonths::operator=(TInt aInterval)
sl@0: /**
sl@0: Assigns a value to this object.
sl@0: 
sl@0: @param aInterval The interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTimeIntervalYears
sl@0: inline TTimeIntervalYears::TTimeIntervalYears()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalYears::TTimeIntervalYears(TInt aInterval)
sl@0: 	: TTimeIntervalBase(aInterval)
sl@0: /**
sl@0: Constructs the object with the specified interval value.
sl@0: 
sl@0: @param aInterval The interval value with which the object is to be initialised.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalYears& TTimeIntervalYears::operator=(TInt aInterval)
sl@0: /**
sl@0: Assigns a value to this object.
sl@0: 
sl@0: @param aInterval The interval value to be assigned.
sl@0: 
sl@0: @return A reference to this object.
sl@0: */
sl@0: 	{iInterval=aInterval;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TTime
sl@0: inline TTime::TTime()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: The object is initialised to an arbitrary value.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTime::TTime(const TInt64& aTime)
sl@0: 	: iTime(aTime)
sl@0: /**
sl@0: Constructs the object from a 64-bit microsecond value.
sl@0: 
sl@0: @param aTime Microsecond value to which to initialise the TTime object.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTime &TTime::operator=(const TInt64& aTime)
sl@0: /**
sl@0: Assigns a value contained in a 64-bit integer to this TTime object.
sl@0: 
sl@0: @param aTime Microsecond value which to assign to the TTime object.
sl@0: 
sl@0: @return This TTime object.
sl@0: */
sl@0: 	{iTime=aTime;return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTime::operator==(TTime aTime) const
sl@0: /**
sl@0: Tests whether two date/times are equal.
sl@0: 
sl@0: @param aTime The time to be compared with this TTime.
sl@0: 
sl@0: @return True if the two TTimes are equal. False if not.
sl@0: */
sl@0: 	{return(iTime==aTime.iTime);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTime::operator!=(TTime aTime) const
sl@0: /**
sl@0: Tests whether two date/times are not equal.
sl@0: 
sl@0: @param aTime The date/time to be compared with this TTime.
sl@0: 
sl@0: @return True if the two TTimes are different. False if the same.
sl@0: */
sl@0: 	{return(iTime!=aTime.iTime);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTime::operator>=(TTime aTime) const
sl@0: /**
sl@0: Tests whether this date/time is later than or the same as the
sl@0: specified date/time.
sl@0: 
sl@0: @param aTime The date/time to be compared with this date/time.
sl@0: 
sl@0: @return True if this date/time is later than or the same as the
sl@0:         specified date/time. False otherwise.
sl@0: */
sl@0: 	{return(iTime>=aTime.iTime);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTime::operator<=(TTime aTime) const
sl@0: /**
sl@0: Tests whether this date/time is earlier than or the same as the
sl@0: specified date/time.
sl@0: 
sl@0: @param aTime The date/time to be compared with this date/time.
sl@0: 
sl@0: @return True if this date/time is earlier than or the same as the
sl@0:         specified date/time. False otherwise.
sl@0: */
sl@0: 	{return(iTime<=aTime.iTime);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTime::operator>(TTime aTime) const
sl@0: /**
sl@0: Tests whether this date/time is later than the specified date/time.
sl@0: 
sl@0: @param aTime The date/time to be compared with this date/time.
sl@0: 
sl@0: @return True if this date/time is later than the specified date/time.
sl@0:         False otherwise.
sl@0: */
sl@0: 	{return(iTime>aTime.iTime);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TTime::operator<(TTime aTime) const
sl@0: /**
sl@0: Tests whether this date/time is earlier than the specified date/time.
sl@0: 
sl@0: @param aTime The date/time to be compared with this date/time.
sl@0: 
sl@0: @return True if this date/time is earlier than the specified date/time.
sl@0:         False otherwise.
sl@0: */
sl@0: 	{return(iTime<aTime.iTime);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline const TInt64& TTime::Int64() const
sl@0: /**
sl@0: Gets the 64 bit integer representation of this TTime obect.
sl@0: 
sl@0: @return The 64 bit integer representation.
sl@0: */
sl@0: 	{return(iTime);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TLexMark8
sl@0: inline TLexMark8::TLexMark8()
sl@0: 	: iPtr(NULL)
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLexMark8::TLexMark8(const TUint8 *aString) 
sl@0: 	: iPtr(aString)
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TLex8
sl@0: inline TLex8::TLex8(const TUint8 *aString)
sl@0: /**
sl@0: Constructs the object with a pointer to a string.
sl@0: 
sl@0: The extraction mark and next character members are initialised to point
sl@0: to the start of the string.
sl@0: 
sl@0: @param aString String to be assigned.
sl@0: */
sl@0: 	{Assign(TPtrC8(aString));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLex8::TLex8(const TDesC8 &aDes)
sl@0: /**
sl@0: Constructs the object with a descriptor.
sl@0: 
sl@0: The extraction mark and next character 
sl@0: members are initialised to point to the start of the string.
sl@0: 
sl@0: @param aDes Descriptor to be assigned by reference.
sl@0: */
sl@0: 	{Assign(aDes);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLex8& TLex8::operator=(const TUint8* aString)
sl@0: /**
sl@0: Allows strings to be assigned to a TLex8.
sl@0: 
sl@0: @param aString String to be assigned to the TLex8. 
sl@0: 
sl@0: @return TLex8 descriptor.
sl@0: */
sl@0: 	{Assign(TPtrC8(aString));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLex8& TLex8::operator=(const TDesC8& aBuf)
sl@0: /**
sl@0: Allows descriptors to be assigned to a TLex8.
sl@0: 
sl@0: @param aBuf Descriptor to be assigned to the TLex8.
sl@0: 
sl@0: @return TLex8 descriptor.
sl@0: */
sl@0: 	{Assign(aBuf);return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLex8::Eos() const
sl@0: /**
sl@0: Tests whether the next character position is at the end of the string.
sl@0: 
sl@0: @return True if at end of string, false otherwise.
sl@0: */
sl@0: 	{return(iNext==iEnd);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex8::Mark()
sl@0: /**
sl@0: Sets the TLex8's next character position to its extraction mark.
sl@0: */
sl@0: 	{Mark(iMark);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex8::Mark(TLexMark8& aMark) const
sl@0: /**
sl@0: Sets the supplied extraction mark to the TLex8's next character position.
sl@0: 
sl@0: @param aMark On return, this is set to the next character position.
sl@0: */
sl@0: 	{aMark.iPtr=iNext;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex8::UnGetToMark()
sl@0: /**
sl@0: Sets the next character position to the current extraction mark position.
sl@0: 
sl@0: @panic USER 63, if the extraction mark is before the start or beyond the end
sl@0:        of the string.
sl@0: */
sl@0:     {UnGetToMark(iMark);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex8::SkipAndMark(TInt aNumber)
sl@0: /**
sl@0: Moves the next character position a specified number of characters. 
sl@0:   
sl@0: @param aNumber Number of characters to skip.
sl@0: 
sl@0: @panic USER 61, if the skip moves the next character position either to before
sl@0:        the start or beyond the end of the string.
sl@0: */
sl@0:     {SkipAndMark(aNumber,iMark);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex8::SkipSpaceAndMark()
sl@0: /**
sl@0: Moves the next character position past any white space and copies it to the 
sl@0: TLex8's extraction mark.
sl@0: 
sl@0: Stops if at the end of the string.
sl@0: */
sl@0:     {SkipSpaceAndMark(iMark);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex8::TokenLength() const
sl@0: /**
sl@0: Gets the length of the token.
sl@0: 
sl@0: This is the difference between the next character 
sl@0: position and the extraction mark.
sl@0: 
sl@0: @return Length of the token.
sl@0: */
sl@0: 	{return(iNext-iMark.iPtr);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex8::MarkedOffset() const
sl@0: /**
sl@0: Gets the offset of the extraction mark from the start of the string.
sl@0: 
sl@0: @return The offset of the extraction mark.
sl@0: */
sl@0:     {return(iMark.iPtr-iBuf);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex8::Val(TInt &aVal)
sl@0: /**
sl@0: Parses the string to extract a signed integer.
sl@0: 
sl@0: @param aVal On return, contains the extracted integer.
sl@0: 
sl@0: @return KErrNone if successful.
sl@0:         KErrGeneral if the next character position is initially at the end of the string
sl@0:         or no valid characters found initially.
sl@0:         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.
sl@0:         If error codes KErrGeneral or KErrOverflow are returned, the object's
sl@0:         members are left unaltered.
sl@0: */
sl@0: 	{return(Val((TInt32&)aVal));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex8::Val(TUint &aVal,TRadix aRadix)
sl@0: /**
sl@0: Parses the string to extract an unsigned integer, using the specified radix.
sl@0: 
sl@0: @param aVal   On return, contains the extracted integer.
sl@0: @param aRadix The radix to use when converting the number. The default radix
sl@0:               for this function overload is decimal.
sl@0: 
sl@0: @return KErrNone if successful.
sl@0:         KErrGeneral if the next character position is initially at the end of the string
sl@0:         or no valid characters found initially.
sl@0:         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.
sl@0:         If error codes KErrGeneral or KErrOverflow are returned, the object's
sl@0:         members are left unaltered.
sl@0: */
sl@0: 	{return(Val((TUint32&)aVal,aRadix));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex8::Assign(const TLex8& aLex)
sl@0: /**
sl@0: Assigns a string to this object from another TLex8 object.
sl@0: 
sl@0: @param aLex The object to be assigned.
sl@0: */
sl@0: 	{new(this) TLex8(aLex);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TLexMark16
sl@0: inline TLexMark16::TLexMark16()
sl@0: 	: iPtr(NULL)
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLexMark16::TLexMark16(const TUint16 *aString) 
sl@0: 	: iPtr(aString)
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TLex16
sl@0: inline TLex16::TLex16(const TUint16 *aString)
sl@0: /**
sl@0: Constructs the object with a pointer to a string.
sl@0: 
sl@0: The extraction mark and next character members are initialised to point
sl@0: to the start of the string.
sl@0: 
sl@0: @param aString String to be assigned.
sl@0: */
sl@0: 	{Assign(TPtrC16(aString));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLex16::TLex16(const TDesC16 &aDes)
sl@0: /**
sl@0: Constructs the object with a descriptor.
sl@0: 
sl@0: The extraction mark and next character 
sl@0: members are initialised to point to the start of the string.
sl@0: 
sl@0: @param aDes Descriptor to be assigned by reference.
sl@0: */
sl@0: 	{Assign(aDes);}
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLex16& TLex16::operator=(const TUint16* aString)
sl@0: /** 
sl@0: Allows strings to be assigned to a TLex16.
sl@0: 
sl@0: @param aString String to be assigned to the TLex16. 
sl@0: 
sl@0: @return TLex16 descriptor.
sl@0: */
sl@0: 	{Assign(TPtrC16(aString));return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLex16& TLex16::operator=(const TDesC16& aBuf)
sl@0: /**
sl@0: Allows descriptors to be assigned to a TLex16.
sl@0: 
sl@0: @param aBuf Descriptor to be assigned to the TLex16.
sl@0: 
sl@0: @return TLex8 descriptor.
sl@0: */
sl@0: 	{Assign(aBuf);return(*this);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLex16::Eos() const
sl@0: /**
sl@0: Tests whether the next character position is at the end of the string.
sl@0: 
sl@0: @return True if at end of string, false otherwise.
sl@0: */
sl@0: 	{return(iNext==iEnd);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex16::Mark(TLexMark16& aMark) const
sl@0: /**
sl@0: Sets the supplied extraction mark to the TLex16's next character position.
sl@0: 
sl@0: @param aMark On return, set to the next character position.
sl@0: */
sl@0: 	{aMark.iPtr=iNext;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex16::Mark()
sl@0: /**
sl@0: Sets the TLex16's next character position to its extraction mark.
sl@0: */
sl@0: 	{iMark.iPtr=iNext;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex16::UnGetToMark()
sl@0: /**
sl@0: Sets the next character position to the current extraction mark position.
sl@0: 
sl@0: @panic USER 68, if the specified mark is before the start or beyond the end
sl@0:        of the string.
sl@0: */
sl@0:     {UnGetToMark(iMark);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex16::SkipAndMark(TInt aNumber)
sl@0: /**
sl@0: Moves the next character position a specified number of characters.
sl@0: 
sl@0: @param aNumber Number of characters to skip. 
sl@0: 
sl@0: @panic USER 68, if the skip moves the next character position either to before
sl@0:        the start or beyond the end of the string.
sl@0: */
sl@0:     {SkipAndMark(aNumber,iMark);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex16::SkipSpaceAndMark()
sl@0: /**
sl@0: Moves the next character position past any white space and copies it to the 
sl@0: TLex16's extraction mark.
sl@0: 
sl@0: Stops if at the end of the string.
sl@0: */
sl@0:     {SkipSpaceAndMark(iMark);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex16::TokenLength() const
sl@0: /**
sl@0: Gets the length of the token.
sl@0: 
sl@0: This is the difference between the next character 
sl@0: position and the extraction mark.
sl@0: 
sl@0: @return Length of the token.
sl@0: */
sl@0: 	{return(iNext-iMark.iPtr);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex16::MarkedOffset() const
sl@0: /**
sl@0: Gets the offset of the extraction mark from the start of the string.
sl@0: 
sl@0: @return The offset of the extraction mark.
sl@0: */
sl@0:     {return(iMark.iPtr-iBuf);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex16::Val(TInt &aVal)
sl@0: /**
sl@0: Parses the string to extract a signed integer.
sl@0: 
sl@0: @param aVal On return, contains the extracted integer.
sl@0: 
sl@0: @return KErrNone if successful.
sl@0:         KErrGeneral if the next character position is initially at the end of the string
sl@0:         or no valid characters found initially.
sl@0:         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.
sl@0:         If error codes KErrGeneral or KErrOverflow are returned, the object's
sl@0:         members are left unaltered.
sl@0: */
sl@0: 	{return(Val((TInt32&)aVal));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLex16::Val(TUint &aVal,TRadix aRadix)
sl@0: /**
sl@0: Parses the string to extract an unsigned integer, using the specified radix.
sl@0: 
sl@0: @param aVal   On return, contains the extracted integer.
sl@0: @param aRadix The radix to use when converting the number. The default radix
sl@0:               for this function overload is decimal.
sl@0: 
sl@0: @return KErrNone if successful.
sl@0:         KErrGeneral if the next character position is initially at the end of the string
sl@0:         or no valid characters found initially.
sl@0:         KErrOverflow if there is sign overflow, i.e. converted value greater than limit.
sl@0:         If error codes KErrGeneral or KErrOverflow are returned, the object's
sl@0:         members are left unaltered.
sl@0: */
sl@0: 	{return(Val((TUint32&)aVal,aRadix));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLex16::Assign(const TLex16& aLex)
sl@0: /**
sl@0: Assigns a string to this object from another TLex16 object.
sl@0: 
sl@0: @param aLex The object to be assigned.
sl@0: */
sl@0: 	{new(this) TLex16(aLex);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TLocale
sl@0: inline TLocale::TLocale(TInt)
sl@0: 	{}
sl@0: 
sl@0: inline TInt TLocale::RegionCode() const
sl@0: 	{return(iRegionCode);}
sl@0: inline TInt TLocale::CountryCode() const
sl@0: /**
sl@0: Gets the code which is used to select country-specific locale data.
sl@0: 
sl@0: The country code is the code used as the international dialling prefix.
sl@0: This code is also used to identify a country by the dialling software.
sl@0: 	
sl@0: @return The country code.
sl@0: */
sl@0: 	{return(iCountryCode);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetCountryCode(TInt aCode)
sl@0: /**
sl@0: Sets the value which is used to select country-specific locale data.
sl@0: 
sl@0: This value can be retrieved by using TLocale::CountryCode(). The country code
sl@0: is the code used as the international dialling prefix. This code is also used
sl@0: to identify a country by the dialling software.
sl@0: 	
sl@0: @param aCode The country code.
sl@0: 
sl@0: @see TLocale::CountryCode
sl@0: */
sl@0: 	{iCountryCode=aCode;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeIntervalSeconds TLocale::UniversalTimeOffset() const
sl@0: /**
sl@0: Gets the locale's universal time offset.
sl@0: 	
sl@0: @return Offset in seconds from universal time. Time zones east of universal 
sl@0: 	    time have positive offsets. Time zones west of universal time have negative 
sl@0: 	    offsets.
sl@0: 
sl@0: @deprecated Use User::UTCOffset to get the current offset inclusive of daylight
sl@0: 			savings time. This function returns the same value, for compatibility.
sl@0: */
sl@0: 	{return(iUniversalTimeOffset);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TDateFormat TLocale::DateFormat() const
sl@0: /**
sl@0: Gets the date format.
sl@0: 	
sl@0: @return The date format.
sl@0: */
sl@0: 	{return(iDateFormat);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetDateFormat(TDateFormat aFormat)
sl@0: /**
sl@0: Sets the date format.
sl@0: 	
sl@0: @param aFormat The date format to be used.
sl@0: */
sl@0: 	{iDateFormat=aFormat;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TTimeFormat TLocale::TimeFormat() const
sl@0: /**
sl@0: Gets the time format (12 or 24 hour).
sl@0: 	
sl@0: @return The time format.
sl@0: */
sl@0: 	{return(iTimeFormat);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetTimeFormat(TTimeFormat aFormat)
sl@0: /**
sl@0: Sets the time format (12 or 24 hour).
sl@0: 	
sl@0: @param aFormat The time format.
sl@0: */
sl@0: 	{iTimeFormat=aFormat;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLocalePos TLocale::CurrencySymbolPosition() const
sl@0: /**
sl@0: Gets the currency symbol position.
sl@0: 	
sl@0: For negative currency values, this position may be
sl@0: reversed using SetNegativeCurrencySymbolOpposite().
sl@0: 	
sl@0: @return The currency symbol position.
sl@0: 
sl@0: @see TLocale::SetNegativeCurrencySymbolOpposite
sl@0: */
sl@0: 	{return(iCurrencySymbolPosition);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetCurrencySymbolPosition(TLocalePos aPos)
sl@0: /**
sl@0: Sets the currency symbol position.
sl@0: 	
sl@0: @param aPos The currency symbol position.
sl@0: */
sl@0: 	{iCurrencySymbolPosition=aPos;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLocale::CurrencySpaceBetween() const
sl@0: /**
sl@0: Gets whether or not a space is inserted between the currency symbol and the 
sl@0: currency value.
sl@0: 	
sl@0: For negative currency values, the space can be removed using SetNegativeLoseSpace().
sl@0: 	
sl@0: @return True if a space is inserted; false if not.
sl@0: 
sl@0: @see TLocale::SetNegativeLoseSpace
sl@0: */
sl@0: 	{return(iCurrencySpaceBetween);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetCurrencySpaceBetween(TBool aSpace)
sl@0: /**
sl@0: Sets whether a space is inserted between the currency symbol and the currency 
sl@0: amount.
sl@0: 	
sl@0: @param aSpace ETrue if a space is inserted; EFalse if not.
sl@0: */
sl@0: 	{iCurrencySpaceBetween=aSpace;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TLocale::CurrencyDecimalPlaces() const
sl@0: /**
sl@0: Gets the number of decimal places to which currency values are set.
sl@0: 	
sl@0: @return The number of decimal places.
sl@0: */
sl@0: 	{return(iCurrencyDecimalPlaces);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetCurrencyDecimalPlaces(TInt aPlaces)
sl@0: /**
sl@0: Sets the number of decimal places to which currency values should be set.
sl@0: 	
sl@0: @param aPlaces The number of decimal places.
sl@0: */
sl@0: 	{iCurrencyDecimalPlaces=aPlaces;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLocale::CurrencyNegativeInBrackets() const
sl@0: /**
sl@0: @deprecated
sl@0: 
sl@0: Gets whether negative currency values are enclosed in brackets rather than 
sl@0: being preceded by a minus sign. 
sl@0: 	
sl@0: This is deprecated, use NegativeCurrencyFormat() instead.
sl@0: 	
sl@0: @return True if negative currency is enclosed in brackets and has no minus 
sl@0:         sign; false if negative currency has a minus sign and is not enclosed
sl@0: 		in brackets.
sl@0: 
sl@0: @see TLocale::NegativeCurrencyFormat
sl@0: */
sl@0: 	{return((TBool)iNegativeCurrencyFormat);}			
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetCurrencyNegativeInBrackets(TBool aBool)
sl@0: /** 
sl@0: @deprecated
sl@0: 
sl@0: Sets whether negative currency values are enclosed in brackets rather than
sl@0: being preceded by a minus sign.
sl@0: 	
sl@0: This is deprecated, use SetNegativeCurrencyFormat() instead.
sl@0: 	
sl@0: @param aBool ETrue, if a negative currency value must be enclosed in brackets 
sl@0: 	         without a minus sign; EFalse, if a negative currency value is
sl@0: 			 preceded by a minus sign without any enclosing brackets.
sl@0: 
sl@0: @see TLocale::SetNegativeCurrencyFormat
sl@0: */
sl@0: 	{iNegativeCurrencyFormat=(aBool)?EInBrackets:ELeadingMinusSign;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLocale::CurrencyTriadsAllowed() const
sl@0: /**
sl@0: Gets whether triads are allowed in currency values. Triads are groups of 
sl@0: three digits separated by the thousands separator.
sl@0: 	
sl@0: @return True if triads are allowed; false if not.
sl@0: */
sl@0: 	{return(iCurrencyTriadsAllowed);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetCurrencyTriadsAllowed(TBool aBool)
sl@0: /**
sl@0: Sets whether triads are allowed in currency values.
sl@0: 	
sl@0: @param aBool ETrue if triads are allowed; EFalse if triads not allowed.
sl@0: */
sl@0: 	{iCurrencyTriadsAllowed=aBool;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TChar TLocale::ThousandsSeparator() const
sl@0: /**
sl@0: Gets the character used to separate groups of three digits to the left of 
sl@0: the decimal separator.
sl@0: 	
sl@0: A thousands separator character is only displayed in currency values if currency 
sl@0: triads are allowed.
sl@0: 	
sl@0: @return The character used as the thousands separator.
sl@0: */
sl@0: 	{return(iThousandsSeparator);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetThousandsSeparator(const TChar& aChar)
sl@0: /**
sl@0: Sets the character to be used to separate groups of three digits to the left 
sl@0: of the decimal separator.
sl@0: 	
sl@0: A thousands separator character is only displayed in currency values if currency 
sl@0: triads are allowed.
sl@0: 	
sl@0: @param aChar The character to be used as the thousands separator.
sl@0: */
sl@0: 	{iThousandsSeparator=aChar;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TChar TLocale::DecimalSeparator() const
sl@0: /**
sl@0: Gets the character used to separate a whole number from its fractional part.
sl@0: 	
sl@0: @return The character used as the decimal separator.
sl@0: */
sl@0: 	{return(iDecimalSeparator);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetDecimalSeparator(const TChar& aChar)
sl@0: /**
sl@0: Sets the character to be used to separate a whole number from its fractional 
sl@0: part.
sl@0: 	
sl@0: @param aChar The character to be used as the decimal separator.
sl@0: */
sl@0: 	{iDecimalSeparator=aChar;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TChar TLocale::DateSeparator(TInt aIndex) const
sl@0: /**
sl@0: Gets one of the four characters used to separate the day, month and year 
sl@0: components of the date.
sl@0: 	
sl@0: If the four separators are represented by S0, S1, S2 and S3 and the three 
sl@0: date components are represented by XX, YY and ZZ, then the separators are 
sl@0: located: S0 XX S1 YY S2 ZZ S3.
sl@0: 	
sl@0: @param aIndex An index indicating which of the four separators is being accessed. 
sl@0:               This must be a value between zero and three inclusive.
sl@0: 
sl@0: @return A date separator character as determined by the value of aIndex.
sl@0: */
sl@0: 	{return(iDateSeparator[aIndex]);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetDateSeparator(const TChar& aChar,TInt aIndex)
sl@0: /**
sl@0: Sets one of the four characters used to separate the day, month and year
sl@0: components of the date.
sl@0: 	
sl@0: If the four separators are represented by S0, S1, S2 and S3 and the three 
sl@0: date components are represented by XX, YY and ZZ, then the separators are 
sl@0: located: S0 XX S1 YY S2 ZZ S3.
sl@0: 	
sl@0: @param aChar  A date separator character to be used.
sl@0: @param aIndex An index indicating which of the four separators is being accessed. 
sl@0: 	          This must be a value between zero and three inclusive.
sl@0: */
sl@0: 	{__ASSERT_DEBUG(aIndex>=0 && aIndex<KMaxDateSeparators,User::Invariant());
sl@0: 	iDateSeparator[aIndex]=aChar;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TChar TLocale::TimeSeparator(TInt aIndex) const
sl@0: /**
sl@0: Gets one of the four characters used to separate the hour, second and minute 
sl@0: components of the time.
sl@0: 	
sl@0: If the four separators are represented by S0, S1, S2 and S3 and the three 
sl@0: time components are represented by XX, YY and ZZ, then the separators are 
sl@0: located: S0 XX S1 YY S2 ZZ S3.
sl@0: 	
sl@0: @param aIndex An index indicating which of the four separators is being
sl@0:               accessed. This must be a value between zero and three inclusive.
sl@0: 
sl@0: @return A time separator character as determined by the value of aIndex.
sl@0: */
sl@0: 
sl@0: 	{return(iTimeSeparator[aIndex]);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetTimeSeparator(const TChar& aChar,TInt aIndex)
sl@0: /**
sl@0: Sets one of the four characters used to separate the hour, minute and second 
sl@0: components of the date.
sl@0: 	
sl@0: If the four separators are represented by S0, S1, S2 and S3 and the three 
sl@0: time components are represented by XX, YY and ZZ, then the separators are 
sl@0: located: S0 XX S1 YY S2 ZZ S3.
sl@0: 	
sl@0: @param aChar  A time separator character to be used.
sl@0: @param aIndex An index indicating which of the four separators is being accessed. 
sl@0: 	          This must be a value between zero and three inclusive.
sl@0: */
sl@0: 	{__ASSERT_DEBUG(aIndex>=0 && aIndex<KMaxTimeSeparators,User::Invariant());
sl@0: 	iTimeSeparator[aIndex]=aChar;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLocalePos TLocale::AmPmSymbolPosition() const
sl@0: /**
sl@0: Gets the am/pm text position (before or after the time value).
sl@0: 
sl@0: @return The am/pm text position (0 before, 1 after).
sl@0: */
sl@0: 	{return(iAmPmSymbolPosition);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetAmPmSymbolPosition(TLocalePos aPos)
sl@0: /**
sl@0: Sets the am/pm text position (before or after the time value).
sl@0: 	
sl@0: @param aSpace The am/pm text position (0 before, 1 after).
sl@0: */
sl@0: 	{iAmPmSymbolPosition=aPos;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLocale::AmPmSpaceBetween() const
sl@0: /**
sl@0: Tests whether or not a space is inserted between the time and the preceding 
sl@0: or trailing am/pm text.
sl@0: 	
sl@0: @return True if a space is inserted between the time and am/pm text; false 
sl@0:         if not.
sl@0: */
sl@0: 	{return(iAmPmSpaceBetween);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetAmPmSpaceBetween(TBool aSpace)
sl@0: /**
sl@0: Sets whether a space is inserted between the time and the preceding or trailing 
sl@0: am/pm text.
sl@0: 	
sl@0: @param aPos ETrue if a space is inserted between the time and am/pm text; 
sl@0:             EFalse otherwise.
sl@0: */
sl@0: 	{iAmPmSpaceBetween=aSpace;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TUint TLocale::DaylightSaving() const
sl@0: /**
sl@0: Gets the zones in which daylight saving is in effect.
sl@0: 	
sl@0: If daylight saving is in effect, one hour is added to the time.
sl@0: 	
sl@0: Use TLocale::QueryHomeHasDaylightSavingOn() to find out whether daylight saving 
sl@0: is in effect for the home city. This is because the daylight saving setting 
sl@0: for the home city may differ from that of the zone in which home is located.
sl@0: 	
sl@0: @return A bit mask in which the three least significant bits are defined, 
sl@0:         indicating which of the three daylight saving zones are adjusted for
sl@0: 		daylight saving. These bits represent:
sl@0: 		Northern (non-European countries in the northern hemisphere),
sl@0: 		Southern (southern hemisphere),
sl@0: 		and European.
sl@0: 
sl@0: @see TLocale::QueryHomeHasDaylightSavingOn
sl@0: @see TDaylightSavingZone
sl@0: 
sl@0: @deprecated Use the timezone server to retrieve information on timezones and DST.
sl@0: 			This method will always indicate that DST is inactive, in order to
sl@0: 			preserve compatibility.
sl@0: */
sl@0: 	{return(iDaylightSaving);} 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLocale::QueryHomeHasDaylightSavingOn() const
sl@0: /**
sl@0: Tests whether or not daylight saving is set for the home city.
sl@0: 	
sl@0: @return True if home daylight saving is set; false if not.
sl@0: 
sl@0: @deprecated Use the timezone server to retrieve information on timezones and DST.
sl@0: 			This method will always indicate that DST is inactive, in order to
sl@0: 			preserve compatibility.
sl@0: */
sl@0: 	{return((iHomeDaylightSavingZone|EDstHome) & iDaylightSaving);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TDaylightSavingZone TLocale::HomeDaylightSavingZone() const
sl@0: /**
sl@0: Gets the daylight saving zone in which the home city is located.
sl@0: 	
sl@0: @return The daylight saving zone in which the home city is located.
sl@0: 
sl@0: @deprecated Use the timezone server to retrieve information on timezones and DST.
sl@0: */
sl@0: 	{return(iHomeDaylightSavingZone);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TUint TLocale::WorkDays() const
sl@0: /**
sl@0: Gets a bit mask representing the days of the week which are considered as 
sl@0: working days.
sl@0: 	
sl@0: @return A bit mask of seven bits indicating (by being set) which days are 
sl@0:         workdays. The least significant bit corresponds to Monday, the next bit to 
sl@0: 	    Tuesday and so on.
sl@0: */
sl@0: 	{return(iWorkDays);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetWorkDays(TUint aMask)
sl@0: /**
sl@0: Sets the days of the week which are considered as working days.
sl@0: 	
sl@0: @param aMask A bit mask of seven bits indicating (by being set) which days 
sl@0:              are workdays. The least significant bit corresponds to Monday, the
sl@0: 			 next bit is Tuesday and so on.
sl@0: */
sl@0: 	{iWorkDays=aMask;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TDay TLocale::StartOfWeek() const
sl@0: /**
sl@0: Gets the day which is considered the first day of the week.
sl@0: 	
sl@0: @return The first day of the week.
sl@0: */
sl@0: 	{return(iStartOfWeek);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetStartOfWeek(TDay aDay)
sl@0: /**
sl@0: Sets the day which is considered to be the first day of the week.
sl@0: 	
sl@0: @param aDay The first day of the week.
sl@0: */
sl@0: 	{iStartOfWeek=aDay;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TClockFormat TLocale::ClockFormat() const
sl@0: /**
sl@0: Gets the clock display format.
sl@0: 	
sl@0: @return The clock display format.
sl@0: */
sl@0: 	{return(iClockFormat);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetClockFormat(TClockFormat aFormat)
sl@0: /**
sl@0: Sets the clock display format.
sl@0: 	
sl@0: @param aFormat The clock display format.
sl@0: */
sl@0: 	{iClockFormat=aFormat;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TUnitsFormat TLocale::UnitsGeneral() const
sl@0: /**
sl@0: Gets the general units of measurement.
sl@0: 
sl@0: This function should be used when both short and long distances use the
sl@0: same units of measurement.
sl@0: 	
sl@0: @return General units of measurement.
sl@0: */
sl@0: 	{return(iUnitsGeneral);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetUnitsGeneral(TUnitsFormat aFormat)
sl@0: /**
sl@0: Sets the general units of measurement.
sl@0: This function should be used when both short and long distances use the
sl@0: same units of measurement.
sl@0: 	
sl@0: @param aFormat General units of measurement.
sl@0: */
sl@0: 	{iUnitsGeneral=aFormat;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TUnitsFormat TLocale::UnitsDistanceShort() const
sl@0: /**
sl@0: Gets the units of measurement for short distances.
sl@0: 
sl@0: Short distances are those which would normally be represented by either
sl@0: metres and centimetres or feet and inches.
sl@0: 	
sl@0: @return Units of measurement for short distances.
sl@0: */
sl@0: 	{return(iUnitsDistanceShort);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetUnitsDistanceShort(TUnitsFormat aFormat)
sl@0: /**
sl@0: Sets the units of measurement for short distances.
sl@0: 
sl@0: Short distances are those which would normally be represented by either
sl@0: metres and centimetres or feet and inches.
sl@0: 	
sl@0: @param aFormat Units of measurement for short distances.
sl@0: */
sl@0: 	{iUnitsDistanceShort=aFormat;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TUnitsFormat TLocale::UnitsDistanceLong() const
sl@0: /**
sl@0: Gets the units of measurement for long distances.
sl@0: 
sl@0: Long distances are those which would normally be represented by either
sl@0: miles or kilometres.
sl@0: 	
sl@0: @return Units of measurement for long distances.
sl@0: */
sl@0: 	{return(iUnitsDistanceLong);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetUnitsDistanceLong(TUnitsFormat aFormat)
sl@0: /**
sl@0: Sets the units of measurement for long distances.
sl@0: 
sl@0: Long distances are those which would normally be represented by either
sl@0: miles or kilometres.
sl@0: 	
sl@0: @param aFormat Units of measurement for long distances.
sl@0: */
sl@0: 	{iUnitsDistanceLong=aFormat;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetNegativeCurrencyFormat(TLocale::TNegativeCurrencyFormat aNegativeCurrencyFormat)
sl@0: /**
sl@0: Sets the negative currency format.
sl@0: 	
sl@0: @param aNegativeCurrencyFormat How negative currency values are formatted.
sl@0: */
sl@0: 	{iNegativeCurrencyFormat = aNegativeCurrencyFormat;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLocale::TNegativeCurrencyFormat TLocale::NegativeCurrencyFormat() const
sl@0: /**
sl@0: Gets the negative currency format.
sl@0: 	
sl@0: @return How negative currency values are formatted.
sl@0: */
sl@0: 	{return(iNegativeCurrencyFormat);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLocale::NegativeLoseSpace() const
sl@0: /**
sl@0: Gets whether negative currency values lose the space between the currency 
sl@0: symbol and the value.
sl@0: 	
sl@0: @return True, if negative currency values lose the space between the value 
sl@0: 	    and the symbol; false, if not.
sl@0: */
sl@0: 	{ 
sl@0: 	if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeLoseSpace)==iExtraNegativeCurrencyFormatFlags)
sl@0: 		return ETrue;
sl@0: 	else
sl@0: 		return EFalse;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetNegativeLoseSpace(TBool aBool)
sl@0: /**
sl@0: Sets whether negative currency values lose the space between the currency symbol 
sl@0: and the value.
sl@0: 	
sl@0: @param aBool ETrue to set a flag which indicates that negative currency values 
sl@0: 	         should lose the space between the value and the symbol. EFalse to unset it.
sl@0: */
sl@0: 	{
sl@0: 	if(aBool)
sl@0: 		iExtraNegativeCurrencyFormatFlags |= EFlagNegativeLoseSpace;
sl@0: 	else
sl@0: 		iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeLoseSpace;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TLocale::NegativeCurrencySymbolOpposite() const
sl@0: /**
sl@0: Gets whether in negative currency values, the position of the currency symbol 
sl@0: is set to be the opposite of the position used for non-negative values (before 
sl@0: or after the value, as set by SetCurrencySymbolPosition()).
sl@0: 	
sl@0: @return True, if the currency symbol position for negative currency values 
sl@0: 	    is the opposite of the position set by SetCurrencySymbolPosition();
sl@0: 		false, otherwise.
sl@0: 
sl@0: @see TLocale::SetCurrencySymbolPosition
sl@0: */
sl@0: 	{
sl@0: 	if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeCurrencySymbolOpposite)==iExtraNegativeCurrencyFormatFlags)
sl@0: 		return ETrue;
sl@0: 	else
sl@0: 		return EFalse;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetNegativeCurrencySymbolOpposite(TBool aBool)
sl@0: /**
sl@0: Sets whether the position of the currency symbol for negative currency values 
sl@0: should be the opposite of the position used for non-negative values (before 
sl@0: or after the value, as set by SetCurrencySymbolPosition()).
sl@0: 	
sl@0: @param aBool ETrue to set the position of the currency symbol in negative 
sl@0:              currency values to be the opposite of the position as set
sl@0: 			 using SetCurrencySymbolPosition(). EFalse to leave the
sl@0: 			 position unchanged.
sl@0: 
sl@0: @see TLocale::SetCurrencySymbolPosition
sl@0: */
sl@0: 	{
sl@0: 	if (aBool)
sl@0: 		iExtraNegativeCurrencyFormatFlags |= EFlagNegativeCurrencySymbolOpposite;
sl@0: 	else
sl@0: 		iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeCurrencySymbolOpposite;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TLanguage TLocale::LanguageDowngrade(TInt aIndex) const
sl@0: /**
sl@0: Gets the language that is stored at the specified index into the customisable 
sl@0: part of the language downgrade path.
sl@0: 	
sl@0: The second, third and fourth languages in the language downgrade path can 
sl@0: be customised. These can be enquired using this function. The first language 
sl@0: in the path is always the language of the current locale, as returned by User::Language(). 
sl@0: 	
sl@0: The languages in the downgrade path are used in turn by the BaflUtils::NearestLanguageFile() 
sl@0: function to find the best matching language-specific version of a language-neutral 
sl@0: filename.
sl@0: 	
sl@0: The full language downgrade path can be retrieved using BaflUtils::GetDowngradePath().
sl@0: 	
sl@0: @param aIndex An index into the customisable part of the language downgrade 
sl@0:               path. Between zero and two inclusive.
sl@0: 
sl@0: @return The language at the specified index.
sl@0: 
sl@0: @see BaflUtils::NearestLanguageFile
sl@0: @see BaflUtils::GetDowngradePath
sl@0: */
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(0 <= aIndex && aIndex < 3, User::Invariant());
sl@0: 	return static_cast<TLanguage>(iLanguageDowngrade[aIndex]);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline void TLocale::SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage)
sl@0: /**
sl@0: Sets a language in the customisable part of the language downgrade path.
sl@0: 	
sl@0: @param aIndex    An index into the customisable part of the path at which to 
sl@0: 	             add the language, a value between zero and two.
sl@0: @param aLanguage The language to add. ELangNone is considered to be the last 
sl@0: 	             language in the path, no more will be searched, so can be used
sl@0: 				 to specify that no language downgrade is required.
sl@0: 
sl@0: @see BaflUtils::NearestLanguageFile
sl@0: @see BaflUtils::GetDowngradePath
sl@0: */
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(0 <= aIndex && aIndex < 3, User::Invariant());
sl@0: 	iLanguageDowngrade[aIndex] = static_cast<TUint16>(aLanguage);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Gets the number mode stored in the locale.
sl@0: 
sl@0: @return The number mode for the locale.
sl@0: */
sl@0: inline TDigitType TLocale::DigitType() const
sl@0: 	{ return iDigitType; }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the number mode for the locale. 
sl@0: 
sl@0: @param aDigitType The number mode to be set.
sl@0: */
sl@0: inline void TLocale::SetDigitType(TDigitType aDigitType)
sl@0: 	{ iDigitType=aDigitType; }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the device time state.
sl@0: 
sl@0: @param aState The device time state. 
sl@0: 
sl@0: @deprecated Use the timezone server to coordinate automatic time adjustment.
sl@0: */
sl@0: inline void TLocale::SetDeviceTime(TDeviceTimeState aState)
sl@0:    	{
sl@0:    	iDeviceTimeState=aState;
sl@0:    	}
sl@0:    
sl@0: 
sl@0: /**
sl@0: Get the pointer to the TLocale object contained in this extended locale.
sl@0: 
sl@0: @return Pointer to the TLocale object. 
sl@0: */
sl@0: inline TLocale*	TExtendedLocale::GetLocale()
sl@0: 	{ return &iLocale; }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Gets the device time state.
sl@0: 
sl@0: @return The device time state.
sl@0: 
sl@0: @deprecated Use the timezone server to coordinate automatic time adjustment.
sl@0: */
sl@0: inline TLocale::TDeviceTimeState TLocale::DeviceTime() const
sl@0:    	{
sl@0:    	return iDeviceTimeState;
sl@0:    	}
sl@0: 
sl@0: 
sl@0: // Class TFindSemaphore
sl@0: inline TFindSemaphore::TFindSemaphore()
sl@0:     : TFindHandleBase()
sl@0: /**
sl@0: Constructs the object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class, is the single 
sl@0: character "*".
sl@0: 
sl@0: A new match pattern can be set after construction by calling the Find() member 
sl@0: function of the TFindHandleBase base class.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TFindSemaphore::TFindSemaphore(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0: /**
sl@0: Constructs this object with the specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction by
sl@0: calling TFindHandleBase::Find().
sl@0: 
sl@0: Note that after construction, the object contains a copy of the supplied
sl@0: match pattern; the source descriptor can, therefore, be safely discarded.
sl@0: 
sl@0: @param aMatch A reference to the descriptor containing the match pattern. 
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TFindMutex
sl@0: inline TFindMutex::TFindMutex()
sl@0:     : TFindHandleBase()
sl@0: /**
sl@0: Constructs this object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class, is the single 
sl@0: character "*".
sl@0: 
sl@0: A new match pattern can be set after construction by calling the Find() member 
sl@0: function of the TFindHandleBase base class.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TFindMutex::TFindMutex(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0: /**
sl@0: Constructs this object with the specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction by calling the Find() member 
sl@0: function of the TFindHandleBase base class.
sl@0: 
sl@0: After construction, the object contains a copy of the supplied match pattern; 
sl@0: the source descriptor can, therefore, be safely discarded.
sl@0: 
sl@0: @param aMatch The match pattern.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TFindChunk
sl@0: inline TFindChunk::TFindChunk()
sl@0:     : TFindHandleBase()
sl@0: /**
sl@0: Constructs this object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class, is
sl@0: the single character "*".
sl@0: 
sl@0: A new match pattern can be set after construction by
sl@0: calling TFindHandleBase::Find().
sl@0: 
sl@0: @see TFindHandleBase
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TFindChunk::TFindChunk(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0: /**
sl@0: Constructs the object with the specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction by
sl@0: calling TFindHandleBase::Find().
sl@0: 
sl@0: @param aMatch The match pattern.
sl@0: 
sl@0: @see TFindHandleBase
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TFindThread
sl@0: inline TFindThread::TFindThread()
sl@0:     : TFindHandleBase()
sl@0: /**
sl@0: Constructs this object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class,
sl@0: is the single character *.
sl@0: 
sl@0: A new match pattern can be set after construction
sl@0: by calling TFindHandleBase::Find().
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TFindThread::TFindThread(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0: /**
sl@0: Constructs this object with the specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction
sl@0: by calling the TFindHandleBase::Find().
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TFindProcess
sl@0: inline TFindProcess::TFindProcess()
sl@0:     : TFindHandleBase()
sl@0: /**
sl@0: Constructs this object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class,
sl@0: is the single character *.
sl@0: 
sl@0: A new match pattern can be set after construction
sl@0: by calling TFindHandleBase::Find().
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TFindProcess::TFindProcess(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0: /**
sl@0: Constructs this object with the specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction
sl@0: by calling the TFindHandleBase::Find().
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TFindLogicalDevice
sl@0: /**
sl@0: Constructs the LDD factory object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class, is the single 
sl@0: character "*".
sl@0: 
sl@0: A new match pattern can be set after construction by calling the Find() member 
sl@0: function of the TFindHandleBase base class.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0: inline TFindLogicalDevice::TFindLogicalDevice()
sl@0:     : TFindHandleBase()
sl@0:     {}
sl@0: 
sl@0: /**
sl@0: Constructs the LDD factory object with a specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction by calling
sl@0: TFindHandleBase::Find().
sl@0: 
sl@0: @param aMatch The match pattern.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0: inline TFindLogicalDevice::TFindLogicalDevice(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0:     {}
sl@0: 
sl@0: // Class TFindPhysicalDevice
sl@0: /**
sl@0: Constructs the PDD factory object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class, is the single 
sl@0: character "*".
sl@0: 
sl@0: A new match pattern can be set after construction by calling the Find() member 
sl@0: function of the TFindHandleBase base class.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0: inline TFindPhysicalDevice::TFindPhysicalDevice()
sl@0:     : TFindHandleBase()
sl@0:     {}
sl@0: 
sl@0: /**
sl@0: Constructs the PDD factory object with a specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction by calling
sl@0: TFindHandleBase::Find().
sl@0: 
sl@0: @param aMatch The match pattern.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0: inline TFindPhysicalDevice::TFindPhysicalDevice(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TFindServer
sl@0: inline TFindServer::TFindServer()
sl@0:     : TFindHandleBase()
sl@0: /**
sl@0: Constructs the object with a default match pattern.
sl@0: 
sl@0: The default match pattern, as implemented by the base class, is the single 
sl@0: character "*".
sl@0: 
sl@0: A new match pattern can be set after construction by calling the Find() member 
sl@0: function of the TFindHandleBase base class.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TFindServer::TFindServer(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0: /**
sl@0: Constructs the object with a specified match pattern.
sl@0: 
sl@0: A new match pattern can be set after construction by calling
sl@0: TFindHandleBase::Find().
sl@0: 
sl@0: @param aMatch The match pattern.
sl@0: 
sl@0: @see TFindHandleBase::Find
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TFindLibrary
sl@0: inline TFindLibrary::TFindLibrary()
sl@0:     : TFindHandleBase()
sl@0: /**
sl@0: Constructs this object with a default match pattern.
sl@0: 
sl@0: The default match pattern is the single character ‘*’ and is implemented by
sl@0: the base class TFindHandleBase.
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TFindLibrary::TFindLibrary(const TDesC &aMatch)
sl@0:     : TFindHandleBase(aMatch)
sl@0: /**
sl@0: Constructs this object with the specified match pattern.
sl@0: 
sl@0: @param aMatch The descriptor containing the match pattern. 
sl@0: */
sl@0:     {}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RDevice
sl@0: /**
sl@0: Opens a handle to an LDD factory object found using a TFindLogicalDevice object.
sl@0: 
sl@0: A TFindLogicalDevice object is used to find all LDD factory objects whose full names match 
sl@0: a specified pattern.
sl@0: 
sl@0: @param aFind A reference to the object which is used to find the LDD factory object.
sl@0: @param aType An enumeration whose enumerators define the ownership of this 
sl@0:              LDD factory object handle. If not explicitly specified, EOwnerProcess is
sl@0: 			 taken as default.
sl@0: 
sl@0: @return KErrNone if successful, otherwise one of the other system wide error 
sl@0:         codes.
sl@0: */
sl@0: inline TInt RDevice::Open(const TFindLogicalDevice& aFind,TOwnerType aType)
sl@0: 	{return(RHandleBase::Open(aFind,aType));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RCriticalSection
sl@0: inline TBool RCriticalSection::IsBlocked() const
sl@0: /**
sl@0: Tests whether the critical section is occupied by any thread.
sl@0: 
sl@0: @return True, if the critical section is occupied by another thread. False, 
sl@0:         otherwise.
sl@0: */
sl@0: 	{return(iBlocked!=1);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RMutex
sl@0: inline TInt RMutex::Open(const TFindMutex& aFind,TOwnerType aType)
sl@0: /**
sl@0: Opens a handle to the global mutex found using a TFindMutex object.
sl@0: 
sl@0: A TFindMutex object is used to find all global mutexes whose full names match 
sl@0: a specified pattern.
sl@0: 
sl@0: By default, any thread in the process can use this instance of RMutex to access 
sl@0: the mutex. However, specifying EOwnerThread as the second parameter to this 
sl@0: function, means that only the opening thread can use this instance of RMutex 
sl@0: to access the mutex; any other thread in this process that wants to access 
sl@0: the mutex must either duplicate the handle or use OpenGlobal() again.
sl@0: 
sl@0: @param aFind A reference to the object which is used to find the mutex.
sl@0: @param aType An enumeration whose enumerators define the ownership of this 
sl@0:              mutex handle. If not explicitly specified, EOwnerProcess is
sl@0: 			 taken as default. 
sl@0: 
sl@0: @return KErrNone if successful, otherwise one of the other system wide error 
sl@0:         codes.
sl@0: */
sl@0: 	{return(RHandleBase::Open(aFind,aType));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RChunk
sl@0: inline TInt RChunk::Open(const TFindChunk& aFind,TOwnerType aType)
sl@0: /**
sl@0: Opens a handle to the global chunk found using a TFindChunk object.
sl@0: 
sl@0: A TFindChunk object is used to find all chunks whose full names match
sl@0: a specified pattern. 
sl@0: 
sl@0: By default, ownership of this chunk handle is vested in the current process, 
sl@0: but can be vested in the current thread by passing EOwnerThread as the second 
sl@0: parameter to this function.
sl@0: 
sl@0: @param aFind A reference to the TFindChunk object used to find the chunk.
sl@0: @param aType An enumeration whose enumerators define the ownership of this 
sl@0:              chunk handle. If not explicitly specified, EOwnerProcess is
sl@0: 			 taken as default.
sl@0: 
sl@0: @return KErrNone if successful, otherwise another of the system error codes.
sl@0: */
sl@0: 	{return(RHandleBase::Open(aFind,aType));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool RChunk::IsReadable() const
sl@0: /**
sl@0: Tests whether the chunk is mapped into its process address space.
sl@0: 
sl@0: @return True, if the chunk is readable; false, otherwise.
sl@0: */
sl@0: 	{return (Attributes()&RHandleBase::EDirectReadAccess); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool RChunk::IsWritable() const
sl@0: /**
sl@0: Tests whether the chunk mapped into its process address space and is writable.
sl@0: 
sl@0: @return True, if the chunk is writable; false, otherwise.
sl@0: */
sl@0: 	{return (Attributes()&RHandleBase::EDirectWriteAccess); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TObjectId
sl@0: inline TObjectId::TObjectId()
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TObjectId::TObjectId(TUint64 aId)
sl@0: 	: iId(aId)
sl@0: /**
sl@0: Constructor taking an unsigned integer value.
sl@0: 
sl@0: @param aId The value of the object id.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TUint64 TObjectId::Id() const
sl@0: /**
sl@0: Return the ID as a 64 bit integer
sl@0: */
sl@0: 	{ return iId; }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TObjectId::operator TUint() const
sl@0: /**
sl@0: Conversion operator invoked by the compiler when a TObjectId type is passed
sl@0: to a function that is prototyped to take a TUint type.
sl@0: 
sl@0: @see TUint
sl@0: */
sl@0: 	{ return TUint(iId); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TObjectId::operator==(TObjectId aId) const
sl@0: /**
sl@0: Tests whether this thread Id is equal to the specified Id.
sl@0: 
sl@0: @param aId The thread Id to be compared with this thread Id.
sl@0: 
sl@0: @return True, if the thread Ids are equal; false otherwise.
sl@0: */
sl@0: 	{return iId==aId.iId;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TBool TObjectId::operator!=(TObjectId aId) const
sl@0: /**
sl@0: Tests whether this thread Id is unequal to the specified thread Id.
sl@0: 
sl@0: @param aId The thread Id to be compared with this thread Id.
sl@0: 
sl@0: @return True, if the thread Ids are unequal; false otherwise.
sl@0: */
sl@0: 	{return iId!=aId.iId;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TThreadId
sl@0: inline TThreadId::TThreadId()
sl@0: 	: TObjectId()
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TThreadId::TThreadId(TUint64 aId)
sl@0: 	: TObjectId(aId)
sl@0: /**
sl@0: Constructor taking an unsigned integer value.
sl@0: 
sl@0: @param aId The value of the thread id.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RThread
sl@0: inline RThread::RThread()
sl@0: 	: RHandleBase(KCurrentThreadHandle)
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: The constructor exists to initialise private data within this handle; it does 
sl@0: not create the thread object.
sl@0: 
sl@0: Specifically, it sets the handle-number to the value KCurrentThreadHandle.
sl@0: In effect, the constructor creates a default thread handle.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt RThread::Open(const TFindThread& aFind,TOwnerType aType)
sl@0: /**
sl@0: Opens a handle to the thread found by pattern matching a name.
sl@0: 
sl@0: A TFindThread object is used to find all threads whose full names match a 
sl@0: specified pattern. 
sl@0: 
sl@0: By default, ownership of this thread handle is vested in the current process, 
sl@0: but can be vested in the current thread by passing EOwnerThread as the second 
sl@0: parameter to this function.
sl@0: 
sl@0: @param aFind A reference to the TFindThread object used to find the thread.
sl@0: @param aType An enumeration whose enumerators define the ownership of this 
sl@0:              thread handle. If not explicitly specified, EOwnerProcess is
sl@0: 			 taken as default.
sl@0: 
sl@0: @return KErrNone if successful, otherwise one of the other system-wide error codes.
sl@0: */
sl@0: 	{return(RHandleBase::Open(aFind,aType));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: inline TBool RThread::HasCapability(TCapability aCapability, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: inline TBool RThread::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: // Only available to NULL arguments
sl@0: inline TBool RThread::HasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability);
sl@0: 	}
sl@0: 
sl@0: inline TBool RThread::HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2);
sl@0: 	}
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: // For things using KSuppressPlatSecDiagnostic
sl@0: inline TBool RThread::HasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline TBool RThread::HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: 
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: // Class TProcessId
sl@0: inline TProcessId::TProcessId()
sl@0: 	: TObjectId()
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TProcessId::TProcessId(TUint64 aId)
sl@0: 	: TObjectId(aId)
sl@0: /**
sl@0: Constructor taking an unsigned integer value.
sl@0: 
sl@0: @param aId The value of the process id.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RProcess
sl@0: inline RProcess::RProcess()
sl@0: 	: RHandleBase(KCurrentProcessHandle)
sl@0: /** 
sl@0: Default constructor.
sl@0: 
sl@0: The constructor exists to initialise private data within this handle; it does 
sl@0: not create the process object.
sl@0: 
sl@0: Specifically, it sets the handle-number to the value KCurrentProcessHandle.
sl@0: In effect, the constructor creates a default process handle.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline RProcess::RProcess(TInt aHandle)
sl@0: 	: RHandleBase(aHandle)
sl@0: /**
sl@0: Constructor taking a handle number.
sl@0: 
sl@0: @param aHandle The handle number to be used to construct this RProcess handle.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt RProcess::Open(const TFindProcess& aFind,TOwnerType aType)
sl@0: /**
sl@0: Opens a handle to the process found by pattern matching a name.
sl@0: 
sl@0: A TFindProcess object is used to find all processes whose full names match 
sl@0: a specified pattern. 
sl@0: 
sl@0: By default, ownership of this process handle is vested in the current process, 
sl@0: but can be vested in the current thread by passing EOwnerThread as the second 
sl@0: parameter to this function.
sl@0: 
sl@0: @param aFind A reference to the TFindProcess object used to find the process.
sl@0: @param aType An enumeration whose enumerators define the ownership of this 
sl@0:              process handle. If not explicitly specified, EOwnerProcess is taken
sl@0: 			 as default.
sl@0: 
sl@0: @return KErrNone if successful, otherwise one of the other system-wide error codes.
sl@0: */
sl@0: 	{return(RHandleBase::Open(aFind,aType));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: inline TBool RProcess::HasCapability(TCapability aCapability, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: inline TBool RProcess::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: // Only available to NULL arguments
sl@0: inline TBool RProcess::HasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability);
sl@0: 	}
sl@0: 
sl@0: inline TBool RProcess::HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2);
sl@0: 	}
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: // For things using KSuppressPlatSecDiagnostic
sl@0: inline TBool RProcess::HasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline TBool RProcess::HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: 
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RSessionBase
sl@0: 
sl@0: 
sl@0: /**
sl@0: Creates a session with a server, specifying no message slots.
sl@0: 
sl@0: It should be called as part of session initialisation in the derived class.
sl@0: 
sl@0: Message slots are not pre-allocated for the session but are taken from
sl@0: a system-wide pool allowing up to 255 asynchronous messages to be outstanding.
sl@0: This raises a risk of failure due to lack of memory and, therefore, this mode
sl@0: of operation is not viable for sessions that make guarantees about the failure
sl@0: modes of asynchonous services.
sl@0: 
sl@0: @param aServer  The name of the server with which a session is to
sl@0:                 be established.
sl@0: @param aVersion The lowest version of the server with which this client
sl@0:                 is compatible
sl@0: 
sl@0: @return KErrNone if successful, otherwise one of the other system-wide error
sl@0:         codes.
sl@0: */
sl@0: inline TInt RSessionBase::CreateSession(const TDesC& aServer,const TVersion& aVersion)
sl@0: 	{return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,NULL,0);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Creates a session with a server, specifying no message slots.
sl@0: 
sl@0: It should be called as part of session initialisation in the derived class.
sl@0: 
sl@0: Message slots are not pre-allocated for the session but are taken from
sl@0: a system-wide pool allowing up to 255 asynchronous messages to be outstanding.
sl@0: This raises a risk of failure due to lack of memory and, therefore, this mode
sl@0: of operation is not viable for sessions that make guarantees about the failure
sl@0: modes of asynchonous services.
sl@0: 
sl@0: @param aServer  A handle to a server with which a session is to be established.
sl@0: @param aVersion The lowest version of the server with which this client
sl@0:                 is compatible
sl@0: 
sl@0: @return KErrNone if successful, otherwise one of the other system-wide error
sl@0:         codes.
sl@0: */
sl@0: inline TInt RSessionBase::CreateSession(RServer2 aServer,const TVersion& aVersion)
sl@0: 	{return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,NULL,0);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Issues a blind request to the server with the specified function number,
sl@0: and arguments.
sl@0: 
sl@0: A blind request is one where the server does not issue a response
sl@0: to the client.
sl@0: 
sl@0: @param aFunction The function number identifying the request.
sl@0: @param aArgs     A set of up to 4 arguments and their types to be passed
sl@0:                  to the server.
sl@0: 
sl@0: @return KErrNone, if the send operation is successful;
sl@0:         KErrServerTerminated, if the server no longer present;
sl@0:         KErrServerBusy, if there are no message slots available;
sl@0:         KErrNoMemory, if there is insufficient memory available.
sl@0: 
sl@0: @panic  USER 72 if the function number is negative.
sl@0: */
sl@0: inline TInt RSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
sl@0: 	{return DoSend(aFunction,&aArgs);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Issues an asynchronous request to the server with the specified function
sl@0: number and arguments. 
sl@0: 
sl@0: The completion status of the request is returned via the request
sl@0: status object, aStatus. 
sl@0: 
sl@0: @param aFunction The function number identifying the request.
sl@0: @param aArgs     A set of up to 4 arguments and their types to be passed
sl@0:                  to the server.
sl@0: @param aStatus   The request status object used to contain the completion status
sl@0:                  of the request.
sl@0:                  
sl@0: @panic  USER 72  if the function number is negative.                 
sl@0: */
sl@0: inline void RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
sl@0: 	{DoSendReceive(aFunction,&aArgs,aStatus);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Issues a synchronous request to the server with the specified function number
sl@0: and arguments.
sl@0: 
sl@0: @param aFunction The function number identifying the request.
sl@0: @param aArgs     A set of up to 4 arguments and their types to be passed
sl@0:                  to the server.
sl@0: 
sl@0: @return KErrNone, if the send operation is successful;
sl@0:         KErrServerTerminated, if the server no longer present;
sl@0:         KErrServerBusy, if there are no message slots available;
sl@0:         KErrNoMemory, if there is insufficient memory available.
sl@0: 
sl@0: @panic  USER 72  if the function number is negative.
sl@0: */
sl@0: inline TInt RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
sl@0: 	{return DoSendReceive(aFunction,&aArgs);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Issues a blind request to the server with the specified function number,
sl@0: but with no arguments.
sl@0: 
sl@0: A blind request is one where the server does not issue a response
sl@0: to the client.
sl@0: 
sl@0: @param aFunction The function number identifying the request.
sl@0: 
sl@0: @return KErrNone, if the send operation is successful;
sl@0:         KErrServerTerminated, if the server no longer present;
sl@0:         KErrServerBusy, if there are no message slots available;
sl@0:         KErrNoMemory, if there is insufficient memory available.
sl@0: 
sl@0: @panic  USER 72 if the function number is negative.
sl@0: */
sl@0: inline TInt RSessionBase::Send(TInt aFunction) const
sl@0: 	{return DoSend(aFunction,NULL);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Issues an asynchronous request to the server with the specified function
sl@0: number, but with no arguments.
sl@0: 
sl@0: The completion status of the request is returned via the request
sl@0: status object, aStatus. 
sl@0: 
sl@0: @param aFunction The function number identifying the request.
sl@0: @param aStatus   The request status object used to contain the completion
sl@0:                  status of the request.
sl@0:                  
sl@0: @panic  USER 72  if the function number is negative.                 
sl@0: */
sl@0: inline void RSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
sl@0: 	{ DoSendReceive(aFunction,NULL,aStatus);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the handle-number of this handle to the specified 
sl@0: value.
sl@0: 
sl@0: The function can take a (zero or positive) handle-number,
sl@0: or a (negative) error number.
sl@0: 
sl@0: If aHandleOrError represents a handle-number, then the handle-number of this handle
sl@0: is set to that value.
sl@0: If aHandleOrError represents an error number, then the handle-number of this handle is set to zero
sl@0: and the negative value is returned.
sl@0: 
sl@0: @param aHandleOrError A handle-number, if zero or positive; an error value, if negative.
sl@0: 
sl@0: @return KErrNone, if aHandle is a handle-number; the value of aHandleOrError, otherwise.
sl@0: */
sl@0: inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError)
sl@0: 	{ return RHandleBase::SetReturnedHandle(aHandleOrError);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle)
sl@0: 	{ return RHandleBase::SetReturnedHandle(aHandleOrError,aHandle);}
sl@0: /**
sl@0: Issues a synchronous request to the server with the specified function number,
sl@0: but with no arguments.
sl@0: 
sl@0: @param aFunction The function number identifying the request.
sl@0: 
sl@0: @return KErrNone, if the send operation is successful;
sl@0:         KErrServerTerminated, if the server no longer present;
sl@0:         KErrServerBusy, if there are no message slots available;
sl@0:         KErrNoMemory, if there is insufficient memory available.
sl@0: 
sl@0: @panic  USER 72  if the function number is negative.
sl@0: */
sl@0: inline TInt RSessionBase::SendReceive(TInt aFunction) const
sl@0: 	{return DoSendReceive(aFunction,NULL);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RSubSessionBase
sl@0: inline RSubSessionBase::RSubSessionBase()
sl@0: 	: iSubSessionHandle(0)
sl@0: /**
sl@0: Default constructor
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt RSubSessionBase::SubSessionHandle() const
sl@0: /**
sl@0: Gets the sub-session handle number.
sl@0: 
sl@0: This number is automatically passed to the server when making requests and is
sl@0: used to identify the appropriate server-side sub-session.
sl@0: 
sl@0: @return The sub-session handle number.
sl@0: */
sl@0: 	{return iSubSessionHandle;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Creates a new sub-session within an existing session.
sl@0: 
sl@0: @param aSession    The session to which this sub-session will belong.
sl@0: @param aFunction   The opcode specifying the requested service; the server should interpret this as a request to create a sub-session.
sl@0: @param aArgs       The message arguments.   
sl@0: 
sl@0: @return            KErrNone if successful, otherwise one of the system-wide error codes.
sl@0: */
sl@0: inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs)
sl@0: 	{ return DoCreateSubSession(aSession,aFunction,&aArgs); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 	
sl@0: /**
sl@0: Creates a new sub-session within an existing session.
sl@0: 
sl@0: This variant sends no message arguments to the server.
sl@0: 
sl@0: @param aSession    The session to which this sub-session will belong.
sl@0: @param aFunction   The opcode specifying the requested service; the server should interpret this as a request to create a sub-session.
sl@0: 
sl@0: @return            KErrNone if successful, otherwise one of the system-wide error codes.
sl@0: */
sl@0: inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction)
sl@0: 	{ return DoCreateSubSession(aSession,aFunction,NULL); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 	
sl@0: /**
sl@0: Sends a blind message to the server - no reply is expected.
sl@0: 
sl@0: A set of message arguments is passed that can be used to specify client
sl@0: addresses, which the server can use to read from and write to the client
sl@0: address space.
sl@0: 
sl@0: Note that this function can fail if there are no available message-slots, either
sl@0: in the system wide pool (if this is being used), or in the session reserved pool
sl@0: (if this is being used). If the client request is synchronous, then always use
sl@0: the synchronous variant of SendReceive(); this is guaranteed to reach the server.
sl@0: 
sl@0: @param aFunction	The opcode specifying the requested service.
sl@0: @param aArgs		The message arguments.
sl@0:                     
sl@0: @return				KErrNone if successful, otherwise one of the system-wide error codes.                    
sl@0: */
sl@0: inline TInt RSubSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
sl@0: 	{return DoSend(aFunction,&aArgs);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 	
sl@0: /**
sl@0: Sends a message to the server and waits asynchronously for the reply.
sl@0: 
sl@0: An opcode specifies the service required.
sl@0: A set of message arguments is passed that can be used to specify client addresses,
sl@0: which the server can use to read from and write to the client address space.
sl@0: 
sl@0: Note that this function can fail if there are no available message-slots, 
sl@0: either in the system wide pool (if this is being used), or in the session
sl@0: reserved pool (if this is being used). If the client request is synchronous,
sl@0: then always use the synchronous variant of SendReceive();
sl@0: this is guaranteed to reach the server.
sl@0: 
sl@0: @param aFunction	The opcode specifying the requested service.
sl@0: @param aArgs		The message arguments.
sl@0: @param aStatus	    A request status which indicates the completion status of the asynchronous request.
sl@0: */
sl@0: inline void RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
sl@0: 	{DoSendReceive(aFunction,&aArgs,aStatus);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 	
sl@0: /**
sl@0: Sends a message to the server and waits synchronously for a reply.
sl@0: 
sl@0: An opcode specifies the service required.
sl@0: A set of message arguments is passed that can be used to specify client addresses,
sl@0: which the server can use to read from and write to the client address space.
sl@0: 
sl@0: Note that this function will only fail if the server itself fails or environmental
sl@0: errors occur in the server. All requests made using this function are guaranteed to
sl@0: reach the server. This means that all synchronous client requests (typically those
sl@0: that return void) should be routed through this synchronous variant of SendReceive().
sl@0: 
sl@0: @param aFunction	The opcode specifying the requested service.
sl@0: @param aArgs		The message arguments.
sl@0: 
sl@0: @return				KErrNone if successful, otherwise one of the system-wide error codes. 
sl@0: */
sl@0: inline TInt RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
sl@0: 	{return DoSendReceive(aFunction,&aArgs);}
sl@0: 	
sl@0: 
sl@0: 
sl@0: 	
sl@0: /**
sl@0: Sends a blind message to the server - no reply is expected.
sl@0: 
sl@0: This variant sends no message arguments to the server.
sl@0: 
sl@0: @param aFunction	The opcode specifying the requested service.
sl@0:                     
sl@0: @return				KErrNone if successful, otherwise one of the system-wide error codes. 
sl@0: */
sl@0: inline TInt RSubSessionBase::Send(TInt aFunction) const
sl@0: 	{return DoSend(aFunction,NULL);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 	
sl@0: /**
sl@0: Sends a message to the server and waits asynchronously for the reply.
sl@0: 
sl@0: An opcode specifies the service required.
sl@0: This variant sends no message arguments to the server.
sl@0: 
sl@0: @param aFunction	The opcode specifying the requested service.
sl@0: @param aStatus	    A request status which indicates the completion status of the asynchronous request.
sl@0: */
sl@0: inline void RSubSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
sl@0: 	{ DoSendReceive(aFunction,NULL,aStatus);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 	
sl@0: /**
sl@0: Sends a message to the server and waits synchronously for a reply.
sl@0: 
sl@0: An opcode specifies the service required.
sl@0: This variant sends no message arguments to the server.
sl@0: 
sl@0: @param aFunction	The opcode specifying the requested service.
sl@0: 
sl@0: @return				KErrNone if successful, otherwise one of the system-wide error codes. 
sl@0: */
sl@0: inline TInt RSubSessionBase::SendReceive(TInt aFunction) const
sl@0: 	{return DoSendReceive(aFunction,NULL);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RRefBase
sl@0: 
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: inline RRefBase::RRefBase()
sl@0: 	: iPtr(NULL)
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Copy constructor.
sl@0: 
sl@0: @param aRef A reference to the object to be copied.
sl@0: */
sl@0: inline RRefBase::RRefBase(const RRefBase &aRef)
sl@0: 	{Copy(aRef);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RRef
sl@0: 
sl@0: 
sl@0: /**
sl@0: Default constructor.
sl@0: */
sl@0: template <class T>
sl@0: inline RRef<T>::RRef()
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Copy constructor.
sl@0: 
sl@0: The constructor frees any existing contained object, and takes ownership of
sl@0: the object owned by anObject. 
sl@0: 
sl@0: @param anObject A reference to another 'reference' object.
sl@0:                 On return from this constructor, anObject may be safely
sl@0:                 orphaned if it lives on the program stack.
sl@0: */
sl@0: template <class T>
sl@0: inline RRef<T>::RRef(const RRef<T> &anObject)
sl@0: 	{Copy(anObject);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Assignment operator.
sl@0: 
sl@0: The constructor frees any existing contained object, and takes ownership of
sl@0: the object owned by anObject. 
sl@0: 
sl@0: @param anObject A reference to another 'reference' object.
sl@0:                 On return from this constructor, anObject may be safely
sl@0:                 orphaned if it lives on the program stack.
sl@0: */
sl@0: template <class T>
sl@0: inline void RRef<T>::operator=(const RRef<T> &anObject)
sl@0: 	{Copy(anObject);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Gets a pointer to the contained object.
sl@0: 
sl@0: @return A pointer to the contained object
sl@0: */
sl@0: template <class T>
sl@0: inline T *RRef<T>::operator->()
sl@0: 	{return((T *)iPtr);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Gets a pointer to the contained object.
sl@0: 
sl@0: @return A pointer to the contained object
sl@0: */
sl@0: template <class T>
sl@0: inline RRef<T>::operator T*()
sl@0: 	{return((T *)iPtr);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Creates a copy of the specified object, which is to be contained by
sl@0: this reference object.
sl@0: 
sl@0: The amount of memory set aside to contain the object is defined by the size
sl@0: of the object
sl@0: 
sl@0: @param anObject The object to be packaged up by this reference object.
sl@0: */
sl@0: template <class T>
sl@0: void RRef<T>::Alloc(const T &anObject)
sl@0: 	{DoAlloc(&anObject,sizeof(T));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Creates a copy of the specified object, which is to be contained by
sl@0: this reference object.
sl@0: 
sl@0: The amount of memory set aside to contain the object is defined by aSize.
sl@0: 
sl@0: @param anObject The object to be packaged up by this reference object.
sl@0: @param aSize    The amount of memory to be set aside to contain the object.
sl@0:                 You must make sure that this is big enough.
sl@0: */
sl@0: template <class T>
sl@0: void RRef<T>::Alloc(const T &anObject,TInt aSize)
sl@0: 	{DoAlloc(&anObject,aSize);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Creates a copy of the specified object, which is to be contained by
sl@0: this reference object, and leaves on failure.
sl@0: 
sl@0: The amount of memory set aside to contain the object is defined by the size
sl@0: of the object
sl@0: 
sl@0: @param anObject The object to be packaged up by this reference object.
sl@0: */
sl@0: template <class T>
sl@0: void RRef<T>::AllocL(const T &anObject)
sl@0: 	{DoAllocL(&anObject,sizeof(T));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Creates a copy of the specified object, which is to be contained by
sl@0: this reference object, and leaves on failure.
sl@0: 
sl@0: The amount of memory set aside to contain the object is defined by aSize.
sl@0: 
sl@0: @param anObject The object to be packaged up by this reference object.
sl@0: @param aSize    The amount of memory to be set aside to contain the object.
sl@0:                 You must make sure that this is big enough.
sl@0: */
sl@0: template <class T>
sl@0: void RRef<T>::AllocL(const T &anObject,TInt aSize)
sl@0: 	{DoAllocL(&anObject,aSize);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TRegion
sl@0: inline TBool TRegion::CheckError() const
sl@0: /** 
sl@0: Tests whether the region's error flag is set.
sl@0: 
sl@0: The error flag may be set:
sl@0: 
sl@0: 1. when an attempt to allocate more memory for the region fails
sl@0: 
sl@0: 2. if an attempt is made to expand a fixed size region beyond its allocated
sl@0:    size
sl@0: 
sl@0: 3. if ForceError() has been called.
sl@0: 
sl@0: Use Clear() to unset the error flag, clear the region and free all allocated 
sl@0: memory.
sl@0: 
sl@0: @return True, if the error flag is set; false, otherwise. 
sl@0: 
sl@0: @see TRegion::ForceError
sl@0: @see TRegion::Clear
sl@0: */
sl@0: 	{return(iError);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TInt TRegion::Count() const
sl@0: /**
sl@0: Gets the number of rectangles in this region.
sl@0: 
sl@0: @return The number of rectangles.
sl@0: */
sl@0: 	{return(iCount);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline const TRect *TRegion::RectangleList() const
sl@0: /**
sl@0: Gets a pointer to the array of rectangles defining this region.
sl@0: 
sl@0: @return Pointer to the array of rectangles. Note that array is a standard 
sl@0:         C++ array, i.e. a concatenated set of TRect objects. Use Count() to
sl@0: 		get the number of rectangles.
sl@0: 
sl@0: @see TRegion::Count
sl@0: */
sl@0: 	{return(((TRegion *)this)->RectangleListW());}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline TRegion::TRegion()
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class RRegion
sl@0: inline TInt RRegion::CheckSpare() const
sl@0: /**
sl@0: Gets the number of free memory slots in the region.
sl@0: 
sl@0: This is the number of slots which have been allocated, minus the number in 
sl@0: use.
sl@0: 
sl@0: @return The number of free memory slots in the region.
sl@0: */
sl@0: 	{return(iAllocedRects-iCount);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TRegionFix
sl@0: template <TInt S>
sl@0: inline TRegionFix<S>::TRegionFix() : TRegion(-S)
sl@0: /**
sl@0: Constructs a default fixed size region.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <TInt S>
sl@0: inline TRegionFix<S>::TRegionFix(const TRect &aRect) : TRegion(-S)
sl@0: /**
sl@0: Constructs a fixed size region with a TRect.
sl@0: 
sl@0: @param aRect Rectangle to be added to the newly constructed region.
sl@0: */
sl@0: 	{AddRect(aRect);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <TInt S>
sl@0: inline TRegionFix<S>::TRegionFix(const TRegionFix<S> &aRegion)
sl@0: /**
sl@0: Copy constructor.
sl@0: 
sl@0: @param aRegion The TRegionFix object to be copied.
sl@0: */
sl@0: 	{*this=aRegion;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <TInt S>
sl@0: inline RRegionBuf<S>::RRegionBuf() : RRegion(-S&(~ERRegionBuf),S)
sl@0: /**
sl@0: Constructs a default object.
sl@0: 
sl@0: The granularity is the value of the template parameter.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: template <TInt S>
sl@0: inline RRegionBuf<S>::RRegionBuf(const RRegion &aRegion) 
sl@0: /**
sl@0: Constructs this object from the specified RRegion.
sl@0: 
sl@0: @param aRegion The region to assign to this RRegionBuf.
sl@0: */
sl@0: 	{*this=aRegion;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <TInt S>
sl@0: inline RRegionBuf<S>::RRegionBuf(const TRect &aRect) : RRegion(-S&(~ERRegionBuf),S)
sl@0: /**
sl@0: Constructs an RRegionBuf with a TRect.
sl@0: 
sl@0: Its granularity is initialised to the value contained in the template argument.
sl@0: The resulting region consists of the specified single rectangle.
sl@0: 
sl@0: @param aRect The single rectangle with which to initialise the region.
sl@0: */
sl@0: 	{AddRect(aRect);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <TInt S>
sl@0: inline RRegionBuf<S>::RRegionBuf(const RRegionBuf<S> &aRegion)
sl@0: /**
sl@0: Copy constructs from an existing RRegionBuf object.
sl@0: 
sl@0: @param aRegion The RRegionBuf to be copied.
sl@0: */
sl@0:     {*this=aRegion;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // enum TTimerLockSpec
sl@0: inline TTimerLockSpec &operator++(TTimerLockSpec &aLock)
sl@0: 	{
sl@0: 	return aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
sl@0: 	}
sl@0: inline TTimerLockSpec operator++(TTimerLockSpec &aLock, TInt)
sl@0: 	{
sl@0: 	TTimerLockSpec l=aLock;
sl@0: 	aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
sl@0: 	return l;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Class TCheckedUid
sl@0: inline const TUidType& TCheckedUid::UidType() const
sl@0: /**
sl@0: Gets the Uid type contained in this object.
sl@0: 
sl@0: @return The Uid type.
sl@0: */
sl@0:     {return(iType);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // Array deletion support, uses CBase deletion (virtual d'tor) for all C-classes
sl@0: template <class T>
sl@0: /**	@internalComponent
sl@0: */
sl@0: void _DeleteArray(T** aBegin,T** aEnd)
sl@0: 	{for (;;) if (aBegin<aEnd) delete *aBegin++; else return;}
sl@0: 
sl@0: template <class T>
sl@0: /**	@internalComponent
sl@0: */
sl@0: struct _ArrayUtil
sl@0: 	{
sl@0: 	static inline void Delete(T* aBegin,T* aEnd,CBase*)
sl@0: 		{::_DeleteArray((CBase**)aBegin,(CBase**)aEnd);}
sl@0: 	static inline void Delete(T* aBegin,T* aEnd,TAny*)
sl@0: 		{::_DeleteArray(aBegin,aEnd);}
sl@0: 	static inline void Delete(T* aArray,TInt aCount)
sl@0: 		{Delete(aArray,aArray+aCount,*aArray);}
sl@0: 	};
sl@0: 
sl@0: 
sl@0: 
sl@0: //SL:
sl@0: //#ifndef __TOOLS__
sl@0: // Template class TFixedArray
sl@0: IMPORT_C void PanicTFixedArray();
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline TFixedArray<T,S>::TFixedArray()
sl@0: /**
sl@0: Default constructor.
sl@0: 
sl@0: Constructs an uninitialised C++ array.
sl@0: */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline void TFixedArray<T,S>::Copy(const T* aList,TInt aLength)
sl@0: /**
sl@0: Copies the specified set of contiguous objects into the C++ array.
sl@0: 
sl@0: The copy operation starts at the beginning of the array, replacing
sl@0: any existing data.
sl@0: 
sl@0: @param aList   A pointer to a set of contiguous objects. 
sl@0: @param aLength The number of contiguous objects to be copied. This value must
sl@0:                not be negative and must not be greater than the size of the
sl@0: 			   array as defined by the integer template parameter.
sl@0: 
sl@0: @panic USER 133, in a debug build only, if aLength is negative or is greater
sl@0:        than the size of the array as defined by the integer template parameter.
sl@0: */
sl@0: 	{__ASSERT_DEBUG(TUint(aLength)<=TUint(S),PanicTFixedArray());Mem::Copy(iRep,aList,aLength*sizeof(T));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline TFixedArray<T,S>::TFixedArray(const T* aList,TInt aLength)
sl@0: /**
sl@0: Constructs a C++ array initialised with the specified objects.
sl@0: 
sl@0: @param aList   A pointer to a set of contiguous objects. 
sl@0: @param aLength The number of contiguous objects to be copied. This value must
sl@0:                not be negative and must not be greater than the size of the
sl@0: 			   array as defined by the integer template parameter.
sl@0: 
sl@0: @panic USER 133, in a debug build only, if aLength is negative or is greater
sl@0:        than the size of the array as defined by the integer template parameter.
sl@0: */
sl@0: 	{Copy(aList,aLength);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline void TFixedArray<T,S>::Reset()
sl@0: /**
sl@0: Fills every element of the array with binary zeroes.
sl@0: */
sl@0: 	{Mem::FillZ(iRep,sizeof(iRep));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline TInt TFixedArray<T,S>::Count() const
sl@0: /**
sl@0: Gets the size of the array.
sl@0: 
sl@0: For any instance of this class, the array size 
sl@0: is fixed and has the same value as the integer template parameter.
sl@0: 
sl@0: @return The size of the array.
sl@0: */
sl@0: 	{return S;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline TInt TFixedArray<T,S>::Length() const
sl@0: /**
sl@0: Gets the size of an array element, in bytes.
sl@0: 
sl@0: @return The size of an array element, in bytes.
sl@0: */
sl@0: 	{return sizeof(T);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline TBool TFixedArray<T,S>::InRange(TInt aIndex)
sl@0: 	{return TUint(aIndex)<S;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline T& TFixedArray<T,S>::operator[](TInt aIndex)
sl@0: /**
sl@0: Gets a reference to the specified element within the C++ array.
sl@0: 
sl@0: @param aIndex The position of the element within the array. This is an offset value; 
sl@0:               a zero value refers to the first element in the array. This value must be 
sl@0:               greater than or equal to zero and less than the size of the array.
sl@0: 
sl@0: @return A reference to an element of the array.
sl@0: 
sl@0: @panic USER 133, in a debug build only, if aIndex is negative or greater than or equal to the size
sl@0:        of the array as defined by the integer template parameter.
sl@0: */
sl@0: 	{__ASSERT_DEBUG(InRange(aIndex),PanicTFixedArray());return iRep[aIndex];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline const T& TFixedArray<T,S>::operator[](TInt aIndex) const
sl@0: /**
sl@0: Gets a const reference to the specified element within the C++ array.
sl@0: 
sl@0: @param aIndex The position of the element within the array. This is an offset value; 
sl@0:               a zero value refers to the first element in the array. This value must be 
sl@0:               greater than or equal to zero and less than the size of the array.
sl@0: 
sl@0: @return A const reference to an element of the array; the element cannot be 
sl@0:         changed through this reference.
sl@0: 
sl@0: @panic USER 133, in a debug build only, if aIndex is negative or greater than or equal to the size
sl@0:        of the array as defined by the integer template parameter.
sl@0: */
sl@0: 	{return CONST_CAST(ThisClass&,*this)[aIndex];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline T& TFixedArray<T,S>::At(TInt aIndex)
sl@0: /**
sl@0: Gets a reference to the specified element within the C++ array.
sl@0: 
sl@0: @param aIndex The position of the element within the array. This is an offset value; 
sl@0:               a zero value refers to the first element in the array. This value must be 
sl@0:               greater than or equal to zero and less than the size of the array.
sl@0: 
sl@0: @return A reference to an element of the array.
sl@0: 
sl@0: @panic USER 133, if aIndex is negative or greater than or equal to the size
sl@0:        of the array as defined by the integer template parameter.
sl@0: */
sl@0: 	{__ASSERT_ALWAYS(InRange(aIndex),PanicTFixedArray());return iRep[aIndex];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline const T& TFixedArray<T,S>::At(TInt aIndex) const
sl@0: /**
sl@0: Gets a const reference to the specified element within the C++ array.
sl@0: 
sl@0: @param aIndex The position of the element within the array. This is an offset value; 
sl@0:               a zero value refers to the first element in the array. This value must be 
sl@0:               greater than or equal to zero and less than the size of the array.
sl@0: 
sl@0: @return A const reference to an element of the array; the element cannot be 
sl@0:         changed through this reference.
sl@0: 
sl@0: @panic USER 133, in a debug build only, if aIndex is negative or greater than or equal to the size
sl@0:        of the array as defined by the integer template parameter.
sl@0: */
sl@0: 	{return CONST_CAST(ThisClass&,*this).At(aIndex);}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline T* TFixedArray<T,S>::Begin()
sl@0: /**
sl@0: Gets a pointer to the first element of the array.
sl@0: 
sl@0: @return A pointer to the first element of the array.
sl@0: */
sl@0: 	{return &iRep[0];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline T* TFixedArray<T,S>::End()
sl@0: /**
sl@0: Gets a pointer to the first byte following the end of the array.
sl@0: 
sl@0: @return A pointer to the first byte following the end of the array.
sl@0: */
sl@0: 	{return &iRep[S];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline const T* TFixedArray<T,S>::Begin() const
sl@0: /**
sl@0: Gets a pointer to the first element of the array.
sl@0: 
sl@0: @return A pointer to a const element of the array. 
sl@0: */
sl@0: 	{return &iRep[0];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline const T* TFixedArray<T,S>::End() const
sl@0: /**
sl@0: Gets a pointer to the first byte following the end of the array.
sl@0: 
sl@0: @return A pointer to the const first byte following the end of the array.
sl@0: */
sl@0: 	{return &iRep[S];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline TInt TFixedArray<T,S>::CountFunctionR(const CBase*)
sl@0: 	{return S;}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline const TAny* TFixedArray<T,S>::AtFunctionR(const CBase* aThis,TInt aIndex)
sl@0: 	{return &REINTERPRET_CAST(const ThisClass&,*aThis)[aIndex];}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline TArray<T> TFixedArray<T,S>::Array() const
sl@0: /**
sl@0: Creates and returns a generic array for this C++ array.
sl@0: 
sl@0: @return A generic array for this C++ array.
sl@0: */
sl@0: 	{return TArray<T>(CountFunctionR,AtFunctionR,REINTERPRET_CAST(const CBase*,this));}
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: template <class T,TInt S>
sl@0: inline void TFixedArray<T,S>::DeleteAll()
sl@0: /**
sl@0: Invokes the delete operator on every member of the array.
sl@0: 
sl@0: The function can only be used for arrays of pointers to CBase derived objects.
sl@0: 
sl@0: If the array is to be used after a call to this function, it is good practice 
sl@0: to call TFixedArray<class T,TInt S>::Reset() to set all array elements to 
sl@0: NULL.
sl@0: */
sl@0: 	{_ArrayUtil<T>::Delete(iRep,S);}
sl@0: //#endif
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // class User
sl@0: 
sl@0: inline RHeap* User::SwitchHeap(RAllocator* aHeap)
sl@0: /**
sl@0: Changes the current thread's heap.
sl@0: 	
sl@0: @param aHeap A pointer to the new heap handle.
sl@0: 
sl@0: @return A pointer to the old heap handle.
sl@0: */
sl@0: 	{ return (RHeap*)SwitchAllocator(aHeap); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: inline RHeap& User::Heap()
sl@0: /**
sl@0: Gets a reference to the handle to the current thread's heap.
sl@0: 	
sl@0: @return A reference to the handle to the current thread's heap.
sl@0: */
sl@0: 	{ return (RHeap&)Allocator(); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: inline TBool User::CreatorHasCapability(TCapability aCapability, const char* aDiagnostic)
sl@0: 	{
sl@0: 	return DoCreatorHasCapability(aCapability, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: inline TBool User::CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic)
sl@0: 	{
sl@0: 	return DoCreatorHasCapability(aCapability1, aCapability2, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: // Only available to NULL arguments
sl@0: inline TBool User::CreatorHasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/)
sl@0: 	{
sl@0: 	return DoCreatorHasCapability(aCapability);
sl@0: 	}
sl@0: 
sl@0: inline TBool User::CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/)
sl@0: 	{
sl@0: 	return DoCreatorHasCapability(aCapability1, aCapability2);
sl@0: 	}
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: // For things using KSuppressPlatSecDiagnostic
sl@0: inline TBool User::CreatorHasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/)
sl@0: 	{
sl@0: 	return DoCreatorHasCapability(aCapability, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline TBool User::CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/)
sl@0: 	{
sl@0: 	return DoCreatorHasCapability(aCapability1, aCapability2, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: 
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: 
sl@0: inline const TAny* User::LeaveIfNull(const TAny* aPtr)
sl@0: /**
sl@0: Leaves with the reason code KErrNoMemory, if the specified pointer is NULL. 
sl@0: 
sl@0: If the pointer is not NULL, the function simply returns with the value of 
sl@0: the pointer.
sl@0: 
sl@0: Used to check pointers to const objects.
sl@0: 
sl@0: @param aPtr The pointer to be tested.
sl@0: 
sl@0: @return If the function returns, the value of aPtr.
sl@0: */
sl@0: 	{ return (const TAny*)LeaveIfNull((TAny*)aPtr); }
sl@0: 
sl@0: /** Sets this TSecurityInfo to the security attributes of this process. */
sl@0: inline void TSecurityInfo::SetToCurrentInfo()
sl@0: 	{ new (this) TSecurityInfo(RProcess()); }
sl@0: 
sl@0: /** Constructs a TSecurityInfo using the security attributes of aProcess */
sl@0: inline void TSecurityInfo::Set(RProcess aProcess)
sl@0: 	{ new (this) TSecurityInfo(aProcess); }
sl@0: 
sl@0: /** Constructs a TSecurityInfo using the security attributes of the process
sl@0: owning aThread 
sl@0: */
sl@0: inline void TSecurityInfo::Set(RThread aThread)
sl@0: 	{ new (this) TSecurityInfo(aThread); }
sl@0: 
sl@0: /** Constructs a TSecurityInfo using the security attributes of the process
sl@0: which sent the message aMsgPtr */
sl@0: inline void TSecurityInfo::Set(RMessagePtr2 aMsgPtr)
sl@0: 	{ new (this) TSecurityInfo(aMsgPtr); }
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of aProcess.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aProcess The RProcess object to check against this TSecurityPolicy.
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of aProcess, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aProcess, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of the process
sl@0: owning aThread.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aThread The thread whose owning process' platform security attributes
sl@0: are to be checked against this TSecurityPolicy.
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security parameters of the owning process of aThread, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aThread, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of the process which sent
sl@0: the given message.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aMsgPtr The RMessagePtr2 object to check against this TSecurityPolicy.
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of aMsg, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aMsgPtr, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of the process which sent
sl@0: the given message.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aMsgPtr The RMessagePtr2 object to check against this TSecurityPolicy.
sl@0: @param aMissing A TSecurityInfo object which this method fills with any capabilities or IDs
sl@0: 				it finds to be missing. 
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of aMsg, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aMsgPtr, aMissing, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of this process' creator.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of this process' creator, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoCheckPolicyCreator(aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aProcess, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aThread, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aMsgPtr, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic)
sl@0: @internalComponent
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aMsgPtr, aMissing, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicyCreator(aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of aProcess.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aProcess The RProcess object to check against this TSecurityPolicy.
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of aProcess, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RProcess aProcess, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aProcess);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of the process
sl@0: owning aThread.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aThread The thread whose owning process' platform security attributes
sl@0: are to be checked against this TSecurityPolicy.
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security parameters of the owning process of aThread, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RThread aThread, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aThread);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of the process which sent
sl@0: the given message.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aMsgPtr The RMessagePtr2 object to check against this TSecurityPolicy.
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of aMsg, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aMsgPtr);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of the process which sent
sl@0: the given message.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aMsgPtr The RMessagePtr2 object to check against this TSecurityPolicy.
sl@0: @param aMissing A TSecurityInfo object which this method fills with any capabilities or IDs
sl@0: 				it finds to be missing. 
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of aMsg, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aMsgPtr, aMissing);
sl@0: 	}
sl@0: 
sl@0: /** Checks this policy against the platform security attributes of this process' creator.
sl@0: 
sl@0: 	When a check fails the action taken is determined by the system wide Platform Security
sl@0: 	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0: 	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0: 	check failed.
sl@0: 
sl@0: @param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0: 							that may be issued if the policy check fails.
sl@0: 							This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0: 							which enables it to be easily removed from the system.
sl@0: @return ETrue if all the requirements of this TSecurityPolicy are met by the
sl@0: platform security attributes of this process' creator, EFalse otherwise.
sl@0: @panic USER 190 if 'this' is an invalid SSecurityInfo object
sl@0: */
sl@0: inline TBool TSecurityPolicy::CheckPolicyCreator(OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicyCreator();
sl@0: 	}
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RProcess aProcess, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aProcess, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RThread aThread, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aThread, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aMsgPtr, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicy(aMsgPtr, aMissing, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline TBool TSecurityPolicy::CheckPolicyCreator(OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoCheckPolicyCreator(KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RProcess aProcess, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aProcess);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RThread aThread, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aThread);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aMsgPtr);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic)
sl@0: @internalComponent
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aMsgPtr, aMissing);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicyCreator(OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicyCreator();
sl@0: 	}
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RProcess aProcess, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aProcess, KSuppressPlatSecDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RThread aThread, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aThread, KSuppressPlatSecDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aMsgPtr, KSuppressPlatSecDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic)
sl@0: @internalComponent
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicy(aMsgPtr, aMissing, KSuppressPlatSecDiagnostic);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @see TSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic)
sl@0: */
sl@0: inline TBool TStaticSecurityPolicy::CheckPolicyCreator(OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return (&(*this))->CheckPolicyCreator(KSuppressPlatSecDiagnostic);
sl@0: 	}
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: 
sl@0: #endif //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: 
sl@0: 
sl@0: #ifndef __KERNEL_MODE__
sl@0: 
sl@0: /**
sl@0: Appends an object pointer onto the array.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be appended.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::AppendL(const T* anEntry)
sl@0: 	{ User::LeaveIfError(Append(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object pointer into the array at the specified position.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if
sl@0: the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be inserted.
sl@0: @param aPos    The position within the array where the object pointer is to be 
sl@0:                inserted. The position is relative to zero, i.e. zero implies
sl@0: 			   that a pointer is inserted at the beginning of the array.
sl@0: 
sl@0: @panic USER 131, if aPos is negative, or is greater than the number of object
sl@0:        pointers currently in the array.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::InsertL(const T* anEntry, TInt aPos)
sl@0: 	{ User::LeaveIfError(Insert(anEntry,aPos)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the first object pointer in the array which matches the specified object 
sl@0: pointer, using a sequential search.
sl@0: 
sl@0: Matching is based on the comparison of pointers.
sl@0: 
sl@0: The find operation always starts at the low index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @return The index of the first matching object pointer within the array.
sl@0: @leave KErrNotFound, if no matching object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::FindL(const T* anEntry) const
sl@0: 	{ return User::LeaveIfError(Find(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the first object pointer in the array whose object matches the specified 
sl@0: object, using a sequential search and a matching algorithm.
sl@0: 
sl@0: The algorithm for determining whether two class T objects match is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: The find operation always starts at the low index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry    The object pointer to be found.
sl@0: @param anIdentity A package encapsulating the function which determines whether 
sl@0:                   two class T objects match.
sl@0: 
sl@0: @return The index of the first matching object pointer within the array.
sl@0: @leave  KErrNotFound, if no suitable object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const
sl@0: 	{ return User::LeaveIfError(Find(anEntry, anIdentity));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the last object pointer in the array which matches the specified object 
sl@0: pointer, using a sequential search.
sl@0: 
sl@0: Matching is based on the comparison of pointers.
sl@0: 
sl@0: The find operation always starts at the high index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @return The index of the last matching object pointer within the array.
sl@0: @leave KErrNotFound, if no matching object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::FindReverseL(const T* anEntry) const
sl@0: 	{ return User::LeaveIfError(FindReverse(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the last object pointer in the array whose object matches the specified 
sl@0: object, using a sequential search and a matching algorithm.
sl@0: 
sl@0: The algorithm for determining whether two class T objects match is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: The find operation always starts at the high index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry    The object pointer to be found.
sl@0: @param anIdentity A package encapsulating the function which determines whether 
sl@0:                   two class T objects match.
sl@0: 
sl@0: @return The index of the last matching object pointer within the array.
sl@0: @leave  KErrNotFound, if no suitable object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::FindReverseL(const T* anEntry, TIdentityRelation<T> anIdentity) const
sl@0: 	{ return User::LeaveIfError(FindReverse(anEntry, anIdentity));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array that matches the specified object
sl@0: pointer, using a binary search technique.
sl@0: 
sl@0: The function assumes that object pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: 
sl@0: @return The index of the matching object pointer within the array
sl@0: @leave KErrNotFound, if no suitable object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::FindInAddressOrderL(const T* anEntry) const
sl@0: 	{ return User::LeaveIfError(FindInAddressOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array whose object matches the specified
sl@0: object, using a binary search technique and an ordering algorithm.
sl@0: 
sl@0: The function assumes that existing object pointers in the array are ordered 
sl@0: so that the objects themselves are in object order as determined by an algorithm 
sl@0: supplied by the caller and packaged as a TLinearOrder<T>.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: 
sl@0: @return The index of the matching object pointer within the array.
sl@0: 
sl@0: @leave KErrNotFound, if no suitable object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const
sl@0: 	{ return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array that matches the specified object
sl@0: pointer, using a binary search technique.
sl@0: 
sl@0: The function assumes that object pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @param anIndex A reference to a TInt into which the
sl@0:                function puts an index value: If the function does not leave,
sl@0:                this is the index of the matching object pointer within the
sl@0:                array. If the function leaves with KErrNotFound, this is the
sl@0:                index of the first object pointer within the array which
sl@0:                logically follows after anEntry.
sl@0: 
sl@0: @leave KErrNotFound, if no suitable object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::FindInAddressOrderL(const T* anEntry, TInt& anIndex) const
sl@0: 	{ User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array whose object matches the specified
sl@0: object, using a binary search technique and an ordering algorithm.
sl@0: 
sl@0: The function assumes that existing object pointers in the array are ordered 
sl@0: so that the objects themselves are in object order as determined by an
sl@0: algorithm supplied by the caller and packaged as a TLinearOrder<T>.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @param anIndex A TInt supplied by the caller. On return, contains an
sl@0:                index value:
sl@0:                If the function does not leave, this is the index of the
sl@0:                matching object pointer within the array. 
sl@0:                If the function leaves with KErrNotFound, this is the index of
sl@0:                the first object pointer in the array whose object is bigger
sl@0:                than the entry being searched for - if no objects pointed to in
sl@0:                the array are bigger, then the index value is the same as the
sl@0:                total number of object pointers in the array.
sl@0: 
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: 
sl@0: @leave         KErrNotFound, if no suitable object pointer can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
sl@0: 	{ User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array that matches the specified object
sl@0: pointer, using a binary search technique.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, the last
sl@0: or any matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that object pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param	anEntry The object pointer to be found.
sl@0: @param	aMode   Specifies whether to find the first match, the last match or
sl@0:                 any match, as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return If there is a matching element, the array index of a matching element -  what
sl@0:         the index refers to depends on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows the
sl@0:         last matching element - if the last matching element is also the last element of the array,
sl@0:         then the index value is the same as the total number of elements in the array.
sl@0:         
sl@0: @leave  KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const
sl@0: 	{ return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array whose object matches the specified
sl@0: object, using a binary search technique and an ordering algorithm.
sl@0: 
sl@0: In the case that there is more than one matching element finds the first, last
sl@0: or any match as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that existing object pointers in the array are ordered 
sl@0: so that the objects themselves are in object order as determined by an algorithm 
sl@0: supplied by the caller and packaged as a TLinearOrder<T> type.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any match,
sl@0:                as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return If there is a matching element, the array index of a matching
sl@0:         element -  what the index refers to depends on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:         the last matching element - if the last matching element is also the last element of the array, then
sl@0:         the index value is the same as the total number of elements in the array.
sl@0: 
sl@0: @leave  KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
sl@0: 	{ return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array that matches the specified object
sl@0: pointer, using a binary search technique.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, the last or
sl@0: any matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that object pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an index
sl@0:                value depending on whether a match is found and on the value of aMode.
sl@0:                If there is no matching element in the array, then this is the  index
sl@0:                of the first element in the array that is bigger than the element being
sl@0:                searched for - if no elements in the array are bigger, then the index
sl@0:                value is the same as the total number of elements in the array.
sl@0:                If there is a matching element, then what the index refers to depends
sl@0:                on the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element
sl@0:                of the array, then the index value is the same as the total number of elements in the array.
sl@0:                
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any match, as defined by
sl@0:                one of the TArrayFindMode enum values.
sl@0: 
sl@0: @leave  KErrNotFound, if no suitable object pointer can be found.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object pointer in the array whose object matches the specified
sl@0: object, using a binary search technique and an ordering algorithm.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, the last or any
sl@0: matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that existing object pointers in the array are ordered 
sl@0: so that the objects themselves are in object order as determined by an
sl@0: algorithm supplied by the caller and packaged as a TLinearOrder<T>.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be found.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an index
sl@0:                value depending on whether a match is found and on the value of aMode.
sl@0:                If there is no matching element in the array, then this is
sl@0:                the index of the first element in the array that is bigger than
sl@0:                the element being searched for - if no elements in the array are bigger,
sl@0:                then the index value is the same as the total number of elements in the array.
sl@0:                If there is a matching element, then what the index refers to depends
sl@0:                on the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element of
sl@0:                the array, then the index value is the same as the total number of elements in the array.
sl@0: 
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any match, as defined by
sl@0:                one of the TArrayFindModeenum values.
sl@0: 
sl@0: @leave  KErrNotFound, if no suitable object pointer can be found.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object pointer into the array in address order.
sl@0: 
sl@0: No duplicate entries are permitted.
sl@0: The function assumes that existing object pointers within the array are in 
sl@0: address order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be inserted.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::InsertInAddressOrderL(const T* anEntry)
sl@0: 	{ User::LeaveIfError(InsertInAddressOrder(anEntry)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object pointer into the array so that the object itself is in object 
sl@0: order.
sl@0: 
sl@0: The algorithm for determining the order of two class T objects is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: No duplicate entries are permitted.
sl@0: 
sl@0: The function assumes that the array is ordered so that the referenced objects 
sl@0: are in object order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: Note that the array remains unchanged following an attempt to insert a duplicate
sl@0: entry.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be inserted.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder)
sl@0: 	{ User::LeaveIfError(InsertInOrder(anEntry, anOrder)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object pointer into the array in address order, allowing duplicates.
sl@0: 
sl@0: If the new object pointer is a duplicate of an existing object pointer in 
sl@0: the array, then the new pointer is inserted after the existing one. If more 
sl@0: than one duplicate object pointer already exists in the array, then any new 
sl@0: duplicate pointer is inserted after the last one.
sl@0: 
sl@0: The function assumes that existing object pointers within the array are in 
sl@0: address order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be inserted.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::InsertInAddressOrderAllowRepeatsL(const T* anEntry)
sl@0: 	{ User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object pointer into the array so that the object itself is in object 
sl@0: order, allowing duplicates
sl@0: 
sl@0: The algorithm for determining the order of two class T objects is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: If the specified object is a duplicate of an existing object, then the new 
sl@0: pointer is inserted after the pointer to the existing object. If more than 
sl@0: one duplicate object already exists, then the new pointer is inserted after 
sl@0: the pointer to the last one.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The object pointer to be inserted. 
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder)
sl@0: 	{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder)); }
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Reserves space for the specified number of elements.
sl@0: 
sl@0: After a call to this function, the memory allocated to the array is sufficient 
sl@0: to hold the number of object pointers specified. Adding new object pointers to the array 
sl@0: does not result in a re-allocation of memory until the the total number of 
sl@0: pointers exceeds the specified count.
sl@0: 
sl@0: @param	aCount	The number of object pointers for which space should be reserved
sl@0: @leave KErrNoMemory	If the requested amount of memory could not be allocated
sl@0: */
sl@0: template <class T>
sl@0: inline void RPointerArray<T>::ReserveL(TInt aCount)
sl@0: 	{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
sl@0: 
sl@0: 
sl@0: 
sl@0: // Specialization for RPointerArray<TAny>
sl@0: 
sl@0: /**
sl@0: Appends an pointer onto the array.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be appended.
sl@0: */
sl@0: inline void RPointerArray<TAny>::AppendL(const TAny* anEntry)
sl@0: 	{ User::LeaveIfError(Append(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an pointer into the array at the specified position.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if
sl@0: the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be inserted.
sl@0: @param aPos    The position within the array where the pointer is to be 
sl@0:                inserted. The position is relative to zero, i.e. zero implies
sl@0: 			   that a pointer is inserted at the beginning of the array.
sl@0: 
sl@0: @panic USER 131, if aPos is negative, or is greater than the number of object
sl@0:        pointers currently in the array.
sl@0: */
sl@0: inline void RPointerArray<TAny>::InsertL(const TAny* anEntry, TInt aPos)
sl@0: 	{ User::LeaveIfError(Insert(anEntry,aPos)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the first pointer in the array which matches the specified pointer, using
sl@0: a sequential search.
sl@0: 
sl@0: Matching is based on the comparison of pointers.
sl@0: 
sl@0: The find operation always starts at the low index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be found.
sl@0: @return The index of the first matching pointer within the array.
sl@0: @leave KErrNotFound, if no matching pointer can be found.
sl@0: */
sl@0: inline TInt RPointerArray<TAny>::FindL(const TAny* anEntry) const
sl@0: 	{ return User::LeaveIfError(Find(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the last pointer in the array which matches the specified pointer, using
sl@0: a sequential search.
sl@0: 
sl@0: Matching is based on the comparison of pointers.
sl@0: 
sl@0: The find operation always starts at the high index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be found.
sl@0: @return The index of the last matching pointer within the array.
sl@0: @leave KErrNotFound, if no matching pointer can be found.
sl@0: */
sl@0: inline TInt RPointerArray<TAny>::FindReverseL(const TAny* anEntry) const
sl@0: 	{ return User::LeaveIfError(FindReverse(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the pointer in the array that matches the specified pointer, using a
sl@0: binary search technique.
sl@0: 
sl@0: The function assumes that pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be found.
sl@0: 
sl@0: @return The index of the matching pointer within the array
sl@0: @leave KErrNotFound, if no suitable pointer can be found.
sl@0: */
sl@0: inline TInt RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry) const
sl@0: 	{ return User::LeaveIfError(FindInAddressOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the pointer in the array that matches the specified pointer, using a
sl@0: binary search technique.
sl@0: 
sl@0: The function assumes that pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be found.
sl@0: @param anIndex A reference to a TInt into which the
sl@0:                function puts an index value: If the function does not leave,
sl@0: 			   this is the index of the matching pointer within the array. If the
sl@0: 			   function leaves with KErrNotFound, this is the index of the last
sl@0: 			   pointer within the array which logically precedes
sl@0: 			   anEntry.
sl@0: 
sl@0: @leave KErrNotFound, if no suitable pointer can be found.
sl@0: */
sl@0: inline void RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const
sl@0: 	{ User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the pointer in the array that matches the specified pointer, using a
sl@0: binary search technique.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, the last
sl@0: or any matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param	anEntry The pointer to be found.
sl@0: @param	aMode   Specifies whether to find the first match, the last match or
sl@0:                 any match, as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return If there is a matching element, the array index of a matching element -  what
sl@0:         the index refers to depends on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows the
sl@0:         last matching element - if the last matching element is also the last element of the array,
sl@0:         then the index value is the same as the total number of elements in the array.
sl@0:         
sl@0: @leave  KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: inline TInt RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const
sl@0: 	{ return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the pointer in the array that matches the specified pointer, using a
sl@0: binary search technique.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, the last or
sl@0: any matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that pointers in the array are in address order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be found.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an index
sl@0:                value depending on whether a match is found and on the value of aMode.
sl@0:                If there is no matching element in the array, then this is the  index
sl@0:                of the first element in the array that is bigger than the element being
sl@0:                searched for - if no elements in the array are bigger, then the index
sl@0:                value is the same as the total number of elements in the array.
sl@0:                If there is a matching element, then what the index refers to depends
sl@0:                on the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element
sl@0:                of the array, then the index value is the same as the total number of elements in the array.
sl@0:                
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any match, as defined by
sl@0:                one of the TArrayFindMode enum values.
sl@0: 
sl@0: @leave  KErrNotFound, if no suitable pointer can be found.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: inline void RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an pointer into the array in address order.
sl@0: 
sl@0: No duplicate entries are permitted.  The function assumes that existing pointers
sl@0: within the array are in address order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be inserted.
sl@0: */
sl@0: inline void RPointerArray<TAny>::InsertInAddressOrderL(const TAny* anEntry)
sl@0: 	{ User::LeaveIfError(InsertInAddressOrder(anEntry)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an pointer into the array in address order, allowing duplicates.
sl@0: 
sl@0: If the new pointer is a duplicate of an existing pointer in the array, then the
sl@0: new pointer is inserted after the existing one. If more than one duplicate
sl@0: pointer already exists in the array, then any new duplicate pointer is inserted
sl@0: after the last one.
sl@0: 
sl@0: The function assumes that existing pointers within the array are in address
sl@0: order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The pointer to be inserted.
sl@0: */
sl@0: inline void RPointerArray<TAny>::InsertInAddressOrderAllowRepeatsL(const TAny* anEntry)
sl@0: 	{ User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
sl@0: 
sl@0: 
sl@0: /**
sl@0: Apends an object onto the array.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry    A reference to the object of type class T to be appended.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::AppendL(const T& anEntry)
sl@0: 	{ User::LeaveIfError(Append(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object into the array at a specified position.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The class T object to be inserted.
sl@0: @param aPos    The position within the array where the object is to
sl@0:                be inserted. The position is relative to zero, i.e. zero
sl@0: 			   implies that an object is inserted at the beginning of
sl@0: 			   the array.
sl@0: 			   
sl@0: @panic USER 131, if aPos is negative or is greater than the number of objects
sl@0:        currently in the array.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::InsertL(const T& anEntry, TInt aPos)
sl@0: 	{ User::LeaveIfError(Insert(anEntry, aPos));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the first object in the array which matches the specified object using 
sl@0: a sequential search.
sl@0: 
sl@0: Matching is based on the comparison of a TInt value at the key offset position 
sl@0: within the objects.
sl@0: 
sl@0: For classes which define their own equality operator (==), the alternative method
sl@0: FindL(const T& anEntry, TIdentityRelation<T> anIdentity) is recommended.
sl@0: 
sl@0: The find operation always starts at the low index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: 
sl@0: @return The index of the first matching object within the array. 
sl@0: @leave  KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::FindL(const T& anEntry) const
sl@0: 	{ return User::LeaveIfError(Find(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the first object in the array which matches the specified object using 
sl@0: a sequential search and a matching algorithm.
sl@0: 
sl@0: The algorithm for determining whether two class T type objects match is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: Such a function need not be supplied if an equality operator (==) is defined for class T. 
sl@0: In this case, default construction of anIdentity provides matching.
sl@0: 
sl@0: See Find(const T& anEntry, TIdentityRelation<T> anIdentity) for more details.
sl@0: 
sl@0: The find operation always starts at the low index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry    A reference to an object of type class T to be used
sl@0:                   for matching.
sl@0: @param anIdentity A package encapsulating the function which determines whether 
sl@0:                   two class T type objects match.
sl@0: 
sl@0: @return The index of the first matching object within the array.
sl@0: @leave  KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const
sl@0: 	{ return User::LeaveIfError(Find(anEntry, anIdentity));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the last object in the array which matches the specified object using 
sl@0: a sequential search.
sl@0: 
sl@0: Matching is based on the comparison of a TInt value at the key offset position 
sl@0: within the objects.
sl@0: 
sl@0: For classes which define their own equality operator (==), the alternative method
sl@0: FindReverseL(const T& anEntry, TIdentityRelation<T> anIdentity) is recommended.
sl@0: 
sl@0: The find operation always starts at the high index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: 
sl@0: @return The index of the last matching object within the array. 
sl@0: @leave  KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::FindReverseL(const T& anEntry) const
sl@0: 	{ return User::LeaveIfError(FindReverse(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the last object in the array which matches the specified object using 
sl@0: a sequential search and a matching algorithm.
sl@0: 
sl@0: The algorithm for determining whether two class T type objects match is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: Such a function need not be supplied if an equality operator (==) is defined for class T. 
sl@0: In this case, default construction of anIdentity provides matching.
sl@0: 
sl@0: See Find(const T& anEntry, TIdentityRelation<T> anIdentity) for more details.
sl@0: 
sl@0: The find operation always starts at the high index end of the array. There 
sl@0: is no assumption about the order of objects in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry    A reference to an object of type class T to be used
sl@0:                   for matching.
sl@0: @param anIdentity A package encapsulating the function which determines whether 
sl@0:                   two class T type objects match.
sl@0: 
sl@0: @return The index of the last matching object within the array.
sl@0: @leave  KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::FindReverseL(const T& anEntry, TIdentityRelation<T> anIdentity) const
sl@0: 	{ return User::LeaveIfError(FindReverse(anEntry, anIdentity));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The function assumes that existing objects within the array are in signed 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: 
sl@0: @return The index of the matching object within the array.
sl@0: @leave  KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::FindInSignedKeyOrderL(const T& anEntry) const
sl@0: 	{ return User::LeaveIfError(FindInSignedKeyOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The function assumes that existing objects within the array are in unsigned 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: 
sl@0: @return The index of the matching object within the array.
sl@0: @leave  KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry) const
sl@0: 	{ return User::LeaveIfError(FindInUnsignedKeyOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique and an ordering algorithm.
sl@0: 
sl@0: The function assumes that existing objects within the array are in object 
sl@0: order as determined by an algorithm supplied by the caller and packaged as 
sl@0: a TLinearOrder<T>.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: 
sl@0: @return The index of the matching object within the array.
sl@0: @leave  KErrNotFound if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const
sl@0: { return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The function assumes that existing objects within the array are in signed 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anIndex On return contains an index value of the matching object within the array.
sl@0:                If the function leaves with KErrNotFound,this is the index of the
sl@0:                first element in the array whose key is bigger than the key of the
sl@0:                element being sought. If there are no elements in the array with
sl@0:                a bigger key, then the index value is the same as the total 
sl@0:                number of elements in the array.
sl@0: @leave KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const
sl@0: 	{ User::LeaveIfError(FindInSignedKeyOrder(anEntry, anIndex));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The function assumes that existing objects within the array are in unsigned 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anIndex On return contains an index value of the matching object within the array. 
sl@0:                If the function leaves with KErrNotFound,  this is the index of the
sl@0:                first element in the array whose key is bigger than the key of the
sl@0:                element being sought. If there are no elements in the array with
sl@0:                a bigger key, then the index value is the same as the total 
sl@0:                number of elements in the array.
sl@0: @leave  KErrNotFound, if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const
sl@0: 	{ User::LeaveIfError(FindInUnsignedKeyOrder(anEntry, anIndex));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique and an ordering algorithm.
sl@0: 
sl@0: The function assumes that existing objects within the array are in object 
sl@0: order as determined by an algorithm supplied by the caller and packaged as 
sl@0: a TLinearOrder<T>.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anIndex On return contains the index value of the matching object within the array
sl@0:                If the function leaves with KErrNotFound, this is the index of
sl@0:                the first element in the array that is bigger than the element
sl@0:                being searched for - if no elements in the array are bigger,
sl@0:                then the index value is the same as the total number of elements
sl@0:                in the array.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: 
sl@0: @leave  KErrNotFound if no matching object can be found.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
sl@0: 	{ User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The element ordering is determined by a signed 32-bit word
sl@0: (the key) embedded in each array element. In the case that there is more than
sl@0: one matching element, finds the first, last or any match as specified.
sl@0: 
sl@0: The function assumes that existing objects within the array are in signed 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param	aMode  Specifies whether to find the first match, the last match or
sl@0:                any match, as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return The array index of a matching element - what the index refers to
sl@0:         depends on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:         the last matching element - if the last matching element is also the last element of
sl@0:         the array, then the index value is the same as the total number of elements in the array.
sl@0: @leave  KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const
sl@0: { return User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The element ordering is determined by an unsigned 32-bit word
sl@0: (the key) embedded in each array element. In the case that there is more than
sl@0: one matching element, finds the first, last or any match as specified.
sl@0: 
sl@0: The function assumes that existing objects within the array are in unsigned 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any
sl@0:         match, as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return The array index of a matching element -  what the index refers to
sl@0:         depends on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:         the last matching element - if the last matching element is also the last element
sl@0:         of the array, then the index value is the same as the total number of elements in the array.
sl@0:         
sl@0: @leave  KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const
sl@0: 	{ return User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique and an ordering algorithm.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, the last or
sl@0: any matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that existing objects within the array are in object 
sl@0: order as determined by an algorithm supplied by the caller and packaged as 
sl@0: a TLinearOrder<T> type.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any match,
sl@0:                as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return The array index of a matching element -  what the index refers to
sl@0:         depends on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:         the last matching element - if the last matching element is also the last element
sl@0:         of the array, then the index value is the same as the total number of elements in the array.
sl@0:         
sl@0: @leave KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline TInt RArray<T>::SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
sl@0: { return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The element ordering is determined by a signed 32-bit word
sl@0: (the key) embedded in each array element. In the case that there is more than
sl@0: one matching element, finds the first, last or any match as specified.
sl@0: 
sl@0: The function assumes that existing objects within the array are in signed 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an
sl@0:                index value depending on whether a match is found and on the
sl@0:                value of aMode. If there is no matching element in the array,
sl@0:                then this is the index of the first element in the array that
sl@0:                is bigger than the element being searched for - if no elements
sl@0:                in the array are bigger, then the index value is the same as
sl@0:                the total number of elements in the array.
sl@0:                If there is a matching element, then what the index refers to
sl@0:                depends on the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element
sl@0:                of the array, then the index value is the same as the total number of elements
sl@0:                in the array.
sl@0: @param aMode   Specifies whether to find the first match, the last match or any match,
sl@0:                as defined by one of the TArrayFindMode enum values.
sl@0:                
sl@0: @leave KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, anIndex, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique.
sl@0: 
sl@0: The element ordering is determined by an unsigned 32-bit word
sl@0: (the key) embedded in each array element. In the case that there is more than
sl@0: one matching element, finds the first, last or any match as specified.
sl@0: 
sl@0: The function assumes that existing objects within the array are in unsigned 
sl@0: key order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an
sl@0:                index value depending on whether a match is found and on the
sl@0:                value of aMode. If there is no matching element in the array,
sl@0:                then this is the index of the first element in the array that
sl@0:                is bigger than the element being searched for - if no elements
sl@0:                in the array are bigger, then the index value is the same as
sl@0:                the total number of elements in the array. If there is a matching
sl@0:                element, then what the index refers to depends on the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element
sl@0:                of the array, then the index value is the same as the total number of elements in the array.
sl@0: @param aMode   Specifies whether to find the first match, the last match or any match,
sl@0:                as defined by one of the  TArrayFindMode enum values.
sl@0:                
sl@0: @leave KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, anIndex, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the object in the array which matches the specified object using a binary 
sl@0: search technique and a specified ordering algorithm.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, the last or
sl@0: any matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that existing objects within the array are in object 
sl@0: order as determined by an algorithm supplied by the caller and packaged as 
sl@0: a TLinearOrder<T> type.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to an object of type class T to be used for matching.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an
sl@0:                index value depending on whether a match is found and on the value
sl@0:                of aMode. If there is no matching element in the array, then this is
sl@0:                the  index of the first element in the array that is bigger than the
sl@0:                element being searched for - if no elements in the array are bigger,
sl@0:                then the index value is the same as the total number of elements
sl@0:                in the array. If there is a matching element, then what the index
sl@0:                refers to depends on the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element
sl@0:                of the array, then the index value is the same as the total number of elements in the array.
sl@0:                
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: @param aMode   Specifies whether to find the first match, the last match or any match,
sl@0:                as defined by one of the TArrayFindMode enum values.
sl@0:                
sl@0: @leave KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object into the array in ascending signed key order.
sl@0: 
sl@0: The order of two class T type objects is based on comparing a TInt value
sl@0: located at the key offset position within the class T object.
sl@0: 
sl@0: No duplicate entries are permitted.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: Note that the array remains unchanged following an attempt to insert a duplicate entry.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to the object of type class T to be inserted.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::InsertInSignedKeyOrderL(const T& anEntry)
sl@0: 	{ User::LeaveIfError(InsertInSignedKeyOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object into the array in ascending unsigned key order, not allowing 
sl@0: duplicate entries.
sl@0: 
sl@0: The order of two class T type objects is based on comparing a TUint value 
sl@0: located at the key offset position within the class T object. 
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: Note that the array remains unchanged following an attempt to insert a duplicate entry.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to the object of type class T to be inserted.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::InsertInUnsignedKeyOrderL(const T& anEntry)
sl@0: 	{ User::LeaveIfError(InsertInUnsignedKeyOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object of into the array in object order.
sl@0: 
sl@0: The algorithm for determining the order of two class T type objects is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: No duplicate entries are permitted.
sl@0: 
sl@0: The function assumes that existing objects within the array are in object 
sl@0: order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: Note that the array remains unchanged following an attempt to insert a duplicate entry.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to the object of type class T to be inserted.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder)
sl@0: 	{ User::LeaveIfError(InsertInOrder(anEntry, anOrder));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object into the array in ascending signed key order,
sl@0: allowing duplicates.
sl@0: 
sl@0: The order of two class T type objects is based on comparing a TInt value
sl@0: located at the key offset position within the class T object. 
sl@0: 
sl@0: If anEntry is a duplicate of an existing object in the array, then the new 
sl@0: object is inserted after the existing object. If more than one duplicate object 
sl@0: already exists in the array, then any new duplicate object is inserted after 
sl@0: the last one.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to the object of type class T to be inserted.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry)
sl@0: 	{ User::LeaveIfError(InsertInSignedKeyOrderAllowRepeats(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object into the array in ascending unsigned key order, allowing 
sl@0: duplicates.
sl@0: 
sl@0: The order of two class T type objects is based on comparing a TUint value 
sl@0: located at the key offset position within the class T object. 
sl@0: 
sl@0: If anEntry is a duplicate of an existing object in the array, then the new 
sl@0: object is inserted after the existing object. If more than one duplicate object 
sl@0: already exists in the array, then any new duplicate object is inserted after 
sl@0: the last one.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to the object of type class T to be inserted.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry)
sl@0: 	{ User::LeaveIfError(InsertInUnsignedKeyOrderAllowRepeats(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an object into the array in object order, allowing duplicates.
sl@0: 
sl@0: The algorithm for determining the order of two class T type objects is provided 
sl@0: by a function supplied by the caller.
sl@0: 
sl@0: If anEntry is a duplicate of an existing object in the array, then the new 
sl@0: object is inserted after the existing object. If more than one duplicate object 
sl@0: already exists in the array, then anEntry is inserted after the last one.
sl@0: 
sl@0: The function assumes that existing objects within the array are in object 
sl@0: order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry A reference to the object of type class T to be inserted.
sl@0: @param anOrder A package encapsulating the function which determines the order 
sl@0:                of two class T objects.
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder)
sl@0: 	{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder));}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Reserves space for the specified number of elements.
sl@0: 
sl@0: After a call to this function, the memory allocated to the array is sufficient 
sl@0: to hold the number of objects specified. Adding new objects to the array 
sl@0: does not result in a re-allocation of memory until the the total number of 
sl@0: objects exceeds the specified count.
sl@0: 
sl@0: @param	aCount	The number of objects for which space should be reserved
sl@0: @leave KErrNoMemory	If the requested amount of memory could not be allocated
sl@0: */
sl@0: template <class T>
sl@0: inline void RArray<T>::ReserveL(TInt aCount)
sl@0: 	{ User::LeaveIfError(RArrayBase::DoReserve(aCount)); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Appends a signed integer onto the array.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The signed integer to be appended.
sl@0: */
sl@0: inline void RArray<TInt>::AppendL(TInt anEntry)
sl@0: 	{ User::LeaveIfError(Append(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts a signed integer into the array at the specified position.
sl@0: 	
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The signed integer to be inserted.
sl@0: @param aPos    The position within the array where the signed integer is to be 
sl@0: 	           inserted. The position is relative to zero, i.e. zero implies
sl@0: 			   that an entry is inserted at the beginning of the array.
sl@0: 		   
sl@0: @panic USER 131, if aPos is negative, or is greater than the number of entries
sl@0:        currently in the array.
sl@0: */
sl@0: inline void RArray<TInt>::InsertL(TInt anEntry, TInt aPos)
sl@0: 	{ User::LeaveIfError(Insert(anEntry, aPos));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the first signed integer in the array which matches the specified signed 
sl@0: integer using a sequential search.
sl@0: 
sl@0: The find operation always starts at the low index end of the array. There 
sl@0: is no assumption about the order of entries in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 	
sl@0: @param anEntry The signed integer to be found.
sl@0: 
sl@0: @return The index of the first matching signed integer within the array.
sl@0: @leave  KErrNotFound, if no matching entry can be found.
sl@0: */
sl@0: inline TInt RArray<TInt>::FindL(TInt anEntry) const
sl@0: 	{ return User::LeaveIfError(Find(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the last signed integer in the array which matches the specified signed 
sl@0: integer using a sequential search.
sl@0: 
sl@0: The find operation always starts at the high index end of the array. There 
sl@0: is no assumption about the order of entries in the array.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 	
sl@0: @param anEntry The signed integer to be found.
sl@0: 
sl@0: @return The index of the last matching signed integer within the array.
sl@0: @leave  KErrNotFound, if no matching entry can be found.
sl@0: */
sl@0: inline TInt RArray<TInt>::FindReverseL(TInt anEntry) const
sl@0: 	{ return User::LeaveIfError(FindReverse(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the signed integer in the array that matches the specified signed integer 
sl@0: using a binary search technique.
sl@0: 
sl@0: The function assumes that the array is in signed integer order.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The signed integer to be found.
sl@0: 
sl@0: @return The index of the matching signed integer within the array.
sl@0: @leave  KErrNotFound, if no match can be found.
sl@0: */
sl@0: inline TInt RArray<TInt>::FindInOrderL(TInt anEntry) const
sl@0: 	{ return User::LeaveIfError(FindInOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the signed integer in the array that matches the specified signed integer
sl@0: using a binary search technique.
sl@0: 	
sl@0: The function assumes that the array is in signed integer order.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The signed integer to be found.
sl@0: @param anIndex A reference to a signed integer into which the
sl@0:                function puts an index value: If the function returns ,
sl@0:                this is the index of the matching signed integer within the
sl@0:                array. If the function leaves with KErrNotFound, this is the
sl@0:                index of the first signed integer within the array that is
sl@0:                bigger than the signed integer being searched for - if no
sl@0:                signed integers within the array are bigger, then the index
sl@0:                value is the same as the total number of signed integers
sl@0:                within the array.
sl@0: @leave  KErrNotFound if no  match can be found.
sl@0: */
sl@0: inline void RArray<TInt>::FindInOrderL(TInt anEntry, TInt& anIndex) const
sl@0: 	{ User::LeaveIfError(FindInOrder(anEntry, anIndex));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the signed integer in the array that matches the specified signed integer 
sl@0: using a binary search technique.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, last or any
sl@0: matching element  as specified by the value of aMode.
sl@0: 	
sl@0: The function assumes that the array is in signed integer order.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The signed integer to be found.
sl@0: @param aMode   Specifies whether to find the first match, the last match or
sl@0:                any match, as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return The array index of a matching element - what the index refers to
sl@0:         depends on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:         the last matching element - if the last matching element is also the last element
sl@0:         of the array, then the index value is the same as the total number of elements in the array.
sl@0:         
sl@0: @leave  KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: inline TInt RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt aMode) const
sl@0: 	{ return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the signed integer in the array that matches the specified signed integer
sl@0: using a binary search technique.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, last or any
sl@0: matching element  as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that the array is in signed integer order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 	
sl@0: @param anEntry The signed integer to be found.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an
sl@0:                index value depending on whether a match is found and on the value of aMode.
sl@0:                If there is no matching element in the array, then this is
sl@0:                the  index of the first element in the array that is bigger
sl@0:                than the element being searched for - if no elements in the
sl@0:                array are bigger, then the index value is the same as the total
sl@0:                number of elements in the array. If there is a matching element,
sl@0:                then what the index refers to depends on the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element
sl@0:                of the array, then the index value is the same as the total number of elements in the array.
sl@0:                
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any match, as defined
sl@0:                by one of the TArrayFindMode enum values.
sl@0:                
sl@0: @leave KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: inline void RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts a signed integer into the array in signed integer order.
sl@0: 
sl@0: No duplicate entries are permitted.
sl@0: 
sl@0: The function assumes that existing entries within the array are in signed 
sl@0: integer order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 
sl@0: Note that the array remains unchanged following an attempt to insert a duplicate entry. 
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 
sl@0: @param anEntry The signed integer to be inserted.
sl@0: */
sl@0: inline void RArray<TInt>::InsertInOrderL(TInt anEntry)
sl@0: 	{ User::LeaveIfError(InsertInOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts a signed integer into the array in signed integer order,
sl@0: allowing duplicates.
sl@0: 
sl@0: If anEntry is a duplicate of an existing entry in the array, then the new 
sl@0: signed integer is inserted after the existing one. If more than one duplicate 
sl@0: entry already exists in the array, then any new duplicate signed integer is 
sl@0: inserted after the last one.
sl@0: 
sl@0: The function assumes that existing entries within the array are in signed 
sl@0: integer order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 	
sl@0: @param anEntry The signed integer to be inserted.
sl@0: */
sl@0: inline void RArray<TInt>::InsertInOrderAllowRepeatsL(TInt anEntry)
sl@0: 	{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Reserves space for the specified number of elements.
sl@0: 
sl@0: After a call to this function, the memory allocated to the array is sufficient 
sl@0: to hold the number of integers specified. Adding new integers to the array 
sl@0: does not result in a re-allocation of memory until the the total number of 
sl@0: integers exceeds the specified count.
sl@0: 
sl@0: @param	aCount	The number of integers for which space should be reserved
sl@0: @leave KErrNoMemory	If the requested amount of memory could not be allocated
sl@0: */
sl@0: inline void RArray<TInt>::ReserveL(TInt aCount)
sl@0: 	{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Appends an unsigned integer onto the array.
sl@0: 	
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The unsigned integer to be appended.
sl@0: */
sl@0: inline void RArray<TUint>::AppendL(TUint anEntry)
sl@0: 	{ User::LeaveIfError(Append(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an unsigned integer into the array at the specified position.
sl@0: 	
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry  The unsigned integer to be inserted.
sl@0: @param aPos     The position within the array where the unsigned integer is to 
sl@0: 	            be inserted. The position is relative to zero, i.e. zero
sl@0: 				implies that an entry is inserted at the beginning of
sl@0: 				the array.
sl@0: 			
sl@0: @panic USER 131, if aPos is negative, or is greater than the number of entries
sl@0:        currently in the array.
sl@0: */
sl@0: inline void RArray<TUint>::InsertL(TUint anEntry, TInt aPos)
sl@0: 	{ User::LeaveIfError(Insert(anEntry, aPos));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the first unsigned integer in the array which matches the specified
sl@0: value, using a sequential search.
sl@0: 
sl@0: The find operation always starts at the low index end of the array. There 
sl@0: is no assumption about the order of entries in the array.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The unsigned integer to be found.
sl@0: @return The index of the first matching unsigned integer within the array.
sl@0: @leave  KErrNotFound, if no matching entry can be found.
sl@0: */
sl@0: inline TInt RArray<TUint>::FindL(TUint anEntry) const
sl@0: 	{ return User::LeaveIfError(Find(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the last unsigned integer in the array which matches the specified
sl@0: value, using a sequential search.
sl@0: 
sl@0: The find operation always starts at the high index end of the array. There 
sl@0: is no assumption about the order of entries in the array.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The unsigned integer to be found.
sl@0: @return The index of the last matching unsigned integer within the array.
sl@0: @leave  KErrNotFound, if no matching entry can be found.
sl@0: */
sl@0: inline TInt RArray<TUint>::FindReverseL(TUint anEntry) const
sl@0: 	{ return User::LeaveIfError(FindReverse(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the unsigned integer in the array which matches the specified value, 
sl@0: using a binary search technique.
sl@0: 	
sl@0: The functions assume that existing entries within the array are in unsigned 
sl@0: integer order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 	
sl@0: @param anEntry The unsigned integer to be found.
sl@0: 
sl@0: @return The index of the matching unsigned integer within the array;
sl@0: @leave  KErrNotFound, if no matching entry can be found.
sl@0: */
sl@0: inline TInt RArray<TUint>::FindInOrderL(TUint anEntry) const
sl@0: 	{ return User::LeaveIfError(FindInOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the unsigned integer in the array which matches the specified value, 
sl@0: using a binary search technique.
sl@0: 
sl@0: If the index cannot be found, the function returns the index of the last
sl@0: unsigned integer within the array which logically precedes anEntry.
sl@0: The functions assume that existing entries within the array are in unsigned 
sl@0: integer order.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 	
sl@0: @param anEntry The unsigned integer to be found.
sl@0: @param anIndex A TInt supplied by the caller. On return, contains an index
sl@0:                value of the matching unsigned integer within the array. 
sl@0:                If the function leaves with KErrNotFound, this is the index of the
sl@0:                first unsigned integer within the array that is bigger than the
sl@0:                unsigned integer being searched for - if no unsigned integers within
sl@0:                the array are bigger, then the index value is the same as the
sl@0:                total number of unsigned integers within the array.
sl@0: 
sl@0: @leave  KErrNotFound, if no matching entry can be found.
sl@0: */
sl@0: inline void RArray<TUint>::FindInOrderL(TUint anEntry, TInt& anIndex) const
sl@0: 	{ User::LeaveIfError(FindInOrder(anEntry, anIndex));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the unsigned integer in the array that matches the specified unsigned integer 
sl@0: using a binary search technique.
sl@0: 
sl@0: In the case that there is more than one matching element, finds the first, last or any
sl@0: match as specified.
sl@0: 	
sl@0: The function assumes that the array is in unsigned integer order.
sl@0: 
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.
sl@0: 	
sl@0: @param anEntry The unsigned integer to be found.
sl@0: @param aMode   Specifies whether to find the first match, the last match or 
sl@0:                any match, as defined by one of the TArrayFindMode enum values.
sl@0: 
sl@0: @return The array index of a matching element - what the index refers to depends
sl@0:         on the value of aMode:
sl@0:         if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:         if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:         if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:         the last matching element - if the last matching element is also the last element
sl@0:         of the array, then the index value is the same as the total number of elements in the array.
sl@0:         
sl@0: @leave KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: inline TInt RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt aMode) const
sl@0: 	{ return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Finds the unsigned integer in the array that matches the specified unsigned integer
sl@0: using a binary search technique.
sl@0: 
sl@0: Where there is more than one matching element, it finds the first, last or
sl@0: any matching element as specified by the value of aMode.
sl@0: 
sl@0: The function assumes that the array is in unsigned integer order.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The unsigned integer to be found.
sl@0: @param anIndex A TInt type supplied by the caller. On return, it contains an index
sl@0:                value depending on whether a match is found and on the value of aMode.
sl@0:                If there is no matching element in the array, then this is the
sl@0:                index of the first element in the array that is bigger than the element
sl@0:                being searched for - if no elements in the array are bigger, then
sl@0:                the index value is the same as the total number of elements in the array.
sl@0:                If there is a matching element, then what the index refers to depends on
sl@0:                the value of aMode:
sl@0:                if this is EArrayFindMode_First, then the index refers to the first matching element;
sl@0:                if this is EArrayFindMode_Any, then the index can refer to any of the matching elements;
sl@0:                if this is EArrayFindMode_Last, then the index refers to first element that follows
sl@0:                the last matching element - if the last matching element is also the last element of the array,
sl@0:                then the index value is the same as the total number of elements in the array.
sl@0:                
sl@0: @param	aMode  Specifies whether to find the first match, the last match or any match, as defined by
sl@0:                one of the TArrayFindMode enum values.
sl@0: @leave KErrNotFound if no matching entry exists.
sl@0: 
sl@0: @see TArrayFindMode
sl@0: */
sl@0: inline void RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const
sl@0: 	{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an unsigned integer into the array in unsigned integer order.
sl@0: 
sl@0: No duplicate entries are permitted.
sl@0: 
sl@0: The function assumes that existing entries within the array are in unsigned 
sl@0: integer order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 	
sl@0: Note that the array remains unchanged following an attempt to insert a duplicate entry.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The unsigned integer to be inserted.
sl@0: */
sl@0: inline void RArray<TUint>::InsertInOrderL(TUint anEntry)
sl@0: 	{ User::LeaveIfError(InsertInOrder(anEntry));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Inserts an unsigned integer into the array in unsigned integer order, allowing 
sl@0: duplicates.
sl@0: 
sl@0: If the new integer is a duplicate of an existing entry in the array, then 
sl@0: the new unsigned integer is inserted after the existing one. If more than 
sl@0: one duplicate entry already exists in the array, then any new duplicate
sl@0: unsigned integer is inserted after the last one.
sl@0: 	
sl@0: The function assumes that existing entries within the array are in unsigned 
sl@0: integer order.
sl@0: 
sl@0: The function leaves with one of the system wide error codes, if the operation fails.
sl@0: 	
sl@0: NOTE: This function is NOT AVAILABLE to code running on the kernel side.	
sl@0: 	
sl@0: @param anEntry The unsigned integer to be inserted.
sl@0: */
sl@0: inline void RArray<TUint>::InsertInOrderAllowRepeatsL(TUint anEntry)
sl@0: 	{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Reserves space for the specified number of elements.
sl@0: 
sl@0: After a call to this function, the memory allocated to the array is sufficient 
sl@0: to hold the number of integers specified. Adding new integers to the array 
sl@0: does not result in a re-allocation of memory until the the total number of 
sl@0: integers exceeds the specified count.
sl@0: 
sl@0: @param	aCount	The number of integers for which space should be reserved
sl@0: @leave KErrNoMemory	If the requested amount of memory could not be allocated
sl@0: */
sl@0: inline void RArray<TUint>::ReserveL(TInt aCount)
sl@0: 	{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
sl@0: 
sl@0: 
sl@0: 
sl@0: // class TChunkHeapCreateInfo
sl@0: /**
sl@0: Sets single thread property of the chunk heap.
sl@0: 
sl@0: This overrides any previous call to TChunkHeapCreateInfo::SetSingleThread()
sl@0: for this TChunkHeapCreateInfo object.
sl@0: 
sl@0: @param aSingleThread	ETrue when the chunk heap is to be single threaded,
sl@0: 						EFalse otherwise.
sl@0: */
sl@0: inline void TChunkHeapCreateInfo::SetSingleThread(const TBool aSingleThread)
sl@0: 	{
sl@0: 	iSingleThread = aSingleThread;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets alignment of the cells of the chunk heap to be created.
sl@0: 
sl@0: This overrides any previous call to TChunkHeapCreateInfo::SetAlignment()
sl@0: for this TChunkHeapCreateInfo object.
sl@0: 
sl@0: @param aAlignment	The alignment of the heap cells.
sl@0: */
sl@0: inline void TChunkHeapCreateInfo::SetAlignment(TInt aAlign)
sl@0: 	{
sl@0: 	iAlign = aAlign;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the increments to the size of the host chunk.  If the supplied value is 
sl@0: less than KMinHeapGrowBy, it is discarded and the value KMinHeapGrowBy is 
sl@0: used instead.
sl@0: 
sl@0: This overrides any previous call to TChunkHeapCreateInfo::SetGrowBy()
sl@0: for this TChunkHeapCreateInfo object.
sl@0: 
sl@0: @param aGrowBy	The increment to the size of the host chunk.
sl@0: */
sl@0: inline void TChunkHeapCreateInfo::SetGrowBy(TInt aGrowBy)
sl@0: 	{
sl@0: 	iGrowBy = aGrowBy;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the offset from the base of the host chunk to the start of the heap.
sl@0: 
sl@0: This overrides any previous call to TChunkHeapCreateInfo::SetOffset()
sl@0: for this TChunkHeapCreateInfo object.
sl@0: 
sl@0: @param aOffset	The offset in bytes.
sl@0: */
sl@0: inline void TChunkHeapCreateInfo::SetOffset(TInt aOffset)
sl@0: 	{
sl@0: 	iOffset = aOffset;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the mode flags of the chunk heap.
sl@0: 
sl@0: This overrides any previous call to TChunkHeapCreateInfo::SetMode()
sl@0: for this TChunkHeapCreateInfo object.
sl@0: 
sl@0: @param aMode	The mode flags for the chunk heap to be created, this should be
sl@0: 				one or more of the values from TChunkHeapCreateMode.
sl@0: */
sl@0: inline void TChunkHeapCreateInfo::SetMode(TUint aMode)
sl@0: 	{
sl@0: 	iMode = aMode;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the paging attribute of the chunk heap to be created.
sl@0: 
sl@0: This overrides any previous call to TChunkHeapCreateInfo::SetPaging()
sl@0: for this TChunkHeapCreateInfo object.
sl@0: 
sl@0: @param aPaging	The paging attribute for the chunk heap to be created.
sl@0: */
sl@0: inline void TChunkHeapCreateInfo::SetPaging(const TChunkHeapPagingAtt aPaging)
sl@0: 	{
sl@0: 	iPaging = aPaging;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Sets the priority of the client's process.
sl@0: 
sl@0: @param aPriority The priority value.
sl@0: */
sl@0: inline void RMessagePtr2::SetProcessPriorityL(TProcessPriority aPriority) const
sl@0: 	{ User::LeaveIfError(SetProcessPriority(aPriority));}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Opens a handle on the client thread.
sl@0: 
sl@0: @param aClient    On successful return, the handle to the client thread.
sl@0: @param aOwnerType An enumeration whose enumerators define the ownership of
sl@0:                   the handle. If not explicitly specified,
sl@0:                   EOwnerProcess is taken as default.
sl@0: */
sl@0: inline void RMessagePtr2::ClientL(RThread& aClient, TOwnerType aOwnerType) const
sl@0: 	{ User::LeaveIfError(Client(aClient, aOwnerType));}
sl@0: 
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: inline TBool RMessagePtr2::HasCapability(TCapability aCapability, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: inline void RMessagePtr2::HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage) const
sl@0: 	{
sl@0: 	if (!HasCapability(aCapability, aDiagnosticMessage))
sl@0: 		{
sl@0: 		User::Leave(KErrPermissionDenied);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: inline TBool RMessagePtr2::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
sl@0: 	}
sl@0: 
sl@0: inline void RMessagePtr2::HasCapabilityL(TCapability aCapability1, TCapability aCapability2, const char* aDiagnosticMessage) const
sl@0: 	{
sl@0: 	if (!HasCapability(aCapability1, aCapability2, aDiagnosticMessage))
sl@0: 		{
sl@0: 		User::Leave(KErrPermissionDenied);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: // Only available to NULL arguments
sl@0: inline TBool RMessagePtr2::HasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability);
sl@0: 	}
sl@0: 
sl@0: inline void RMessagePtr2::HasCapabilityL(TCapability aCapability, OnlyCreateWithNull /*aDiagnosticMessage*/) const
sl@0: 	{
sl@0: 	if (!DoHasCapability(aCapability))
sl@0: 		{
sl@0: 		User::Leave(KErrPermissionDenied);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: inline TBool RMessagePtr2::HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2);
sl@0: 	}
sl@0: 
sl@0: inline void RMessagePtr2::HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnosticMessage*/) const
sl@0: 	{
sl@0: 	if (!DoHasCapability(aCapability1, aCapability2))
sl@0: 		{
sl@0: 		User::Leave(KErrPermissionDenied);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: // For things using KSuppressPlatSecDiagnostic
sl@0: inline TBool RMessagePtr2::HasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline void RMessagePtr2::HasCapabilityL(TCapability aCapability, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	if (!DoHasCapability(aCapability, KSuppressPlatSecDiagnosticMagicValue))
sl@0: 		{
sl@0: 		User::Leave(KErrPermissionDenied);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: inline TBool RMessagePtr2::HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	return DoHasCapability(aCapability1, aCapability2, KSuppressPlatSecDiagnosticMagicValue);
sl@0: 	}
sl@0: 
sl@0: inline void RMessagePtr2::HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull /*aDiagnostic*/, OnlyCreateWithNull /*aSuppress*/) const
sl@0: 	{
sl@0: 	if (!DoHasCapability(aCapability1, aCapability2, KSuppressPlatSecDiagnosticMagicValue))
sl@0: 		{
sl@0: 		User::Leave(KErrPermissionDenied);
sl@0: 		}
sl@0: 	}
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0: 
sl@0: #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0: 
sl@0: inline TInt RThread::RenameMe(const TDesC& aName)
sl@0: 	{ return User::RenameThread(aName); }
sl@0: inline TInt RProcess::RenameMe(const TDesC& aName)
sl@0: 	{ return User::RenameProcess(aName); }
sl@0: 
sl@0: 
sl@0: #endif // !__KERNEL_MODE__
sl@0: 
sl@0: #ifdef __SUPPORT_CPP_EXCEPTIONS__
sl@0: // The standard header file <exception> defines the following guard macro for EDG and CW, VC++, GCC respectively.
sl@0: // The guard below is ugly. It will surely come back and bite us unless we resolve the whole issue of standard headers
sl@0: // when we move to supporting Standard C++.
sl@0: 
sl@0: // The macro __SYMBIAN_STDCPP_SUPPORT__ is defined when building a StdC++ target.
sl@0: // In this case, we wish to avoid defining uncaught_exception below since it clashes with the StdC++ specification 
sl@0: #if !defined(_EXCEPTION) && !defined(_EXCEPTION_) && !defined(__EXCEPTION__) && !defined(__SYMBIAN_STDCPP_SUPPORT__)
sl@0: 
sl@0: #if defined(__VC32__) && !defined(_CRTIMP_PURE)
sl@0: 
sl@0: 	// Declare MS EH runtime functions
sl@0: 	bool __uncaught_exception(void);
sl@0: 
sl@0: #if _MSC_VER >= 1200
sl@0: 	__declspec(noreturn) void terminate(void);
sl@0: 	__declspec(noreturn) void unexpected(void);
sl@0: #else
sl@0: 	void terminate(void);
sl@0: 	void unexpected(void);
sl@0: #endif
sl@0: 
sl@0: 	typedef void (*terminate_handler)();
sl@0: 	terminate_handler set_terminate(terminate_handler h) throw();
sl@0: 	typedef void (*unexpected_handler)();
sl@0: 	unexpected_handler set_unexpected(unexpected_handler h) throw();
sl@0: 
sl@0: namespace std {
sl@0: #ifdef __MSVCDOTNET__
sl@0: 	inline bool uncaught_exception(void) { return ::__uncaught_exception(); }
sl@0: #else // !__MSVCDOTNET__
sl@0: 	// MS KB242192: BUG: uncaught_exception() Always Returns False
sl@0: 	inline bool uncaught_exception(void) { return false; }
sl@0: #endif //__MSVCDOTNET__
sl@0: 	inline void terminate(void) { ::terminate(); }
sl@0: 	inline void unexpected(void) { ::unexpected(); }
sl@0: 	inline terminate_handler set_terminate(terminate_handler h) throw() { return ::set_terminate(h); }
sl@0: 	inline unexpected_handler set_unexpected(unexpected_handler h) throw() { return ::set_unexpected(h); }
sl@0: }
sl@0: 
sl@0: #endif // extract from MSVC headers
sl@0: 
sl@0: #ifdef __CW32__
sl@0: 
sl@0: 	extern "C" bool __uncaught_exception(void);
sl@0: 
sl@0: namespace std {
sl@0: #if __MWERKS__ > 0x3200
sl@0: 	inline bool uncaught_exception(void) { return ::__uncaught_exception(); }
sl@0: #else
sl@0: 	// no uncaught_exception() implementation on CW 2.4.7
sl@0: 	inline bool uncaught_exception(void) { return false; }
sl@0: #endif
sl@0: }
sl@0: 
sl@0: #endif // extract from CW headers
sl@0: 
sl@0: #endif // <exception> header guard
sl@0: 
sl@0: #endif //__SUPPORT_CPP_EXCEPTIONS__