Symbian

开发平台：

C/C++

S60UIExample.inc：源码内容

__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 3 */
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));}
#line 5324
template <class T>
inline TInt RPointerArray<T>::FindInAddressOrderL(const T* anEntry) const
{ return User::LeaveIfError(FindInAddressOrder(anEntry));}
#line 5347
template <class T>
inline TInt RPointerArray<T>::FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const
{ return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
#line 5370
template <class T>
inline void RPointerArray<T>::FindInAddressOrderL(const T* anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
#line 5398
template <class T>
inline void RPointerArray<T>::FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder)); }
#line 5430
template <class T>
inline TInt RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
#line 5466
template <class T>
inline TInt RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
#line 5504
template <class T>
inline void RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
#line 5546
template <class T>
inline void RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode)); }
#line 5564
template <class T>
inline void RPointerArray<T>::InsertInAddressOrderL(const T* anEntry)
{ User::LeaveIfError(InsertInAddressOrder(anEntry)); }
#line 5592
template <class T>
inline void RPointerArray<T>::InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrder(anEntry, anOrder)); }
#line 5614
template <class T>
inline void RPointerArray<T>::InsertInAddressOrderAllowRepeatsL(const T* anEntry)
{ User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
#line 5639
template <class T>
inline void RPointerArray<T>::InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder)); }
#line 5656
template <class T>
inline void RPointerArray<T>::ReserveL(TInt aCount)
{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
#line 5673
inline void RPointerArray<TAny>::AppendL(const TAny* anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 5693
inline void RPointerArray<TAny>::InsertL(const TAny* anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry,aPos)); }
#line 5712
inline TInt RPointerArray<TAny>::FindL(const TAny* anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 5729
inline TInt RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry) const
{ return User::LeaveIfError(FindInAddressOrder(anEntry));}
#line 5751
inline void RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
#line 5782
inline TInt RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
#line 5819
inline void RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
#line 5835
inline void RPointerArray<TAny>::InsertInAddressOrderL(const TAny* anEntry)
{ User::LeaveIfError(InsertInAddressOrder(anEntry)); }
#line 5856
inline void RPointerArray<TAny>::InsertInAddressOrderAllowRepeatsL(const TAny* anEntry)
{ User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
#line 5869
template <class T>
inline void RArray<T>::AppendL(const T& anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 5890
template <class T>
inline void RArray<T>::InsertL(const T& anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry, aPos));}
#line 5912
template <class T>
inline TInt RArray<T>::FindL(const T& anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 5937
template <class T>
inline TInt RArray<T>::FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const
{ return User::LeaveIfError(Find(anEntry, anIdentity));}
#line 5956
template <class T>
inline TInt RArray<T>::FindInSignedKeyOrderL(const T& anEntry) const
{ return User::LeaveIfError(FindInSignedKeyOrder(anEntry));}
#line 5975
template <class T>
inline TInt RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry) const
{ return User::LeaveIfError(FindInUnsignedKeyOrder(anEntry));}
#line 5997
template <class T>
inline TInt RArray<T>::FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const
{ return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
#line 6018
template <class T>
inline void RArray<T>::FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInSignedKeyOrder(anEntry, anIndex));}
#line 6039
template <class T>
inline void RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInUnsignedKeyOrder(anEntry, anIndex));}
#line 6063
template <class T>
inline void RArray<T>::FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder));}
#line 6096
template <class T>
inline TInt RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, aMode));}
#line 6130
template <class T>
inline TInt RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, aMode));}
#line 6166
template <class T>
inline TInt RArray<T>::SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
#line 6207
template <class T>
inline void RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, anIndex, aMode));}
#line 6246
template <class T>
inline void RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, anIndex, aMode));}
#line 6288
template <class T>
inline void RArray<T>::SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode));}
#line 6309
template <class T>
inline void RArray<T>::InsertInSignedKeyOrderL(const T& anEntry)
{ User::LeaveIfError(InsertInSignedKeyOrder(anEntry));}
#line 6329
template <class T>
inline void RArray<T>::InsertInUnsignedKeyOrderL(const T& anEntry)
{ User::LeaveIfError(InsertInUnsignedKeyOrder(anEntry));}
#line 6355
template <class T>
inline void RArray<T>::InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrder(anEntry, anOrder));}
#line 6378
template <class T>
inline void RArray<T>::InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry)
{ User::LeaveIfError(InsertInSignedKeyOrderAllowRepeats(anEntry));}
#line 6401
template <class T>
inline void RArray<T>::InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry)
{ User::LeaveIfError(InsertInUnsignedKeyOrderAllowRepeats(anEntry));}
#line 6427
template <class T>
inline void RArray<T>::InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder));}
#line 6444
template <class T>
inline void RArray<T>::ReserveL(TInt aCount)
{ User::LeaveIfError(RArrayBase::DoReserve(aCount)); }
#line 6460
inline void RArray<TInt>::AppendL(TInt anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 6479
inline void RArray<TInt>::InsertL(TInt anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry, aPos));}
#line 6497
inline TInt RArray<TInt>::FindL(TInt anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 6514
inline TInt RArray<TInt>::FindInOrderL(TInt anEntry) const
{ return User::LeaveIfError(FindInOrder(anEntry));}
#line 6535
inline void RArray<TInt>::FindInOrderL(TInt anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex));}
#line 6566
inline TInt RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
#line 6603
inline void RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
#line 6623
inline void RArray<TInt>::InsertInOrderL(TInt anEntry)
{ User::LeaveIfError(InsertInOrder(anEntry));}
#line 6645
inline void RArray<TInt>::InsertInOrderAllowRepeatsL(TInt anEntry)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
#line 6661
inline void RArray<TInt>::ReserveL(TInt aCount)
{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
#line 6676
inline void RArray<TUint>::AppendL(TUint anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 6696
inline void RArray<TUint>::InsertL(TUint anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry, aPos));}
#line 6713
inline TInt RArray<TUint>::FindL(TUint anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 6731
inline TInt RArray<TUint>::FindInOrderL(TUint anEntry) const
{ return User::LeaveIfError(FindInOrder(anEntry));}
#line 6755
inline void RArray<TUint>::FindInOrderL(TUint anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex));}
#line 6786
inline TInt RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
#line 6822
inline void RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
#line 6842
inline void RArray<TUint>::InsertInOrderL(TUint anEntry)
{ User::LeaveIfError(InsertInOrder(anEntry));}
#line 6864
inline void RArray<TUint>::InsertInOrderAllowRepeatsL(TUint anEntry)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
#line 6880
inline void RArray<TUint>::ReserveL(TInt aCount)
{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
#line 6891
inline void RMessagePtr2::SetProcessPriorityL(TProcessPriority aPriority) const
{ User::LeaveIfError(SetProcessPriority(aPriority));}
#line 6903
inline void RMessagePtr2::ClientL(RThread& aClient, TOwnerType aOwnerType) const
{ User::LeaveIfError(Client(aClient, aOwnerType));}
inline TBool RMessagePtr2::HasCapability(TCapability aCapability, const char* aDiagnostic) const
{
return DoHasCapability(aCapability, aDiagnostic);
}
inline void RMessagePtr2::HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage) const
{
if (!HasCapability(aCapability, aDiagnosticMessage))
{
User::Leave(KErrPermissionDenied);
}
}
inline TBool RMessagePtr2::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
{
return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
}
inline void RMessagePtr2::HasCapabilityL(TCapability aCapability1, TCapability aCapability2, const char* aDiagnosticMessage) const
{
if (!HasCapability(aCapability1, aCapability2, aDiagnosticMessage))
{
User::Leave(KErrPermissionDenied);
}
}
#line 6995
inline TInt RThread::RenameMe(const TDesC& aName)
{ return User::RenameThread(aName); }
inline TInt RProcess::RenameMe(const TDesC& aName)
{ return User::RenameProcess(aName); }
#line 7044
extern "C" bool __uncaught_exception(void);
namespace std {
inline bool uncaught_exception(void) { return ::__uncaught_exception(); }
}
#line 4892 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 2 */
#line 10 "C:\Symbian\9.1\S60_3rd\epoc32\include\eikstart.h" /* stack depth 1 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\apparc.h" /* stack depth 2 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.h" /* stack depth 3 */
#line 13
class CBase
#line 42
{
public:
inline CBase() {}
__declspec(dllexport) virtual ~CBase();
inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
inline TAny* operator new(TUint aSize) throw() ;
inline TAny* operator new(TUint aSize, TLeave);
inline TAny* operator new(TUint aSize, TUint aExtraSize) throw() ;
inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize);
__declspec(dllexport) static void Delete(CBase* aPtr);
protected:
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
private:
CBase(const CBase&);
CBase& operator=(const CBase&);
private:
};
class CBufBase : public CBase
#line 86
{
public:
__declspec(dllexport) ~CBufBase();
inline TInt Size() const;
__declspec(dllexport) void Reset();
__declspec(dllexport) void Read(TInt aPos,TDes8& aDes) const;
__declspec(dllexport) void Read(TInt aPos,TDes8& aDes,TInt aLength) const;
__declspec(dllexport) void Read(TInt aPos,TAny* aPtr,TInt aLength) const;
__declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes);
__declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes,TInt aLength);
__declspec(dllexport) void Write(TInt aPos,const TAny* aPtr,TInt aLength);
__declspec(dllexport) void InsertL(TInt aPos,const TDesC8& aDes);
__declspec(dllexport) void InsertL(TInt aPos,const TDesC8& aDes,TInt aLength);
__declspec(dllexport) void InsertL(TInt aPos,const TAny* aPtr,TInt aLength);
__declspec(dllexport) void ExpandL(TInt aPos,TInt aLength);
__declspec(dllexport) void ResizeL(TInt aSize);
#line 117
virtual void Compress()=0;
#line 131
virtual void Delete(TInt aPos,TInt aLength)=0;
#line 147
virtual TPtr8 Ptr(TInt aPos)=0;
#line 168
virtual TPtr8 BackPtr(TInt aPos)=0;
private:
virtual void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength)=0;
protected:
__declspec(dllexport) CBufBase(TInt anExpandSize);
protected:
TInt iSize;
TInt iExpandSize;
};
class CBufFlat : public CBufBase
#line 195
{
public:
__declspec(dllexport) ~CBufFlat();
__declspec(dllexport) static CBufFlat* NewL(TInt anExpandSize);
inline TInt Capacity() const;
__declspec(dllexport) void SetReserveL(TInt aSize);
__declspec(dllexport) void Compress();
__declspec(dllexport) void Delete(TInt aPos,TInt aLength);
__declspec(dllexport) TPtr8 Ptr(TInt aPos);
__declspec(dllexport) TPtr8 BackPtr(TInt aPos);
protected:
__declspec(dllexport) CBufFlat(TInt anExpandSize);
private:
__declspec(dllexport) void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
private:
TInt iMaxSize;
TUint8* iPtr;
};
class TBufSegLink;
class CBufSeg : public CBufBase
#line 238
{
public:
__declspec(dllexport) ~CBufSeg();
__declspec(dllexport) static CBufSeg* NewL(TInt anExpandSize);
__declspec(dllexport) void Compress();
__declspec(dllexport) void Delete(TInt aPos,TInt aLength);
__declspec(dllexport) TPtr8 Ptr(TInt aPos);
__declspec(dllexport) TPtr8 BackPtr(TInt aPos);
protected:
__declspec(dllexport) CBufSeg(TInt anExpandSize);
void InsertIntoSegment(TBufSegLink* aSeg,TInt anOffset,const TAny* aPtr,TInt aLength);
void DeleteFromSegment(TBufSegLink* aSeg,TInt anOffset,TInt aLength);
void FreeSegment(TBufSegLink* aSeg);
void SetSBO(TInt aPos);
void AllocSegL(TBufSegLink* aSeg,TInt aNumber);
private:
__declspec(dllexport) void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
private:
TDblQue<TBufSegLink> iQue;
TBufSegLink* iSeg;
TInt iBase;
TInt iOffset;
};
class TKeyArrayFix : public TKey
#line 289
{
public:
__declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpText aType);
__declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpText aType,TInt aLength);
__declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpNumeric aType);
protected:
__declspec(dllexport) virtual void Set(CBufBase* aBase,TInt aRecordLength);
__declspec(dllexport) TAny* At(TInt anIndex) const;
protected:
TInt iRecordLength;
CBufBase* iBase;
friend class CArrayFixBase;
};
typedef CBufBase*(*TBufRep)(TInt anExpandSize);
class CArrayFixBase : public CBase
#line 319
{
public:
__declspec(dllexport) ~CArrayFixBase();
inline TInt Count() const;
inline TInt Length() const;
__declspec(dllexport) void Compress();
__declspec(dllexport) void Reset();
__declspec(dllexport) TInt Sort(TKeyArrayFix& aKey);
__declspec(dllexport) TAny* At(TInt anIndex) const;
__declspec(dllexport) TAny* End(TInt anIndex) const;
__declspec(dllexport) TAny* Back(TInt anIndex) const;
__declspec(dllexport) void Delete(TInt anIndex);
__declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
__declspec(dllexport) TAny* ExpandL(TInt anIndex);
__declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
__declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr);
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aCount);
__declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TKeyArrayFix& aKey);
__declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TKeyArrayFix& aKey);
__declspec(dllexport) void ResizeL(TInt aCount,const TAny* aPtr);
protected:
__declspec(dllexport) CArrayFixBase(TBufRep aRep,TInt aRecordLength,TInt aGranularity);
__declspec(dllexport) void InsertRepL(TInt anIndex,const TAny* aPtr,TInt aReplicas);
__declspec(dllexport) void SetKey(TKeyArrayFix& aKey) const;
__declspec(dllexport) void SetReserveFlatL(TInt aCount);
__declspec(dllexport) static TInt CountR(const CBase* aPtr);
__declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
private:
TInt iCount;
TInt iGranularity;
TInt iLength;
TBufRep iCreateRep;
CBufBase* iBase;
};
template <class T>
class CArrayFix : public CArrayFixBase
#line 370
{
public:
inline CArrayFix(TBufRep aRep,TInt aGranularity);
inline const T& operator[](TInt anIndex) const;
inline T& operator[](TInt anIndex);
inline const T& At(TInt anIndex) const;
inline const T* End(TInt anIndex) const;
inline const T* Back(TInt anIndex) const;
inline T& At(TInt anIndex);
inline T* End(TInt anIndex);
inline T* Back(TInt anIndex);
inline void AppendL(const T& aRef);
inline void AppendL(const T* aPtr,TInt aCount);
inline void AppendL(const T& aRef,TInt aReplicas);
inline T& ExpandL(TInt anIndex);
inline T& ExtendL();
inline TInt Find(const T& aRef,TKeyArrayFix& aKey,TInt& anIndex) const;
inline TInt FindIsq(const T& aRef,TKeyArrayFix& aKey,TInt& anIndex) const;
inline void InsertL(TInt anIndex,const T& aRef);
inline void InsertL(TInt anIndex,const T* aPtr,TInt aCount);
inline void InsertL(TInt anIndex,const T& aRef,TInt aReplicas);
inline TInt InsertIsqL(const T& aRef,TKeyArrayFix& aKey);
inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TKeyArrayFix& aKey);
inline void ResizeL(TInt aCount);
inline void ResizeL(TInt aCount,const T& aRef);
inline const TArray<T> Array() const;
};
template<> class CArrayFix<TAny> : public CArrayFixBase
#line 413
{
public:
inline CArrayFix(TBufRep aRep,TInt aRecordLength,TInt aGranularity);
inline const TAny* At(TInt anIndex) const;
inline const TAny* End(TInt anIndex) const;
inline const TAny* Back(TInt anIndex) const;
inline TAny* At(TInt anIndex);
inline TAny* End(TInt anIndex);
inline TAny* Back(TInt anIndex);
inline void AppendL(const TAny* aPtr);
inline void AppendL(const TAny* aPtr,TInt aCount);
inline TAny* ExtendL();
};
template <class T>
class CArrayFixFlat : public CArrayFix<T>
#line 452
{
public:
inline explicit CArrayFixFlat(TInt aGranularity);
inline void SetReserveL(TInt aCount);
};
template<> class CArrayFixFlat<TAny> : public CArrayFix<TAny>
#line 479
{
public:
inline CArrayFixFlat(TInt aRecordLength,TInt aGranularity);
inline void SetReserveL(TInt aCount);
};
template<> class CArrayFixFlat<TInt> : public CArrayFix<TInt>
#line 498
{
public:
__declspec(dllexport) explicit CArrayFixFlat(TInt aGranularity);
__declspec(dllexport) ~CArrayFixFlat();
inline void SetReserveL(TInt aCount);
};
template<> class CArrayFixFlat<TUid> : public CArrayFix<TUid>
#line 518
{
public:
__declspec(dllexport) explicit CArrayFixFlat(TInt aGranularity);
__declspec(dllexport) ~CArrayFixFlat();
inline void SetReserveL(TInt aCount);
};
template <class T>
class CArrayFixSeg : public CArrayFix<T>
#line 545
{
public:
inline explicit CArrayFixSeg(TInt aGranularity);
};
template<> class CArrayFixSeg<TAny> : public CArrayFix<TAny>
#line 571
{
public:
inline CArrayFixSeg(TInt aRecordLength,TInt aGranularity);
};
template <class T>
class CArrayPtr : public CArrayFix<T*>
#line 591
{
public:
inline CArrayPtr(TBufRep aRep,TInt aGranularity);
void ResetAndDestroy();
};
template <class T>
class CArrayPtrFlat : public CArrayPtr<T>
#line 624
{
public:
inline explicit CArrayPtrFlat(TInt aGranularity);
inline void SetReserveL(TInt aCount);
};
template <class T>
class CArrayPtrSeg : public CArrayPtr<T>
#line 652
{
public:
inline explicit CArrayPtrSeg(TInt aGranularity);
};
class TKeyArrayVar : public TKey
#line 689
{
public:
__declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpText aType);
__declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpText aType,TInt aLength);
__declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpNumeric aType);
protected:
__declspec(dllexport) virtual void Set(CBufBase* aBase);
__declspec(dllexport) TAny* At(TInt anIndex) const;
protected:
CBufBase* iBase;
friend class CArrayVarBase;
};
class CArrayVarBase : public CBase
#line 718
{
public:
__declspec(dllexport) ~CArrayVarBase();
inline TInt Count() const;
__declspec(dllexport) TInt Length(TInt anIndex) const;
__declspec(dllexport) void Compress();
__declspec(dllexport) void Reset();
__declspec(dllexport) TInt Sort(TKeyArrayVar& aKey);
__declspec(dllexport) TAny* At(TInt anIndex) const;
__declspec(dllexport) void Delete(TInt anIndex);
__declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
__declspec(dllexport) TAny* ExpandL(TInt anIndex,TInt aLength);
__declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
__declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
__declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
__declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
protected:
__declspec(dllexport) CArrayVarBase(TBufRep aRep,TInt aGranularity);
__declspec(dllexport) void SetKey(TKeyArrayVar& aKey) const;
__declspec(dllexport) static TInt CountR(const CBase* aPtr);
__declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
private:
TInt iCount;
TInt iGranularity;
TBufRep iCreateRep;
CBufBase* iBase;
};
template <class T>
class CArrayVar : public CArrayVarBase
#line 762
{
public:
inline CArrayVar(TBufRep aRep,TInt aGranularity);
inline const T& operator[](TInt anIndex) const;
inline T& operator[](TInt anIndex);
inline const T& At(TInt anIndex) const;
inline T& At(TInt anIndex);
inline void AppendL(const T& aRef,TInt aLength);
inline T& ExpandL(TInt anIndex,TInt aLength);
inline T& ExtendL(TInt aLength);
inline TInt Find(const T& aRef,TKeyArrayVar& aKey,TInt& anIndex) const;
inline TInt FindIsq(const T& aRef,TKeyArrayVar& aKey,TInt& anIndex) const;
inline void InsertL(TInt anIndex,const T& aRef,TInt aLength);
inline TInt InsertIsqL(const T& aRef,TInt aLength,TKeyArrayVar& aKey);
inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TInt aLength,TKeyArrayVar& aKey);
inline const TArray<T> Array() const;
};
template<> class CArrayVar<TAny> : public CArrayVarBase
#line 799
{
public:
inline CArrayVar(TBufRep aRep,TInt aGranularity);
inline const TAny* At(TInt anIndex) const;
inline TAny* At(TInt anIndex);
inline void AppendL(const TAny* aPtr,TInt aLength);
inline TAny* ExtendL(TInt aLength);
};
template <class T>
class CArrayVarFlat : public CArrayVar<T>
#line 828
{
public:
inline explicit CArrayVarFlat(TInt aGranularity);
};
template <class T>
class CArrayVarSeg : public CArrayVar<T>
#line 853
{
public:
inline explicit CArrayVarSeg(TInt aGranularity);
};
class TKeyArrayPak : public TKeyArrayVar
#line 890
{
public:
__declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpText aType);
__declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpText aType,TInt aLength);
__declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpNumeric aType);
protected:
__declspec(dllexport) virtual void Set(CBufBase* aBase);
__declspec(dllexport) TAny* At(TInt anIndex) const;
private:
TInt iCacheIndex;
TInt iCacheOffset;
friend class CArrayPakBase;
};
class CArrayPakBase : public CBase
#line 916
{
public:
__declspec(dllexport) ~CArrayPakBase();
inline TInt Count() const;
__declspec(dllexport) TInt Length(TInt anIndex) const;
__declspec(dllexport) void Compress();
__declspec(dllexport) void Reset();
__declspec(dllexport) void SortL(TKeyArrayVar& aKey);
__declspec(dllexport) TAny* At(TInt anIndex) const;
__declspec(dllexport) void Delete(TInt anIndex);
__declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
__declspec(dllexport) TAny* ExpandL(TInt anIndex,TInt aLength);
__declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
__declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
__declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
__declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
protected:
__declspec(dllexport) CArrayPakBase(TBufRep aRep,TInt aGranularity);
__declspec(dllexport) void SetKey(TKeyArrayPak& aKey) const;
__declspec(dllexport) TInt GetOffset(TInt anIndex) const;
__declspec(dllexport) void BuildVarArrayL(CArrayVarFlat<TAny> *& aVarFlat);
__declspec(dllexport) static TInt CountR(const CBase* aPtr);
__declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
private:
TInt iCount;
TInt iGranularity;
TBufRep iCreateRep;
CBufBase* iBase;
TInt iCacheIndex;
TInt iCacheOffset;
};
template <class T>
class CArrayPak : public CArrayPakBase
#line 964
{
public:
inline CArrayPak(TBufRep aRep,TInt aGranularity);
inline const T& operator[](TInt anIndex) const;
inline T& operator[](TInt anIndex);
inline const T& At(TInt anIndex) const;
inline T& At(TInt anIndex);
inline void AppendL(const T& aRef,TInt aLength);
inline T& ExpandL(TInt anIndex,TInt aLength);
inline T& ExtendL(TInt aLength);
inline TInt Find(const T& aRef,TKeyArrayPak& aKey,TInt& anIndex) const;
inline TInt FindIsq(const T& aRef,TKeyArrayPak& aKey,TInt& anIndex) const;
inline void InsertL(TInt anIndex,const T& aRef,TInt aLength);
inline TInt InsertIsqL(const T& aRef,TInt aLength,TKeyArrayPak& aKey);
inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TInt aLength,TKeyArrayPak& aKey);
inline const TArray<T> Array() const;
};
template<> class CArrayPak<TAny> : public CArrayPakBase
#line 1001
{
public:
inline CArrayPak(TBufRep aRep,TInt aGranularity);
inline const TAny* At(TInt anIndex) const;
inline TAny* At(TInt anIndex);
inline void AppendL(const TAny* aPtr,TInt aLength);
inline TAny* ExtendL(TInt aLength);
};
template <class T>
class CArrayPakFlat : public CArrayPak<T>
#line 1029
{
public:
inline explicit CArrayPakFlat(TInt aGranularity);
};
class CObjectCon;
class CObject : public CBase
#line 1055
{
public:
__declspec(dllexport) CObject();
__declspec(dllexport) ~CObject();
__declspec(dllexport) virtual TInt Open();
__declspec(dllexport) virtual void Close();
__declspec(dllexport) virtual TName Name() const;
__declspec(dllexport) virtual TFullName FullName() const;
__declspec(dllexport) TInt SetName(const TDesC* aName);
__declspec(dllexport) void SetNameL(const TDesC* aName);
inline CObject* Owner() const;
inline void SetOwner(CObject* anOwner);
inline TInt AccessCount() const;
protected:
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
protected:
inline TInt UniqueID() const;
inline void Inc();
inline void Dec();
private:
TInt iAccessCount;
CObject* iOwner;
CObjectCon* iContainer;
HBufC* iName;
TAny* iSpare1;
TAny* iSpare2;
friend class CObjectCon;
friend class CObjectIx;
public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
};
struct TObjectDataStr
{
TInt16 instance;
TInt16 uniqueID;
};
struct SObjectIxRec
{
union
{
TObjectDataStr str;
TInt nextEmpty;
};
CObject* obj;
};
class CObjectIx : public CBase
#line 1129
{
public:
enum {
ENoClose=KHandleNoClose,
ELocalHandle=KHandleFlagLocal
};
public:
__declspec(dllexport) static CObjectIx* NewL();
__declspec(dllexport) ~CObjectIx();
__declspec(dllexport) TInt AddL(CObject* anObj);
__declspec(dllexport) void Remove(TInt aHandle);
__declspec(dllexport) CObject* At(TInt aHandle,TInt aUniqueID);
__declspec(dllexport) CObject* At(TInt aHandle);
__declspec(dllexport) CObject* AtL(TInt aHandle,TInt aUniqueID);
__declspec(dllexport) CObject* AtL(TInt aHandle);
__declspec(dllexport) TInt At(const CObject* anObject) const;
__declspec(dllexport) TInt Count(CObject* anObject) const;
__declspec(dllexport) CObject* operator[](TInt anIndex);
inline TInt Count() const;
inline TInt ActiveCount() const;
protected:
__declspec(dllexport) CObjectIx();
private:
void UpdateState();
private:
TInt iNumEntries;
TInt iHighWaterMark;
TInt iAllocated;
TInt iNextInstance;
SObjectIxRec *iObjects;
TInt iFree;
TInt iUpdateDisabled;
TAny* iSpare1;
TAny* iSpare2;
};
inline TBool IsLocalHandle(TInt aHandle)
{return(aHandle&CObjectIx::ELocalHandle);}
inline void SetLocalHandle(TInt &aHandle)
{aHandle|=CObjectIx::ELocalHandle;}
inline void UnSetLocalHandle(TInt &aHandle)
{aHandle&=(~CObjectIx::ELocalHandle);}
class CObjectCon : public CBase
#line 1208
{
protected:
enum {ENotOwnerID};
public:
__declspec(dllexport) static CObjectCon* NewL();
__declspec(dllexport) ~CObjectCon();
__declspec(dllexport) void Remove(CObject* anObj);
__declspec(dllexport) void AddL(CObject* anObj);
__declspec(dllexport) CObject* operator[](TInt anIndex);
__declspec(dllexport) CObject* At(TInt aFindHandle) const;
__declspec(dllexport) CObject* AtL(TInt aFindHandle) const;
__declspec(dllexport) TInt CheckUniqueFullName(const CObject* anOwner,const TDesC& aName) const;
__declspec(dllexport) TInt CheckUniqueFullName(const CObject* anObject) const;
__declspec(dllexport) TInt FindByName(TInt& aFindHandle,const TDesC& aMatch,TName& aName) const;
__declspec(dllexport) TInt FindByFullName(TInt& aFindHandle,const TDesC& aMatch,TFullName& aFullName) const;
inline TInt UniqueID() const;
inline TInt Count() const;
protected:
__declspec(dllexport) CObjectCon(TInt aUniqueID);
TBool NamesMatch(const CObject* anObject, const CObject* aCurrentObject) const;
TBool NamesMatch(const CObject* anObject, const TName& anObjectName, const CObject* aCurrentObject) const;
public:
TInt iUniqueID;
private:
TInt iCount;
TInt iAllocated;
CObject** iObjects;
TAny* iSpare1;
TAny* iSpare2;
friend class CObjectConIx;
};
class CObjectConIx : public CBase
#line 1264
{
public:
__declspec(dllexport) static CObjectConIx* NewL();
__declspec(dllexport) ~CObjectConIx();
__declspec(dllexport) CObjectCon* Lookup(TInt aFindHandle) const;
__declspec(dllexport) CObjectCon* CreateL();
__declspec(dllexport) void Remove(CObjectCon* aCon);
protected:
__declspec(dllexport) CObjectConIx();
__declspec(dllexport) void CreateContainerL(CObjectCon*& anObject);
private:
TInt iCount;
TInt iAllocated;
TInt iNextUniqueID;
CObjectCon** iContainers;
TAny* iSpare1;
TAny* iSpare2;
};
class CBitMapAllocator : public CBase
{
public:
__declspec(dllexport) static CBitMapAllocator* New(TInt aSize);
__declspec(dllexport) static CBitMapAllocator* NewL(TInt aSize);
__declspec(dllexport) ~CBitMapAllocator();
__declspec(dllexport) TInt Alloc();
__declspec(dllexport) TInt AllocFrom(TInt aPos);
__declspec(dllexport) TInt Alloc(TInt aCount, TInt& aConsecutive);
__declspec(dllexport) TInt AllocAligned(TInt anAlignment);
__declspec(dllexport) TInt AllocAlignedBlock(TInt anAlignment);
__declspec(dllexport) TInt AllocFromTop();
__declspec(dllexport) TInt AllocFromTopFrom(TInt aPos);
__declspec(dllexport) void AllocAt(TInt aPos);
__declspec(dllexport) void AllocAt(TInt aPos, TInt aCount);
__declspec(dllexport) TBool IsFree(TInt aPos);
__declspec(dllexport) TBool IsFree(TInt aPos, TInt aCount);
__declspec(dllexport) void Free(TInt aPos);
__declspec(dllexport) void Free(TInt aPos, TInt aCount);
__declspec(dllexport) TInt Avail();
__declspec(dllexport) TInt Size();
__declspec(dllexport) TInt ExtractRamPages(TInt aConsecutive,TInt& aPageNo);
protected:
__declspec(dllexport) CBitMapAllocator(TInt aSize,TInt aLength);
protected:
TInt iAvail;
TInt iSize;
TInt iLength;
TUint iMap[1];
};
class TCleanupStackItem;
#line 1334
typedef void (*TCleanupOperation)(TAny*);
class TCleanupItem
#line 1350
{
public:
inline TCleanupItem(TCleanupOperation anOperation);
inline TCleanupItem(TCleanupOperation anOperation,TAny* aPtr);
private:
TCleanupOperation iOperation;
TAny* iPtr;
friend class TCleanupStackItem;
};
class CCleanup : public CBase
#line 1373
{
public:
__declspec(dllexport) static CCleanup* New();
__declspec(dllexport) static CCleanup* NewL();
__declspec(dllexport) ~CCleanup();
__declspec(dllexport) void NextLevel();
__declspec(dllexport) void PreviousLevel();
__declspec(dllexport) void PushL(TAny* aPtr);
__declspec(dllexport) void PushL(CBase* anObject);
__declspec(dllexport) void PushL(TCleanupItem anItem);
__declspec(dllexport) void Pop();
__declspec(dllexport) void Pop(TInt aCount);
__declspec(dllexport) void PopAll();
__declspec(dllexport) void PopAndDestroy();
__declspec(dllexport) void PopAndDestroy(TInt aCount);
__declspec(dllexport) void PopAndDestroyAll();
__declspec(dllexport) void Check(TAny* aExpectedItem);
protected:
__declspec(dllexport) void DoPop(TInt aCount,TBool aDestroy);
__declspec(dllexport) void DoPopAll(TBool aDestroy);
protected:
__declspec(dllexport) CCleanup();
protected:
TCleanupStackItem* iBase;
TCleanupStackItem* iTop;
TCleanupStackItem* iNext;
};
class TCleanupTrapHandler : public TTrapHandler
#line 1427
{
public:
TCleanupTrapHandler();
virtual void Trap();
virtual void UnTrap();
virtual void Leave(TInt aValue);
inline CCleanup& Cleanup();
private:
CCleanup* iCleanup;
friend class CTrapCleanup;
};
template <class T>
class TAutoClose
#line 1454
{
public:
inline ~TAutoClose();
inline void PushL();
inline void Pop();
private:
static void Close(TAny *aObj);
public:
T iObj;
};
class CTrapCleanup : public CBase
#line 1481
{
public:
__declspec(dllexport) static CTrapCleanup* New();
__declspec(dllexport) ~CTrapCleanup();
protected:
__declspec(dllexport) CTrapCleanup();
private:
TCleanupTrapHandler iHandler;
TTrapHandler* iOldHandler;
};
class CCirBufBase : public CBase
#line 1507
{
public:
__declspec(dllexport) ~CCirBufBase();
inline TInt Count() const;
inline TInt Length() const;
__declspec(dllexport) void SetLengthL(TInt aLength);
__declspec(dllexport) void Reset();
protected:
__declspec(dllexport) CCirBufBase(TInt aSize);
__declspec(dllexport) TInt DoAdd(const TUint8* aPtr);