e32std.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\e32std.h
// 
//
 
#ifndef __E32STD_H__
#define __E32STD_H__
 
#ifdef __KERNEL_MODE__
#error !! Including e32std.h in kernel code !!
#endif
 
#include <e32cmn.h>
 
class TFunctor
    {
public:
    IMPORT_C virtual void operator()() =0;
    };
 
class TCallBack
    {
public:
    inline TCallBack();
    inline TCallBack(TInt (*aFunction)(TAny* aPtr));
    inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
    inline TInt CallBack() const;
public:
    
    TInt (*iFunction)(TAny* aPtr);
    
    
    TAny* iPtr;
    };
 
 
 
 
class TSglQueLink
    {
#if defined _DEBUG
public:
    inline TSglQueLink() : iNext(NULL)
    {}
#endif
private:
    IMPORT_C void Enque(TSglQueLink* aLink);
public:
    TSglQueLink* iNext;
    friend class TSglQueBase;
    };
 
 
 
 
class TDblQueLinkBase
    {
public:
    inline TDblQueLinkBase() : iNext(NULL)
    {}
    IMPORT_C void Enque(TDblQueLinkBase* aLink);
    IMPORT_C void AddBefore(TDblQueLinkBase* aLink);
public:
    TDblQueLinkBase* iNext;
    
    TDblQueLinkBase* iPrev;
    };
 
 
 
 
class TDblQueLink : public TDblQueLinkBase
    {
public:
    IMPORT_C void Deque();
    };
 
 
 
 
class TPriQueLink : public TDblQueLink
    {
public:
    TInt iPriority;
    };
 
 
 
 
class TDeltaQueLink : public TDblQueLinkBase
    {
public:
    TInt iDelta;
    };
 
 
 
 
class TTickCountQueLink : public TDblQueLink
    {
public:
    TUint iTickCount;
    };
 
 
 
 
class TSglQueBase
    {
public:
    IMPORT_C TBool IsEmpty() const;
    IMPORT_C void SetOffset(TInt aOffset);
    IMPORT_C void Reset();
protected:
    IMPORT_C TSglQueBase();
    IMPORT_C TSglQueBase(TInt aOffset);
    IMPORT_C void DoAddFirst(TAny* aPtr);
    IMPORT_C void DoAddLast(TAny* aPtr);
    IMPORT_C void DoRemove(TAny* aPtr);
protected:
    TSglQueLink* iHead;
    
    TSglQueLink* iLast;
    
    TInt iOffset;
private:
    TSglQueBase(const TSglQueBase& aQue);
    TSglQueBase &operator=(const TSglQueBase& aQue);
    friend class TSglQueIterBase;
    };
 
 
 
 
class TDblQueBase
    {
public:
    IMPORT_C TBool IsEmpty() const;
    IMPORT_C void SetOffset(TInt aOffset);
    IMPORT_C void Reset();
protected:
    IMPORT_C TDblQueBase();
    IMPORT_C TDblQueBase(TInt aOffset);
    IMPORT_C void DoAddFirst(TAny* aPtr);
    IMPORT_C void DoAddLast(TAny* aPtr);
    IMPORT_C void DoAddPriority(TAny* aPtr);
    IMPORT_C void __DbgTestEmpty() const;
protected:
    TDblQueLink iHead;
    
    TInt iOffset;
private:
    TDblQueBase(const TDblQueBase& aQue);
    TDblQueBase& operator=(const TDblQueBase& aQue);
    friend class TDblQueIterBase;
    };
 
 
 
 
class TDeltaQueBase : public TDblQueBase
    {
public:
    IMPORT_C TBool CountDown();
    IMPORT_C TBool CountDown(TInt aValue);
    IMPORT_C TBool FirstDelta(TInt& aValue);
    IMPORT_C void Reset();
protected:
    IMPORT_C TDeltaQueBase();
    IMPORT_C TDeltaQueBase(TInt aOffset);
    IMPORT_C void DoAddDelta(TAny* aPtr,TInt aDelta);
    IMPORT_C void DoRemove(TAny* aPtr);
    IMPORT_C TAny* DoRemoveFirst();
protected:
    TInt* iFirstDelta;
    };
 
 
 
 
template <class T>
class TSglQue : public TSglQueBase
    {
public:
    inline TSglQue();
    inline explicit TSglQue(TInt aOffset);
    inline void AddFirst(T& aRef);
    inline void AddLast(T& aRef);
    inline TBool IsFirst(const T* aPtr) const;
    inline TBool IsLast(const T* aPtr) const;
    inline T* First() const;
    inline T* Last() const;
    inline void Remove(T& aRef);
    };
 
 
 
 
template <class T>
class TDblQue : public TDblQueBase
    {
public:
    inline TDblQue();
    inline explicit TDblQue(TInt aOffset);
    inline void AddFirst(T& aRef);
    inline void AddLast(T& aRef);
    inline TBool IsHead(const T* aPtr) const;
    inline TBool IsFirst(const T* aPtr) const;
    inline TBool IsLast(const T* aPtr) const;
    inline T* First() const;
    inline T* Last() const;
    };
 
 
 
 
template <class T>
class TPriQue : public TDblQueBase
    {
public:
    inline TPriQue();
    inline explicit TPriQue(TInt aOffset);
    inline void Add(T& aRef);
    inline TBool IsHead(const T* aPtr) const;
    inline TBool IsFirst(const T* aPtr) const;
    inline TBool IsLast(const T* aPtr) const;
    inline T* First() const;
    inline T* Last() const;
    };
 
 
 
 
template <class T>
class TDeltaQue : public TDeltaQueBase
    {
public:
    inline TDeltaQue();
    inline explicit TDeltaQue(TInt aOffset);
    inline void Add(T& aRef,TInt aDelta);
    inline void Remove(T& aRef);
    inline T* RemoveFirst();
    };
 
 
 
 
// Forward declaration
class TTickCountQueLink;
 
class TTickCountQue : public TDblQueBase
    {
public:
    TTickCountQue();
    void Add(TTickCountQueLink& aRef);
    TTickCountQueLink* First() const;
    TTickCountQueLink* RemoveFirst();
    TTickCountQueLink* RemoveFirst(TUint aTickCount);
    };
 
 
 
 
class TSglQueIterBase
    {
public:
    IMPORT_C void SetToFirst();
protected:
    IMPORT_C TSglQueIterBase(TSglQueBase& aQue);
    IMPORT_C TAny* DoPostInc();
    IMPORT_C TAny* DoCurrent();
    IMPORT_C void DoSet(TAny* aLink);
protected:
    TInt iOffset;
    TSglQueLink* iHead;
    TSglQueLink* iNext;
    };
 
 
 
 
template <class T>
class TSglQueIter : public TSglQueIterBase
    {
public:
    inline TSglQueIter(TSglQueBase& aQue);
    inline void Set(T& aLink);
    inline operator T*();
    inline T* operator++(TInt);
    };
 
 
 
 
class TDblQueIterBase
    {
public:
    IMPORT_C void SetToFirst();
    IMPORT_C void SetToLast();
protected:
    IMPORT_C TDblQueIterBase(TDblQueBase& aQue);
    IMPORT_C TAny* DoPostInc();
    IMPORT_C TAny* DoPostDec();
    IMPORT_C TAny* DoCurrent();
    IMPORT_C void DoSet(TAny* aLink);
protected:
    TInt iOffset;
    
    TDblQueLinkBase* iHead;
    
    TDblQueLinkBase* iNext;
    };
 
 
 
 
template <class T>
class TDblQueIter : public TDblQueIterBase
    {
public:
    inline TDblQueIter(TDblQueBase& aQue);
    inline void Set(T& aLink);
    inline operator T*();
    inline T* operator++(TInt);
    inline T* operator--(TInt);
    };
 
 
 
 
enum TKeyCmpText
    {
    ECmpNormal,
    
    
    ECmpNormal8,
    
    
    ECmpNormal16,
    
    
    ECmpFolded,
    
    
    ECmpFolded8,
    
    
    ECmpFolded16,
    
    
    ECmpCollated,
    
    
    ECmpCollated8,
    
    
    ECmpCollated16
    };
 
 
 
 
enum TKeyCmpNumeric
    {
    ECmpTInt8=((ECmpCollated16+1)<<1),
    
    
    ECmpTInt16,
    
    
    ECmpTInt32,
    
    
    ECmpTInt,
    
    
    ECmpTUint8,
    
    
    ECmpTUint16,
    
    
    ECmpTUint32,
    
    
    ECmpTUint,
    
    
    ECmpTInt64
    };
 
 
 
 
class TKey
    {
public:
    inline void SetPtr(const TAny* aPtr);
    IMPORT_C virtual TInt Compare(TInt aLeft,TInt aRight) const;
    IMPORT_C virtual TAny* At(TInt anIndex) const;
protected:
    IMPORT_C TKey();
    IMPORT_C TKey(TInt aOffset,TKeyCmpText aType);
    IMPORT_C TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
    IMPORT_C TKey(TInt aOffset,TKeyCmpNumeric aType);
protected:
    TInt iKeyOffset;
    TInt iKeyLength;
    TInt iCmpType;
    const TAny* iPtr;
    };
 
class TSwap
    {
public:
    IMPORT_C TSwap();
    IMPORT_C virtual void Swap(TInt aLeft,TInt aRight) const;
    };
 
 
 
 
class TCharF : public TChar
    {
public:
    inline TCharF(TUint aChar);
    inline TCharF(const TChar& aChar);
    inline TCharF& operator=(TUint aChar);
    inline TCharF& operator=(const TChar& aChar);
    };
 
 
 
 
class TCharLC : public TChar
    {
public:
    inline TCharLC(TUint aChar);
    inline TCharLC(const TChar& aChar);
    inline TCharLC& operator=(TUint aChar);
    inline TCharLC& operator=(const TChar& aChar);
    };
 
 
 
 
class TCharUC : public TChar
    {
public:
    inline TCharUC(TUint aChar);
    inline TCharUC(const TChar& aChar);
    inline TCharUC& operator=(TUint aChar);
    inline TCharUC& operator=(const TChar& aChar);
    };
 
 
 
class TRealFormat
    {
public:
    IMPORT_C TRealFormat();
    IMPORT_C TRealFormat(TInt aWidth);
    IMPORT_C TRealFormat(TInt aWidth,TInt aDecimalPlaces);
public:
    TInt iType;
    
    
    TInt iWidth;
    
    
    TInt iPlaces;
    
    
    TChar iPoint;
    
    
    TChar iTriad;
    
    
    TInt iTriLen;
    };
 
 
 
 
class TLexMark8
    {
public:
    inline TLexMark8();
private:
    inline TLexMark8(const TUint8* aString);
    const TUint8* iPtr;
    friend class TLex8;
    __DECLARE_TEST;
    };
 
 
 
 
class TRealX;
class TLex8
    {
public:
    IMPORT_C TLex8();
    inline TLex8(const TUint8* aString);
    inline TLex8(const TDesC8& aDes);
    inline TLex8& operator=(const TUint8* aString);
    inline TLex8& operator=(const TDesC8& aDes);
    inline TBool Eos() const;
    inline void Mark(TLexMark8& aMark) const;
    inline void Mark();
    IMPORT_C void Inc();
    IMPORT_C void Inc(TInt aNumber);
    IMPORT_C TChar Get();
    IMPORT_C TChar Peek() const;
    IMPORT_C void UnGet();
    inline void UnGetToMark();
    IMPORT_C void UnGetToMark(const TLexMark8 aMark);
    IMPORT_C void SkipSpace();
    inline void SkipAndMark(TInt aNumber);
    IMPORT_C void SkipAndMark(TInt aNumber, TLexMark8& aMark);
    inline void SkipSpaceAndMark();
    IMPORT_C void SkipSpaceAndMark(TLexMark8& aMark);
    IMPORT_C void SkipCharacters();
    inline TInt TokenLength() const;
    IMPORT_C TInt TokenLength(const TLexMark8 aMark) const;
    IMPORT_C TPtrC8 MarkedToken() const;
    IMPORT_C TPtrC8 MarkedToken(const TLexMark8 aMark) const;
    IMPORT_C TPtrC8 NextToken();
    IMPORT_C TPtrC8 Remainder() const;
    IMPORT_C TPtrC8 RemainderFromMark() const;
    IMPORT_C TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
    IMPORT_C TInt Offset() const;
    inline TInt MarkedOffset() const;
    IMPORT_C TInt MarkedOffset(const TLexMark8 aMark) const;
    IMPORT_C TInt Val(TInt8& aVal);
    IMPORT_C TInt Val(TInt16& aVal);
    IMPORT_C TInt Val(TInt32& aVal);
    IMPORT_C TInt Val(TInt64& aVal);
    inline TInt Val(TInt& aVal);
    IMPORT_C TInt Val(TUint8& aVal,TRadix aRadix);
    IMPORT_C TInt Val(TUint16& aVal,TRadix aRadix);
    IMPORT_C TInt Val(TUint32& aVal,TRadix aRadix);
    IMPORT_C TInt Val(TInt64& aVal, TRadix aRadix);
    inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
    IMPORT_C TInt BoundedVal(TInt32& aVal,TInt aLimit);
    IMPORT_C TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
    IMPORT_C TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
    IMPORT_C TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
    IMPORT_C TInt Val(TReal32& aVal);
    IMPORT_C TInt Val(TReal32& aVal,TChar aPoint);
    IMPORT_C TInt Val(TReal64& aVal);
    IMPORT_C TInt Val(TReal64& aVal,TChar aPoint);
    inline void Assign(const TLex8& aLex);
    IMPORT_C void Assign(const TUint8* aString);
    IMPORT_C void Assign(const TDesC8& aDes);
    TInt Val(TRealX& aVal);
    TInt Val(TRealX& aVal, TChar aPoint);
 
    inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
 
    inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
 
    inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
 
    inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
private:
    void Scndig(TInt& aSig, TInt& aExp, TUint64& aDl);
    void ScndigAfterPoint(TInt& aSig, TUint64& aDl);
    void ValidateMark(const TLexMark8 aMark) const;
private:
    const TUint8* iNext;
    const TUint8* iBuf;
    const TUint8* iEnd;
    TLexMark8 iMark;
    __DECLARE_TEST;
    };
 
 
 
 
class TLexMark16
    {
public:
    inline TLexMark16();
private:
    inline TLexMark16(const TUint16* aString);
    const TUint16* iPtr;
    friend class TLex16;    
    __DECLARE_TEST;
    };
 
 
 
 
class TLex16
    {
public:
    IMPORT_C TLex16();
    inline TLex16(const TUint16* aString);
    inline TLex16(const TDesC16& aDes);
    inline TLex16& operator=(const TUint16* aString);
    inline TLex16& operator=(const TDesC16& aDes);
    inline TBool Eos() const;
    inline void Mark();
    inline void Mark(TLexMark16& aMark) const;
    IMPORT_C void Inc();
    IMPORT_C void Inc(TInt aNumber);
    IMPORT_C TChar Get();
    IMPORT_C TChar Peek() const;
    IMPORT_C void UnGet();
    inline void UnGetToMark();
    IMPORT_C void UnGetToMark(const TLexMark16 aMark);
    IMPORT_C void SkipSpace();
    inline void SkipAndMark(TInt aNumber);
    IMPORT_C void SkipAndMark(TInt aNumber, TLexMark16& aMark);
    IMPORT_C void SkipSpaceAndMark(TLexMark16& aMark);
    inline void SkipSpaceAndMark();
    IMPORT_C void SkipCharacters();
    inline TInt TokenLength() const;
    IMPORT_C TInt TokenLength(const TLexMark16 aMark) const;
    IMPORT_C TPtrC16 MarkedToken() const;
    IMPORT_C TPtrC16 MarkedToken(const TLexMark16 aMark) const;
    IMPORT_C TPtrC16 NextToken();
    IMPORT_C TPtrC16 Remainder() const;
    IMPORT_C TPtrC16 RemainderFromMark() const;
    IMPORT_C TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
    IMPORT_C TInt Offset() const;
    inline TInt MarkedOffset() const;
    IMPORT_C TInt MarkedOffset(const TLexMark16 aMark) const;
    IMPORT_C TInt Val(TInt8& aVal);
    IMPORT_C TInt Val(TInt16& aVal);
    IMPORT_C TInt Val(TInt32& aVal);
    IMPORT_C TInt Val(TInt64& aVal);
    inline TInt Val(TInt& aVal);
    IMPORT_C TInt Val(TUint8& aVal,TRadix aRadix);
    IMPORT_C TInt Val(TUint16& aVal,TRadix aRadix);
    IMPORT_C TInt Val(TUint32& aVal,TRadix aRadix);
    IMPORT_C TInt Val(TInt64& aVal, TRadix aRadix);
//  inline TInt Val(TInt64& aVal, TRadix aRadix) {return Val(aVal,aRadix);}
    inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
    IMPORT_C TInt BoundedVal(TInt32& aVal,TInt aLimit);
    IMPORT_C TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
    IMPORT_C TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
    IMPORT_C TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
    IMPORT_C TInt Val(TReal32& aVal);
    IMPORT_C TInt Val(TReal32& aVal,TChar aPoint);
    IMPORT_C TInt Val(TReal64& aVal);
    IMPORT_C TInt Val(TReal64& aVal,TChar aPoint);
    inline void Assign(const TLex16& aLex);
    IMPORT_C void Assign(const TUint16* aString);
    IMPORT_C void Assign(const TDesC16& aDes);      
    TInt Val(TRealX& aVal);
    TInt Val(TRealX& aVal, TChar aPoint);
 
    inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
 
    inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
 
    inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
 
    inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
private:
    void Scndig(TInt& aSig, TInt& aExp, TUint64& aDl);
    void ValidateMark(const TLexMark16 aMark) const;
private:
    const TUint16* iNext;
    const TUint16* iBuf;
    const TUint16* iEnd;
    TLexMark16 iMark;
    __DECLARE_TEST;
    };
 
 
 
 
#if defined(_UNICODE)
typedef TLex16 TLex;
 
 
 
 
typedef TLexMark16 TLexMark;
 
 
 
 
#else
 
 
 
typedef TLex8 TLex;
 
 
 
 
typedef TLexMark8 TLexMark;
#endif
 
 
 
 
class TCheckedUid
    {
public:
    IMPORT_C TCheckedUid();
    IMPORT_C TCheckedUid(const TUidType& aUidType);
    IMPORT_C TCheckedUid(const TDesC8& aPtr);
    IMPORT_C void Set(const TUidType& aUidType);
    IMPORT_C void Set(const TDesC8& aPtr);
    IMPORT_C TPtrC8 Des() const;
    inline const TUidType& UidType() const;
protected:
    IMPORT_C TUint Check() const;
private:
    TUidType iType;
    TUint iCheck;
    };
 
 
 
 
class TDateTime
    {
public:
    inline TDateTime();
    IMPORT_C TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
    IMPORT_C TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
    IMPORT_C TInt SetYear(TInt aYear);
    IMPORT_C TInt SetYearLeapCheck(TInt aYear);
    IMPORT_C TInt SetMonth(TMonth aMonth);
    IMPORT_C TInt SetDay(TInt aDay);
    IMPORT_C TInt SetHour(TInt aHour);
    IMPORT_C TInt SetMinute(TInt aMinute);
    IMPORT_C TInt SetSecond(TInt aSecond);
    IMPORT_C TInt SetMicroSecond(TInt aMicroSecond);
    inline TInt Year() const;
    inline TMonth Month() const;
    inline TInt Day() const;
    inline TInt Hour() const;
    inline TInt Minute() const;
    inline TInt Second() const;
    inline TInt MicroSecond() const;
private:
    TInt iYear;
    TMonth iMonth;
    TInt iDay;
    TInt iHour;
    TInt iMinute;
    TInt iSecond;
    TInt iMicroSecond;
    };
 
 
 
 
class TTimeIntervalMicroSeconds
    {
public:
    inline TTimeIntervalMicroSeconds();
    inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
    inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
    inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
    inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
    inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
    inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
    inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
    inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
    inline const TInt64& Int64() const;
private:
    TInt64 iInterval;
    };
 
 
 
 
class TTimeIntervalBase
    {
public:
    inline TBool operator==(TTimeIntervalBase aInterval) const;
    inline TBool operator!=(TTimeIntervalBase aInterval) const;
    inline TBool operator>=(TTimeIntervalBase aInterval) const;
    inline TBool operator<=(TTimeIntervalBase aInterval) const;
    inline TBool operator>(TTimeIntervalBase aInterval) const;
    inline TBool operator<(TTimeIntervalBase aInterval) const;
    inline TInt Int() const;
protected:
    inline TTimeIntervalBase();
    inline TTimeIntervalBase(TInt aInterval);
protected:
    TInt iInterval;
    };
 
 
 
 
class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
    {
public:
    inline TTimeIntervalMicroSeconds32();
    inline TTimeIntervalMicroSeconds32(TInt aInterval);
    inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
    };
 
 
 
 
class TTimeIntervalSeconds : public TTimeIntervalBase
    {
public:
    inline TTimeIntervalSeconds();
    inline TTimeIntervalSeconds(TInt aInterval);
    inline TTimeIntervalSeconds& operator=(TInt aInterval);
    };
 
 
 
 
class TTimeIntervalMinutes : public TTimeIntervalBase
    {
public:
    inline TTimeIntervalMinutes();
    inline TTimeIntervalMinutes(TInt aInterval);
    inline TTimeIntervalMinutes& operator=(TInt aInterval);
    };
 
 
 
 
class TTimeIntervalHours : public TTimeIntervalBase
    {
public:
    inline TTimeIntervalHours();
    inline TTimeIntervalHours(TInt aInterval);
    inline TTimeIntervalHours& operator=(TInt aInterval);
    };
 
 
 
 
class TTimeIntervalDays : public TTimeIntervalBase
    {
public:
    inline TTimeIntervalDays();
    inline TTimeIntervalDays(TInt aInterval);
    inline TTimeIntervalDays& operator=(TInt aInterval);
    };
 
 
 
 
class TTimeIntervalMonths : public TTimeIntervalBase
    {
public:
    inline TTimeIntervalMonths();
    inline TTimeIntervalMonths(TInt aInterval);
    inline TTimeIntervalMonths& operator=(TInt aInterval);
    };
 
 
 
 
class TTimeIntervalYears : public TTimeIntervalBase
    {
public:
    inline TTimeIntervalYears();
    inline TTimeIntervalYears(TInt aInterval);
    inline TTimeIntervalYears& operator=(TInt aInterval);
    };
    
    
    
enum {
     EParseTimePresent=0x1,
     EParseDatePresent=0x2
     };
 
 
 
class TLocale;
class TTime
    {
public:
    inline TTime();
    inline TTime(const TInt64& aTime);
    IMPORT_C TTime(const TDesC& aString);
    IMPORT_C TTime(const TDateTime& aDateTime);
    inline TTime& operator=(const TInt64& aTime);
    IMPORT_C TTime& operator=(const TDateTime& aDateTime);
    IMPORT_C void HomeTime();
    IMPORT_C void UniversalTime();
    IMPORT_C TInt Set(const TDesC& aString);
    IMPORT_C TInt HomeTimeSecure();
    IMPORT_C TInt UniversalTimeSecure();
 
    IMPORT_C TDateTime DateTime() const;
    IMPORT_C TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;
    IMPORT_C TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;
    IMPORT_C TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;
    IMPORT_C TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;
    IMPORT_C TTimeIntervalDays DaysFrom(TTime aTime) const;
    IMPORT_C TTimeIntervalMonths MonthsFrom(TTime aTime) const;
    IMPORT_C TTimeIntervalYears YearsFrom(TTime aTime) const;
 
    IMPORT_C TInt DaysInMonth() const;
    IMPORT_C TDay DayNoInWeek() const;
    IMPORT_C TInt DayNoInMonth() const;
    IMPORT_C TInt DayNoInYear() const;
    IMPORT_C TInt DayNoInYear(TTime aStartDate) const;
    IMPORT_C TInt WeekNoInYear() const;
    IMPORT_C TInt WeekNoInYear(TTime aStartDate) const;
    IMPORT_C TInt WeekNoInYear(TFirstWeekRule aRule) const;
    IMPORT_C TInt WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const;
    IMPORT_C void FormatL(TDes& aDes,const TDesC& aFormat) const;
    IMPORT_C void FormatL(TDes& aDes,const TDesC& aFormat,const TLocale& aLocale) const;
    IMPORT_C void RoundUpToNextMinute();
    IMPORT_C TInt Parse(const TDesC& aDes,TInt aCenturyOffset=0);
 
    IMPORT_C TTime operator+(TTimeIntervalYears aYear) const;
    IMPORT_C TTime operator+(TTimeIntervalMonths aMonth) const;
    IMPORT_C TTime operator+(TTimeIntervalDays aDay) const;
    IMPORT_C TTime operator+(TTimeIntervalHours aHour) const;
    IMPORT_C TTime operator+(TTimeIntervalMinutes aMinute) const;
    IMPORT_C TTime operator+(TTimeIntervalSeconds aSecond) const;   
    IMPORT_C TTime operator+(TTimeIntervalMicroSeconds aMicroSecond) const;
    IMPORT_C TTime operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const;
    IMPORT_C TTime operator-(TTimeIntervalYears aYear) const;
    IMPORT_C TTime operator-(TTimeIntervalMonths aMonth) const;
    IMPORT_C TTime operator-(TTimeIntervalDays aDay) const;
    IMPORT_C TTime operator-(TTimeIntervalHours aHour) const;
    IMPORT_C TTime operator-(TTimeIntervalMinutes aMinute) const;
    IMPORT_C TTime operator-(TTimeIntervalSeconds aSecond) const;   
    IMPORT_C TTime operator-(TTimeIntervalMicroSeconds aMicroSecond) const;
    IMPORT_C TTime operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const;
    IMPORT_C TTime& operator+=(TTimeIntervalYears aYear);
    IMPORT_C TTime& operator+=(TTimeIntervalMonths aMonth);
    IMPORT_C TTime& operator+=(TTimeIntervalDays aDay);
    IMPORT_C TTime& operator+=(TTimeIntervalHours aHour);
    IMPORT_C TTime& operator+=(TTimeIntervalMinutes aMinute);
    IMPORT_C TTime& operator+=(TTimeIntervalSeconds aSecond);   
    IMPORT_C TTime& operator+=(TTimeIntervalMicroSeconds aMicroSecond);
    IMPORT_C TTime& operator+=(TTimeIntervalMicroSeconds32 aMicroSecond);
    IMPORT_C TTime& operator-=(TTimeIntervalYears aYear);
    IMPORT_C TTime& operator-=(TTimeIntervalMonths aMonth);
    IMPORT_C TTime& operator-=(TTimeIntervalDays aDay);
    IMPORT_C TTime& operator-=(TTimeIntervalHours aHour);
    IMPORT_C TTime& operator-=(TTimeIntervalMinutes aMinute);
    IMPORT_C TTime& operator-=(TTimeIntervalSeconds aSecond);   
    IMPORT_C TTime& operator-=(TTimeIntervalMicroSeconds aMicroSecond);
    IMPORT_C TTime& operator-=(TTimeIntervalMicroSeconds32 aMicroSecond);
    inline TBool operator==(TTime aTime) const;
    inline TBool operator!=(TTime aTime) const;
    inline TBool operator>=(TTime aTime) const;
    inline TBool operator<=(TTime aTime) const;
    inline TBool operator>(TTime aTime) const;
    inline TBool operator<(TTime aTime) const;
    inline const TInt64& Int64() const;
private:
    static TTime Convert(const TDateTime& aDateTime);
private:
    TInt64 iTime;
    __DECLARE_TEST;
    };
 
 
 
 
class Time
    {
public:
    IMPORT_C static TTime NullTTime();
    IMPORT_C static TTime MaxTTime();
    IMPORT_C static TTime MinTTime();
    IMPORT_C static TInt DaysInMonth(TInt aYear, TMonth aMonth);
    IMPORT_C static TBool IsLeapYear(TInt aYear);
    IMPORT_C static TInt LeapYearsUpTo(TInt aYear);
    };
 
 
 
 
class TDayName : public TBuf<KMaxDayName>
    {
public:
    IMPORT_C TDayName();
    IMPORT_C TDayName(TDay aDay);
    IMPORT_C void Set(TDay aDay);
    };
 
 
 
 
class TDayNameAbb : public TBuf<KMaxDayNameAbb>
    {
public:
    IMPORT_C TDayNameAbb();
    IMPORT_C TDayNameAbb(TDay aDay);
    IMPORT_C void Set(TDay aDay);
    };
 
 
 
 
class TMonthName : public TBuf<KMaxMonthName>
    {
public:
    IMPORT_C TMonthName();
    IMPORT_C TMonthName(TMonth aMonth);
    IMPORT_C void Set(TMonth aMonth);
    };
 
 
 
 
class TMonthNameAbb : public TBuf<KMaxMonthNameAbb>
    {
public:
    IMPORT_C TMonthNameAbb();
    IMPORT_C TMonthNameAbb(TMonth aMonth);
    IMPORT_C void Set(TMonth aMonth);
    };
 
 
 
 
class TDateSuffix : public TBuf<KMaxSuffix>
    {
public:
    IMPORT_C TDateSuffix();
    IMPORT_C TDateSuffix(TInt aDateSuffix);
    IMPORT_C void Set(TInt aDateSuffix);
    };
 
 
 
 
class TAmPmName : public TBuf<KMaxAmPmName>
    {
public:
    IMPORT_C TAmPmName();
    IMPORT_C TAmPmName(TAmPm aSelector);
    IMPORT_C void Set(TAmPm aSelector);
    };
 
 
 
 
class TCurrencySymbol : public TBuf<KMaxCurrencySymbol>
    {
public:
    IMPORT_C TCurrencySymbol();
    IMPORT_C void Set();
    };
 
 
 
 
class TShortDateFormatSpec : public TBuf<KMaxShortDateFormatSpec> // to be passed into TTime::FormatL
    {
public:
    IMPORT_C TShortDateFormatSpec();
    IMPORT_C void Set();
    };
 
 
 
 
class TLongDateFormatSpec : public TBuf<KMaxLongDateFormatSpec> // to be passed into TTime::FormatL
    {
public:
    IMPORT_C TLongDateFormatSpec();
    IMPORT_C void Set();
    };
 
 
 
 
class TTimeFormatSpec : public TBuf<KMaxTimeFormatSpec> // to be passed into TTime::FormatL
    {
public:
    IMPORT_C TTimeFormatSpec();
    IMPORT_C void Set();
    };
 
 
 
 
class TLocale
    {
public:
        
    enum TNegativeCurrencyFormat
        {
        ELeadingMinusSign,
 
        EInBrackets, //this one must be non-zero for binary compatibility with the old TBool TLocale::iCurrencyNegativeInBrackets which was exposed in the binary interface because it was accessed via *inline* functions
            
        ETrailingMinusSign,
        
        EInterveningMinusSign
        };
        
    enum 
        {
        EFlagNegativeLoseSpace = 0x00000001,
        
        EFlagNegativeCurrencySymbolOpposite=0x00000002
        };
    enum TDeviceTimeState
        {
        EDeviceUserTime,
 
        ENITZNetworkTimeSync
        };
public:
    IMPORT_C TLocale();
    inline TLocale(TInt);
    IMPORT_C void Refresh();
    IMPORT_C TInt Set() const;
    IMPORT_C void FormatCurrency(TDes& aText, TInt aAmount);
    IMPORT_C void FormatCurrency(TDes& aText, TInt64 aAmount);
    IMPORT_C void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt aAmount); 
    IMPORT_C void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt64 aAmount); 
    
    inline TInt CountryCode() const;
    inline void SetCountryCode(TInt aCode);
    inline TTimeIntervalSeconds UniversalTimeOffset() const;
    inline TDateFormat DateFormat() const;
    inline void SetDateFormat(TDateFormat aFormat);
    inline TTimeFormat TimeFormat() const;
    inline void SetTimeFormat(TTimeFormat aFormat);
    inline TLocalePos CurrencySymbolPosition() const;
    inline void SetCurrencySymbolPosition(TLocalePos aPos);
    inline TBool CurrencySpaceBetween() const;
    inline void SetCurrencySpaceBetween(TBool aSpace);
    inline TInt CurrencyDecimalPlaces() const;
    inline void SetCurrencyDecimalPlaces(TInt aPlaces);
    inline TBool CurrencyNegativeInBrackets() const;        // These two functions are deprecated
    inline void SetCurrencyNegativeInBrackets(TBool aBool); // They are here to maintain compatibility. Use the New functions -> NegativeCurrencyFormat setter/getter. 
    inline TBool CurrencyTriadsAllowed() const;  
    inline void SetCurrencyTriadsAllowed(TBool aBool);
    inline TChar ThousandsSeparator() const;
    inline void SetThousandsSeparator(const TChar& aChar);
    inline TChar DecimalSeparator() const;
    inline void SetDecimalSeparator(const TChar& aChar);
    inline TChar DateSeparator(TInt aIndex) const;
    inline void SetDateSeparator(const TChar& aChar,TInt aIndex);
    inline TChar TimeSeparator(TInt aIndex) const;
    inline void SetTimeSeparator(const TChar& aChar,TInt aIndex);
    inline TBool AmPmSpaceBetween() const;
    inline void SetAmPmSpaceBetween(TBool aSpace);
    inline TLocalePos AmPmSymbolPosition() const;
    inline void SetAmPmSymbolPosition(TLocalePos aPos);
    inline TUint DaylightSaving() const;
    inline TBool QueryHomeHasDaylightSavingOn() const;
    inline TDaylightSavingZone HomeDaylightSavingZone() const;
    inline TUint WorkDays() const;
    inline void SetWorkDays(TUint aMask);
    inline TDay StartOfWeek() const;
    inline void SetStartOfWeek(TDay aDay);
    inline TClockFormat ClockFormat() const;
    inline void SetClockFormat(TClockFormat aFormat);
    inline TUnitsFormat UnitsGeneral() const;
    inline void SetUnitsGeneral(TUnitsFormat aFormat);
    inline TUnitsFormat UnitsDistanceShort() const;
    inline void SetUnitsDistanceShort(TUnitsFormat aFormat);
    inline TUnitsFormat UnitsDistanceLong() const;
    inline void SetUnitsDistanceLong(TUnitsFormat aFormat);
    inline TNegativeCurrencyFormat NegativeCurrencyFormat() const;
    inline void SetNegativeCurrencyFormat(TNegativeCurrencyFormat aNegativeCurrencyFormat);
    inline TBool NegativeLoseSpace() const;
    inline void SetNegativeLoseSpace(TBool aBool);
    inline TBool NegativeCurrencySymbolOpposite() const;
    inline void SetNegativeCurrencySymbolOpposite(TBool aBool);
    inline TLanguage LanguageDowngrade(TInt aIndex) const;   // 0 <= aIndex < 3
    inline void SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage);
    inline TDigitType DigitType() const;
    inline void SetDigitType(TDigitType aDigitType);
    inline TDeviceTimeState DeviceTime() const;
    inline void SetDeviceTime(TDeviceTimeState aState);
    inline TInt RegionCode() const;
 
    void SetDefaults(); 
private:
    friend class TExtendedLocale;
private:
    TInt iCountryCode;
    TTimeIntervalSeconds iUniversalTimeOffset;
    TDateFormat iDateFormat;
    TTimeFormat iTimeFormat;
    TLocalePos iCurrencySymbolPosition;
    TBool iCurrencySpaceBetween;
    TInt iCurrencyDecimalPlaces;
    TNegativeCurrencyFormat iNegativeCurrencyFormat; // replaced TBool iCurrencyNegativeInBrackets
    TBool iCurrencyTriadsAllowed;
    TChar iThousandsSeparator;
    TChar iDecimalSeparator;
    TChar iDateSeparator[KMaxDateSeparators];
    TChar iTimeSeparator[KMaxTimeSeparators];
    TLocalePos iAmPmSymbolPosition;
    TBool iAmPmSpaceBetween;
    TUint iDaylightSaving;
    TDaylightSavingZone iHomeDaylightSavingZone;
    TUint iWorkDays;
    TDay iStartOfWeek;
    TClockFormat iClockFormat;
    TUnitsFormat iUnitsGeneral;
    TUnitsFormat iUnitsDistanceShort;
    TUnitsFormat iUnitsDistanceLong;
    TUint iExtraNegativeCurrencyFormatFlags;
    TUint16 iLanguageDowngrade[3];
    TUint16 iRegionCode;
    TDigitType iDigitType;
    TDeviceTimeState iDeviceTimeState;
    TInt iSpare[0x1E];
    };
 
enum TLocaleAspect
    {
    ELocaleLanguageSettings = 0x01,
    ELocaleCollateSetting = 0x02,
    ELocaleLocaleSettings = 0x04,
    ELocaleTimeDateSettings = 0x08,
    };
 
struct SLocaleLanguage
    {
    TLanguage       iLanguage;
    const TText*    iDateSuffixTable;
    const TText*    iDayTable;
    const TText*    iDayAbbTable;
    const TText*    iMonthTable;
    const TText*    iMonthAbbTable;
    const TText*    iAmPmTable;
    const TText16* const*   iMsgTable;
    };
 
struct SLocaleLocaleSettings
    {
    TText   iCurrencySymbol[KMaxCurrencySymbol+1];
    TAny*   iLocaleExtraSettingsDllPtr;
    };
 
struct SLocaleTimeDateFormat
    {
    TText   iShortDateFormatSpec[KMaxShortDateFormatSpec+1];
    TText   iLongDateFormatSpec[KMaxLongDateFormatSpec+1];
    TText   iTimeFormatSpec[KMaxTimeFormatSpec+1];
    TAny*   iLocaleTimeDateFormatDllPtr;
    };
 
struct LCharSet;
 
class TExtendedLocale
    {
public:
 
    // Default constructor, create an empty instance
    IMPORT_C TExtendedLocale();
 
    // Initialise to (or restore from!) current system wide locale
    // settings
    IMPORT_C void LoadSystemSettings();
    
    // Overwrite current system wide locale settings with the current
    // contents of this TExtendedLocale
    IMPORT_C TInt SaveSystemSettings();
 
    //load a complete locale data from a single locale dll
    IMPORT_C TInt LoadLocale(const TDesC& aLocaleDllName);
    
    //load a complete locale data from three locale dlls, which are language lcoale dll, region locale dll, and collation locale dll.
    IMPORT_C TInt LoadLocale(const TDesC& aLanguageLocaleDllName, const TDesC& aRegionLocaleDllName, const TDesC& aCollationLocaleDllName); 
    
    // Load an additional Locale DLL and over-ride a selected subset
    // (currently ELocaleLanguageSettings to select an alternative set
    // of language specific text strings, ELocaleCollateSetting to
    // select a new system collation table,
    // ELocaleOverRideMatchCollationTable to locally select an
    // alternative collation order for matching text strings, or
    // ELocaleOverRideSortCollationTable for ordering text strings)
    // of settings with its contents
    IMPORT_C TInt LoadLocaleAspect(TUint aAspectGroup, const TDesC& aLocaleDllName);
    
    //load a locale aspect from a locale dll. 
    //Such as load language locale aspect from locale language dll; 
    //load region locale aspect from locale region dll; 
    //load collation locale aspect from locale collation dll. 
    //There are in all three aspect, which are langauge, region, and collation.
    IMPORT_C TInt LoadLocaleAspect(const TDesC& aLocaleDllName);
 
    // Set the currency Symbol
    IMPORT_C TInt SetCurrencySymbol(const TDesC &aSymbol);
 
    // Get the name of the DLL holding the data for a particular set
    // of Locale properties
    IMPORT_C TInt GetLocaleDllName(TLocaleAspect aLocaleDataSet, TDes& aDllName);
 
    // Get the preferred collation method.
    // Note that some Charsets may contain more than one Collation
    // method (e.g "dictionary" v "phonebook" ordering) so an optional
    // index parameter can be used to select between them
    IMPORT_C TCollationMethod GetPreferredCollationMethod(TInt index = 0) ;
    
    //Get the Currency Symbol
    IMPORT_C TPtrC GetCurrencySymbol();
    
    //Get the Long Date Format
    IMPORT_C TPtrC GetLongDateFormatSpec();
    
    //Get the Short Date Format
    IMPORT_C TPtrC GetShortDateFormatSpec();
    
    //Get the Time Format
    IMPORT_C TPtrC GetTimeFormatSpec();
 
    // Retrieve a reference to the encapsulated TLocale
    inline TLocale* GetLocale();
 
private:
 
    TInt DoLoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList);
    void DoUpdateLanguageSettings(TLibraryFunction* aExportList);
    void DoUpdateLocaleSettings(TLibraryFunction* aExportList);
    void DoUpdateTimeDateFormat(TLibraryFunction* aExportList);
    
#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL    
    void DoUpdateLanguageSettingsV2(TLibraryFunction* aExportList);
    void DoUpdateLocaleSettingsV2(TLibraryFunction* aExportList);       
    TInt CheckLocaleDllName(const TDesC& aLocaleDllName, TInt& languageID);
    void AddExtension(TDes& aFileName, TInt aExtension);    
#endif
 
private:
 
    TLocale                 iLocale;
    SLocaleLanguage         iLanguageSettings;
    SLocaleLocaleSettings   iLocaleExtraSettings;
    SLocaleTimeDateFormat   iLocaleTimeDateFormat;
    const LCharSet*         iDefaultCharSet;
    const LCharSet*         iPreferredCharSet;
    };
 
 
 
 
class TRect
    {
public:
    enum TUninitialized { EUninitialized };
    TRect(TUninitialized) {}
    IMPORT_C TRect();
    IMPORT_C TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
    IMPORT_C TRect(const TPoint& aPointA,const TPoint& aPointB);
    IMPORT_C TRect(const TPoint& aPoint,const TSize& aSize);
    IMPORT_C TRect(const TSize& aSize);
    IMPORT_C TBool operator==(const TRect& aRect) const;
    IMPORT_C TBool operator!=(const TRect& aRect) const;
    IMPORT_C void SetRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
    IMPORT_C void SetRect(const TPoint& aPointTL,const TPoint& aPointBR);
    IMPORT_C void SetRect(const TPoint& aPoint,const TSize& aSize);
    IMPORT_C void Move(TInt aDx,TInt aDy);
    IMPORT_C void Move(const TPoint& aOffset);
    IMPORT_C void Resize(TInt aDx,TInt aDy);
    IMPORT_C void Resize(const TSize& aSize);
    IMPORT_C void Shrink(TInt aDx,TInt aDy);
    IMPORT_C void Shrink(const TSize& aSize);
    IMPORT_C void Grow(TInt aDx,TInt aDy);
    IMPORT_C void Grow(const TSize& aSize);
    IMPORT_C void BoundingRect(const TRect& aRect);
    IMPORT_C TBool IsEmpty() const;
    IMPORT_C TBool Intersects(const TRect& aRect) const;
    IMPORT_C void Intersection(const TRect& aRect);
    IMPORT_C void Normalize();
    IMPORT_C TBool Contains(const TPoint& aPoint) const;
    IMPORT_C TSize Size() const;
    IMPORT_C TInt Width() const;
    IMPORT_C TInt Height() const;
    IMPORT_C TBool IsNormalized() const;
    IMPORT_C TPoint Center() const;
    IMPORT_C void SetSize(const TSize& aSize);
    IMPORT_C void SetWidth(TInt aWidth);
    IMPORT_C void SetHeight(TInt aHeight);
private:
    void Adjust(TInt aDx,TInt aDy);
public:
    TPoint iTl;
    
    TPoint iBr;
    };
 
 
 
 
class TRegion
    {
public:
    inline TInt Count() const;
    inline const TRect* RectangleList() const;
    inline TBool CheckError() const;
    IMPORT_C TBool IsEmpty() const;
    IMPORT_C TRect BoundingRect() const;
    IMPORT_C const TRect& operator[](TInt aIndex) const;
    IMPORT_C void Copy(const TRegion& aRegion);
    IMPORT_C void AddRect(const TRect& aRect);
    IMPORT_C void SubRect(const TRect& aRect,TRegion* aSubtractedRegion=NULL);
    IMPORT_C void Offset(TInt aXoffset,TInt aYoffset);
    IMPORT_C void Offset(const TPoint& aOffset);
    IMPORT_C void Union(const TRegion& aRegion);
    IMPORT_C void Intersection(const TRegion& aRegion,const TRegion& aRegion2);
    IMPORT_C void Intersect(const TRegion& aRegion);
    IMPORT_C void SubRegion(const TRegion& aRegion,TRegion* aSubtractedRegion=NULL);
    IMPORT_C void ClipRect(const TRect& aRect);
    IMPORT_C void Clear();
    IMPORT_C void Tidy();
    IMPORT_C TInt Sort();
    IMPORT_C TInt Sort(const TPoint& aOffset);
    IMPORT_C void ForceError();
    IMPORT_C TBool IsContainedBy(const TRect& aRect) const;
    IMPORT_C TBool Contains(const TPoint& aPoint) const;
    IMPORT_C TBool Intersects(const TRect& aRect) const;    
protected:
    IMPORT_C TRect* RectangleListW();
    IMPORT_C TRegion(TInt aAllocedRects);
    inline TRegion();
    TBool SetListSize(TInt aCount);
    void AppendRect(const TRect& aRect);
    void DeleteRect(TRect* aRect);
    void AppendRegion(TRegion& aRegion);
    void MergeRect(const TRect& aRect, TBool aEnclosed);
    void SubtractRegion(const TRegion &aRegion,TRegion *aSubtractedRegion=NULL);
    void ShrinkRegion();
    TRect* ExpandRegion(TInt aCount);
protected:
    TInt iCount;
    TBool iError;
    TInt iAllocedRects;
protected:
    enum {ERRegionBuf=0x40000000};
    };
 
 
 
 
class RRegion : public TRegion
    {
private:
    enum {EDefaultGranularity=5};
protected:
    IMPORT_C RRegion(TInt aBuf,TInt aGran);
public:
    IMPORT_C RRegion();
    IMPORT_C RRegion(TInt aGran);
    IMPORT_C RRegion(const RRegion& aRegion);
    IMPORT_C RRegion(const TRect& aRect,TInt aGran=EDefaultGranularity);
    IMPORT_C RRegion(TInt aCount,TRect* aRectangleList,TInt aGran=EDefaultGranularity);
    IMPORT_C void Close();
    IMPORT_C void Destroy();
    inline TInt CheckSpare() const;
private:
    TInt iGranularity;
    TRect* iRectangleList;
    friend class TRegion;
    };
 
 
 
 
template <TInt S>
class RRegionBuf : public RRegion
    {
public:
    inline RRegionBuf();
    inline RRegionBuf(const RRegion& aRegion);
    inline RRegionBuf(const RRegionBuf<S>& aRegion);
    inline RRegionBuf(const TRect& aRect);
private:
    TInt8 iRectangleBuf[S*sizeof(TRect)];
    };
 
 
 
 
template <TInt S>
class TRegionFix : public TRegion
    {
public:
    inline TRegionFix();
    inline TRegionFix(const TRect& aRect);
    inline TRegionFix(const TRegionFix<S>& aRegion);
private:
    TInt8 iRectangleBuf[S*sizeof(TRect)];
    };
 
 
 
 
class TFindHandleBase : public TFindHandle
    {
public:
    IMPORT_C TFindHandleBase();
    IMPORT_C TFindHandleBase(const TDesC& aMatch);
    IMPORT_C void Find(const TDesC& aMatch);
protected:
    TInt NextObject(TFullName& aResult,TInt aObjectType);
private:
    
    TFullName iMatch;
    };
 
 
 
 
class TFindSemaphore : public TFindHandleBase
    {
public:
    inline TFindSemaphore();
    inline TFindSemaphore(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
 
class TFindMutex : public TFindHandleBase
    {
public:
    inline TFindMutex();
    inline TFindMutex(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
 
class TFindChunk : public TFindHandleBase
    {
public:
    inline TFindChunk();
    inline TFindChunk(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
 
 
class TFindThread : public TFindHandleBase
    {
public:
    inline TFindThread();
    inline TFindThread(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
 
class TFindProcess : public TFindHandleBase
    {
public:
    inline TFindProcess();
    inline TFindProcess(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
class TFindLogicalDevice : public TFindHandleBase
    {
public:
    inline TFindLogicalDevice();
    inline TFindLogicalDevice(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
class TFindPhysicalDevice : public TFindHandleBase
    {
public:
    inline TFindPhysicalDevice();
    inline TFindPhysicalDevice(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
 
 
class TFindServer : public TFindHandleBase
    {
public:
    inline TFindServer();
    inline TFindServer(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
 
class TFindLibrary : public TFindHandleBase
    {
public:
    inline TFindLibrary();
    inline TFindLibrary(const TDesC& aMatch);
    IMPORT_C TInt Next(TFullName& aResult);
    };
 
 
 
class RDevice : public RHandleBase
    {
public:
    inline TInt Open(const TFindLogicalDevice& aFind,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
    IMPORT_C void GetCaps(TDes8& aDes) const;
    IMPORT_C TBool QueryVersionSupported(const TVersion& aVer) const;
    IMPORT_C TBool IsAvailable(TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* anInfo) const;
    };
 
class RTimer : public RHandleBase
    {
public:
    IMPORT_C TInt CreateLocal();
    IMPORT_C void Cancel();
    IMPORT_C void After(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
    IMPORT_C void AfterTicks(TRequestStatus &aStatus, TInt aTicks);
    IMPORT_C void At(TRequestStatus& aStatus,const TTime& aTime);
    IMPORT_C void AtUTC(TRequestStatus& aStatus,const TTime& aUTCTime);
    IMPORT_C void Lock(TRequestStatus& aStatus,TTimerLockSpec aLock);
    IMPORT_C void Inactivity(TRequestStatus& aStatus, TTimeIntervalSeconds aSeconds);
    IMPORT_C void HighRes(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
    IMPORT_C void AgainHighRes(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
    };
 
 
 
 
class RLibrary : public RHandleBase
    {
public:
    IMPORT_C void Close();
    IMPORT_C TInt Load(const TDesC& aFileName, const TUidType& aType);
    IMPORT_C TInt Load(const TDesC& aFileName, const TDesC& aPath=KNullDesC);
    IMPORT_C TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType);
    IMPORT_C TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType, TUint32 aModuleVersion);
    IMPORT_C TInt LoadRomLibrary(const TDesC& aFileName, const TDesC& aPath);
    IMPORT_C TLibraryFunction Lookup(TInt anOrdinal) const;
    IMPORT_C TUidType Type() const;
    IMPORT_C TFileName FileName() const;
    IMPORT_C TInt GetRamSizes(TInt& aCodeSize, TInt& aConstDataSize);
    IMPORT_C TInt Init(); 
public:
    struct TInfo
        {
        TUint32 iModuleVersion;         
        TUidType iUids;                 
        TSecurityInfo iSecurityInfo;    
        };
 
    struct TInfoV2 : public TInfo
        {
        TUint8 iHardwareFloatingPoint;  
        enum TDebugAttributes
        {
            EDebugAllowed = 1<<0, 
            ETraceAllowed = 1<<1 
        };
        TUint8 iDebugAttributes; 
        TUint8 iSpare[6];
        };
 
    typedef TPckgBuf<TInfo> TInfoBuf;
 
    typedef TPckgBuf<TInfoV2> TInfoBufV2;
 
    enum TRequiredImageHeaderSize
        {
#ifdef __WINS__
        KRequiredImageHeaderSize = KMaxTInt
#else
        KRequiredImageHeaderSize = 9*1024
#endif
        };
 
    IMPORT_C static TInt GetInfoFromHeader(const TDesC8& aHeader, TDes8& aInfoBuf);
 
    struct SInfo
        {
        TUint32 iModuleVersion;
        TUidType iUids;
        SSecurityInfo iS;
        };
 
    typedef TPckgBuf<SInfo> SInfoBuf;
 
    IMPORT_C static TInt GetInfo(const TDesC& aFileName, TDes8& aInfoBuf);
private:
    TInt InitL();
    };
 
 
 
 
class RCriticalSection : private RSemaphore
    {
public:
    IMPORT_C RCriticalSection();
    IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
    IMPORT_C void Close();
    IMPORT_C void Wait();
    IMPORT_C void Signal();
    inline TBool IsBlocked() const;
private:
    TInt iBlocked;
    };
 
 
 
class RMutex : public RHandleBase
    {
public:
    inline TInt Open(const TFindMutex& aFind,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateGlobal(const TDesC& aName,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 Poll();       // acquire the lock if possible, but don't block
    IMPORT_C TInt Wait(TInt aTimeout);  // timeout in microseconds
    IMPORT_C void Signal();
    IMPORT_C TBool IsHeld();
    };
 
 
 
class RCondVar : public RHandleBase
    {
public:
    IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateGlobal(const TDesC& aName, 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 TInt Wait(RMutex& aMutex);
    IMPORT_C TInt TimedWait(RMutex& aMutex, TInt aTimeout); // timeout in microseconds
    IMPORT_C void Signal();
    IMPORT_C void Broadcast();
    };
 
 
 
class UserHeap;
class TChunkCreate;
struct TChunkCreateInfo;
class RChunk : public RHandleBase
    {
public:
    enum TRestrictions
        {
        EPreventAdjust = 0x01,
        };
public:
    inline TInt Open(const TFindChunk& aFind,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateLocal(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateLocalCode(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateGlobal(const TDesC& aName,TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateDoubleEndedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateDoubleEndedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateDisconnectedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt CreateDisconnectedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Create(TChunkCreateInfo& aCreateInfo);
    IMPORT_C TInt SetRestrictions(TUint aFlags);
    IMPORT_C TInt OpenGlobal(const TDesC& aName,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Adjust(TInt aNewSize) const;
    IMPORT_C TInt AdjustDoubleEnded(TInt aBottom, TInt aTop) const;
    IMPORT_C TInt Commit(TInt anOffset, TInt aSize) const;
    IMPORT_C TInt Allocate(TInt aSize) const;
    IMPORT_C TInt Decommit(TInt anOffset, TInt aSize) const;
    IMPORT_C TInt Unlock(TInt aOffset, TInt aSize); 
    IMPORT_C TInt Lock(TInt aOffset, TInt aSize);   
    IMPORT_C TUint8* Base() const;
    IMPORT_C TInt Size() const;
    IMPORT_C TInt Bottom() const;
    IMPORT_C TInt Top() const;
    IMPORT_C TInt MaxSize() const;
    inline TBool IsReadable() const;
    inline TBool IsWritable() const;
    IMPORT_C TBool IsPaged() const;
private:
    friend class UserHeap;
    };
 
 
struct TChunkCreateInfo
    {
public :
    enum TChunkCreateVersions
        {
        EVersion0,
        ESupportedVersions,
        };
 
    friend class RChunk;
 
    enum TChunkPagingAtt
        {
        EUnspecified,   
        EPaged,         
        EUnpaged,       
        };
 
    IMPORT_C TChunkCreateInfo();
    IMPORT_C void SetNormal(TInt aInitialSize, TInt aMaxSize);
    IMPORT_C void SetCode(TInt aInitialSize, TInt aMaxSize);
    IMPORT_C void SetDoubleEnded(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize);
    IMPORT_C void SetDisconnected(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize);
    IMPORT_C void SetOwner(TOwnerType aType);
    IMPORT_C void SetGlobal(const TDesC& aName);
    IMPORT_C void SetClearByte(TUint8 aClearByte);
    IMPORT_C void SetPaging(const TChunkPagingAtt aPaging);
    IMPORT_C void SetReadOnly();
    void SetThreadHeap(TInt aInitialSize, TInt aMaxSize, const TDesC& aName);
 
    IMPORT_C void SetCache(TInt aMaxSize);
protected :
    TUint iVersionNumber;
    TUint iType;
    TBool iGlobal;
    TInt iMaxSize;
    TOwnerType iOwnerType;
    const TDesC* iName;
    TInt iInitialBottom;
    TInt iInitialTop;
    TUint iAttributes;
    TUint8 iClearByte; 
    TUint8 iSpare1[3];
    TUint iSpare2;
    };
 
struct TChunkHeapCreateInfo
    {
public:
    enum TChunkHeapCreateVersions
        {
        EVersion0,
        ESupportedVersions,
        };
 
    enum TChunkHeapPagingAtt
        {
        EUnspecified,   
        EPaged,         
        EUnpaged,       
        };
 
    friend class UserHeap;
 
    IMPORT_C TChunkHeapCreateInfo(TInt aMinLength, TInt aMaxLength);
    IMPORT_C void SetCreateChunk(const TDesC* aName);
    IMPORT_C void SetUseChunk(const RChunk aChunk);
    inline void SetSingleThread(TBool aSingleThread);
    inline void SetAlignment(TInt aAlign);
    inline void SetGrowBy(TInt aGrowBy);
    inline void SetOffset(TInt aOffset);
    inline void SetMode(TUint aMode);
    inline void SetPaging(const TChunkHeapPagingAtt aPaging);
 
protected:
    TUint iVersionNumber;
    TInt iMinLength;
    TInt iMaxLength;
    TInt iAlign;
    TInt iGrowBy;
    TBool iSingleThread;
    TInt iOffset;
    TChunkHeapPagingAtt iPaging;
    TUint iMode;
    TDesC* iName;
    RChunk iChunk;
    TInt iSpare[5];
    };
 
struct SStdEpocThreadCreateInfo;
class UserHeap
    {
public:
    enum TChunkHeapCreateMode
        {
        EChunkHeapSwitchTo  = 0x1,
        EChunkHeapDuplicate = 0x2,
 
        EChunkHeapMask = EChunkHeapSwitchTo | EChunkHeapDuplicate,
        };
    IMPORT_C static RHeap* FixedHeap(TAny* aBase, TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);
    IMPORT_C static RHeap* ChunkHeap(const TDesC* aName, TInt aMinLength, TInt aMaxLength, TInt aGrowBy=1, TInt aAlign=0, TBool aSingleThread=EFalse);
    IMPORT_C static RHeap* ChunkHeap(RChunk aChunk, TInt aMinLength, TInt aGrowBy=1, TInt aMaxLength=0, TInt aAlign=0, TBool aSingleThread=EFalse, TUint32 aMode=0);
    IMPORT_C static RHeap* OffsetChunkHeap(RChunk aChunk, TInt aMinLength, TInt aOffset, TInt aGrowBy=1, TInt aMaxLength=0, TInt aAlign=0, TBool aSingleThread=EFalse, TUint32 aMode=0);
    IMPORT_C static RHeap* ChunkHeap(const TChunkHeapCreateInfo& aCreateInfo);
    IMPORT_C static TInt SetupThreadHeap(TBool aNotFirst, SStdEpocThreadCreateInfo& aInfo);
    IMPORT_C static TInt CreateThreadHeap(SStdEpocThreadCreateInfo& aInfo, RHeap*& aHeap, TInt aAlign=0, TBool aSingleThread=EFalse);
    };
 
 
 
 
class TObjectId
    {
public:
    inline TObjectId();
    inline TObjectId(TUint64 anId);
    inline TUint64 Id() const;
    inline operator TUint() const;
    inline TBool operator==(TObjectId aId) const;
    inline TBool operator!=(TObjectId aId) const;
private:
    TUint64 iId;
    };
 
 
 
 
class TThreadId : public TObjectId
    {
public:
    inline TThreadId();
    inline TThreadId(TUint64 anId);
    };
 
 
 
 
struct TThreadCreateInfo
    {
public :
    enum TThreadCreateVersions
        {
        EVersion0,
        ESupportedVersions,
        };
 
    enum TThreadPagingAtt
        {
        EUnspecified,   
        EPaged,         
        EUnpaged,       
        };
 
    friend class RThread;
 
    IMPORT_C TThreadCreateInfo( const TDesC &aName, TThreadFunction aFunction, 
                                TInt aStackSize, TAny* aPtr);
    IMPORT_C void SetCreateHeap(TInt aHeapMinSize, TInt aHeapMaxSize);
    IMPORT_C void SetUseHeap(const RAllocator* aHeap);
    IMPORT_C void SetOwner(const TOwnerType aOwner);
    IMPORT_C void SetPaging(const TThreadPagingAtt aPaging);
 
protected:
    TUint iVersionNumber;
    const TDesC* iName;
    TThreadFunction iFunction;
    TInt iStackSize;
    TAny* iParameter;
    TOwnerType iOwner;
    RAllocator* iHeap;
    TInt iHeapMinSize;
    TInt iHeapMaxSize;
    TUint iAttributes;
    TUint32 iSpare[6];
    };
 
class RProcess;
 
 
class RThread : public RHandleBase
    {
public:
    inline RThread();
    IMPORT_C TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, TAny *aPtr, TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, RAllocator* aHeap, TAny* aPtr, TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Create(const TThreadCreateInfo& aCreateInfo);
    IMPORT_C TInt Open(const TDesC& aFullName, TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(TThreadId aID, TOwnerType aType=EOwnerProcess);
    IMPORT_C TThreadId Id() const;
    IMPORT_C void Resume() const;
    IMPORT_C void Suspend() const;
    inline static TInt RenameMe(const TDesC& aName);
 
    IMPORT_C void Kill(TInt aReason);
    IMPORT_C void Terminate(TInt aReason);
    IMPORT_C void Panic(const TDesC& aCategory,TInt aReason);
    IMPORT_C TInt Process(RProcess& aProcess) const;
    IMPORT_C TThreadPriority Priority() const;
    IMPORT_C void SetPriority(TThreadPriority aPriority) const;
    IMPORT_C TProcessPriority ProcessPriority() const;
    IMPORT_C void SetProcessPriority(TProcessPriority aPriority) const;
    IMPORT_C TInt RequestCount() const;
    IMPORT_C TExitType ExitType() const;
    IMPORT_C TInt ExitReason() const;
    IMPORT_C TExitCategoryName ExitCategory() const;
    IMPORT_C void RequestComplete(TRequestStatus*& aStatus,TInt aReason) const;
    IMPORT_C void RequestSignal() const;
    IMPORT_C void Logon(TRequestStatus& aStatus) const;
    IMPORT_C TInt LogonCancel(TRequestStatus& aStatus) const;
    IMPORT_C void HandleCount(TInt& aProcessHandleCount, TInt& aThreadHandleCount) const;
    IMPORT_C void Context(TDes8& aDes) const;
    IMPORT_C TInt StackInfo(TThreadStackInfo& aInfo) const;
    IMPORT_C TInt GetCpuTime(TTimeIntervalMicroSeconds& aCpuTime) const;
    inline TInt Open(const TFindThread& aFind,TOwnerType aType=EOwnerProcess);
    IMPORT_C void Rendezvous(TRequestStatus& aStatus) const;
    IMPORT_C TInt RendezvousCancel(TRequestStatus& aStatus) const;
    IMPORT_C static void Rendezvous(TInt aReason);
 
    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 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 aCapability, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
 
    inline TInt Create(const TDesC& aName,TThreadFunction aFunction,TInt aStackSize,TAny* aPtr,RLibrary* aLibrary,RHeap* aHeap, TInt aHeapMinSize,TInt aHeapMaxSize,TOwnerType aType);
 
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 aCapability1, TCapability aCapability2, const char* aDiagnostic) const;
    IMPORT_C TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2) const;
    };
 
inline TInt RThread::Create(const TDesC& /*aName*/,TThreadFunction /*aFunction*/,TInt /*aStackSize*/,TAny* /*aPtr*/,RLibrary* /*aLibrary*/,RHeap* /*aHeap*/, TInt /*aHeapMinSize*/,TInt /*aHeapMaxSize*/,TOwnerType /*aType*/)
    {return KErrNotSupported; }
 
 
 
class TProcessId : public TObjectId
    {
public:
    inline TProcessId();
    inline TProcessId(TUint64 anId);
    };
 
 
 
 
class RSubSessionBase;
 
class RProcess : public RHandleBase
    {
public:
    inline RProcess();
    IMPORT_C TInt Create(const TDesC& aFileName,const TDesC& aCommand,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Create(const TDesC& aFileName,const TDesC& aCommand,const TUidType &aUidType, TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(TProcessId aId,TOwnerType aType=EOwnerProcess);
    IMPORT_C TUidType Type() const;
    IMPORT_C TProcessId Id() const;
    inline static TInt RenameMe(const TDesC& aName);
 
    IMPORT_C void Kill(TInt aReason);
    IMPORT_C void Terminate(TInt aReason);
    IMPORT_C void Panic(const TDesC& aCategory,TInt aReason);
    IMPORT_C void Resume();
    IMPORT_C TFileName FileName() const;
    IMPORT_C TExitType ExitType() const;
    IMPORT_C TInt ExitReason() const;
    IMPORT_C TExitCategoryName ExitCategory() const;
    IMPORT_C TProcessPriority Priority() const;
    IMPORT_C TInt SetPriority(TProcessPriority aPriority) const;
    IMPORT_C TBool JustInTime() const;
    IMPORT_C void SetJustInTime(TBool aBoolean) const; 
    IMPORT_C void Logon(TRequestStatus& aStatus) const;
    IMPORT_C TInt LogonCancel(TRequestStatus& aStatus) const;
    IMPORT_C TInt GetMemoryInfo(TModuleMemoryInfo& aInfo) const;
    inline TInt Open(const TFindProcess& aFind,TOwnerType aType=EOwnerProcess);
    IMPORT_C void Rendezvous(TRequestStatus& aStatus) const;
    IMPORT_C TInt RendezvousCancel(TRequestStatus& aStatus) const;
    IMPORT_C static void Rendezvous(TInt aReason);
    IMPORT_C TBool DefaultDataPaged() 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 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 aCapability, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
 
    IMPORT_C TInt SetParameter(TInt aIndex,  RHandleBase aHandle);
    IMPORT_C TInt SetParameter(TInt aSlot, const RSubSessionBase& aSession);
    IMPORT_C TInt SetParameter(TInt aSlot, const TDesC16& aDes);
    IMPORT_C TInt SetParameter(TInt aSlot, const TDesC8& aDes);
    IMPORT_C TInt SetParameter(TInt aSlot, TInt aData);
    inline RProcess(TInt aHandle);
 
    inline TUid Identity() const { return SecureId(); }
 
    enum TSecureApi { ESecureApiOff, ESecureApiOn, ESecureApiQuery }; // __SECURE_API__ remove this
 
    IMPORT_C TInt SecureApi(TInt aState); // __SECURE_API__ remove this
 
    enum TDataCaging { EDataCagingOff, EDataCagingOn, EDataCagingQuery}; // __DATA_CAGING__ __SECURE_API__ remove this
 
    IMPORT_C TInt DataCaging(TInt aState); // __DATA_CAGING__ __SECURE_API__ remove this
    
 
    IMPORT_C TInt CreateWithStackOverride(const TDesC& aFileName,const TDesC& aCommand, const TUidType &aUidType, TInt aMinStackSize, TOwnerType aType);
 
    IMPORT_C static TAny* ExeExportData(void);
 
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 aCapability1, TCapability aCapability2, const char* aDiagnostic) const;
    IMPORT_C TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2) const;
    };
 
 
 
 
 
 
 
 
 
class RServer2 : public RHandleBase
    {
public:
    IMPORT_C TInt CreateGlobal(const TDesC& aName);
    IMPORT_C TInt CreateGlobal(const TDesC& aName, TInt aMode);
    IMPORT_C TInt CreateGlobal(const TDesC& aName, TInt aMode, TInt aRole, TInt aOpts);
    IMPORT_C void Receive(RMessage2& aMessage,TRequestStatus& aStatus);
    IMPORT_C void Receive(RMessage2& aMessage);
    IMPORT_C void Cancel();
    };
 
 
 
 
class RSessionBase : public RHandleBase
    {
    friend class RSubSessionBase;
public:
    enum TAttachMode {EExplicitAttach,EAutoAttach};
public:
    inline TInt ShareAuto() { return DoShare(EAutoAttach); }
 
 
    inline TInt ShareProtected() { return DoShare(EAutoAttach|KCreateProtectedObject); }
 
 
    IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,const TSecurityPolicy& aServerPolicy,TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
    IMPORT_C TInt Open(TInt aArgumentIndex, const TSecurityPolicy& aServerPolicy, TOwnerType aType=EOwnerProcess);
    inline TInt SetReturnedHandle(TInt aHandleOrError);
    IMPORT_C TInt SetReturnedHandle(TInt aHandleOrError,const TSecurityPolicy& aServerPolicy);
protected:
    inline TInt CreateSession(const TDesC& aServer,const TVersion& aVersion);
    IMPORT_C TInt CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots);
    IMPORT_C TInt CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TIpcSessionType aType,const TSecurityPolicy* aPolicy=0, TRequestStatus* aStatus=0);
    inline TInt CreateSession(RServer2 aServer,const TVersion& aVersion);
    IMPORT_C TInt CreateSession(RServer2 aServer,const TVersion& aVersion,TInt aAsyncMessageSlots);
    IMPORT_C TInt CreateSession(RServer2 aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TIpcSessionType aType,const TSecurityPolicy* aPolicy=0, TRequestStatus* aStatus=0);
    inline static TInt SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle);
 
    inline TInt CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TRequestStatus* aStatus)
        { return CreateSession(aServer, aVersion, aAsyncMessageSlots, EIpcSession_Unsharable, (TSecurityPolicy*)0, aStatus); }
    inline TInt Send(TInt aFunction,const TIpcArgs& aArgs) const;
    inline void SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const;
    inline TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
    inline TInt Send(TInt aFunction) const;
    inline void SendReceive(TInt aFunction,TRequestStatus& aStatus) const;
    inline TInt SendReceive(TInt aFunction) const;
private:
    IMPORT_C TInt DoSend(TInt aFunction,const TIpcArgs* aArgs) const;
    IMPORT_C void DoSendReceive(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus& aStatus) const;
    IMPORT_C TInt DoSendReceive(TInt aFunction,const TIpcArgs* aArgs) const;
    TInt SendAsync(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus* aStatus) const;
    TInt SendSync(TInt aFunction,const TIpcArgs* aArgs) const;
    IMPORT_C TInt DoShare(TInt aAttachMode);
    TInt DoConnect(const TVersion &aVersion,TRequestStatus* aStatus);
    };
 
 
 
 
class RSubSessionBase
    {
public:
    inline TInt SubSessionHandle() const;
protected:
    inline RSubSessionBase();
    IMPORT_C const RSessionBase Session() const;
    inline TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
    inline TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction);
    IMPORT_C TInt CreateAutoCloseSubSession(RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
    IMPORT_C void CloseSubSession(TInt aFunction);
    inline TInt Send(TInt aFunction,const TIpcArgs& aArgs) const;
    inline void SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const;
    inline TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
    inline TInt Send(TInt aFunction) const;
    inline void SendReceive(TInt aFunction,TRequestStatus& aStatus) const;
    inline TInt SendReceive(TInt aFunction) const;
private:
    IMPORT_C TInt DoCreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs* aArgs);
    IMPORT_C TInt DoSend(TInt aFunction,const TIpcArgs* aArgs) const;
    IMPORT_C void DoSendReceive(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus& aStatus) const;
    IMPORT_C TInt DoSendReceive(TInt aFunction,const TIpcArgs* aArgs) const;
    TInt DoCreateSubSession(RSessionBase& aSession,TInt aFunction,const TIpcArgs* aArgs, TBool aAutoClose);
private:
    RSessionBase iSession;
    TInt iSubSessionHandle;
    };
 
 
 
 
class RRefBase
    {
public:
    IMPORT_C void Free();
protected:
    inline RRefBase();
    inline RRefBase(const RRefBase& aRef);
    IMPORT_C void DoAlloc(const TAny* aPtr,TInt aSize);
    IMPORT_C void DoAllocL(const TAny* aPtr,TInt aSize);
    IMPORT_C void Copy(const RRefBase& aRef);
private:
    IMPORT_C void operator=(const RRefBase& aRef);
protected:
    TInt* iPtr;
    };
 
 
 
 
template <class T>
class RRef : public RRefBase
    {
public:
    inline RRef();
    inline RRef(const RRef<T>& anObject);
    inline void operator=(const RRef<T>& anObject);
    inline T* operator->();
    inline operator T*();
    inline void Alloc(const T& anObject);
    inline void Alloc(const T& anObject,TInt aSize);
    inline void AllocL(const T& anObject);
    inline void AllocL(const T& anObject,TInt aSize);
    };
 
 
 
 
class RChangeNotifier : public RHandleBase
    {
public:
    IMPORT_C TInt Create();
    IMPORT_C TInt Logon(TRequestStatus& aStatus) const;
    IMPORT_C TInt LogonCancel() const;
    };
 
 
 
 
class RUndertaker : public RHandleBase
    {
public:
    IMPORT_C TInt Create();
    IMPORT_C TInt Logon(TRequestStatus& aStatus,TInt& aThreadHandle) const;
    IMPORT_C TInt LogonCancel() const;
    };
 
 
 
 
 
class HBufC16;
class RNotifier : public RSessionBase
    {
public:
    IMPORT_C RNotifier();
    IMPORT_C TInt Connect();
    IMPORT_C void Close();
    IMPORT_C TInt StartNotifier(TUid aNotifierUid,const TDesC8& aBuffer);
    IMPORT_C TInt StartNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
    IMPORT_C TInt StartNotifier(TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
    IMPORT_C TInt CancelNotifier(TUid aNotifierUid);
    IMPORT_C TInt UpdateNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
    IMPORT_C void UpdateNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
    IMPORT_C void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
    IMPORT_C void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
    IMPORT_C TInt UnloadNotifiers(TUid aNotifierUid);
    IMPORT_C TInt LoadNotifiers(TUid aNotifierUid);
    IMPORT_C void Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aBut1,const TDesC& aBut2,TInt& aButtonVal,TRequestStatus& aStatus);
    IMPORT_C void NotifyCancel();
    IMPORT_C TInt InfoPrint(const TDesC& aDes);
private:
    TPtr8 iButtonVal;
    HBufC16* iCombinedBuffer;
    };
 
class TTrapHandler
    {
public:
    IMPORT_C TTrapHandler();
    
    IMPORT_C virtual void Trap()=0;
    
    IMPORT_C virtual void UnTrap()=0;
    
    IMPORT_C virtual void Leave(TInt aValue)=0;
    };
 
 
 
 
struct TCollationMethod; // forward declaration
 
 
 
 
class Mem
    {
public:
    inline static TUint8* Copy(TAny* aTrg, const TAny* aSrc, TInt aLength);
    inline static TUint8* Move(TAny* aTrg, const TAny* aSrc, TInt aLength);
    inline static void Fill(TAny* aTrg, TInt aLength, TChar aChar);
    inline static void FillZ(TAny* aTrg, TInt aLength);
#ifndef __GCC32__
    inline static TInt Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
#else
    IMPORT_C static TInt Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
#endif
 
    IMPORT_C static TInt Compare(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
    IMPORT_C static TInt CompareF(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
    IMPORT_C static TInt CompareF(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
    IMPORT_C static TInt CompareC(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
    IMPORT_C static TInt CompareC(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
    IMPORT_C static TInt CompareC(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL,
                                  TInt aMaxLevel, const TCollationMethod* aCollationMethod);
    IMPORT_C static TInt CollationMethods();
    IMPORT_C static TUint CollationMethodId(TInt aIndex);
    IMPORT_C static const TCollationMethod* CollationMethodByIndex(TInt aIndex);
    IMPORT_C static const TCollationMethod* CollationMethodById(TUint aId);
    IMPORT_C static const TCollationMethod* GetDefaultMatchingTable();
    IMPORT_C static void Swap(TAny* aPtr1, TAny* aPtr2, TInt aLength);
    IMPORT_C static void Crc(TUint16& aCrc, const TAny* aPtr, TInt aLength);
    IMPORT_C static void Crc32(TUint32& aCrc, const TAny* aPtr, TInt aLength);
    };
 
 
 
 
 
class User : public UserHeap
    {
public:
    // Execution control
    IMPORT_C static void InitProcess();         
    IMPORT_C static void Exit(TInt aReason);
    IMPORT_C static void Panic(const TDesC& aCategory,TInt aReason);
    IMPORT_C static void HandleException(TAny* aInfo);  
    // Cleanup support
    IMPORT_C static void Leave(TInt aReason);
    IMPORT_C static void LeaveNoMemory();
    IMPORT_C static TInt LeaveIfError(TInt aReason);
    IMPORT_C static TAny* LeaveIfNull(TAny* aPtr);
    inline static const TAny* LeaveIfNull(const TAny* aPtr);
    IMPORT_C static TTrapHandler* SetTrapHandler(TTrapHandler* aHandler);
    IMPORT_C static TTrapHandler* TrapHandler();
    IMPORT_C static TTrapHandler* MarkCleanupStack();   
    IMPORT_C static void UnMarkCleanupStack(TTrapHandler* aHandler);   
    IMPORT_C static void LeaveEnd();    
    // Infoprint
    IMPORT_C static TInt InfoPrint(const TDesC& aDes);
    // Asynchronous service support
    IMPORT_C static void RequestComplete(TRequestStatus*& aStatus,TInt aReason);
    IMPORT_C static void WaitForAnyRequest();
    IMPORT_C static void WaitForRequest(TRequestStatus& aStatus); 
    IMPORT_C static void WaitForRequest(TRequestStatus& aStatus1,TRequestStatus& aStatus2);
    IMPORT_C static void WaitForNRequest(TRequestStatus *aStatusArray[], TInt aNum);
    // User heap management
    IMPORT_C static TInt AllocLen(const TAny* aCell); 
    IMPORT_C static TAny* Alloc(TInt aSize);
    IMPORT_C static TAny* AllocL(TInt aSize); 
    IMPORT_C static TAny* AllocLC(TInt aSize);
    IMPORT_C static TAny* AllocZ(TInt aSize);
    IMPORT_C static TAny* AllocZL(TInt aSize); 
    IMPORT_C static TInt AllocSize(TInt& aTotalAllocSize); 
    IMPORT_C static TInt Available(TInt& aBiggestBlock); 
    IMPORT_C static TInt CountAllocCells();
    IMPORT_C static TInt CountAllocCells(TInt& aFreeCount); 
    IMPORT_C static void Free(TAny* aCell);
    IMPORT_C static void FreeZ(TAny*& aCell); 
    IMPORT_C static RAllocator& Allocator();
    inline static RHeap& Heap();
    IMPORT_C static TAny* ReAlloc(TAny* aCell, TInt aSize, TInt aMode=0);
    IMPORT_C static TAny* ReAllocL(TAny* aCell, TInt aSize, TInt aMode=0);
    IMPORT_C static RAllocator* SwitchAllocator(RAllocator* aAllocator);
    inline static RHeap* SwitchHeap(RAllocator* aHeap);
    IMPORT_C static TInt CompressAllHeaps();
    // Synchronous timer services
    IMPORT_C static void After(TTimeIntervalMicroSeconds32 aInterval);
    IMPORT_C static TInt At(const TTime& aTime);
    IMPORT_C static void AfterHighRes(TTimeIntervalMicroSeconds32 aInterval);
    // Set time and deal with timezones
    IMPORT_C static TInt SetHomeTime(const TTime& aTime);
    IMPORT_C static TInt SetHomeTimeSecure(const TTime& aTime);
    IMPORT_C static TInt SetUTCTime(const TTime& aUTCTime);
    IMPORT_C static TInt SetUTCTimeSecure(const TTime& aUTCTime);
    IMPORT_C static TTimeIntervalSeconds UTCOffset();
    IMPORT_C static void SetUTCOffset(TTimeIntervalSeconds aOffset);
    IMPORT_C static TInt SetUTCTimeAndOffset(const TTime& aUTCTime, TTimeIntervalSeconds aOffset);
    // Set locale information
    IMPORT_C static TInt SetCurrencySymbol(const TDesC& aSymbol);
    // Set floating point mode
    IMPORT_C static TInt SetFloatingPointMode(TFloatingPointMode aMode, TFloatingPointRoundingMode aRoundingMode=EFpRoundToNearest);
    // Timers
    IMPORT_C static TUint TickCount();
    IMPORT_C static TUint32 NTickCount();
    IMPORT_C static TTimerLockSpec LockPeriod();
    IMPORT_C static TTimeIntervalSeconds InactivityTime();
    IMPORT_C static void ResetInactivityTime();
    IMPORT_C static TUint32 FastCounter();
    // Atomic operations
    IMPORT_C static TInt LockedInc(TInt& aValue);
    IMPORT_C static TInt LockedDec(TInt& aValue);
    IMPORT_C static TInt SafeInc(TInt& aValue);
    IMPORT_C static TInt SafeDec(TInt& aValue);
    // Beep
    IMPORT_C static TInt Beep(TInt aFrequency,TTimeIntervalMicroSeconds32 aDuration); 
    // Information
    IMPORT_C static TInt IsRomAddress(TBool& aBool,TAny* aPtr);
    // Algorithms
    IMPORT_C static TInt BinarySearch(TInt aCount,const TKey& aKey,TInt& aPos);
    IMPORT_C static TInt QuickSort(TInt aCount,const TKey& aKey,const TSwap& aSwap);
    // Language-dependent character functions 
    IMPORT_C static TLanguage Language();
    IMPORT_C static TRegionCode RegionCode();
    IMPORT_C static TUint Collate(TUint aChar); 
    IMPORT_C static TUint Fold(TUint aChar); 
    IMPORT_C static TUint LowerCase(TUint aChar); 
    IMPORT_C static TUint UpperCase(TUint aChar); 
    IMPORT_C static TUint Fold(TUint aChar,TInt aFlags);
    IMPORT_C static TUint TitleCase(TUint aChar);
    // C-style string length
    IMPORT_C static TInt StringLength(const TUint8* aString); 
    IMPORT_C static TInt StringLength(const TUint16* aString);
    // Device management
    IMPORT_C static TInt FreeLogicalDevice(const TDesC& aDeviceName); 
    IMPORT_C static TInt FreePhysicalDevice(const TDesC& aDriverName); 
    IMPORT_C static TInt LoadLogicalDevice(const TDesC& aFileName); 
    IMPORT_C static TInt LoadPhysicalDevice(const TDesC& aFileName); 
    // Version information
    IMPORT_C static TBool QueryVersionSupported(const TVersion& aCurrent,const TVersion& aRequested);
    IMPORT_C static TVersion Version();
    // Machine configuration
    IMPORT_C static TInt SetMachineConfiguration(const TDesC8& aConfig);
    IMPORT_C static TInt MachineConfiguration(TDes8& aConfig,TInt& aSize);
    // Debugging support
    IMPORT_C static void SetDebugMask(TUint32 aVal);
    IMPORT_C static void SetDebugMask(TUint32 aVal, TUint aIndex);
    IMPORT_C static void SetJustInTime(const TBool aBoolean); 
    IMPORT_C static void Check();
    IMPORT_C static void Invariant();
    IMPORT_C static TBool JustInTime();
    IMPORT_C static void __DbgMarkStart(TBool aKernel);
    IMPORT_C static void __DbgMarkCheck(TBool aKernel, TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum);
    IMPORT_C static TUint32 __DbgMarkEnd(TBool aKernel, TInt aCount);
    IMPORT_C static void __DbgSetAllocFail(TBool aKernel, RAllocator::TAllocFail aFail, TInt aRate);
    IMPORT_C static RAllocator::TAllocFail __DbgGetAllocFail(TBool aKernel);
    IMPORT_C static void __DbgSetBurstAllocFail(TBool aKernel, RAllocator::TAllocFail aFail, TUint aRate, TUint aBurst);
    IMPORT_C static TUint __DbgCheckFailure(TBool aKernel);
    IMPORT_C static void PanicUnexpectedLeave(); 
    // Name Validation
    IMPORT_C static TInt ValidateName(const TDesC& aName);
    // Instruction Memory Barrier
    IMPORT_C static void IMB_Range(TAny* aStart, TAny* aEnd);
    //
    IMPORT_C static TInt CommandLineLength();
    IMPORT_C static void CommandLine(TDes &aCommand);
    IMPORT_C static TExceptionHandler ExceptionHandler();
    IMPORT_C static TInt SetExceptionHandler(TExceptionHandler aHandler,TUint32 aMask);
    IMPORT_C static void ModifyExceptionMask(TUint32 aClearMask, TUint32 aSetMask);
    IMPORT_C static TInt RaiseException(TExcType aType);
    IMPORT_C static TBool IsExceptionHandled(TExcType aType);
 
    enum TCritical {
    
    
                   ENotCritical, 
                   
                                      
                   EProcessCritical,
 
                   
                   EProcessPermanent,
                   
                   
                   EAllThreadsCritical,
                                        
                    
                   ESystemCritical,
                   
                   
                   ESystemPermanent
                   };
    IMPORT_C static TCritical Critical();
    IMPORT_C static TCritical Critical(RThread aThread);
    IMPORT_C static TInt SetCritical(TCritical aCritical);
    IMPORT_C static TCritical ProcessCritical();
    IMPORT_C static TCritical ProcessCritical(RProcess aProcess);
    IMPORT_C static TInt SetProcessCritical(TCritical aCritical);
    IMPORT_C static TBool PriorityControl();
    IMPORT_C static void SetPriorityControl(TBool aEnable);
 
    enum TRealtimeState
        {
        ERealtimeStateOff,  
        ERealtimeStateOn,   
        ERealtimeStateWarn  
        };
 
    IMPORT_C static TInt SetRealtimeState(TRealtimeState aState);
 
    IMPORT_C static TSecureId CreatorSecureId();
 
    IMPORT_C static TVendorId CreatorVendorId();
 
#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
    inline static TBool CreatorHasCapability(TCapability aCapability, const char* aDiagnostic=0);
#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
    // Only available to NULL arguments
    inline static TBool CreatorHasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic=NULL);
#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
    // For things using KSuppressPlatSecDiagnostic
    inline static TBool CreatorHasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress);
#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
 
#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
    inline static TBool CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0);
#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
    // Only available to NULL arguments
    inline static TBool CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic=NULL);
#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
    // For things using KSuppressPlatSecDiagnostic
    inline static TBool CreatorHasCapability(TCapability aCapability, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress);
#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
 
    IMPORT_C static TInt ParameterLength(TInt aSlot);
    IMPORT_C static TInt GetTIntParameter(TInt aSlot, TInt& aData);
    IMPORT_C static TInt GetDesParameter(TInt aSlot, TDes8& aDes);
    IMPORT_C static TInt GetDesParameter(TInt aSlot, TDes16& aDes);
    IMPORT_C static TInt RenameThread(const TDesC &aName);
    IMPORT_C static TInt RenameProcess(const TDesC &aName);
    /*
    User::Identity() has been deprecated and is available for backward
    compatibility purposes only.
 
    Use RProcess().SecureId() instead.
    
    @deprecated
    */
    inline static TUid Identity() { return RProcess().SecureId(); }
 
    /*
    User::CreatorIdentity() has been deprecated and is available for backward
    compatibility purposes only.
 
    Use CreatorSecureId() instead.
    
    @deprecated
    */
    static inline TUid CreatorIdentity() { return CreatorSecureId(); }
 
    IMPORT_C static void NotifyOnIdle(TRequestStatus& aStatus);         
    IMPORT_C static void CancelMiscNotifier(TRequestStatus& aStatus);   
private:
    // Implementations of functions with diagnostics
    IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability, const char* aDiagnostic);
    IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability);
    IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic);
    IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability1, TCapability aCapability2);
    };
 
 
 
 
class ExecHandler;
 
typedef void (*TTlsCleanupHandler)(TAny*);      //don't use
 
class Dll
    {
public:
    static TInt SetTls(TAny* aPtr);
    static TAny* Tls();
    static void FreeTls();
    static void FileName(TFileName &aFileName);
    };
 
 
 
 
#ifndef __TOOLS__
template <class T,TInt S> 
class TFixedArray
    {
    typedef TFixedArray<T,S> ThisClass;
public:
    inline TFixedArray();
    inline TFixedArray(const T* aList, TInt aLength);
    //
    inline void Copy(const T* aList, TInt aLength);
    inline void Reset();        // zero fill
    inline void DeleteAll();
    //
    inline TInt Count() const;
    inline TInt Length() const;
    // Accessors - debug range checking
    inline T& operator[](TInt aIndex);
    inline const T& operator[] (TInt aIndex) const;
    // Accessors - always range checking
    inline T& At(TInt aIndex);
    inline const T& At(TInt aIndex) const;
    // Provides pointers to the beginning and end of the array
    inline T* Begin();
    inline T* End();
    inline const T* Begin() const;
    inline const T* End() const;
    //
    inline TArray<T> Array() const;
protected:
    inline static TBool InRange(TInt aIndex);
    inline static TInt CountFunctionR(const CBase* aThis);
    inline static const TAny* AtFunctionR(const CBase* aThis,TInt aIndex);
protected:
    T iRep[S];
    };
 
 
 
 
#define DECLARE_ROM_ARRAY( AName, AData, AType ) \
    const TFixedArray<AType,(sizeof(AData)/sizeof((AData)[0]))>& \
            AName = *(reinterpret_cast<const TFixedArray<AType, \
                           (sizeof(AData)/sizeof((AData)[0]))>* > (AData))
#endif
 
// Global leaving operator new
inline TAny* operator new(TUint aSize, TLeave);
inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize);
#if !defined(__VC32__) || defined (__MSVCDOTNET__)
inline TAny* operator new[](TUint aSize, TLeave);
#endif
 
 
#ifdef __LEAVE_EQUALS_THROW__
#define __ASSERT_ALWAYS_NO_LEAVE(_s)    \
    {                                                       \
    try {                                                   \
        TTrapHandler* ____t = User::MarkCleanupStack();     \
        _s;                                                 \
        User::UnMarkCleanupStack(____t);                    \
        }                                                   \
    catch (XLeaveException& /*l*/)                          \
        {                                                   \
        User::PanicUnexpectedLeave();                       \
        }                                                   \
    catch (...)                                             \
        {                                                   \
        User::Invariant();                                  \
        }                                                   \
    }
 
#else
#define __ASSERT_ALWAYS_NO_LEAVE(_s)    \
    {                                   \
    TInt _r;                            \
    TTrap _t;                           \
    if (_t.Trap(_r) == 0)               \
        {                               \
        _s;                             \
        TTrap::UnTrap();                \
        }                               \
    else                                \
        User::PanicUnexpectedLeave();   \
    }
#endif
 
#ifdef _DEBUG
#define __ASSERT_DEBUG_NO_LEAVE(_s)     __ASSERT_ALWAYS_NO_LEAVE(_s)
#else
#define __ASSERT_DEBUG_NO_LEAVE(_s)     { _s; }
#endif
 
 
 
// Inline methods
#include <e32std.inl>
 
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <e32std_private.h>
#endif
 
#endif