User Class Reference

class User : public UserHeap

Set of static user functions.

These functions are related to a number of System component APIs.

The majority of the functions are related to either the current thread, or its heap. Examples in this category include User::Exit(), which causes the thread to terminate, and User::Alloc(), which allocates memory from the current thread's heap.

Some of these functions are equivalent to functions in the RThread or RHeap classes. In these cases, the User function is a convenient way to access the function without first having to get a handle to the current thread.

Functions are also provided to support debugging of memory leaks. These function calls can be written explicitly or can be generated using a corresponding macro - the advantage of using a macro is that the function call is only generated for debug builds.

A final category of functions, which includes User::BinarySearch() and User::QuickSort(), are just useful functions which have no other natural home.

RThread

RHeap

Inherits from

Public Member Functions
IMPORT_C voidAfter(TTimeIntervalMicroSeconds32)
IMPORT_C voidAfterHighRes(TTimeIntervalMicroSeconds32)
IMPORT_C TAny *Alloc(TInt)
IMPORT_C TAny *AllocL(TInt)
IMPORT_C TAny *AllocLC(TInt)
IMPORT_C TIntAllocLen(const TAny *)
IMPORT_C TIntAllocSize(TInt &)
IMPORT_C TAny *AllocZ(TInt)
IMPORT_C TAny *AllocZL(TInt)
IMPORT_C RAllocator &Allocator()
IMPORT_C TIntAt(const TTime &)
IMPORT_C TIntAvailable(TInt &)
IMPORT_C TIntBeep(TInt, TTimeIntervalMicroSeconds32)
IMPORT_C TIntBinarySearch(TInt, const TKey &, TInt &)
IMPORT_C voidCancelMiscNotifier(TRequestStatus &)
IMPORT_C voidCheck()
IMPORT_C TUintCollate(TUint)
IMPORT_C voidCommandLine(TDes &)
IMPORT_C TIntCommandLineLength()
IMPORT_C TIntCompressAllHeaps()
IMPORT_C TIntCountAllocCells()
IMPORT_C TIntCountAllocCells(TInt &)
TBool CreatorHasCapability(TCapability, const char *)
TBool CreatorHasCapability(TCapability, TCapability, const char *)
TUid CreatorIdentity()
IMPORT_C TSecureIdCreatorSecureId()
IMPORT_C TVendorIdCreatorVendorId()
IMPORT_C TCriticalCritical()
IMPORT_C TCriticalCritical(RThread)
IMPORT_C TExceptionHandlerExceptionHandler()
IMPORT_C voidExit(TInt)
IMPORT_C TUint32FastCounter()
IMPORT_C TUintFold(TUint)
IMPORT_C TUintFold(TUint, TInt)
IMPORT_C voidFree(TAny *)
IMPORT_C TIntFreeLogicalDevice(const TDesC &)
IMPORT_C TIntFreePhysicalDevice(const TDesC &)
IMPORT_C voidFreeZ(TAny *&)
IMPORT_C TIntGetDesParameter(TInt, TDes8 &)
IMPORT_C TIntGetDesParameter(TInt, TDes16 &)
IMPORT_C TIntGetTIntParameter(TInt, TInt &)
IMPORT_C voidHandleException(TAny *)
RHeap &Heap()
IMPORT_C voidIMB_Range(TAny *, TAny *)
TUid Identity()
IMPORT_C TTimeIntervalSecondsInactivityTime()
IMPORT_C TIntInfoPrint(const TDesC &)
IMPORT_C voidInitProcess()
IMPORT_C voidInvariant()
IMPORT_C TBoolIsExceptionHandled(TExcType)
IMPORT_C TIntIsRomAddress(TBool &, TAny *)
IMPORT_C TBoolJustInTime()
IMPORT_C TLanguageLanguage()
IMPORT_C voidLeave(TInt)
IMPORT_C voidLeaveEnd()
IMPORT_C TIntLeaveIfError(TInt)
IMPORT_C TAny *LeaveIfNull(TAny *)
const TAny *LeaveIfNull(const TAny *)
IMPORT_C voidLeaveNoMemory()
IMPORT_C TIntLoadLogicalDevice(const TDesC &)
IMPORT_C TIntLoadPhysicalDevice(const TDesC &)
IMPORT_C TTimerLockSpecLockPeriod()
IMPORT_C TIntLockedDec(TInt &)
IMPORT_C TIntLockedInc(TInt &)
IMPORT_C TUintLowerCase(TUint)
IMPORT_C TIntMachineConfiguration(TDes8 &, TInt &)
IMPORT_C TTrapHandler *MarkCleanupStack()
IMPORT_C voidModifyExceptionMask(TUint32, TUint32)
IMPORT_C TUint32NTickCount()
IMPORT_C voidNotifyOnIdle(TRequestStatus &)
IMPORT_C voidPanic(const TDesC &, TInt)
IMPORT_C voidPanicUnexpectedLeave()
IMPORT_C TIntParameterLength(TInt)
IMPORT_C TBoolPriorityControl()
IMPORT_C TCriticalProcessCritical()
IMPORT_C TCriticalProcessCritical(RProcess)
IMPORT_C TBoolQueryVersionSupported(const TVersion &, const TVersion &)
IMPORT_C TIntQuickSort(TInt, const TKey &, const TSwap &)
IMPORT_C TIntRaiseException(TExcType)
IMPORT_C TAny *ReAlloc(TAny *, TInt, TInt)
IMPORT_C TAny *ReAllocL(TAny *, TInt, TInt)
IMPORT_C TRegionCodeRegionCode()
IMPORT_C TIntRenameProcess(const TDesC &)
IMPORT_C TIntRenameThread(const TDesC &)
IMPORT_C voidRequestComplete(TRequestStatus *&, TInt)
IMPORT_C voidResetInactivityTime()
IMPORT_C TIntSafeDec(TInt &)
IMPORT_C TIntSafeInc(TInt &)
IMPORT_C TIntSetCritical(TCritical)
IMPORT_C TIntSetCurrencySymbol(const TDesC &)
IMPORT_C voidSetDebugMask(TUint32)
IMPORT_C voidSetDebugMask(TUint32, TUint)
IMPORT_C TIntSetExceptionHandler(TExceptionHandler, TUint32)
IMPORT_C TIntSetFloatingPointMode(TFloatingPointMode, TFloatingPointRoundingMode)
IMPORT_C TIntSetHomeTime(const TTime &)
IMPORT_C TIntSetHomeTimeSecure(const TTime &)
IMPORT_C voidSetJustInTime(const TBool)
IMPORT_C TIntSetMachineConfiguration(const TDesC8 &)
IMPORT_C voidSetPriorityControl(TBool)
IMPORT_C TIntSetProcessCritical(TCritical)
IMPORT_C TIntSetRealtimeState(TRealtimeState)
IMPORT_C TTrapHandler *SetTrapHandler(TTrapHandler *)
IMPORT_C voidSetUTCOffset(TTimeIntervalSeconds)
IMPORT_C TIntSetUTCTime(const TTime &)
IMPORT_C TIntSetUTCTimeAndOffset(const TTime &, TTimeIntervalSeconds)
IMPORT_C TIntSetUTCTimeSecure(const TTime &)
IMPORT_C TIntStringLength(const TUint8 *)
IMPORT_C TIntStringLength(const TUint16 *)
IMPORT_C RAllocator *SwitchAllocator(RAllocator *)
RHeap *SwitchHeap(RAllocator *)
IMPORT_C TUintTickCount()
IMPORT_C TUintTitleCase(TUint)
IMPORT_C TTrapHandler *TrapHandler()
IMPORT_C TTimeIntervalSecondsUTCOffset()
IMPORT_C voidUnMarkCleanupStack(TTrapHandler *)
IMPORT_C TUintUpperCase(TUint)
IMPORT_C TIntValidateName(const TDesC &)
IMPORT_C TVersionVersion()
IMPORT_C voidWaitForAnyRequest()
IMPORT_C voidWaitForNRequest(TRequestStatus *, TInt)
IMPORT_C voidWaitForRequest(TRequestStatus &)
IMPORT_C voidWaitForRequest(TRequestStatus &, TRequestStatus &)
IMPORT_C TUint__DbgCheckFailure(TBool)
IMPORT_C void__DbgMarkCheck(TBool, TBool, TInt, const TUint8 *, TInt)
IMPORT_C TUint32__DbgMarkEnd(TBool, TInt)
IMPORT_C void__DbgMarkStart(TBool)
IMPORT_C void__DbgSetAllocFail(TBool, RAllocator::TAllocFail, TInt)
IMPORT_C void__DbgSetBurstAllocFail(TBool, RAllocator::TAllocFail, TUint, TUint)
Private Member Functions
IMPORT_C TBoolDoCreatorHasCapability(TCapability, const char *)
IMPORT_C TBoolDoCreatorHasCapability(TCapability)
IMPORT_C TBoolDoCreatorHasCapability(TCapability, TCapability, const char *)
IMPORT_C TBoolDoCreatorHasCapability(TCapability, TCapability)
Inherited Functions
UserHeap::ChunkHeap(RChunk,TInt,TInt,TInt,TInt,TBool,TUint32)
UserHeap::ChunkHeap(const TChunkHeapCreateInfo &)
UserHeap::ChunkHeap(const TDesC *,TInt,TInt,TInt,TInt,TBool)
UserHeap::CreateThreadHeap(SStdEpocThreadCreateInfo &,RHeap *&,TInt,TBool)
UserHeap::FixedHeap(TAny *,TInt,TInt,TBool)
UserHeap::OffsetChunkHeap(RChunk,TInt,TInt,TInt,TInt,TInt,TBool,TUint32)
UserHeap::SetupThreadHeap(TBool,SStdEpocThreadCreateInfo &)
Public Member Enumerations
enumTCritical {
ENotCritical, EProcessCritical, EProcessPermanent, EAllThreadsCritical, ESystemCritical, ESystemPermanent
}
enumTRealtimeState { ERealtimeStateOff, ERealtimeStateOn, ERealtimeStateWarn }
Inherited Enumerations
UserHeap:TChunkHeapCreateMode

Member Functions Documentation

After(TTimeIntervalMicroSeconds32)

IMPORT_C voidAfter(TTimeIntervalMicroSeconds32aInterval)[static]

Parameters

TTimeIntervalMicroSeconds32 aInterval

AfterHighRes(TTimeIntervalMicroSeconds32)

IMPORT_C voidAfterHighRes(TTimeIntervalMicroSeconds32aInterval)[static]

Parameters

TTimeIntervalMicroSeconds32 aInterval

Alloc(TInt)

IMPORT_C TAny *Alloc(TIntaSize)[static]

Parameters

TInt aSize

AllocL(TInt)

IMPORT_C TAny *AllocL(TIntaSize)[static]

Parameters

TInt aSize

AllocLC(TInt)

IMPORT_C TAny *AllocLC(TIntaSize)[static]

Parameters

TInt aSize

AllocLen(const TAny *)

IMPORT_C TIntAllocLen(const TAny *aCell)[static]

Parameters

const TAny * aCell

AllocSize(TInt &)

IMPORT_C TIntAllocSize(TInt &aTotalAllocSize)[static]

Parameters

TInt & aTotalAllocSize

AllocZ(TInt)

IMPORT_C TAny *AllocZ(TIntaSize)[static]

Parameters

TInt aSize

AllocZL(TInt)

IMPORT_C TAny *AllocZL(TIntaSize)[static]

Parameters

TInt aSize

Allocator()

IMPORT_C RAllocator &Allocator()[static]

At(const TTime &)

IMPORT_C TIntAt(const TTime &aTime)[static]

Parameters

const TTime & aTime

Available(TInt &)

IMPORT_C TIntAvailable(TInt &aBiggestBlock)[static]

Parameters

TInt & aBiggestBlock

Beep(TInt, TTimeIntervalMicroSeconds32)

IMPORT_C TIntBeep(TIntaFrequency,
TTimeIntervalMicroSeconds32aDuration
)[static]

Parameters

TInt aFrequency
TTimeIntervalMicroSeconds32 aDuration

BinarySearch(TInt, const TKey &, TInt &)

IMPORT_C TIntBinarySearch(TIntaCount,
const TKey &aKey,
TInt &aPos
)[static]

Parameters

TInt aCount
const TKey & aKey
TInt & aPos

CancelMiscNotifier(TRequestStatus &)

IMPORT_C voidCancelMiscNotifier(TRequestStatus &aStatus)[static]

Parameters

TRequestStatus & aStatus

Check()

IMPORT_C voidCheck()[static]

Collate(TUint)

IMPORT_C TUintCollate(TUintaChar)[static]

Parameters

TUint aChar

CommandLine(TDes &)

IMPORT_C voidCommandLine(TDes &aCommand)[static]

Parameters

TDes & aCommand

CommandLineLength()

IMPORT_C TIntCommandLineLength()[static]

CompressAllHeaps()

IMPORT_C TIntCompressAllHeaps()[static]

CountAllocCells()

IMPORT_C TIntCountAllocCells()[static]

CountAllocCells(TInt &)

IMPORT_C TIntCountAllocCells(TInt &aFreeCount)[static]

Parameters

TInt & aFreeCount

CreatorHasCapability(TCapability, const char *)

TBool CreatorHasCapability(TCapabilityaCapability,
const char *aDiagnostic = 0
)[static, inline]

Check if the process that created the current process has a given capability

When a check fails the action taken is determined by the system wide Platform Security configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. If PlatSecEnforcement is OFF, then this function will return ETrue even though the check failed.

ETrue if the creator process has the capability, EFalse otherwise.

Parameters

TCapability aCapabilityThe capability to test.
const char * aDiagnostic = 0A string that will be emitted along with any diagnostic message that may be issued if the test finds the capability is not present. This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro which enables it to be easily removed from the system.

CreatorHasCapability(TCapability, TCapability, const char *)

TBool CreatorHasCapability(TCapabilityaCapability1,
TCapabilityaCapability2,
const char *aDiagnostic = 0
)[static, inline]

Check if the process that created the current process has both of the given capabilities

When a check fails the action taken is determined by the system wide Platform Security configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. If PlatSecEnforcement is OFF, then this function will return ETrue even though the check failed.

ETrue if the creator process has both the capabilities, EFalse otherwise.

Parameters

TCapability aCapability1The first capability to test.
TCapability aCapability2The second capability to test.
const char * aDiagnostic = 0A string that will be emitted along with any diagnostic message that may be issued if the test finds a capability is not present. This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro which enables it to be easily removed from the system.

CreatorIdentity()

TUid CreatorIdentity()[static, inline]

CreatorSecureId()

IMPORT_C TSecureIdCreatorSecureId()[static]

Return the Secure ID of the process that created the current process. The Secure ID.

CreatorVendorId()

IMPORT_C TVendorIdCreatorVendorId()[static]

Return the Vendor ID of the process that created the current process. The Vendor ID.

Critical()

IMPORT_C TCriticalCritical()[static]

Critical(RThread)

IMPORT_C TCriticalCritical(RThreadaThread)[static]

Parameters

RThread aThread

DoCreatorHasCapability(TCapability, const char *)

IMPORT_C TBoolDoCreatorHasCapability(TCapabilityaCapability,
const char *aDiagnostic
)[private, static]

Parameters

TCapability aCapability
const char * aDiagnostic

DoCreatorHasCapability(TCapability)

IMPORT_C TBoolDoCreatorHasCapability(TCapabilityaCapability)[private, static]

Parameters

TCapability aCapability

DoCreatorHasCapability(TCapability, TCapability, const char *)

IMPORT_C TBoolDoCreatorHasCapability(TCapabilityaCapability1,
TCapabilityaCapability2,
const char *aDiagnostic
)[private, static]

Parameters

TCapability aCapability1
TCapability aCapability2
const char * aDiagnostic

DoCreatorHasCapability(TCapability, TCapability)

IMPORT_C TBoolDoCreatorHasCapability(TCapabilityaCapability1,
TCapabilityaCapability2
)[private, static]

Parameters

TCapability aCapability1
TCapability aCapability2

ExceptionHandler()

IMPORT_C TExceptionHandlerExceptionHandler()[static]

Exit(TInt)

IMPORT_C voidExit(TIntaReason)[static]

Parameters

TInt aReason

FastCounter()

IMPORT_C TUint32FastCounter()[static]

Fold(TUint)

IMPORT_C TUintFold(TUintaChar)[static]

Parameters

TUint aChar

Fold(TUint, TInt)

IMPORT_C TUintFold(TUintaChar,
TIntaFlags
)[static]

Parameters

TUint aChar
TInt aFlags

Free(TAny *)

IMPORT_C voidFree(TAny *aCell)[static]

Parameters

TAny * aCell

FreeLogicalDevice(const TDesC &)

IMPORT_C TIntFreeLogicalDevice(const TDesC &aDeviceName)[static]

Parameters

const TDesC & aDeviceName

FreePhysicalDevice(const TDesC &)

IMPORT_C TIntFreePhysicalDevice(const TDesC &aDriverName)[static]

Parameters

const TDesC & aDriverName

FreeZ(TAny *&)

IMPORT_C voidFreeZ(TAny *&aCell)[static]

Parameters

TAny *& aCell

GetDesParameter(TInt, TDes8 &)

IMPORT_C TIntGetDesParameter(TIntaSlot,
TDes8 &aDes
)[static]

Parameters

TInt aSlot
TDes8 & aDes

GetDesParameter(TInt, TDes16 &)

IMPORT_C TIntGetDesParameter(TIntaSlot,
TDes16 &aDes
)[static]

Parameters

TInt aSlot
TDes16 & aDes

GetTIntParameter(TInt, TInt &)

IMPORT_C TIntGetTIntParameter(TIntaSlot,
TInt &aData
)[static]

Parameters

TInt aSlot
TInt & aData

HandleException(TAny *)

IMPORT_C voidHandleException(TAny *aInfo)[static]

Parameters

TAny * aInfo

Heap()

RHeap &Heap()[static, inline]

Gets a reference to the handle to the current thread's heap.

A reference to the handle to the current thread's heap.

IMB_Range(TAny *, TAny *)

IMPORT_C voidIMB_Range(TAny *aStart,
TAny *aEnd
)[static]

Parameters

TAny * aStart
TAny * aEnd

Identity()

TUid Identity()[static, inline]

InactivityTime()

IMPORT_C TTimeIntervalSecondsInactivityTime()[static]

InfoPrint(const TDesC &)

IMPORT_C TIntInfoPrint(const TDesC &aDes)[static]

Parameters

const TDesC & aDes

InitProcess()

IMPORT_C voidInitProcess()[static]

Invariant()

IMPORT_C voidInvariant()[static]

IsExceptionHandled(TExcType)

IMPORT_C TBoolIsExceptionHandled(TExcTypeaType)[static]

Parameters

TExcType aType

IsRomAddress(TBool &, TAny *)

IMPORT_C TIntIsRomAddress(TBool &aBool,
TAny *aPtr
)[static]

Parameters

TBool & aBool
TAny * aPtr

JustInTime()

IMPORT_C TBoolJustInTime()[static]

Language()

IMPORT_C TLanguageLanguage()[static]

Leave(TInt)

IMPORT_C voidLeave(TIntaReason)[static]

Parameters

TInt aReason

LeaveEnd()

IMPORT_C voidLeaveEnd()[static]

LeaveIfError(TInt)

IMPORT_C TIntLeaveIfError(TIntaReason)[static]

Parameters

TInt aReason

LeaveIfNull(TAny *)

IMPORT_C TAny *LeaveIfNull(TAny *aPtr)[static]

Parameters

TAny * aPtr

LeaveIfNull(const TAny *)

const TAny *LeaveIfNull(const TAny *aPtr)[static, inline]

Leaves with the reason code KErrNoMemory, if the specified pointer is NULL.

If the pointer is not NULL, the function simply returns with the value of the pointer.

Used to check pointers to const objects.

If the function returns, the value of aPtr.

Parameters

const TAny * aPtrThe pointer to be tested.

LeaveNoMemory()

IMPORT_C voidLeaveNoMemory()[static]

LoadLogicalDevice(const TDesC &)

IMPORT_C TIntLoadLogicalDevice(const TDesC &aFileName)[static]

Parameters

const TDesC & aFileName

LoadPhysicalDevice(const TDesC &)

IMPORT_C TIntLoadPhysicalDevice(const TDesC &aFileName)[static]

Parameters

const TDesC & aFileName

LockPeriod()

IMPORT_C TTimerLockSpecLockPeriod()[static]

LockedDec(TInt &)

IMPORT_C TIntLockedDec(TInt &aValue)[static]

Parameters

TInt & aValue

LockedInc(TInt &)

IMPORT_C TIntLockedInc(TInt &aValue)[static]

Parameters

TInt & aValue

LowerCase(TUint)

IMPORT_C TUintLowerCase(TUintaChar)[static]

Parameters

TUint aChar

MachineConfiguration(TDes8 &, TInt &)

IMPORT_C TIntMachineConfiguration(TDes8 &aConfig,
TInt &aSize
)[static]

Parameters

TDes8 & aConfig
TInt & aSize

MarkCleanupStack()

IMPORT_C TTrapHandler *MarkCleanupStack()[static]

ModifyExceptionMask(TUint32, TUint32)

IMPORT_C voidModifyExceptionMask(TUint32aClearMask,
TUint32aSetMask
)[static]

Parameters

TUint32 aClearMask
TUint32 aSetMask

NTickCount()

IMPORT_C TUint32NTickCount()[static]

NotifyOnIdle(TRequestStatus &)

IMPORT_C voidNotifyOnIdle(TRequestStatus &aStatus)[static]

Parameters

TRequestStatus & aStatus

Panic(const TDesC &, TInt)

IMPORT_C voidPanic(const TDesC &aCategory,
TIntaReason
)[static]

Parameters

const TDesC & aCategory
TInt aReason

PanicUnexpectedLeave()

IMPORT_C voidPanicUnexpectedLeave()[static]

ParameterLength(TInt)

IMPORT_C TIntParameterLength(TIntaSlot)[static]

Parameters

TInt aSlot

PriorityControl()

IMPORT_C TBoolPriorityControl()[static]

ProcessCritical()

IMPORT_C TCriticalProcessCritical()[static]

ProcessCritical(RProcess)

IMPORT_C TCriticalProcessCritical(RProcessaProcess)[static]

Parameters

RProcess aProcess

QueryVersionSupported(const TVersion &, const TVersion &)

IMPORT_C TBoolQueryVersionSupported(const TVersion &aCurrent,
const TVersion &aRequested
)[static]

Parameters

const TVersion & aCurrent
const TVersion & aRequested

QuickSort(TInt, const TKey &, const TSwap &)

IMPORT_C TIntQuickSort(TIntaCount,
const TKey &aKey,
const TSwap &aSwap
)[static]

Parameters

TInt aCount
const TKey & aKey
const TSwap & aSwap

RaiseException(TExcType)

IMPORT_C TIntRaiseException(TExcTypeaType)[static]

Parameters

TExcType aType

ReAlloc(TAny *, TInt, TInt)

IMPORT_C TAny *ReAlloc(TAny *aCell,
TIntaSize,
TIntaMode = 0
)[static]

Parameters

TAny * aCell
TInt aSize
TInt aMode = 0

ReAllocL(TAny *, TInt, TInt)

IMPORT_C TAny *ReAllocL(TAny *aCell,
TIntaSize,
TIntaMode = 0
)[static]

Parameters

TAny * aCell
TInt aSize
TInt aMode = 0

RegionCode()

IMPORT_C TRegionCodeRegionCode()[static]

RenameProcess(const TDesC &)

IMPORT_C TIntRenameProcess(const TDesC &aName)[static]

Parameters

const TDesC & aName

RenameThread(const TDesC &)

IMPORT_C TIntRenameThread(const TDesC &aName)[static]

Parameters

const TDesC & aName

RequestComplete(TRequestStatus *&, TInt)

IMPORT_C voidRequestComplete(TRequestStatus *&aStatus,
TIntaReason
)[static]

Parameters

TRequestStatus *& aStatus
TInt aReason

ResetInactivityTime()

IMPORT_C voidResetInactivityTime()[static]

SafeDec(TInt &)

IMPORT_C TIntSafeDec(TInt &aValue)[static]

Parameters

TInt & aValue

SafeInc(TInt &)

IMPORT_C TIntSafeInc(TInt &aValue)[static]

Parameters

TInt & aValue

SetCritical(TCritical)

IMPORT_C TIntSetCritical(TCriticalaCritical)[static]

Parameters

TCritical aCritical

SetCurrencySymbol(const TDesC &)

IMPORT_C TIntSetCurrencySymbol(const TDesC &aSymbol)[static]

Parameters

const TDesC & aSymbol

SetDebugMask(TUint32)

IMPORT_C voidSetDebugMask(TUint32aVal)[static]

Parameters

TUint32 aVal

SetDebugMask(TUint32, TUint)

IMPORT_C voidSetDebugMask(TUint32aVal,
TUintaIndex
)[static]

Parameters

TUint32 aVal
TUint aIndex

SetExceptionHandler(TExceptionHandler, TUint32)

IMPORT_C TIntSetExceptionHandler(TExceptionHandleraHandler,
TUint32aMask
)[static]

Parameters

TExceptionHandler aHandler
TUint32 aMask

SetFloatingPointMode(TFloatingPointMode, TFloatingPointRoundingMode)

IMPORT_C TIntSetFloatingPointMode(TFloatingPointModeaMode,
TFloatingPointRoundingModeaRoundingMode = EFpRoundToNearest
)[static]

Parameters

TFloatingPointMode aMode
TFloatingPointRoundingMode aRoundingMode = EFpRoundToNearest

SetHomeTime(const TTime &)

IMPORT_C TIntSetHomeTime(const TTime &aTime)[static]

Parameters

const TTime & aTime

SetHomeTimeSecure(const TTime &)

IMPORT_C TIntSetHomeTimeSecure(const TTime &aTime)[static]

Parameters

const TTime & aTime

SetJustInTime(const TBool)

IMPORT_C voidSetJustInTime(const TBoolaBoolean)[static]

Parameters

const TBool aBoolean

SetMachineConfiguration(const TDesC8 &)

IMPORT_C TIntSetMachineConfiguration(const TDesC8 &aConfig)[static]

Parameters

const TDesC8 & aConfig

SetPriorityControl(TBool)

IMPORT_C voidSetPriorityControl(TBoolaEnable)[static]

Parameters

TBool aEnable

SetProcessCritical(TCritical)

IMPORT_C TIntSetProcessCritical(TCriticalaCritical)[static]

Parameters

TCritical aCritical

SetRealtimeState(TRealtimeState)

IMPORT_C TIntSetRealtimeState(TRealtimeStateaState)[static]

Set the current threads realtime state. TRealtimeState

KErrNone if successful. KErrArgument if aState is invalid.

Parameters

TRealtimeState aStateThe state

SetTrapHandler(TTrapHandler *)

IMPORT_C TTrapHandler *SetTrapHandler(TTrapHandler *aHandler)[static]

Parameters

TTrapHandler * aHandler

SetUTCOffset(TTimeIntervalSeconds)

IMPORT_C voidSetUTCOffset(TTimeIntervalSecondsaOffset)[static]

Parameters

TTimeIntervalSeconds aOffset

SetUTCTime(const TTime &)

IMPORT_C TIntSetUTCTime(const TTime &aUTCTime)[static]

Parameters

const TTime & aUTCTime

SetUTCTimeAndOffset(const TTime &, TTimeIntervalSeconds)

IMPORT_C TIntSetUTCTimeAndOffset(const TTime &aUTCTime,
TTimeIntervalSecondsaOffset
)[static]

Parameters

const TTime & aUTCTime
TTimeIntervalSeconds aOffset

SetUTCTimeSecure(const TTime &)

IMPORT_C TIntSetUTCTimeSecure(const TTime &aUTCTime)[static]

Parameters

const TTime & aUTCTime

StringLength(const TUint8 *)

IMPORT_C TIntStringLength(const TUint8 *aString)[static]

Parameters

const TUint8 * aString

StringLength(const TUint16 *)

IMPORT_C TIntStringLength(const TUint16 *aString)[static]

Parameters

const TUint16 * aString

SwitchAllocator(RAllocator *)

IMPORT_C RAllocator *SwitchAllocator(RAllocator *aAllocator)[static]

Parameters

RAllocator * aAllocator

SwitchHeap(RAllocator *)

RHeap *SwitchHeap(RAllocator *aHeap)[static, inline]

Changes the current thread's heap.

A pointer to the old heap handle.

Parameters

RAllocator * aHeapA pointer to the new heap handle.

TickCount()

IMPORT_C TUintTickCount()[static]

TitleCase(TUint)

IMPORT_C TUintTitleCase(TUintaChar)[static]

Parameters

TUint aChar

TrapHandler()

IMPORT_C TTrapHandler *TrapHandler()[static]

UTCOffset()

IMPORT_C TTimeIntervalSecondsUTCOffset()[static]

UnMarkCleanupStack(TTrapHandler *)

IMPORT_C voidUnMarkCleanupStack(TTrapHandler *aHandler)[static]

Parameters

TTrapHandler * aHandler

UpperCase(TUint)

IMPORT_C TUintUpperCase(TUintaChar)[static]

Parameters

TUint aChar

ValidateName(const TDesC &)

IMPORT_C TIntValidateName(const TDesC &aName)[static]

Parameters

const TDesC & aName

Version()

IMPORT_C TVersionVersion()[static]

WaitForAnyRequest()

IMPORT_C voidWaitForAnyRequest()[static]

WaitForNRequest(TRequestStatus *, TInt)

IMPORT_C voidWaitForNRequest(TRequestStatus *aStatusArray,
TIntaNum
)[static]

Parameters

TRequestStatus * aStatusArray
TInt aNum

WaitForRequest(TRequestStatus &)

IMPORT_C voidWaitForRequest(TRequestStatus &aStatus)[static]

Parameters

TRequestStatus & aStatus

WaitForRequest(TRequestStatus &, TRequestStatus &)

IMPORT_C voidWaitForRequest(TRequestStatus &aStatus1,
TRequestStatus &aStatus2
)[static]

Parameters

TRequestStatus & aStatus1
TRequestStatus & aStatus2

__DbgCheckFailure(TBool)

IMPORT_C TUint__DbgCheckFailure(TBoolaKernel)[static]

Parameters

TBool aKernel

__DbgMarkCheck(TBool, TBool, TInt, const TUint8 *, TInt)

IMPORT_C void__DbgMarkCheck(TBoolaKernel,
TBoolaCountAll,
TIntaCount,
const TUint8 *aFileName,
TIntaLineNum
)[static]

Parameters

TBool aKernel
TBool aCountAll
TInt aCount
const TUint8 * aFileName
TInt aLineNum

__DbgMarkEnd(TBool, TInt)

IMPORT_C TUint32__DbgMarkEnd(TBoolaKernel,
TIntaCount
)[static]

Parameters

TBool aKernel
TInt aCount

__DbgMarkStart(TBool)

IMPORT_C void__DbgMarkStart(TBoolaKernel)[static]

Parameters

TBool aKernel

__DbgSetAllocFail(TBool, RAllocator::TAllocFail, TInt)

IMPORT_C void__DbgSetAllocFail(TBoolaKernel,
RAllocator::TAllocFailaFail,
TIntaRate
)[static]

Parameters

TBool aKernel
RAllocator::TAllocFail aFail
TInt aRate

__DbgSetBurstAllocFail(TBool, RAllocator::TAllocFail, TUint, TUint)

IMPORT_C void__DbgSetBurstAllocFail(TBoolaKernel,
RAllocator::TAllocFailaFail,
TUintaRate,
TUintaBurst
)[static]

Parameters

TBool aKernel
RAllocator::TAllocFail aFail
TUint aRate
TUint aBurst

Member Enumerations Documentation

Enum TCritical

A set of values that defines the effect that terminating a thread has, either on its owning process or on the whole system.

A thread is said to be critical if its owning process or the entire system terminates when the thread itself terminates.

You pass one of these values to the functions:

The meaning of a value when passed to one function is different to its meaning when passed the other function. See the description of each individual value.

User::SetCritical()

User::SetProcessCritical()

Enumerators

ENotCritical
This value can be passed to both:
  • User::SetCritical(), which means that the current thread is no longer critical, i.e. termination of the current thread will no longer cause termination of the current thread's owning process (i.e. the current process) or a reboot of the system.

  • User::SetProcessCritical(), which means that threads subsequently created in the current thread's owning process (i.e. the current process) will no longer cause termination of that process or a reboot of the system. Note, however, that existing threads are NOT affected when you call this function.

User::SetCritical()

User::SetProcessCritical()

EProcessCritical

This value can only be passed to User::SetCritical() and affects the current thread only.

It means that the owning process (i.e.the current process) terminates if:
  • the current thread is terminated.

  • the current thread panics.

User::SetCritical()

EProcessPermanent

This value can only be passed to User::SetCritical() and affects the current thread only.

It means that the owning process (i.e.the current process) terminates if the current thread terminates for any reason.

User::SetCritical()

EAllThreadsCritical

This value can only be passed to User::SetProcessCritical() and affects any new threads created in the current process.

It means that the current process terminates if:
  • any new thread subsequently created in the current process is terminated.

  • any new thread subsequently created in the current process panics.

Note, however, that existing threads in the current process are NOT affected when you call User::SetProcessCritical() with this value.

EProcessCritical

User::SetProcessCritical()

ESystemCritical

This value can be passed to both: User::SetCritical() and User::SetProcessCritical().

When passed to User::SetCritical(), it means that the entire system is rebooted if:
  • the current thread is terminated.

  • the current thread panics.

When passed to User::SetProcessCritical(), it means that the entire system is rebooted if:
  • any new thread subsequently created in the current process is terminated.

  • any new thread subsequently created in the current process panics.

  • the process itself is terminated

  • the process itself panics

Note:
  1. existing threads in the current process are NOT affected when you call User::SetProcessCritical() with this value.

  2. Only a process with 'Protected Server' capability can set a thread to system-critical.

User::SetCritical()

User::SetProcessCritical()

ESystemPermanent

This value can be passed to both: User::SetCritical() and User::SetProcessCritical().

When passed to User::SetCritical(), it means that the entire system is rebooted if the current thread exits for any reason.

When passed to User::SetProcessCritical(), it means that the entire system is rebooted if any new thread subsequently created in the current process exits for any reason, or if the process itself exits for any reason.

Note:
  1. existing threads in the current process are NOT affected when you call User::SetProcessCritical() with this value.

  2. Only a process with 'Protected Server' capability can set a thread to system-permanent.

User::SetCritical()

User::SetProcessCritical()

Enum TRealtimeState

A threads realtime state. Some non-realtime behaviour can be detected by the kernel. When it does so, action is taken depending on the thread state:
  • ERealtimeStateOff - no action.

  • ERealtimeStateOn - the the thread will be panicked with KERN-EXEC 61 (EIllegalFunctionForRealtimeThread).

  • ERealtimeStateWarn - no action. However, if the kernel trace flag KREALTIME is enabled then tracing will be emitted as if the thread state was ERealtimeStateOn.

Enumerators

ERealtimeStateOff

Thread is not realtime

ERealtimeStateOn

Thread is realtime

ERealtimeStateWarn

Thread is realtime but doesn't want this enforced