--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/e32/include/e32cmn.h Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,6727 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// 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);
+}
+
+
+#if defined(__TOOLS2__) && !defined(_WIN32)
+// memcpy prototype clash: Throw spec on Linux differs from Symbian?
+#include <string.h>
+#elif !defined(__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 TUint16 __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;
+ };
+
+
+
+
+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
+ {
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+public:
+ /**
+ @internalComponent
+ */
+#else
+protected:
+#endif
+ enum
+ {
+ 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
+
+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,
+
+
+ /**
+ Attempts to allocate from this heap fail at a random rate.
+ The interval pattern between failures may be different every
+ time the simulation is started.
+ */
+ ETrueRandom,
+
+
+ /**
+ Attempts to allocate from this heap fail at a rate aRate;
+ for example, if aRate is 3, allocation fails at every
+ third attempt.
+ */
+ EDeterministic,
+
+
+ /**
+ Cancels simulated heap allocation failure.
+ */
+ ENone,
+
+
+ /**
+ An allocation from this heap will fail after the next aRate - 1
+ allocation attempts. For example, if aRate = 1 then the next
+ attempt to allocate from this heap will fail.
+ */
+ EFailNext,
+
+ /**
+ Cancels simulated heap allocation failure, and sets
+ the nesting level for all allocated cells to zero.
+ */
+ EReset,
+
+ /**
+ aBurst allocations from this heap fail at a random rate;
+ however, the interval pattern between failures is the same
+ every time the simulation is started.
+ */
+ EBurstRandom,
+
+
+ /**
+ aBurst allocations from this heap fail at a random rate.
+ The interval pattern between failures may be different every
+ time the simulation is started.
+ */
+ EBurstTrueRandom,
+
+
+ /**
+ aBurst allocations from this heap fail at a rate aRate.
+ For example, if aRate is 10 and aBurst is 2, then 2 allocations
+ will fail at every tenth attempt.
+ */
+ EBurstDeterministic,
+
+ /**
+ aBurst allocations from this heap will fail after the next aRate - 1
+ allocation attempts have occurred. For example, if aRate = 1 and
+ aBurst = 3 then the next 3 attempts to allocate from this heap will fail.
+ */
+ EBurstFailNext,
+
+ /**
+ Use this to determine how many times the current debug
+ failure mode has failed so far.
+ @see RAllocator::__DbgCheckFailure()
+ */
+ ECheckFailure,
+ };
+
+
+ /**
+ Heap debug checking type flag.
+ */
+ enum TDbgHeapType {
+ /**
+ The heap is a user heap.
+ */
+ EUser,
+
+ /**
+ The heap is the Kernel heap.
+ */
+ EKernel
+ };
+
+
+ enum TAllocDebugOp {ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail};
+
+
+ /**
+ Flags controlling reallocation.
+ */
+ enum TReAllocMode {
+ /**
+ A reallocation of a cell must not change
+ the start address of the cell.
+ */
+ ENeverMove=1,
+
+ /**
+ Allows the start address of the cell to change
+ if the cell shrinks in size.
+ */
+ EAllowMoveOnShrink=2
+ };
+
+
+ enum TFlags {ESingleThreaded=1, EFixedSize=2, ETraceAllocs=4, EMonitorMemory=8,};
+ struct SCheckInfo {TBool iAll; TInt iCount; const TDesC8* iFileName; TInt iLineNum;};
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+ struct SRAllocatorBurstFail {TInt iBurst; TInt iRate; TInt iUnused[2];};
+#endif
+ enum {EMaxHandles=32};
+
+public:
+ inline RAllocator();
+#ifndef __KERNEL_MODE__
+ IMPORT_C TInt Open();
+ IMPORT_C void Close();
+ IMPORT_C TAny* AllocZ(TInt aSize);
+ IMPORT_C TAny* AllocZL(TInt aSize);
+ IMPORT_C TAny* AllocL(TInt aSize);
+ IMPORT_C TAny* AllocLC(TInt aSize);
+ IMPORT_C void FreeZ(TAny*& aCell);
+ IMPORT_C TAny* ReAllocL(TAny* aCell, TInt aSize, TInt aMode=0);
+ IMPORT_C TInt Count() const;
+ IMPORT_C TInt Count(TInt& aFreeCount) const;
+#endif
+ UIMPORT_C void Check() const;
+ UIMPORT_C void __DbgMarkStart();
+ UIMPORT_C TUint32 __DbgMarkEnd(TInt aCount);
+ UIMPORT_C TInt __DbgMarkCheck(TBool aCountAll, TInt aCount, const TDesC8& aFileName, TInt aLineNum);
+ inline void __DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum);
+ UIMPORT_C void __DbgSetAllocFail(TAllocFail aType, TInt aRate);
+ UIMPORT_C void __DbgSetBurstAllocFail(TAllocFail aType, TUint aRate, TUint aBurst);
+ UIMPORT_C TUint __DbgCheckFailure();
+protected:
+ UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+#ifndef __KERNEL_MODE__
+ IMPORT_C virtual void DoClose();
+#endif
+protected:
+ TInt iAccessCount;
+ TInt iHandleCount;
+ TInt* iHandles;
+ TUint32 iFlags;
+ TInt iCellCount;
+ TInt iTotalAllocSize;
+ };
+
+
+
+
+class UserHeap;
+/**
+@publishedAll
+@released
+
+Represents the default implementation for a heap.
+
+The default implementation uses an address-ordered first fit type algorithm.
+
+The heap itself is contained in a chunk and may be the only occupant of the
+chunk or may share the chunk with the program stack.
+
+The class contains member functions for allocating, adjusting, freeing individual
+cells and generally managing the heap.
+
+The class is not a handle in the same sense that RChunk is a handle; i.e.
+there is no Kernel object which corresponds to the heap.
+*/
+class RHeap : public RAllocator
+ {
+public:
+ /**
+ The structure of a heap cell header for a heap cell on the free list.
+ */
+ struct SCell {
+ /**
+ The length of the cell, which includes the length of
+ this header.
+ */
+ TInt len;
+
+
+ /**
+ A pointer to the next cell in the free list.
+ */
+ SCell* next;
+ };
+
+
+ /**
+ The structure of a heap cell header for an allocated heap cell in a debug build.
+ */
+ struct SDebugCell {
+ /**
+ The length of the cell, which includes the length of
+ this header.
+ */
+ TInt len;
+
+
+ /**
+ The nested level.
+ */
+ TInt nestingLevel;
+
+
+ /**
+ The cumulative number of allocated cells
+ */
+ TInt allocCount;
+ };
+
+ /**
+ @internalComponent
+ */
+ struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc; TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; };
+
+ /**
+ @internalComponent
+ */
+ struct _s_align {char c; double d;};
+
+ /**
+ The default cell alignment.
+ */
+ enum {ECellAlignment = sizeof(_s_align)-sizeof(double)};
+
+ /**
+ Size of a free cell header.
+ */
+ enum {EFreeCellSize = sizeof(SCell)};
+
+
+#ifdef _DEBUG
+ /**
+ Size of an allocated cell header in a debug build.
+ */
+ enum {EAllocCellSize = sizeof(SDebugCell)};
+#else
+ /**
+ Size of an allocated cell header in a release build.
+ */
+ enum {EAllocCellSize = sizeof(SCell*)};
+#endif
+
+
+ /**
+ @internalComponent
+ */
+ enum TDebugOp {EWalk=128};
+
+
+ /**
+ @internalComponent
+ */
+ enum TCellType
+ {EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress,
+ EBadFreeCellAddress, EBadFreeCellSize};
+
+
+ /**
+ @internalComponent
+ */
+ enum TDebugHeapId {EUser=0, EKernel=1};
+
+ /**
+ @internalComponent
+ */
+ enum TDefaultShrinkRatios {EShrinkRatio1=256, EShrinkRatioDflt=512};
+
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+ /**
+ @internalComponent
+ */
+#else
+private:
+#endif
+ typedef void (*TWalkFunc)(TAny*, TCellType, TAny*, TInt);
+
+public:
+ UIMPORT_C virtual TAny* Alloc(TInt aSize);
+ UIMPORT_C virtual void Free(TAny* aPtr);
+ UIMPORT_C virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0);
+ UIMPORT_C virtual TInt AllocLen(const TAny* aCell) const;
+#ifndef __KERNEL_MODE__
+ UIMPORT_C virtual TInt Compress();
+ UIMPORT_C virtual void Reset();
+ UIMPORT_C virtual TInt AllocSize(TInt& aTotalAllocSize) const;
+ UIMPORT_C virtual TInt Available(TInt& aBiggestBlock) const;
+#endif
+ UIMPORT_C virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL);
+protected:
+ UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+public:
+ UIMPORT_C RHeap(TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);
+ UIMPORT_C RHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign=0, TBool aSingleThread=EFalse);
+ UIMPORT_C TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;
+ inline void operator delete(TAny* aPtr, TAny* aBase);
+ inline TUint8* Base() const;
+ inline TInt Size() const;
+ inline TInt MaxLength() const;
+ inline TInt Align(TInt a) const;
+ inline const TAny* Align(const TAny* a) const;
+ inline TBool IsLastCell(const SCell* aCell) const;
+ inline void Lock() const;
+ inline void Unlock() const;
+ inline TInt ChunkHandle() const;
+protected:
+ inline RHeap();
+ void Initialise();
+ SCell* DoAlloc(TInt aSize, SCell*& aLastFree);
+ void DoFree(SCell* pC);
+ TInt TryToGrowHeap(TInt aSize, SCell* aLastFree);
+ inline void FindFollowingFreeCell(SCell* aCell, SCell*& pPrev, SCell*& aNext);
+ TInt TryToGrowCell(SCell* pC, SCell* pP, SCell* pE, TInt aSize);
+ TInt Reduce(SCell* aCell);
+ UIMPORT_C SCell* GetAddress(const TAny* aCell) const;
+ void CheckCell(const SCell* aCell) const;
+ void Walk(TWalkFunc aFunc, TAny* aPtr);
+ static void WalkCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen);
+ TInt DoCountAllocFree(TInt& aFree);
+ TInt DoCheckHeap(SCheckInfo* aInfo);
+ void DoMarkStart();
+ TUint32 DoMarkEnd(TInt aExpected);
+ void DoSetAllocFail(TAllocFail aType, TInt aRate);
+ TBool CheckForSimulatedAllocFail();
+ inline TInt SetBrk(TInt aBrk);
+ inline TAny* ReAllocImpl(TAny* aPtr, TInt aSize, TInt aMode);
+ void DoSetAllocFail(TAllocFail aType, TInt aRate, TUint aBurst);
+protected:
+ TInt iMinLength;
+ TInt iMaxLength;
+ TInt iOffset;
+ TInt iGrowBy;
+ TInt iChunkHandle;
+ RFastLock iLock;
+ TUint8* iBase;
+ TUint8* iTop;
+ TInt iAlign;
+ TInt iMinCell;
+ TInt iPageSize;
+ SCell iFree;
+protected:
+ TInt iNestingLevel;
+ TInt iAllocCount;
+ TAllocFail iFailType;
+ TInt iFailRate;
+ TBool iFailed;
+ TInt iFailAllocCount;
+ TInt iRand;
+ TAny* iTestData;
+
+ friend class UserHeap;
+ };
+
+
+
+
+
+class OnlyCreateWithNull;
+
+/** @internalTechnology */
+typedef void (OnlyCreateWithNull::* __NullPMF)();
+
+/** @internalTechnology */
+class OnlyCreateWithNull
+ {
+public:
+ inline OnlyCreateWithNull(__NullPMF /*aPointerToNull*/) {}
+ };
+
+/**
+@publishedAll
+@released
+
+A handle to a message sent by the client to the server.
+
+A server's interaction with its clients is channelled through an RMessagePtr2
+object, which acts as a handle to a message sent by the client.
+The details of the original message are kept by the kernel allowing it enforce
+correct usage of the member functions of this class.
+
+@see RMessage2
+*/
+class RMessagePtr2
+ {
+public:
+ inline RMessagePtr2();
+ inline TBool IsNull() const;
+ inline TInt Handle() const;
+#ifndef __KERNEL_MODE__
+ IMPORT_C void Complete(TInt aReason) const;
+ IMPORT_C void Complete(RHandleBase aHandle) const;
+ IMPORT_C TInt GetDesLength(TInt aParam) const;
+ IMPORT_C TInt GetDesLengthL(TInt aParam) const;
+ IMPORT_C TInt GetDesMaxLength(TInt aParam) const;
+ IMPORT_C TInt GetDesMaxLengthL(TInt aParam) const;
+ IMPORT_C void ReadL(TInt aParam,TDes8& aDes,TInt aOffset=0) const;
+ IMPORT_C void ReadL(TInt aParam,TDes16 &aDes,TInt aOffset=0) const;
+ IMPORT_C void WriteL(TInt aParam,const TDesC8& aDes,TInt aOffset=0) const;
+ IMPORT_C void WriteL(TInt aParam,const TDesC16& aDes,TInt aOffset=0) const;
+ IMPORT_C TInt Read(TInt aParam,TDes8& aDes,TInt aOffset=0) const;
+ IMPORT_C TInt Read(TInt aParam,TDes16 &aDes,TInt aOffset=0) const;
+ IMPORT_C TInt Write(TInt aParam,const TDesC8& aDes,TInt aOffset=0) const;
+ IMPORT_C TInt Write(TInt aParam,const TDesC16& aDes,TInt aOffset=0) const;
+ IMPORT_C void Panic(const TDesC& aCategory,TInt aReason) const;
+ IMPORT_C void Kill(TInt aReason) const;
+ IMPORT_C void Terminate(TInt aReason) const;
+ IMPORT_C TInt SetProcessPriority(TProcessPriority aPriority) const;
+ inline void SetProcessPriorityL(TProcessPriority aPriority) const;
+ IMPORT_C TInt Client(RThread& aClient, TOwnerType aOwnerType=EOwnerProcess) const;
+ inline void ClientL(RThread& aClient, TOwnerType aOwnerType=EOwnerProcess) const;
+ IMPORT_C TUint ClientProcessFlags() const;
+ IMPORT_C const TRequestStatus* ClientStatus() const;
+
+ /**
+ Return the Secure ID of the process which sent this message.
+
+ If an intended use of this method is to check that the Secure ID is
+ a given value, then the use of a TSecurityPolicy object should be
+ considered. E.g. Instead of something like:
+
+ @code
+ RMessagePtr2& message;
+ TInt error = message.SecureId()==KRequiredSecureId ? KErrNone : KErrPermissionDenied;
+ @endcode
+
+ this could be used;
+
+ @code
+ RMessagePtr2& message;
+ static _LIT_SECURITY_POLICY_S0(mySidPolicy, KRequiredSecureId);
+ TBool pass = mySidPolicy().CheckPolicy(message);
+ @endcode
+
+ This has the benefit that the TSecurityPolicy::CheckPolicy methods are
+ configured by the system wide Platform Security configuration. I.e. are
+ capable of emitting diagnostic messages when a check fails and/or the
+ check can be forced to always pass.
+
+ @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
+ @see _LIT_SECURITY_POLICY_S0
+
+ @return The Secure ID.
+
+ @publishedAll
+ @released
+ */
+ IMPORT_C TSecureId SecureId() const;
+
+ /**
+ Return the Vendor ID of the process which sent this message.
+
+ If an intended use of this method is to check that the Vendor ID is
+ a given value, then the use of a TSecurityPolicy object should be
+ considered. E.g. Instead of something like:
+
+ @code
+ RMessagePtr2& message;
+ TInt error = message.VendorId()==KRequiredVendorId ? KErrNone : KErrPermissionDenied;
+ @endcode
+
+ this could be used;
+
+ @code
+ RMessagePtr2& message;
+ static _LIT_SECURITY_POLICY_V0(myVidPolicy, KRequiredVendorId);
+ TBool pass = myVidPolicy().CheckPolicy(message);
+ @endcode
+
+ This has the benefit that the TSecurityPolicy::CheckPolicy methods are
+ configured by the system wide Platform Security configuration. I.e. are
+ capable of emitting diagnostic messages when a check fails and/or the
+ check can be forced to always pass.
+
+ @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
+ @see _LIT_SECURITY_POLICY_V0
+
+ @return The Vendor ID.
+ @publishedAll
+ @released
+ */
+ IMPORT_C TVendorId VendorId() const;
+
+ /**
+ Check if the process which sent this message has a given capability.
+
+ When a check fails the action taken is determined by the system wide Platform Security
+ configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
+ If PlatSecEnforcement is OFF, then this function will return ETrue even though the
+ check failed.
+
+ @param aCapability The capability to test.
+ @param aDiagnostic A string that will be emitted along with any diagnostic message
+ that may be issued if the test finds the capability is not present.
+ This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
+ which enables it to be easily removed from the system.
+ @return ETrue if process which sent this message has the capability, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool HasCapability(TCapability aCapability, const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /**
+ Check if the process which sent this message has a given capability.
+
+ When a check fails the action taken is determined by the system wide Platform Security
+ configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
+ If PlatSecEnforcement is OFF, then this function will not leave even though the
+ check failed.
+
+ @param aCapability The capability to test.
+ @param aDiagnosticMessage A string that will be emitted along with any diagnostic message
+ that may be issued if the test finds the capability is not present.
+ This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
+ which enables it to be easily removed from the system.
+ @leave KErrPermissionDenied, if the process does not have the capability.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline void HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline void HasCapabilityL(TCapability aCapability, OnlyCreateWithNull aDiagnosticMessage=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline void HasCapabilityL(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /**
+ Check if the process which sent this message has both of the given capabilities.
+
+ When a check fails the action taken is determined by the system wide Platform Security
+ configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
+ If PlatSecEnforcement is OFF, then this function will return ETrue even though the
+ check failed.
+
+ @param aCapability1 The first capability to test.
+ @param aCapability2 The second capability to test.
+ @param aDiagnostic A string that will be emitted along with any diagnostic message
+ that may be issued if the test finds a capability is not present.
+ This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
+ which enables it to be easily removed from the system.
+ @return ETrue if the process which sent this message has both the capabilities, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /**
+ Check if the process which sent this message has both of the given capabilities.
+
+ When a check fails the action taken is determined by the system wide Platform Security
+ configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
+ If PlatSecEnforcement is OFF, then this function will not leave even though the
+ check failed.
+
+ @param aCapability1 The first capability to test.
+ @param aCapability2 The second capability to test.
+ @param aDiagnosticMessage A string that will be emitted along with any diagnostic message
+ that may be issued if the test finds a capability is not present.
+ This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
+ which enables it to be easily removed from the system.
+ @leave KErrPermissionDenied, if the process does not have the capabilities.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, const char* aDiagnosticMessage=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnosticMessage=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /**
+ @deprecated Use SecureId()
+ */
+ inline TUid Identity() const { return SecureId(); }
+#endif
+
+private:
+ // Implementations of functions with diagnostics
+ IMPORT_C TBool DoHasCapability(TCapability aCapability, const char* aDiagnostic) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability, TCapability aCapability2, const char* aDiagnostic) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability, TCapability aCapability2) const;
+
+protected:
+ TInt iHandle;
+ };
+inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight);
+inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight);
+
+class CSession2;
+
+#define __IPC_V2_PRESENT__
+
+/**
+@publishedAll
+@released
+
+An object that encapsulates the details of a client request.
+*/
+class RMessage2 : public RMessagePtr2
+ {
+ friend class CServer2;
+public:
+
+ /**
+ Defines internal message types.
+ */
+ enum TSessionMessages {
+ /**
+ A message type used internally that means connect.
+ */
+ EConnect=-1,
+
+ /**
+ A message type used internally that means disconnect.
+ */
+ EDisConnect=-2
+ };
+public:
+ inline RMessage2();
+#ifndef __KERNEL_MODE__
+ IMPORT_C explicit RMessage2(const RMessagePtr2& aPtr);
+ void SetAuthorised() const;
+ void ClearAuthorised() const;
+ TBool Authorised() const;
+#endif
+ inline TInt Function() const;
+ inline TInt Int0() const;
+ inline TInt Int1() const;
+ inline TInt Int2() const;
+ inline TInt Int3() const;
+ inline const TAny* Ptr0() const;
+ inline const TAny* Ptr1() const;
+ inline const TAny* Ptr2() const;
+ inline const TAny* Ptr3() const;
+ inline CSession2* Session() const;
+protected:
+
+ /**
+ The request type.
+ */
+ TInt iFunction;
+
+ /**
+ A copy of the message arguments.
+ */
+ TInt iArgs[KMaxMessageArguments];
+private:
+ TInt iSpare1;
+protected:
+ /**
+ @internalComponent
+ */
+ const TAny* iSessionPtr;
+private:
+ mutable TInt iFlags;// Currently only used for *Authorised above
+ TInt iSpare3; // Reserved for future use
+
+ friend class RMessage;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines an 8-bit modifiable buffer descriptor to contain passwords when dealing
+with password security support in a file server session.
+
+The descriptor takes a maximum length of KMaxMediaPassword.
+
+@see KMaxMediaPassword
+*/
+typedef TBuf8<KMaxMediaPassword> TMediaPassword; // 128 bit
+
+
+
+/**
+@publishedPartner
+@prototype
+A configuration flag for the shared chunk buffer configuration class (used by the multimedia device drivers). This being
+set signifies that a buffer offset list follows the buffer configuration class. This list holds the offset of each buffer.
+*/
+const TUint KScFlagBufOffsetListInUse=0x00000001;
+
+/**
+@publishedPartner
+@prototype
+A configuration flag for the shared chunk buffer configuration class (used by the multimedia device drivers). This being
+set is a suggestion that the shared chunk should be configured leaving guard pages around each buffers.
+*/
+const TUint KScFlagUseGuardPages=0x00000002;
+
+/**
+@publishedPartner
+@prototype
+The shared chunk buffer configuration class (used by the multimedia device drivers). This is used to hold information
+on the current buffer configuration within a shared chunk.
+*/
+class TSharedChunkBufConfigBase
+ {
+public:
+ inline TSharedChunkBufConfigBase();
+public:
+ /** The number of buffers. */
+ TInt iNumBuffers;
+ /** The size of each buffer in bytes. */
+ TInt iBufferSizeInBytes;
+ /** Reserved field. */
+ TInt iReserved1;
+ /** Shared chunk buffer flag settings. */
+ TUint iFlags;
+ };
+
+
+/** Maximum size of capability set
+
+@internalTechnology
+*/
+const TInt KCapabilitySetMaxSize = (((TInt)ECapability_HardLimit + 7)>>3);
+
+/** Maximum size of any future extension to TSecurityPolicy
+
+@internalTechnology
+*/
+const TInt KMaxSecurityPolicySize = KCapabilitySetMaxSize + 3*sizeof(TUint32);
+
+
+/** Class representing an arbitrary set of capabilities.
+
+This class can only contain capabilities supported by the current OS version.
+
+@publishedAll
+@released
+*/
+class TCapabilitySet
+ {
+public:
+ inline TCapabilitySet();
+ inline TCapabilitySet(TCapability aCapability);
+ IMPORT_C TCapabilitySet(TCapability aCapability1, TCapability aCapability2);
+ IMPORT_C void SetEmpty();
+ inline void Set(TCapability aCapability);
+ inline void Set(TCapability aCapability1, TCapability aCapability2);
+ IMPORT_C void SetAllSupported();
+ IMPORT_C void AddCapability(TCapability aCapability);
+ IMPORT_C void RemoveCapability(TCapability aCapability);
+ IMPORT_C void Union(const TCapabilitySet& aCapabilities);
+ IMPORT_C void Intersection(const TCapabilitySet& aCapabilities);
+ IMPORT_C void Remove(const TCapabilitySet& aCapabilities);
+ IMPORT_C TBool HasCapability(TCapability aCapability) const;
+ IMPORT_C TBool HasCapabilities(const TCapabilitySet& aCapabilities) const;
+
+ /**
+ Make this set consist of the capabilities which are disabled on this platform.
+ @internalTechnology
+ */
+ IMPORT_C void SetDisabled();
+ /**
+ @internalComponent
+ */
+ TBool NotEmpty() const;
+
+private:
+ TUint32 iCaps[KCapabilitySetMaxSize / sizeof(TUint32)];
+ };
+
+#ifndef __SECURITY_INFO_DEFINED__
+#define __SECURITY_INFO_DEFINED__
+/**
+@internalTechnology
+ */
+struct SCapabilitySet
+ {
+ enum {ENCapW=2};
+
+ inline void AddCapability(TCapability aCap1) {((TCapabilitySet*)this)->AddCapability(aCap1);}
+ inline void Remove(const SCapabilitySet& aCaps) {((TCapabilitySet*)this)->Remove(*((TCapabilitySet*)&aCaps));}
+ inline TBool NotEmpty() const {return ((TCapabilitySet*)this)->NotEmpty();}
+
+ inline const TUint32& operator[] (TInt aIndex) const { return iCaps[aIndex]; }
+ inline TUint32& operator[] (TInt aIndex) { return iCaps[aIndex]; }
+
+ TUint32 iCaps[ENCapW];
+ };
+
+/**
+@internalTechnology
+ */
+struct SSecurityInfo
+ {
+ TUint32 iSecureId;
+ TUint32 iVendorId;
+ SCapabilitySet iCaps; // Capabilities re. platform security
+ };
+
+#endif
+
+/** Define this macro to reference the set of all capabilities.
+ @internalTechnology
+*/
+#ifdef __REFERENCE_ALL_SUPPORTED_CAPABILITIES__
+
+extern const SCapabilitySet AllSupportedCapabilities;
+
+#endif //__REFERENCE_ALL_SUPPORTED_CAPABILITIES__
+
+/** Define this macro to include the set of all capabilities.
+ @internalTechnology
+*/
+#ifdef __INCLUDE_ALL_SUPPORTED_CAPABILITIES__
+
+/** The set of all capabilities.
+ @internalTechnology
+*/
+const SCapabilitySet AllSupportedCapabilities = {
+ {
+ ECapability_Limit<32 ? (TUint32)((1u<<(ECapability_Limit&31))-1u) : 0xffffffffu
+ ,
+ ECapability_Limit>=32 ? (TUint32)((1u<<(ECapability_Limit&31))-1u) : 0u
+ }
+ };
+
+#endif // __INCLUDE_ALL_SUPPORTED_CAPABILITIES__
+
+#ifndef __KERNEL_MODE__
+class RProcess;
+class RThread;
+class RMessagePtr2;
+class RSessionBase;
+#else
+class DProcess;
+class DThread;
+#endif
+
+/** Class representing all security attributes of a process or DLL.
+ These comprise a set of capabilities, a Secure ID and a Vendor ID.
+
+@publishedAll
+@released
+*/
+class TSecurityInfo
+ {
+public:
+ inline TSecurityInfo();
+#ifdef __KERNEL_MODE__
+ IMPORT_C TSecurityInfo(DProcess* aProcess);
+ IMPORT_C TSecurityInfo(DThread* aThread);
+#else
+ IMPORT_C TSecurityInfo(RProcess aProcess);
+ IMPORT_C TSecurityInfo(RThread aThread);
+ IMPORT_C TSecurityInfo(RMessagePtr2 aMesPtr);
+ inline void Set(RProcess aProcess);
+ inline void Set(RThread aThread);
+ inline void Set(RMessagePtr2 aMsgPtr);
+ TInt Set(RSessionBase aSession); /**< @internalComponent */
+ inline void SetToCurrentInfo();
+ IMPORT_C void SetToCreatorInfo();
+#endif //__KERNEL_MODE__
+public:
+ TSecureId iSecureId; /**< Secure ID */
+ TVendorId iVendorId; /**< Vendor ID */
+ TCapabilitySet iCaps; /**< Capability Set */
+ };
+
+
+/** Class representing a generic security policy
+
+This class can specify a security policy consisting of either:
+
+-# A check for between 0 and 7 capabilities
+-# A check for a given Secure ID along with 0-3 capabilities
+-# A check for a given Vendor ID along with 0-3 capabilities
+
+If multiple capabilities are specified, all of them must be present for the
+security check to succeed ('AND' relation).
+
+The envisaged use case for this class is to specify access rights to an object
+managed either by the kernel or by a server but in principle owned by a client
+and usable in a limited way by other clients. For example
+- Publish and Subscribe properties
+- DBMS databases
+
+In these cases the owning client would pass one (or more) of these objects to
+the server to specify which security checks should be done on other clients
+before allowing access to the object.
+
+To pass a TSecurityPolicy object via IPC, a client should obtain a descriptor
+for the object using Package() and send this. When a server receives this descriptor
+it should read the descriptor contents into a TSecurityPolicyBuf and then
+Set() should be used to create a policy object from this.
+
+Because this class has non-default constructors, compilers will not initialise
+this object at compile time, instead code will be generated to construct the object
+at run-time. This is wasteful - and Symbian OS DLLs are not permitted to have
+such uninitialised data. To overcome these problems a set of macros are provided to
+construct a const object which behaves like a TSecurityPolicy. These are:
+
+_LIT_SECURITY_POLICY_C1 through _LIT_SECURITY_POLICY_C7,
+_LIT_SECURITY_POLICY_S0 through _LIT_SECURITY_POLICY_S3 and
+_LIT_SECURITY_POLICY_V0 through _LIT_SECURITY_POLICY_V3.
+
+Also, the macros _LIT_SECURITY_POLICY_PASS and _LIT_SECURITY_POLICY_FAIL are provided
+in order to allow easy construction of a const object which can be used as a
+TSecuityPolicy which always passes or always fails, respectively.
+
+If a security policy object is needed to be embedded in another class then the
+TStaticSecurityPolicy structure can be used. This behaves in the same way as a
+TSecurityPolicy object but may be initialised at compile time.
+
+@see TStaticSecurityPolicy
+@see TSecurityPolicyBuf
+@see _LIT_SECURITY_POLICY_PASS
+@see _LIT_SECURITY_POLICY_FAIL
+@see _LIT_SECURITY_POLICY_C1
+@see _LIT_SECURITY_POLICY_C2
+@see _LIT_SECURITY_POLICY_C3
+@see _LIT_SECURITY_POLICY_C4
+@see _LIT_SECURITY_POLICY_C5
+@see _LIT_SECURITY_POLICY_C6
+@see _LIT_SECURITY_POLICY_C7
+@see _LIT_SECURITY_POLICY_S0
+@see _LIT_SECURITY_POLICY_S1
+@see _LIT_SECURITY_POLICY_S2
+@see _LIT_SECURITY_POLICY_S3
+@see _LIT_SECURITY_POLICY_V0
+@see _LIT_SECURITY_POLICY_V1
+@see _LIT_SECURITY_POLICY_V2
+@see _LIT_SECURITY_POLICY_V3
+
+@publishedAll
+@released
+*/
+class TSecurityPolicy
+ {
+public:
+ enum TSecPolicyType
+ {
+ EAlwaysFail=0,
+ EAlwaysPass=1,
+ };
+
+public:
+ inline TSecurityPolicy();
+ IMPORT_C TSecurityPolicy(TSecPolicyType aType);
+ IMPORT_C TSecurityPolicy(TCapability aCap1, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None);
+ IMPORT_C TSecurityPolicy(TCapability aCap1, TCapability aCap2, TCapability aCap3, TCapability aCap4, TCapability aCap5 = ECapability_None, TCapability aCap6 = ECapability_None, TCapability aCap7 = ECapability_None);
+ IMPORT_C TSecurityPolicy(TSecureId aSecureId, TCapability aCap1 = ECapability_None, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None);
+ IMPORT_C TSecurityPolicy(TVendorId aVendorId, TCapability aCap1 = ECapability_None, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None);
+ IMPORT_C TInt Set(const TDesC8& aDes);
+ IMPORT_C TPtrC8 Package() const;
+
+#ifdef __KERNEL_MODE__
+
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool CheckPolicy(DProcess* aProcess, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicy(DThread* aThread, const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool CheckPolicy(DProcess* aProcess, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicy(DThread* aThread, OnlyCreateWithNull aDiagnostic=NULL) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+#else // !__KERNEL_MODE__
+
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool CheckPolicy(RProcess aProcess, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicy(RThread aThread, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicyCreator(const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ TInt CheckPolicy(RSessionBase aSession) const; /**< @internalComponent */
+
+#endif //__KERNEL_MODE__
+
+ TBool Validate() const;
+
+private:
+#ifdef __KERNEL_MODE__
+ IMPORT_C TBool DoCheckPolicy(DProcess* aProcess, const char* aDiagnostic) const;
+ IMPORT_C TBool DoCheckPolicy(DProcess* aProcess) const;
+ IMPORT_C TBool DoCheckPolicy(DThread* aThread, const char* aDiagnostic) const;
+ IMPORT_C TBool DoCheckPolicy(DThread* aThread) const;
+#else // !__KERNEL_MODE__
+ IMPORT_C TBool DoCheckPolicy(RProcess aProcess, const char* aDiagnostic) const;
+ IMPORT_C TBool DoCheckPolicy(RProcess aProcess) const;
+ IMPORT_C TBool DoCheckPolicy(RThread aThread, const char* aDiagnostic) const;
+ IMPORT_C TBool DoCheckPolicy(RThread aThread) const;
+ IMPORT_C TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const;
+ IMPORT_C TBool DoCheckPolicy(RMessagePtr2 aMsgPtr) const;
+ IMPORT_C TBool DoCheckPolicyCreator(const char* aDiagnostic) const;
+ IMPORT_C TBool DoCheckPolicyCreator() const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const;
+#endif //__REMOVE_PLATSEC_DIAGNOSTICS__
+ TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing) const;
+#endif //__KERNEL_MODE__
+
+public:
+ /** Constants to specify the type of TSecurityPolicy objects.
+ */
+ enum TType
+ {
+ ETypeFail=0, /**< Always fail*/
+ ETypePass=1, /**< Always pass*/
+ ETypeC3=2, /**< Up to 3 capabilities*/
+ ETypeC7=3, /**< Up to 7 capabilities*/
+ ETypeS3=4, /**< Secure ID and up to 3 capabilities*/
+ ETypeV3=5, /**< Vendor ID and up to 3 capabilities*/
+
+ /** The number of possible TSecurityPolicy types
+ This is intended of internal Symbain use only.
+ @internalTechnology
+ */
+ ETypeLimit
+
+ // other values may be added to indicate expanded policy objects (future extensions)
+ };
+protected:
+ TBool CheckPolicy(const SSecurityInfo& aSecInfo, SSecurityInfo& aMissing) const;
+private:
+ void ConstructAndCheck3(TCapability aCap1, TCapability aCap2, TCapability aCap3);
+private:
+ TUint8 iType;
+ TUint8 iCaps[3]; // missing capabilities are set to 0xff
+ union
+ {
+ TUint32 iSecureId;
+ TUint32 iVendorId;
+ TUint8 iExtraCaps[4]; // missing capabilities are set to 0xff
+ };
+ friend class TCompiledSecurityPolicy;
+ };
+
+/** Provides a TPkcgBuf wrapper for a descriptorised TSecurityPolicy. This a
+suitable container for passing a security policy across IPC.
+@publishedAll
+@released
+*/
+typedef TPckgBuf<TSecurityPolicy> TSecurityPolicyBuf;
+
+
+/** Structure for compile-time initialisation of a security policy.
+
+This structure behaves in the same way as a TSecurityPolicy object but has
+the advantage that it may be initialised at compile time. E.g.
+the following line defines a security policy 'KSecurityPolictReadUserData'
+which checks ReadUserData capability.
+
+@code
+_LIT_SECURITY_POLICY_C1(KSecurityPolictReadUserData,ECapabilityReadUserData)
+@endcode
+
+Or, an array of security policies may be created like this:
+@code
+static const TStaticSecurityPolicy MyPolicies[] =
+ {
+ _INIT_SECURITY_POLICY_C1(ECapabilityReadUserData),
+ _INIT_SECURITY_POLICY_PASS(),
+ _INIT_SECURITY_POLICY_S0(0x1234567)
+ }
+@endcode
+
+This class should not be initialised directly, instead one of the following
+macros should be used:
+
+- _INIT_SECURITY_POLICY_PASS
+- _INIT_SECURITY_POLICY_FAIL
+- _INIT_SECURITY_POLICY_C1
+- _INIT_SECURITY_POLICY_C2
+- _INIT_SECURITY_POLICY_C3
+- _INIT_SECURITY_POLICY_C4
+- _INIT_SECURITY_POLICY_C5
+- _INIT_SECURITY_POLICY_C6
+- _INIT_SECURITY_POLICY_C7
+- _INIT_SECURITY_POLICY_S0
+- _INIT_SECURITY_POLICY_S1
+- _INIT_SECURITY_POLICY_S2
+- _INIT_SECURITY_POLICY_S3
+- _INIT_SECURITY_POLICY_V0
+- _INIT_SECURITY_POLICY_V1
+- _INIT_SECURITY_POLICY_V2
+- _INIT_SECURITY_POLICY_V3
+- _LIT_SECURITY_POLICY_PASS
+- _LIT_SECURITY_POLICY_FAIL
+- _LIT_SECURITY_POLICY_C1
+- _LIT_SECURITY_POLICY_C2
+- _LIT_SECURITY_POLICY_C3
+- _LIT_SECURITY_POLICY_C4
+- _LIT_SECURITY_POLICY_C5
+- _LIT_SECURITY_POLICY_C6
+- _LIT_SECURITY_POLICY_C7
+- _LIT_SECURITY_POLICY_S0
+- _LIT_SECURITY_POLICY_S1
+- _LIT_SECURITY_POLICY_S2
+- _LIT_SECURITY_POLICY_S3
+- _LIT_SECURITY_POLICY_V0
+- _LIT_SECURITY_POLICY_V1
+- _LIT_SECURITY_POLICY_V2
+- _LIT_SECURITY_POLICY_V3
+
+@see TSecurityPolicy
+@publishedAll
+@released
+*/
+struct TStaticSecurityPolicy
+ {
+ inline const TSecurityPolicy* operator&() const;
+ inline operator const TSecurityPolicy&() const;
+ inline const TSecurityPolicy& operator()() const;
+
+#ifndef __KERNEL_MODE__
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool CheckPolicy(RProcess aProcess, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicy(RThread aThread, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic=0) const;
+ inline TBool CheckPolicyCreator(const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic=NULL) const;
+ inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+ inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+#endif // !__KERNEL_MODE__
+
+ TUint32 iA; /**< @internalComponent */
+ TUint32 iB; /**< @internalComponent */
+ };
+
+
+/**
+A dummy enum for use by the CAPABILITY_AS_TUINT8 macro
+@internalComponent
+*/
+enum __invalid_capability_value {};
+
+/**
+A macro to cast a TCapability to a TUint8.
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param cap The capability value
+@internalComponent
+*/
+#define CAPABILITY_AS_TUINT8(cap) \
+ ((TUint8)(int)( \
+ (cap)==ECapability_None \
+ ? (__invalid_capability_value(*)[1])(ECapability_None) \
+ : (__invalid_capability_value(*)[((TUint)(cap+1)<=(TUint)ECapability_Limit)?1:2])(cap) \
+ ))
+
+
+/**
+A macro to construct a TUint32 from four TUint8s. The TUint32 is in BigEndian
+ordering useful for class layout rather than number generation.
+
+@param i1 The first TUint8
+@param i2 The second TUint8
+@param i3 The third TUint8
+@param i4 The fourth TUint8
+@internalComponent
+*/
+#define FOUR_TUINT8(i1,i2,i3,i4) \
+ (TUint32)( \
+ (TUint8)i1 | \
+ (TUint8)i2 << 8 | \
+ (TUint8)i3 << 16 | \
+ (TUint8)i4 << 24 \
+ )
+
+
+/** Macro for compile-time initialisation of a security policy object that
+always fails. That is, checks against this policy will always fail,
+irrespective of the security attributes of the item being checked.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_FAIL \
+ { \
+ FOUR_TUINT8( \
+ (TUint8)TSecurityPolicy::ETypeFail, \
+ (TUint8)0xff, \
+ (TUint8)0xff, \
+ (TUint8)0xff \
+ ), \
+ (TUint32)0xffffffff \
+ }
+
+
+/** Macro for compile-time definition of a security policy object that always
+fails. That is, checks against this policy will always fail, irrespective of
+the security attributes of the item being checked.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+@param n Name to use for policy object
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_FAIL(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_FAIL
+
+
+/** Macro for compile-time initialisation of a security policy object that
+always passes. That is, checks against this policy will always pass,
+irrespective of the security attributes of the item being checked.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_PASS \
+ { \
+ FOUR_TUINT8( \
+ (TUint8)TSecurityPolicy::ETypePass, \
+ (TUint8)0xff, \
+ (TUint8)0xff, \
+ (TUint8)0xff \
+ ), \
+ (TUint32)0xffffffff \
+ }
+
+
+/** Macro for compile-time definition of a security policy object that always
+passes. That is, checks against this policy will always pass, irrespective of
+the security attributes of the item being checked.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+@param n Name to use for policy object
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_PASS(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_PASS
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for seven capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+@param c5 The fifth capability to check (enumerator of TCapability)
+@param c6 The sixth capability to check (enumerator of TCapability)
+@param c7 The seventh capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,c7) \
+ { \
+ FOUR_TUINT8( \
+ (TUint8)TSecurityPolicy::ETypeC7, \
+ CAPABILITY_AS_TUINT8(c1), \
+ CAPABILITY_AS_TUINT8(c2), \
+ CAPABILITY_AS_TUINT8(c3) \
+ ), \
+ FOUR_TUINT8( \
+ CAPABILITY_AS_TUINT8(c4), \
+ CAPABILITY_AS_TUINT8(c5), \
+ CAPABILITY_AS_TUINT8(c6), \
+ CAPABILITY_AS_TUINT8(c7) \
+ ) \
+ }
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for seven capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+@param c5 The fifth capability to check (enumerator of TCapability)
+@param c6 The sixth capability to check (enumerator of TCapability)
+@param c7 The seventh capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,c6,c7) \
+ const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,c7)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for six capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+@param c5 The fifth capability to check (enumerator of TCapability)
+@param c6 The sixth capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_C6(c1,c2,c3,c4,c5,c6) \
+ _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for six capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+@param c5 The fifth capability to check (enumerator of TCapability)
+@param c6 The sixth capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_C6(n,c1,c2,c3,c4,c5,c6) \
+ _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,c6,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for five capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+@param c5 The fifth capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_C5(c1,c2,c3,c4,c5) \
+ _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for five capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+@param c5 The fifth capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_C5(n,c1,c2,c3,c4,c5) \
+ _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for four capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_C4(c1,c2,c3,c4) \
+ _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,ECapability_None,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for four capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+@param c4 The fourth capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_C4(n,c1,c2,c3,c4) \
+ _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,ECapability_None,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for three capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_C3(c1,c2,c3) \
+ { \
+ FOUR_TUINT8( \
+ (TUint8)TSecurityPolicy::ETypeC3, \
+ CAPABILITY_AS_TUINT8(c1), \
+ CAPABILITY_AS_TUINT8(c2), \
+ CAPABILITY_AS_TUINT8(c3) \
+ ), \
+ (TUint32)0xffffffff \
+ }
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for three capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_C3(n,c1,c2,c3) \
+ const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_C3(c1,c2,c3)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for two capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_C2(c1,c2) \
+ _INIT_SECURITY_POLICY_C3(c1,c2,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for two capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_C2(n,c1,c2) \
+ _LIT_SECURITY_POLICY_C3(n,c1,c2,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for one capability.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param c1 The first capability to check (enumerator of TCapability)
+
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_C1(c1) \
+ _INIT_SECURITY_POLICY_C3(c1,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for one capability.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning will be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param c1 The first capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_C1(n,c1) \
+ _LIT_SECURITY_POLICY_C3(n,c1,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a secure ID and three capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param sid The SID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_S3(sid,c1,c2,c3) \
+ { \
+ FOUR_TUINT8( \
+ (TUint8)TSecurityPolicy::ETypeS3, \
+ CAPABILITY_AS_TUINT8(c1), \
+ CAPABILITY_AS_TUINT8(c2), \
+ CAPABILITY_AS_TUINT8(c3) \
+ ), \
+ (TUint32)(sid) \
+ }
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a secure ID and three capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param sid The SID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_S3(n,sid,c1,c2,c3) \
+ const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_S3(sid,c1,c2,c3)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a secure ID and two capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param sid The SID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_S2(sid,c1,c2) \
+ _INIT_SECURITY_POLICY_S3(sid,c1,c2,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a secure ID and two capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param sid The SID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_S2(n,sid,c1,c2) \
+ _LIT_SECURITY_POLICY_S3(n,sid,c1,c2,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a secure ID and one capability.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param sid The SID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_S1(sid,c1) \
+ _INIT_SECURITY_POLICY_S3(sid,c1,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a secure ID and one capability.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param sid The SID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_S1(n,sid,c1) \
+ _LIT_SECURITY_POLICY_S3(n,sid,c1,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a secure ID.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+@param sid The SID value to check for
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_S0(sid) \
+ _INIT_SECURITY_POLICY_S3(sid,ECapability_None,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a secure ID.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+@param n Name to use for policy object
+@param sid The SID value to check for
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_S0(n,sid) \
+ _LIT_SECURITY_POLICY_S3(n,sid,ECapability_None,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a vendor ID and three capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param vid The VID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_V3(vid,c1,c2,c3) \
+ { \
+ FOUR_TUINT8( \
+ (TUint8)TSecurityPolicy::ETypeV3, \
+ CAPABILITY_AS_TUINT8(c1), \
+ CAPABILITY_AS_TUINT8(c2), \
+ CAPABILITY_AS_TUINT8(c3) \
+ ), \
+ (TUint32)(vid) \
+ }
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a vendor ID and three capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param vid The VID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+@param c3 The third capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_V3(n,vid,c1,c2,c3) \
+ const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_V3(vid,c1,c2,c3)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a vendor ID and two capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param vid The VID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_V2(vid,c1,c2) \
+ _INIT_SECURITY_POLICY_V3(vid,c1,c2,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a vendor ID and two capabilities.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param vid The VID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+@param c2 The second capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_V2(n,vid,c1,c2) \
+ _LIT_SECURITY_POLICY_V3(n,vid,c1,c2,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a vendor ID and one capability.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param vid The VID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_V1(vid,c1) \
+ _INIT_SECURITY_POLICY_V3(vid,c1,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a vendor ID and one capability.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+If an invlid capability value is specified then, dependant on the compiler,
+a compile time error or warning be produced which includes the label
+"__invalid_capability_value"
+
+@param n Name to use for policy object
+@param vid The VID value to check for
+@param c1 The first capability to check (enumerator of TCapability)
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_V1(n,vid,c1) \
+ _LIT_SECURITY_POLICY_V3(n,vid,c1,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time initialisation of a security policy object
+The policy will check for a vendor ID.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+@param vid The VID value to check for
+
+@publishedAll
+@released
+*/
+#define _INIT_SECURITY_POLICY_V0(vid) \
+ _INIT_SECURITY_POLICY_V3(vid,ECapability_None,ECapability_None,ECapability_None)
+
+
+/** Macro for compile-time definition of a security policy object
+The policy will check for a vendor ID.
+
+The object declared has an implicit conversion to const TSecurityPolicy&.
+Taking the address of the object will return a const TSecurityPolicy*.
+Explicit conversion to const TSecurityPolicy& may be effected by using the
+function call operator n().
+
+@param n Name to use for policy object
+@param vid The VID value to check for
+
+@publishedAll
+@released
+*/
+#define _LIT_SECURITY_POLICY_V0(n,vid) \
+ _LIT_SECURITY_POLICY_V3(n,vid,ECapability_None,ECapability_None,ECapability_None)
+
+
+
+#ifdef __KERNEL_MODE__
+class DThread;
+class RMessageK;
+#endif
+class TPlatSecDiagnostic;
+
+/**
+Class containing Platform Security related methods
+@internalTechnology
+*/
+class PlatSec
+ {
+#ifndef __KERNEL_MODE__
+public:
+ /**
+ Tests whether a given Platform Security capability is enforced by the system.
+
+ Capabilities may not be enforced for several reasons:
+ -# The capability has been explicitly disabled on this system
+ by use of the PlatSecDisabledCaps configuration parameter
+ -# Platform Security checks have been globally disabled
+ by use of the EPlatSecEnforcement configuration parameter
+ -# The capability value is unknown. I.e. Is not part of the set of supported
+ capabilities. See TCapabilitySet::SetAllSupported().
+
+ @param aCapability The capability to test
+ @return A non-zero value if the capability is enforced, zero if it is not.
+
+ @publishedAll
+ @released
+ */
+ IMPORT_C static TBool IsCapabilityEnforced(TCapability aCapability);
+
+ /**
+ An enumeration used with PlatSecSetting()
+ @see PlatSecSetting()
+ @publishedAll
+ @test
+ */
+ enum TConfigSetting
+ {
+ EPlatSecEnforcement, /**< Used to request the value of the PlatSecEnforcement setting */
+ EPlatSecDiagnotics, /**< Used to request the value of the PlatSecDiagnotics setting */
+ EPlatSecProcessIsolation, /**< Used to request the value of the PlatSecProcessIsolation setting */
+ EPlatSecEnforceSysBin, /**< Used to request the value of the PlatSecEnforceSysBin setting */
+ EPlatSecLocked, /**< Used to request the value of the PlatSecLocked setting */
+ };
+
+ /**
+ A test function to return the state of a given Platform Security configuration setting.
+ @param aSetting An enumerated value representing the required setting
+ @return A value representing the setting. 0 represents 'OFF', 1 represents 'ON'
+ Other values may be returned for some settings, these exceptions are documented
+ in the description for individual enumerations of TConfigSetting.
+ @see TConfigSetting
+ @publishedAll
+ @test
+ */
+ IMPORT_C static TInt ConfigSetting(TConfigSetting aSetting);
+
+#endif // Not __KERNEL_MODE__
+
+ //
+ // All methods below here are internalTechnology
+ //
+
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+public:
+ /** @internalTechnology */
+ static inline TInt LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
+#ifdef __KERNEL_MODE__
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(const DProcess* aViolatingProcess, TCapability aCapability, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(const DThread* aViolatingThread, TCapability aCapability, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt SecureIdCheckFail(const DProcess* aViolatingProcess, TSecureId aSid, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt PolicyCheckFail(const DProcess* aProcess, const SSecurityInfo& aMissing, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt PolicyCheckFail(const DThread* aProcess, const SSecurityInfo& aMissing, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt ProcessIsolationFail(const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt ProcessIsolationIPCFail(RMessageK* aMessage, const char* aContextText);
+#else // !__KERNEL_MODE__
+ /** @internalTechnology */
+ static inline TInt LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
+ /** @internalTechnology */
+ static inline TInt CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt PolicyCheckFail(RSessionBase aSession, const SSecurityInfo& aMissingCaps, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps, const char* aContextText);
+ /** @internalTechnology */
+ static inline TInt CreatorCapabilityCheckFail(TCapability aCapability);
+ /** @internalTechnology */
+ static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps);
+ /** @internalTechnology */
+ static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability);
+ /** @internalTechnology */
+ static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps);
+ /** @internalTechnology */
+ static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps);
+ /** @internalTechnology */
+ static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps);
+#endif //__KERNEL_MODE__
+
+private:
+ UIMPORT_C static TInt EmitDiagnostic(TPlatSecDiagnostic& aDiagnostic, const char* aContextText);
+#else //__REMOVE_PLATSEC_DIAGNOSTICS__
+#ifndef __KERNEL_MODE__
+private:
+ IMPORT_C static TInt EmitDiagnostic(TPlatSecDiagnostic& aDiagnostic, const char* aContextText);
+#endif // !__KERNEL_MODE__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+
+public:
+ /** @internalTechnology */
+ UIMPORT_C static TInt EmitDiagnostic();
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+Contains information about the code and data sections belonging to a process.
+
+@see RProcess::GetMemoryInfo
+*/
+class TProcessMemoryInfo
+ {
+public:
+ /**
+ The code base address (.text).
+ */
+ TUint32 iCodeBase;
+
+
+ /**
+ The size of the code section (.text).
+ */
+ TUint32 iCodeSize;
+
+
+ /**
+ The base address of the constant data section (.radata).
+ */
+ TUint32 iConstDataBase;
+
+
+ /**
+ The size of the constant data section (.radata).
+ */
+
+ TUint32 iConstDataSize;
+
+
+ /**
+ The base address of the initialised data section (.data).
+ */
+ TUint32 iInitialisedDataBase;
+
+
+ /**
+ The size of the initialised data section (.data).
+ */
+ TUint32 iInitialisedDataSize;
+
+
+ /**
+ The base address of the uninitialised data section (.bss).
+ */
+ TUint32 iUninitialisedDataBase;
+
+
+ /**
+ The size of the uninitialised data section (.bss).
+ */
+ TUint32 iUninitialisedDataSize;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines a more useful synonym for TProcessMemoryInfo.
+*/
+typedef TProcessMemoryInfo TModuleMemoryInfo; // more accurate name - remove old one later
+
+
+
+
+#ifndef __KERNEL_MODE__
+class CBase;
+/**
+@publishedAll
+@released
+
+Generic array.
+
+This class defines a generic array which can be constructed by any of the
+following templated concrete arrays:
+
+1. CArrayFixFlat<class T>
+
+2. CArrayFixSeg<class T>
+
+3. CArrayVarFlat<class T>
+
+4. CArrayVarSeg<class T>
+
+5. CArrayPakFlat<class T>
+
+6. RArray<class T>
+
+7. RPointerArray<class T>
+
+and also by the following template specialisation classes:
+
+1. RArray<TInt>
+
+2. RArray<TUint>
+
+It allows a degree of polymorphism amongst the array classes. It permits the
+operator[] and the Count() member functions of an array to be invoked without
+knowing which array class has been used to construct that array.
+
+TArray allows access to elements of an array but does not permit changes to
+those elements.
+
+Use the Array() member function of an array to construct and return
+a TArray<class T> object for that array.
+
+A TArray<class T> type object is not intended to be constructed explicitly
+by user code.
+
+@see CArrayFixFlat
+@see CArrayFixSeg
+@see CArrayVarFlat
+@see CArrayVarSeg
+@see CArrayPakFlat
+@see RArray
+@see RPointerArray
+@see RArray<TInt>
+@see RArray<TUint>
+*/
+template <class T>
+class TArray
+ {
+public:
+ inline TArray(TInt (*aCount)(const CBase* aPtr),const TAny*(*anAt)(const CBase* aPtr,TInt anIndex),const CBase* aPtr);
+ inline TInt Count() const;
+ inline const T& operator[](TInt anIndex) const;
+private:
+ const CBase* iPtr;
+ TInt (*iCount)(const CBase* aPtr);
+ const TAny*(*iAt)(const CBase* aPtr,TInt anIndex);
+ };
+#endif
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines a function type used by a TIdentityRelation object.
+
+A function of this type implements an algorithm for determining whether
+two objects match.
+
+@see TIdentityRelation
+*/
+typedef TBool (*TGeneralIdentityRelation)(const TAny*, const TAny*);
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines a function type used by a TLinearOrder object
+
+A function of this type implements an algorithm that determines
+the order of two objects.
+
+@see TLinearOrder
+*/
+typedef TInt (*TGeneralLinearOrder)(const TAny*, const TAny*);
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class which packages a function that determines whether two
+objects of a given class type match. During linear search operations the search
+term is always passed as the first argument and the second argument is an
+element of the array being searched.
+
+A TIdentityRelation<T> object is constructed and passed as a parameter to
+member functions of the array classes RArray<T> and RPointerArray<T>.
+
+@see RArray
+@see RPointerArray
+*/
+template <class T>
+class TIdentityRelation
+ {
+public:
+ inline TIdentityRelation();
+ inline TIdentityRelation( TBool (*anIdentity)(const T&, const T&) );
+ inline operator TGeneralIdentityRelation() const;
+private:
+ inline static TBool EqualityOperatorCompare(const T& aLeft, const T& aRight);
+private:
+ TGeneralIdentityRelation iIdentity;
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+A set of common identity relations for frequently occurring types.
+
+@see RArray
+@see RPointerArray
+@see RHashSet
+@see RPtrHashSet
+@see RHashMap
+@see RPtrHashMap
+*/
+class DefaultIdentity
+ {
+public:
+ IMPORT_C static TBool Integer(const TInt&, const TInt&);
+ IMPORT_C static TBool Des8(const TDesC8&, const TDesC8&);
+ IMPORT_C static TBool Des16(const TDesC16&, const TDesC16&);
+ IMPORT_C static TBool IntegerPtr(TInt* const&, TInt* const&);
+ IMPORT_C static TBool Des8Ptr(TDesC8* const&, TDesC8* const&);
+ IMPORT_C static TBool Des16Ptr(TDesC16* const&, TDesC16* const&);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class which packages a function that determines the order of two
+objects of a given class type. During binary search operations the search term
+is always passed as the first argument and the second argument is an element
+of the array being searched.
+
+A TLinearOrder<T> object is constructed and passed as a parameter to member
+functions of the array classes RArray<T> and RPointerArray<T>.
+
+@see RArray
+@see RPointerArray
+*/
+template <class T>
+class TLinearOrder
+ {
+public:
+ inline TLinearOrder( TInt(*anOrder)(const T&, const T&) );
+ inline operator TGeneralLinearOrder() const;
+private:
+ TGeneralLinearOrder iOrder;
+ };
+
+
+/*
+@publishedAll
+@released
+
+A set of values that tell array search functions which array element is to be
+returned when there are duplicate elements in the array.
+
+These values are used by RArray, RPointerArray, RArray<TInt>,
+and RArray<TUint> search functions.
+
+Examples of functions that take
+these enum values are: RPointerArray::SpecificFindInOrderL(),
+and RArray::SpecificFindInSignedKeyOrder().
+
+@see RArray
+@see RPointerArray
+@see RArray<TInt>
+@see RArray<TUint>
+*/
+enum TArrayFindMode
+ {
+ /**
+ Indicates that any element in a block of duplicate elements can be
+ returned by a search function.
+
+ Note that using this mode, there can be no guarantee that the element
+ returned by the search functions will be the same if the size of the array
+ changes between successive calls to those functions.
+ */
+ EArrayFindMode_Any = 0,
+
+ /**
+ Indicates that the first element in a block of duplicate elements
+ is returned.
+ */
+ EArrayFindMode_First = 1,
+
+ /**
+ Indicates that the first element after the last element in a block
+ of duplicate elements is returned.
+ */
+ EArrayFindMode_Last = 2,
+
+ /**
+ @internalTechnology
+ */
+ EArrayFindMode_Limit = 3
+ };
+
+
+/**
+@internalComponent
+
+Base class used in the derivation of RPointerArray, RArray<TInt>,
+and RArray<TUint>.
+
+The base class is inherited privately.
+
+The class is internal and is not intended for use.
+*/
+class RPointerArrayBase
+ {
+protected:
+ IMPORT_C RPointerArrayBase();
+ IMPORT_C RPointerArrayBase(TInt aGranularity);
+ IMPORT_C RPointerArrayBase(TInt aMinGrowBy, TInt aFactor);
+ IMPORT_C void Close();
+ IMPORT_C TInt Count() const;
+ inline void ZeroCount() {iCount=0;}
+ inline TAny** Entries() {return iEntries;}
+ IMPORT_C TAny*& At(TInt anIndex) const;
+ IMPORT_C TInt Append(const TAny* anEntry);
+ IMPORT_C TInt Insert(const TAny* anEntry, TInt aPos);
+ IMPORT_C void Remove(TInt anIndex);
+ IMPORT_C void Compress();
+ IMPORT_C void Reset();
+ IMPORT_C TInt Find(const TAny* anEntry) const;
+ IMPORT_C TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const;
+ IMPORT_C TInt FindReverse(const TAny* aEntry) const;
+ IMPORT_C TInt FindReverse(const TAny* aEntry, TGeneralIdentityRelation aIdentity) const;
+ IMPORT_C TInt FindIsqSigned(TInt anEntry) const;
+ IMPORT_C TInt FindIsqUnsigned(TUint anEntry) const;
+ IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const;
+ IMPORT_C TInt FindIsqSigned(TInt anEntry, TInt aMode) const;
+ IMPORT_C TInt FindIsqUnsigned(TUint anEntry, TInt aMode) const;
+ IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const;
+ IMPORT_C TInt InsertIsqSigned(TInt anEntry, TBool aAllowRepeats);
+ IMPORT_C TInt InsertIsqUnsigned(TUint anEntry, TBool aAllowRepeats);
+ IMPORT_C TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats);
+ IMPORT_C TInt BinarySearchSigned(TInt anEntry, TInt& anIndex) const;
+ IMPORT_C TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex) const;
+ IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const;
+ IMPORT_C TInt BinarySearchSigned(TInt anEntry, TInt& anIndex, TInt aMode) const;
+ IMPORT_C TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex, TInt aMode) const;
+ IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const;
+#ifndef __KERNEL_MODE__
+ IMPORT_C RPointerArrayBase(TAny** aEntries, TInt aCount);
+ IMPORT_C void GranularCompress();
+ IMPORT_C TInt DoReserve(TInt aCount);
+ IMPORT_C void HeapSortSigned();
+ IMPORT_C void HeapSortUnsigned();
+ IMPORT_C void HeapSort(TGeneralLinearOrder anOrder);
+ IMPORT_C static TInt GetCount(const CBase* aPtr);
+ IMPORT_C static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex);
+#endif
+private:
+ TInt Grow();
+private:
+ TInt iCount;
+ TAny** iEntries;
+ TInt iAllocated;
+ TInt iGranularity; // positive means linear, negative means exponential growth
+ TInt iSpare1;
+ TInt iSpare2;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A simple and efficient array of pointers to objects.
+
+The elements of the array are pointers to instances of a class; this class
+is specified as the template parameter T.
+
+The class offers standard array behaviour which includes insertion, appending
+and sorting of pointers.
+
+Derivation from RPointerArrayBase is private.
+*/
+template <class T>
+class RPointerArray : private RPointerArrayBase
+ {
+public:
+ inline RPointerArray();
+ inline explicit RPointerArray(TInt aGranularity);
+ inline RPointerArray(TInt aMinGrowBy, TInt aFactor);
+ inline void Close();
+ inline TInt Count() const;
+ inline T* const& operator[](TInt anIndex) const;
+ inline T*& operator[](TInt anIndex);
+ inline TInt Append(const T* anEntry);
+ inline TInt Insert(const T* anEntry, TInt aPos);
+ inline void Remove(TInt anIndex);
+ inline void Compress();
+ inline void Reset();
+ void ResetAndDestroy();
+ inline TInt Find(const T* anEntry) const;
+ inline TInt Find(const T* anEntry, TIdentityRelation<T> anIdentity) const;
+ template <class K>
+ inline TInt Find(const K& aKey, TBool (*apfnCompare)(const K* k, const T& t)) const
+ /**
+ Finds the first object pointer in the array which matches aKey using
+ the comparison algorithm provided by apfnCompare.
+
+ The find operation always starts at the low index end of the array. There
+ is no assumption about the order of objects in the array.
+
+ @param aKey The key of type K to be compared with the elements of the array using apfnCompare.
+ @param apfnCompare A function defining the identity relation between the
+ object pointers in the array, and their keys of type K. The
+ function returns true if k and t match based on this relationship.
+
+ @return The index of the first matching object pointer within the array.
+ KErrNotFound, if no suitable object pointer can be found.
+ */
+ { return RPointerArrayBase::Find((T*)&aKey,*(TIdentityRelation<T>*)&apfnCompare); }
+ inline TInt FindReverse(const T* anEntry) const;
+ inline TInt FindReverse(const T* anEntry, TIdentityRelation<T> anIdentity) const;
+ template <class K>
+ inline TInt FindReverse(const K& aKey, TInt (*apfnMatch)(const K* k, const T& t)) const
+ /**
+ Finds the first object pointer in the array which matches aKey using
+ the comparison algorithm provided by apfnCompare.
+
+ The find operation always starts at the high index end of the array. There
+ is no assumption about the order of objects in the array.
+
+ @param aKey The key of type K to be compared with the elements of the array using apfnMatch.
+ @param apfnMatch A function defining the identity relation between the
+ object pointers in the array, and their keys of type K. The
+ function returns true if k and t match based on this relationship.
+
+ @return The index of the first matching object pointer within the array.
+ KErrNotFound, if no suitable object pointer can be found.
+ */
+
+ { return RPointerArrayBase::FindReverse((T*)&aKey,*(TIdentityRelation<T>*)&apfnMatch); }
+ inline TInt FindInAddressOrder(const T* anEntry) const;
+ inline TInt FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const;
+ inline TInt FindInAddressOrder(const T* anEntry, TInt& anIndex) const;
+ inline TInt FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
+ template <class K>
+ inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const
+ /**
+ Finds the object pointer in the array whose object matches the specified
+ key, (Using the relationship defined within apfnCompare) using a binary search
+ technique and an ordering algorithm.
+
+ The function assumes that existing object pointers in the array are ordered
+ so that the objects themselves are in object order as determined by an algorithm
+ supplied by the caller and packaged as a TLinearOrder<T>.
+
+ @param aKey The key of type K to be compared with the elements of the array using apfnCompare.
+ @param apfnCompare A function which defines the order that the array was sorted,
+ where in it aKey (via the defined relationship) should fit, and if the key is present.
+
+ @return The index of the matching object pointer within the array.
+ KErrNotFound, if no suitable object pointer can be found.
+ */
+ { return RPointerArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T>*)&apfnCompare); }
+ inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const;
+ inline TInt SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const;
+ inline TInt SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline TInt InsertInAddressOrder(const T* anEntry);
+ inline TInt InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder);
+ inline TInt InsertInAddressOrderAllowRepeats(const T* anEntry);
+ inline TInt InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder);
+#ifndef __KERNEL_MODE__
+ inline void AppendL(const T* anEntry);
+ inline void InsertL(const T* anEntry, TInt aPos);
+ inline TInt FindL(const T* anEntry) const;
+ inline TInt FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const;
+ inline TInt FindReverseL(const T* anEntry) const;
+ inline TInt FindReverseL(const T* anEntry, TIdentityRelation<T> anIdentity) const;
+ inline TInt FindInAddressOrderL(const T* anEntry) const;
+ inline TInt FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const;
+ inline void FindInAddressOrderL(const T* anEntry, TInt& anIndex) const;
+ inline void FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
+ inline TInt SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const;
+ inline TInt SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline void SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const;
+ inline void SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline void InsertInAddressOrderL(const T* anEntry);
+ inline void InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder);
+ inline void InsertInAddressOrderAllowRepeatsL(const T* anEntry);
+ inline void InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder);
+
+ inline RPointerArray(T** aEntries, TInt aCount);
+ inline void GranularCompress();
+ inline TInt Reserve(TInt aCount);
+ inline void ReserveL(TInt aCount);
+ inline void SortIntoAddressOrder();
+ inline void Sort(TLinearOrder<T> anOrder);
+ inline TArray<T*> Array() const;
+#endif
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+Array of raw pointers.
+
+The array is a simple and efficient specialized array of TAny pointers offering
+standard array behaviour.
+
+The derivation from RPointerArrayBase is private.
+*/
+TEMPLATE_SPECIALIZATION class RPointerArray<TAny> : private RPointerArrayBase
+ {
+public:
+ inline RPointerArray();
+ inline explicit RPointerArray(TInt aGranularity);
+ inline RPointerArray(TInt aMinGrowBy, TInt aFactor);
+ inline void Close();
+ inline TInt Count() const;
+ inline TAny* const& operator[](TInt anIndex) const;
+ inline TAny*& operator[](TInt anIndex);
+ inline TInt Append(const TAny* anEntry);
+ inline TInt Insert(const TAny* anEntry, TInt aPos);
+ inline void Remove(TInt anIndex);
+ inline void Compress();
+ inline void Reset();
+ inline TInt Find(const TAny* anEntry) const;
+ inline TInt FindReverse(const TAny* anEntry) const;
+ inline TInt FindInAddressOrder(const TAny* anEntry) const;
+ inline TInt FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const;
+ inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const;
+ inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
+ inline TInt InsertInAddressOrder(const TAny* anEntry);
+ inline TInt InsertInAddressOrderAllowRepeats(const TAny* anEntry);
+#ifndef __KERNEL_MODE__
+ inline void AppendL(const TAny* anEntry);
+ inline void InsertL(const TAny* anEntry, TInt aPos);
+ inline TInt FindL(const TAny* anEntry) const;
+ inline TInt FindReverseL(const TAny* anEntry) const;
+ inline TInt FindInAddressOrderL(const TAny* anEntry) const;
+ inline void FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const;
+ inline TInt SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const;
+ inline void SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
+ inline void InsertInAddressOrderL(const TAny* anEntry);
+ inline void InsertInAddressOrderAllowRepeatsL(const TAny* anEntry);
+
+ inline RPointerArray(TAny** aEntries, TInt aCount);
+ inline void GranularCompress();
+ inline void SortIntoAddressOrder();
+ inline TArray<TAny*> Array() const;
+#endif
+ };
+
+
+
+/**
+@internalComponent
+
+Base class used in the derivation of RArray.
+
+The base class is inherited privately.
+
+The class is internal and is not intended for use.
+*/
+class RArrayBase
+ {
+protected:
+ IMPORT_C RArrayBase(TInt anEntrySize);
+ IMPORT_C RArrayBase(TInt anEntrySize, TInt aGranularity);
+ IMPORT_C RArrayBase(TInt anEntrySize, TInt aGranularity, TInt aKeyOffset);
+ IMPORT_C RArrayBase(TInt anEntrySize, TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
+ IMPORT_C RArrayBase(TInt aEntrySize,TAny* aEntries, TInt aCount);
+ IMPORT_C void Close();
+ IMPORT_C TInt Count() const;
+ IMPORT_C TAny* At(TInt anIndex) const;
+ IMPORT_C TInt Append(const TAny* anEntry);
+ IMPORT_C TInt Insert(const TAny* anEntry, TInt aPos);
+ IMPORT_C void Remove(TInt anIndex);
+ IMPORT_C void Compress();
+ IMPORT_C void Reset();
+ IMPORT_C TInt Find(const TAny* anEntry) const;
+ IMPORT_C TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const;
+ IMPORT_C TInt FindReverse(const TAny* aEntry) const;
+ IMPORT_C TInt FindReverse(const TAny* aEntry, TGeneralIdentityRelation aIdentity) const;
+ IMPORT_C TInt FindIsqSigned(const TAny* anEntry) const;
+ IMPORT_C TInt FindIsqUnsigned(const TAny* anEntry) const;
+ IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const;
+ IMPORT_C TInt FindIsqSigned(const TAny* anEntry, TInt aMode) const;
+ IMPORT_C TInt FindIsqUnsigned(const TAny* anEntry, TInt aMode) const;
+ IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const;
+ IMPORT_C TInt InsertIsqSigned(const TAny* anEntry, TBool aAllowRepeats);
+ IMPORT_C TInt InsertIsqUnsigned(const TAny* anEntry, TBool aAllowRepeats);
+ IMPORT_C TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats);
+ IMPORT_C TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex) const;
+ IMPORT_C TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex) const;
+ IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const;
+ IMPORT_C TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
+ IMPORT_C TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
+ IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const;
+#ifndef __KERNEL_MODE__
+ IMPORT_C void GranularCompress();
+ IMPORT_C TInt DoReserve(TInt aCount);
+ IMPORT_C void HeapSortSigned();
+ IMPORT_C void HeapSortUnsigned();
+ IMPORT_C void HeapSort(TGeneralLinearOrder anOrder);
+ IMPORT_C static TInt GetCount(const CBase* aPtr);
+ IMPORT_C static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex);
+#endif
+private:
+ TInt Grow();
+private:
+ TInt iCount;
+ TAny* iEntries;
+ TInt iEntrySize;
+ TInt iKeyOffset;
+ TInt iAllocated;
+ TInt iGranularity; // positive means linear, negative means exponential growth
+ TInt iSpare1;
+ TInt iSpare2;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A simple and efficient array of fixed length objects.
+
+The elements of the array are instances of a class; this class is specified
+as the template parameter T.
+
+The array offers standard array behaviour which includes insertion, appending
+and sorting of elements.
+
+Note:
+
+1. where possible, this class should be used in preference to
+ CArrayFixFlat<classT>.
+
+2. the derivation from RArrayBase is private.
+
+3. for performance reasons, RArray stores objects in the array as
+ word (4 byte) aligned quantities. This means that some member functions
+ do not work when RArray is instantiated for classes of less than 4 bytes
+ in size, or when the class's alignment requirement is not 4.
+ Be aware that it is possible to get an unhandled exception on hardware
+ that enforces strict alignment.
+
+ The affected functions are:
+
+ 3.1 the constructor: RArray(TInt, T*, TInt)
+
+ 3.2 Append(const T&)
+
+ 3.3 Insert(const T&, TInt)
+
+ 3.4 the [] operator, and then using the pointer to iterate through
+ the array as you would with a C array.
+*/
+template <class T>
+class RArray : private RArrayBase
+ {
+public:
+ inline RArray();
+ inline explicit RArray(TInt aGranularity);
+ inline RArray(TInt aGranularity, TInt aKeyOffset);
+ inline RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
+ inline RArray(TInt aEntrySize,T* aEntries, TInt aCount);
+ inline void Close();
+ inline TInt Count() const;
+ inline const T& operator[](TInt anIndex) const;
+ inline T& operator[](TInt anIndex);
+ inline TInt Append(const T& anEntry);
+ inline TInt Insert(const T& anEntry, TInt aPos);
+ inline void Remove(TInt anIndex);
+ inline void Compress();
+ inline void Reset();
+ inline TInt Find(const T& anEntry) const;
+ inline TInt Find(const T& anEntry, TIdentityRelation<T> anIdentity) const;
+ template <class K>
+ inline TInt Find(const K& aKey, TBool (*apfnCompare)(const K* k, const T& t)) const
+ /**
+ Finds the first object in the array which matches aKey using
+ the comparison algorithm provided by apfnCompare.
+
+ The find operation always starts at the low index end of the array. There
+ is no assumption about the order of objects in the array.
+
+ @param aKey The key of type K to be compared with the elements of the array using apfnCompare.
+ @param apfnCompare A function defining the identity relation between the
+ object in the array, and their keys of type K. The function
+ returns true if k and t match based on this relationship.
+
+ @return The index of the first matching object within the array.
+ KErrNotFound, if no suitable object can be found.
+ */
+ { return RArrayBase::Find((T*)&aKey,*(TIdentityRelation<T>*)&apfnCompare); }
+ inline TInt FindReverse(const T& anEntry) const;
+ inline TInt FindReverse(const T& anEntry, TIdentityRelation<T> anIdentity) const;
+ template <class K>
+ inline TInt FindReverse(const K& aKey, TInt (*apfnMatch)(const K* k, const T& t)) const
+ /**
+ Finds the first object in the array which matches aKey using the comparison
+ algorithm provided by apfnCompare.
+
+ The find operation always starts at the high index end of the array. There
+ is no assumption about the order of objects in the array.
+
+ @param aKey The key of type K to be compared with the elements of the array using apfnMatch.
+ @param apfnMatch A function defining the identity relation between the
+ object in the array, and their keys of type K. The function
+ returns true if k and t match based on this relationship.
+
+ @return The index of the first matching object within the array.
+ KErrNotFound, if no suitable object can be found.
+ */
+ { return RArrayBase::FindReverse((T*)&aKey,*(TIdentityRelation<T>*)&apfnMatch); }
+ inline TInt FindInSignedKeyOrder(const T& anEntry) const;
+ inline TInt FindInUnsignedKeyOrder(const T& anEntry) const;
+ inline TInt FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const;
+ inline TInt FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const;
+ inline TInt FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const;
+ inline TInt FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
+ template <class K>
+ inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const
+ /**
+ Finds the object in the array whose object matches the specified
+ key, (Using the relationship defined within apfnCompare) using a binary search
+ technique and an ordering algorithm.
+
+ The function assumes that existing objects in the array are ordered so
+ that the objects themselves are in object order as determined by an algorithm
+ supplied by the caller and packaged as a TLinearOrder<T>.
+
+ @param aKey The key of type K to be compared with the elements of the array using apfnCompare.
+ @param apfnCompare A function which defines the order that the array was sorted,
+ where in it aKey (via the defined relationship) should fit, and if the key is present.
+
+ @return The index of the matching object within the array.
+ KErrNotFound, if no suitable object can be found.
+ */
+
+ { return RArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T>*)&apfnCompare); }
+ inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const;
+ inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const;
+ inline TInt SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
+ inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
+ inline TInt SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline TInt InsertInSignedKeyOrder(const T& anEntry);
+ inline TInt InsertInUnsignedKeyOrder(const T& anEntry);
+ inline TInt InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder);
+ inline TInt InsertInSignedKeyOrderAllowRepeats(const T& anEntry);
+ inline TInt InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry);
+ inline TInt InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder);
+#ifndef __KERNEL_MODE__
+ inline void AppendL(const T& anEntry);
+ inline void InsertL(const T& anEntry, TInt aPos);
+ inline TInt FindL(const T& anEntry) const;
+ inline TInt FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
+ inline TInt FindReverseL(const T& anEntry) const;
+ inline TInt FindReverseL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
+ inline TInt FindInSignedKeyOrderL(const T& anEntry) const;
+ inline TInt FindInUnsignedKeyOrderL(const T& anEntry) const;
+ inline TInt FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const;
+ inline void FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
+ inline void FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
+ inline void FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
+ inline TInt SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const;
+ inline TInt SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const;
+ inline TInt SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline void SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
+ inline void SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
+ inline void SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
+ inline void InsertInSignedKeyOrderL(const T& anEntry);
+ inline void InsertInUnsignedKeyOrderL(const T& anEntry);
+ inline void InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder);
+ inline void InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry);
+ inline void InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry);
+ inline void InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder);
+
+ inline void GranularCompress();
+ inline TInt Reserve(TInt aCount);
+ inline void ReserveL(TInt aCount);
+ inline void SortSigned();
+ inline void SortUnsigned();
+ inline void Sort(TLinearOrder<T> anOrder);
+ inline TArray<T> Array() const;
+#endif
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A simple and efficient specialized array of signed integers offering standard
+array behaviour.
+
+Note that derivation from RPointerArrayBase is private.
+*/
+TEMPLATE_SPECIALIZATION class RArray<TInt> : private RPointerArrayBase
+ {
+public:
+ inline RArray();
+ inline explicit RArray(TInt aGranularity);
+ inline RArray(TInt aMinGrowBy, TInt aFactor);
+ inline void Close();
+ inline TInt Count() const;
+ inline const TInt& operator[](TInt anIndex) const;
+ inline TInt& operator[](TInt anIndex);
+ inline TInt Append(TInt anEntry);
+ inline TInt Insert(TInt anEntry, TInt aPos);
+ inline void Remove(TInt anIndex);
+ inline void Compress();
+ inline void Reset();
+ inline TInt Find(TInt anEntry) const;
+ inline TInt FindReverse(TInt anEntry) const;
+ inline TInt FindInOrder(TInt anEntry) const;
+ inline TInt FindInOrder(TInt anEntry, TInt& anIndex) const;
+ inline TInt SpecificFindInOrder(TInt anEntry, TInt aMode) const;
+ inline TInt SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const;
+ inline TInt InsertInOrder(TInt anEntry);
+ inline TInt InsertInOrderAllowRepeats(TInt anEntry);
+#ifndef __KERNEL_MODE__
+ inline void AppendL(TInt anEntry);
+ inline void InsertL(TInt anEntry, TInt aPos);
+ inline TInt FindL(TInt anEntry) const;
+ inline TInt FindReverseL(TInt anEntry) const;
+ inline TInt FindInOrderL(TInt anEntry) const;
+ inline void FindInOrderL(TInt anEntry, TInt& anIndex) const;
+ inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const;
+ inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const;
+ inline void InsertInOrderL(TInt anEntry);
+ inline void InsertInOrderAllowRepeatsL(TInt anEntry);
+
+ inline RArray(TInt* aEntries, TInt aCount);
+ inline void GranularCompress();
+ inline TInt Reserve(TInt aCount);
+ inline void ReserveL(TInt aCount);
+ inline void Sort();
+ inline TArray<TInt> Array() const;
+#endif
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Array of unsigned integers.
+
+The array is a simple and efficient specialized array of unsigned integers
+offering standard array behaviour.
+
+The derivation from RPointerArrayBase is private.
+*/
+TEMPLATE_SPECIALIZATION class RArray<TUint> : private RPointerArrayBase
+ {
+public:
+ inline RArray();
+ inline explicit RArray(TInt aGranularity);
+ inline RArray(TInt aMinGrowBy, TInt aFactor);
+ inline void Close();
+ inline TInt Count() const;
+ inline const TUint& operator[](TInt anIndex) const;
+ inline TUint& operator[](TInt anIndex);
+ inline TInt Append(TUint anEntry);
+ inline TInt Insert(TUint anEntry, TInt aPos);
+ inline void Remove(TInt anIndex);
+ inline void Compress();
+ inline void Reset();
+ inline TInt Find(TUint anEntry) const;
+ inline TInt FindReverse(TUint anEntry) const;
+ inline TInt FindInOrder(TUint anEntry) const;
+ inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const;
+ inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const;
+ inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const;
+ inline TInt InsertInOrder(TUint anEntry);
+ inline TInt InsertInOrderAllowRepeats(TUint anEntry);
+#ifndef __KERNEL_MODE__
+ inline void AppendL(TUint anEntry);
+ inline void InsertL(TUint anEntry, TInt aPos);
+ inline TInt FindL(TUint anEntry) const;
+ inline TInt FindReverseL(TUint anEntry) const;
+ inline TInt FindInOrderL(TUint anEntry) const;
+ inline void FindInOrderL(TUint anEntry, TInt& anIndex) const;
+ inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const;
+ inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const;
+ inline void InsertInOrderL(TUint anEntry);
+ inline void InsertInOrderAllowRepeatsL(TUint anEntry);
+
+ inline RArray(TUint* aEntries, TInt aCount);
+ inline void GranularCompress();
+ inline TInt Reserve(TInt aCount);
+ inline void ReserveL(TInt aCount);
+ inline void Sort();
+ inline TArray<TUint> Array() const;
+#endif
+ };
+
+#ifndef __LEAVE_EQUALS_THROW__
+
+class TTrapHandler;
+
+/**
+@internalComponent
+*/
+class TTrap
+ {
+public:
+#ifndef __KERNEL_MODE__
+ IMPORT_C TInt Trap(TInt& aResult);
+ IMPORT_C static void UnTrap();
+#endif
+public:
+ enum {EMaxState=0x10};
+public:
+ TInt iState[EMaxState];
+ TTrap* iNext;
+ TInt* iResult;
+ TTrapHandler* iHandler;
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+Executes the set of C++ statements _s under a trap harness.
+
+Use this macro as a C++ statement.
+
+_r must be a TInt which has already been declared; if any of the
+C++ statements _s leaves, then the leave code is returned in _r,
+otherwise _r is set to KErrNone.
+
+_s can consist of multiple C++ statements; in theory, _s can consist
+of any legal C++ code but in practice, such statements consist of simple
+function calls, e.g. Foo() or an assignment of some value to the result of
+a function call, e.g. functionValue=GetFoo().
+
+A cleanup stack is constructed for the set of C++ statements _s.
+If any function in _s leaves, objects pushed to the cleanup stack are
+cleaned-up. In addition, if any of the C++ statements in _s leaves,
+then remaining C++ code in _s is not executed and any variables which
+are assigned within that remaining code are not defined.
+
+@param _r An lvalue, convertible to TInt&, which will receive the result of
+ any User::Leave() executed within _s or, if no leave occurred,
+ it will be set to KErrNone. The value of _r on entry is not used.
+
+@param _s C++ statements which will be executed under a trap harness.
+
+@see TRAPD
+*/
+#define TRAP(_r,_s) {TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}}
+
+/**
+@publishedAll
+@released
+
+Executes the set of C++ statements _s under a trap harness.
+
+Use this macro in the same way as you would TRAP, except that the
+variable _r is defined as part of the macro (and is therefore valid for the
+rest of the block in which the macro occurs). Often, this saves a line of code.
+
+@param _r A name, which will be declared as a TInt, and will receive the result
+ of any User::Leave() executed within _s or, if no leave occurred, it
+ will be set to KErrNone. After the macro, _r remains in scope until
+ the end of its enclosing block.
+
+@param _s C++ statements which will be executed under a trap harness.
+
+@see TRAP
+*/
+#define TRAPD(_r,_s) TInt _r;{TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}}
+
+/**
+@publishedAll
+@released
+
+Executes the set of C++ statements _s under a trap harness.
+Any leave code generated is ignored.
+
+Use this macro as a C++ statement.
+
+This macro is functionally equivalent to:
+@code
+ TInt x;
+ TRAP(x,_s)
+@endcode
+or
+@code
+ TRAPD(x,_s)
+@endcode
+where the value in 'x' is not used by any subsequent code.
+
+_s can consist of multiple C++ statements; in theory, _s can consist
+of any legal C++ code but in practice, such statements consist of simple
+function calls, e.g. Foo() or an assignment of some value to the result of
+a function call, e.g. functionValue=GetFoo().
+
+A cleanup stack is constructed for the set of C++ statements _s.
+If any function in _s leaves, objects pushed to the cleanup stack are
+cleaned-up. In addition, if any of the C++ statements in _s leaves,
+then remaining C++ code in _s is not executed and any variables which
+are assigned within that remaining code are not defined.
+
+@param _s C++ statements which will be executed under a trap harness.
+
+@see TRAPD
+@see TRAP
+*/
+#define TRAP_IGNORE(_s) {TInt _ignore;TTrap __t;if (__t.Trap(_ignore)==0){_s;TTrap::UnTrap();}}
+
+
+#else //__LEAVE_EQUALS_THROW__
+
+#ifdef __WINS__
+/** @internalComponent */
+#define __WIN32SEHTRAP TWin32SEHTrap __trap; __trap.Trap();
+/** @internalComponent */
+#define __WIN32SEHUNTRAP __trap.UnTrap();
+IMPORT_C void EmptyFunction();
+#define __CALL_EMPTY_FUNCTION EmptyFunction();
+#else // !__WINS__
+#define __WIN32SEHTRAP
+#define __WIN32SEHUNTRAP
+#define __CALL_EMPTY_FUNCTION
+#endif //__WINS__
+
+/**
+This macro is used by the TRAP and TRAPD macros and provides a means
+of inserting code into uses of these.
+
+This macro is invoked before any 'trapped' code is called, and it should be
+redefined to do whatever task is required. E.g. this code:
+
+@code
+ #undef TRAP_INSTRUMENTATION_START
+ #define TRAP_INSTRUMENTATION_START DoMyLoging(__LINE__)
+@endcode
+
+Will cause all subsequent uses of the TRAP macros to behave in an
+equivalent way to:
+
+@code
+ DoMyLoging(__LINE__)
+ TRAP(r,SomeCodeL());
+@endcode
+
+
+@publishedPartner
+@released
+
+@see TRAP
+@see TRAPD
+*/
+#define TRAP_INSTRUMENTATION_START
+
+
+
+/**
+This macro is used by the TRAP and TRAPD macros and provides a means
+of inserting code into uses of these.
+
+This macro is invoked if the 'trapped' code did not Leave.
+E.g. this code:
+
+@code
+ #undef TRAP_INSTRUMENTATION_NOLEAVE
+ #define TRAP_INSTRUMENTATION_NOLEAVE DoMyLoging(__LINE__)
+@endcode
+
+Will cause all subsequent uses of the TRAP macros to behave in an
+equivalent way to:
+
+@code
+ TRAP(r,SomeCodeL());
+ if(r==KErrNone) DoMyLoging(__LINE__);
+@endcode
+
+
+@param aLine The line number in the C++ source file where the TRAP or TRAPD
+ macro was used.
+
+@publishedPartner
+@released
+
+@see TRAP
+@see TRAPD
+*/
+#define TRAP_INSTRUMENTATION_NOLEAVE
+
+
+/**
+This macro is used by the TRAP and TRAPD macros and provides a means
+of inserting code into uses of these.
+
+This macro is invoked if the 'trapped' code did Leave. E.g. this code:
+
+@code
+ #undef TRAP_INSTRUMENTATION_LEAVE
+ #define TRAP_INSTRUMENTATION_LEAVE(aResult) DoMyLoging(aResult,__LINE__)
+@endcode
+
+Will cause all subsequent uses of the TRAP macros to behave in an
+equivalent way to:
+
+@code
+ TRAP(r,SomeCodeL());
+ if(r!=KErrNone) DoMyLoging(r,__LINE__);
+@endcode
+
+
+@param aResult A reference to the result value used in the TRAP macro.
+
+
+@publishedPartner
+@released
+
+@see TRAP
+@see TRAPD
+*/
+#define TRAP_INSTRUMENTATION_LEAVE(aResult)
+
+
+
+/**
+This macro is used by the TRAP and TRAPD macros and provides a means
+of inserting code into uses of these.
+
+This macro is invoked after the 'trapped' code is called, regardless of whether
+or not it did Leave. It should be redefined to do whatever task is
+required. E.g. this code:
+
+@code
+ #undef TRAP_INSTRUMENTATION_END
+ #define TRAP_INSTRUMENTATION_END DoMyLoging(__LINE__)
+@endcode
+
+Will cause all subsequent uses of the TRAP macros to behave in an
+equivalent way to:
+
+@code
+ TRAP(r,SomeCodeL());
+ DoMyLoging(__LINE__)
+@endcode
+
+
+@publishedPartner
+@released
+
+@see TRAP
+@see TRAPD
+*/
+#define TRAP_INSTRUMENTATION_END
+
+
+
+/**
+@publishedAll
+@released
+
+Executes the set of C++ statements _s under a trap harness.
+
+Use this macro as a C++ statement.
+
+_r must be a TInt which has already been declared; if any of the
+C++ statements _s leaves, then the leave code is returned in _r,
+otherwise _r is set to KErrNone.
+
+_s can consist of multiple C++ statements; in theory, _s can consist
+of any legal C++ code but in practice, such statements consist of simple
+function calls, e.g. Foo() or an assignment of some value to the result of
+a function call, e.g. functionValue=GetFoo().
+
+A cleanup stack is constructed for the set of C++ statements _s.
+If any function in _s leaves, objects pushed to the cleanup stack are
+cleaned-up. In addition, if any of the C++ statements in _s leaves,
+then remaining C++ code in _s is not executed and any variables which
+are assigned within that remaining code are not defined.
+
+@param _r An lvalue, convertible to TInt&, which will receive the result of
+ any User::Leave() executed within _s or, if no leave occurred,
+ it will be set to KErrNone. The value of _r on entry is not used.
+
+@param _s C++ statements which will be executed under a trap harness.
+
+@see TRAPD
+*/
+
+/*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a
+workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect
+trap handler to be invoked when multiple nested TRAP's were present and
+User::Leave(..) was called. */
+
+#define TRAP(_r, _s) \
+ { \
+ TInt& __rref = _r; \
+ __rref = 0; \
+ { TRAP_INSTRUMENTATION_START; } \
+ try { \
+ __WIN32SEHTRAP \
+ TTrapHandler* ____t = User::MarkCleanupStack(); \
+ _s; \
+ User::UnMarkCleanupStack(____t); \
+ { TRAP_INSTRUMENTATION_NOLEAVE; } \
+ __WIN32SEHUNTRAP \
+ } \
+ catch (XLeaveException& l) \
+ { \
+ __rref = l.GetReason(); \
+ { TRAP_INSTRUMENTATION_LEAVE(__rref); } \
+ } \
+ catch (...) \
+ { \
+ User::Invariant(); \
+ } \
+ __CALL_EMPTY_FUNCTION \
+ { TRAP_INSTRUMENTATION_END; } \
+ }
+
+
+/**
+@publishedAll
+@released
+
+Executes the set of C++ statements _s under a trap harness.
+
+Use this macro in the same way as you would TRAP, except that the
+variable _r is defined as part of the macro (and is therefore valid for the
+rest of the block in which the macro occurs). Often, this saves a line of code.
+
+@param _r A name, which will be declared as a TInt, and will receive the result
+ of any User::Leave() executed within _s or, if no leave occurred, it
+ will be set to KErrNone. After the macro, _r remains in scope until
+ the end of its enclosing block.
+
+@param _s C++ statements which will be executed under a trap harness.
+
+@see TRAP
+*/
+
+/*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a
+workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect
+trap handler to be invoked when multiple nested TRAP's were present and
+User::Leave(..) was called. */
+
+
+#define TRAPD(_r, _s) \
+ TInt _r; \
+ { \
+ _r = 0; \
+ { TRAP_INSTRUMENTATION_START; } \
+ try { \
+ __WIN32SEHTRAP \
+ TTrapHandler* ____t = User::MarkCleanupStack(); \
+ _s; \
+ User::UnMarkCleanupStack(____t); \
+ { TRAP_INSTRUMENTATION_NOLEAVE; } \
+ __WIN32SEHUNTRAP \
+ } \
+ catch (XLeaveException& l) \
+ { \
+ _r = l.GetReason(); \
+ { TRAP_INSTRUMENTATION_LEAVE(_r); } \
+ } \
+ catch (...) \
+ { \
+ User::Invariant(); \
+ } \
+ __CALL_EMPTY_FUNCTION \
+ { TRAP_INSTRUMENTATION_END; } \
+ }
+
+/**
+@publishedAll
+@released
+
+Executes the set of C++ statements _s under a trap harness.
+Any leave code generated is ignored.
+
+Use this macro as a C++ statement.
+
+This macro is functionally equivalent to:
+@code
+ TInt x;
+ TRAP(x,_s)
+@endcode
+or
+@code
+ TRAPD(x,_s)
+@endcode
+where the value in 'x' is not used by any subsequent code.
+
+Use this macro as a C++ statement.
+
+_s can consist of multiple C++ statements; in theory, _s can consist
+of any legal C++ code but in practice, such statements consist of simple
+function calls, e.g. Foo() or an assignment of some value to the result of
+a function call, e.g. functionValue=GetFoo().
+
+A cleanup stack is constructed for the set of C++ statements _s.
+If any function in _s leaves, objects pushed to the cleanup stack are
+cleaned-up. In addition, if any of the C++ statements in _s leaves,
+then remaining C++ code in _s is not executed and any variables which
+are assigned within that remaining code are not defined.
+
+@param _s C++ statements which will be executed under a trap harness.
+
+@see TRAPD
+@see TRAP
+*/
+
+/*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a
+workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect
+trap handler to be invoked when multiple nested TRAP's were present and
+User::Leave(..) was called. */
+
+#define TRAP_IGNORE(_s) \
+ { \
+ { TRAP_INSTRUMENTATION_START; } \
+ try { \
+ __WIN32SEHTRAP \
+ TTrapHandler* ____t = User::MarkCleanupStack(); \
+ _s; \
+ User::UnMarkCleanupStack(____t); \
+ { TRAP_INSTRUMENTATION_NOLEAVE; } \
+ __WIN32SEHUNTRAP \
+ } \
+ catch (XLeaveException& l) \
+ { \
+ l.GetReason(); \
+ { TRAP_INSTRUMENTATION_LEAVE(l.Reason()); } \
+ } \
+ catch (...) \
+ { \
+ User::Invariant(); \
+ } \
+ __CALL_EMPTY_FUNCTION \
+ { TRAP_INSTRUMENTATION_END; } \
+ }
+
+
+#endif //__LEAVE_EQUALS_THROW__
+
+/* The macro __SYMBIAN_STDCPP_SUPPORT__ is defined when building a StdC++ target.
+ * In this case, operator new and operator delete below should not be declared
+ * to avoid clashing with StdC++ declarations.
+ */
+
+#ifndef __SYMBIAN_STDCPP_SUPPORT__
+
+#ifndef __OPERATOR_NEW_DECLARED__
+
+/* Some operator new and operator delete overloads may be declared in compiler
+ * pre-include files.
+ *
+ * __OPERATOR_NEW_DECLARED__ is #defined if they are, so that we can avoid
+ * re-declaring them here.
+ */
+
+#define __OPERATOR_NEW_DECLARED__
+
+/**
+@publishedAll
+@released
+*/
+GLREF_C TAny* operator new(TUint aSize) __NO_THROW;
+
+/**
+@publishedAll
+@released
+*/
+GLREF_C TAny* operator new(TUint aSize,TUint anExtraSize) __NO_THROW;
+
+/**
+@publishedAll
+@released
+*/
+GLREF_C void operator delete(TAny* aPtr) __NO_THROW;
+
+#ifndef __PLACEMENT_VEC_NEW_INLINE
+/**
+@publishedAll
+@released
+*/
+GLREF_C TAny* operator new[](TUint aSize) __NO_THROW;
+
+/**
+@publishedAll
+@released
+*/
+GLREF_C void operator delete[](TAny* aPtr) __NO_THROW;
+#endif // !__PLACEMENT_VEC_NEW_INLINE
+
+#endif // !__OPERATOR_NEW_DECLARED__
+
+#endif // !__SYMBIAN_STDCPP_SUPPORT__
+
+/**
+@publishedAll
+@released
+*/
+inline TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;
+
+/**
+@publishedAll
+@released
+*/
+inline void operator delete(TAny* aPtr, TAny* aBase) __NO_THROW;
+
+#ifndef __PLACEMENT_VEC_NEW_INLINE
+/**
+@publishedAll
+@released
+*/
+inline TAny* operator new[](TUint aSize, TAny* aBase) __NO_THROW;
+
+/**
+@publishedAll
+@released
+*/
+inline void operator delete[](TAny* aPtr, TAny* aBase) __NO_THROW;
+
+#endif // !__PLACEMENT_VEC_NEW_INLINE
+
+#if !defined(__BOOL_NO_TRUE_TRAP__)
+
+/**
+@publishedAll
+@released
+*/
+TBool operator==(TTrue,volatile const TBool);
+
+/**
+@publishedAll
+@released
+*/
+TBool operator==(volatile const TBool,TTrue);
+
+/**
+@publishedAll
+@released
+*/
+TBool operator!=(TTrue,volatile const TBool);
+
+/**
+@publishedAll
+@released
+*/
+TBool operator!=(volatile const TBool,TTrue);
+#endif
+
+
+
+
+/**
+@publishedAll
+@released
+
+A Version 2 client/server class that clients use to package
+the arguments to be sent to a server.
+
+The object can package up to 4 arguments together with information about each
+argument's type, width and accessibility; it is also possible for
+the package to contain zero arguments. In addition to the default constructor,
+the class has four templated constructors, allowing an object of this type to
+be constructed for 0, 1, 2, 3 or 4 arguments.
+
+Internally, the arguments are stored in a simple TInt array.
+Consecutive arguments in a constructor's parameter list are put into
+consecutive slots in the array. The Set() overloaded functions can be used
+to set argument values into specific slots within this array.
+*/
+class TIpcArgs
+ {
+public:
+ /**
+ @internalComponent
+
+ Argument types; some of these may be ORed together to specify
+ type, accessibility, and width.
+ */
+ enum TArgType
+ {
+ EUnspecified = 0, /**< Type not specified.*/
+ EHandle = 1, /**< Handle type.*/
+ EFlagDes = 4, /**< Descriptor type.*/
+ EFlagConst = 2, /**< Read only type.*/
+ EFlag16Bit = 1, /**< 16 bit rather than 8 bit.*/
+ EDes8 = EFlagDes, /**< 8 bit read/write descriptor.*/
+ EDes16 = EFlagDes|EFlag16Bit, /**< 16 bit read/write descriptor.*/
+ EDesC8 = EFlagDes|EFlagConst, /**< 8 bit read only descriptor.*/
+ EDesC16 = EFlagDes|EFlagConst|EFlag16Bit, /**< 16 bit read only descriptor.*/
+ };
+
+
+ /**
+ @internalComponent
+
+ Bit width of type information.
+ */
+ enum {
+ KBitsPerType=3 /** Number of bits of type information used for each of the 4 arguments. */
+ };
+
+
+ /**
+ Indicates a Null argument.
+ */
+ enum TNothing {
+ /**
+ An enum value that can be used to indicate an empty or
+ unused argument to a server. For example:
+
+ @code
+ TIpcArgs args(arg1, TIpcArgs::ENothing, arg2);
+ @endcode
+
+ This argument will have an undefined value when the server
+ receives the message.
+ */
+ ENothing
+ };
+public:
+ /**
+ Default constructor.
+
+ An argument package constructed using this constructor has no arguments;
+ however, arguments can subsequently be set into this argument package object
+ using the Set() member functions.
+ */
+ inline TIpcArgs()
+ :iFlags(0)
+ {}
+
+
+ /**
+ A templated constructor that constructs the argument package; it takes
+ 1 argument.
+
+ @param a0 An argument of general class type T0 to be contained by
+ this object.
+ */
+ template <class T0>
+ inline explicit TIpcArgs(T0 a0)
+ {
+ Assign(iArgs[0],a0);
+ iFlags=(Type(a0)<<(0*KBitsPerType));
+ }
+
+
+ /**
+ A templated constructor that constructs the argument package; it takes
+ 2 arguments.
+
+ @param a0 An argument of general class type T0 to be contained by
+ this object.
+ @param a1 An argument of general class type T1 to be contained by
+ this object.
+ */
+ template <class T0,class T1>
+ inline TIpcArgs(T0 a0,T1 a1)
+ {
+ Assign(iArgs[0],a0);
+ Assign(iArgs[1],a1);
+ iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType));
+ }
+
+
+ /**
+ A templated constructor that constructs the argument package; it takes
+ 3 arguments.
+
+ @param a0 An argument of general class type T0 to be contained by
+ this object.
+ @param a1 An argument of general class type T1 to be contained by
+ this object.
+ @param a2 An argument of general class type T2 to be contained by
+ this object.
+ */
+ template <class T0,class T1,class T2>
+ inline TIpcArgs(T0 a0,T1 a1,T2 a2)
+ {
+ Assign(iArgs[0],a0);
+ Assign(iArgs[1],a1);
+ Assign(iArgs[2],a2);
+ iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType));
+ }
+
+
+ /**
+ A templated constructor that constructs the argument package; it takes
+ 4 arguments.
+
+ @param a0 An argument of general class type T0 to be contained by
+ this object.
+ @param a1 An argument of general class type T1 to be contained by
+ this object.
+ @param a2 An argument of general class type T2 to be contained by
+ this object.
+ @param a3 An argument of general class type T3 to be contained by
+ this object.
+ */
+ template <class T0,class T1,class T2,class T3>
+ inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3)
+ {
+ Assign(iArgs[0],a0);
+ Assign(iArgs[1],a1);
+ Assign(iArgs[2],a2);
+ Assign(iArgs[3],a3);
+ iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType))|(Type(a3)<<(3*KBitsPerType));
+ }
+ //
+ inline void Set(TInt aIndex,TNothing);
+ inline void Set(TInt aIndex,TInt aValue);
+ inline void Set(TInt aIndex,const TAny* aValue);
+ inline void Set(TInt aIndex,RHandleBase aValue);
+ inline void Set(TInt aIndex,const TDesC8* aValue);
+#ifndef __KERNEL_MODE__
+ inline void Set(TInt aIndex,const TDesC16* aValue);
+#endif
+ inline void Set(TInt aIndex,TDes8* aValue);
+#ifndef __KERNEL_MODE__
+ inline void Set(TInt aIndex,TDes16* aValue);
+#endif
+private:
+ inline static TArgType Type(TNothing);
+ inline static TArgType Type(TInt);
+ inline static TArgType Type(const TAny*);
+ inline static TArgType Type(RHandleBase aValue);
+ inline static TArgType Type(const TDesC8*);
+#ifndef __KERNEL_MODE__
+ inline static TArgType Type(const TDesC16*);
+#endif
+ inline static TArgType Type(TDes8*);
+#ifndef __KERNEL_MODE__
+ inline static TArgType Type(TDes16*);
+#endif
+ //
+ inline static void Assign(TInt&,TNothing);
+ inline static void Assign(TInt& aArg,TInt aValue);
+ inline static void Assign(TInt& aArg,const TAny* aValue);
+ inline static void Assign(TInt& aArg,RHandleBase aValue);
+ inline static void Assign(TInt& aArg,const TDesC8* aValue);
+#ifndef __KERNEL_MODE__
+ inline static void Assign(TInt& aArg,const TDesC16* aValue);
+#endif
+ inline static void Assign(TInt& aArg,TDes8* aValue);
+#ifndef __KERNEL_MODE__
+ inline static void Assign(TInt& aArg,TDes16* aValue);
+#endif
+public:
+
+ /**
+ The location where the message arguments are stored.
+
+ There is no reason to access this data member directly and it should be
+ considered as internal.
+ */
+ TInt iArgs[KMaxMessageArguments];
+
+ /**
+ The location where the flag bits describing the argument types are stored.
+
+ The symbolic values describing the argument types are internal to Symbian,
+ and there is therefore no reason to access this data member directly.
+ It should be considered as internal.
+ */
+ TInt iFlags;
+ };
+
+// Structures for passing 64 bit integers and doubles across GCC/EABI boundaries
+
+/**
+@internalComponent
+*/
+struct SInt64
+ {
+public:
+ inline SInt64();
+ inline SInt64(Int64 a);
+ inline SInt64& operator=(Int64 a);
+ inline operator Int64() const;
+public:
+ TUint32 iData[2]; // little endian
+ };
+
+/**
+@internalComponent
+*/
+struct SUint64
+ {
+public:
+ inline SUint64();
+ inline SUint64(Uint64 a);
+ inline SUint64& operator=(Uint64 a);
+ inline operator Uint64() const;
+public:
+ TUint32 iData[2]; // little endian
+ };
+
+/**
+@internalComponent
+*/
+struct SDouble
+ {
+public:
+ inline SDouble();
+ inline SDouble(TReal a);
+ inline SDouble& operator=(TReal a);
+ inline operator TReal() const;
+public:
+ TUint32 iData[2]; // always little endian
+ };
+
+/**
+@publishedAll
+@released
+
+Stores information about a thread's stack.
+
+Note, on the emulator, the memory between iLimit and the thread's current stack pointer
+may not actually be committed.
+
+@see RThread::StackInfo()
+*/
+class TThreadStackInfo
+ {
+public:
+ /**
+ The address which the stack pointer would contain if the stack were empty.
+ */
+ TLinAddr iBase;
+
+ /**
+ The address which the stack pointer would contain if the stack were full,
+ (The lowest valid address).
+ */
+ TLinAddr iLimit;
+
+ /**
+ The limit value for the stack if it were expanded to its maximum size.
+
+ Currently expanding stacks is not supported so iExpandLimit==iLimit
+ */
+ TLinAddr iExpandLimit;
+ };
+
+
+
+
+#ifdef __SUPPORT_CPP_EXCEPTIONS__
+/**
+@internalComponent
+@released
+
+The class used to implement User::Leave in term of throw and TRAP in terms of catch.
+
+*/
+class XLeaveException
+ {
+public:
+ inline XLeaveException() {}
+ inline XLeaveException(TInt aReason) {iR = aReason;}
+ inline TInt Reason() const {return iR;}
+ IMPORT_C TInt GetReason() const;
+private:
+#if __ARMCC_VERSION >= 220000 || (defined(__TOOLS2__) && defined(__linux__))
+ // From rvct 2.2 onwards we want the class impedimenta to be shared, so create a key function.
+ // Unfortunately we can't make this the key function the dtor since this would make it impossible for existing 2.1
+ // derived binaries to be 'BC' with 2.2 binaries (in the general case (which I wont attempt to describe coz its
+ // too complex) so its best to be safe). As a clue: if 2.1 is used to compile with a key function its not possible
+ // for catch handlers to work :-( (see the old code).
+ virtual void ForceKeyFunction();
+#endif
+private:
+#if __ARMCC_VERSION < 220000
+ TAny* iVtable; // reserve space for vtable
+#endif
+ TInt iR;
+ };
+
+// The standard header file <exception> defines the following guard macro for EDG and CW, VC++, GCC respectively.
+// The guard below is ugly. It will surely come back and bite us unless we resolve the whole issue of standard headers
+// when we move to supporting Standard C++.
+
+// The macro __SYMBIAN_STDCPP_SUPPORT__ is defined when building a StdC++ target.
+// In this case, we wish to avoid declaring uncaught_exception below since it clashes with the StdC++ specification
+
+#if !defined(_EXCEPTION) && !defined(_EXCEPTION_) && !defined(__EXCEPTION__) && !defined(__SYMBIAN_STDCPP_SUPPORT__)
+// Declare standard C++ functions relating to exceptions here
+namespace std {
+#if defined(__VC32__) || defined(__CW32__)
+ bool uncaught_exception();
+#else
+ IMPORT_C bool uncaught_exception();
+#endif
+ void terminate(void);
+ void unexpected(void);
+ typedef void (*terminate_handler)();
+ terminate_handler set_terminate(terminate_handler h) throw();
+ typedef void (*unexpected_handler)();
+ unexpected_handler set_unexpected(unexpected_handler h) throw();
+}
+
+#endif
+#endif //__SUPPORT_CPP_EXCEPTIONS__
+
+#ifdef __WINS__
+
+#ifndef __WIN32_SEH_TYPES_KNOWN__
+class __UnknownWindowsType1;
+class __UnknownWindowsType2;
+#endif
+
+class TWin32SEHTrap;
+
+/**
+ * Typedef for the SEH handler function
+ * @internalComponent
+ */
+typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
+
+/**
+ * @internalComponent
+ */
+class TWin32SEHTrap
+ {
+private:
+ // Prevent copy/assign
+ TWin32SEHTrap(TWin32SEHTrap const &);
+ TWin32SEHTrap& operator=(TWin32SEHTrap const &);
+
+#ifdef __KERNEL_MODE__
+//
+// Kernel-side functions for nkern exception handler
+//
+public:
+ /** Find final exception handler in SEH chain */
+ static TWin32SEHTrap* IterateForFinal();
+
+ /** Access exception handler */
+ TWin32SEHExceptionHandler* ExceptionHandler();
+
+private:
+
+#else // !__KERNEL_MODE__
+//
+// User-side functions for use in TRAP(...)
+//
+public:
+ UIMPORT_C TWin32SEHTrap();
+
+public:
+ /** Add object to SEH chain */
+ UIMPORT_C void Trap();
+
+ /** Remove object from SEH chain */
+ UIMPORT_C void UnTrap();
+
+#ifndef __IN_SEH_CPP__
+private:
+#endif
+ /** Handle Win32 exceptions */
+ static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
+
+#endif //__KERNEL_MODE__
+
+ //
+ // NB: This is really an _EXCEPTION_REGISTRATION_RECORD
+ //
+ TWin32SEHTrap* iPrevExceptionRegistrationRecord; /** Link to previous SEH record */
+ TWin32SEHExceptionHandler* iExceptionHandler; /** SEH handler function */
+
+private:
+ TUint32 iPadding[254]; // discourage the compiler from putting this in reused function parameter space
+ };
+
+#else // !__WINS__
+
+#ifdef __X86__
+/**
+ * @internalComponent
+ */
+class TWin32SEHTrap
+ {
+public:
+ UIMPORT_C TWin32SEHTrap();
+ UIMPORT_C void Trap();
+ UIMPORT_C void UnTrap();
+ };
+#endif //__X86__
+#endif //__WINS__
+
+/**
+@internalTechnology
+ */
+struct TEmulatorImageHeader
+ {
+ TUid iUids[KMaxCheckedUid];
+ TProcessPriority iPriority;
+ SSecurityInfo iS;
+ TUint32 iSpare1;
+ TUint32 iSpare2;
+ TUint32 iModuleVersion;
+ TUint32 iFlags;
+ };
+
+// forward declaration of shareable data buffers pool infomation
+class TShPoolInfo;
+
+#include <e32cmn.inl>
+
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <e32cmn_private.h>
+#endif
+
+#endif //__E32CMN_H__