Symbian

开发平台：

C/C++

S60UIExamplePlayView.inc：源码内容

};
public:
__declspec(dllexport) TLocale();
inline TLocale(TInt);
__declspec(dllexport) void Refresh();
__declspec(dllexport) TInt Set() const;
__declspec(dllexport) void FormatCurrency(TDes& aText, TInt aAmount);
__declspec(dllexport) void FormatCurrency(TDes& aText, TInt64 aAmount);
__declspec(dllexport) void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt aAmount);
__declspec(dllexport) 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;
inline void SetCurrencyNegativeInBrackets(TBool aBool);
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;
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);
void SetDefaults();
private:
friend class TExtendedLocale;
private:
TInt iCountryCode;
TTimeIntervalSeconds iUniversalTimeOffset;
TDateFormat iDateFormat;
TTimeFormat iTimeFormat;
TLocalePos iCurrencySymbolPosition;
TBool iCurrencySpaceBetween;
TInt iCurrencyDecimalPlaces;
TNegativeCurrencyFormat iNegativeCurrencyFormat;
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 iSpare16;
TDigitType iDigitType;
TDeviceTimeState iDeviceTimeState;
TInt iSpare[0x1E];
};
const TUint KLocaleLanguageKey = 0x10208903;
const TUint KLocaleDataKey = 0x10208904;
const TUint KLocaleDataExtraKey = 0x10208905;
const TUint KLocaleTimeDateFormatKey = 0x10208907;
const TUint KLocaleDefaultCharSetKey = 0x10208908;
const TUint KLocalePreferredCharSetKey = 0x10208909;
enum TLocaleFunctions
{
FnDummy,
FnAmPmTable,
FnCharSet,
FnCollTable,
FnCurrencySymbol,
FnDateSuffixTable,
FnDayAbbTable,
FnDayTable,
FnFoldTable,
FnLanguage,
FnLocaleData,
FnLowerTable,
FnMonthAbbTable,
FnMonthTable,
FnMsgTable,
FnTypeTable,
FnUniCode,
FnUpperTable,
FnShortDateFormatSpec,
FnLongDateFormatSpec,
FnTimeFormatSpec,
FnFatUtilityFunctions
};
#line 2407
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;
#line 2462
class TExtendedLocale
{
public:
__declspec(dllexport) TExtendedLocale();
__declspec(dllexport) void LoadSystemSettings();
__declspec(dllexport) TInt SaveSystemSettings();
__declspec(dllexport) TInt LoadLocale(const TDesC& aLocaleDllName);
#line 2488
__declspec(dllexport) TInt LoadLocaleAspect(TUint aAspectGroup, const TDesC& aLocaleDllName);
__declspec(dllexport) TInt SetCurrencySymbol(const TDesC &aSymbol);
__declspec(dllexport) TInt GetLocaleDllName(TLocaleAspect aLocaleDataSet, TDes& aDllName);
__declspec(dllexport) TCollationMethod GetPreferredCollationMethod(TInt index = 0) ;
inline TLocale* GetLocale();
private:
TInt DoLoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList);
void DoUpdateLanguageSettings(TLibraryFunction* aExportList);
void DoUpdateLocaleSettings(TLibraryFunction* aExportList);
void DoUpdateTimeDateFormat(TLibraryFunction* aExportList);
private:
TLocale iLocale;
SLocaleLanguage iLanguageSettings;
SLocaleLocaleSettings iLocaleExtraSettings;
SLocaleTimeDateFormat iLocaleTimeDateFormat;
const LCharSet* iDefaultCharSet;
const LCharSet* iPreferredCharSet;
};
#line 2544
class TRect
{
public:
enum TUninitialized { EUninitialized };
TRect(TUninitialized) {}
__declspec(dllexport) TRect();
__declspec(dllexport) TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
__declspec(dllexport) TRect(const TPoint& aPointA,const TPoint& aPointB);
__declspec(dllexport) TRect(const TPoint& aPoint,const TSize& aSize);
__declspec(dllexport) TRect(const TSize& aSize);
__declspec(dllexport) TBool operator==(const TRect& aRect) const;
__declspec(dllexport) TBool operator!=(const TRect& aRect) const;
__declspec(dllexport) void SetRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
__declspec(dllexport) void SetRect(const TPoint& aPointTL,const TPoint& aPointBR);
__declspec(dllexport) void SetRect(const TPoint& aPoint,const TSize& aSize);
__declspec(dllexport) void Move(TInt aDx,TInt aDy);
__declspec(dllexport) void Move(const TPoint& aOffset);
__declspec(dllexport) void Resize(TInt aDx,TInt aDy);
__declspec(dllexport) void Resize(const TSize& aSize);
__declspec(dllexport) void Shrink(TInt aDx,TInt aDy);
__declspec(dllexport) void Shrink(const TSize& aSize);
__declspec(dllexport) void Grow(TInt aDx,TInt aDy);
__declspec(dllexport) void Grow(const TSize& aSize);
__declspec(dllexport) void BoundingRect(const TRect& aRect);
__declspec(dllexport) TBool IsEmpty() const;
__declspec(dllexport) TBool Intersects(const TRect& aRect) const;
__declspec(dllexport) void Intersection(const TRect& aRect);
__declspec(dllexport) void Normalize();
__declspec(dllexport) TBool Contains(const TPoint& aPoint) const;
__declspec(dllexport) TSize Size() const;
__declspec(dllexport) TInt Width() const;
__declspec(dllexport) TInt Height() const;
__declspec(dllexport) TBool IsNormalized() const;
__declspec(dllexport) TPoint Center() const;
__declspec(dllexport) void SetSize(const TSize& aSize);
__declspec(dllexport) void SetWidth(TInt aWidth);
__declspec(dllexport) void SetHeight(TInt aHeight);
private:
void Adjust(TInt aDx,TInt aDy);
public:
TPoint iTl;
TPoint iBr;
};
#line 2646
class TRegion
{
public:
inline TInt Count() const;
inline const TRect* RectangleList() const;
inline TBool CheckError() const;
__declspec(dllexport) TBool IsEmpty() const;
__declspec(dllexport) TRect BoundingRect() const;
__declspec(dllexport) const TRect& operator[](TInt aIndex) const;
__declspec(dllexport) void Copy(const TRegion& aRegion);
__declspec(dllexport) void AddRect(const TRect& aRect);
__declspec(dllexport) void SubRect(const TRect& aRect,TRegion* aSubtractedRegion=0 );
__declspec(dllexport) void Offset(TInt aXoffset,TInt aYoffset);
__declspec(dllexport) void Offset(const TPoint& aOffset);
__declspec(dllexport) void Union(const TRegion& aRegion);
__declspec(dllexport) void Intersection(const TRegion& aRegion,const TRegion& aRegion2);
__declspec(dllexport) void Intersect(const TRegion& aRegion);
__declspec(dllexport) void SubRegion(const TRegion& aRegion,TRegion* aSubtractedRegion=0 );
__declspec(dllexport) void ClipRect(const TRect& aRect);
__declspec(dllexport) void Clear();
__declspec(dllexport) void Tidy();
__declspec(dllexport) TInt Sort();
__declspec(dllexport) TInt Sort(const TPoint& aOffset);
__declspec(dllexport) void ForceError();
__declspec(dllexport) TBool IsContainedBy(const TRect& aRect) const;
__declspec(dllexport) TBool Contains(const TPoint& aPoint) const;
protected:
__declspec(dllexport) TRect* RectangleListW();
__declspec(dllexport) TRegion(TInt aAllocedRects);
inline TRegion();
TBool SetListSize(TInt aCount);
void AppendRect(const TRect& aRect);
void DeleteRect(TRect* aRect);
void AppendRegion(TRegion& aRegion);
protected:
TInt iCount;
TBool iError;
TInt iAllocedRects;
protected:
enum {ERRegionBuf=0x40000000};
};
#line 2703
class RRegion : public TRegion
{
private:
enum {EDefaultGranularity=5};
protected:
__declspec(dllexport) RRegion(TInt aBuf,TInt aGran);
public:
__declspec(dllexport) RRegion();
__declspec(dllexport) RRegion(TInt aGran);
__declspec(dllexport) RRegion(const RRegion& aRegion);
__declspec(dllexport) RRegion(const TRect& aRect,TInt aGran=EDefaultGranularity);
__declspec(dllexport) RRegion(TInt aCount,TRect* aRectangleList,TInt aGran=EDefaultGranularity);
__declspec(dllexport) void Close();
__declspec(dllexport) void Destroy();
inline TInt CheckSpare() const;
private:
TInt iGranularity;
TRect* iRectangleList;
friend class TRegion;
};
#line 2744
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)];
};
#line 2774
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)];
};
#line 2806
class TFindHandleBase
{
public:
__declspec(dllexport) TFindHandleBase();
__declspec(dllexport) TFindHandleBase(const TDesC& aMatch);
__declspec(dllexport) void Find(const TDesC& aMatch);
inline TInt Handle() const;
protected:
TInt NextObject(TFullName& aResult,TInt aObjectType);
private:
TInt iFindHandle;
TInt iSpare1;
TInt iSpare2;
TInt iSpare3;
TFullName iMatch;
};
#line 2859
class TFindSemaphore : public TFindHandleBase
{
public:
inline TFindSemaphore();
inline TFindSemaphore(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2895
class TFindMutex : public TFindHandleBase
{
public:
inline TFindMutex();
inline TFindMutex(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2922
class TFindChunk : public TFindHandleBase
{
public:
inline TFindChunk();
inline TFindChunk(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2952
class TFindThread : public TFindHandleBase
{
public:
inline TFindThread();
inline TFindThread(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2981
class TFindProcess : public TFindHandleBase
{
public:
inline TFindProcess();
inline TFindProcess(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3010
class TFindLogicalDevice : public TFindHandleBase
{
public:
inline TFindLogicalDevice();
inline TFindLogicalDevice(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3037
class TFindPhysicalDevice : public TFindHandleBase
{
public:
inline TFindPhysicalDevice();
inline TFindPhysicalDevice(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3065
class TFindServer : public TFindHandleBase
{
public:
inline TFindServer();
inline TFindServer(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3089
class TFindLibrary : public TFindHandleBase
{
public:
inline TFindLibrary();
inline TFindLibrary(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3114
class RDevice : public RHandleBase
{
public:
inline TInt Open(const TFindLogicalDevice& aFind,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void GetCaps(TDes8& aDes) const;
__declspec(dllexport) TBool QueryVersionSupported(const TVersion& aVer) const;
__declspec(dllexport) TBool IsAvailable(TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* anInfo) const;
};
#line 3154
class RTimer : public RHandleBase
{
public:
__declspec(dllexport) TInt CreateLocal();
__declspec(dllexport) void Cancel();
__declspec(dllexport) void After(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
__declspec(dllexport) void AfterTicks(TRequestStatus &aStatus, TInt aTicks);
__declspec(dllexport) void At(TRequestStatus& aStatus,const TTime& aTime);
__declspec(dllexport) void AtUTC(TRequestStatus& aStatus,const TTime& aUTCTime);
__declspec(dllexport) void Lock(TRequestStatus& aStatus,TTimerLockSpec aLock);
__declspec(dllexport) void Inactivity(TRequestStatus& aStatus, TTimeIntervalSeconds aSeconds);
__declspec(dllexport) void HighRes(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
};
#line 3179
class RLibrary : public RHandleBase
{
public:
__declspec(dllexport) void Close();
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TUidType& aType);
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath=KNullDesC);
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType);
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType, TUint32 aModuleVersion);
__declspec(dllexport) TInt LoadRomLibrary(const TDesC& aFileName, const TDesC& aPath);
__declspec(dllexport) TLibraryFunction Lookup(TInt anOrdinal) const;
__declspec(dllexport) TUidType Type() const;
__declspec(dllexport) TFileName FileName() const;
__declspec(dllexport) TInt GetRamSizes(TInt& aCodeSize, TInt& aConstDataSize);
__declspec(dllexport) TInt Init();
public:
struct TInfo
{
TUint32 iModuleVersion;
TUidType iUids;
TSecurityInfo iSecurityInfo;
};
struct TInfoV2 : public TInfo
{
TUint8 iHardwareFloatingPoint;
TUint8 iSpare[7];
};
typedef TPckgBuf<TInfo> TInfoBuf;
typedef TPckgBuf<TInfoV2> TInfoBufV2;
enum TRequiredImageHeaderSize
{
KRequiredImageHeaderSize = KMaxTInt
};
__declspec(dllexport) static TInt GetInfoFromHeader(const TDesC8& aHeader, TDes8& aInfoBuf);
struct SInfo
{
TUint32 iModuleVersion;
TUidType iUids;
SSecurityInfo iS;
};
typedef TPckgBuf<SInfo> SInfoBuf;
__declspec(dllexport) static TInt GetInfo(const TDesC& aFileName, TDes8& aInfoBuf);
private:
TInt InitL();
};
#line 3292
class RCriticalSection : private RSemaphore
{
public:
__declspec(dllexport) RCriticalSection();
__declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void Close();
__declspec(dllexport) void Wait();
__declspec(dllexport) void Signal();
inline TBool IsBlocked() const;
private:
TInt iBlocked;
};
#line 3320
class RMutex : public RHandleBase
{
public:
inline TInt Open(const TFindMutex& aFind,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt OpenGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void Wait();
__declspec(dllexport) void Signal();
__declspec(dllexport) TBool IsHeld();
};
#line 3349
class RCondVar : public RHandleBase
{
public:
__declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt OpenGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(RMessagePtr2 aMessage, TInt aParam, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Wait(RMutex& aMutex);
__declspec(dllexport) TInt TimedWait(RMutex& aMutex, TInt aTimeout);
__declspec(dllexport) void Signal();
__declspec(dllexport) void Broadcast();
};
class UserHeap;
class TChunkCreate;
#line 3375
class RChunk : public RHandleBase
{
public:
enum TAttribs
{
ENormal=0x00,
EDoubleEnded=0x01,
EDisconnected=0x02,
ELocal=0x00,
EGlobal=0x10,
EData=0x00,
ECode=0x20,
};
enum TRestrictions
{
EPreventAdjust = 0x01,
};
public:
inline TInt Open(const TFindChunk& aFind,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateLocal(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateLocalCode(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateGlobal(const TDesC& aName,TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateDoubleEndedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateDoubleEndedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateDisconnectedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateDisconnectedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Create(TUint aAtt, TInt aMaxSize, TInt aInitialBottom, TInt aInitialTop, const TDesC* aName, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt SetRestrictions(TUint aFlags);
__declspec(dllexport) TInt OpenGlobal(const TDesC& aName,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(RMessagePtr2 aMessage,TInt aParam,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Adjust(TInt aNewSize) const;
__declspec(dllexport) TInt AdjustDoubleEnded(TInt aBottom, TInt aTop) const;
__declspec(dllexport) TInt Commit(TInt anOffset, TInt aSize) const;
__declspec(dllexport) TInt Allocate(TInt aSize) const;
__declspec(dllexport) TInt Decommit(TInt anOffset, TInt aSize) const;
__declspec(dllexport) TUint8* Base() const;
__declspec(dllexport) TInt Size() const;
__declspec(dllexport) TInt Bottom() const;
__declspec(dllexport) TInt Top() const;
__declspec(dllexport) TInt MaxSize() const;
inline TBool IsReadable() const;
inline TBool IsWritable() const;
private:
friend class UserHeap;
};
struct SStdEpocThreadCreateInfo;
#line 3445
class UserHeap
{
public:
enum TChunkHeapCreateMode {EChunkHeapSwitchTo=1, EChunkHeapDuplicate=2};
__declspec(dllexport) static RHeap* FixedHeap(TAny* aBase, TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);
__declspec(dllexport) static RHeap* ChunkHeap(const TDesC* aName, TInt aMinLength, TInt aMaxLength, TInt aGrowBy=1, TInt aAlign=0, TBool aSingleThread=EFalse);
__declspec(dllexport) static RHeap* ChunkHeap(RChunk aChunk, TInt aMinLength, TInt aGrowBy=1, TInt aMaxLength=0, TInt aAlign=0, TBool aSingleThread=EFalse, TUint32 aMode=0);
__declspec(dllexport) static TInt SetupThreadHeap(TBool aNotFirst, SStdEpocThreadCreateInfo& aInfo);
__declspec(dllexport) static TInt CreateThreadHeap(SStdEpocThreadCreateInfo& aInfo, RHeap*& aHeap, TInt aAlign=0, TBool aSingleThread=EFalse);
};
#line 3465
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;
};
#line 3493
class TThreadId : public TObjectId
{
public:
inline TThreadId();
inline TThreadId(TUint64 anId);
};
class RProcess;
#line 3514
class RThread : public RHandleBase
{
public:
inline RThread();
__declspec(dllexport) TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, TAny *aPtr, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, RAllocator* aHeap, TAny* aPtr, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(const TDesC& aFullName, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TThreadId aID, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TThreadId Id() const;
__declspec(dllexport) void Resume() const;
__declspec(dllexport) void Suspend() const;
inline static TInt RenameMe(const TDesC& aName);
__declspec(dllexport) void Kill(TInt aReason);
__declspec(dllexport) void Terminate(TInt aReason);
__declspec(dllexport) void Panic(const TDesC& aCategory,TInt aReason);
__declspec(dllexport) TInt Process(RProcess& aProcess) const;
__declspec(dllexport) TThreadPriority Priority() const;
__declspec(dllexport) void SetPriority(TThreadPriority aPriority) const;
__declspec(dllexport) TProcessPriority ProcessPriority() const;
__declspec(dllexport) void SetProcessPriority(TProcessPriority aPriority) const;
__declspec(dllexport) TInt RequestCount() const;
__declspec(dllexport) TExitType ExitType() const;
__declspec(dllexport) TInt ExitReason() const;
__declspec(dllexport) TExitCategoryName ExitCategory() const;
__declspec(dllexport) void RequestComplete(TRequestStatus*& aStatus,TInt aReason) const;
__declspec(dllexport) void RequestSignal() const;
__declspec(dllexport) void Logon(TRequestStatus& aStatus) const;
__declspec(dllexport) TInt LogonCancel(TRequestStatus& aStatus) const;
__declspec(dllexport) void HandleCount(TInt& aProcessHandleCount, TInt& aThreadHandleCount) const;
__declspec(dllexport) void Context(TDes8& aDes) const;
__declspec(dllexport) TInt StackInfo(TThreadStackInfo& aInfo) const;
__declspec(dllexport) TInt GetCpuTime(TTimeIntervalMicroSeconds& aCpuTime) const;
inline TInt Open(const TFindThread& aFind,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void Rendezvous(TRequestStatus& aStatus) const;
__declspec(dllexport) TInt RendezvousCancel(TRequestStatus& aStatus) const;
__declspec(dllexport) static void Rendezvous(TInt aReason);
#line 3588
__declspec(dllexport) TSecureId SecureId() const;
#line 3622
__declspec(dllexport) TVendorId VendorId() const;
#line 3642
inline TBool HasCapability(TCapability aCapability, const char* aDiagnostic=0) const;
#line 3671
inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0) const;
#line 3686
inline TInt Create(const TDesC& aName,TThreadFunction aFunction,TInt aStackSize,TAny* aPtr,RLibrary* aLibrary,RHeap* aHeap, TInt aHeapMinSize,TInt aHeapMaxSize,TOwnerType aType);
private:
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability, const char* aDiagnostic) const;
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability) const;
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const;
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2) const;
};
inline TInt RThread::Create(const TDesC& ,TThreadFunction ,TInt ,TAny* ,RLibrary* ,RHeap* , TInt ,TInt ,TOwnerType )
{return KErrNotSupported; }
#line 3717
class TProcessId : public TObjectId
{
public:
inline TProcessId();
inline TProcessId(TUint64 anId);
};
class RSubSessionBase;
#line 3737
class RProcess : public RHandleBase
{
public:
inline RProcess();
__declspec(dllexport) TInt Create(const TDesC& aFileName,const TDesC& aCommand,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Create(const TDesC& aFileName,const TDesC& aCommand,const TUidType &aUidType, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TProcessId aId,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TUidType Type() const;
__declspec(dllexport) TProcessId Id() const;
inline static TInt RenameMe(const TDesC& aName);
__declspec(dllexport) void Kill(TInt aReason);
__declspec(dllexport) void Terminate(TInt aReason);
__declspec(dllexport) void Panic(const TDesC& aCategory,TInt aReason);
__declspec(dllexport) void Resume();
__declspec(dllexport) TFileName FileName() const;
__declspec(dllexport) TExitType ExitType() const;
__declspec(dllexport) TInt ExitReason() const;
__declspec(dllexport) TExitCategoryName ExitCategory() const;
__declspec(dllexport) TProcessPriority Priority() const;
__declspec(dllexport) void SetPriority(TProcessPriority aPriority) const;
__declspec(dllexport) TBool JustInTime() const;
__declspec(dllexport) void SetJustInTime(TBool aBoolean) const;
__declspec(dllexport) void Logon(TRequestStatus& aStatus) const;
__declspec(dllexport) TInt LogonCancel(TRequestStatus& aStatus) const;
__declspec(dllexport) TInt GetMemoryInfo(TModuleMemoryInfo& aInfo) const;
inline TInt Open(const TFindProcess& aFind,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void Rendezvous(TRequestStatus& aStatus) const;
__declspec(dllexport) TInt RendezvousCancel(TRequestStatus& aStatus) const;
__declspec(dllexport) static void Rendezvous(TInt aReason);
#line 3805
__declspec(dllexport) TSecureId SecureId() const;
#line 3839
__declspec(dllexport) TVendorId VendorId() const;
#line 3859
inline TBool HasCapability(TCapability aCapability, const char* aDiagnostic=0) const;
#line 3888
inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0) const;
#line 3898
__declspec(dllexport) TInt SetParameter(TInt aIndex, RHandleBase aHandle);
__declspec(dllexport) TInt SetParameter(TInt aSlot, const RSubSessionBase& aSession);
__declspec(dllexport) TInt SetParameter(TInt aSlot, const TDesC16& aDes);
__declspec(dllexport) TInt SetParameter(TInt aSlot, const TDesC8& aDes);
__declspec(dllexport) TInt SetParameter(TInt aSlot, TInt aData);
inline RProcess(TInt aHandle);
inline TUid Identity() const { return SecureId(); }
enum TSecureApi { ESecureApiOff, ESecureApiOn, ESecureApiQuery };
__declspec(dllexport) TInt SecureApi(TInt aState);
enum TDataCaging { EDataCagingOff, EDataCagingOn, EDataCagingQuery};
__declspec(dllexport) TInt DataCaging(TInt aState);
private:
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability, const char* aDiagnostic) const;
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability) const;
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const;
__declspec(dllexport) TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2) const;
};
#line 3957
class RServer2 : public RHandleBase
{
public:
__declspec(dllexport) TInt CreateGlobal(const TDesC& aName);
__declspec(dllexport) TInt CreateGlobal(const TDesC& aName, TInt aMode);
__declspec(dllexport) void Receive(RMessage2& aMessage,TRequestStatus& aStatus);
__declspec(dllexport) void Receive(RMessage2& aMessage);
__declspec(dllexport) void Cancel();
};
#line 3982
class RSessionBase : public RHandleBase
{
friend class RSubSessionBase;
public:
enum TAttachMode {EExplicitAttach,EAutoAttach};
public:
#line 4011
inline TInt ShareAuto() { return DoShare(EAutoAttach); }
#line 4033
inline TInt ShareProtected() { return DoShare(EAutoAttach|KCreateProtectedObject); }
__declspec(dllexport) TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(RMessagePtr2 aMessage,TInt aParam,const TSecurityPolicy& aServerPolicy,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TInt aArgumentIndex, const TSecurityPolicy& aServerPolicy, TOwnerType aType=EOwnerProcess);
inline TInt SetReturnedHandle(TInt aHandleOrError);
__declspec(dllexport) TInt SetReturnedHandle(TInt aHandleOrError,const TSecurityPolicy& aServerPolicy);
protected:
inline TInt CreateSession(const TDesC& aServer,const TVersion& aVersion);
__declspec(dllexport) TInt CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots);
__declspec(dllexport) 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);
__declspec(dllexport) TInt CreateSession(RServer2 aServer,const TVersion& aVersion,TInt aAsyncMessageSlots);
__declspec(dllexport) 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:
__declspec(dllexport) TInt DoSend(TInt aFunction,const TIpcArgs* aArgs) const;
__declspec(dllexport) void DoSendReceive(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus& aStatus) const;
__declspec(dllexport) 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;
__declspec(dllexport) TInt DoShare(TInt aAttachMode);
TInt DoConnect(const TVersion &aVersion,TRequestStatus* aStatus);
};
#line 4096
class RSubSessionBase
{
public:
inline TInt SubSessionHandle() const;
protected:
inline RSubSessionBase();
__declspec(dllexport) const RSessionBase Session() const;
inline TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
inline TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction);
__declspec(dllexport) TInt CreateAutoCloseSubSession(RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
__declspec(dllexport) 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:
__declspec(dllexport) TInt DoCreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs* aArgs);
__declspec(dllexport) TInt DoSend(TInt aFunction,const TIpcArgs* aArgs) const;
__declspec(dllexport) void DoSendReceive(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus& aStatus) const;
__declspec(dllexport) TInt DoSendReceive(TInt aFunction,const TIpcArgs* aArgs) const;
TInt DoCreateSubSession(RSessionBase& aSession,TInt aFunction,const TIpcArgs* aArgs, TBool aAutoClose);
private:
RSessionBase iSession;
TInt iSubSessionHandle;
};
#line 4136
class RRefBase
{
public:
__declspec(dllexport) void Free();
protected:
inline RRefBase();
inline RRefBase(const RRefBase& aRef);
__declspec(dllexport) void DoAlloc(const TAny* aPtr,TInt aSize);
__declspec(dllexport) void DoAllocL(const TAny* aPtr,TInt aSize);
__declspec(dllexport) void Copy(const RRefBase& aRef);
private:
__declspec(dllexport) void operator=(const RRefBase& aRef);
protected:
TInt* iPtr;
};
#line 4166
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);
};
#line 4192
class RChangeNotifier : public RHandleBase
{
public:
__declspec(dllexport) TInt Create();
__declspec(dllexport) TInt Logon(TRequestStatus& aStatus) const;
__declspec(dllexport) TInt LogonCancel() const;
};
#line 4213
class RUndertaker : public RHandleBase
{
public:
__declspec(dllexport) TInt Create();
__declspec(dllexport) TInt Logon(TRequestStatus& aStatus,TInt& aThreadHandle) const;
__declspec(dllexport) TInt LogonCancel() const;
};
class HBufC16;
#line 4236
class RNotifier : public RSessionBase
{
public:
__declspec(dllexport) RNotifier();
__declspec(dllexport) TInt Connect();
__declspec(dllexport) void Close();
__declspec(dllexport) TInt StartNotifier(TUid aNotifierUid,const TDesC8& aBuffer);
__declspec(dllexport) TInt StartNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
__declspec(dllexport) TInt StartNotifier(TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
__declspec(dllexport) TInt CancelNotifier(TUid aNotifierUid);
__declspec(dllexport) TInt UpdateNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
__declspec(dllexport) void UpdateNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
__declspec(dllexport) void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
__declspec(dllexport) void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
__declspec(dllexport) TInt UnloadNotifiers(TUid aNotifierUid);
__declspec(dllexport) TInt LoadNotifiers(TUid aNotifierUid);
__declspec(dllexport) void Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aBut1,const TDesC& aBut2,TInt& aButtonVal,TRequestStatus& aStatus);
__declspec(dllexport) void NotifyCancel();
__declspec(dllexport) TInt InfoPrint(const TDesC& aDes);
private:
TPtr8 iButtonVal;
HBufC16* iCombinedBuffer;
};
#line 4270
const TInt KMediaPasswordNotifyUid(0x10004c00);
enum TMediaPswdNotifyExitMode {EMPEMUnlock, EMPEMCancel, EMPEMUnlockAndStore};
struct TMediaPswdNotifyBase
{
enum TCardType {ECTMmcPassword} iCT;
TVersion iVersion;
};
struct TMediaPswdSendNotifyInfoV1 : public TMediaPswdNotifyBase
{
};
struct TMediaPswdSendNotifyInfoV1Debug : public TMediaPswdSendNotifyInfoV1
{
TInt iSleepPeriod;
TMediaPswdNotifyExitMode iEM;
TText8 iPW[KMaxMediaPassword];
};
struct TMediaPswdReplyNotifyInfoV1 : public TMediaPswdNotifyBase
{
TText8 iPW[KMaxMediaPassword];
TMediaPswdNotifyExitMode iEM;
};
#line 4325
class TTrapHandler
{
public:
__declspec(dllexport) TTrapHandler();
__declspec(dllexport) virtual void Trap()=0;
__declspec(dllexport) virtual void UnTrap()=0;
__declspec(dllexport) virtual void Leave(TInt aValue)=0;
};
struct TCollationMethod;
#line 4369
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);
inline static TInt Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
__declspec(dllexport) static TInt Compare(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
__declspec(dllexport) static TInt CompareF(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
__declspec(dllexport) static TInt CompareF(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
__declspec(dllexport) static TInt CompareC(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
__declspec(dllexport) static TInt CompareC(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
__declspec(dllexport) static TInt CompareC(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL,
TInt aMaxLevel, const TCollationMethod* aCollationMethod);
__declspec(dllexport) static TInt CollationMethods();
__declspec(dllexport) static TUint CollationMethodId(TInt aIndex);
__declspec(dllexport) static const TCollationMethod* CollationMethodByIndex(TInt aIndex);
__declspec(dllexport) static const TCollationMethod* CollationMethodById(TUint aId);
__declspec(dllexport) static const TCollationMethod* GetDefaultMatchingTable();
__declspec(dllexport) static void Swap(TAny* aPtr1, TAny* aPtr2, TInt aLength);
__declspec(dllexport) static void Crc(TUint16& aCrc, const TAny* aPtr, TInt aLength);
__declspec(dllexport) static void Crc32(TUint32& aCrc, const TAny* aPtr, TInt aLength);
};
#line 4431
class User : public UserHeap
{
public:
__declspec(dllexport) static void InitProcess();
__declspec(dllexport) static void Exit(TInt aReason);
__declspec(dllexport) static void Panic(const TDesC& aCategory,TInt aReason);
__declspec(dllexport) static void HandleException(TAny* aInfo);
__declspec(dllexport) static void Leave(TInt aReason);
__declspec(dllexport) static void LeaveNoMemory();
__declspec(dllexport) static TInt LeaveIfError(TInt aReason);
__declspec(dllexport) static TAny* LeaveIfNull(TAny* aPtr);
__declspec(dllexport) static TTrapHandler* SetTrapHandler(TTrapHandler* aHandler);
__declspec(dllexport) static TTrapHandler* TrapHandler();
__declspec(dllexport) static TTrapHandler* MarkCleanupStack();
__declspec(dllexport) static void UnMarkCleanupStack(TTrapHandler* aHandler);
__declspec(dllexport) static void LeaveEnd();
__declspec(dllexport) static TInt InfoPrint(const TDesC& aDes);
__declspec(dllexport) static void RequestComplete(TRequestStatus*& aStatus,TInt aReason);
__declspec(dllexport) static void WaitForAnyRequest();
__declspec(dllexport) static void WaitForRequest(TRequestStatus& aStatus);
__declspec(dllexport) static void WaitForRequest(TRequestStatus& aStatus1,TRequestStatus& aStatus2);
__declspec(dllexport) static TInt AllocLen(const TAny* aCell);
__declspec(dllexport) static TAny* Alloc(TInt aSize);
__declspec(dllexport) static TAny* AllocL(TInt aSize);
__declspec(dllexport) static TAny* AllocLC(TInt aSize);
__declspec(dllexport) static TAny* AllocZ(TInt aSize);
__declspec(dllexport) static TAny* AllocZL(TInt aSize);
__declspec(dllexport) static TInt AllocSize(TInt& aTotalAllocSize);
__declspec(dllexport) static TInt Available(TInt& aBiggestBlock);
__declspec(dllexport) static TInt CountAllocCells();
__declspec(dllexport) static TInt CountAllocCells(TInt& aFreeCount);
__declspec(dllexport) static void Free(TAny* aCell);
__declspec(dllexport) static void FreeZ(TAny*& aCell);
__declspec(dllexport) static RAllocator& Allocator();
inline static RHeap& Heap();
__declspec(dllexport) static TAny* ReAlloc(TAny* aCell, TInt aSize, TInt aMode=0);
__declspec(dllexport) static TAny* ReAllocL(TAny* aCell, TInt aSize, TInt aMode=0);
__declspec(dllexport) static RAllocator* SwitchAllocator(RAllocator* aAllocator);
inline static RHeap* SwitchHeap(RAllocator* aHeap);
__declspec(dllexport) static TInt CompressAllHeaps();
__declspec(dllexport) static void After(TTimeIntervalMicroSeconds32 aInterval);
__declspec(dllexport) static TInt At(const TTime& aTime);
__declspec(dllexport) static void AfterHighRes(TTimeIntervalMicroSeconds32 aInterval);
__declspec(dllexport) static TInt SetHomeTime(const TTime& aTime);
__declspec(dllexport) static TInt SetUTCTime(const TTime& aUTCTime);
__declspec(dllexport) static TTimeIntervalSeconds UTCOffset();
__declspec(dllexport) static void SetUTCOffset(TTimeIntervalSeconds aOffset);
__declspec(dllexport) static TInt SetUTCTimeAndOffset(const TTime& aUTCTime, TTimeIntervalSeconds aOffset);
__declspec(dllexport) static TInt SetCurrencySymbol(const TDesC& aSymbol);
__declspec(dllexport) static TUint TickCount();
__declspec(dllexport) static TUint32 NTickCount();
__declspec(dllexport) static TTimerLockSpec LockPeriod();
__declspec(dllexport) static TTimeIntervalSeconds InactivityTime();
__declspec(dllexport) static void ResetInactivityTime();
__declspec(dllexport) static TUint32 FastCounter();
__declspec(dllexport) static TInt LockedInc(TInt& aValue);
__declspec(dllexport) static TInt LockedDec(TInt& aValue);
__declspec(dllexport) static TInt SafeInc(TInt& aValue);
__declspec(dllexport) static TInt SafeDec(TInt& aValue);
__declspec(dllexport) static TInt Beep(TInt aFrequency,TTimeIntervalMicroSeconds32 aDuration);
__declspec(dllexport) static TInt IsRomAddress(TBool& aBool,TAny* aPtr);
__declspec(dllexport) static TInt BinarySearch(TInt aCount,const TKey& aKey,TInt& aPos);
__declspec(dllexport) static TInt QuickSort(TInt aCount,const TKey& aKey,const TSwap& aSwap);
__declspec(dllexport) static TLanguage Language();
__declspec(dllexport) static TUint Collate(TUint aChar);
__declspec(dllexport) static TUint Fold(TUint aChar);
__declspec(dllexport) static TUint LowerCase(TUint aChar);
__declspec(dllexport) static TUint UpperCase(TUint aChar);
__declspec(dllexport) static TUint Fold(TUint aChar,TInt aFlags);
__declspec(dllexport) static TUint TitleCase(TUint aChar);
__declspec(dllexport) static TInt StringLength(const TUint8* aString);
__declspec(dllexport) static TInt StringLength(const TUint16* aString);
__declspec(dllexport) static TInt FreeLogicalDevice(const TDesC& aDeviceName);
__declspec(dllexport) static TInt FreePhysicalDevice(const TDesC& aDriverName);
__declspec(dllexport) static TInt LoadLogicalDevice(const TDesC& aFileName);
__declspec(dllexport) static TInt LoadPhysicalDevice(const TDesC& aFileName);
__declspec(dllexport) static TBool QueryVersionSupported(const TVersion& aCurrent,const TVersion& aRequested);
__declspec(dllexport) static TVersion Version();
__declspec(dllexport) static TInt SetMachineConfiguration(const TDesC8& aConfig);
__declspec(dllexport) static TInt MachineConfiguration(TDes8& aConfig,TInt& aSize);
__declspec(dllexport) static void SetDebugMask(TUint32 aVal);
__declspec(dllexport) static void SetDebugMask(TUint32 aVal, TUint aIndex);
__declspec(dllexport) static void SetJustInTime(const TBool aBoolean);
__declspec(dllexport) static void Check();
__declspec(dllexport) static void Invariant();
__declspec(dllexport) static TBool JustInTime();
__declspec(dllexport) static void __DbgMarkStart(TBool aKernel);
__declspec(dllexport) static void __DbgMarkCheck(TBool aKernel, TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum);
__declspec(dllexport) static TUint32 __DbgMarkEnd(TBool aKernel, TInt aCount);
__declspec(dllexport) static void __DbgSetAllocFail(TBool aKernel, RAllocator::TAllocFail aFail, TInt aRate);
__declspec(dllexport) static void PanicUnexpectedLeave();
__declspec(dllexport) static TInt ValidateName(const TDesC& aName);
__declspec(dllexport) static void IMB_Range(TAny* aStart, TAny* aEnd);
__declspec(dllexport) static TInt CommandLineLength();
__declspec(dllexport) static void CommandLine(TDes &aCommand);
__declspec(dllexport) static TExceptionHandler ExceptionHandler();
__declspec(dllexport) static TInt SetExceptionHandler(TExceptionHandler aHandler,TUint32 aMask);
__declspec(dllexport) static void ModifyExceptionMask(TUint32 aClearMask, TUint32 aSetMask);
__declspec(dllexport) static TInt RaiseException(TExcType aType);
__declspec(dllexport) static TBool IsExceptionHandled(TExcType aType);
enum TCritical {
ENotCritical,
EProcessCritical,
EProcessPermanent,
EAllThreadsCritical,
#line 4594
ESystemCritical,
#line 4605
ESystemPermanent
};
__declspec(dllexport) static TCritical Critical();
__declspec(dllexport) static TInt SetCritical(TCritical aCritical);
__declspec(dllexport) static TCritical ProcessCritical();
__declspec(dllexport) static TInt SetProcessCritical(TCritical aCritical);
__declspec(dllexport) static TBool PriorityControl();
__declspec(dllexport) static void SetPriorityControl(TBool aEnable);
__declspec(dllexport) static TSecureId CreatorSecureId();
__declspec(dllexport) static TVendorId CreatorVendorId();
#line 4648
inline static TBool CreatorHasCapability(TCapability aCapability, const char* aDiagnostic=0);
#line 4677
inline static TBool CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0);
#line 4687
__declspec(dllexport) static TInt ParameterLength(TInt aSlot);
__declspec(dllexport) static TInt GetTIntParameter(TInt aSlot, TInt& aData);
__declspec(dllexport) static TInt GetDesParameter(TInt aSlot, TDes8& aDes);
__declspec(dllexport) static TInt GetDesParameter(TInt aSlot, TDes16& aDes);
__declspec(dllexport) static TInt RenameThread(const TDesC &aName);
__declspec(dllexport) static TInt RenameProcess(const TDesC &aName);
inline static TUid Identity() { return RProcess().SecureId(); }
static inline TUid CreatorIdentity() { return CreatorSecureId(); }
private:
__declspec(dllexport) static TBool DoCreatorHasCapability(TCapability aCapability, const char* aDiagnostic);
__declspec(dllexport) static TBool DoCreatorHasCapability(TCapability aCapability);
__declspec(dllexport) static TBool DoCreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic);
__declspec(dllexport) static TBool DoCreatorHasCapability(TCapability aCapability1, TCapability aCapability2);
};
class ExecHandler;
typedef void (*TTlsCleanupHandler)(TAny*);
class Dll
{
public:
static TInt SetTls(TAny* aPtr);
static TAny* Tls();
static void FreeTls();
static void FileName(TFileName &aFileName);
};
#line 4758
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();
inline void DeleteAll();
inline TInt Count() const;
inline TInt Length() const;
inline T& operator[](TInt aIndex);
inline const T& operator[] (TInt aIndex) const;
inline T& At(TInt aIndex);
inline const T& At(TInt aIndex) const;
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];
};
#line 4811
inline TAny* operator new(TUint aSize, TLeave);
inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize);
inline TAny* operator new[](TUint aSize, TLeave);
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.inl" /* stack depth 5 */
inline TAny* operator new(TUint aSize, TLeave)
{return User::AllocL(aSize);}
inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize)
{return User::AllocL(aSize + aExtraSize);}
inline TAny* operator new[](TUint aSize, TLeave)
{return User::AllocL(aSize);}
inline TUint8* Mem::Copy(TAny* aTrg, const TAny* aSrc, TInt aLength)
#line 41
{ return (TUint8*)memmove(aTrg, aSrc, aLength) + aLength; }
inline TUint8* Mem::Move(TAny* aTrg, const TAny* aSrc, TInt aLength)
#line 70
{ return (TUint8*)wordmove(aTrg, aSrc, aLength) + aLength; }
inline void Mem::Fill(TAny* aTrg, TInt aLength, TChar aChar)
#line 89
{ memset(aTrg, (TInt)(aChar.operator TUint()), aLength); }
inline void Mem::FillZ(TAny* aTrg,TInt aLength)
#line 105
{ memclr(aTrg, aLength); }
inline TInt Mem::Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL)
#line 140
{ return memcompare(aLeft, aLeftL, aRight, aRightL); }
inline TInt RHeap::SetBrk(TInt aBrk)
{ return ((RChunk*)&iChunkHandle)->Adjust(aBrk); }
inline void TChar::SetChar(TUint aChar)
{iChar=aChar;}
inline void TChar::Fold()
#line 181
{iChar=User::Fold(iChar);}
inline void TChar::LowerCase()
{iChar=User::LowerCase(iChar);}
inline void TChar::UpperCase()
{iChar=User::UpperCase(iChar);}
inline void TChar::Fold(TInt aFlags)
#line 224
{iChar=User::Fold(iChar,aFlags);}
inline void TChar::TitleCase()
{iChar=User::TitleCase(iChar);}
inline TBool TChar::Eos() const
{return(iChar==0);}
inline TCallBack::TCallBack()
{iFunction=0 ;}
inline TCallBack::TCallBack(TInt (*aFunction)(TAny *aPtr))
: iFunction(aFunction),iPtr(0 )
#line 277
{}
inline TCallBack::TCallBack(TInt (*aFunction)(TAny *aPtr),TAny *aPtr)
: iFunction(aFunction),iPtr(aPtr)
#line 294
{}
#line 313
inline TInt TCallBack::CallBack() const
{ return (iFunction ? (*iFunction)(iPtr) : 0); }
template <class T>
inline TSglQue<T>::TSglQue()
#line 335
{}
template <class T>
inline TSglQue<T>::TSglQue(TInt aOffset)
: TSglQueBase(aOffset)
#line 354
{}
template <class T>
inline void TSglQue<T>::AddFirst(T &aRef)
#line 370
{DoAddFirst(&aRef);}
template <class T>
inline void TSglQue<T>::AddLast(T &aRef)
#line 387
{DoAddLast(&aRef);}
template <class T>
inline TBool TSglQue<T>::IsFirst(const T *aPtr) const
#line 402
{return(PtrAdd(aPtr,iOffset)==(T *)iHead);}
template <class T>
inline TBool TSglQue<T>::IsLast(const T *aPtr) const
#line 417
{return(PtrAdd(aPtr,iOffset)==(T *)iLast);}
template <class T>
inline T *TSglQue<T>::First() const
{return(PtrSub((T *)iHead,iOffset));}
template <class T>
inline T *TSglQue<T>::Last() const
{return(PtrSub((T *)iLast,iOffset));}
template <class T>
inline void TSglQue<T>::Remove(T &aRef)
#line 461
{DoRemove(&aRef);}
template <class T>
inline TDblQue<T>::TDblQue()
#line 482
{}
template <class T>
inline TDblQue<T>::TDblQue(TInt aOffset)
: TDblQueBase(aOffset)
#line 501
{}
template <class T>
inline void TDblQue<T>::AddFirst(T &aRef)
#line 517
{DoAddFirst(&aRef);}
template <class T>
inline void TDblQue<T>::AddLast(T &aRef)
#line 534
{DoAddLast(&aRef);}
template <class T>
inline TBool TDblQue<T>::IsHead(const T *aPtr) const
#line 554
{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
template <class T>
inline TBool TDblQue<T>::IsFirst(const T *aPtr) const
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
template <class T>
inline TBool TDblQue<T>::IsLast(const T *aPtr) const
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
template <class T>
inline T *TDblQue<T>::First() const
{
__DbgTestEmpty();
return(PtrSub((T *)iHead.iNext,iOffset));
}
template <class T>
inline T *TDblQue<T>::Last() const
{
__DbgTestEmpty();
return(PtrSub((T *)iHead.iPrev,iOffset));
}
template <class T>
inline TPriQue<T>::TPriQue()
#line 643
{}
template <class T>
inline TPriQue<T>::TPriQue(TInt aOffset)
: TDblQueBase(aOffset)
#line 660
{}
template <class T>
inline void TPriQue<T>::Add(T &aRef)
#line 675
{DoAddPriority(&aRef);}
template <class T>
inline TBool TPriQue<T>::IsHead(const T *aPtr) const
#line 695
{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
template <class T>
inline TBool TPriQue<T>::IsFirst(const T *aPtr) const
#line 710
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
template <class T>
inline TBool TPriQue<T>::IsLast(const T *aPtr) const
#line 725
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
template <class T>
inline T *TPriQue<T>::First() const
{return(PtrSub((T *)iHead.iNext,iOffset));}
template <class T>
inline T *TPriQue<T>::Last() const
{return(PtrSub((T *)iHead.iPrev,iOffset));}
template <class T>
inline TDeltaQue<T>::TDeltaQue()
#line 776
{}
template <class T>
inline TDeltaQue<T>::TDeltaQue(TInt aOffset)
: TDeltaQueBase(aOffset)
#line 797
{}
template <class T>
inline void TDeltaQue<T>::Add(T &aRef,TInt aDelta)
#line 815
{DoAddDelta(&aRef,aDelta);}
template <class T>
inline void TDeltaQue<T>::Remove(T &aRef)
#line 830
{DoRemove(&aRef);}
template <class T>
inline T *TDeltaQue<T>::RemoveFirst()
{return((T *) DoRemoveFirst());}
template <class T>
inline TSglQueIter<T>::TSglQueIter(TSglQueBase &aQue)
: TSglQueIterBase(aQue)
#line 871
{}
template <class T>
inline void TSglQueIter<T>::Set(T &aLink)
#line 887
{DoSet(&aLink);}
template <class T>
inline TSglQueIter<T>::operator T *()
#line 902
{return((T *)DoCurrent());}
template <class T>
inline T *TSglQueIter<T>::operator++(TInt)
#line 919
{return((T *)DoPostInc());}
template <class T>
inline TDblQueIter<T>::TDblQueIter(TDblQueBase &aQue)
: TDblQueIterBase(aQue)
#line 948
{}
template <class T>
inline void TDblQueIter<T>::Set(T &aLink)
#line 964
{DoSet(&aLink);}
template <class T>
inline TDblQueIter<T>::operator T *()
#line 985
{return((T *) DoCurrent());}
template <class T>
inline T *TDblQueIter<T>::operator++(TInt)
#line 1003
{return((T *) DoPostInc());}
template <class T>
inline T *TDblQueIter<T>::operator--(TInt)
#line 1021
{return((T *) DoPostDec());}
inline void TKey::SetPtr(const TAny *aPtr)
#line 1042
{iPtr=aPtr;}
inline TCharF::TCharF(TUint aChar)
: TChar(User::Fold(aChar))
{}
inline TCharF::TCharF(const TChar& aChar)
: TChar(User::Fold(aChar))
{}
inline TCharF& TCharF::operator=(TUint aChar)
{SetChar(User::Fold(aChar));return(*this);}
inline TCharF& TCharF::operator=(const TChar& aChar)
{SetChar(User::Fold(aChar));return(*this);}
inline TCharLC::TCharLC(TUint aChar)
: TChar(User::LowerCase(aChar))
{}
inline TCharLC::TCharLC(const TChar& aChar)
: TChar(User::LowerCase(aChar))
{}
inline TCharLC& TCharLC::operator=(TUint aChar)
{SetChar(User::LowerCase(aChar));return(*this);}
inline TCharLC& TCharLC::operator=(const TChar& aChar)
#line 1150
{SetChar(User::LowerCase(aChar));return(*this);}
inline TCharUC::TCharUC(TUint aChar)
: TChar(User::UpperCase(aChar))
{}
inline TCharUC::TCharUC(const TChar& aChar)
: TChar(User::UpperCase(aChar))
{}
inline TCharUC& TCharUC::operator=(TUint aChar)
{SetChar(User::UpperCase(aChar));return(*this);}
inline TCharUC& TCharUC::operator=(const TChar& aChar)
#line 1204
{SetChar(User::UpperCase(aChar));return(*this);}
inline TDateTime::TDateTime()
: iYear(1980),
iMonth(EJanuary),
iDay(1),
iHour(0),
iMinute(0),
iSecond(0),
iMicroSecond(0)
{}
inline TInt TDateTime::Year() const
{return(iYear);}
inline TMonth TDateTime::Month() const
{return(iMonth);}
inline TInt TDateTime::Day() const
{return(iDay);}
inline TInt TDateTime::Hour() const
{return(iHour);}
inline TInt TDateTime::Minute() const
{return(iMinute);}
inline TInt TDateTime::Second() const
{return(iSecond);}
inline TInt TDateTime::MicroSecond() const
{return(iMicroSecond);}
inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds()
{}
inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds(const TInt64& aInterval)
: iInterval(aInterval)
{}
inline TTimeIntervalMicroSeconds& TTimeIntervalMicroSeconds::operator=(const TInt64& aInterval)
{iInterval=aInterval;return(*this);}
inline TBool TTimeIntervalMicroSeconds::operator==(const TTimeIntervalMicroSeconds& aInterval) const
#line 1354
{return(iInterval==aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator!=(const TTimeIntervalMicroSeconds& aInterval) const
#line 1368
{return(iInterval!=aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator>=(const TTimeIntervalMicroSeconds& aInterval) const
#line 1383
{return(iInterval>=aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator<=(const TTimeIntervalMicroSeconds& aInterval) const
#line 1398
{return(iInterval<=aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator>(const TTimeIntervalMicroSeconds& aInterval) const
#line 1413
{return(iInterval>aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator<(const TTimeIntervalMicroSeconds& aInterval) const
#line 1428
{return(iInterval<aInterval.iInterval);}
inline const TInt64& TTimeIntervalMicroSeconds::Int64() const
{return(iInterval);}
inline TTimeIntervalBase::TTimeIntervalBase()
{}
inline TTimeIntervalBase::TTimeIntervalBase(TInt aInterval)
: iInterval(aInterval)
{}
inline TBool TTimeIntervalBase::operator==(TTimeIntervalBase aInterval) const
{return(iInterval==aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator!=(TTimeIntervalBase aInterval) const
#line 1488
{return(iInterval!=aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator>=(TTimeIntervalBase aInterval) const
#line 1503
{return(iInterval>=aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator<=(TTimeIntervalBase aInterval) const
#line 1518
{return(iInterval<=aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator>(TTimeIntervalBase aInterval) const
#line 1532
{return(iInterval>aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator<(TTimeIntervalBase aInterval) const
#line 1546
{return(iInterval<aInterval.iInterval);}
inline TInt TTimeIntervalBase::Int() const
{return(iInterval);}
inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32()
{}
inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalMicroSeconds32& TTimeIntervalMicroSeconds32::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalSeconds::TTimeIntervalSeconds()
{}
inline TTimeIntervalSeconds::TTimeIntervalSeconds(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalSeconds& TTimeIntervalSeconds::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalMinutes::TTimeIntervalMinutes()
{}
inline TTimeIntervalMinutes::TTimeIntervalMinutes(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalMinutes& TTimeIntervalMinutes::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalHours::TTimeIntervalHours()
{}
inline TTimeIntervalHours::TTimeIntervalHours(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalHours& TTimeIntervalHours::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalDays::TTimeIntervalDays()
{}
inline TTimeIntervalDays::TTimeIntervalDays(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalDays& TTimeIntervalDays::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalMonths::TTimeIntervalMonths()
{}
inline TTimeIntervalMonths::TTimeIntervalMonths(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalMonths& TTimeIntervalMonths::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalYears::TTimeIntervalYears()
{}
inline TTimeIntervalYears::TTimeIntervalYears(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalYears& TTimeIntervalYears::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTime::TTime()
{}
inline TTime::TTime(const TInt64& aTime)
: iTime(aTime)
{}
inline TTime &TTime::operator=(const TInt64& aTime)
{iTime=aTime;return(*this);}
inline TBool TTime::operator==(TTime aTime) const
{return(iTime==aTime.iTime);}
inline TBool TTime::operator!=(TTime aTime) const
{return(iTime!=aTime.iTime);}
inline TBool TTime::operator>=(TTime aTime) const
#line 1890
{return(iTime>=aTime.iTime);}
inline TBool TTime::operator<=(TTime aTime) const
#line 1905
{return(iTime<=aTime.iTime);}
inline TBool TTime::operator>(TTime aTime) const
#line 1919
{return(iTime>aTime.iTime);}
inline TBool TTime::operator<(TTime aTime) const
#line 1933
{return(iTime<aTime.iTime);}
inline const TInt64& TTime::Int64() const
{return(iTime);}
inline TLexMark8::TLexMark8()
: iPtr(0 )
{}
inline TLexMark8::TLexMark8(const TUint8 *aString)
: iPtr(aString)
{}
inline TLex8::TLex8(const TUint8 *aString)
#line 1977
{Assign(TPtrC8(aString));}
inline TLex8::TLex8(const TDesC8 &aDes)
#line 1991
{Assign(aDes);}
inline TLex8& TLex8::operator=(const TUint8* aString)
{Assign(TPtrC8(aString));return(*this);}
inline TLex8& TLex8::operator=(const TDesC8& aBuf)
{Assign(aBuf);return(*this);}
inline TBool TLex8::Eos() const
{return(iNext==iEnd);}
inline void TLex8::Mark()
{Mark(iMark);}
inline void TLex8::Mark(TLexMark8& aMark) const
{aMark.iPtr=iNext;}
inline void TLex8::UnGetToMark()
{UnGetToMark(iMark);}
inline void TLex8::SkipAndMark(TInt aNumber)
#line 2074
{SkipAndMark(aNumber,iMark);}
inline void TLex8::SkipSpaceAndMark()
{SkipSpaceAndMark(iMark);}
inline TInt TLex8::TokenLength() const
#line 2100
{return(iNext-iMark.iPtr);}
inline TInt TLex8::MarkedOffset() const
{return(iMark.iPtr-iBuf);}
inline TInt TLex8::Val(TInt &aVal)
#line 2129
{return(Val((TInt32&)aVal));}
inline TInt TLex8::Val(TUint &aVal,TRadix aRadix)
#line 2149
{return(Val((TUint32&)aVal,aRadix));}
inline void TLex8::Assign(const TLex8& aLex)
{new(this) TLex8(aLex);}
inline TLexMark16::TLexMark16()
: iPtr(0 )
{}
inline TLexMark16::TLexMark16(const TUint16 *aString)
: iPtr(aString)
{}
inline TLex16::TLex16(const TUint16 *aString)
#line 2193
{Assign(TPtrC16(aString));}
inline TLex16::TLex16(const TDesC16 &aDes)
#line 2207
{Assign(aDes);}
inline TLex16& TLex16::operator=(const TUint16* aString)
{Assign(TPtrC16(aString));return(*this);}
inline TLex16& TLex16::operator=(const TDesC16& aBuf)
{Assign(aBuf);return(*this);}
inline TBool TLex16::Eos() const
{return(iNext==iEnd);}
inline void TLex16::Mark(TLexMark16& aMark) const
{aMark.iPtr=iNext;}
inline void TLex16::Mark()
{iMark.iPtr=iNext;}
inline void TLex16::UnGetToMark()
{UnGetToMark(iMark);}
inline void TLex16::SkipAndMark(TInt aNumber)
#line 2289
{SkipAndMark(aNumber,iMark);}
inline void TLex16::SkipSpaceAndMark()
{SkipSpaceAndMark(iMark);}
inline TInt TLex16::TokenLength() const
#line 2315
{return(iNext-iMark.iPtr);}
inline TInt TLex16::MarkedOffset() const
{return(iMark.iPtr-iBuf);}
inline TInt TLex16::Val(TInt &aVal)
#line 2344
{return(Val((TInt32&)aVal));}
inline TInt TLex16::Val(TUint &aVal,TRadix aRadix)
#line 2364
{return(Val((TUint32&)aVal,aRadix));}
inline void TLex16::Assign(const TLex16& aLex)
{new(this) TLex16(aLex);}
inline TLocale::TLocale(TInt)
{}
inline TInt TLocale::CountryCode() const
#line 2393
{return(iCountryCode);}
inline void TLocale::SetCountryCode(TInt aCode)
#line 2410
{iCountryCode=aCode;}
inline TTimeIntervalSeconds TLocale::UniversalTimeOffset() const
#line 2426
{return(iUniversalTimeOffset);}
inline TDateFormat TLocale::DateFormat() const
{return(iDateFormat);}
inline void TLocale::SetDateFormat(TDateFormat aFormat)
{iDateFormat=aFormat;}
inline TTimeFormat TLocale::TimeFormat() const
{return(iTimeFormat);}
inline void TLocale::SetTimeFormat(TTimeFormat aFormat)
{iTimeFormat=aFormat;}
inline TLocalePos TLocale::CurrencySymbolPosition() const
#line 2486
{return(iCurrencySymbolPosition);}
inline void TLocale::SetCurrencySymbolPosition(TLocalePos aPos)
{iCurrencySymbolPosition=aPos;}
inline TBool TLocale::CurrencySpaceBetween() const
#line 2513
{return(iCurrencySpaceBetween);}
inline void TLocale::SetCurrencySpaceBetween(TBool aSpace)
{iCurrencySpaceBetween=aSpace;}
inline TInt TLocale::CurrencyDecimalPlaces() const
{return(iCurrencyDecimalPlaces);}
inline void TLocale::SetCurrencyDecimalPlaces(TInt aPlaces)
{iCurrencyDecimalPlaces=aPlaces;}
inline TBool TLocale::CurrencyNegativeInBrackets() const
#line 2567
{return((TBool)iNegativeCurrencyFormat);}
inline void TLocale::SetCurrencyNegativeInBrackets(TBool aBool)
#line 2587
{iNegativeCurrencyFormat=(aBool)?EInBrackets:ELeadingMinusSign;}
inline TBool TLocale::CurrencyTriadsAllowed() const
{return(iCurrencyTriadsAllowed);}
inline void TLocale::SetCurrencyTriadsAllowed(TBool aBool)
{iCurrencyTriadsAllowed=aBool;}
inline TChar TLocale::ThousandsSeparator() const
#line 2625
{return(iThousandsSeparator);}
inline void TLocale::SetThousandsSeparator(const TChar& aChar)
#line 2640
{iThousandsSeparator=aChar;}
inline TChar TLocale::DecimalSeparator() const
{return(iDecimalSeparator);}
inline void TLocale::SetDecimalSeparator(const TChar& aChar)
{iDecimalSeparator=aChar;}
inline TChar TLocale::DateSeparator(TInt aIndex) const
#line 2682
{return(iDateSeparator[aIndex]);}
inline void TLocale::SetDateSeparator(const TChar& aChar,TInt aIndex)
#line 2700
{(void)((aIndex>=0 && aIndex<KMaxDateSeparators)||(User::Invariant(),0)) ;
iDateSeparator[aIndex]=aChar;}
inline TChar TLocale::TimeSeparator(TInt aIndex) const
#line 2721
{return(iTimeSeparator[aIndex]);}
inline void TLocale::SetTimeSeparator(const TChar& aChar,TInt aIndex)
#line 2739
{(void)((aIndex>=0 && aIndex<KMaxTimeSeparators)||(User::Invariant(),0)) ;
iTimeSeparator[aIndex]=aChar;}
inline TLocalePos TLocale::AmPmSymbolPosition() const
{return(iAmPmSymbolPosition);}
inline void TLocale::SetAmPmSymbolPosition(TLocalePos aPos)
{iAmPmSymbolPosition=aPos;}
inline TBool TLocale::AmPmSpaceBetween() const
{return(iAmPmSpaceBetween);}
inline void TLocale::SetAmPmSpaceBetween(TBool aSpace)
{iAmPmSpaceBetween=aSpace;}
inline TUint TLocale::DaylightSaving() const
#line 2817
{return(iDaylightSaving);}
inline TBool TLocale::QueryHomeHasDaylightSavingOn() const
#line 2832
{return((iHomeDaylightSavingZone|EDstHome) & iDaylightSaving);}
inline TDaylightSavingZone TLocale::HomeDaylightSavingZone() const
{return(iHomeDaylightSavingZone);}
inline TUint TLocale::WorkDays() const
#line 2859
{return(iWorkDays);}
inline void TLocale::SetWorkDays(TUint aMask)
{iWorkDays=aMask;}
inline TDay TLocale::StartOfWeek() const
{return(iStartOfWeek);}
inline void TLocale::SetStartOfWeek(TDay aDay)
{iStartOfWeek=aDay;}
inline TClockFormat TLocale::ClockFormat() const
{return(iClockFormat);}
inline void TLocale::SetClockFormat(TClockFormat aFormat)
{iClockFormat=aFormat;}
inline TUnitsFormat TLocale::UnitsGeneral() const
#line 2930
{return(iUnitsGeneral);}
inline void TLocale::SetUnitsGeneral(TUnitsFormat aFormat)
{iUnitsGeneral=aFormat;}
inline TUnitsFormat TLocale::UnitsDistanceShort() const
#line 2957
{return(iUnitsDistanceShort);}
inline void TLocale::SetUnitsDistanceShort(TUnitsFormat aFormat)
#line 2971
{iUnitsDistanceShort=aFormat;}
inline TUnitsFormat TLocale::UnitsDistanceLong() const
#line 2985
{return(iUnitsDistanceLong);}
inline void TLocale::SetUnitsDistanceLong(TUnitsFormat aFormat)
#line 2999
{iUnitsDistanceLong=aFormat;}
inline void TLocale::SetNegativeCurrencyFormat(TLocale::TNegativeCurrencyFormat aNegativeCurrencyFormat)
{iNegativeCurrencyFormat = aNegativeCurrencyFormat;}
inline TLocale::TNegativeCurrencyFormat TLocale::NegativeCurrencyFormat() const
{return(iNegativeCurrencyFormat);}
inline TBool TLocale::NegativeLoseSpace() const
{
if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeLoseSpace)==iExtraNegativeCurrencyFormatFlags)
return ETrue;
else
return EFalse;
}
inline void TLocale::SetNegativeLoseSpace(TBool aBool)
{
if(aBool)
iExtraNegativeCurrencyFormatFlags |= EFlagNegativeLoseSpace;
else
iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeLoseSpace;
}
inline TBool TLocale::NegativeCurrencySymbolOpposite() const
#line 3074
{
if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeCurrencySymbolOpposite)==iExtraNegativeCurrencyFormatFlags)
return ETrue;
else
return EFalse;
}
inline void TLocale::SetNegativeCurrencySymbolOpposite(TBool aBool)
#line 3097
{
if (aBool)
iExtraNegativeCurrencyFormatFlags |= EFlagNegativeCurrencySymbolOpposite;
else
iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeCurrencySymbolOpposite;
}
inline TLanguage TLocale::LanguageDowngrade(TInt aIndex) const
#line 3130
{
(void)((0 <= aIndex && aIndex < 3)||( User::Invariant(),0)) ;
return static_cast<TLanguage>(iLanguageDowngrade[aIndex]);
}
inline void TLocale::SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage)
#line 3151
{
(void)((0 <= aIndex && aIndex < 3)||( User::Invariant(),0)) ;
iLanguageDowngrade[aIndex] = static_cast<TUint16>(aLanguage);
}
#line 3164
inline TDigitType TLocale::DigitType() const
{ return iDigitType; }
#line 3175
inline void TLocale::SetDigitType(TDigitType aDigitType)
{ iDigitType=aDigitType; }
#line 3188
inline void TLocale::SetDeviceTime(TDeviceTimeState aState)
{
iDeviceTimeState=aState;
}
inline TLocale* TExtendedLocale::GetLocale()
{ return &iLocale; }
#line 3205
inline TLocale::TDeviceTimeState TLocale::DeviceTime() const
{
return iDeviceTimeState;
}
inline TInt TFindHandleBase::Handle() const
#line 3225
{return(iFindHandle);}
inline TFindSemaphore::TFindSemaphore()
: TFindHandleBase()
#line 3244
{}
inline TFindSemaphore::TFindSemaphore(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3264
{}
inline TFindMutex::TFindMutex()
: TFindHandleBase()
#line 3283
{}
inline TFindMutex::TFindMutex(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3303
{}
inline TFindChunk::TFindChunk()
: TFindHandleBase()
#line 3322
{}
inline TFindChunk::TFindChunk(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3339
{}
inline TFindThread::TFindThread()
: TFindHandleBase()
#line 3358
{}
inline TFindThread::TFindThread(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3373
{}
inline TFindProcess::TFindProcess()
: TFindHandleBase()
#line 3392
{}
inline TFindProcess::TFindProcess(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3407
{}
inline TFindLogicalDevice::TFindLogicalDevice()
: TFindHandleBase()
{}
inline TFindLogicalDevice::TFindLogicalDevice(const TDesC &aMatch)
: TFindHandleBase(aMatch)
{}
inline TFindPhysicalDevice::TFindPhysicalDevice()
: TFindHandleBase()
{}
inline TFindPhysicalDevice::TFindPhysicalDevice(const TDesC &aMatch)
: TFindHandleBase(aMatch)
{}
inline TFindServer::TFindServer()
: TFindHandleBase()
#line 3446
{}
inline TFindServer::TFindServer(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3463
{}
inline TFindLibrary::TFindLibrary()
: TFindHandleBase()
{}
inline TFindLibrary::TFindLibrary(const TDesC &aMatch)
: TFindHandleBase(aMatch)
{}
inline TInt RDevice::Open(const TFindLogicalDevice& aFind,TOwnerType aType)
{return(RHandleBase::Open(aFind,aType));}
inline TBool RCriticalSection::IsBlocked() const
{return(iBlocked!=1);}
inline TInt RMutex::Open(const TFindMutex& aFind,TOwnerType aType)
#line 3536
{return(RHandleBase::Open(aFind,aType));}
inline TInt RChunk::Open(const TFindChunk& aFind,TOwnerType aType)
#line 3560
{return(RHandleBase::Open(aFind,aType));}
inline TBool RChunk::IsReadable() const
{return (Attributes()&RHandleBase::EDirectReadAccess); }
inline TBool RChunk::IsWritable() const
{return (Attributes()&RHandleBase::EDirectWriteAccess); }
inline TObjectId::TObjectId()
{}
inline TObjectId::TObjectId(TUint64 aId)
: iId(aId)
{}
inline TUint64 TObjectId::Id() const
{ return iId; }
inline TObjectId::operator TUint() const
{ return TUint(iId); }
inline TBool TObjectId::operator==(TObjectId aId) const
{return iId==aId.iId;}
inline TBool TObjectId::operator!=(TObjectId aId) const
{return iId!=aId.iId;}
inline TThreadId::TThreadId()
: TObjectId()
{}
inline TThreadId::TThreadId(TUint64 aId)
: TObjectId(aId)
{}
inline RThread::RThread()
: RHandleBase(KCurrentThreadHandle)
#line 3691
{}
inline TInt RThread::Open(const TFindThread& aFind,TOwnerType aType)
#line 3714
{return(RHandleBase::Open(aFind,aType));}
inline TBool RThread::HasCapability(TCapability aCapability, const char* aDiagnostic) const
{
return DoHasCapability(aCapability, aDiagnostic);
}
inline TBool RThread::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
{
return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
}
#line 3761
inline TProcessId::TProcessId()
: TObjectId()
{}
inline TProcessId::TProcessId(TUint64 aId)
: TObjectId(aId)
{}
inline RProcess::RProcess()
: RHandleBase(KCurrentProcessHandle)
#line 3795
{}
inline RProcess::RProcess(TInt aHandle)
: RHandleBase(aHandle)
{}
inline TInt RProcess::Open(const TFindProcess& aFind,TOwnerType aType)
#line 3830
{return(RHandleBase::Open(aFind,aType));}
inline TBool RProcess::HasCapability(TCapability aCapability, const char* aDiagnostic) const
{
return DoHasCapability(aCapability, aDiagnostic);
}
inline TBool RProcess::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
{
return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
}
#line 3902
inline TInt RSessionBase::CreateSession(const TDesC& aServer,const TVersion& aVersion)
{return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,0 ,0);}
#line 3926
inline TInt RSessionBase::CreateSession(RServer2 aServer,const TVersion& aVersion)
{return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,0 ,0);}
#line 3950
inline TInt RSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSend(aFunction,&aArgs);}
#line 3971
inline void RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
{DoSendReceive(aFunction,&aArgs,aStatus);}
#line 3992
inline TInt RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSendReceive(aFunction,&aArgs);}
#line 4014
inline TInt RSessionBase::Send(TInt aFunction) const
{return DoSend(aFunction,0 );}
#line 4033
inline void RSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
{ DoSendReceive(aFunction,0 ,aStatus);}
#line 4055
inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError)
{ return RHandleBase::SetReturnedHandle(aHandleOrError);}
inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle)
{ return RHandleBase::SetReturnedHandle(aHandleOrError,aHandle);}
#line 4076
inline TInt RSessionBase::SendReceive(TInt aFunction) const
{return DoSendReceive(aFunction,0 );}
inline RSubSessionBase::RSubSessionBase()
: iSubSessionHandle(0)
{}
inline TInt RSubSessionBase::SubSessionHandle() const
#line 4102
{return iSubSessionHandle;}
inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs)
{ return DoCreateSubSession(aSession,aFunction,&aArgs); }
inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction)
{ return DoCreateSubSession(aSession,aFunction,0 ); }
inline TInt RSubSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSend(aFunction,&aArgs);}
inline void RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
{DoSendReceive(aFunction,&aArgs,aStatus);}
inline TInt RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSendReceive(aFunction,&aArgs);}
inline TInt RSubSessionBase::Send(TInt aFunction) const
{return DoSend(aFunction,0 );}
inline void RSubSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
{ DoSendReceive(aFunction,0 ,aStatus);}
inline TInt RSubSessionBase::SendReceive(TInt aFunction) const
{return DoSendReceive(aFunction,0 );}
#line 4132
inline RRefBase::RRefBase()
: iPtr(0 )
{}
#line 4143
inline RRefBase::RRefBase(const RRefBase &aRef)
{Copy(aRef);}
#line 4155
template <class T>
inline RRef<T>::RRef()
{}
#line 4171
template <class T>
inline RRef<T>::RRef(const RRef<T> &anObject)
{Copy(anObject);}
#line 4188
template <class T>
inline void RRef<T>::operator=(const RRef<T> &anObject)
{Copy(anObject);}
#line 4200
template <class T>
inline T *RRef<T>::operator->()
{return((T *)iPtr);}
#line 4212
template <class T>
inline RRef<T>::operator T*()
{return((T *)iPtr);}
#line 4228
template <class T>
void RRef<T>::Alloc(const T &anObject)
{DoAlloc(&anObject,sizeof(T));}
#line 4245
template <class T>
void RRef<T>::Alloc(const T &anObject,TInt aSize)
{DoAlloc(&anObject,aSize);}
#line 4261
template <class T>
void RRef<T>::AllocL(const T &anObject)
{DoAllocL(&anObject,sizeof(T));}
#line 4278
template <class T>
void RRef<T>::AllocL(const T &anObject,TInt aSize)
{DoAllocL(&anObject,aSize);}
inline TBool TRegion::CheckError() const
#line 4307
{return(iError);}
inline TInt TRegion::Count() const
{return(iCount);}
inline const TRect *TRegion::RectangleList() const
#line 4333
{return(((TRegion *)this)->RectangleListW());}
inline TRegion::TRegion()
{}
inline TInt RRegion::CheckSpare() const
#line 4354
{return(iAllocedRects-iCount);}
template <TInt S>
inline TRegionFix<S>::TRegionFix() : TRegion(-S)
{}
template <TInt S>
inline TRegionFix<S>::TRegionFix(const TRect &aRect) : TRegion(-S)
{AddRect(aRect);}
template <TInt S>
inline TRegionFix<S>::TRegionFix(const TRegionFix<S> &aRegion)
{*this=aRegion;}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf() : RRegion(-S&(~ERRegionBuf),S)
{}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf(const RRegion &aRegion)
{*this=aRegion;}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf(const TRect &aRect) : RRegion(-S&(~ERRegionBuf),S)
#line 4427
{AddRect(aRect);}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf(const RRegionBuf<S> &aRegion)
{*this=aRegion;}
inline TTimerLockSpec &operator++(TTimerLockSpec &aLock)
{
return aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
}
inline TTimerLockSpec operator++(TTimerLockSpec &aLock, TInt)
{
TTimerLockSpec l=aLock;
aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
return l;
}
inline const TUidType& TCheckedUid::UidType() const
{return(iType);}
template <class T>
void _DeleteArray(T** aBegin,T** aEnd)
{for (;;) if (aBegin<aEnd) delete *aBegin++; else return;}
template <class T>
struct _ArrayUtil
{
static inline void Delete(T* aBegin,T* aEnd,CBase*)
{::_DeleteArray((CBase**)aBegin,(CBase**)aEnd);}
static inline void Delete(T* aBegin,T* aEnd,TAny*)
{::_DeleteArray(aBegin,aEnd);}
static inline void Delete(T* aArray,TInt aCount)
{Delete(aArray,aArray+aCount,*aArray);}
};
__declspec(dllexport) void PanicTFixedArray();
template <class T,TInt S>
inline TFixedArray<T,S>::TFixedArray()
{}
template <class T,TInt S>
inline void TFixedArray<T,S>::Copy(const T* aList,TInt aLength)
#line 4529
{(void)((TUint(aLength)<=TUint(S))||(PanicTFixedArray(),0)) ;Mem::Copy(iRep,aList,aLength*sizeof(T));}
template <class T,TInt S>
inline TFixedArray<T,S>::TFixedArray(const T* aList,TInt aLength)
#line 4547
{Copy(aList,aLength);}
template <class T,TInt S>
inline void TFixedArray<T,S>::Reset()
{Mem::FillZ(iRep,sizeof(iRep));}
template <class T,TInt S>
inline TInt TFixedArray<T,S>::Count() const
#line 4572
{return S;}
template <class T,TInt S>
inline TInt TFixedArray<T,S>::Length() const
{return sizeof(T);}
template <class T,TInt S>
inline TBool TFixedArray<T,S>::InRange(TInt aIndex)
{return TUint(aIndex)<S;}
template <class T,TInt S>
inline T& TFixedArray<T,S>::operator[](TInt aIndex)
#line 4610
{(void)((InRange(aIndex))||(PanicTFixedArray(),0)) ;return iRep[aIndex];}
template <class T,TInt S>
inline const T& TFixedArray<T,S>::operator[](TInt aIndex) const
#line 4630
{return (const_cast<ThisClass&>(*this)) [aIndex];}
template <class T,TInt S>
inline T& TFixedArray<T,S>::At(TInt aIndex)
#line 4649
{(void)((InRange(aIndex))||(PanicTFixedArray(),0)) ;return iRep[aIndex];}
template <class T,TInt S>
inline const T& TFixedArray<T,S>::At(TInt aIndex) const
#line 4669
{return (const_cast<ThisClass&>(*this)) .At(aIndex);}
template <class T,TInt S>
inline T* TFixedArray<T,S>::Begin()
{return &iRep[0];}
template <class T,TInt S>
inline T* TFixedArray<T,S>::End()
{return &iRep[S];}
template <class T,TInt S>
inline const T* TFixedArray<T,S>::Begin() const
{return &iRep[0];}
template <class T,TInt S>
inline const T* TFixedArray<T,S>::End() const
{return &iRep[S];}
template <class T,TInt S>
inline TInt TFixedArray<T,S>::CountFunctionR(const CBase*)
{return S;}
template <class T,TInt S>
inline const TAny* TFixedArray<T,S>::AtFunctionR(const CBase* aThis,TInt aIndex)
{return &(reinterpret_cast<const ThisClass&>(*aThis)) [aIndex];}
template <class T,TInt S>
inline TArray<T> TFixedArray<T,S>::Array() const
{return TArray<T>(CountFunctionR,AtFunctionR,(reinterpret_cast<const CBase*>(this)) );}
template <class T,TInt S>
inline void TFixedArray<T,S>::DeleteAll()
#line 4759
{_ArrayUtil<T>::Delete(iRep,S);}
inline RHeap* User::SwitchHeap(RAllocator* aHeap)
{ return (RHeap*)SwitchAllocator(aHeap); }
inline RHeap& User::Heap()
{ return (RHeap&)Allocator(); }
inline TBool User::CreatorHasCapability(TCapability aCapability, const char* aDiagnostic)
{
return DoCreatorHasCapability(aCapability, aDiagnostic);
}
inline TBool User::CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic)
{
return DoCreatorHasCapability(aCapability1, aCapability2, aDiagnostic);
}
#line 4833
inline void TSecurityInfo::SetToCurrentInfo()
{ new (this) TSecurityInfo(RProcess()); }
inline void TSecurityInfo::Set(RProcess aProcess)
{ new (this) TSecurityInfo(aProcess); }
inline void TSecurityInfo::Set(RThread aThread)
{ new (this) TSecurityInfo(aThread); }
inline void TSecurityInfo::Set(RMessagePtr2 aMsgPtr)
{ new (this) TSecurityInfo(aMsgPtr); }
#line 4869
inline TBool TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
{
return DoCheckPolicy(aProcess, aDiagnostic);
}
#line 4892
inline TBool TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
{
return DoCheckPolicy(aThread, aDiagnostic);
}
#line 4914
inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
{
return DoCheckPolicy(aMsgPtr, aDiagnostic);
}
#line 4938
inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
{
return DoCheckPolicy(aMsgPtr, aMissing, aDiagnostic);
}
#line 4958
inline TBool TSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
{
return DoCheckPolicyCreator(aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aProcess, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aThread, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aMsgPtr, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aMsgPtr, aMissing, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
{
return (&(*this))->CheckPolicyCreator(aDiagnostic);
}
#line 5241
template <class T>
inline void RPointerArray<T>::AppendL(const T* anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 5262
template <class T>
inline void RPointerArray<T>::InsertL(const T* anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry,aPos)); }
#line 5282
template <class T>
inline TInt RPointerArray<T>::FindL(const T* anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 5306
template <class T>
inline TInt RPointerArray<T>::FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const
{ return User::LeaveIfError(Find(anEntry, anIdentity));}