e32cmn.h

Go to the documentation of this file.

// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\include\e32cmn.h
// 
//
 
#ifndef __E32CMN_H__
#define __E32CMN_H__
#include <e32const.h>
 
extern "C" {
IMPORT_C TInt memcompare(const TUint8* aLeft, TInt aLeftLen, const TUint8* aRight, TInt aRightLen);
 
 
 
 
IMPORT_C TAny* wordmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength);
 
 
 
 
IMPORT_C TAny* memclr(TAny* aTrg, unsigned int aLength);
}
 
 
 
 
#ifndef __TOOLS__
extern "C" {
    IMPORT_C TAny* memset(TAny* aTrg, TInt aValue, unsigned int aLength);
 
 
 
 
    IMPORT_C TAny* memcpy(TAny* aTrg, const TAny* aSrc, unsigned int aLength);
 
 
 
 
    IMPORT_C TAny* memmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength);
}
#else
#include <string.h>
#endif
 
 
 
 
inline TInt Lim(TInt aVal,TUint aLimit)
    {return(((TUint)aVal)<=aLimit);}
 
 
 
 
inline TInt LimX(TInt aVal,TUint aLimit)
    {return(((TUint)aVal)<aLimit);}
 
 
 
 
template <class T>
inline T Min(T aLeft,T aRight)
    {return(aLeft<aRight ? aLeft : aRight);}
 
 
 
 
template <class T>
inline T Min(T aLeft,TUint aRight)
    {return(aLeft<(TInt)aRight ? aLeft : (T)aRight);}
 
 
 
 
template <class T>
inline T Max(T aLeft,T aRight)
    {return(aLeft<aRight ? aRight : aLeft);}
 
 
 
 
template <class T>
inline T Max(T aLeft,TUint aRight)
    {return(aLeft<(TInt)aRight ? (TInt)aRight : aLeft);}
 
 
 
 
template <class T>
inline T Abs(T aVal)
    {return(aVal<0 ? -aVal : aVal);}
 
 
 
 
template <class T>
inline TBool Rng(T aMin,T aVal,T aMax)
    {return(aVal>=aMin && aVal<=aMax);}
 
 
 
 
template <class T,class S>
inline T* PtrAdd(T* aPtr,S aVal)
    {return((T*)(((TUint8*)aPtr)+aVal));}
 
 
 
 
template <class T,class S>
inline T* PtrSub(T* aPtr,S aVal)
    {return((T*)(((TUint8*)aPtr)-aVal));}
 
 
 
 
template <class T>
inline T Align2(T aValue)
    {return((T)((((TUint)aValue)+sizeof(TUint16)-1)&~(sizeof(TUint16)-1)));}
 
 
 
 
template <class T>
inline T Align4(T aValue)
    {return((T)((((TUint)aValue)+sizeof(TUint32)-1)&~(sizeof(TUint32)-1)));}
 
 
 
 
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
 
 
 
 
class TChar
    {
public:
 
    
    enum TCategory
        {
        EAlphaGroup = 0x00,                             
        
        
        ELetterOtherGroup = 0x10,                       
        
        
        ELetterModifierGroup = 0x20,                    
        
        
        EMarkGroup = 0x30,
        
        
        ENumberGroup = 0x40,
        
        
        EPunctuationGroup = 0x50,
        
        
        ESymbolGroup = 0x60,
        
        
        ESeparatorGroup = 0x70,
        
        
        EControlGroup = 0x80,
        
        
        EMaxAssignedGroup = 0xE0,
        
        
        EUnassignedGroup = 0xF0,
 
 
        ELuCategory = EAlphaGroup | 0,                  
        
        
        ELlCategory = EAlphaGroup | 1,                  
        
        
        ELtCategory = EAlphaGroup | 2,                  
        
        
        ELoCategory = ELetterOtherGroup | 0,            
        
        
        EMaxLetterCategory = ELetterOtherGroup | 0x0F,  
 
        ELmCategory = ELetterModifierGroup | 0,         
        
        
        EMaxLetterOrLetterModifierCategory = ELetterModifierGroup | 0x0F, 
 
        EMnCategory = EMarkGroup | 0,                   
        
        
        EMcCategory = EMarkGroup | 1,                   
        
        
        EMeCategory = EMarkGroup | 2,                   
        
        
        ENdCategory = ENumberGroup | 0,                 
        
        
        ENlCategory = ENumberGroup | 1,                 
        
        
        ENoCategory = ENumberGroup | 2,                 
        
        
        EPcCategory = EPunctuationGroup | 0,            
        
        
        EPdCategory = EPunctuationGroup | 1,            
        
        
        EPsCategory = EPunctuationGroup | 2,            
        
        
        EPeCategory = EPunctuationGroup | 3,
        
        
        EPiCategory = EPunctuationGroup | 4,            
        
        
        EPfCategory = EPunctuationGroup | 5,            
        
        
        EPoCategory = EPunctuationGroup | 6,            
        
        
        ESmCategory = ESymbolGroup | 0,                 
        
        
        EScCategory = ESymbolGroup | 1,                 
        
        
        ESkCategory = ESymbolGroup | 2,                 
        
        
        ESoCategory = ESymbolGroup | 3,                 
        
        
        EMaxGraphicCategory = ESymbolGroup | 0x0F,      
 
 
        EZsCategory = ESeparatorGroup | 0,              
 
 
        EMaxPrintableCategory = EZsCategory,            
 
 
        EZlCategory = ESeparatorGroup | 1,              
 
 
        EZpCategory = ESeparatorGroup | 2,              
 
 
        ECcCategory = EControlGroup | 0,                
 
 
        ECfCategory = EControlGroup | 1,                
 
 
        EMaxAssignedCategory = EMaxAssignedGroup | 0x0F,
                                                        
 
        ECsCategory = EUnassignedGroup | 0,             
        
        
        ECoCategory = EUnassignedGroup | 1,             
        
        
        ECnCategory = EUnassignedGroup | 2              
        };
 
    
    enum TBdCategory
        {
        ELeftToRight,               // L Left-to-Right 
       
       
        ELeftToRightEmbedding,      // LRE Left-to-Right Embedding 
       
       
        ELeftToRightOverride,       // LRO Left-to-Right Override 
       
       
        ERightToLeft,               // R Right-to-Left 
       
       
        ERightToLeftArabic,         // AL Right-to-Left Arabic 
       
       
        ERightToLeftEmbedding,      // RLE Right-to-Left Embedding 
       
       
        ERightToLeftOverride,       // RLO Right-to-Left Override 
       
       
        EPopDirectionalFormat,      // PDF Pop Directional Format 
       
       
        EEuropeanNumber,            // EN European Number 
       
       
        EEuropeanNumberSeparator,   // ES European Number Separator 
       
       
        EEuropeanNumberTerminator,  // ET European Number Terminator 
       
       
        EArabicNumber,              // AN Arabic Number 
       
       
        ECommonNumberSeparator,     // CS Common Number Separator 
       
       
        ENonSpacingMark,            // NSM Non-Spacing Mark 
       
       
        EBoundaryNeutral,           // BN Boundary Neutral 
       
       
        EParagraphSeparator,        // B Paragraph Separator 
       
       
        ESegmentSeparator,          // S Segment Separator 
 
        
        EWhitespace,                // WS Whitespace 
 
 
        EOtherNeutral               // ON Other Neutrals 
        };
 
 
    enum TCjkWidth
        {
        ENeutralWidth,          
        
        
        EHalfWidth,             // other categories are as defined in the report
        
        
        EFullWidth,
        
        
        ENarrow,
        
        EWide
        };
 
 
    enum TEncoding
        {
        EUnicode,
        
        
        EShiftJIS       
        };
 
 
    enum
        {
        EFoldCase = 1,          
 
 
        EFoldAccents = 2,       
 
 
        EFoldDigits = 4,        
 
 
        EFoldSpaces = 8,        
 
 
        EFoldKana = 16,         
 
 
        EFoldWidth = 32,        
 
 
        EFoldStandard = EFoldCase | EFoldAccents | EFoldDigits | EFoldSpaces,
 
 
        EFoldAll = -1   
        };
 
 
    struct TCharInfo
        {
        TCategory iCategory;                
        
        
        TBdCategory iBdCategory;            
        
        
        TInt iCombiningClass;               
        
        
        TUint iLowerCase;                   
        
        
        TUint iUpperCase;                   
        
        
        TUint iTitleCase;                   
        
        
        TBool iMirrored;                    
        
        
        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;
    
    // surrogate specific ones
    inline static TBool IsSupplementary(TUint aChar);
    inline static TBool IsSurrogate(TText16 aInt16);
    inline static TBool IsHighSurrogate(TText16 aInt16);
    inline static TBool IsLowSurrogate(TText16 aInt16);
    inline static TUint JoinSurrogate(TText16 aHighSurrogate, TText16 aLowSurrogate);
    inline static TText16 GetHighSurrogate(TUint aChar);
    inline static TText16 GetLowSurrogate(TUint aChar);
 
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))
typedef TDesC16 TDesC;
 
 
 
 
typedef TPtrC16 TPtrC;
 
 
 
 
typedef TDes16 TDes;
 
 
 
 
typedef TPtr16 TPtr;
 
 
 
 
#ifndef __KERNEL_MODE__
typedef HBufC16 HBufC;
 
 
 
 
typedef TDes16Overflow TDesOverflow;
 
 
typedef RBuf16 RBuf;
 
#endif
#else
#define __Size (sizeof(TUint)/sizeof(TUint8))
 
 
 
 
typedef TDesC8 TDesC;
 
 
 
 
typedef TPtrC8 TPtrC;
 
 
 
 
typedef TDes8 TDes;
 
 
 
 
typedef TPtr8 TPtr;
#ifndef __KERNEL_MODE__
 
 
 
 
typedef HBufC8 HBufC;
 
 
 
 
typedef TDes8Overflow TDesOverflow;
 
 
typedef RBuf8 RBuf;
 
#endif
#endif
 
 
#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
typedef TBufCBase16 TBufCBase;
#else
typedef TBufCBase8 TBufCBase;
#endif
 
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)];
    };
 
 
 
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)];
    };
 
 
 
 
typedef TRefByValue<const TDesC> __TRefDesC;
 
 
 
 
template <TInt S>
class TLitC
    {
public:
    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__)
 
    typedef TUint8 __TText;
#elif defined(__GCC32__)
 
    typedef wchar_t __TText;
#elif defined(__VC32__)
 
    typedef TUint16 __TText;
 
#elif defined(__CW32__)
 
    typedef TUint16 __TText;
#elif !defined(__TText_defined)
#error  no typedef for __TText
#endif
public:
    TUint iTypeLength;
 
    __TText iBuf[__Align(S)];
    };
 
 
_LIT(KNullDesC,"");
 
 
 
_LIT8(KNullDesC8,"");
#ifndef __KERNEL_MODE__
 
 
 
_LIT16(KNullDesC16,"");
#endif
 
 
 
 
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);
    };
 
 
 
 
template <class T>
class TPckg : public TPtr8
    {
public:
    inline TPckg(const T& aRef);
    inline T& operator()();
private:
    TPckg<T>& operator=(const TPckg<T>& aRef);
    };
 
 
 
 
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;
    };
 
 
 
 
typedef TBuf<KMaxName> TName;
 
 
typedef TBuf<KMaxFullName> TFullName;
 
 
 
typedef TBuf<KMaxExitCategoryName> TExitCategoryName;
 
 
 
typedef TBuf<KMaxFileName> TFileName;
 
 
 
typedef TBuf<KMaxPath> TPath;
 
 
 
 
typedef TBuf<KMaxVersionName> TVersionName;
 
 
 
 
typedef TBuf<KMaxUidName> TUidName;
 
 
 
 
#define KNullUid TUid::Null()
 
 
 
 
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:
    TInt32 iUid;
    };
 
 
 
 
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];
    };
 
 
 
 
class TSecureId
    {
public:
    inline TSecureId();
    inline TSecureId(TUint32 aId);
    inline operator TUint32() const;
    inline TSecureId(TUid aId);
    inline operator TUid() const;
public:
    TUint32 iId;
    };
 
 
 
 
class TVendorId
    {
public:
    inline TVendorId();
    inline TVendorId(TUint32 aId);
    inline operator TUint32() const;
    inline TVendorId(TUid aId);
    inline operator TUid() const;
public:
    TUint32 iId;
    };
 
 
 
#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000
#pragma push
#pragma diag_suppress 430 
#endif
class SSecureId
    {
public:
    inline const TSecureId* operator&() const;
    inline operator const TSecureId&() const;
    inline operator TUint32() const;
    inline operator TUid() const;
public:
    TUint32 iId;
    };
#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000 
#pragma pop     
#endif
 
    
    
#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000
#pragma push
#pragma diag_suppress 430 
#endif
class SVendorId
    {
public:
    inline const TVendorId* operator&() const;
    inline operator const TVendorId&() const;
    inline operator TUint32() const;
    inline operator TUid() const;
public:
    TUint32 iId;
    };
#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000 
#pragma pop     
#endif
 
 
 
#define _LIT_SECURE_ID(name,value) const SSecureId name={value}
 
 
 
 
#define _LIT_VENDOR_ID(name,value) const SVendorId name={value}
 
 
 
 
class TVersion
    {
public:
    IMPORT_C TVersion();
    IMPORT_C TVersion(TInt aMajor,TInt aMinor,TInt aBuild);
    IMPORT_C TVersionName Name() const;
public:
    TInt8 iMajor;
 
 
    TInt8 iMinor;
 
    
    TInt16 iBuild;
    };
 
 
 
 
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;
class TPoint
    {
public:
#ifndef __KERNEL_MODE__
    enum TUninitialized { EUninitialized };
    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:
    TInt iX;
    TInt iY;
    };
 
 
 
 
class TPoint3D
    {
public:
#ifndef __KERNEL_MODE__
    enum TUninitialized { EUninitialized };
 
    TPoint3D(TUninitialized) {}
    inline TPoint3D();
    inline TPoint3D(TInt aX,TInt aY,TInt aZ);
    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;
    IMPORT_C TPoint3D operator-() const;
    
    IMPORT_C void SetXYZ(TInt aX,TInt aY,TInt aZ);
    
    IMPORT_C void SetPoint(const TPoint& aPoint);
 
    IMPORT_C TPoint AsPoint() const;
#endif
public:
    TInt iX;
    TInt iY;
    TInt iZ;
    };
 
 
 
class TAngle3D
    {
public:
    TInt iPhi;
    TInt iTheta;
    };
 
    
class TSize
    {
public:
#ifndef __KERNEL_MODE__
    enum TUninitialized { EUninitialized };
    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:
    TInt iWidth;
    TInt iHeight;
    };
 
 
 
 
class THandleInfo
    {
public:
    TInt iNumOpenInProcess;
    
    TInt iNumOpenInThread;
    
    TInt iNumProcesses;
    
    TInt iNumThreads;
    };
 
 
 
 
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;
class RHandleBase
    {
public:
    enum TAttributes
        {
        EReadAccess=0x1,
        EWriteAccess=0x2,
        EDirectReadAccess=0x4,
        EDirectWriteAccess=0x8,
        };
public:
    inline RHandleBase();
    inline TInt Handle() const;
    inline void SetHandle(TInt aHandle);
    inline TInt SetReturnedHandle(TInt aHandleOrError); 
    static void DoExtendedClose();
#ifndef __KERNEL_MODE__
    IMPORT_C void Close();
    IMPORT_C TName Name() const;
    IMPORT_C TFullName FullName() const;
    IMPORT_C void FullName(TDes& aName) const;
    IMPORT_C void SetHandleNC(TInt aHandle);
    IMPORT_C TInt Duplicate(const RThread& aSrc,TOwnerType aType=EOwnerProcess);
    IMPORT_C void HandleInfo(THandleInfo* anInfo);
    IMPORT_C TUint Attributes() const;
    IMPORT_C TInt BTraceId() const;
    IMPORT_C void NotifyDestruction(TRequestStatus& aStatus);   
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;
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 TInt Poll();       // acquire the semaphore if possible, but don't block
    IMPORT_C void Signal();
    IMPORT_C void Signal(TInt aCount);
#endif
    };
 
 
 
 
class RFastLock : public RSemaphore
    {
public:
    inline RFastLock();
    IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
    IMPORT_C void Wait();
    IMPORT_C TInt Wait(TInt aTimeout);  // timeout in microseconds
    IMPORT_C TInt Poll();       // acquire the lock if possible, but don't block
    IMPORT_C void Signal();
private:
    TInt iCount;
    };
 
 
 
 
class RReadWriteLock
    {
public:
    enum TReadWriteLockPriority
        {
        EWriterPriority,
        EAlternatePriority,
        EReaderPriority,
        };
    enum TReadWriteLockClientCategoryLimit
        {
        EReadWriteLockClientCategoryLimit = KMaxTUint16
        };
 
public:
    inline RReadWriteLock();
    IMPORT_C TInt CreateLocal(TReadWriteLockPriority aPriority = EWriterPriority);
    IMPORT_C void Close();
 
    IMPORT_C void ReadLock();
    IMPORT_C void WriteLock();
    IMPORT_C TBool TryReadLock();
    IMPORT_C TBool TryWriteLock();
    IMPORT_C TBool TryUpgradeReadLock();
    IMPORT_C void DowngradeWriteLock();
    IMPORT_C void Unlock();
 
private:
    RReadWriteLock(const RReadWriteLock& aLock);
    RReadWriteLock& operator=(const RReadWriteLock& aLock);
 
    TInt UnlockWriter();
    TInt UnlockAlternate();
    TInt UnlockReader();
 
private:
    volatile TUint64 iValues; // Bits 0-15: readers; bit 16: writer; bits 32-47: readersPending; bits 48-63: writersPending
    TReadWriteLockPriority iPriority;
    RSemaphore iReaderSem;
    RSemaphore iWriterSem;
    TUint32 iSpare[4]; // Reserved for future development
    };
 
 
 
 
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;
    };
 
 
 
 
// 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;
    };
 
 
 
 
class RAllocator : public MAllocator
    {
public:
    enum TAllocFail
        {
        ERandom,
 
        ETrueRandom,
 
        EDeterministic,
 
        ENone,
 
        EFailNext,
 
        EReset,
 
        EBurstRandom,
 
        EBurstTrueRandom,
 
        EBurstDeterministic,
 
        EBurstFailNext,
 
        ECheckFailure,
        };
 
    enum TDbgHeapType
        {
        EUser,
 
        EKernel
        };
 
    enum TAllocDebugOp
        {
        ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail, EGetFail,
        EGetSize=48, EGetMaxLength, EGetBase, EAlignInteger, EAlignAddr
        };
 
    enum TReAllocMode
        {
        ENeverMove=1,
 
        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 TAllocFail __DbgGetAllocFail();
    UIMPORT_C void __DbgSetBurstAllocFail(TAllocFail aType, TUint aRate, TUint aBurst);
    UIMPORT_C TUint __DbgCheckFailure();
    UIMPORT_C TInt Size() const;
    UIMPORT_C TInt MaxLength() const;
    UIMPORT_C TUint8* Base() const;
    UIMPORT_C TInt Align(TInt a) const;
    UIMPORT_C TAny* Align(TAny* a) const;
 
protected:
    UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
#ifndef __KERNEL_MODE__
    IMPORT_C virtual void DoClose();
#endif
 
protected:
    TInt    iAccessCount;       // Value of the allocator's access count (ie. Number of times RAllocator::Open() has been called)
    TInt    iHandleCount;       // Number of handles in the iHandles array
    TInt*   iHandles;           // Array of handles to chunks used by the heap implementation
    TUint32 iFlags;             // Flags describing attributes of the heap; see RAllocator::TFlags
    TInt    iCellCount;         // Internal debugger use only; use MAllocator::AllocSize() instead
    TInt    iTotalAllocSize;    // Internal debugger use only; use MAllocator::AllocSize() instead
    };
 
class UserHeap;
 
// This #define is for tools such as MemSpy that need to work across different versions of
// Symbian and need to know whether they are working with the new or old heap
 
#define __SYMBIAN_KERNEL_HYBRID_HEAP__
 
class RHeap : public RAllocator
    {
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);
    inline RHeap() { }
 
public:
 
    struct SDebugCell
        {
        TInt nestingLevel;
 
        TInt allocCount;
        };
 
    struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc;  TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; };
 
    enum { EDebugHdrSize = sizeof(SDebugCell) };
 
    enum { ECellAlignment = 8 };
 
    enum { EFreeCellSize = 4 };
 
#ifdef _DEBUG
    enum { EAllocCellSize = (4 + EDebugHdrSize) };
#else
    enum { EAllocCellSize = 4 };
#endif
 
    enum TDebugOp { EWalk = 128, EHybridHeap };
 
    enum TCellType
        {
        EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress,
        EBadFreeCellAddress, EBadFreeCellSize
        };
 
    enum TDebugHeapId { EUser = 0, EKernel = 1 };
 
    enum TDefaultShrinkRatios { EShrinkRatio1 = 256, EShrinkRatioDflt = 512 };
 
    typedef void (*TWalkFunc)(TAny*, TCellType, TAny*, TInt);
 
protected:
 
    // These variables are present only for downwards binary compatibility.  Most are unused,
    // but some must be present so that previously inline functions continue to work.  These
    // old inline functions are now replaced with non inline versions so recompiling existing
    // code will automatically switch to the new versions and you should no longer access any
    // of the variables in here.
    //
    // These variables should now all be considered private and should NOT be accessed directly!
    //
    TInt        iUnused1;       // Present for binary compatibility reasons only
    TInt        iMaxLength;     // Use RAllocator::MaxLength() to get this information now
    TInt        iUnused2;       // Present for binary compatibility reasons only
    TInt        iUnused3;       // Present for binary compatibility reasons only
    // These next two variables must remain in this order for correct object destruction
    TInt        iChunkHandle;   // Do not use; consider undocumented
    RFastLock   iLock;          // Do not use; consider undocumented
    TUint8*     iBase;          // Use RAllocator::Base() to get this information now
    TUint8*     iTop;           // Do not use; consider undocumented
    TInt        iAlign;         // Use RAllocator::Align() to get this information now
 
    // These variables are temporary to prevent source breaks from req417-52840.  They are deprecated in
    // favour of non hacky ways of determining this information but are required during the switchover to
    // this method
    TAllocFail  iFailType;      // Use RAllocator::__DbgGetAllocFail() to get this information now
    TInt        iNestingLevel;  // Do not use; consider undocumented
    TAny*       iTestData;      // Do not use; consider undocumented
 
    friend class UserHeap;
    };
 
class OnlyCreateWithNull;
 
typedef void (OnlyCreateWithNull::* __NullPMF)();
 
class OnlyCreateWithNull
    {
public:
    inline OnlyCreateWithNull(__NullPMF /*aPointerToNull*/) {}
    };
 
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;
    IMPORT_C TBool ClientIsRealtime() const;
    
    IMPORT_C TSecureId SecureId() const;
 
    IMPORT_C TVendorId VendorId() const;
 
#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__
 
#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__
 
#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__
 
#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__
 
    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__
 
class RMessage2 : public RMessagePtr2
    {
    friend class CServer2;
public:
 
    enum TSessionMessages {
                          EConnect=-1,
                          
                          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:
    
    TInt iFunction;
    
    TInt iArgs[KMaxMessageArguments];
private:
    TInt iSpare1;
protected:
    const TAny* iSessionPtr;
private:
    mutable TInt iFlags;// Currently only used for *Authorised above
    TInt iSpare3;       // Reserved for future use
 
    friend class RMessage;
    };
 
 
 
 
typedef TBuf8<KMaxMediaPassword> TMediaPassword;    // 128 bit
 
 
 
const TUint KScFlagBufOffsetListInUse=0x00000001;
 
const TUint KScFlagUseGuardPages=0x00000002;
 
class TSharedChunkBufConfigBase
    {
public: 
    inline TSharedChunkBufConfigBase();
public:
    TInt iNumBuffers;
    TInt iBufferSizeInBytes;
    TInt iReserved1;
    TUint iFlags;
    };
 
 
const TInt KCapabilitySetMaxSize = (((TInt)ECapability_HardLimit + 7)>>3);
 
const TInt KMaxSecurityPolicySize = KCapabilitySetMaxSize + 3*sizeof(TUint32);
 
 
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;
 
    IMPORT_C void SetDisabled();
    TBool NotEmpty() const;
 
private:
    TUint32 iCaps[KCapabilitySetMaxSize / sizeof(TUint32)];
    };
 
#ifndef __SECURITY_INFO_DEFINED__
#define __SECURITY_INFO_DEFINED__
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];
    };
 
struct SSecurityInfo
    {
    TUint32 iSecureId;
    TUint32 iVendorId;
    SCapabilitySet iCaps;   // Capabilities re. platform security
    };
 
#endif
 
#ifdef __REFERENCE_ALL_SUPPORTED_CAPABILITIES__
 
extern const SCapabilitySet AllSupportedCapabilities;
 
#endif  //__REFERENCE_ALL_SUPPORTED_CAPABILITIES__
 
#ifdef __INCLUDE_ALL_SUPPORTED_CAPABILITIES__
 
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 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); 
    inline void SetToCurrentInfo();
    IMPORT_C void SetToCreatorInfo();
#endif //__KERNEL_MODE__
public:
    TSecureId       iSecureId;  
    TVendorId       iVendorId;  
    TCapabilitySet  iCaps;      
    };
 
 
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; 
#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:
    enum TType
        {
        ETypeFail=0,    
        ETypePass=1,    
        ETypeC3=2,      
        ETypeC7=3,      
        ETypeS3=4,      
        ETypeV3=5,      
        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;
    };
 
typedef TPckgBuf<TSecurityPolicy> TSecurityPolicyBuf;
 
 
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; 
    TUint32 iB; 
    };
 
    
enum __invalid_capability_value {};
 
#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)  \
    ))
 
 
#define FOUR_TUINT8(i1,i2,i3,i4)          \
    (                                     \
        (TUint32)((i1) & 0xFF)          | \
        (TUint32)((i2) & 0xFF) << 8     | \
        (TUint32)((i3) & 0xFF) << 16    | \
        (TUint32)((i4) & 0xFF) << 24      \
    )
 
 
#define _INIT_SECURITY_POLICY_FAIL \
    {                                                                       \
    FOUR_TUINT8(                                                            \
        (TUint8)TSecurityPolicy::ETypeFail,                                 \
        (TUint8)0xff,                                                       \
        (TUint8)0xff,                                                       \
        (TUint8)0xff                                                        \
    ),                                                                      \
    (TUint32)0xffffffff                                                     \
    }
 
 
#define _LIT_SECURITY_POLICY_FAIL(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_FAIL
 
 
#define _INIT_SECURITY_POLICY_PASS \
    {                                                                       \
    FOUR_TUINT8(                                                            \
        (TUint8)TSecurityPolicy::ETypePass,                                 \
        (TUint8)0xff,                                                       \
        (TUint8)0xff,                                                       \
        (TUint8)0xff                                                        \
    ),                                                                      \
    (TUint32)0xffffffff                                                     \
    }
 
 
#define _LIT_SECURITY_POLICY_PASS(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_PASS
 
 
#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)                                            \
    )                                                                       \
    }
 
 
#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)
 
 
#define _INIT_SECURITY_POLICY_C6(c1,c2,c3,c4,c5,c6)  \
    _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,ECapability_None)
 
 
#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)
 
 
#define _INIT_SECURITY_POLICY_C5(c1,c2,c3,c4,c5)  \
    _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,ECapability_None,ECapability_None)
 
 
#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)
 
 
#define _INIT_SECURITY_POLICY_C4(c1,c2,c3,c4)  \
    _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,ECapability_None,ECapability_None,ECapability_None)
 
 
#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)
 
 
#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                                                     \
    }
 
 
#define _LIT_SECURITY_POLICY_C3(n,c1,c2,c3)                                 \
    const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_C3(c1,c2,c3)
 
 
#define _INIT_SECURITY_POLICY_C2(c1,c2)  \
    _INIT_SECURITY_POLICY_C3(c1,c2,ECapability_None)
 
 
#define _LIT_SECURITY_POLICY_C2(n,c1,c2)  \
    _LIT_SECURITY_POLICY_C3(n,c1,c2,ECapability_None)
 
 
#define _INIT_SECURITY_POLICY_C1(c1)  \
    _INIT_SECURITY_POLICY_C3(c1,ECapability_None,ECapability_None)
 
 
#define _LIT_SECURITY_POLICY_C1(n,c1)  \
    _LIT_SECURITY_POLICY_C3(n,c1,ECapability_None,ECapability_None)
 
 
#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)                                                          \
    }
 
 
#define _LIT_SECURITY_POLICY_S3(n,sid,c1,c2,c3)                             \
    const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_S3(sid,c1,c2,c3)
 
 
#define _INIT_SECURITY_POLICY_S2(sid,c1,c2)  \
    _INIT_SECURITY_POLICY_S3(sid,c1,c2,ECapability_None)
 
 
#define _LIT_SECURITY_POLICY_S2(n,sid,c1,c2)  \
    _LIT_SECURITY_POLICY_S3(n,sid,c1,c2,ECapability_None)
 
 
#define _INIT_SECURITY_POLICY_S1(sid,c1)  \
    _INIT_SECURITY_POLICY_S3(sid,c1,ECapability_None,ECapability_None)
 
 
#define _LIT_SECURITY_POLICY_S1(n,sid,c1)  \
    _LIT_SECURITY_POLICY_S3(n,sid,c1,ECapability_None,ECapability_None)
 
 
#define _INIT_SECURITY_POLICY_S0(sid)  \
    _INIT_SECURITY_POLICY_S3(sid,ECapability_None,ECapability_None,ECapability_None)
 
 
#define _LIT_SECURITY_POLICY_S0(n,sid)  \
    _LIT_SECURITY_POLICY_S3(n,sid,ECapability_None,ECapability_None,ECapability_None)
 
 
#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)                                                          \
    }
 
 
#define _LIT_SECURITY_POLICY_V3(n,vid,c1,c2,c3)                             \
    const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_V3(vid,c1,c2,c3)
 
 
#define _INIT_SECURITY_POLICY_V2(vid,c1,c2)  \
    _INIT_SECURITY_POLICY_V3(vid,c1,c2,ECapability_None)
 
 
#define _LIT_SECURITY_POLICY_V2(n,vid,c1,c2)  \
    _LIT_SECURITY_POLICY_V3(n,vid,c1,c2,ECapability_None)
 
 
#define _INIT_SECURITY_POLICY_V1(vid,c1)  \
    _INIT_SECURITY_POLICY_V3(vid,c1,ECapability_None,ECapability_None)
 
 
#define _LIT_SECURITY_POLICY_V1(n,vid,c1)  \
    _LIT_SECURITY_POLICY_V3(n,vid,c1,ECapability_None,ECapability_None)
 
 
#define _INIT_SECURITY_POLICY_V0(vid)  \
    _INIT_SECURITY_POLICY_V3(vid,ECapability_None,ECapability_None,ECapability_None)
 
 
#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 PlatSec
    {
#ifndef __KERNEL_MODE__
public:
    IMPORT_C static TBool IsCapabilityEnforced(TCapability aCapability);
 
    enum TConfigSetting
        {
        EPlatSecEnforcement, 
        EPlatSecDiagnotics,  
        EPlatSecProcessIsolation,  
        EPlatSecEnforceSysBin,  
        EPlatSecLocked,  
        };
 
    IMPORT_C static TInt ConfigSetting(TConfigSetting aSetting);
 
#endif // Not __KERNEL_MODE__
 
    //
    // All methods below here are internalTechnology
    //
 
#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
public:
    static inline TInt LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
#ifdef __KERNEL_MODE__
    static inline TInt CapabilityCheckFail(const DProcess* aViolatingProcess, TCapability aCapability, const char* aContextText);
    static inline TInt CapabilityCheckFail(const DThread* aViolatingThread, TCapability aCapability, const char* aContextText);
    static inline TInt SecureIdCheckFail(const DProcess* aViolatingProcess, TSecureId aSid, const char* aContextText);
    static inline TInt PolicyCheckFail(const DProcess* aProcess, const SSecurityInfo& aMissing, const char* aContextText);
    static inline TInt PolicyCheckFail(const DThread* aProcess, const SSecurityInfo& aMissing, const char* aContextText);
    static inline TInt ProcessIsolationFail(const char* aContextText);
    static inline TInt ProcessIsolationIPCFail(RMessageK* aMessage, const char* aContextText);
#else // !__KERNEL_MODE__
    static inline TInt LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
    static inline TInt CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText);
    static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText);
    static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText);
    static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText);
    static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing, const char* aContextText);
    static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText);
    static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText);
    static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps, const char* aContextText);
    static inline TInt PolicyCheckFail(RSessionBase aSession, const SSecurityInfo& aMissingCaps, const char* aContextText);
    static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps, const char* aContextText);
    static inline TInt CreatorCapabilityCheckFail(TCapability aCapability);
    static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps);
    static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability);
    static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps);
    static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing);
    static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability);
    static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps);
    static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps);
    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:
    UIMPORT_C static TInt EmitDiagnostic();
    };
 
 
#define KMaxSerialNumLength 64
typedef TBuf8<KMaxSerialNumLength> TMediaSerialNumber;
 
 
class TProcessMemoryInfo
    {
public:
    TUint32 iCodeBase;
 
    
    TUint32 iCodeSize;
    
    
    TUint32 iConstDataBase;
    
    
    TUint32 iConstDataSize;
    
    
    TUint32 iInitialisedDataBase;
    
    
    TUint32 iInitialisedDataSize;
 
    
    TUint32 iUninitialisedDataBase;
 
    
    TUint32 iUninitialisedDataSize;
    };
 
 
 
 
typedef TProcessMemoryInfo TModuleMemoryInfo;   // more accurate name - remove old one later
 
 
 
 
#ifndef __KERNEL_MODE__
class CBase;
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
 
 
 
 
typedef TBool (*TGeneralIdentityRelation)(const TAny*, const TAny*);
 
 
 
 
typedef TInt (*TGeneralLinearOrder)(const TAny*, const TAny*);
 
 
 
 
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;
    };
 
 
 
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&);
    };
 
 
 
 
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
    {
    EArrayFindMode_Any = 0,
    
    EArrayFindMode_First = 1,
 
    EArrayFindMode_Last = 2,
    
    EArrayFindMode_Limit = 3
    };
 
 
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;
    };
 
 
 
 
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
        { 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
        { 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
        { 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
    };
 
 
 
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
    };
 
 
 
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 void SetKeyOffset(TInt aKeyOffset);
    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;
    };
 
 
 
 
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 void SetKeyOffset(TInt aKeyOffset);
    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
        { 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 
        { 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
        { 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
    };
 
 
 
 
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
    };
 
 
 
 
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;
 
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;
    };
 
 
 
#define TRAP(_r,_s) {TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}}
 
#define TRAPD(_r,_s) TInt _r;{TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}}
 
#define TRAP_IGNORE(_s) {TInt _ignore;TTrap __t;if (__t.Trap(_ignore)==0){_s;TTrap::UnTrap();}}
 
 
#else //__LEAVE_EQUALS_THROW__
 
#ifdef __WINS__
#define __WIN32SEHTRAP      TWin32SEHTrap __trap; __trap.Trap();
#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__
 
#define TRAP_INSTRUMENTATION_START
 
 
 
#define TRAP_INSTRUMENTATION_NOLEAVE
 
 
#define TRAP_INSTRUMENTATION_LEAVE(aResult)
 
 
 
#define TRAP_INSTRUMENTATION_END
 
 
 
/*__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; }                           \
    }
 
 
/*__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; }                           \
    }
 
/*__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__
 
GLREF_C TAny* operator new(TUint aSize) __NO_THROW;
 
GLREF_C TAny* operator new(TUint aSize,TUint anExtraSize) __NO_THROW;
 
GLREF_C void operator delete(TAny* aPtr) __NO_THROW;
 
#ifndef __OMIT_VEC_OPERATOR_NEW_DECL__
GLREF_C TAny* operator new[](TUint aSize) __NO_THROW;
 
GLREF_C void operator delete[](TAny* aPtr) __NO_THROW;
#endif // !__OMIT_VEC_OPERATOR_NEW_DECL__
 
#endif // !__OPERATOR_NEW_DECLARED__
 
#endif // !__SYMBIAN_STDCPP_SUPPORT__
 
inline TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;
 
inline void operator delete(TAny* aPtr, TAny* aBase) __NO_THROW;
 
#ifndef __PLACEMENT_VEC_NEW_INLINE
inline TAny* operator new[](TUint aSize, TAny* aBase) __NO_THROW;
 
inline void operator delete[](TAny* aPtr, TAny* aBase) __NO_THROW;
 
#endif // !__PLACEMENT_VEC_NEW_INLINE
 
#if !defined(__BOOL_NO_TRUE_TRAP__)
 
TBool operator==(TTrue,volatile const TBool);
 
TBool operator==(volatile const TBool,TTrue);
 
TBool operator!=(TTrue,volatile const TBool);
 
TBool operator!=(volatile const TBool,TTrue);
#endif
 
 
 
 
class TIpcArgs
    {
public:
    enum TArgType
        {
        EUnspecified = 0,                         
        EHandle = 1,                              
        EFlagDes = 4,                             
        EFlagConst = 2,                           
        EFlag16Bit = 1,                           
        EDes8 = EFlagDes,                         
        EDes16 = EFlagDes|EFlag16Bit,             
        EDesC8 = EFlagDes|EFlagConst,             
        EDesC16 = EFlagDes|EFlagConst|EFlag16Bit, 
        };
 
 
    enum 
        {
        KBitsPerType    = 3,        
        KPinArgShift    = KBitsPerType*KMaxMessageArguments,    
        KPinArg0        = 1<<(KPinArgShift+0),  
        KPinArg1        = 1<<(KPinArgShift+1),  
        KPinArg2        = 1<<(KPinArgShift+2),  
        KPinArg3        = 1<<(KPinArgShift+3),  
        KPinMask        = 0xf<<KPinArgShift,    
        };
    
    
    enum TNothing {
                  ENothing
                  };
public:
    inline TIpcArgs()
        :iFlags(0)
        {}
        
        
    template <class T0>
    inline explicit TIpcArgs(T0 a0)
        {
        Assign(iArgs[0],a0);
        iFlags=(Type(a0)<<(0*KBitsPerType));
        }
        
        
    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));
        }
                
        
    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));
        }
 
 
    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
 
    inline TIpcArgs& PinArgs(TBool aPinArg0=ETrue, TBool aPinArg1=ETrue, TBool aPinArg2=ETrue, TBool aPinArg3=ETrue);
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:
    
    TInt iArgs[KMaxMessageArguments];
    
    TInt iFlags;
    };
 
// Structures for passing 64 bit integers and doubles across GCC/EABI boundaries
 
struct SInt64
    {
public:
    inline SInt64();
    inline SInt64(Int64 a);
    inline SInt64& operator=(Int64 a);
    inline operator Int64() const;
public:
    TUint32 iData[2];   // little endian
    };
 
struct SUint64
    {
public:
    inline SUint64();
    inline SUint64(Uint64 a);
    inline SUint64& operator=(Uint64 a);
    inline operator Uint64() const;
public:
    TUint32 iData[2];   // little endian
    };
 
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
    };
 
class TThreadStackInfo
    {
public:
    TLinAddr iBase;
    
    TLinAddr iLimit;
    
    TLinAddr iExpandLimit;
    };
 
 
 
 
#ifdef __SUPPORT_CPP_EXCEPTIONS__
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
    // 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 include the StdC++ specification <exception> rather than declaring uncaught_exception.
 
#ifdef __SYMBIAN_STDCPP_SUPPORT__
    #include <stdapis/stlportv5/exception>
#elif !defined(_EXCEPTION) && !defined(_EXCEPTION_) && !defined(__EXCEPTION__)
// 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 TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
 
class TWin32SEHTrap
    {
private:
    // Prevent copy/assign
    TWin32SEHTrap(TWin32SEHTrap const &);
    TWin32SEHTrap& operator=(TWin32SEHTrap const &);
 
#ifdef __KERNEL_MODE__
//
// Kernel-side functions for nkern exception handler
//
public:
    static TWin32SEHTrap* IterateForFinal();
 
    TWin32SEHExceptionHandler* ExceptionHandler();
 
private:
 
#else // !__KERNEL_MODE__
//
// User-side functions for use in TRAP(...)
//
public:
    UIMPORT_C TWin32SEHTrap();
 
public:
    UIMPORT_C void Trap();
 
    UIMPORT_C void UnTrap();
 
#ifndef __IN_SEH_CPP__
private:
#endif
    static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
 
#endif //__KERNEL_MODE__
 
    //
    // NB: This is really an _EXCEPTION_REGISTRATION_RECORD
    //
    TWin32SEHTrap*                  iPrevExceptionRegistrationRecord;   
    TWin32SEHExceptionHandler*      iExceptionHandler;                  
private:
    TUint32 iPadding[254];  // discourage the compiler from putting this in reused function parameter space
    };
 
#else // !__WINS__
 
#ifdef __X86__
class TWin32SEHTrap
    {
public:
    UIMPORT_C TWin32SEHTrap();
    UIMPORT_C void Trap();
    UIMPORT_C void UnTrap();
    };
#endif //__X86__
#endif //__WINS__
 
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__