// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32\include\e32cmn.h

 // 

 //

 #ifndef __E32CMN_H__

 #define __E32CMN_H__

 #include <e32const.h>

 extern "C" {

 /**

 @publishedAll

 @released

 A Nanokernel utility function that compares two memory buffers for equality.

 The two buffers are considered equal only if:

 1. the buffers have the same length

 and

 2. the binary content of both buffers is the same.

 @param aLeft     The start address of the first buffer in the comparison.

 @param aLeftLen  The length of the first buffer in the comparison.

 @param aRight    The start address of the second buffer in the comparison.

 @param aRightLen The length of the second buffer in the comparison.

 @return Zero if both buffers are equal; non-zero, otherwise.

 @panic USER 88        In debug mode only, if aLeftL is negative, 

                       and the function is called on the user side.

 @panic KERN-COMMON 88 In debug mode only, if aLeftL is negative,

                       and the function is called on the kernel side.

 @panic USER 89        In debug mode only, if aRightL is negative, 

                       and the function is called on the user side.

 @panic KERN-COMMON 89 In debug mode only, if aRightL is negative,

                       and the function is called on the kernel side.

 */

 IMPORT_C TInt memcompare(const TUint8* aLeft, TInt aLeftLen, const TUint8* aRight, TInt aRightLen);

 /**

 @publishedAll

 @released

 A Nanokernel utility function that moves (copies) bytes in memory.

 The function assumes that the addresses are aligned on word boundaries,

 and that the length value is a multiple of 4.

 @param aTrg    The target address.

 @param aSrc    The source address.

 @param aLength The number of bytes to be moved.

 @return The target address.

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

                       and the function is called on the user side.

 @panic KERN-COMMON 91 In debug mode only, if aLength is not a multiple of 4,

                       and the function is called on the kernel side.

 @panic USER 92        In debug mode only, if aSrc is not aligned on a word boundary,

                       and the function is called on the user side.

 @panic KERN-COMMON 92 In debug mode only, if aSrc is not aligned on a word boundary,

                       and the function is called on the kernel side.

 @panic USER 93        In debug mode only, if aTrg is not aligned on a word boundary,

                       and the function is called on the user side.

 @panic KERN-COMMON 93 In debug mode only, if aTrg is not aligned on a word boundary,

                       and the function is called on the kernel side.

 */

 IMPORT_C TAny* wordmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength);

 /**

 @publishedAll

 @released

 A Nanokernel utility function that sets the specified number of bytes

 to binary zero.

 @param aTrg    The start address.

 @param aLength The number of bytes to be set.

 @return The target address.

 */

 IMPORT_C TAny* memclr(TAny* aTrg, unsigned int aLength);

 }

 #ifndef __TOOLS__

 extern "C" {

 /**

 @publishedAll

 @released

 A Nanokernel utility function that sets all of the specified number of bytes to

 the specified fill value.

 @param aTrg    The start address.

 @param aValue  The fill value (the first or junior byte).

 @param aLength The number of bytes to be set.

 @return The target address.

 */

 	IMPORT_C TAny* memset(TAny* aTrg, TInt aValue, unsigned int aLength);

 /**

 @publishedAll

 @released

 A Nanokernel utility function that copies bytes in memory.

 @param aTrg    The target address.

 @param aSrc    The source address.

 @param aLength The number of bytes to be moved.

 @return The target address.

 */

 	IMPORT_C TAny* memcpy(TAny* aTrg, const TAny* aSrc, unsigned int aLength);

 /**

 @publishedAll

 @released

 A Nanokernel utility function that moves (copies) bytes in memory.

 @param aTrg    The target address.

 @param aSrc    The source address.

 @param aLength The number of bytes to be moved.

 @return The target address.

 */

 	IMPORT_C TAny* memmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength);

 }

 #else

 #include <string.h>

 #endif

 /** 

 @publishedAll

 @released

 Tests whether the specified value is less than or equal to the

 specified upper limit.

 @param aVal   The value to be tested.

 @param aLimit The upper limit.

 @return True, if the value is less than or equal to the specified upper limit;

         false, otherwise.

 */

 inline TInt Lim(TInt aVal,TUint aLimit)

 	{return(((TUint)aVal)<=aLimit);}

 /** 

 @publishedAll

 @released

 Tests whether the specified value is strictly less than the

 specified upper limit.

 @param aVal   The value to be tested.

 @param aLimit The upper limit.

 @return True, if the value is strictly less than the specified upper limit;

         false, otherwise.

 */

 inline TInt LimX(TInt aVal,TUint aLimit)

 	{return(((TUint)aVal)<aLimit);}

 /** 

 @publishedAll

 @released

 Returns the smaller of two values.

 @param aLeft  The first value to be compared.

 @param aRight The second value to be compared.

 @return The smaller value.

 */

 template <class T>

 inline T Min(T aLeft,T aRight)

 	{return(aLeft<aRight ? aLeft : aRight);}

 /**

 @publishedAll

 @released

 Returns the smaller of two objects, where the right hand object is a treated

 as a TInt for the  purpose of comparison.

 @param aLeft  The first value to be compared.

 @param aRight The second value to be compared.

 @return The smaller value.

 */

 template <class T>

 inline T Min(T aLeft,TUint aRight)

 	{return(aLeft<(TInt)aRight ? aLeft : (T)aRight);}

 /** 

 @publishedAll

 @released

 Returns the larger of two values.

 @param aLeft  The first value to be compared.

 @param aRight The second value to be compared.

 @return The larger value.

 */

 template <class T>

 inline T Max(T aLeft,T aRight)

 	{return(aLeft<aRight ? aRight : aLeft);}

 /**

 @publishedAll

 @released

 Returns the larger of two objects, where the right hand object is a treated

 as a TInt for the  purpose of comparison.

 @param aLeft  The first value to be compared.

 @param aRight The second value to be compared.

 @return The larger value.

 */

 template <class T>

 inline T Max(T aLeft,TUint aRight)

 	{return(aLeft<(TInt)aRight ? (TInt)aRight : aLeft);}

 /**

 @publishedAll

 @released

 Returns an absolute value.

 @param aVal The source value.

 @return The absolute value

 */

 template <class T>

 inline T Abs(T aVal)

 	{return(aVal<0 ? -aVal : aVal);}

 /** 

 @publishedAll

 @released

 Determines whether a specified value lies within a defined range of values.

 @param aMin The lower value of the range.

 @param aVal The value to be compared.

 @param aMax The higher value of the range.

 @return True, if the specified value lies within the range; false, otherwise.

 */

 template <class T>

 inline TBool Rng(T aMin,T aVal,T aMax)

 	{return(aVal>=aMin && aVal<=aMax);}

 /**

 @publishedAll

 @released

 Adds a value to a pointer.

 @param aPtr Pointer to an object of type T.

 @param aVal The value to be added.

 @return The resulting pointer value, as a pointer to a type T.

 */

 template <class T,class S>

 inline T* PtrAdd(T* aPtr,S aVal)

 	{return((T*)(((TUint8*)aPtr)+aVal));}

 /**

 @publishedAll

 @released

 Subtracts a value from a pointer.

 @param aPtr Pointer to an object of type T.

 @param aVal The value to be added.

 @return The resulting pointer value, as a pointer to a type T.

 */

 template <class T,class S>

 inline T* PtrSub(T* aPtr,S aVal)

 	{return((T*)(((TUint8*)aPtr)-aVal));}

 /**

 @publishedAll

 @released

 Aligns the specified value onto a 2-byte boundary.

 @param aValue The value to be aligned.

 @return The aligned value. 

 */

 template <class T>

 inline T Align2(T aValue)

 	{return((T)((((TUint)aValue)+sizeof(TUint16)-1)&~(sizeof(TUint16)-1)));}

 /**

 @publishedAll

 @released

 Aligns the specified value onto a 4-byte boundary.

 @param aValue The value to be aligned.

 @return The aligned value. 

 */

 template <class T>

 inline T Align4(T aValue)

 	{return((T)((((TUint)aValue)+sizeof(TUint32)-1)&~(sizeof(TUint32)-1)));}

 /**

 @publishedAll

 @released

 A templated class which encapsulates a reference to an object within a wrapper.

 The wrapper object can be passed to a function as a value type. This allows 

 a reference to be passed to a function as a value type.

 This wrapper object is commonly termed a value reference.

 */

 template <class T>

 class TRefByValue

 	{

 public:

 	inline TRefByValue(T& aRef);

 	inline operator T&();

 private:

 	TRefByValue& operator=(TRefByValue aRef);

 private:

 	T &iRef;

 	};

 #if !defined (__KERNEL_MODE__)

 class TDesC16;	// forward declaration for TChar member functions

 class TPtrC16;	// forward declaration for TChar member functions

 #endif

 /**

 @publishedAll

 @released

 Holds a character value and provides a number of utility functions to

 manipulate it and test its properties.

 For example, there are functions to convert the character 

 to uppercase and test whether or not it is a control character.

 The character value is stored as a 32-bit unsigned integer. The shorthand 

 "TChar value" is used to describe the character value wrapped by a TChar 

 object.

 TChar can be used to represent Unicode values outside plane 0 (that is, the 

 extended Unicode range from 0x10000 to 0xFFFFF). This differentiates it from 

 TText which can only be used for 16-bit Unicode character values.

 @see TText

 */

 class TChar

 	{

 public:

     /**

     General Unicode character category.

     The high nibble encodes the major category (Mark, Number, etc.) and a low 

     nibble encodes the subdivisions of that category.

     The category codes can be used in three ways:

     (i) as unique constants: there is one for each Unicode category, with a

     name of the form

     @code

     E<XX>Category

     @endcode

     where

     @code

     <XX>

     @endcode

     is the category name given by

     the Unicode database (e.g., the constant ELuCategory is used for lowercase

     letters, category Lu);

     (ii) as numbers in certain ranges: letter categories are all <= EMaxLetterCategory;

     (iii) as codes in which the upper nibble gives the category group

     (e.g., punctuation categories all yield TRUE for

     the test (category & 0xF0) ==EPunctuationGroup).

     */

 	enum TCategory

 		{

         /**

         Alphabetic letters.

         Includes ELuCategory, ELlCategory and ELtCategory.

         */

 		EAlphaGroup = 0x00,								

         /**

         Other letters.

         Includes ELoCategory.

         */

 		ELetterOtherGroup = 0x10,						

         /**

         Letter modifiers.

         Includes ELmCategory.

         */

 		ELetterModifierGroup = 0x20,					

         /**

         Marks group.

         Includes EMnCategory, EMcCategory and EMeCategory.

         */

 		EMarkGroup = 0x30,

         /**

         Numbers group.

 	    Includes ENdCategory, ENlCategory and ENoCategory.

 	    */

 		ENumberGroup = 0x40,

         /**

         Punctuation group.

 	    IncludesEPcCategory, PdCategory, EpeCategory, EPsCategory and EPoCategory.

 	    */

 		EPunctuationGroup = 0x50,

         /**

         Symbols group.

         Includes ESmCategory, EScCategory, ESkCategory and ESoCategory.

         */

 		ESymbolGroup = 0x60,

         /**

         Separators group.

         Includes EZsCategory, EZlCategory and EZlpCategory.

         */

 		ESeparatorGroup = 0x70,

         /**

         Control, format, private use, unassigned.

      	Includes ECcCategory, ECtCategory, ECsCategory,

      	ECoCategory and ECnCategory.

      	*/

 		EControlGroup = 0x80,

 	    /**

 	    The highest possible groups category.

 	    */

 		EMaxAssignedGroup = 0xE0,

         /**

         Unassigned to any other group.

         */

 		EUnassignedGroup = 0xF0,

         /**

         Letter, Uppercase.

         */

 		ELuCategory = EAlphaGroup | 0,					

         /**

         Letter, Lowercase.

         */

 		ELlCategory = EAlphaGroup | 1,					

 	    /**

 	    Letter, Titlecase.

 	    */

 		ELtCategory = EAlphaGroup | 2,					

      	/**

      	Letter, Other.

      	*/

 		ELoCategory = ELetterOtherGroup | 0,			

 	    /**

 	    The highest possible (non-modifier) letter category.

 	    */

 		EMaxLetterCategory = ELetterOtherGroup | 0x0F,	

 	    /**

 	    Letter, Modifier.

 	    */

 		ELmCategory = ELetterModifierGroup | 0,			

 	    /**

 	    The highest possible letter category.

 	    */

 		EMaxLetterOrLetterModifierCategory = ELetterModifierGroup | 0x0F, 

 	    /**

 	    Mark, Non-Spacing

 	    */

 		EMnCategory = EMarkGroup | 0,					

         /**

         Mark, Combining.

         */

 		EMcCategory = EMarkGroup | 1,					

         /**

         Mark, Enclosing.

         */

 		EMeCategory = EMarkGroup | 2,					

         /**

         Number, Decimal Digit.

         */

 		ENdCategory = ENumberGroup | 0,					

         /**

         Number, Letter.

         */

 		ENlCategory = ENumberGroup | 1,					

         /**

         Number, Other.

         */

 		ENoCategory = ENumberGroup | 2,					

         /**

         Punctuation, Connector.

         */

 		EPcCategory = EPunctuationGroup | 0,			

         /**

         Punctuation, Dash.

         */

 		EPdCategory = EPunctuationGroup | 1,			

         /**

         Punctuation, Open.

         */

 		EPsCategory = EPunctuationGroup | 2,			

         /**

         Punctuation, Close.

         */

 		EPeCategory = EPunctuationGroup | 3,

 		/**

 		Punctuation, Initial Quote

 		*/			

 		EPiCategory = EPunctuationGroup | 4,			

 		/**

 		Punctuation, Final Quote

 		*/

 		EPfCategory = EPunctuationGroup | 5,			

         /**

         Punctuation, Other.

         */

 		EPoCategory = EPunctuationGroup | 6,			

         /**

         Symbol, Math.

         */

 		ESmCategory = ESymbolGroup | 0,					

         /**

         Symbol, Currency.

         */

 		EScCategory = ESymbolGroup | 1,					

         /**

         Symbol, Modifier.

         */

 		ESkCategory = ESymbolGroup | 2,					

         /**

         Symbol, Other.

         */

 		ESoCategory = ESymbolGroup | 3,					

         /**

         The highest possible graphic character category.

         */

 		EMaxGraphicCategory = ESymbolGroup | 0x0F,		

         /**

         Separator, Space.

         */

 		EZsCategory = ESeparatorGroup | 0,				

         /**

         The highest possible printable character category.

         */

 		EMaxPrintableCategory = EZsCategory,			

         /**

         Separator, Line.

         */

 		EZlCategory = ESeparatorGroup | 1,				

         /**

         Separator, Paragraph.

         */

 		EZpCategory = ESeparatorGroup | 2,				

         /**

         Other, Control.

         */

 		ECcCategory = EControlGroup | 0,				

         /**

         Other, Format.

         */

 		ECfCategory = EControlGroup | 1,				

         /**

         The highest possible category for assigned 16-bit characters; does not

         include surrogates, which are interpreted as pairs and have no meaning

         on their own.

         */

 		EMaxAssignedCategory = EMaxAssignedGroup | 0x0F,

         /**

         Other, Surrogate.

         */

 		ECsCategory = EUnassignedGroup | 0,				

         /**

         Other, Private Use.

         */

 		ECoCategory = EUnassignedGroup | 1,				

         /**

         Other, Not Assigned.

         */

 		ECnCategory = EUnassignedGroup | 2				

 		};

     /**

     The bi-directional Unicode character category.

     For more information on the bi-directional algorithm, see Unicode Technical 

     Report No. 9 available at: http://www.unicode.org/unicode/reports/tr9.

     */

 	enum TBdCategory

 		{

 	    /**

 	    Left to right.

 	    */

 		ELeftToRight,				// L Left-to-Right 

 	    /**

 	    Left to right embedding.

 	    */

 		ELeftToRightEmbedding,		// LRE Left-to-Right Embedding 

 	    /**

 	    Left-to-Right Override.

 	    */

 		ELeftToRightOverride,		// LRO Left-to-Right Override 

 	    /**

 	    Right to left.

 	    */

 		ERightToLeft,				// R Right-to-Left 

 	    /**

 	    Right to left Arabic.

 	    */

 		ERightToLeftArabic,			// AL Right-to-Left Arabic 

 	    /**

 	    Right to left embedding.

 	    */

 		ERightToLeftEmbedding,		// RLE Right-to-Left Embedding 

 	    /**

 	    Right-to-Left Override.

 	    */

 		ERightToLeftOverride,		// RLO Right-to-Left Override 

 	    /**

 	    Pop Directional Format.

 	    */

 		EPopDirectionalFormat,		// PDF Pop Directional Format 

 	    /**

 	    European number.

 	    */

 		EEuropeanNumber,			// EN European Number 

 	    /**

 	    European number separator.

 	    */

 		EEuropeanNumberSeparator,	// ES European Number Separator 

 	    /**

 	    European number terminator.

 	    */

 		EEuropeanNumberTerminator,	// ET European Number Terminator 

 	    /**

 	    Arabic number.

 	    */

 		EArabicNumber,				// AN Arabic Number 

 	    /**

 	    Common number separator.

 	    */

 		ECommonNumberSeparator,		// CS Common Number Separator 

 	    /**

 	    Non Spacing Mark.

 	    */

 		ENonSpacingMark,			// NSM Non-Spacing Mark 

 	    /**

 	    Boundary Neutral.

 	    */

 		EBoundaryNeutral,			// BN Boundary Neutral 

 	    /**

 	    Paragraph Separator.

 	    */

 		EParagraphSeparator,		// B Paragraph Separator 

 	    /**

 	    Segment separator.

 	    */

 		ESegmentSeparator,			// S Segment Separator 

 		/**

 		Whitespace

 		*/

 		EWhitespace,				// WS Whitespace 

 	    /**

 	    Other neutrals; all other characters: punctuation, symbols.

 	    */

 		EOtherNeutral				// ON Other Neutrals 

 		};

 	/**

     Notional character width as known to East Asian (Chinese, Japanese,

     Korean (CJK)) coding systems.

     */

 	enum TCjkWidth

 		{

 	    /**

 	    Includes 'ambiguous width' defined in Unicode Technical Report 11: East Asian Width

 	    */

 		ENeutralWidth,			

 	    /**

 	    Character which occupies a single cell.

 	    */

 		EHalfWidth,				// other categories are as defined in the report

         /**

         Character which occupies 2 cells.

         */

 		EFullWidth,

         /**

         Characters that are always narrow and have explicit full-width

         counterparts. All of ASCII is an example of East Asian Narrow

         characters.

         */

 		ENarrow,

 	    /**

 	    Characters that are always wide. This category includes characters that

 	    have explicit half-width counterparts.

 	    */

 		EWide

 		};

 	/**

 	@deprecated

     Encoding systems used by the translation functions.

     */

   	enum TEncoding

   		{

   		/**

   		The Unicode encoding.

   		*/

   		EUnicode,

         /**

         The shift-JIS encoding (used in Japan).

         */

   		EShiftJIS		

   		};

 	/**

 	Flags defining operations to be performed using TChar::Fold().

 	The flag values are passed to the Fold() funtion.

 	@see TChar::Fold

 	*/

 	enum

 		{

 		/**

 		Convert characters to their lower case form if any.

 		*/

 		EFoldCase = 1,			

 		/**

 		Strip accents

      	*/

 		EFoldAccents = 2,		

 		/**

 		Convert digits representing values 0..9 to characters '0'..'9'

      	*/

 		EFoldDigits = 4,		

 		/**

 		Convert all spaces (ordinary, fixed-width, ideographic, etc.) to ' '

      	*/

 		EFoldSpaces = 8,		

 		/**

 		Convert hiragana to katakana.

      	*/

 		EFoldKana = 16,			

 		/**

 	    Fold fullwidth and halfwidth variants to their standard forms

      	*/

 		EFoldWidth = 32,		

 		/**

 		Perform standard folding operations, i.e.those done by Fold() with no argument

      	*/

 		EFoldStandard = EFoldCase | EFoldAccents | EFoldDigits | EFoldSpaces,

         /**

         Perform all possible folding operations

         */

 		EFoldAll = -1	

 		};

 	struct TCharInfo

     /**

     A structure to hold information about a Unicode character.

     An object of this type is passed to TChar::GetInfo().

     @see TChar::GetInfo

     */

 		{

 	    /**

 	    General category.

 	    */

 		TCategory iCategory;				

         /**

         Bi-directional category.

         */

 		TBdCategory iBdCategory;			

         /**

         Combining class: number (currently) in the range 0..234

         */

 		TInt iCombiningClass;				

         /**

         Lower case form.

         */

 		TUint iLowerCase;					

         /**

         Upper case form.

         */

 		TUint iUpperCase;					

         /**

         Title case form.

         */

 		TUint iTitleCase;					

         /**

         True, if the character is mirrored.

         */

 		TBool iMirrored;					

         /**

         Integer numeric value: -1 if none, -2 if a fraction.

         */

 		TInt iNumericValue;					

 		};

 	inline TChar();

 	inline TChar(TUint aChar);

 	inline TChar& operator-=(TUint aChar);

 	inline TChar& operator+=(TUint aChar);

 	inline TChar operator-(TUint aChar);

 	inline TChar operator+(TUint aChar);

 	inline operator TUint() const;

 #ifndef __KERNEL_MODE__

 	inline void Fold();

 	inline void LowerCase();

 	inline void UpperCase();

 	inline TBool Eos() const;

 	IMPORT_C TUint GetUpperCase() const;

 	IMPORT_C TUint GetLowerCase() const;

 	IMPORT_C TBool IsLower() const;

 	IMPORT_C TBool IsUpper() const;

 	IMPORT_C TBool IsAlpha() const;

 	IMPORT_C TBool IsDigit() const;

 	IMPORT_C TBool IsAlphaDigit() const;

 	IMPORT_C TBool IsHexDigit() const;

 	IMPORT_C TBool IsSpace() const;

 	IMPORT_C TBool IsPunctuation() const;

 	IMPORT_C TBool IsGraph() const;

 	IMPORT_C TBool IsPrint() const;

 	IMPORT_C TBool IsControl() const;

 	inline void Fold(TInt aFlags);

 	inline void TitleCase();

 	IMPORT_C TUint GetTitleCase() const;

 	IMPORT_C TBool IsTitle() const;

 	IMPORT_C TBool IsAssigned() const;

 	IMPORT_C void GetInfo(TCharInfo& aInfo) const;

 	IMPORT_C TCategory GetCategory() const;

 	IMPORT_C TBdCategory GetBdCategory() const;

 	IMPORT_C TInt GetCombiningClass() const;

 	IMPORT_C TBool IsMirrored() const;

 	IMPORT_C TInt GetNumericValue() const;

 	IMPORT_C TCjkWidth GetCjkWidth() const;

 	IMPORT_C static TBool Compose(TUint& aResult,const TDesC16& aSource);

 	IMPORT_C TBool Decompose(TPtrC16& aResult) const;

 protected:

 	inline void SetChar(TUint aChar);

 #endif

 private:

 	TUint iChar;

 	__DECLARE_TEST;

 	};

 #include <e32des8.h>

 #ifndef __KERNEL_MODE__

 #include <e32des16.h>

 #endif

 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

 #define __Size (sizeof(TUint)/sizeof(TUint16))

 /**

 @publishedAll

 @released

 Defines a build-independent non-modifiable descriptor.

 A 16-bit build variant is generated for a Unicode, non-kernel

 mode build.

 A build-independent type should always be used unless an explicit 8-bit 

 or 16-bit type is required.

 @see TDesC8

 @see TDesC16

 */

 typedef TDesC16 TDesC;

 /**

 @publishedAll

 @released

 Defines a build-independent non-modifiable pointer descriptor.

 A 16-bit build variant is generated for a Unicode, non-kernel

 mode build.

 A build-independent type should always be used unless an explicit 8-bit 

 or 16-bit type is required.

 @see TPtrC8

 @see TPtrC16

 */

 typedef TPtrC16 TPtrC;

 /**

 @publishedAll

 @released

 Defines a build-independent modifiable descriptor.

 A 16-bit build variant is generated for a Unicode, non-kernel

 mode build.

 A build-independent type should always be used unless an explicit 8-bit 

 or 16-bit type is required.

 @see TDes8

 @see TDes16

 */

 typedef TDes16 TDes;

 /**

 @publishedAll

 @released

 Defines a build-independent modifiable pointer descriptor.

 A 16-bit build variant is generated for a Unicode, non-kernel

 mode build.

 A build-independent type should always be used unless an explicit 8-bit 

 or 16-bit type is required.

 @see TPtr8

 @see TPtr16

 */

 typedef TPtr16 TPtr;

 #ifndef __KERNEL_MODE__

 /**

 @publishedAll

 @released

 Defines a build-independent heap descriptor. 

 A 16-bit build variant is generated for a Unicode, non-kernel

 mode build.

 A build-independent type should always be used unless an explicit 8-bit 

 or 16-bit type is required.

 @see HBufC8

 @see HBufC16

 */

 typedef HBufC16 HBufC;

 /** 

 @publishedAll

 @released

 Defines a build-independent descriptor overflow handler.

 A 16-bit build variant is generated for a Unicode, non-kernel

 mode build.

 A build-independent type should always be used unless an explicit 8-bit 

 or 16-bit type is required.

 @see TDes8Overflow

 @see TDes16Overflow

 */

 typedef TDes16Overflow TDesOverflow;

 /** 

 @publishedAll

 @released

 Defines a build-independent resizable buffer descriptor.

 A 16-bit build variant is generated for a Unicode, non-kernel mode build.

 A build-independent type should always be used unless an explicit 8-bit 

 or 16-bit type is required.

 @see RBuf8

 @see RBuf16

 */

 typedef RBuf16 RBuf;

 #endif

 #else

 #define __Size (sizeof(TUint)/sizeof(TUint8))

 /**

 @publishedAll

 @released

 Defines a build-independent non-modifiable descriptor.

 An 8-bit build variant is generated for a non-Unicode build.

 This build-independent type should always be used unless an explicit 8-bit 

 or 16-bit build variant is required.

 @see TDesC8

 @see TDesC16

 */

 typedef TDesC8 TDesC;

 /**

 @publishedAll

 @released

 Defines a build-independent non-modifiable pointer descriptor.

 An 8-bit build variant is generated for a non-Unicode build.

 This build-independent type should always be used unless an explicit 8-bit 

 or 16-bit build variant is required.

 @see TPtrC8

 @see TPtrC16

 */

 typedef TPtrC8 TPtrC;

 /**

 @publishedAll

 @released

 Defines a build-independent modifiable descriptor.

 An 8-bit build variant is generated for a non-Unicode build.

 This build-independent type should always be used unless an explicit 8-bit 

 or 16-bit build variant is required.

 @see TDes8

 @see TDes16

 */

 typedef TDes8 TDes;

 /**

 @publishedAll

 @released

 Defines a build-independent modifiable pointer descriptor.

 An 8-bit build variant is generated for a non-Unicode build.

 This build-independent type should always be used unless an explicit 8-bit 

 or 16-bit build variant is required.

 @see TPtr8

 @see TPtr16

 */

 typedef TPtr8 TPtr;

 #ifndef __KERNEL_MODE__

 /**

 @publishedAll

 @released

 Defines a build-independent heap descriptor.

 An 8-bit build variant is generated for a non-Unicode, non-kernel

 mode build.

 This build-independent type should always be used unless an explicit 8-bit 

 or 16-bit build variant is required.

 @see HBufC8

 @see HBufC16

 */

 typedef HBufC8 HBufC;

 /**

 @publishedAll

 @released

 Defines a build-independent descriptor overflow handler. 

 An 8-bit build variant is generated for a non-Unicode, non-kernel

 mode build.

 This build-independent type should always be used unless an explicit 8-bit 

 or 16-bit build variant is required.

 @see TDes8Overflow

 @see TDes16Overflow

 */

 typedef TDes8Overflow TDesOverflow;

 /**

 @publishedAll

 @released

 Defines a build-independent resizable buffer descriptor.

 An 8-bit build variant is generated for a non-Unicode, non-kernel mode build.

 This build-independent type should always be used unless an explicit 8-bit 

 or 16-bit build variant is required.

 @see RBuf8

 @see RBuf16

 */

 typedef RBuf8 RBuf;

 #endif

 #endif

 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

 typedef TBufCBase16 TBufCBase;

 #else

 typedef TBufCBase8 TBufCBase;

 #endif

 /**

 @publishedAll

 @released

 A build-independent non-modifiable buffer descriptor.

 This is a descriptor class which provides a buffer of fixed length for

 containing and accessing TUint16 or TUint8 data, depending on the build.

 The class intended for instantiation. The data that the descriptor represents 

 is part of the descriptor object itself.

 The class is templated, based on an integer value which defines the size of 

 the descriptor's data area.

 The data is intended to be accessed, but not modified; however, it can be 

 completely replaced using the assignment operators of this class. The base 

 class provides the functions through which the data is accessed.

 This class derives from TBufCBase16 for a Unicode, non-kernel build, but

 derives from TBufCBase8 for a non-Unicode build.

 @see TDesC

 @see TDesC8

 @see TDesC16

 @see TPtr

 @see TPtr8

 @see TPtr16

 @see TBufC8

 @see TBufC16

 */

 template <TInt S>

 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

 class TBufC : public TBufCBase16

 #else

 class TBufC : public TBufCBase8

 #endif

 	{

 public:

 	inline TBufC();

 	inline TBufC(const TText* aString);

 	inline TBufC(const TDesC& aDes);

 	inline TBufC<S>& operator=(const TText* aString);

 	inline TBufC<S>& operator=(const TDesC& aDes);

 	inline TPtr Des();

 private:

 	TText iBuf[__Align(S)];

 	};

 /**

 @publishedAll

 @released

 A build-independent modifiable buffer descriptor.

 This is a descriptor class which provides a buffer of fixed length for

 containing, accessing and manipulating TUint16 or TUint8 data, depending

 on the build.

 The class is intended for instantiation. The data that the descriptor represents 

 is part of the descriptor object itself.

 The class is templated, based on an integer value which determines the size 

 of the data area created as part of the buffer descriptor object; this is 

 also the maximum length of the descriptor.

 The data is intended to be both accessed and modified. The base classes provide 

 the functions through which the data is accessed.

 This class derives from TBufCBase16 for a Unicode, non-kernel build, but

 derives from TBufCBase8 for a non-Unicode build.

 @see TDesC

 @see TDesC8

 @see TDesC16

 @see TDes

 @see TDes8

 @see TDes16

 @see TPtr

 @see TPtr8

 @see TPtr16

 */

 template <TInt S>

 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

 class TBuf : public TBufBase16

 #else

 class TBuf : public TBufBase8

 #endif

 	{

 public:

 	inline TBuf();

 	inline explicit TBuf(TInt aLength);

 	inline TBuf(const TText* aString);

 	inline TBuf(const TDesC& aDes);

 	inline TBuf<S>& operator=(const TText* aString);

 	inline TBuf<S>& operator=(const TDesC& aDes);

 	inline TBuf<S>& operator=(const TBuf<S>& aBuf);

 private:

 	TText iBuf[__Align(S)];

 	};

 /**

 @publishedAll

 @released

 Value reference used in operator TLitC::__TRefDesC().

 @see TRefByValue

 */

 typedef TRefByValue<const TDesC> __TRefDesC;

 /**

 @publishedAll

 @released

 Encapsulates literal text.

 This is always constructed using an _LIT macro.

 This class is build independent; i.e. for a non-Unicode build, an 8-bit build

 variant is generated; for a Unicode build, a 16 bit build variant is generated.

 The class has no explicit constructors. See the _LIT macro definition.

 */

 template <TInt S>

 class TLitC

 	{

 public:

     /**

     @internalComponent

     */

 	enum {BufferSize=S-1};

 	inline const TDesC* operator&() const;

 	inline operator const TDesC&() const;

 	inline const TDesC& operator()() const;

 	inline operator const __TRefDesC() const;

 public:

 #if !defined(_UNICODE) || defined(__KERNEL_MODE__)

     /**

     @internalComponent

     */

 	typedef TUint8 __TText;

 #elif defined(__GCC32__)

     /**

     @internalComponent

     */

 	typedef wchar_t __TText;

 #elif defined(__VC32__)

 	/**

     @internalComponent

     */

 	typedef wchar_t __TText;

 #elif defined(__CW32__)

     /**

     @internalComponent

     */

 	typedef TUint16 __TText;

 #elif !defined(__TText_defined)

 #error  no typedef for __TText

 #endif

 public:

     /**

     @internalComponent

     */

 	TUint iTypeLength;

     /**

     @internalComponent

     */

 	__TText iBuf[__Align(S)];

 	};

 /**

 @publishedAll

 @released

 Defines an empty or null literal descriptor.

 This is the build independent form.

 An 8 bit build variant is generated for a non-Unicode build;

 a 16 bit build variant is generated for a Unicode build.

 */

 _LIT(KNullDesC,"");

 /**

 @publishedAll

 @released

 Defines an empty or null literal descriptor for use with 8-bit descriptors.

 */

 _LIT8(KNullDesC8,"");

 #ifndef __KERNEL_MODE__

 /**

 @publishedAll

 @released

 Defines an empty or null literal descriptor for use with 16-bit descriptors

 */

 _LIT16(KNullDesC16,"");

 #endif

 /**

 @publishedAll

 @released

 Packages a non-modifiable pointer descriptor which represents an object of 

 specific type.

 The template parameter defines the type of object.

 The object represented by the packaged pointer descriptor is accessible through 

 the package but cannot be changed. */

 template <class T>

 class TPckgC : public TPtrC8

 	{

 public:

 	inline TPckgC(const T& aRef);

 	inline const T& operator()() const;

 private:

 	TPckgC<T>& operator=(const TPckgC<T>& aRef);

 	};

 /**

 @publishedAll

 @released

 Packages a modifiable pointer descriptor which represents an object of specific 

 type.

 The template parameter defines the type of object.

 The object represented by the packaged pointer descriptor is accessible through 

 the package.

 */

 template <class T>

 class TPckg : public TPtr8

 	{

 public:

 	inline TPckg(const T& aRef);

 	inline T& operator()();

 private:

 	TPckg<T>& operator=(const TPckg<T>& aRef);

 	};

 /**

 @publishedAll

 @released

 Packages an object into a modifiable buffer descriptor.

 The template parameter defines the type of object to be packaged.

 The package provides a type safe way of transferring an object or data structure 

 which is contained within a modifiable buffer descriptor. Typically, a package 

 is used for passing data via inter thread communication.

 The contained object is accessible through the package.

 */

 template <class T>

 class TPckgBuf : public TAlignedBuf8<sizeof(T)>

 	{

 public:

 	inline TPckgBuf();

 	inline TPckgBuf(const T& aRef);

 	inline TPckgBuf& operator=(const TPckgBuf<T>& aRef);

 	inline T& operator=(const T& aRef);

 	inline T& operator()();

 	inline const T& operator()() const;

 	};

 /**

 @publishedAll

 @released

 Defines a modifiable buffer descriptor that can contain the name of a reference 

 counting object.

 @see TBuf

 @see CObject

 */

 typedef TBuf<KMaxName> TName;

 /**

 @publishedAll

 @released

 Defines a modifiable buffer descriptor that can contain the full name of a 

 reference counting object.

 @see TBuf

 @see CObject

 */

 typedef TBuf<KMaxFullName> TFullName;

 /**

 @publishedAll

 @released

 Defines a modifiable buffer descriptor to contain the category name identifying

 the cause of thread or process termination. The buffer takes a maximum length

 of KMaxExitCategoryName.

 @see RThread::ExitCategory

 @see RThread::ExitCategory

 */

 typedef TBuf<KMaxExitCategoryName> TExitCategoryName;

 /**

 @publishedAll

 @released

 A buffer that can contain the name of a file.

 The name can have a maximum length of KMaxFileName

 (currently 256 but check the definition of KMaxFileName).

 @see KMaxFileName

 */

 typedef TBuf<KMaxFileName> TFileName;

 /**

 @publishedAll

 @released

 A buffer that can contain the name of a path.

 The name can have a maximum length of KMaxPath

 (currently 256 but check the definition of KMaxPath).

 @see KMaxPath

 */

 typedef TBuf<KMaxPath> TPath;

 /**

 @publishedAll

 @released

 Version name type.

 This is a buffer descriptor with a maximum length of KMaxVersionName.

 A TVersion object returns the formatted character representation of its version

 information in a descriptor of this type.

 @see TVersion

 */

 typedef TBuf<KMaxVersionName> TVersionName;

 /**

 @publishedAll

 @released

 Defines a modifiable buffer descriptor for the text form of the UID.

 The descriptor has a maximum length of KMaxUidName and is used to contain

 the standard text format returned by the function TUid::Name().

 @see TUid::Name

 */

 typedef TBuf<KMaxUidName> TUidName;

 /**

 @publishedAll

 @released

 Defines a null UID

 */

 #define KNullUid TUid::Null()

 /**

 @publishedAll

 @released

 A globally unique 32-bit number.

 */

 class TUid

 	{

 public:

 #ifndef __KERNEL_MODE__

 	IMPORT_C TBool operator==(const TUid& aUid) const;

 	IMPORT_C TBool operator!=(const TUid& aUid) const;

 	IMPORT_C TUidName Name() const;

 #endif

 	static inline TUid Uid(TInt aUid);

 	static inline TUid Null();

 public:

 	/**

 	The 32-bit integer UID value.

 	*/

 	TInt32 iUid;

 	};

 /**

 @publishedAll

 @released

 Encapsulates a set of three unique identifiers (UIDs) which, in combination, 

 identify a system object such as a GUI application or a DLL. The three

 component UIDs are referred to as UID1, UID2 and UID3.

 An object of this type is referred to as a compound identifier or a UID type.

 */

 class TUidType

 	{

 public:

 #ifndef __KERNEL_MODE__

 	IMPORT_C TUidType();

 	IMPORT_C TUidType(TUid aUid1);

 	IMPORT_C TUidType(TUid aUid1,TUid aUid2);

 	IMPORT_C TUidType(TUid aUid1,TUid aUid2,TUid aUid3);

 	IMPORT_C TBool operator==(const TUidType& aUidType) const;

 	IMPORT_C TBool operator!=(const TUidType& aUidType) const;

 	IMPORT_C const TUid& operator[](TInt anIndex) const;

 	IMPORT_C TUid MostDerived() const;

 	IMPORT_C TBool IsPresent(TUid aUid) const;

 	IMPORT_C TBool IsValid() const;

 private:

 #endif

 	TUid iUid[KMaxCheckedUid];

 	};

 /**

 A class used to represent the Secure ID of a process or executable image.

 Constructors and conversion operators are provided to enable conversion

 of this class to and from both TUint32 and TUid objects.

 Because this class has non-default constructors, compilers will not initialise

 this objects at compile time, instead code will be generated to construct the object

 at run-time. This is wastefull, and Symbian OS DLLs are not permitted to have

 such uninitialised data. To overcome these problems a macro is provided to construct

 a const object which behaves like a TSecureId. This is _LIT_SECURE_ID.

 This macro should be used where it is desirable to define const TSecureId objects,

 like in header files. E.g. Instead of writing:

 @code

 	const TSecureId MyId=0x1234567

 @endcode

 use

 @code

 	_LIT_SECURE_ID(MyId,0x1234567)

 @endcode

 @publishedAll

 @released

 @see _LIT_SECURE_ID

 */

 class TSecureId

 	{

 public:

 	inline TSecureId();

 	inline TSecureId(TUint32 aId);

 	inline operator TUint32() const;

 	inline TSecureId(TUid aId);

 	inline operator TUid() const;

 public:

 	TUint32 iId;

 	};

 /**

 A class used to represent the Vendor ID of a process or executable image

 Constructors and conversion operators are provided to enable conversion

 of this class to and from both TUint32 and TUid objects.

 Because this class has non-default constructors, compilers will not initialise

 this objects at compile time, instead code will be generated to construct the object

 at run-time. This is wastefull, and Symbian OS DLLs are not permitted to have

 such uninitialised data. To overcome these problems a macro is provided to construct

 a const object which behaves like a TSecureId. This is _LIT_VENDOR_ID.

 This macro should be used where it is desirable to define const TSecureId objects,

 like in header files. E.g. Instead of writing:

 @code

 	const TVendorId MyId=0x1234567

 @endcode

 use

 @code

 	_LIT_VENDOR_ID(MyId,0x1234567)

 @endcode

 @publishedAll

 @released

 @see _LIT_VENDOR_ID

 */

 class TVendorId

 	{

 public:

 	inline TVendorId();

 	inline TVendorId(TUint32 aId);

 	inline operator TUint32() const;

 	inline TVendorId(TUid aId);

 	inline operator TUid() const;

 public:

 	TUint32 iId;

 	};

 /**

 Structure for compile-time definition of a secure ID

 @internalComponent

 */

 class SSecureId

 	{

 public:

 	inline const TSecureId* operator&() const;

 	inline operator const TSecureId&() const;

 	inline operator TUint32() const;

 	inline operator TUid() const;

 public:

 	TUint32 iId;

 	};

 /**

 Structure for compile-time definition of a vendor ID

 @internalComponent

 */

 class SVendorId

 	{

 public:

 	inline const TVendorId* operator&() const;

 	inline operator const TVendorId&() const;

 	inline operator TUint32() const;

 	inline operator TUid() const;

 public:

 	TUint32 iId;

 	};

 /**

 Macro for compile-time definition of a secure ID

 @param name Name to use for secure ID

 @param value Value of secure ID

 @publishedAll

 @released

 */

 #define _LIT_SECURE_ID(name,value) const SSecureId name={value}

 /**

 Macro for compile-time definition of a vendor ID

 @param name Name to use for vendor ID

 @param value Value of vendor ID

 @publishedAll

 @released

 */

 #define _LIT_VENDOR_ID(name,value) const SVendorId name={value}

 /**

 @publishedAll

 @released

 Contains version information.

 A version is defined by a set of three numbers:

 1. the major version number, ranging from 0 to 127, inclusive

 2. the minor version number, ranging from 0 to 99 inclusive

 3. the build number, ranging from 0 to 32767 inclusive.

 The class provides a constructor for setting all three numbers.

 It also provides a member function to build a character representation of

 this information in a TVersionName descriptor.

 @see TVersionName

 */

 class TVersion

 	{

 public:

 	IMPORT_C TVersion();

 	IMPORT_C TVersion(TInt aMajor,TInt aMinor,TInt aBuild);

 	IMPORT_C TVersionName Name() const;

 public:

     /**

     The major version number.

     */

 	TInt8 iMajor;

     /**

     The minor version number.

     */

 	TInt8 iMinor;

 	/**

 	The build number.

 	*/

 	TInt16 iBuild;

 	};

 /**

 @publishedAll

 @released

 Indicates the completion status of a request made to a service provider.

 When a thread makes a request, it passes a request status as a parameter. 

 On completion, the provider signals the requesting thread's request semaphore 

 and stores a completion code in the request status. Typically, this is KErrNone 

 or one of the other system-wide error codes.

 This class is not intended for user derivation.

 */

 class TRequestStatus

 	{

 public:

 	inline TRequestStatus();

 	inline TRequestStatus(TInt aVal);

 	inline TInt operator=(TInt aVal);

 	inline TBool operator==(TInt aVal) const;

 	inline TBool operator!=(TInt aVal) const;

 	inline TBool operator>=(TInt aVal) const;

 	inline TBool operator<=(TInt aVal) const;

 	inline TBool operator>(TInt aVal) const;

 	inline TBool operator<(TInt aVal) const;

 	inline TInt Int() const;

 private:

 	enum

 		{

 		EActive				= 1,  //bit0

 		ERequestPending		= 2,  //bit1

 		};

 	TInt iStatus;

 	TUint iFlags;

 	friend class CActive;

 	friend class CActiveScheduler;

 	friend class CServer2;

    //SL: Added this so that upon request completion a thread can set iStatus without touching iFlag

    //That stuff is usually probably handled by some exec call accessing the memory directly (just a guess)

    //@see RThread::RequestComplete

    friend class RThread;

 	};

 class TSize;

 /**

 @publishedAll

 @released

 Stores a two-dimensional point in Cartesian co-ordinates.

 Its data members (iX and iY) are public and can be manipulated directly, or 

 by means of the functions provided. Functions are provided to set and manipulate 

 the point, and to compare points for equality.

 */

 class TPoint

 	{

 public:

 #ifndef __KERNEL_MODE__

 	enum TUninitialized { EUninitialized };

 	/**

 	Constructs default point, initialising its iX and iY members to zero.

 	*/

 	TPoint(TUninitialized) {}

 	inline TPoint();

 	inline TPoint(TInt aX,TInt aY);

 	IMPORT_C TBool operator==(const TPoint& aPoint) const;

 	IMPORT_C TBool operator!=(const TPoint& aPoint) const;

 	IMPORT_C TPoint& operator-=(const TPoint& aPoint);

 	IMPORT_C TPoint& operator+=(const TPoint& aPoint);

 	IMPORT_C TPoint& operator-=(const TSize& aSize);

 	IMPORT_C TPoint& operator+=(const TSize& aSize);

 	IMPORT_C TPoint operator-(const TPoint& aPoint) const;

 	IMPORT_C TPoint operator+(const TPoint& aPoint) const;

 	IMPORT_C TPoint operator-(const TSize& aSize) const;

 	IMPORT_C TPoint operator+(const TSize& aSize) const;

 	IMPORT_C TPoint operator-() const;

 	IMPORT_C void SetXY(TInt aX,TInt aY);

 	IMPORT_C TSize AsSize() const;

 #endif

 public:

 	/**

 	The x co-ordinate.

 	*/

 	TInt iX;

 	/**

 	The y co-ordinate.

 	*/

 	TInt iY;

 	};

 /**

 @publishedAll

 @prototype

 Stores a three-dimensional point in Cartesian or polar co-ordinates.

 Its data members (iX, iY and iZ) are public and can be manipulated directly.

 */

 class TPoint3D

 	{

 public:

 #ifndef __KERNEL_MODE__

 	enum TUninitialized { EUninitialized };

 	/**

 	TUninitialized Constructor

 	*/

 	TPoint3D(TUninitialized) {}

 	/**

 	Constructs default TPoint3D, initialising its iX , iY and iZ members to zero.

 	*/

 	inline TPoint3D();

 	/**

 	Constructs  TPoint3D with the specified x,y  and z co-ordinates.

 	*/

 	inline TPoint3D(TInt aX,TInt aY,TInt aZ);

 	/** 

 	Copy Construct from TPoint , initialises Z co-ordinate to  Zero

 	*/

 	inline TPoint3D(const  TPoint& aPoint);

 	IMPORT_C TBool operator==(const TPoint3D& aPoint3D) const;

 	IMPORT_C TBool operator!=(const TPoint3D& aPoint3D) const;

 	IMPORT_C TPoint3D& operator-=(const TPoint3D& aPoint3D);

 	IMPORT_C TPoint3D& operator-=(const TPoint& aPoint);

 	IMPORT_C TPoint3D& operator+=(const TPoint3D& aPoint3D);	

 	IMPORT_C TPoint3D& operator+=(const TPoint& aPoint);

 	IMPORT_C TPoint3D operator-(const TPoint3D& aPoint3D) const;

 	IMPORT_C TPoint3D operator-(const TPoint& aPoint) const;	

 	IMPORT_C TPoint3D operator+(const TPoint3D& aPoint3D) const;

 	IMPORT_C TPoint3D operator+(const TPoint& aPoint) const;

 	/**

     Unary minus operator. The operator returns the negation of this Point3D 

 	*/

 	IMPORT_C TPoint3D operator-() const;

 	/**

 	Set Method to set the xyz co-ordinates of TPoint3D

 	*/

 	IMPORT_C void SetXYZ(TInt aX,TInt aY,TInt aZ);

 	/**

 	TPoint3D from TPoint, sets the Z co-ordinate to  Zero

 	*/

 	IMPORT_C void SetPoint(const TPoint& aPoint);

 	/**

 	Returns TPoint from TPoint3D

 	*/

 	IMPORT_C TPoint AsPoint() const;

 #endif

 public:

 	/**

 	The x co-ordinate.

 	*/

 	TInt iX;

 	/**

 	The y co-ordinate.

 	*/

 	TInt iY;

 	/**

 	The z co-ordinate.

 	*/

 	TInt iZ;

 	};

 /**

 @internalTechnology

 @prototype For now, only intended to be used by TRwEvent and the Windows Server

 Stores the angular spherical coordinates (Phi,Theta) of a three-dimensional point.

 Its data members (iPhi, iTheta) are public and can be manipulated directly.

 */

 class TAngle3D

 	{

 public:

 	/**

 	The Phi co-ordinate (angle between X-axis and the line that links the projection of the point on the X-Y plane and the origin).

 	*/

 	TInt iPhi;

 	/**

 	The Theta co-ordinate (angle between the Z-axis and the line that links the point and the origin).

 	*/

 	TInt iTheta;

 	};

 /**

 @publishedAll

 @released

 Stores a two-dimensional size as a width and a height value.

 Its data members are public and can be manipulated directly, or by means of 

 the functions provided.

 */

 class TSize

 	{

 public:

 #ifndef __KERNEL_MODE__

 	enum TUninitialized { EUninitialized };

 	/**

 	Constructs the size object with its iWidth and iHeight members set to zero.

 	*/

 	TSize(TUninitialized) {}

 	inline TSize();

 	inline TSize(TInt aWidth,TInt aHeight);

 	IMPORT_C TBool operator==(const TSize& aSize) const;

 	IMPORT_C TBool operator!=(const TSize& aSize) const;

 	IMPORT_C TSize& operator-=(const TSize& aSize);

 	IMPORT_C TSize& operator-=(const TPoint& aPoint);

 	IMPORT_C TSize& operator+=(const TSize& aSize);

 	IMPORT_C TSize& operator+=(const TPoint& aPoint);

 	IMPORT_C TSize operator-(const TSize& aSize) const;

 	IMPORT_C TSize operator-(const TPoint& aPoint) const;

 	IMPORT_C TSize operator+(const TSize& aSize) const;

 	IMPORT_C TSize operator+(const TPoint& aPoint) const;

 	IMPORT_C TSize operator-() const;

 	IMPORT_C void SetSize(TInt aWidth,TInt aHeight);

 	IMPORT_C TPoint AsPoint() const;

 #endif

 public:

 	/**

 	The width of this TSize object.

 	*/

 	TInt iWidth;

 	/**

 	The height of this TSize object.

 	*/

 	TInt iHeight;

 	};

 /**

 @publishedAll

 @released

 Information about a kernel object.

 This type of object is passed to RHandleBase::HandleInfo(). The function 

 fetches information on the usage of the kernel object associated with that 

 handle and stores the information in the THandleInfo object.

 The class contains four data members and no explicitly defined function

 members.

 */

 class THandleInfo

 	{

 public:

 	/**

 	The number of times that the kernel object is open in the current process.

 	*/

 	TInt iNumOpenInProcess;

 	/**

 	The number of times that the kernel object is open in the current thread.

 	*/

 	TInt iNumOpenInThread;

 	/**

 	The number of processes which have a handle on the kernel object.

 	*/

 	TInt iNumProcesses;

 	/**

 	The number of threads which have a handle on the kernel object.

 	*/

 	TInt iNumThreads;

 	};

 /**

 @internalComponent

 */

 class TFindHandle

 	{

 public:

 	inline TFindHandle();

 	inline TInt Handle() const;

 #ifdef __KERNEL_MODE__

 	inline TInt Index() const;

 	inline TInt UniqueID() const;

 	inline TUint64 ObjectID() const;

 	inline void Set(TInt aIndex, TInt aUniqueId, TUint64 aObjectId);

 #else

 protected:

 	inline void Reset();

 #endif

 private:

 	TInt iHandle;

 	TInt iSpare1;

 	TInt iObjectIdLow;

 	TInt iObjectIdHigh;

 	};

 class RThread;

 class TFindHandleBase;

 class TFindSemaphore;

 /**

 @publishedAll

 @released

 A handle to an object.

 The class encapsulates the basic behaviour of a handle, hiding the

 handle-number which identifies the object which the handle represents.

 The class is abstract in the sense that a RHandleBase object is never

 explicitly instantiated. It is always a base class to a concrete handle class;

 for example, RSemaphore, RThread, RProcess, RCriticalSection etc.

 */

 class RHandleBase

 	{

 public:

     /**

     @publishedAll

     @released

 	Read/Write attributes for the handle.

     */

     enum TAttributes

 		{

 		EReadAccess=0x1,

 		EWriteAccess=0x2,

 		EDirectReadAccess=0x4,

 		EDirectWriteAccess=0x8,

 		};

 public:

 	inline RHandleBase();

 	inline TInt Handle() const;

 	inline void SetHandle(TInt aHandle);

 	inline TInt SetReturnedHandle(TInt aHandleOrError);	

 	static void DoExtendedClose();

 #ifndef __KERNEL_MODE__

 	IMPORT_C void Close();

 	IMPORT_C TName Name() const;

 	IMPORT_C TFullName FullName() const;

 	IMPORT_C void FullName(TDes& aName) const;

 	IMPORT_C void SetHandleNC(TInt aHandle);

 	IMPORT_C TInt Duplicate(const RThread& aSrc,TOwnerType aType=EOwnerProcess);

 	IMPORT_C void HandleInfo(THandleInfo* anInfo);

 	IMPORT_C TUint Attributes() const;

 	IMPORT_C TInt BTraceId() const;

 	IMPORT_C void NotifyDestruction(TRequestStatus& aStatus);	/**< @internalTechnology */

 protected:

 	inline RHandleBase(TInt aHandle);

 	IMPORT_C TInt Open(const TFindHandleBase& aHandle,TOwnerType aType);

 	static TInt SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle);

 	TInt OpenByName(const TDesC &aName,TOwnerType aOwnerType,TInt aObjectType);

 #endif

 private:

 	static void DoExtendedCloseL();

 protected:

 	TInt iHandle;

 	};

 class RMessagePtr2;

 /**

 @publishedAll

 @released

 A handle to a semaphore.

 The semaphore itself is a Kernel side object.

 As with all handles, they should be closed after use. RHandleBase provides 

 the necessary Close() function, which should be called when the handle is 

 no longer required.

 @see RHandleBase::Close

 */

 class RSemaphore : public RHandleBase

 	{

 public:

 #ifndef __KERNEL_MODE__

 	inline TInt Open(const TFindSemaphore& aFind,TOwnerType aType=EOwnerProcess);

 	IMPORT_C TInt CreateLocal(TInt aCount,TOwnerType aType=EOwnerProcess);

 	IMPORT_C TInt CreateGlobal(const TDesC& aName,TInt aCount,TOwnerType aType=EOwnerProcess);

 	IMPORT_C TInt OpenGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);

 	IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);

 	IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);

 	IMPORT_C void Wait();

 	IMPORT_C TInt Wait(TInt aTimeout);	// timeout in microseconds

 	IMPORT_C void Signal();

 	IMPORT_C void Signal(TInt aCount);

 #endif

 	};

 /**

 @publishedAll

 @released

 A fast semaphore.

 This is a layer over a standard semaphore, and only calls into the kernel side

 if there is contention.

 */

 class RFastLock : public RSemaphore

 	{

 public:

 	inline RFastLock();

 	IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);

 	IMPORT_C void Wait();

 	IMPORT_C void Signal();

 private:

 	TInt iCount;

 	};

 /**

 @publishedAll

 @released

 A read-write lock.

 This is a lock for co-ordinating readers and writers to shared resources.

 It is designed to allow multiple concurrent readers.

 It is not a kernel side object and so does not inherit from RHandleBase.

 */

 class RReadWriteLock

 	{

 public:

 	enum TReadWriteLockPriority

 		{

 		/** Pending writers always get the lock before pending readers */

 		EWriterPriority,

 		/** Lock is given alternately to pending readers and writers */

 		EAlternatePriority,

 		/** Pending readers always get the lock before pending writers - beware writer starvation! */

 		EReaderPriority,

 		};

 	enum TReadWriteLockClientCategoryLimit

 		{

 		/** Maximum number of clients in each category: read locked, read lock pending, write lock pending */

 		EReadWriteLockClientCategoryLimit = KMaxTUint16

 		};

 public:

 	inline RReadWriteLock();

 	IMPORT_C TInt CreateLocal(TReadWriteLockPriority aPriority = EWriterPriority);

 	IMPORT_C void Close();

 	IMPORT_C void ReadLock();

 	IMPORT_C void WriteLock();

 	IMPORT_C TBool TryReadLock();

 	IMPORT_C TBool TryWriteLock();

 	IMPORT_C TBool TryUpgradeReadLock();

 	IMPORT_C void DowngradeWriteLock();

 	IMPORT_C void Unlock();

 private:

 	RReadWriteLock(const RReadWriteLock& aLock);

 	RReadWriteLock& operator=(const RReadWriteLock& aLock);

 	TInt UnlockWriter();

 	TInt UnlockAlternate();

 	TInt UnlockReader();

 private:

 	volatile TUint64 iValues; // Bits 0-15: readers; bit 16: writer; bits 32-47: readersPending; bits 48-63: writersPending

 	TReadWriteLockPriority iPriority;

 	RSemaphore iReaderSem;

 	RSemaphore iWriterSem;

 	TUint32 iSpare[4]; // Reserved for future development

 	};

 /**

 @publishedAll

 @released

 The user-side handle to a logical channel.

 The class provides functions that are used to open a channel

 to a device driver, and to make requests. A device driver provides

 a derived class to give the user-side a tailored interface to the driver.

 */

 class RBusLogicalChannel : public RHandleBase

 	{

 public:

 	IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);

 	IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);

 protected:

 	inline TInt DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* anInfo, TOwnerType aType=EOwnerProcess, TBool aProtected=EFalse);

 	IMPORT_C void DoCancel(TUint aReqMask);

 	IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus);

 	IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TAny* a1);

 	IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TAny* a1,TAny* a2);

 	IMPORT_C TInt DoControl(TInt aFunction);

 	IMPORT_C TInt DoControl(TInt aFunction,TAny* a1);

 	IMPORT_C TInt DoControl(TInt aFunction,TAny* a1,TAny* a2);

 	inline TInt DoSvControl(TInt aFunction) { return DoControl(aFunction); }

 	inline TInt DoSvControl(TInt aFunction,TAny* a1) { return DoControl(aFunction, a1); }

 	inline TInt DoSvControl(TInt aFunction,TAny* a1,TAny* a2) { return DoControl(aFunction, a1, a2); }

 private:

 	IMPORT_C TInt DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TInt aType);

 private:

 	// Padding for Binary Compatibility purposes

 	TInt iPadding1;

 	TInt iPadding2;

 	};

 /**

 @internalComponent

 Base class for memory allocators.

 */

 // Put pure virtual functions into a separate base class so that vptr is at same

 // place in both GCC98r2 and EABI builds.

 class MAllocator

 	{

 public:

 	virtual TAny* Alloc(TInt aSize)=0;

 	virtual void Free(TAny* aPtr)=0;

 	virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0)=0;

 	virtual TInt AllocLen(const TAny* aCell) const =0;

 	virtual TInt Compress()=0;

 	virtual void Reset()=0;

 	virtual TInt AllocSize(TInt& aTotalAllocSize) const =0;

 	virtual TInt Available(TInt& aBiggestBlock) const =0;

 	virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL)=0;

 	virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)=0;

 	};

 /**

 @publishedAll

 @released

 Base class for heaps.

 */

 class RAllocator : public MAllocator

 	{

 public:

     /**

     A set of heap allocation failure flags.

     This enumeration indicates how to simulate heap allocation failure.

     @see RAllocator::__DbgSetAllocFail()

     */

 	enum TAllocFail {

                     /**

                     Attempts to allocate from this heap fail at a random rate;

                     however, the interval pattern between failures is the same

                     every time simulation is started.

                     */

 	                ERandom,