--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/include/e32std.h Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,5271 @@
+// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32\include\e32std.h
+//
+//
+
+#ifndef __E32STD_H__
+#define __E32STD_H__
+
+#ifdef __KERNEL_MODE__
+#error !! Including e32std.h in kernel code !!
+#endif
+
+#include <e32cmn.h>
+
+/**
+@publishedAll
+@released
+*/
+class TFunctor
+ {
+public:
+ IMPORT_C virtual void operator()() =0;
+ };
+
+/**
+@publishedAll
+@released
+
+Encapsulates a general call-back function.
+
+The class encapsulates:
+
+1. a pointer to a function which takes an argument of type TAny* and returns
+ a TInt.
+
+2. a pointer which is passed to the function every time it is called.
+ The pointer can point to any object. It can also be NULL.
+
+The callback function can be a static function of a class,
+e.g. TInt X::Foo(TAny *) or it can be a function which is not a member of
+any class, e.g. TInt Foo(TAny *).
+
+When used with the CIdle and the CPeriodic classes, the callback function
+is intended to be called repeatedly; the encapsulated pointer is passed on
+each call. Typically, the pointer refers to an object which records the state
+of the task across each call. When used with CIdle, the callback function
+should also return a true (non-zero) value if it is intended to be called
+again, otherwise it should return a false (zero) value.
+
+@see CIdle
+@see CPeriodic
+*/
+class TCallBack
+ {
+public:
+ inline TCallBack();
+ inline TCallBack(TInt (*aFunction)(TAny* aPtr));
+ inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
+ inline TInt CallBack() const;
+public:
+
+ /**
+ A pointer to the callback function.
+ */
+ TInt (*iFunction)(TAny* aPtr);
+
+
+ /**
+ A pointer that is passed to the callback function when
+ the function is called.
+ */
+ TAny* iPtr;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+An object embedded within a class T so that objects of type T can form part
+of a singly linked list.
+
+A link object encapsulates a pointer to the next link object in the list.
+
+@see TSglQue
+*/
+class TSglQueLink
+ {
+#if defined _DEBUG
+public:
+ inline TSglQueLink() : iNext(NULL)
+ /**
+ An explicitly coded default constructor that is only defined for DEBUG builds.
+
+ It sets the pointer to the next link object to NULL.
+
+ @see iNext
+ */
+ {}
+#endif
+private:
+ IMPORT_C void Enque(TSglQueLink* aLink);
+public:
+ /**
+ A pointer to the next link object in the list.
+ */
+ TSglQueLink* iNext;
+ friend class TSglQueBase;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A base class that provides implementation for the link object of a doubly
+linked list.
+
+It also encapsulates pointers both to the next and the previous link
+objects in the doubly linked list.
+
+The class is abstract and is not intended to be instantiated.
+
+@see TDblQueLink
+*/
+class TDblQueLinkBase
+ {
+public:
+ inline TDblQueLinkBase() : iNext(NULL)
+ /**
+ Default constructor.
+
+ It sets the pointer to the next link object to NULL.
+
+ @see iNext
+ */
+ {}
+ IMPORT_C void Enque(TDblQueLinkBase* aLink);
+ IMPORT_C void AddBefore(TDblQueLinkBase* aLink);
+public:
+ /**
+ A pointer to the next link object in the list.
+ */
+ TDblQueLinkBase* iNext;
+
+ /**
+ A pointer to the previous link object in the list.
+ */
+ TDblQueLinkBase* iPrev;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+An object embedded within a class T so that objects of type T can form part
+of a doubly linked list.
+*/
+class TDblQueLink : public TDblQueLinkBase
+ {
+public:
+ IMPORT_C void Deque();
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+An object embedded within a class T so that objects of type T can form part
+of an ordered doubly linked list.
+
+Objects are added to the doubly linked list in descending priority order.
+*/
+class TPriQueLink : public TDblQueLink
+ {
+public:
+ /**
+ The priority value.
+
+ Objects are added to the doubly linked list in descending order of this value.
+ */
+ TInt iPriority;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+An object embedded within a class T so that objects of type T can form part
+of a delta doubly linked list.
+*/
+class TDeltaQueLink : public TDblQueLinkBase
+ {
+public:
+ /**
+ The delta value.
+ */
+ TInt iDelta;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+An object embedded within a class T so that objects of type T can form part
+of a doubly linked list sorted by tick count.
+*/
+class TTickCountQueLink : public TDblQueLink
+ {
+public:
+ /**
+ The tick count.
+ */
+ TUint iTickCount;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A base class that provides implementation for the singly linked list header.
+
+It also encapsulates the offset value of a link object.
+
+The class is abstract and is not intended to be instantiated.
+
+@see TSglQue
+*/
+class TSglQueBase
+ {
+public:
+ IMPORT_C TBool IsEmpty() const;
+ IMPORT_C void SetOffset(TInt aOffset);
+ IMPORT_C void Reset();
+protected:
+ IMPORT_C TSglQueBase();
+ IMPORT_C TSglQueBase(TInt aOffset);
+ IMPORT_C void DoAddFirst(TAny* aPtr);
+ IMPORT_C void DoAddLast(TAny* aPtr);
+ IMPORT_C void DoRemove(TAny* aPtr);
+protected:
+ /**
+ A pointer to the first element in the list.
+ */
+ TSglQueLink* iHead;
+
+ /**
+ A pointer to the last element in the list.
+ */
+ TSglQueLink* iLast;
+
+ /**
+ The offset of a component link object within elements that form the list.
+ */
+ TInt iOffset;
+private:
+ TSglQueBase(const TSglQueBase& aQue);
+ TSglQueBase &operator=(const TSglQueBase& aQue);
+ friend class TSglQueIterBase;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A base class that provides implementation for the doubly linked list header.
+
+It also encapsulates the offset value of a link object.
+
+The class is abstract and is not intended to be instantiated.
+
+@see TDblQue
+*/
+class TDblQueBase
+ {
+public:
+ IMPORT_C TBool IsEmpty() const;
+ IMPORT_C void SetOffset(TInt aOffset);
+ IMPORT_C void Reset();
+protected:
+ IMPORT_C TDblQueBase();
+ IMPORT_C TDblQueBase(TInt aOffset);
+ IMPORT_C void DoAddFirst(TAny* aPtr);
+ IMPORT_C void DoAddLast(TAny* aPtr);
+ IMPORT_C void DoAddPriority(TAny* aPtr);
+ IMPORT_C void __DbgTestEmpty() const;
+protected:
+ /**
+ The head, or anchor point of the queue.
+ */
+ TDblQueLink iHead;
+
+ /**
+ The offset of a component link object within elements that form the list.
+ */
+ TInt iOffset;
+private:
+ TDblQueBase(const TDblQueBase& aQue);
+ TDblQueBase& operator=(const TDblQueBase& aQue);
+ friend class TDblQueIterBase;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A base class that provides implementation for the TDeltaQue template class.
+
+The class is abstract and is not intended to be instantiated.
+
+@see TDeltaQue
+*/
+class TDeltaQueBase : public TDblQueBase
+ {
+public:
+ IMPORT_C TBool CountDown();
+ IMPORT_C TBool CountDown(TInt aValue);
+ IMPORT_C TBool FirstDelta(TInt& aValue);
+ IMPORT_C void Reset();
+protected:
+ IMPORT_C TDeltaQueBase();
+ IMPORT_C TDeltaQueBase(TInt aOffset);
+ IMPORT_C void DoAddDelta(TAny* aPtr,TInt aDelta);
+ IMPORT_C void DoRemove(TAny* aPtr);
+ IMPORT_C TAny* DoRemoveFirst();
+protected:
+ /**
+ Pointer to the delta value in the first link element.
+ */
+ TInt* iFirstDelta;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class that provides the behaviour for managing a singly linked
+list.
+
+It also acts as the head of the list, maintaining the pointers into the list.
+
+The template parameter defines the type of element that forms the singly linked
+list and is the class that acts as host to the link object.
+
+@see TSglQueLink
+*/
+template <class T>
+class TSglQue : public TSglQueBase
+ {
+public:
+ inline TSglQue();
+ inline explicit TSglQue(TInt aOffset);
+ inline void AddFirst(T& aRef);
+ inline void AddLast(T& aRef);
+ inline TBool IsFirst(const T* aPtr) const;
+ inline TBool IsLast(const T* aPtr) const;
+ inline T* First() const;
+ inline T* Last() const;
+ inline void Remove(T& aRef);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class that provides the behaviour for managing a doubly linked
+list.
+
+It also acts as the head of the list, maintaining the pointers into the list.
+
+The template parameter defines the type of element that forms the doubly linked
+list and is the class that acts as host to the link object.
+
+@see TDblQueLink
+*/
+template <class T>
+class TDblQue : public TDblQueBase
+ {
+public:
+ inline TDblQue();
+ inline explicit TDblQue(TInt aOffset);
+ inline void AddFirst(T& aRef);
+ inline void AddLast(T& aRef);
+ inline TBool IsHead(const T* aPtr) const;
+ inline TBool IsFirst(const T* aPtr) const;
+ inline TBool IsLast(const T* aPtr) const;
+ inline T* First() const;
+ inline T* Last() const;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class that provides the behaviour for managing a doubly linked
+list in which the elements are added in descending priority order.
+
+Priority is defined by the value of the TPriQueLink::iPriority member of
+the link element.
+
+The template parameter defines the type of element that forms the doubly linked
+list and is the class that acts as host to the link object.
+
+@see TPriQueLink
+@see TPriQueLink::iPriority
+*/
+template <class T>
+class TPriQue : public TDblQueBase
+ {
+public:
+ inline TPriQue();
+ inline explicit TPriQue(TInt aOffset);
+ inline void Add(T& aRef);
+ inline TBool IsHead(const T* aPtr) const;
+ inline TBool IsFirst(const T* aPtr) const;
+ inline TBool IsLast(const T* aPtr) const;
+ inline T* First() const;
+ inline T* Last() const;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class that provides the behaviour for managing a doubly linked
+list in which elements represent values which are increments, or deltas, on
+the value represented by a preceding element.
+
+The list is ordered so that the head of the queue represents a nominal zero
+point.
+
+The delta value of a new element represents its 'distance' from the nominal
+zero point. The new element is added into the list, and the delta values of
+adjacent elements (and of the new element, if necessary) are adjusted, so
+that the sum of all deltas, up to and including the new element, is the same
+as the new element's intended 'distance' from the nominal zero point.
+
+A common use for a list of this type is as a queue of timed events, where
+the delta values represent the intervals between the events.
+
+The delta value is defined by the value of the TDeltaQueLink::iDelta member
+of the link element.
+
+The template parameter defines the type of element that forms the doubly linked
+list and is the class that acts as host to the link object.
+
+@see TDeltaQueLink
+@see TDeltaQueLink::iDelta
+*/
+template <class T>
+class TDeltaQue : public TDeltaQueBase
+ {
+public:
+ inline TDeltaQue();
+ inline explicit TDeltaQue(TInt aOffset);
+ inline void Add(T& aRef,TInt aDelta);
+ inline void Remove(T& aRef);
+ inline T* RemoveFirst();
+ };
+
+
+
+
+// Forward declaration
+class TTickCountQueLink;
+
+/**
+@internalComponent
+@released
+
+A class that provides the behaviour for managing a doubly linked list
+in which elements are added in order of the time until their tick count.
+
+A common use for a list of this type is as a queue of timed events, where
+the tick counts are the expiry times of the events.
+
+The tick count is defined by the value of the TTickCountQueLink::iTickCount
+member of the link element.
+
+@see TTickCountQueLink
+@see TTickCountQueLink::iTickCount
+*/
+class TTickCountQue : public TDblQueBase
+ {
+public:
+ TTickCountQue();
+ void Add(TTickCountQueLink& aRef);
+ TTickCountQueLink* First() const;
+ TTickCountQueLink* RemoveFirst();
+ TTickCountQueLink* RemoveFirst(TUint aTickCount);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A base class that provides implementation for the singly linked list iterator.
+
+It also encapsulates a pointer to the current link link list element.
+
+The class is abstract and is not intended to be instantiated.
+*/
+class TSglQueIterBase
+ {
+public:
+ IMPORT_C void SetToFirst();
+protected:
+ IMPORT_C TSglQueIterBase(TSglQueBase& aQue);
+ IMPORT_C TAny* DoPostInc();
+ IMPORT_C TAny* DoCurrent();
+ IMPORT_C void DoSet(TAny* aLink);
+protected:
+ TInt iOffset;
+ TSglQueLink* iHead;
+ TSglQueLink* iNext;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class that provides the behaviour for iterating through a set of
+singly linked list elements.
+
+The template parameter defines the type of element that forms the singly linked
+list. The class defined in the template parameter contains the link object.
+*/
+template <class T>
+class TSglQueIter : public TSglQueIterBase
+ {
+public:
+ inline TSglQueIter(TSglQueBase& aQue);
+ inline void Set(T& aLink);
+ inline operator T*();
+ inline T* operator++(TInt);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A base class that provides implementation for the doubly linked list iterator.
+
+It also encapsulates a pointer to the current link list element.
+
+The class is abstract and is not intended to be instantiated.
+*/
+class TDblQueIterBase
+ {
+public:
+ IMPORT_C void SetToFirst();
+ IMPORT_C void SetToLast();
+protected:
+ IMPORT_C TDblQueIterBase(TDblQueBase& aQue);
+ IMPORT_C TAny* DoPostInc();
+ IMPORT_C TAny* DoPostDec();
+ IMPORT_C TAny* DoCurrent();
+ IMPORT_C void DoSet(TAny* aLink);
+protected:
+ /**
+ The offset of a component link object within elements that form the list.
+ */
+ TInt iOffset;
+
+ /**
+ Pointer to the anchor for the list.
+ */
+ TDblQueLinkBase* iHead;
+
+ /**
+ Pointer to the current element.
+ */
+ TDblQueLinkBase* iNext;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A templated class that provides the behaviour for iterating through a set of
+doubly linked list elements.
+
+The template parameter defines the type of element that forms the doubly linked
+list. The class defined in the template parameter contains the link object.
+*/
+template <class T>
+class TDblQueIter : public TDblQueIterBase
+ {
+public:
+ inline TDblQueIter(TDblQueBase& aQue);
+ inline void Set(T& aLink);
+ inline operator T*();
+ inline T* operator++(TInt);
+ inline T* operator--(TInt);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Governs the type of comparison to be made between descriptor keys or between
+text keys.
+
+@see TKeyArrayFix
+@see TKeyArrayVar
+@see TKeyArrayPak
+*/
+enum TKeyCmpText
+ {
+ /**
+ For a Unicode build, this is the same as ECmpNormal16.
+ For a non-Unicode build, this is the same as ECmpNormal8.
+
+ Using the build independent names (i.e. TPtrC, TPtr, TBufC, TBuf or TText)
+ allows the compiler to chose the correct variant according to the build.
+ */
+ ECmpNormal,
+
+
+ /**
+ For descriptor keys, the key is assumed to be the 8 bit variant, derived
+ from TDesc8. A simple comparison is done between the content of the
+ descriptors; the data is not folded and collation rules are not applied for
+ the purpose of the comparison.
+
+ For text keys, the key is assumed to be the 8 bit variant, of type TText8.
+ A normal comparison is done between the text data; the data is not folded
+ and collation rules are not applied for the purpose of the comparison.
+ */
+ ECmpNormal8,
+
+
+ /**
+ For descriptor keys, the key is assumed to be the 16 bit variant, derived
+ from TDesc16. A simple comparison is done between the content of the
+ descriptors; the data is not folded and collation rules are not applied for
+ the purpose of the comparison.
+
+ For text keys, the key is assumed to be the 16 bit variant, of type
+ TText16. A normal comparison is done between the text data; the data is
+ not folded and collation rules are not applied for the purpose of the
+ comparison.
+ */
+ ECmpNormal16,
+
+
+ /**
+ For a Unicode build, this is the same as EcmpFolded16.
+ For a non-Unicode build, this is the same as EcmpFolded8.
+
+ Using the build independent names (i.e. TPtrC, TPtr, TBufC, TBuf or TText)
+ allows the compiler to chose the correct variant according to the build.
+ */
+ ECmpFolded,
+
+
+ /**
+ For descriptor keys, the key is assumed to be the 8 bit variant,
+ derived from TDesc8. The descriptor contents are folded for the purpose
+ of the comparison.
+
+ For text keys, the key is assumed to be the 8 bit variant, of type
+ TText8. The text data is folded for the purpose of the comparison.
+ */
+ ECmpFolded8,
+
+
+ /**
+ For descriptor keys, the key is assumed to be the 16 bit variant,
+ derived from TDesc16. The descriptor contents are folded for the purpose
+ of the comparison.
+
+ For text keys, the key is assumed to be the 16 bit variant, of type
+ TText16. The text data is folded for the purpose of the comparison.
+ */
+ ECmpFolded16,
+
+
+ /**
+ For a Unicode build, this is the same as EcmpCollated16.
+ For a non-Unicode build, this is the same as EcmpCollated8.
+
+ Using the build independent names (i.e. TPtrC, TPtr, TBufC, TBuf or TText)
+ allows the compiler to chose the correct variant according to the build.
+ */
+ ECmpCollated,
+
+
+ /**
+ For descriptor keys, the key is assumed to be the 8 bit variant,
+ derived from TDesc8. Collation rules are applied for the purpose of
+ the comparison.
+
+ For text keys, the key is assumed to be the 8 bit variant, of type
+ TText8. Collation rules are applied for the purpose of the comparison.
+ */
+ ECmpCollated8,
+
+
+ /**
+ For descriptor keys, the key is assumed to be the 16 bit variant,
+ derived from TDesc16. Collation rules are applied for the purpose of
+ the comparison.
+
+ For text keys, the key is assumed to be the 16 bit variant,
+ of type TText16. Collation rules are applied for the purpose of
+ the comparison.
+ */
+ ECmpCollated16
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Governs the type of comparison to be made between numeric keys.
+
+@see TKeyArrayFix
+@see TKeyArrayVar
+@see TKeyArrayPak
+*/
+enum TKeyCmpNumeric
+ {
+ /**
+ The key is assumed to be of type TInt8.
+ */
+ ECmpTInt8=((ECmpCollated16+1)<<1),
+
+
+ /**
+ The key is assumed to be of type TInt16.
+ */
+ ECmpTInt16,
+
+
+ /**
+ The key is assumed to be of type TInt32.
+ */
+ ECmpTInt32,
+
+
+ /**
+ The key is assumed to be of type TInt.
+ */
+ ECmpTInt,
+
+
+ /**
+ The key is assumed to be of type TUint8.
+ */
+ ECmpTUint8,
+
+
+ /**
+ The key is assumed to be of type TUint16.
+ */
+ ECmpTUint16,
+
+
+ /**
+ The key is assumed to be of type TUint32.
+ */
+ ECmpTUint32,
+
+
+ /**
+ The key is assumed to be of type TUint.
+ */
+ ECmpTUint,
+
+
+ /**
+ The key is assumed to be of type TInt64.
+ */
+ ECmpTInt64
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines the characteristics of a key used to access the elements of an array.
+
+The class is abstract and cannot be instantiated. A derived class must be
+defined and implemented.
+
+The classes TKeyArrayFix, TKeyArrayVar and TKeyArrayPak, derived from TKey,
+are already supplied to implement keys for the fixed length element, variable
+length element and packed arrays.
+
+A derived class would normally be written to define the characteristics of
+a key for a non standard array.
+
+@see TKeyArrayFix
+@see TKeyArrayVar
+@see TKeyArrayPak
+*/
+class TKey
+ {
+public:
+ inline void SetPtr(const TAny* aPtr);
+ IMPORT_C virtual TInt Compare(TInt aLeft,TInt aRight) const;
+ IMPORT_C virtual TAny* At(TInt anIndex) const;
+protected:
+ IMPORT_C TKey();
+ IMPORT_C TKey(TInt aOffset,TKeyCmpText aType);
+ IMPORT_C TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
+ IMPORT_C TKey(TInt aOffset,TKeyCmpNumeric aType);
+protected:
+ TInt iKeyOffset;
+ TInt iKeyLength;
+ TInt iCmpType;
+ const TAny* iPtr;
+ };
+
+/**
+@publishedAll
+@released
+
+Defines the basic behaviour for swapping two elements of an array.
+
+The class is abstract. A derived class must be defined and implemented to
+use the functionality.
+
+A derived class can define how to swap two elements of an array. In practice,
+this means providing an implementation for the virtual function Swap().
+
+To support this, the derived class is also likely to need a pointer to the
+array itself and suitable constructors and/or other member functions to set
+such a pointer.
+*/
+class TSwap
+ {
+public:
+ IMPORT_C TSwap();
+ IMPORT_C virtual void Swap(TInt aLeft,TInt aRight) const;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Folds a specified character and provides functions to fold additional
+characters after construction of the object.
+
+Folding converts the character to a form which can be used in tolerant
+comparisons without control over the operations performed. Tolerant comparisons
+are those which ignore character differences like case and accents.
+
+Note that folding is locale-independent behaviour. It is also important to
+note that there can be no guarantee that folding is in any way culturally
+appropriate, and should not be used for matching characters in
+natural language.
+
+@see User::Fold
+*/
+class TCharF : public TChar
+ {
+public:
+ inline TCharF(TUint aChar);
+ inline TCharF(const TChar& aChar);
+ inline TCharF& operator=(TUint aChar);
+ inline TCharF& operator=(const TChar& aChar);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Converts a specified character to lower case and provides functions to convert
+additional characters after construction of the object.
+*/
+class TCharLC : public TChar
+ {
+public:
+ inline TCharLC(TUint aChar);
+ inline TCharLC(const TChar& aChar);
+ inline TCharLC& operator=(TUint aChar);
+ inline TCharLC& operator=(const TChar& aChar);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Converts a specified character to upper case and provides functions to convert
+additional characters after construction of the object.
+*/
+class TCharUC : public TChar
+ {
+public:
+ inline TCharUC(TUint aChar);
+ inline TCharUC(const TChar& aChar);
+ inline TCharUC& operator=(TUint aChar);
+ inline TCharUC& operator=(const TChar& aChar);
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+Defines the character representation of a real number type such
+as a TReal or a TRealX.
+
+An object of this type is used by functions that convert real values to
+character format, for example, the descriptor functions:
+Num(), AppendNum() and Format().
+
+There are three constructors for constructing a suitable object.
+The data members of the class, however, are public and can be
+explicitly set after construction.
+*/
+class TRealFormat
+ {
+public:
+ IMPORT_C TRealFormat();
+ IMPORT_C TRealFormat(TInt aWidth);
+ IMPORT_C TRealFormat(TInt aWidth,TInt aDecimalPlaces);
+public:
+ /**
+ Governs the format of the character representation of the real number.
+
+ This is set to one of the defined format types.
+
+ One or more of the defined format flags can subsequently be ORed into this member.
+
+ @see KRealFormatFixed
+ @see KRealFormatExponent
+ @see KRealFormatGeneral
+ @see KRealFormatNoExponent
+ @see KRealFormatCalculator
+ @see KExtraSpaceForSign
+ @see KAllowThreeDigitExp
+ @see KDoNotUseTriads
+ @see KGeneralLimit
+ @see KUseSigFigs
+ */
+ TInt iType;
+
+
+ /**
+ Defines the maximum number of characters required to represent the number.
+ */
+ TInt iWidth;
+
+
+ /**
+ Defines either the number of characters to be used to represent the decimal
+ portion of the number, or the maximum number of significant digits in
+ the character representation of the number.
+
+ The interpretation depends on the chosen format as defined by iType.
+
+ @see TRealFormat::iType
+ */
+ TInt iPlaces;
+
+
+ /**
+ Defines the character to be used to separate the integer portion of
+ a number representation from its decimal portion.
+
+ In general, the character used for this purpose is a matter of local
+ convention. The TLocale::DecimalSeparator() function can supply the
+ desired character.
+
+ @see TLocale
+ */
+ TChar iPoint;
+
+
+ /**
+ Defines the character to be used to delimit groups of three digits in
+ the integer part of the number.
+
+ In general, the character used for this purpose is a matter of local
+ convention. The TLocale::ThousandsSeparator() function can supply the
+ desired character.
+
+ @see TLocale
+ */
+ TChar iTriad;
+
+
+ /**
+ Defines the threshold number of digits above which triad separation is to
+ occur. A value of zero disables triad separation and no triad separation
+ character (i.e. the character held in iTriad) is inserted into the
+ resulting character representation regardless of the number of characters.
+
+ For example, a value of 1 causes the number 1000 to be represented by the
+ characters "1,000" whereas a value of 4 causes the same number to be
+ represented by the characters "1000" (This assumes the ‘,’ triad separation
+ character).
+
+ Note that no triad separation occurs if the flag KDoNotUseTriads is set in
+ the iType data member.
+
+ @see TRealFormat::iTriad
+ @see KDoNotUseTriads
+ */
+ TInt iTriLen;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines the extraction mark used by the TLex8 class to indicate the current
+lexical element being analysed.
+
+In practice, objects of this type are accessed through the TLexMark typedef.
+
+@see TLexMark
+@see TLex8
+*/
+class TLexMark8
+ {
+public:
+ inline TLexMark8();
+private:
+ inline TLexMark8(const TUint8* aString);
+ const TUint8* iPtr;
+ friend class TLex8;
+ __DECLARE_TEST;
+ };
+
+
+
+
+class TRealX;
+/**
+@publishedAll
+@released
+
+Provides general string-parsing functions suitable for numeric format
+conversions and syntactical-element parsing.
+
+The class is the 8-bit variant for non-Unicode strings and 8-bit wide
+characters.
+
+An instance of this class stores a string, maintaining an extraction mark
+to indicate the current lexical element being analysed and a pointer to the
+next character to be examined.
+
+Objects of this type are normally accessed through the build independent type
+TLex.
+
+@see TLex
+*/
+class TLex8
+ {
+public:
+ IMPORT_C TLex8();
+ inline TLex8(const TUint8* aString);
+ inline TLex8(const TDesC8& aDes);
+ inline TLex8& operator=(const TUint8* aString);
+ inline TLex8& operator=(const TDesC8& aDes);
+ inline TBool Eos() const;
+ inline void Mark(TLexMark8& aMark) const;
+ inline void Mark();
+ IMPORT_C void Inc();
+ IMPORT_C void Inc(TInt aNumber);
+ IMPORT_C TChar Get();
+ IMPORT_C TChar Peek() const;
+ IMPORT_C void UnGet();
+ inline void UnGetToMark();
+ IMPORT_C void UnGetToMark(const TLexMark8 aMark);
+ IMPORT_C void SkipSpace();
+ inline void SkipAndMark(TInt aNumber);
+ IMPORT_C void SkipAndMark(TInt aNumber, TLexMark8& aMark);
+ inline void SkipSpaceAndMark();
+ IMPORT_C void SkipSpaceAndMark(TLexMark8& aMark);
+ IMPORT_C void SkipCharacters();
+ inline TInt TokenLength() const;
+ IMPORT_C TInt TokenLength(const TLexMark8 aMark) const;
+ IMPORT_C TPtrC8 MarkedToken() const;
+ IMPORT_C TPtrC8 MarkedToken(const TLexMark8 aMark) const;
+ IMPORT_C TPtrC8 NextToken();
+ IMPORT_C TPtrC8 Remainder() const;
+ IMPORT_C TPtrC8 RemainderFromMark() const;
+ IMPORT_C TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
+ IMPORT_C TInt Offset() const;
+ inline TInt MarkedOffset() const;
+ IMPORT_C TInt MarkedOffset(const TLexMark8 aMark) const;
+ IMPORT_C TInt Val(TInt8& aVal);
+ IMPORT_C TInt Val(TInt16& aVal);
+ IMPORT_C TInt Val(TInt32& aVal);
+ IMPORT_C TInt Val(TInt64& aVal);
+ inline TInt Val(TInt& aVal);
+ IMPORT_C TInt Val(TUint8& aVal,TRadix aRadix);
+ IMPORT_C TInt Val(TUint16& aVal,TRadix aRadix);
+ IMPORT_C TInt Val(TUint32& aVal,TRadix aRadix);
+ IMPORT_C TInt Val(TInt64& aVal, TRadix aRadix);
+ inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
+ IMPORT_C TInt BoundedVal(TInt32& aVal,TInt aLimit);
+ IMPORT_C TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
+ IMPORT_C TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
+ IMPORT_C TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
+ IMPORT_C TInt Val(TReal32& aVal);
+ IMPORT_C TInt Val(TReal32& aVal,TChar aPoint);
+ IMPORT_C TInt Val(TReal64& aVal);
+ IMPORT_C TInt Val(TReal64& aVal,TChar aPoint);
+ inline void Assign(const TLex8& aLex);
+ IMPORT_C void Assign(const TUint8* aString);
+ IMPORT_C void Assign(const TDesC8& aDes);
+ TInt Val(TRealX& aVal);
+ TInt Val(TRealX& aVal, TChar aPoint);
+
+ /** @deprecated Use BoundedVal(TInt32& aVal,TInt aLimit) */
+ inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
+
+ /** @deprecated Use BoundedVal(TInt64& aVal,const TInt64& aLimit) */
+ inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
+
+ /** @deprecated Use BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit) */
+ inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
+
+ /** @deprecated Use BoundedVal(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) */
+ inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
+private:
+ void Scndig(TInt& aSig, TInt& aExp, TUint64& aDl);
+ void ScndigAfterPoint(TInt& aSig, TUint64& aDl);
+ void ValidateMark(const TLexMark8 aMark) const;
+private:
+ const TUint8* iNext;
+ const TUint8* iBuf;
+ const TUint8* iEnd;
+ TLexMark8 iMark;
+ __DECLARE_TEST;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines the extraction mark used by the TLex16 class to indicate the current
+lexical element being analysed.
+
+In practice, objects of this type are accessed through the TLexMark typedef.
+
+@see TLexMark
+@see TLex16
+*/
+class TLexMark16
+ {
+public:
+ inline TLexMark16();
+private:
+ inline TLexMark16(const TUint16* aString);
+ const TUint16* iPtr;
+ friend class TLex16;
+ __DECLARE_TEST;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Provides general string-parsing functions suitable for numeric format
+conversions and syntactical-element parsing.
+
+The class is the 16-bit variant for Unicode strings and 16-bit wide
+characters.
+
+An instance of this class stores a string, maintaining an extraction mark
+to indicate the current lexical element being analysed and a pointer to the
+next character to be examined.
+
+Objects of this type are normally accessed through the build independent type
+TLex.
+
+@see TLex
+*/
+class TLex16
+ {
+public:
+ IMPORT_C TLex16();
+ inline TLex16(const TUint16* aString);
+ inline TLex16(const TDesC16& aDes);
+ inline TLex16& operator=(const TUint16* aString);
+ inline TLex16& operator=(const TDesC16& aDes);
+ inline TBool Eos() const;
+ inline void Mark();
+ inline void Mark(TLexMark16& aMark) const;
+ IMPORT_C void Inc();
+ IMPORT_C void Inc(TInt aNumber);
+ IMPORT_C TChar Get();
+ IMPORT_C TChar Peek() const;
+ IMPORT_C void UnGet();
+ inline void UnGetToMark();
+ IMPORT_C void UnGetToMark(const TLexMark16 aMark);
+ IMPORT_C void SkipSpace();
+ inline void SkipAndMark(TInt aNumber);
+ IMPORT_C void SkipAndMark(TInt aNumber, TLexMark16& aMark);
+ IMPORT_C void SkipSpaceAndMark(TLexMark16& aMark);
+ inline void SkipSpaceAndMark();
+ IMPORT_C void SkipCharacters();
+ inline TInt TokenLength() const;
+ IMPORT_C TInt TokenLength(const TLexMark16 aMark) const;
+ IMPORT_C TPtrC16 MarkedToken() const;
+ IMPORT_C TPtrC16 MarkedToken(const TLexMark16 aMark) const;
+ IMPORT_C TPtrC16 NextToken();
+ IMPORT_C TPtrC16 Remainder() const;
+ IMPORT_C TPtrC16 RemainderFromMark() const;
+ IMPORT_C TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
+ IMPORT_C TInt Offset() const;
+ inline TInt MarkedOffset() const;
+ IMPORT_C TInt MarkedOffset(const TLexMark16 aMark) const;
+ IMPORT_C TInt Val(TInt8& aVal);
+ IMPORT_C TInt Val(TInt16& aVal);
+ IMPORT_C TInt Val(TInt32& aVal);
+ IMPORT_C TInt Val(TInt64& aVal);
+ inline TInt Val(TInt& aVal);
+ IMPORT_C TInt Val(TUint8& aVal,TRadix aRadix);
+ IMPORT_C TInt Val(TUint16& aVal,TRadix aRadix);
+ IMPORT_C TInt Val(TUint32& aVal,TRadix aRadix);
+ IMPORT_C TInt Val(TInt64& aVal, TRadix aRadix);
+// inline TInt Val(TInt64& aVal, TRadix aRadix) {return Val(aVal,aRadix);}
+ inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
+ IMPORT_C TInt BoundedVal(TInt32& aVal,TInt aLimit);
+ IMPORT_C TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
+ IMPORT_C TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
+ IMPORT_C TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
+ IMPORT_C TInt Val(TReal32& aVal);
+ IMPORT_C TInt Val(TReal32& aVal,TChar aPoint);
+ IMPORT_C TInt Val(TReal64& aVal);
+ IMPORT_C TInt Val(TReal64& aVal,TChar aPoint);
+ inline void Assign(const TLex16& aLex);
+ IMPORT_C void Assign(const TUint16* aString);
+ IMPORT_C void Assign(const TDesC16& aDes);
+ TInt Val(TRealX& aVal);
+ TInt Val(TRealX& aVal, TChar aPoint);
+
+ /** @deprecated Use BoundedVal(TInt32& aVal,TInt aLimit) */
+ inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
+
+ /** @deprecated Use BoundedVal(TInt64& aVal,const TInt64& aLimit) */
+ inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
+
+ /** @deprecated Use BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit) */
+ inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
+
+ /** @deprecated Use BoundedVal(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) */
+ inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
+private:
+ void Scndig(TInt& aSig, TInt& aExp, TUint64& aDl);
+ void ValidateMark(const TLexMark16 aMark) const;
+private:
+ const TUint16* iNext;
+ const TUint16* iBuf;
+ const TUint16* iEnd;
+ TLexMark16 iMark;
+ __DECLARE_TEST;
+ };
+
+
+
+
+#if defined(_UNICODE)
+/**
+@publishedAll
+@released
+
+Provides access to general string-parsing functions suitable for numeric format
+conversions and syntactical-element parsing.
+
+It maps directly to either a TLex16 for a Unicode build or a TLex8 for a non-Unicode
+build.
+
+The build independent type should always be used unless an explicit 16 bit
+or 8 bit build variant is required.
+
+@see TLex16
+@see TLex8
+*/
+typedef TLex16 TLex;
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines the extraction mark used by the TLex classes to indicate the current
+lexical element being analysed.
+
+It maps directly to either a TLexMark16 for a Unicode build or a TLexMark8
+for a non-Unicode build.
+
+The build independent type should always be used unless an explicit 16 bit
+or 8 bit build variant is required.
+*/
+typedef TLexMark16 TLexMark;
+
+
+
+
+#else
+
+
+
+/**
+@publishedAll
+@released
+
+Provides access to general string-parsing functions suitable for numeric format
+conversions and syntactical-element parsing.
+
+It maps directly to either a TLex16 for a Unicode build or a TLex8 for a non-Unicode
+build.
+
+The build independent type should always be used unless an explicit 16 bit
+or 8 bit build variant is required.
+
+@see TLex16
+@see TLex8
+*/
+typedef TLex8 TLex;
+
+
+
+
+/**
+@publishedAll
+@released
+
+Defines the extraction mark used by the TLex classes to indicate the current
+lexical element being analysed.
+
+It maps directly to either a TLexMark16 for a Unicode build or a TLexMark8
+for a non-Unicode build.
+
+The build independent type should always be used unless an explicit 16 bit
+or 8 bit build variant is required.
+*/
+typedef TLexMark8 TLexMark;
+#endif
+
+
+
+
+/**
+@publishedAll
+@released
+
+Packages a Uid type together with a checksum.
+
+@see TUidType
+*/
+class TCheckedUid
+ {
+public:
+ IMPORT_C TCheckedUid();
+ IMPORT_C TCheckedUid(const TUidType& aUidType);
+ IMPORT_C TCheckedUid(const TDesC8& aPtr);
+ IMPORT_C void Set(const TUidType& aUidType);
+ IMPORT_C void Set(const TDesC8& aPtr);
+ IMPORT_C TPtrC8 Des() const;
+ inline const TUidType& UidType() const;
+protected:
+ IMPORT_C TUint Check() const;
+private:
+ TUidType iType;
+ TUint iCheck;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A date and time object in which the individual components are accessible in
+human-readable form.
+
+The individual components are: year, month, day, hour, minute,
+second and microsecond.
+
+These components are stored as integers and all except the year are checked for
+validity when a TDateTime is constructed or assigned new values.
+
+This class only supports getting and setting the entire date/time or any component
+of it. It does not support adding or subtracting intervals to or from a time.
+For functions which manipulate times, use class TTime.
+
+@see TTime
+*/
+class TDateTime
+ {
+public:
+ inline TDateTime();
+ IMPORT_C TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
+ IMPORT_C TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
+ IMPORT_C TInt SetYear(TInt aYear);
+ IMPORT_C TInt SetYearLeapCheck(TInt aYear);
+ IMPORT_C TInt SetMonth(TMonth aMonth);
+ IMPORT_C TInt SetDay(TInt aDay);
+ IMPORT_C TInt SetHour(TInt aHour);
+ IMPORT_C TInt SetMinute(TInt aMinute);
+ IMPORT_C TInt SetSecond(TInt aSecond);
+ IMPORT_C TInt SetMicroSecond(TInt aMicroSecond);
+ inline TInt Year() const;
+ inline TMonth Month() const;
+ inline TInt Day() const;
+ inline TInt Hour() const;
+ inline TInt Minute() const;
+ inline TInt Second() const;
+ inline TInt MicroSecond() const;
+private:
+ TInt iYear;
+ TMonth iMonth;
+ TInt iDay;
+ TInt iHour;
+ TInt iMinute;
+ TInt iSecond;
+ TInt iMicroSecond;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a time interval of a millionth of a second stored as
+a 64-bit integer.
+
+It supports the initialisation, setting and getting of an interval and provides
+standard comparison operations. Objects of this class can be added to and
+subtracted from TTime objects.
+
+@see TTime
+*/
+class TTimeIntervalMicroSeconds
+ {
+public:
+ inline TTimeIntervalMicroSeconds();
+ inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
+ inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
+ inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
+ inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
+ inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
+ inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
+ inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
+ inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
+ inline const TInt64& Int64() const;
+private:
+ TInt64 iInterval;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Provides a base class for all time interval classes using
+a 32-bit representation.
+
+It supports retrieving the interval and provides various operations for
+comparing intervals. Its concrete derived classes can be added to and
+subtracted from a TTime.
+
+The comparison operators simply compare the integer representations of the
+two intervals. They do not take account of different time interval units.
+So, for example, when comparing for equality an interval of three hours with
+an interval of three days, the result is true.
+
+@see TTime
+*/
+class TTimeIntervalBase
+ {
+public:
+ inline TBool operator==(TTimeIntervalBase aInterval) const;
+ inline TBool operator!=(TTimeIntervalBase aInterval) const;
+ inline TBool operator>=(TTimeIntervalBase aInterval) const;
+ inline TBool operator<=(TTimeIntervalBase aInterval) const;
+ inline TBool operator>(TTimeIntervalBase aInterval) const;
+ inline TBool operator<(TTimeIntervalBase aInterval) const;
+ inline TInt Int() const;
+protected:
+ inline TTimeIntervalBase();
+ inline TTimeIntervalBase(TInt aInterval);
+protected:
+ TInt iInterval;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a microsecond time interval stored in 32 rather than 64 bits.
+
+Its range is +-2147483647, which is +-35 minutes, 47 seconds. Comparison and
+interval retrieval functions are provided by the base class TTimeIntervalBase.
+*/
+class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
+ {
+public:
+ inline TTimeIntervalMicroSeconds32();
+ inline TTimeIntervalMicroSeconds32(TInt aInterval);
+ inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a time interval in seconds.
+
+Comparison and interval retrieval functions
+are provided by the base class TTimeIntervalBase.
+
+The range of values which it can represent is +-2147483647, which is equal to
++-24855 days (approximately 68 years).
+*/
+class TTimeIntervalSeconds : public TTimeIntervalBase
+ {
+public:
+ inline TTimeIntervalSeconds();
+ inline TTimeIntervalSeconds(TInt aInterval);
+ inline TTimeIntervalSeconds& operator=(TInt aInterval);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a time interval in minutes.
+
+Comparison and interval retrieval functions
+are provided by the base class TTimeIntervalBase.
+*/
+class TTimeIntervalMinutes : public TTimeIntervalBase
+ {
+public:
+ inline TTimeIntervalMinutes();
+ inline TTimeIntervalMinutes(TInt aInterval);
+ inline TTimeIntervalMinutes& operator=(TInt aInterval);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a time interval in hours.
+
+Comparison and interval retrieval functions
+are provided by the base class TTimeIntervalBase.
+*/
+class TTimeIntervalHours : public TTimeIntervalBase
+ {
+public:
+ inline TTimeIntervalHours();
+ inline TTimeIntervalHours(TInt aInterval);
+ inline TTimeIntervalHours& operator=(TInt aInterval);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a time interval in days.
+
+Comparison and interval retrieval functions
+are provided by the base class TTimeIntervalBase.
+*/
+class TTimeIntervalDays : public TTimeIntervalBase
+ {
+public:
+ inline TTimeIntervalDays();
+ inline TTimeIntervalDays(TInt aInterval);
+ inline TTimeIntervalDays& operator=(TInt aInterval);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a time interval in months.
+
+Comparison and interval retrieval functions
+are provided by the base class TTimeIntervalBase.
+*/
+class TTimeIntervalMonths : public TTimeIntervalBase
+ {
+public:
+ inline TTimeIntervalMonths();
+ inline TTimeIntervalMonths(TInt aInterval);
+ inline TTimeIntervalMonths& operator=(TInt aInterval);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Represents a time interval in years.
+
+Comparison and interval retrieval functions
+are provided by the base class TTimeIntervalBase.
+*/
+class TTimeIntervalYears : public TTimeIntervalBase
+ {
+public:
+ inline TTimeIntervalYears();
+ inline TTimeIntervalYears(TInt aInterval);
+ inline TTimeIntervalYears& operator=(TInt aInterval);
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+An enumeration one or both of whose enumerator values may be returned
+by TTime::Parse().
+
+@see TTime::Parse
+*/
+enum {
+ /**
+ Indicates that a time is present.
+
+ @see TTime::Parse
+ */
+ EParseTimePresent=0x1,
+ /**
+ Indicates that a date is present.
+
+ @see TTime::Parse
+ */
+ EParseDatePresent=0x2
+ };
+
+
+
+class TLocale;
+/**
+@publishedAll
+@released
+
+Stores and manipulates the date and time.
+
+It represents a date and time as a number of microseconds since midnight,
+January 1st, 1 AD nominal Gregorian. BC dates are represented by negative
+TTime values. A TTime object may be constructed from a TInt64, a TDateTime
+a string literal, or by default, which initialises the time to an arbitrary
+value. To access human-readable time information, the TTime may be converted
+from a TInt64 into a TDateTime, which represents the date and time as seven
+numeric fields and provides functions to extract these fields. Alternatively,
+to display the time as text, the time may be formatted and placed into a
+descriptor using a variety of formatting commands and which may or may not
+honour the system's locale settings. The conversion between time and text may
+be performed the other way around, so that a descriptor can be parsed and
+converted into a TTime value.
+
+In addition to setting and getting the date and time and converting between
+text and time, TTime provides functions to get intervals between times and
+standard comparison and arithmetic operators which enable time intervals to
+be added or subtracted to or from the time.
+
+@see TInt64
+@see TDateTime
+*/
+class TTime
+ {
+public:
+ inline TTime();
+ inline TTime(const TInt64& aTime);
+ IMPORT_C TTime(const TDesC& aString);
+ IMPORT_C TTime(const TDateTime& aDateTime);
+ inline TTime& operator=(const TInt64& aTime);
+ IMPORT_C TTime& operator=(const TDateTime& aDateTime);
+ IMPORT_C void HomeTime();
+ IMPORT_C void UniversalTime();
+ IMPORT_C TInt Set(const TDesC& aString);
+ IMPORT_C TInt HomeTimeSecure();
+ IMPORT_C TInt UniversalTimeSecure();
+
+ IMPORT_C TDateTime DateTime() const;
+ IMPORT_C TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;
+ IMPORT_C TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;
+ IMPORT_C TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;
+ IMPORT_C TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;
+ IMPORT_C TTimeIntervalDays DaysFrom(TTime aTime) const;
+ IMPORT_C TTimeIntervalMonths MonthsFrom(TTime aTime) const;
+ IMPORT_C TTimeIntervalYears YearsFrom(TTime aTime) const;
+
+ IMPORT_C TInt DaysInMonth() const;
+ IMPORT_C TDay DayNoInWeek() const;
+ IMPORT_C TInt DayNoInMonth() const;
+ IMPORT_C TInt DayNoInYear() const;
+ IMPORT_C TInt DayNoInYear(TTime aStartDate) const;
+ IMPORT_C TInt WeekNoInYear() const;
+ IMPORT_C TInt WeekNoInYear(TTime aStartDate) const;
+ IMPORT_C TInt WeekNoInYear(TFirstWeekRule aRule) const;
+ IMPORT_C TInt WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const;
+ IMPORT_C void FormatL(TDes& aDes,const TDesC& aFormat) const;
+ IMPORT_C void FormatL(TDes& aDes,const TDesC& aFormat,const TLocale& aLocale) const;
+ IMPORT_C void RoundUpToNextMinute();
+ IMPORT_C TInt Parse(const TDesC& aDes,TInt aCenturyOffset=0);
+
+ IMPORT_C TTime operator+(TTimeIntervalYears aYear) const;
+ IMPORT_C TTime operator+(TTimeIntervalMonths aMonth) const;
+ IMPORT_C TTime operator+(TTimeIntervalDays aDay) const;
+ IMPORT_C TTime operator+(TTimeIntervalHours aHour) const;
+ IMPORT_C TTime operator+(TTimeIntervalMinutes aMinute) const;
+ IMPORT_C TTime operator+(TTimeIntervalSeconds aSecond) const;
+ IMPORT_C TTime operator+(TTimeIntervalMicroSeconds aMicroSecond) const;
+ IMPORT_C TTime operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const;
+ IMPORT_C TTime operator-(TTimeIntervalYears aYear) const;
+ IMPORT_C TTime operator-(TTimeIntervalMonths aMonth) const;
+ IMPORT_C TTime operator-(TTimeIntervalDays aDay) const;
+ IMPORT_C TTime operator-(TTimeIntervalHours aHour) const;
+ IMPORT_C TTime operator-(TTimeIntervalMinutes aMinute) const;
+ IMPORT_C TTime operator-(TTimeIntervalSeconds aSecond) const;
+ IMPORT_C TTime operator-(TTimeIntervalMicroSeconds aMicroSecond) const;
+ IMPORT_C TTime operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const;
+ IMPORT_C TTime& operator+=(TTimeIntervalYears aYear);
+ IMPORT_C TTime& operator+=(TTimeIntervalMonths aMonth);
+ IMPORT_C TTime& operator+=(TTimeIntervalDays aDay);
+ IMPORT_C TTime& operator+=(TTimeIntervalHours aHour);
+ IMPORT_C TTime& operator+=(TTimeIntervalMinutes aMinute);
+ IMPORT_C TTime& operator+=(TTimeIntervalSeconds aSecond);
+ IMPORT_C TTime& operator+=(TTimeIntervalMicroSeconds aMicroSecond);
+ IMPORT_C TTime& operator+=(TTimeIntervalMicroSeconds32 aMicroSecond);
+ IMPORT_C TTime& operator-=(TTimeIntervalYears aYear);
+ IMPORT_C TTime& operator-=(TTimeIntervalMonths aMonth);
+ IMPORT_C TTime& operator-=(TTimeIntervalDays aDay);
+ IMPORT_C TTime& operator-=(TTimeIntervalHours aHour);
+ IMPORT_C TTime& operator-=(TTimeIntervalMinutes aMinute);
+ IMPORT_C TTime& operator-=(TTimeIntervalSeconds aSecond);
+ IMPORT_C TTime& operator-=(TTimeIntervalMicroSeconds aMicroSecond);
+ IMPORT_C TTime& operator-=(TTimeIntervalMicroSeconds32 aMicroSecond);
+ inline TBool operator==(TTime aTime) const;
+ inline TBool operator!=(TTime aTime) const;
+ inline TBool operator>=(TTime aTime) const;
+ inline TBool operator<=(TTime aTime) const;
+ inline TBool operator>(TTime aTime) const;
+ inline TBool operator<(TTime aTime) const;
+ inline const TInt64& Int64() const;
+private:
+ static TTime Convert(const TDateTime& aDateTime);
+private:
+ TInt64 iTime;
+ __DECLARE_TEST;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A utility class whose functions may be used by the other date/time related
+classes.
+*/
+class Time
+ {
+public:
+ IMPORT_C static TTime NullTTime();
+ IMPORT_C static TTime MaxTTime();
+ IMPORT_C static TTime MinTTime();
+ IMPORT_C static TInt DaysInMonth(TInt aYear, TMonth aMonth);
+ IMPORT_C static TBool IsLeapYear(TInt aYear);
+ IMPORT_C static TInt LeapYearsUpTo(TInt aYear);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Gets a copy of the current locale's full text name for a day of the week.
+
+After construction or after a call to Set(), the copy of the text can be accessed
+and manipulated using the standard descriptor member functions provided by
+the base class.
+
+@see KMaxDayName
+*/
+class TDayName : public TBuf<KMaxDayName>
+ {
+public:
+ IMPORT_C TDayName();
+ IMPORT_C TDayName(TDay aDay);
+ IMPORT_C void Set(TDay aDay);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Gets a copy of the current locale's abbreviated text name for a day of the
+week.
+
+After construction or after a call to Set(), the copy of the abbreviated text
+can be accessed and manipulated using the standard descriptor member functions
+provided by the base class.
+
+The abbreviated day name cannot be assumed to be one character. In English,
+it is 3 characters (Mon, Tue, Wed etc.), but the length can vary from locale
+to locale, with a maximum length of KMaxDayNameAbb.
+
+@see KMaxDayNameAbb
+*/
+class TDayNameAbb : public TBuf<KMaxDayNameAbb>
+ {
+public:
+ IMPORT_C TDayNameAbb();
+ IMPORT_C TDayNameAbb(TDay aDay);
+ IMPORT_C void Set(TDay aDay);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Gets a copy of the current locale's full text name for a month.
+
+After construction or after a call to Set(), the copy of the text can be accessed
+and manipulated using the standard descriptor member functions provided by
+the base class.
+
+@see KMaxMonthName
+*/
+class TMonthName : public TBuf<KMaxMonthName>
+ {
+public:
+ IMPORT_C TMonthName();
+ IMPORT_C TMonthName(TMonth aMonth);
+ IMPORT_C void Set(TMonth aMonth);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Gets a copy of the current locale's abbreviated text name for a month.
+
+After construction or after a call to Set(), the copy of the abbreviated text
+can be accessed and manipulated using the standard descriptor member functions
+provided by the base class.
+
+@see KMaxMonthNameAbb
+*/
+class TMonthNameAbb : public TBuf<KMaxMonthNameAbb>
+ {
+public:
+ IMPORT_C TMonthNameAbb();
+ IMPORT_C TMonthNameAbb(TMonth aMonth);
+ IMPORT_C void Set(TMonth aMonth);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Gets a copy of the current locale's date suffix text for a specific day in
+the month.
+
+The text is the set of characters which can be appended to dates of the month
+(e.g. in English, st for 1st, nd for 2nd etc).
+
+After construction or after a call to Set(), the copy of the suffix text can
+be accessed and manipulated using the standard descriptor member functions
+provided by the base class.
+*/
+class TDateSuffix : public TBuf<KMaxSuffix>
+ {
+public:
+ IMPORT_C TDateSuffix();
+ IMPORT_C TDateSuffix(TInt aDateSuffix);
+ IMPORT_C void Set(TInt aDateSuffix);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Current locale's am/pm text
+
+This class retrieves a copy of the current locale's text identifying time
+before and after noon. In English, this is am and pm.
+
+After construction or after a call to Set(), the copy of the text can be accessed
+and manipulated using the standard descriptor member functions provided by
+the base class.
+*/
+class TAmPmName : public TBuf<KMaxAmPmName>
+ {
+public:
+ IMPORT_C TAmPmName();
+ IMPORT_C TAmPmName(TAmPm aSelector);
+ IMPORT_C void Set(TAmPm aSelector);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Gets a copy of the currency symbol(s) in use by the current locale.
+
+After construction or after a call to TCurrencySymbol::Set(), the copy of
+the currency symbol(s) can be accessed and manipulated using the standard
+descriptor member functions provided by the base class.
+*/
+class TCurrencySymbol : public TBuf<KMaxCurrencySymbol>
+ {
+public:
+ IMPORT_C TCurrencySymbol();
+ IMPORT_C void Set();
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Contains a format list that defines the short date format.
+
+An instance of this class should be passed as the second argument
+to TTime::FormatL().
+The string does not include any time components. The content of the long
+date format specification is taken from the system-wide settings.
+
+For example, in the English locale, the short date format would be something
+like 14/1/2000.
+
+This class is used as follows:
+
+@code
+TTime now;
+now.HomeTime();
+TBuf<KMaxShortDateFormatSpec*2> buffer;
+now.FormatL(buffer,TShortDateFormatSpec());
+@endcode
+
+@see KMaxShortDateFormatSpec
+@see TTime::FormatL
+*/
+class TShortDateFormatSpec : public TBuf<KMaxShortDateFormatSpec> // to be passed into TTime::FormatL
+ {
+public:
+ IMPORT_C TShortDateFormatSpec();
+ IMPORT_C void Set();
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Contains a format list that defines the long date format.
+
+An instance of this class should be passed as the second argument
+to TTime::FormatL().
+The string does not include any time components. The content of the long
+date format specification is taken from the system-wide settings.
+
+For example, in the English locale, the long date format would be
+something like 14th January 2000.
+
+This class is used as follows:
+
+@code
+TTime now;
+now.HomeTime();
+TBuf<KMaxLongDateFormatSpec*2> buffer;
+now.FormatL(buffer,TLongDateFormatSpec());
+@endcode
+
+@see KMaxLongDateFormatSpec
+@see TTime::FormatL
+*/
+class TLongDateFormatSpec : public TBuf<KMaxLongDateFormatSpec> // to be passed into TTime::FormatL
+ {
+public:
+ IMPORT_C TLongDateFormatSpec();
+ IMPORT_C void Set();
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Contains a format list that defines the time string format.
+
+An instance of this class should be passed as the second argument
+to TTime::FormatL().
+The string does not include any time components. The content of the time format
+specification is taken from the system-wide settings.
+
+This class is used as follows:
+
+@code
+TTime now;
+now.HomeTime();
+TBuf<KMaxTimeFormatSpec*2> buffer;
+now.FormatL(buffer,TTimeFormatSpec());
+@endcode
+
+@see KMaxTimeFormatSpec
+@see TTime::FormatL
+*/
+class TTimeFormatSpec : public TBuf<KMaxTimeFormatSpec> // to be passed into TTime::FormatL
+ {
+public:
+ IMPORT_C TTimeFormatSpec();
+ IMPORT_C void Set();
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Sets and gets the system's locale settings.
+
+Symbian OS maintains the locale information internally. On
+construction, this object is initialized with the system information
+for all locale items.
+*/
+class TLocale
+ {
+public:
+
+ /**
+ Indicates how negative currency values are formatted.
+ */
+ enum TNegativeCurrencyFormat
+ {
+ /**
+ A minus sign is inserted before the currency symbol and value.
+ */
+ ELeadingMinusSign,
+
+ /**
+ The currency value and symbol are enclosed in brackets (no minus sign
+ is used).
+ */
+ EInBrackets, //this one must be non-zero for binary compatibility with the old TBool TLocale::iCurrencyNegativeInBrackets which was exposed in the binary interface because it was accessed via *inline* functions
+
+ /**
+ A minus sign is inserted after the currency symbol and value.
+ */
+ ETrailingMinusSign,
+
+ /**
+ A minus sign is inserted between the currency symbol and the value.
+ */
+ EInterveningMinusSign
+ };
+
+ /**
+ Flags for negative currency values formatting
+ */
+ enum
+ {
+ /**
+ If this flag is set and the currency value being formatted is negative,
+ if there is a space between the currency symbol and the value,
+ that space is lost.
+ */
+ EFlagNegativeLoseSpace = 0x00000001,
+
+ /**
+ If this flag is set and the currency value being formatted is negative,
+ the position of the currency symbol is placed in the opposite direction
+ from the position set for the positive currency value.
+ */
+ EFlagNegativeCurrencySymbolOpposite=0x00000002
+ };
+ /** Indicates how the device universal time is maintained */
+ enum TDeviceTimeState
+ {
+ /** Universal time is maintained by the device RTC and the user selection
+ of the locale of the device indicating offset from GMT and daylight saving*/
+ EDeviceUserTime,
+
+ /** Universal time and offset from GMT is supplied by the mobile network
+ and maintained by device RTC */
+ ENITZNetworkTimeSync
+ };
+public:
+ IMPORT_C TLocale();
+ inline TLocale(TInt);
+ IMPORT_C void Refresh();
+ IMPORT_C TInt Set() const;
+ IMPORT_C void FormatCurrency(TDes& aText, TInt aAmount);
+ IMPORT_C void FormatCurrency(TDes& aText, TInt64 aAmount);
+ IMPORT_C void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt aAmount);
+ IMPORT_C void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt64 aAmount);
+
+ inline TInt CountryCode() const;
+ inline void SetCountryCode(TInt aCode);
+ inline TTimeIntervalSeconds UniversalTimeOffset() const;
+ inline TDateFormat DateFormat() const;
+ inline void SetDateFormat(TDateFormat aFormat);
+ inline TTimeFormat TimeFormat() const;
+ inline void SetTimeFormat(TTimeFormat aFormat);
+ inline TLocalePos CurrencySymbolPosition() const;
+ inline void SetCurrencySymbolPosition(TLocalePos aPos);
+ inline TBool CurrencySpaceBetween() const;
+ inline void SetCurrencySpaceBetween(TBool aSpace);
+ inline TInt CurrencyDecimalPlaces() const;
+ inline void SetCurrencyDecimalPlaces(TInt aPlaces);
+ inline TBool CurrencyNegativeInBrackets() const; // These two functions are deprecated
+ inline void SetCurrencyNegativeInBrackets(TBool aBool); // They are here to maintain compatibility. Use the New functions -> NegativeCurrencyFormat setter/getter.
+ inline TBool CurrencyTriadsAllowed() const;
+ inline void SetCurrencyTriadsAllowed(TBool aBool);
+ inline TChar ThousandsSeparator() const;
+ inline void SetThousandsSeparator(const TChar& aChar);
+ inline TChar DecimalSeparator() const;
+ inline void SetDecimalSeparator(const TChar& aChar);
+ inline TChar DateSeparator(TInt aIndex) const;
+ inline void SetDateSeparator(const TChar& aChar,TInt aIndex);
+ inline TChar TimeSeparator(TInt aIndex) const;
+ inline void SetTimeSeparator(const TChar& aChar,TInt aIndex);
+ inline TBool AmPmSpaceBetween() const;
+ inline void SetAmPmSpaceBetween(TBool aSpace);
+ inline TLocalePos AmPmSymbolPosition() const;
+ inline void SetAmPmSymbolPosition(TLocalePos aPos);
+ inline TUint DaylightSaving() const;
+ inline TBool QueryHomeHasDaylightSavingOn() const;
+ inline TDaylightSavingZone HomeDaylightSavingZone() const;
+ inline TUint WorkDays() const;
+ inline void SetWorkDays(TUint aMask);
+ inline TDay StartOfWeek() const;
+ inline void SetStartOfWeek(TDay aDay);
+ inline TClockFormat ClockFormat() const;
+ inline void SetClockFormat(TClockFormat aFormat);
+ inline TUnitsFormat UnitsGeneral() const;
+ inline void SetUnitsGeneral(TUnitsFormat aFormat);
+ inline TUnitsFormat UnitsDistanceShort() const;
+ inline void SetUnitsDistanceShort(TUnitsFormat aFormat);
+ inline TUnitsFormat UnitsDistanceLong() const;
+ inline void SetUnitsDistanceLong(TUnitsFormat aFormat);
+ inline TNegativeCurrencyFormat NegativeCurrencyFormat() const;
+ inline void SetNegativeCurrencyFormat(TNegativeCurrencyFormat aNegativeCurrencyFormat);
+ inline TBool NegativeLoseSpace() const;
+ inline void SetNegativeLoseSpace(TBool aBool);
+ inline TBool NegativeCurrencySymbolOpposite() const;
+ inline void SetNegativeCurrencySymbolOpposite(TBool aBool);
+ inline TLanguage LanguageDowngrade(TInt aIndex) const; // 0 <= aIndex < 3
+ inline void SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage);
+ inline TDigitType DigitType() const;
+ inline void SetDigitType(TDigitType aDigitType);
+ inline TDeviceTimeState DeviceTime() const;
+ inline void SetDeviceTime(TDeviceTimeState aState);
+ inline TInt RegionCode() const;
+
+ void SetDefaults(); /**< @internalComponent */
+
+private:
+ friend class TExtendedLocale;
+private:
+ TInt iCountryCode;
+ TTimeIntervalSeconds iUniversalTimeOffset;
+ TDateFormat iDateFormat;
+ TTimeFormat iTimeFormat;
+ TLocalePos iCurrencySymbolPosition;
+ TBool iCurrencySpaceBetween;
+ TInt iCurrencyDecimalPlaces;
+ TNegativeCurrencyFormat iNegativeCurrencyFormat; // replaced TBool iCurrencyNegativeInBrackets
+ TBool iCurrencyTriadsAllowed;
+ TChar iThousandsSeparator;
+ TChar iDecimalSeparator;
+ TChar iDateSeparator[KMaxDateSeparators];
+ TChar iTimeSeparator[KMaxTimeSeparators];
+ TLocalePos iAmPmSymbolPosition;
+ TBool iAmPmSpaceBetween;
+ TUint iDaylightSaving;
+ TDaylightSavingZone iHomeDaylightSavingZone;
+ TUint iWorkDays;
+ TDay iStartOfWeek;
+ TClockFormat iClockFormat;
+ TUnitsFormat iUnitsGeneral;
+ TUnitsFormat iUnitsDistanceShort;
+ TUnitsFormat iUnitsDistanceLong;
+ TUint iExtraNegativeCurrencyFormatFlags;
+ TUint16 iLanguageDowngrade[3];
+ TUint16 iRegionCode;
+ TDigitType iDigitType;
+ TDeviceTimeState iDeviceTimeState;
+ TInt iSpare[0x1E];
+ };
+
+/**
+@publishedAll
+@released
+
+TLocaleAspect
+
+Enumeration used with TExtendedLocale::LoadLocaleAspect to select which
+locale information is to be replaced from the contents of the Locale
+DLL being loaded.
+
+ELocaleLanguageSettings - Replaces everything that should change with
+ language selection e.g. Month names, Day names,
+ etc,
+
+ELocaleLocaleSettings - Replaces the currently selected currency symbol,
+ TLocale settings, and FAT utility functions
+
+ELocaleTimeAndDateSettings - Replaces the current time and date display
+ format settings.
+
+ELocaleCollateSettings - Replaces the "system" preferred Charset
+ (because that's where the collation table
+ is!). The "Default" charset will remain
+ unchanged until after the next power
+ off/on cycle
+*/
+enum TLocaleAspect
+ {
+ ELocaleLanguageSettings = 0x01,
+ ELocaleCollateSetting = 0x02,
+ ELocaleLocaleSettings = 0x04,
+ ELocaleTimeDateSettings = 0x08,
+ };
+
+/**
+@internalComponent
+*/
+struct SLocaleLanguage
+ {
+ TLanguage iLanguage;
+ const TText* iDateSuffixTable;
+ const TText* iDayTable;
+ const TText* iDayAbbTable;
+ const TText* iMonthTable;
+ const TText* iMonthAbbTable;
+ const TText* iAmPmTable;
+ const TText16* const* iMsgTable;
+ };
+
+/**
+@internalComponent
+*/
+struct SLocaleLocaleSettings
+ {
+ TText iCurrencySymbol[KMaxCurrencySymbol+1];
+ TAny* iLocaleExtraSettingsDllPtr;
+ };
+
+/**
+@internalComponent
+*/
+struct SLocaleTimeDateFormat
+ {
+ TText iShortDateFormatSpec[KMaxShortDateFormatSpec+1];
+ TText iLongDateFormatSpec[KMaxLongDateFormatSpec+1];
+ TText iTimeFormatSpec[KMaxTimeFormatSpec+1];
+ TAny* iLocaleTimeDateFormatDllPtr;
+ };
+
+struct LCharSet;
+
+/**
+@publishedAll
+@released
+
+Extended locale class
+
+This class holds a collection of locale information. It contains a TLocale internally.
+It has methods to load a locale DLL and to set the system wide locale information.
+
+*/
+class TExtendedLocale
+ {
+public:
+
+ // Default constructor, create an empty instance
+ IMPORT_C TExtendedLocale();
+
+ // Initialise to (or restore from!) current system wide locale
+ // settings
+ IMPORT_C void LoadSystemSettings();
+
+ // Overwrite current system wide locale settings with the current
+ // contents of this TExtendedLocale
+ IMPORT_C TInt SaveSystemSettings();
+
+ //load a complete locale data from a single locale dll
+ IMPORT_C TInt LoadLocale(const TDesC& aLocaleDllName);
+
+ //load a complete locale data from three locale dlls, which are language lcoale dll, region locale dll, and collation locale dll.
+ IMPORT_C TInt LoadLocale(const TDesC& aLanguageLocaleDllName, const TDesC& aRegionLocaleDllName, const TDesC& aCollationLocaleDllName);
+
+ // Load an additional Locale DLL and over-ride a selected subset
+ // (currently ELocaleLanguageSettings to select an alternative set
+ // of language specific text strings, ELocaleCollateSetting to
+ // select a new system collation table,
+ // ELocaleOverRideMatchCollationTable to locally select an
+ // alternative collation order for matching text strings, or
+ // ELocaleOverRideSortCollationTable for ordering text strings)
+ // of settings with its contents
+ IMPORT_C TInt LoadLocaleAspect(TUint aAspectGroup, const TDesC& aLocaleDllName);
+
+ //load a locale aspect from a locale dll.
+ //Such as load language locale aspect from locale language dll;
+ //load region locale aspect from locale region dll;
+ //load collation locale aspect from locale collation dll.
+ //There are in all three aspect, which are langauge, region, and collation.
+ IMPORT_C TInt LoadLocaleAspect(const TDesC& aLocaleDllName);
+
+ // Set the currency Symbol
+ IMPORT_C TInt SetCurrencySymbol(const TDesC &aSymbol);
+
+ // Get the name of the DLL holding the data for a particular set
+ // of Locale properties
+ IMPORT_C TInt GetLocaleDllName(TLocaleAspect aLocaleDataSet, TDes& aDllName);
+
+ // Get the preferred collation method.
+ // Note that some Charsets may contain more than one Collation
+ // method (e.g "dictionary" v "phonebook" ordering) so an optional
+ // index parameter can be used to select between them
+ IMPORT_C TCollationMethod GetPreferredCollationMethod(TInt index = 0) ;
+
+ //Get the Currency Symbol
+ IMPORT_C TPtrC GetCurrencySymbol();
+
+ //Get the Long Date Format
+ IMPORT_C TPtrC GetLongDateFormatSpec();
+
+ //Get the Short Date Format
+ IMPORT_C TPtrC GetShortDateFormatSpec();
+
+ //Get the Time Format
+ IMPORT_C TPtrC GetTimeFormatSpec();
+
+ // Retrieve a reference to the encapsulated TLocale
+ inline TLocale* GetLocale();
+
+private:
+
+ TInt DoLoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList);
+ void DoUpdateLanguageSettings(TLibraryFunction* aExportList);
+ void DoUpdateLocaleSettings(TLibraryFunction* aExportList);
+ void DoUpdateTimeDateFormat(TLibraryFunction* aExportList);
+
+#ifdef SYMBIAN_DISTINCT_LOCALE_MODEL
+ void DoUpdateLanguageSettingsV2(TLibraryFunction* aExportList);
+ void DoUpdateLocaleSettingsV2(TLibraryFunction* aExportList);
+ TInt CheckLocaleDllName(const TDesC& aLocaleDllName, TInt& languageID);
+ void AddExtension(TDes& aFileName, TInt aExtension);
+#endif
+
+private:
+
+ TLocale iLocale;
+ SLocaleLanguage iLanguageSettings;
+ SLocaleLocaleSettings iLocaleExtraSettings;
+ SLocaleTimeDateFormat iLocaleTimeDateFormat;
+ const LCharSet* iDefaultCharSet;
+ const LCharSet* iPreferredCharSet;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Geometric rectangle.
+
+The class represents a rectangle whose sides are parallel with the axes of
+the co-ordinate system.
+
+The co-ordinates of the top-left and bottom-right corners are used to set
+the dimensions of the rectangle. The bottom right co-ordinate is outside the
+rectangle. Thus TRect(TPoint(2,2),TSize(4,4)) is equal
+to TRect(TPoint(2,2),TPoint(6,6)),
+and in both cases you get a 4x4 pixel rectangle on the screen.
+
+Functions are provided to initialise and manipulate the rectangle and to extract
+information about it.
+*/
+class TRect
+ {
+public:
+ enum TUninitialized { EUninitialized };
+ /**
+ Constructs a default rectangle.
+
+ This initialises the co-ordinates of its top
+ left and bottom right corners to (0,0).
+ */
+ TRect(TUninitialized) {}
+ IMPORT_C TRect();
+ IMPORT_C TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
+ IMPORT_C TRect(const TPoint& aPointA,const TPoint& aPointB);
+ IMPORT_C TRect(const TPoint& aPoint,const TSize& aSize);
+ IMPORT_C TRect(const TSize& aSize);
+ IMPORT_C TBool operator==(const TRect& aRect) const;
+ IMPORT_C TBool operator!=(const TRect& aRect) const;
+ IMPORT_C void SetRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
+ IMPORT_C void SetRect(const TPoint& aPointTL,const TPoint& aPointBR);
+ IMPORT_C void SetRect(const TPoint& aPoint,const TSize& aSize);
+ IMPORT_C void Move(TInt aDx,TInt aDy);
+ IMPORT_C void Move(const TPoint& aOffset);
+ IMPORT_C void Resize(TInt aDx,TInt aDy);
+ IMPORT_C void Resize(const TSize& aSize);
+ IMPORT_C void Shrink(TInt aDx,TInt aDy);
+ IMPORT_C void Shrink(const TSize& aSize);
+ IMPORT_C void Grow(TInt aDx,TInt aDy);
+ IMPORT_C void Grow(const TSize& aSize);
+ IMPORT_C void BoundingRect(const TRect& aRect);
+ IMPORT_C TBool IsEmpty() const;
+ IMPORT_C TBool Intersects(const TRect& aRect) const;
+ IMPORT_C void Intersection(const TRect& aRect);
+ IMPORT_C void Normalize();
+ IMPORT_C TBool Contains(const TPoint& aPoint) const;
+ IMPORT_C TSize Size() const;
+ IMPORT_C TInt Width() const;
+ IMPORT_C TInt Height() const;
+ IMPORT_C TBool IsNormalized() const;
+ IMPORT_C TPoint Center() const;
+ IMPORT_C void SetSize(const TSize& aSize);
+ IMPORT_C void SetWidth(TInt aWidth);
+ IMPORT_C void SetHeight(TInt aHeight);
+private:
+ void Adjust(TInt aDx,TInt aDy);
+public:
+ /**
+ The x and y co-ordinates of the top left hand corner of the rectangle.
+ */
+ TPoint iTl;
+
+ /**
+ The x and y co-ordinates of the bottom right hand corner of the rectangle.
+ */
+ TPoint iBr;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Clipping region - abstract base class.
+
+This abstract base class represents a 2-dimensional area which is used by
+Graphics, the graphics window server, and the text window server to define
+regions of the display which need to be updated, or regions within which all
+operations must occur.
+
+A TRegion is defined in terms of an array of TRects and the more complex the
+region, the more TRects are required to represent it.
+
+A clipping region initially has space allocated for five rectangles.
+If manipulations result in a region which requires more than this, an attempt
+is made to allocate more rectangles. If this cannot be done, an error flag
+is set, and all subsequent operations involving the region have no effect
+(except possibly to propagate the error flag to other regions).
+The CheckError() member function allows
+the error flag to be tested; Clear() can be used to clear it.
+
+The redraw logic of application programs may use the TRegion in various ways:
+
+1. minimally, they pass it to the graphics context as the clipping region; when
+ a graphics context is activated to a window, the clipping region is set up
+ automatically
+
+2. if they wish to avoid redrawing objects which are outside the general area
+ of the region, they may use TRegion::BoundingRect() to return the rectangle
+ which bounds the clipping region, and draw only primitives that lie within
+ that rectangle
+
+3. if they wish to exercise finer control, they may extract the individual rectangles
+ that comprise the clipping region using Operator[]().
+
+Application programs may also manipulate clipping regions in order to constrain
+parts of their redrawing to narrower areas of the screen than the clipping
+region offered by the window server. To do this, functions that allow clipping
+region manipulation may be used; for example, adding or removing rectangles
+or finding the intersection or union of two regions.
+*/
+class TRegion
+ {
+public:
+ inline TInt Count() const;
+ inline const TRect* RectangleList() const;
+ inline TBool CheckError() const;
+ IMPORT_C TBool IsEmpty() const;
+ IMPORT_C TRect BoundingRect() const;
+ IMPORT_C const TRect& operator[](TInt aIndex) const;
+ IMPORT_C void Copy(const TRegion& aRegion);
+ IMPORT_C void AddRect(const TRect& aRect);
+ IMPORT_C void SubRect(const TRect& aRect,TRegion* aSubtractedRegion=NULL);
+ IMPORT_C void Offset(TInt aXoffset,TInt aYoffset);
+ IMPORT_C void Offset(const TPoint& aOffset);
+ IMPORT_C void Union(const TRegion& aRegion);
+ IMPORT_C void Intersection(const TRegion& aRegion,const TRegion& aRegion2);
+ IMPORT_C void Intersect(const TRegion& aRegion);
+ IMPORT_C void SubRegion(const TRegion& aRegion,TRegion* aSubtractedRegion=NULL);
+ IMPORT_C void ClipRect(const TRect& aRect);
+ IMPORT_C void Clear();
+ IMPORT_C void Tidy();
+ IMPORT_C TInt Sort();
+ IMPORT_C TInt Sort(const TPoint& aOffset);
+ IMPORT_C void ForceError();
+ IMPORT_C TBool IsContainedBy(const TRect& aRect) const;
+ IMPORT_C TBool Contains(const TPoint& aPoint) const;
+ IMPORT_C TBool Intersects(const TRect& aRect) const;
+protected:
+ IMPORT_C TRect* RectangleListW();
+ IMPORT_C TRegion(TInt aAllocedRects);
+ inline TRegion();
+ TBool SetListSize(TInt aCount);
+ void AppendRect(const TRect& aRect);
+ void DeleteRect(TRect* aRect);
+ void AppendRegion(TRegion& aRegion);
+ void MergeRect(const TRect& aRect, TBool aEnclosed);
+ void SubtractRegion(const TRegion &aRegion,TRegion *aSubtractedRegion=NULL);
+ void ShrinkRegion();
+ TRect* ExpandRegion(TInt aCount);
+protected:
+ TInt iCount;
+ TBool iError;
+ TInt iAllocedRects;
+protected:
+ enum {ERRegionBuf=0x40000000};
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Expandable region.
+
+This class provides for the construction and destruction of a TRegion, including
+a granularity for expanding the region. A region;s granularity represents
+the number of memory slots allocated when the object is created, and the number
+of new memory slots allocated each time an RRegion is expanded beyond the
+number of free slots. The default granularity is five.
+*/
+class RRegion : public TRegion
+ {
+private:
+ enum {EDefaultGranularity=5};
+protected:
+ IMPORT_C RRegion(TInt aBuf,TInt aGran);
+public:
+ IMPORT_C RRegion();
+ IMPORT_C RRegion(TInt aGran);
+ IMPORT_C RRegion(const RRegion& aRegion);
+ IMPORT_C RRegion(const TRect& aRect,TInt aGran=EDefaultGranularity);
+ IMPORT_C RRegion(TInt aCount,TRect* aRectangleList,TInt aGran=EDefaultGranularity);
+ IMPORT_C void Close();
+ IMPORT_C void Destroy();
+ inline TInt CheckSpare() const;
+private:
+ TInt iGranularity;
+ TRect* iRectangleList;
+ friend class TRegion;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Region with pre-allocated buffer.
+
+This class provides the functionality of an RRegion, but in addition, for
+optimisation purposes, uses a buffer containing pre-allocated space for as
+many rectangles as are specified in the granularity.
+
+When this buffer is full, cell allocation takes place as for an RRegion, and
+the RRegionBuf effectively becomes an RRegion. In this case, the region does
+not revert to using the buffer, even if the region were to shrink so that
+the buffer could, once again, contain the region. When the region is no longer
+required, call Close(), defined in the base class RRegion, to free up all
+memory.
+*/
+template <TInt S>
+class RRegionBuf : public RRegion
+ {
+public:
+ inline RRegionBuf();
+ inline RRegionBuf(const RRegion& aRegion);
+ inline RRegionBuf(const RRegionBuf<S>& aRegion);
+ inline RRegionBuf(const TRect& aRect);
+private:
+ TInt8 iRectangleBuf[S*sizeof(TRect)];
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A fixed size region.
+
+The region consists of a fixed number of rectangles; this number is specified
+in the templated argument. The region cannot be expanded to contain more than
+this number of rectangles. If an attempt is made to do so, the region's
+error flag is set, and the region is cleared.
+
+Note that when adding a rectangle to a region, if that rectangle overlaps
+an existing rectangle, the operation causes more than one rectangle to be
+created.
+*/
+template <TInt S>
+class TRegionFix : public TRegion
+ {
+public:
+ inline TRegionFix();
+ inline TRegionFix(const TRect& aRect);
+ inline TRegionFix(const TRegionFix<S>& aRegion);
+private:
+ TInt8 iRectangleBuf[S*sizeof(TRect)];
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Base class for searching for global kernel objects.
+
+This is the base class for a number of classes which are used to find specific
+types of global kernel object such as semaphores, threads and mutexes;
+TFindSemaphore, TFindThread and TFindMutex are typical examples of such
+derived classes.
+
+The class implements the common behaviour, specifically, the storage of the
+match pattern which is used to search for object names.
+
+This class is not intended to be explicitly instantiated; it has public
+constructors but they are part of the class implementation and are described
+for information only.
+*/
+class TFindHandleBase : public TFindHandle
+ {
+public:
+ IMPORT_C TFindHandleBase();
+ IMPORT_C TFindHandleBase(const TDesC& aMatch);
+ IMPORT_C void Find(const TDesC& aMatch);
+protected:
+ TInt NextObject(TFullName& aResult,TInt aObjectType);
+private:
+
+ /**
+ The full name of the last kernel side object found.
+ */
+ TFullName iMatch;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Finds all global semaphores whose full names match a specified pattern.
+
+The match pattern can be set into the TFindSemaphore object at construction;
+it can also be changed at any time after construction by using the Find()
+member function of the TFindHandleBase base class.
+
+After construction, the Next() member function can be used repeatedly to find
+successive global semaphores whose full names match the current pattern.
+
+A successful call to Next() means that a matching global semaphore has been
+found. To open a handle on this semaphore, call the RSemaphore::Open() function
+and pass a reference to this TFindSemaphore.
+
+Pattern matching is part of descriptor behaviour.
+
+@see TFindHandleBase::Find
+@see TFindSemaphore::Next
+@see RSemaphore::Open
+@see TDesC16::Match
+@see TDesC8::Match
+*/
+class TFindSemaphore : public TFindHandleBase
+ {
+public:
+ inline TFindSemaphore();
+ inline TFindSemaphore(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Finds all global mutexes whose full names match a specified pattern.
+
+The match pattern can be set into the object at construction; it can also
+be changed at any time after construction by using the Find() member function
+of the base class.
+
+After construction, the Next() member function may be used repeatedly to find
+successive global mutexes whose full names match the current pattern.
+
+A successful call to Next() means that a matching global mutex has been found.
+To open a handle on this mutex, call the Open() member function of RMutex
+and pass a reference to this TFindMutex object.
+
+Pattern matching is part of descriptors behaviour.
+
+@see TFindHandleBase::Find
+@see TFindMutex::Next
+@see RMutex::Open
+@see TDesC16::Match
+@see TDesC8::Match
+*/
+class TFindMutex : public TFindHandleBase
+ {
+public:
+ inline TFindMutex();
+ inline TFindMutex(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Searches for all global chunks by pattern matching against the names of (Kernel
+side) chunk objects.
+
+The match pattern can be set into this object at construction; it can also
+be changed at any time after construction by using TFindHandleBase::Find().
+
+After construction, call TFindChunk::Next() repeatedly to find successive
+chunks whose names match the current pattern. A successful call
+to TFindChunk::Next() means that a matching chunk has been found.
+
+@see TFindHandleBase
+*/
+class TFindChunk : public TFindHandleBase
+ {
+public:
+ inline TFindChunk();
+ inline TFindChunk(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+
+
+/**
+@publishedAll
+@released
+
+Searches for threads by pattern matching against the names
+of thread objects.
+
+The match pattern can be set into this object at construction; it can also be
+changed at any time after construction by using TFindHandleBase::Find().
+
+After construction, call TFindThread::Next() repeatedly to find successive
+threads whose names match the current pattern.
+A successful call to TFindThread::Next() means that a matching thread has
+been found. To open a handle on this thread, call RThread::Open() and pass
+a reference to this TFindThread.
+
+@see RThread
+*/
+class TFindThread : public TFindHandleBase
+ {
+public:
+ inline TFindThread();
+ inline TFindThread(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Searches for processes by pattern matching against the names
+of process objects.
+
+The match pattern can be set into this object at construction; it can also be
+changed at any time after construction by using TFindHandleBase::Find().
+
+After construction, call TFindProcess::Next() repeatedly to find successive
+processes whose names match the current pattern.
+A successful call to TFindProcess::Next() means that a matching process has
+been found. To open a handle on this process, call RProcess::Open() and pass
+a reference to this TFindProcess.
+
+@see RProcess
+*/
+class TFindProcess : public TFindHandleBase
+ {
+public:
+ inline TFindProcess();
+ inline TFindProcess(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+Searches for LDD factory objects by pattern matching against the names of
+ LDD factory objects.
+
+An LDD factory object is an instance of a DLogicalDevice derived class.
+
+The match pattern can be set into this object at construction; it can also
+be changed at any time after construction by using TFindHandleBase::Find().
+
+After construction, call TFindLogicalDevice::Next() repeatedly to find successive
+LDD factory objects whose names match the current pattern. A successful call to
+TFindLogicalDevice::Next() means that a matching LDD factory object has been found.
+
+The name of an LDD factory object is set by its Install() member function as
+part of the construction process.
+*/
+class TFindLogicalDevice : public TFindHandleBase
+ {
+public:
+ inline TFindLogicalDevice();
+ inline TFindLogicalDevice(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+/**
+@publishedAll
+@released
+
+Searches for PDD factory objects by pattern matching against the names of
+PDD factory objects.
+
+A PDD factory object is an instance of a DPhysicalDevice derived class.
+
+The match pattern can be set into this object at construction; it can also be
+changed at any time after construction by using TFindHandleBase::Find().
+
+After construction, call TFindPhysicalDevice::Next() repeatedly to find successive
+PDD factory objects whose names match the current pattern. A successful call to
+TFindPhysicalDevice::Next() means that a matching PDD factory object has been found.
+
+The name of a PDD factory object is set by its Install() member function as part
+of the construction process.
+*/
+class TFindPhysicalDevice : public TFindHandleBase
+ {
+public:
+ inline TFindPhysicalDevice();
+ inline TFindPhysicalDevice(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+
+
+/**
+@publishedAll
+@released
+
+Searches for servers by pattern matching against the names of kernel side
+server objects.
+
+The match pattern can be set into this object at construction; it can also
+be changed at any time after construction by using the TFindHandleBase::Find()
+base class.
+
+After construction, call TFindServer::Next() repeatedly to find successive
+servers whose names match the current pattern.
+A successful call to TFindServer::Next() means that a matching server
+has been found.
+*/
+class TFindServer : public TFindHandleBase
+ {
+public:
+ inline TFindServer();
+ inline TFindServer(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Searches for DLLs whose full names match a specified pattern.
+
+The match pattern is set at construction but can also be changed at any time
+after construction by using TFindHandleBase::Find().
+
+After construction, use TFindLibrary::Next() to repeatedly find successive DLLs
+whose names match the current pattern. A successful call to
+TFindLibrary::Next() means that a matching DLL has been found.
+*/
+class TFindLibrary : public TFindHandleBase
+ {
+public:
+ inline TFindLibrary();
+ inline TFindLibrary(const TDesC& aMatch);
+ IMPORT_C TInt Next(TFullName& aResult);
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+User side handle to an LDD factory object, an instance of a DLogicalDevice
+derived class.
+
+The LDD factory object is a Kernel side object which is constructed on the
+Kernel heap when the logical device is opened using User::LoadLogicalDevice().
+The handle allows the User side to get information about the logical device.
+
+To use the device, a thread must create and use an instance of an
+RBusLogicalChannel derived class.
+
+*/
+class RDevice : public RHandleBase
+ {
+public:
+ inline TInt Open(const TFindLogicalDevice& aFind,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
+ IMPORT_C void GetCaps(TDes8& aDes) const;
+ IMPORT_C TBool QueryVersionSupported(const TVersion& aVer) const;
+ IMPORT_C TBool IsAvailable(TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* anInfo) const;
+ };
+
+/**
+@publishedAll
+@released
+
+Asynchronous timer services.
+
+Five types of asynchronous request are supported by the class:
+
+1. Requesting an event after a specified interval
+
+2. Requesting an event at a specified system time
+
+3. Requesting a timer event on a specific second fraction
+
+4. Requesting an event if an interval elapses with no user activity.
+
+5. Requesting an event after a specified interval, to a resolution of 1ms.
+
+Each of these requests can be cancelled.
+
+The timer exists from its creation, following a call to RTimer::CreateLocal(),
+until it is destroyed by a call to the Close() member function of the base
+class RHandleBase.
+
+This class is ultimately implemented in terms of the nanokernel tick, and
+therefore the granularity of the generated events is limited to the period of
+this timer. This is variant specific, but is usually 1 millisecond.
+
+Note that the CTimer active object uses an RTimer.
+*/
+class RTimer : public RHandleBase
+ {
+public:
+ IMPORT_C TInt CreateLocal();
+ IMPORT_C void Cancel();
+ IMPORT_C void After(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
+ IMPORT_C void AfterTicks(TRequestStatus &aStatus, TInt aTicks);
+ IMPORT_C void At(TRequestStatus& aStatus,const TTime& aTime);
+ IMPORT_C void AtUTC(TRequestStatus& aStatus,const TTime& aUTCTime);
+ IMPORT_C void Lock(TRequestStatus& aStatus,TTimerLockSpec aLock);
+ IMPORT_C void Inactivity(TRequestStatus& aStatus, TTimeIntervalSeconds aSeconds);
+ IMPORT_C void HighRes(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to a dynamically loadable DLL.
+
+The class is not intended for user derivation.
+*/
+class RLibrary : public RHandleBase
+ {
+public:
+ IMPORT_C void Close();
+ IMPORT_C TInt Load(const TDesC& aFileName, const TUidType& aType);
+ IMPORT_C TInt Load(const TDesC& aFileName, const TDesC& aPath=KNullDesC);
+ IMPORT_C TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType);
+ IMPORT_C TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType, TUint32 aModuleVersion);
+ IMPORT_C TInt LoadRomLibrary(const TDesC& aFileName, const TDesC& aPath);
+ IMPORT_C TLibraryFunction Lookup(TInt anOrdinal) const;
+ IMPORT_C TUidType Type() const;
+ IMPORT_C TFileName FileName() const;
+ IMPORT_C TInt GetRamSizes(TInt& aCodeSize, TInt& aConstDataSize);
+ IMPORT_C TInt Init(); /**< @internalTechnology */
+public:
+ /**
+ Class representing information about an executable binary, (DLL or EXE).
+ @internalTechnology
+ */
+ struct TInfo
+ {
+ TUint32 iModuleVersion; /**< Version number */
+ TUidType iUids; /**< UIDs */
+ TSecurityInfo iSecurityInfo; /**< Security Info */
+ };
+
+ /**
+ Class representing information about an executable binary, (DLL or EXE), version 2.
+ @internalTechnology
+ */
+ struct TInfoV2 : public TInfo
+ {
+ TUint8 iHardwareFloatingPoint; /**< Which hardware floating point used, from TFloatingPointType */
+ enum TDebugAttributes
+ {
+ EDebugAllowed = 1<<0, ///< Flags set if executable may be debugged.
+ ETraceAllowed = 1<<1 ///< Flags set if executable may be traced.
+ };
+ TUint8 iDebugAttributes; ///< Bitmask of values from enum TDebugAttributes
+ TUint8 iSpare[6];
+ };
+
+ /**
+ Type representing a TInfo struct packaged as a descriptor.
+ @internalTechnology
+ */
+ typedef TPckgBuf<TInfo> TInfoBuf;
+
+ /**
+ Type representing a TInfo struct packaged as a descriptor, version 2.
+ @internalTechnology
+ */
+ typedef TPckgBuf<TInfoV2> TInfoBufV2;
+
+ /**
+ @internalTechnology
+ */
+ enum TRequiredImageHeaderSize
+ {
+#ifdef __WINS__
+ /**
+ Size of header data which should be passed to GetInfoFromHeader()
+ */
+ KRequiredImageHeaderSize = KMaxTInt
+#else
+ KRequiredImageHeaderSize = 9*1024
+#endif
+ };
+
+ IMPORT_C static TInt GetInfoFromHeader(const TDesC8& aHeader, TDes8& aInfoBuf);
+
+ /**
+ @internalTechnology
+ @deprecated Use TInfo
+ */
+ struct SInfo
+ {
+ TUint32 iModuleVersion;
+ TUidType iUids;
+ SSecurityInfo iS;
+ };
+
+ /**
+ @internalTechnology
+ @deprecated Use TInfoBuf
+ */
+ typedef TPckgBuf<SInfo> SInfoBuf;
+
+ /**
+ @internalTechnology
+ */
+ IMPORT_C static TInt GetInfo(const TDesC& aFileName, TDes8& aInfoBuf);
+private:
+ TInt InitL();
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to a critical section.
+
+A critical section itself is a kernel object, and is implemented using
+a semaphore. The class RCriticalSection inherits privately from RSemaphore
+as a matter of implementation and this is, in effect, equivalent to using
+a semaphore.
+
+The public functions of RSemaphore are not part of the public API of this
+class.
+
+As with all handles, they should be closed after use. This class provides
+the necessary Close() function, which should be called when the handle is
+no longer required.
+
+@see RHandleBase::Close
+*/
+class RCriticalSection : private RSemaphore
+ {
+public:
+ IMPORT_C RCriticalSection();
+ IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
+ IMPORT_C void Close();
+ IMPORT_C void Wait();
+ IMPORT_C void Signal();
+ inline TBool IsBlocked() const;
+private:
+ TInt iBlocked;
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to a mutex.
+
+The mutex itself is a kernel side object.
+
+Handles should be closed after use. RHandleBase provides the necessary Close()
+function which should be called when the handle is no longer required.
+
+@see RHandleBase::Close
+*/
+class RMutex : public RHandleBase
+ {
+public:
+ inline TInt Open(const TFindMutex& aFind,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt OpenGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
+ IMPORT_C void Wait();
+ IMPORT_C void Signal();
+ IMPORT_C TBool IsHeld();
+ };
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to a condition variable.
+
+The condition variable itself is a kernel side object.
+
+Handles should be closed after use. RHandleBase provides the necessary Close()
+function which should be called when the handle is no longer required.
+
+@see RHandleBase::Close
+*/
+class RCondVar : public RHandleBase
+ {
+public:
+ IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt OpenGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(RMessagePtr2 aMessage, TInt aParam, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Wait(RMutex& aMutex);
+ IMPORT_C TInt TimedWait(RMutex& aMutex, TInt aTimeout); // timeout in microseconds
+ IMPORT_C void Signal();
+ IMPORT_C void Broadcast();
+ };
+
+
+
+class UserHeap;
+class TChunkCreate;
+struct TChunkCreateInfo;
+/**
+@publishedAll
+@released
+
+A handle to a chunk.
+
+The chunk itself is a kernel side object.
+*/
+class RChunk : public RHandleBase
+ {
+public:
+ /**
+ Set of flags used by SetRestrictions().
+
+ @see RChunk::SetRestrictions
+ */
+ enum TRestrictions
+ {
+ EPreventAdjust = 0x01, // Prevent Adjust, Commit, Allocate and Decommit
+ };
+public:
+ inline TInt Open(const TFindChunk& aFind,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateLocal(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateLocalCode(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateGlobal(const TDesC& aName,TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateDoubleEndedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateDoubleEndedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateDisconnectedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt CreateDisconnectedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Create(TChunkCreateInfo& aCreateInfo);
+ IMPORT_C TInt SetRestrictions(TUint aFlags);
+ IMPORT_C TInt OpenGlobal(const TDesC& aName,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Adjust(TInt aNewSize) const;
+ IMPORT_C TInt AdjustDoubleEnded(TInt aBottom, TInt aTop) const;
+ IMPORT_C TInt Commit(TInt anOffset, TInt aSize) const;
+ IMPORT_C TInt Allocate(TInt aSize) const;
+ IMPORT_C TInt Decommit(TInt anOffset, TInt aSize) const;
+ IMPORT_C TInt Unlock(TInt aOffset, TInt aSize); /**< @internalTechnology */
+ IMPORT_C TInt Lock(TInt aOffset, TInt aSize); /**< @internalTechnology */
+ IMPORT_C TUint8* Base() const;
+ IMPORT_C TInt Size() const;
+ IMPORT_C TInt Bottom() const;
+ IMPORT_C TInt Top() const;
+ IMPORT_C TInt MaxSize() const;
+ inline TBool IsReadable() const;
+ inline TBool IsWritable() const;
+ IMPORT_C TBool IsPaged() const;
+private:
+ friend class UserHeap;
+ };
+
+
+/**
+This structure specifies the type and properties of the chunk to be created. It
+is passed as a parameter to the RChunk::Create() method.
+
+@publishedAll
+@released
+*/
+struct TChunkCreateInfo
+ {
+public :
+ /**
+ Currently supported version numbers
+ @internalComponent
+ */
+ enum TChunkCreateVersions
+ {
+ EVersion0,
+ ESupportedVersions,
+ };
+
+ friend class RChunk;
+
+ /**
+ Attributes that specify whether the chunk to be created is data paged or not.
+ */
+ enum TChunkPagingAtt
+ {
+ EUnspecified, /**< The chunk will use the creating process's paging attributes.*/
+ EPaged, /**< The chunk will be data paged.*/
+ EUnpaged, /**< The chunk will not be data paged.*/
+ };
+
+ IMPORT_C TChunkCreateInfo();
+ IMPORT_C void SetNormal(TInt aInitialSize, TInt aMaxSize);
+ IMPORT_C void SetCode(TInt aInitialSize, TInt aMaxSize);
+ IMPORT_C void SetDoubleEnded(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize);
+ IMPORT_C void SetDisconnected(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize);
+ IMPORT_C void SetOwner(TOwnerType aType);
+ IMPORT_C void SetGlobal(const TDesC& aName);
+ IMPORT_C void SetClearByte(TUint8 aClearByte);
+ IMPORT_C void SetPaging(const TChunkPagingAtt aPaging);
+ void SetThreadHeap(TInt aInitialSize, TInt aMaxSize, const TDesC& aName);
+
+ /**
+ For use by file server only.
+ @internalTechnology
+ */
+ IMPORT_C void SetCache(TInt aMaxSize);
+protected :
+ /** The version number of this TChunkCreateInfo.
+ @internalComponent
+ */
+ TUint iVersionNumber;
+ /** The type of the chunk to be created.
+ @internalComponent
+ */
+ TUint iType;
+ /** Specify if chunk is global or not.
+ @internalComponent
+ */
+ TBool iGlobal;
+ /** The maximum size in bytes of the chunk to be created.
+ @internalComponent
+ */
+ TInt iMaxSize;
+ /** An enumeration whose enumerators define the ownership of this chunk
+ handle. If not explicitly specified, EOwnerProcess is taken as default.
+ @internalComponent
+ */
+ TOwnerType iOwnerType;
+ /** A pointer to a descriptor containing the name to be assigned to
+ global chunks. The length of the descriptor must be no greater than
+ that allowed for a TKName type. Must be NULL for local chunks.
+ @internalComponent
+ */
+ const TDesC* iName;
+ /** The offset of the bottom of the region to commit to the chunk on
+ creation from the base of the chunk's reserved region.
+ This is only used for double ended and disconnected chunks.
+ @internalComponent
+ */
+ TInt iInitialBottom;
+ /** The offset of the top of the region to commit to the chunk on
+ creation from the base of the chunk's reserved region.
+ This is only used for double ended and disconnected chunks.
+ @internalComponent
+ */
+ TInt iInitialTop;
+ /** Attributes to the chunk to be created should have.
+ Should be set from one or more the values in TChunkCreate::TChunkCreateAtt.
+ @internalComponent
+ */
+ TUint iAttributes;
+ /** The byte to clear all the memory committed to the chunk to.
+ @internalComponent
+ */
+ TUint8 iClearByte;
+ /** @internalComponent*/
+ TUint8 iSpare1[3];
+ /** @internalComponent*/
+ TUint iSpare2;
+ };
+
+/**
+This structure specifies the type and properties of the user heap to be created. It
+is passed as a parameter to the UserHeap::Create() method.
+
+@publishedAll
+@released
+*/
+struct TChunkHeapCreateInfo
+ {
+public:
+ /**
+ Currently supported version numbers
+ @internalComponent
+ */
+ enum TChunkHeapCreateVersions
+ {
+ EVersion0,
+ ESupportedVersions,
+ };
+
+ /**
+ Attributes that specify whether the chunk heap to be created is data paged or not.
+ */
+ enum TChunkHeapPagingAtt
+ {
+ EUnspecified, /**< The chunk heap will use the creating process's paging attributes.*/
+ EPaged, /**< The chunk heap will be data paged.*/
+ EUnpaged, /**< The chunk heap will not be data paged.*/
+ };
+
+ friend class UserHeap;
+
+ IMPORT_C TChunkHeapCreateInfo(TInt aMinLength, TInt aMaxLength);
+ IMPORT_C void SetCreateChunk(const TDesC* aName);
+ IMPORT_C void SetUseChunk(const RChunk aChunk);
+ inline void SetSingleThread(TBool aSingleThread);
+ inline void SetAlignment(TInt aAlign);
+ inline void SetGrowBy(TInt aGrowBy);
+ inline void SetOffset(TInt aOffset);
+ inline void SetMode(TUint aMode);
+ inline void SetPaging(const TChunkHeapPagingAtt aPaging);
+
+protected:
+ /** The version number of this TChunkHeapCreateInfo.
+ @internalComponent
+ */
+ TUint iVersionNumber;
+ /** The minimum size for the heap.
+ @internalConponent
+ */
+ TInt iMinLength;
+ /** The maximum size for the heap.
+ @internalConponent
+ */
+ TInt iMaxLength;
+ /** The alignment of the heap.
+ @internalComponent
+ */
+ TInt iAlign;
+ /** The grow by value of the heap.
+ @internalComponent
+ */
+ TInt iGrowBy;
+ /** The single thread value of the heap.
+ @internalComponent
+ */
+ TBool iSingleThread;
+ /** The offset from the base of the chunk to the start of the heap.
+ @internalComponent
+ */
+ TInt iOffset;
+ /** The paging attributes of the chunk.
+ @internalComponent
+ */
+ TChunkHeapPagingAtt iPaging;
+ /** The mode flags for the heap.
+ @internalComponent
+ */
+ TUint iMode;
+ /** The name of the chunk to be created for the heap.
+ @internalComponent
+ */
+ TDesC* iName;
+ /** The chunk to use for the heap.
+ @internalComponent
+ */
+ RChunk iChunk;
+ /**@internalComponent*/
+ TInt iSpare[5];
+ };
+
+struct SStdEpocThreadCreateInfo;
+/**
+@publishedAll
+@released
+
+A set of static functions for constructing fixed length heaps and local or
+global heaps.
+
+@see RHeap
+@see RChunk
+*/
+class UserHeap
+ {
+public:
+ /**
+ Flags to control the heap creation.
+ */
+ enum TChunkHeapCreateMode
+ {
+ /** On successful creation of the heap this switches the calling thread to
+ use the new heap.
+ */
+ EChunkHeapSwitchTo = 0x1,
+ /** On successful creation of the heap this causes the handle to the heap
+ to be duplicated.
+ */
+ EChunkHeapDuplicate = 0x2,
+
+ /** @internalComponent*/
+ EChunkHeapMask = EChunkHeapSwitchTo | EChunkHeapDuplicate,
+ };
+ IMPORT_C static RHeap* FixedHeap(TAny* aBase, TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);
+ IMPORT_C static RHeap* ChunkHeap(const TDesC* aName, TInt aMinLength, TInt aMaxLength, TInt aGrowBy=1, TInt aAlign=0, TBool aSingleThread=EFalse);
+ IMPORT_C static RHeap* ChunkHeap(RChunk aChunk, TInt aMinLength, TInt aGrowBy=1, TInt aMaxLength=0, TInt aAlign=0, TBool aSingleThread=EFalse, TUint32 aMode=0);
+ IMPORT_C static RHeap* OffsetChunkHeap(RChunk aChunk, TInt aMinLength, TInt aOffset, TInt aGrowBy=1, TInt aMaxLength=0, TInt aAlign=0, TBool aSingleThread=EFalse, TUint32 aMode=0);
+ IMPORT_C static RHeap* ChunkHeap(const TChunkHeapCreateInfo& aCreateInfo);
+ IMPORT_C static TInt SetupThreadHeap(TBool aNotFirst, SStdEpocThreadCreateInfo& aInfo);
+ IMPORT_C static TInt CreateThreadHeap(SStdEpocThreadCreateInfo& aInfo, RHeap*& aHeap, TInt aAlign=0, TBool aSingleThread=EFalse);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Encapsulates the Id of a kernel object.
+*/
+class TObjectId
+ {
+public:
+ inline TObjectId();
+ inline TObjectId(TUint64 anId);
+ inline TUint64 Id() const;
+ inline operator TUint() const;
+ inline TBool operator==(TObjectId aId) const;
+ inline TBool operator!=(TObjectId aId) const;
+private:
+ TUint64 iId;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Encapsulates the Id of a thread.
+
+An object of this type is not explicitly constructed in open code,
+but is returned by the Id() member function of a thread handle,
+an RThread type.
+
+@see RThread
+*/
+class TThreadId : public TObjectId
+ {
+public:
+ inline TThreadId();
+ inline TThreadId(TUint64 anId);
+ };
+
+
+
+
+/**
+This structure specifies the type and properties of the thread to be created. It
+is passed as a parameter to the RThread::Create() method.
+
+@publishedAll
+@released
+*/
+struct TThreadCreateInfo
+ {
+public :
+ /**
+ Currently supported version numbers
+ @internalComponent
+ */
+ enum TThreadCreateVersions
+ {
+ EVersion0,
+ ESupportedVersions,
+ };
+
+ /**
+ Attributes that specify whether the stack and heap of the thread to be created
+ are data paged or not.
+ */
+ enum TThreadPagingAtt
+ {
+ EUnspecified, /**< The thread will use the creating process's paging attributes.*/
+ EPaged, /**< The thread will data page its stack and heap.*/
+ EUnpaged, /**< The thread will not data page its stack and heap.*/
+ };
+
+ friend class RThread;
+
+ IMPORT_C TThreadCreateInfo( const TDesC &aName, TThreadFunction aFunction,
+ TInt aStackSize, TAny* aPtr);
+ IMPORT_C void SetCreateHeap(TInt aHeapMinSize, TInt aHeapMaxSize);
+ IMPORT_C void SetUseHeap(const RAllocator* aHeap);
+ IMPORT_C void SetOwner(const TOwnerType aOwner);
+ IMPORT_C void SetPaging(const TThreadPagingAtt aPaging);
+
+protected:
+ /** The version number of this TChunkCreateInfo.
+ @internalComponent
+ */
+ TUint iVersionNumber;
+ /** The Name to be given to the thread to be created
+ @internalComponent
+ */
+ const TDesC* iName;
+ /** The function this thread will execute.
+ @internalComponent
+ */
+ TThreadFunction iFunction;
+ /** The size of the stack of the thread to be created.
+ @internalComponent
+ */
+ TInt iStackSize;
+ /** The parameter to be passed to the function of the thread to be created.
+ @internalComponent
+ */
+ TAny* iParameter;
+ /** The owner of the thread to be created.
+ @internalComponent
+ */
+ TOwnerType iOwner;
+ /** The heap for the thread to be created to use.
+ NULL if a new heap is to be created.
+ @internalComponent
+ */
+ RAllocator* iHeap;
+ /** Minimum size of any heap to be created for the thread.
+ @internalComponent*/
+ TInt iHeapMinSize;
+ /** Maximum size of any heap to be created for the thread.
+ @internalComponent
+ */
+ TInt iHeapMaxSize;
+ /** The attributes of the thread
+ @internalComponent
+ */
+ TUint iAttributes;
+ /**@internalComponent*/
+ TUint32 iSpare[6];
+ };
+
+class RProcess;
+
+
+/**
+@publishedAll
+@released
+
+A handle to a thread.
+
+The thread itself is a kernel object.
+*/
+class RThread : public RHandleBase
+ {
+public:
+ inline RThread();
+ IMPORT_C TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, TAny *aPtr, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, RAllocator* aHeap, TAny* aPtr, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Create(const TThreadCreateInfo& aCreateInfo);
+ IMPORT_C TInt Open(const TDesC& aFullName, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(TThreadId aID, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TThreadId Id() const;
+ IMPORT_C void Resume() const;
+ IMPORT_C void Suspend() const;
+ /**
+ @publishedAll
+ @deprecated Use User::RenameThread() instead
+ */
+ inline static TInt RenameMe(const TDesC& aName);
+
+ IMPORT_C void Kill(TInt aReason);
+ IMPORT_C void Terminate(TInt aReason);
+ IMPORT_C void Panic(const TDesC& aCategory,TInt aReason);
+ IMPORT_C TInt Process(RProcess& aProcess) const;
+ IMPORT_C TThreadPriority Priority() const;
+ IMPORT_C void SetPriority(TThreadPriority aPriority) const;
+ IMPORT_C TProcessPriority ProcessPriority() const;
+ IMPORT_C void SetProcessPriority(TProcessPriority aPriority) const;
+ IMPORT_C TInt RequestCount() const;
+ IMPORT_C TExitType ExitType() const;
+ IMPORT_C TInt ExitReason() const;
+ IMPORT_C TExitCategoryName ExitCategory() const;
+ IMPORT_C void RequestComplete(TRequestStatus*& aStatus,TInt aReason) const;
+ IMPORT_C void RequestSignal() const;
+ IMPORT_C void Logon(TRequestStatus& aStatus) const;
+ IMPORT_C TInt LogonCancel(TRequestStatus& aStatus) const;
+ IMPORT_C void HandleCount(TInt& aProcessHandleCount, TInt& aThreadHandleCount) const;
+ IMPORT_C void Context(TDes8& aDes) const;
+ IMPORT_C TInt StackInfo(TThreadStackInfo& aInfo) const;
+ IMPORT_C TInt GetCpuTime(TTimeIntervalMicroSeconds& aCpuTime) const;
+ inline TInt Open(const TFindThread& aFind,TOwnerType aType=EOwnerProcess);
+ IMPORT_C void Rendezvous(TRequestStatus& aStatus) const;
+ IMPORT_C TInt RendezvousCancel(TRequestStatus& aStatus) const;
+ IMPORT_C static void Rendezvous(TInt aReason);
+
+ /**
+ Return the Secure ID of the process to which the thread belongs.
+
+ If an intended use of this method is to check that the Secure ID is
+ a given value, then the use of a TSecurityPolicy object should be
+ considered. E.g. Instead of something like:
+
+ @code
+ RThread& thread;
+ TInt error = thread.SecureId()==KRequiredSecureId ? KErrNone : KErrPermissionDenied;
+ @endcode
+
+ this could be used;
+
+ @code
+ RThread& thread;
+ static _LIT_SECURITY_POLICY_S0(mySidPolicy, KRequiredSecureId);
+ TBool pass = mySidPolicy().CheckPolicy(thread);
+ @endcode
+
+ This has the benefit that the TSecurityPolicy::CheckPolicy methods are
+ configured by the system wide Platform Security configuration. I.e. are
+ capable of emitting diagnostic messages when a check fails and/or the
+ check can be forced to always pass.
+
+ @see TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
+ @see _LIT_SECURITY_POLICY_S0
+
+ @return The Secure ID.
+ @publishedAll
+ @released
+ */
+ IMPORT_C TSecureId SecureId() const;
+
+ /**
+ Return the Vendor ID of the process to which the thread belongs.
+
+ If an intended use of this method is to check that the Vendor ID is
+ a given value, then the use of a TSecurityPolicy object should be
+ considered. E.g. Instead of something like:
+
+ @code
+ RThread& thread;
+ TInt error = thread.VendorId()==KRequiredVendorId ? KErrNone : KErrPermissionDenied;
+ @endcode
+
+ this could be used;
+
+ @code
+ RThread& thread;
+ static _LIT_SECURITY_POLICY_V0(myVidPolicy, KRequiredVendorId);
+ TBool pass = myVidPolicy().CheckPolicy(thread);
+ @endcode
+
+ This has the benefit that the TSecurityPolicy::CheckPolicy methods are
+ configured by the system wide Platform Security configuration. I.e. are
+ capable of emitting diagnostic messages when a check fails and/or the
+ check can be forced to always pass.
+
+ @see TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
+ @see _LIT_SECURITY_POLICY_V0
+
+ @return The Vendor ID.
+ @publishedAll
+ @released
+ */
+ IMPORT_C TVendorId VendorId() const;
+
+ /**
+ Check if the process to which the thread belongs 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.
+
+ @param aCapability The capability to test.
+ @param aDiagnostic A 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.
+ @return ETrue if the process to which the thread belongs has the capability, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool HasCapability(TCapability aCapability, const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /**
+ Check if the process to which the thread belongs 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.
+
+ @param aCapability1 The first capability to test.
+ @param aCapability2 The second capability to test.
+ @param aDiagnostic A 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.
+ @return ETrue if the process to which the thread belongs has both the capabilities, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool HasCapability(TCapability aCapability, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /** Function only temporarily supported to aid migration to process emulation...
+
+ @publishedAll
+ @deprecated Use process emulation instead
+ */
+ inline TInt Create(const TDesC& aName,TThreadFunction aFunction,TInt aStackSize,TAny* aPtr,RLibrary* aLibrary,RHeap* aHeap, TInt aHeapMinSize,TInt aHeapMaxSize,TOwnerType aType);
+
+private:
+ // Implementations of functions with diagnostics
+ IMPORT_C TBool DoHasCapability(TCapability aCapability, const char* aDiagnostic) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2) const;
+ };
+
+/**
+@publishedAll
+@deprecated
+*/
+inline TInt RThread::Create(const TDesC& /*aName*/,TThreadFunction /*aFunction*/,TInt /*aStackSize*/,TAny* /*aPtr*/,RLibrary* /*aLibrary*/,RHeap* /*aHeap*/, TInt /*aHeapMinSize*/,TInt /*aHeapMaxSize*/,TOwnerType /*aType*/)
+ {return KErrNotSupported; }
+
+
+
+/**
+@publishedAll
+@released
+
+Encapsulates the Id of a process.
+
+An object of this type is not explicitly constructed in open code,
+but is returned by the Id() member function of a process handle,
+an RProcess type.
+
+@see RProcess
+*/
+class TProcessId : public TObjectId
+ {
+public:
+ inline TProcessId();
+ inline TProcessId(TUint64 anId);
+ };
+
+
+
+
+class RSubSessionBase;
+
+/**
+@publishedAll
+@released
+
+A handle to a process.
+
+The process itself is a kernel object.
+*/
+class RProcess : public RHandleBase
+ {
+public:
+ inline RProcess();
+ IMPORT_C TInt Create(const TDesC& aFileName,const TDesC& aCommand,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Create(const TDesC& aFileName,const TDesC& aCommand,const TUidType &aUidType, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(TProcessId aId,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TUidType Type() const;
+ IMPORT_C TProcessId Id() const;
+ /**
+ @publishedAll
+ @deprecated Use User::RenameProcess() instead
+ */
+ inline static TInt RenameMe(const TDesC& aName);
+
+ IMPORT_C void Kill(TInt aReason);
+ IMPORT_C void Terminate(TInt aReason);
+ IMPORT_C void Panic(const TDesC& aCategory,TInt aReason);
+ IMPORT_C void Resume();
+ IMPORT_C TFileName FileName() const;
+ IMPORT_C TExitType ExitType() const;
+ IMPORT_C TInt ExitReason() const;
+ IMPORT_C TExitCategoryName ExitCategory() const;
+ IMPORT_C TProcessPriority Priority() const;
+ IMPORT_C TInt SetPriority(TProcessPriority aPriority) const;
+ IMPORT_C TBool JustInTime() const;
+ IMPORT_C void SetJustInTime(TBool aBoolean) const;
+ IMPORT_C void Logon(TRequestStatus& aStatus) const;
+ IMPORT_C TInt LogonCancel(TRequestStatus& aStatus) const;
+ IMPORT_C TInt GetMemoryInfo(TModuleMemoryInfo& aInfo) const;
+ inline TInt Open(const TFindProcess& aFind,TOwnerType aType=EOwnerProcess);
+ IMPORT_C void Rendezvous(TRequestStatus& aStatus) const;
+ IMPORT_C TInt RendezvousCancel(TRequestStatus& aStatus) const;
+ IMPORT_C static void Rendezvous(TInt aReason);
+ IMPORT_C TBool DefaultDataPaged() const;
+
+ /**
+ Return the Secure ID of the process.
+
+ If an intended use of this method is to check that the Secure ID is
+ a given value, then the use of a TSecurityPolicy object should be
+ considered. E.g. Instead of something like:
+
+ @code
+ RProcess& process;
+ TInt error = process.SecureId()==KRequiredSecureId ? KErrNone : KErrPermissionDenied;
+ @endcode
+
+ this could be used;
+
+ @code
+ RProcess& process;
+ static _LIT_SECURITY_POLICY_S0(mySidPolicy, KRequiredSecureId);
+ TBool pass = mySidPolicy().CheckPolicy(process);
+ @endcode
+
+ This has the benefit that the TSecurityPolicy::CheckPolicy methods are
+ configured by the system wide Platform Security configuration. I.e. are
+ capable of emitting diagnostic messages when a check fails and/or the
+ check can be forced to always pass.
+
+ @see TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
+ @see _LIT_SECURITY_POLICY_S0
+
+ @return The Secure ID.
+ @publishedAll
+ @released
+ */
+ IMPORT_C TSecureId SecureId() const;
+
+ /**
+ Return the Vendor ID of the process.
+
+ If an intended use of this method is to check that the Vendor ID is
+ a given value, then the use of a TSecurityPolicy object should be
+ considered. E.g. Instead of something like:
+
+ @code
+ RProcess& process;
+ TInt error = process.VendorId()==KRequiredVendorId ? KErrNone : KErrPermissionDenied;
+ @endcode
+
+ this could be used;
+
+ @code
+ RProcess& process;
+ static _LIT_SECURITY_POLICY_V0(myVidPolicy, KRequiredVendorId);
+ TBool pass = myVidPolicy().CheckPolicy(process);
+ @endcode
+
+ This has the benefit that the TSecurityPolicy::CheckPolicy methods are
+ configured by the system wide Platform Security configuration. I.e. are
+ capable of emitting diagnostic messages when a check fails and/or the
+ check can be forced to always pass.
+
+ @see TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
+ @see _LIT_SECURITY_POLICY_V0
+
+ @return The Vendor ID.
+ @publishedAll
+ @released
+ */
+ IMPORT_C TVendorId VendorId() const;
+
+ /**
+ Check if the 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.
+
+ @param aCapability The capability to test.
+ @param aDiagnostic A 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.
+ @return ETrue if the process has the capability, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool HasCapability(TCapability aCapability, const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /**
+ Check if the 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.
+
+ @param aCapability1 The first capability to test.
+ @param aCapability2 The second capability to test.
+ @param aDiagnostic A 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.
+ @return ETrue if the process has both the capabilities, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0) const;
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic=NULL) const;
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline TBool HasCapability(TCapability aCapability, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ IMPORT_C TInt SetParameter(TInt aIndex, RHandleBase aHandle);
+ IMPORT_C TInt SetParameter(TInt aSlot, const RSubSessionBase& aSession);
+ IMPORT_C TInt SetParameter(TInt aSlot, const TDesC16& aDes);
+ IMPORT_C TInt SetParameter(TInt aSlot, const TDesC8& aDes);
+ IMPORT_C TInt SetParameter(TInt aSlot, TInt aData);
+ inline RProcess(TInt aHandle);
+
+ /**
+ @deprecated Use RProcess::SecureId() instead
+ */
+ inline TUid Identity() const { return SecureId(); }
+
+ /**
+ Legacy Platform Security development and migration support
+ @internalAll
+ @deprecated No replacement
+ */
+ enum TSecureApi { ESecureApiOff, ESecureApiOn, ESecureApiQuery }; // __SECURE_API__ remove this
+
+ /**
+ Legacy Platform Security development and migration support
+ @internalAll
+ @deprecated No replacement
+ */
+ IMPORT_C TInt SecureApi(TInt aState); // __SECURE_API__ remove this
+
+ /**
+ Legacy Platform Security development and migration support
+ @internalAll
+ @deprecated No replacement
+ */
+ enum TDataCaging { EDataCagingOff, EDataCagingOn, EDataCagingQuery}; // __DATA_CAGING__ __SECURE_API__ remove this
+
+ /**
+ Legacy Platform Security development and migration support
+ @internalAll
+ @deprecated No replacement
+ */
+ IMPORT_C TInt DataCaging(TInt aState); // __DATA_CAGING__ __SECURE_API__ remove this
+
+
+ IMPORT_C TInt CreateWithStackOverride(const TDesC& aFileName,const TDesC& aCommand, const TUidType &aUidType, TInt aMinStackSize, TOwnerType aType);
+
+ IMPORT_C static TAny* ExeExportData(void);
+
+private:
+ // Implementations of functions with diagnostics
+ IMPORT_C TBool DoHasCapability(TCapability aCapability, const char* aDiagnostic) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const;
+ IMPORT_C TBool DoHasCapability(TCapability aCapability1, TCapability aCapability2) const;
+ };
+
+
+
+
+
+
+
+
+
+/**
+@internalTechnology
+*/
+class RServer2 : public RHandleBase
+ {
+public:
+ IMPORT_C TInt CreateGlobal(const TDesC& aName);
+ IMPORT_C TInt CreateGlobal(const TDesC& aName, TInt aMode);
+ IMPORT_C TInt CreateGlobal(const TDesC& aName, TInt aMode, TInt aRole, TInt aOpts);
+ IMPORT_C void Receive(RMessage2& aMessage,TRequestStatus& aStatus);
+ IMPORT_C void Receive(RMessage2& aMessage);
+ IMPORT_C void Cancel();
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Client-side handle to a session with a server.
+
+This is the client-side interface through which communication with the server
+is channelled.
+
+Clients normally define and implement a derived class to provide
+a richer interface.
+*/
+class RSessionBase : public RHandleBase
+ {
+ friend class RSubSessionBase;
+public:
+ /**
+ Indicates whether or not threads in the process are automatically attached
+ to the session when passed as a parameter to the Share() function.
+ */
+ enum TAttachMode {EExplicitAttach,EAutoAttach};
+public:
+ /**
+ Creates a session that can be shared by other threads in the current
+ process.
+
+ After calling this function the session object may be used by threads other
+ than than the one that created it.
+
+ Note that this can only be done with servers that mark their sessions
+ as sharable.
+
+ @return KErrNone, if the session is successfully shared;
+ KErrNoMmemory, if the attempt fails for lack of memory.
+
+ @panic KERN-EXEC 23 The session cannot be shared.
+
+ @see CServer2
+ @see RSessionBase::ShareProtected()
+ @see CServer2::TServerType
+ */
+ inline TInt ShareAuto() { return DoShare(EAutoAttach); }
+
+
+ /**
+ Creates a session handle that can be be passed via IPC to another process
+ as well as being shared by other threads in the current process.
+
+ After calling this function the session object may be used by threads other
+ than than the one that created it.
+
+ Note that this can only be done with servers that mark their sessions
+ as globally sharable.
+
+ @return KErrNone, if the session is successfully shared;
+ KErrNoMmemory, if the attempt fails for lack of memory.
+
+ @panic KERN-EXEC 23 The session cannot be shared.
+
+ @see CServer2
+ @see RSessionBase::ShareAuto()
+ @see CServer2::TServerType
+ */
+ inline TInt ShareProtected() { return DoShare(EAutoAttach|KCreateProtectedObject); }
+
+
+ IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,const TSecurityPolicy& aServerPolicy,TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
+ IMPORT_C TInt Open(TInt aArgumentIndex, const TSecurityPolicy& aServerPolicy, TOwnerType aType=EOwnerProcess);
+ inline TInt SetReturnedHandle(TInt aHandleOrError);
+ IMPORT_C TInt SetReturnedHandle(TInt aHandleOrError,const TSecurityPolicy& aServerPolicy);
+protected:
+ inline TInt CreateSession(const TDesC& aServer,const TVersion& aVersion);
+ IMPORT_C TInt CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots);
+ IMPORT_C TInt CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TIpcSessionType aType,const TSecurityPolicy* aPolicy=0, TRequestStatus* aStatus=0);
+ inline TInt CreateSession(RServer2 aServer,const TVersion& aVersion);
+ IMPORT_C TInt CreateSession(RServer2 aServer,const TVersion& aVersion,TInt aAsyncMessageSlots);
+ IMPORT_C TInt CreateSession(RServer2 aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TIpcSessionType aType,const TSecurityPolicy* aPolicy=0, TRequestStatus* aStatus=0);
+ inline static TInt SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle);
+
+ /**
+ @deprecated Use CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TIpcSessionType aType,const TSecurityPolicy* aPolicy=0, TRequestStatus* aStatus=0);
+ */
+ inline TInt CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TRequestStatus* aStatus)
+ { return CreateSession(aServer, aVersion, aAsyncMessageSlots, EIpcSession_Unsharable, (TSecurityPolicy*)0, aStatus); }
+ inline TInt Send(TInt aFunction,const TIpcArgs& aArgs) const;
+ inline void SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const;
+ inline TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
+ inline TInt Send(TInt aFunction) const;
+ inline void SendReceive(TInt aFunction,TRequestStatus& aStatus) const;
+ inline TInt SendReceive(TInt aFunction) const;
+private:
+ IMPORT_C TInt DoSend(TInt aFunction,const TIpcArgs* aArgs) const;
+ IMPORT_C void DoSendReceive(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus& aStatus) const;
+ IMPORT_C TInt DoSendReceive(TInt aFunction,const TIpcArgs* aArgs) const;
+ TInt SendAsync(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus* aStatus) const;
+ TInt SendSync(TInt aFunction,const TIpcArgs* aArgs) const;
+ IMPORT_C TInt DoShare(TInt aAttachMode);
+ TInt DoConnect(const TVersion &aVersion,TRequestStatus* aStatus);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Client-side handle to a sub-session.
+
+It represents a client-side sub-session, and has a corresponding sub-session
+object on the server-side.
+
+Clients normally define and implement a derived class to provide a richer
+interface. In particular, a derived class should:
+
+1. provide a function to create a new sub-session with the server;
+ this should call CreateSubSession().
+
+2. provide a function to close the current sub-session;
+ this should call CloseSubSession().
+
+A session must already exist with a server before a client can establish
+any sub-sessions.
+*/
+class RSubSessionBase
+ {
+public:
+ inline TInt SubSessionHandle() const;
+protected:
+ inline RSubSessionBase();
+ IMPORT_C const RSessionBase Session() const;
+ inline TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
+ inline TInt CreateSubSession(const RSessionBase& aSession,TInt aFunction);
+ IMPORT_C TInt CreateAutoCloseSubSession(RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs);
+ IMPORT_C void CloseSubSession(TInt aFunction);
+ inline TInt Send(TInt aFunction,const TIpcArgs& aArgs) const;
+ inline void SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const;
+ inline TInt SendReceive(TInt aFunction,const TIpcArgs& aArgs) const;
+ inline TInt Send(TInt aFunction) const;
+ inline void SendReceive(TInt aFunction,TRequestStatus& aStatus) const;
+ inline TInt SendReceive(TInt aFunction) const;
+private:
+ IMPORT_C TInt DoCreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs* aArgs);
+ IMPORT_C TInt DoSend(TInt aFunction,const TIpcArgs* aArgs) const;
+ IMPORT_C void DoSendReceive(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus& aStatus) const;
+ IMPORT_C TInt DoSendReceive(TInt aFunction,const TIpcArgs* aArgs) const;
+ TInt DoCreateSubSession(RSessionBase& aSession,TInt aFunction,const TIpcArgs* aArgs, TBool aAutoClose);
+private:
+ RSessionBase iSession;
+ TInt iSubSessionHandle;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Base class that provides an implementation for the templated
+RRef class.
+
+@see RRef
+*/
+class RRefBase
+ {
+public:
+ IMPORT_C void Free();
+protected:
+ inline RRefBase();
+ inline RRefBase(const RRefBase& aRef);
+ IMPORT_C void DoAlloc(const TAny* aPtr,TInt aSize);
+ IMPORT_C void DoAllocL(const TAny* aPtr,TInt aSize);
+ IMPORT_C void Copy(const RRefBase& aRef);
+private:
+ IMPORT_C void operator=(const RRefBase& aRef);
+protected:
+ TInt* iPtr;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Contains, or packages, a copy of an instance of another class.
+
+The template parameter defines the type of the contained object.
+
+The contained object is held in allocated memory, and can be accessed
+through the member selection and dereference operators.
+*/
+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);
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+A handle to a change notifier.
+
+The change notifier itself is a kernel object.
+*/
+class RChangeNotifier : public RHandleBase
+ {
+public:
+ IMPORT_C TInt Create();
+ IMPORT_C TInt Logon(TRequestStatus& aStatus) const;
+ IMPORT_C TInt LogonCancel() const;
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+
+Handle to a thread death notifier.
+
+The notifier allows threads to be notified of the death of another thread.
+
+The thread-death notifier itself is a kernel object.
+*/
+class RUndertaker : public RHandleBase
+ {
+public:
+ IMPORT_C TInt Create();
+ IMPORT_C TInt Logon(TRequestStatus& aStatus,TInt& aThreadHandle) const;
+ IMPORT_C TInt LogonCancel() const;
+ };
+
+
+
+
+
+class HBufC16;
+/**
+@publishedAll
+@released
+
+A handle to a session with the extended notifier server that provides support
+for plug-in notifiers.
+
+The interface allows engines or other low level components
+to communicate with the UI.
+*/
+class RNotifier : public RSessionBase
+ {
+public:
+ IMPORT_C RNotifier();
+ IMPORT_C TInt Connect();
+ IMPORT_C void Close();
+ IMPORT_C TInt StartNotifier(TUid aNotifierUid,const TDesC8& aBuffer);
+ IMPORT_C TInt StartNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
+ IMPORT_C TInt StartNotifier(TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
+ IMPORT_C TInt CancelNotifier(TUid aNotifierUid);
+ IMPORT_C TInt UpdateNotifier(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
+ IMPORT_C void UpdateNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
+ IMPORT_C void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
+ IMPORT_C void StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse);
+ IMPORT_C TInt UnloadNotifiers(TUid aNotifierUid);
+ IMPORT_C TInt LoadNotifiers(TUid aNotifierUid);
+ IMPORT_C void Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aBut1,const TDesC& aBut2,TInt& aButtonVal,TRequestStatus& aStatus);
+ IMPORT_C void NotifyCancel();
+ IMPORT_C TInt InfoPrint(const TDesC& aDes);
+private:
+ TPtr8 iButtonVal;
+ HBufC16* iCombinedBuffer;
+ };
+
+/**
+@publishedAll
+@released
+
+Abstract class that defines a handler to work with the TRAP mechanism.
+
+Symbian OS provides a trap handler and this class does not normally need to be
+used or accessed directly by applications and third party code.
+*/
+class TTrapHandler
+ {
+public:
+ IMPORT_C TTrapHandler();
+
+ /**
+ Called when a TRAP is invoked.
+ */
+ IMPORT_C virtual void Trap()=0;
+
+ /**
+ Called when a function exits a TRAP without leaving.
+ */
+ IMPORT_C virtual void UnTrap()=0;
+
+ /**
+ Called when a function within a TRAP leaves.
+
+ @param aValue The leave value.
+ */
+ IMPORT_C virtual void Leave(TInt aValue)=0;
+ };
+
+
+
+
+struct TCollationMethod; // forward declaration
+
+
+
+
+/**
+@publishedAll
+@released
+
+Contains a set of static functions which perform manipulation of
+data in memory.
+
+The arguments passed to the functions of this class are pointers to memory
+locations and length values. These functions are, therefore, not normally
+used in open code but are suitable for implementing data manipulation for
+other classes. Typically the interface provided by such classes is typesafe
+and hides this direct memory to memory manipulation.
+*/
+class Mem
+ {
+public:
+ inline static TUint8* Copy(TAny* aTrg, const TAny* aSrc, TInt aLength);
+ inline static TUint8* Move(TAny* aTrg, const TAny* aSrc, TInt aLength);
+ inline static void Fill(TAny* aTrg, TInt aLength, TChar aChar);
+ inline static void FillZ(TAny* aTrg, TInt aLength);
+#ifndef __GCC32__
+ inline static TInt Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
+#else
+ IMPORT_C static TInt Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
+#endif
+
+ IMPORT_C static TInt Compare(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
+ IMPORT_C static TInt CompareF(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
+ IMPORT_C static TInt CompareF(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
+ IMPORT_C static TInt CompareC(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL);
+ IMPORT_C static TInt CompareC(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL);
+ IMPORT_C static TInt CompareC(const TUint16* aLeft, TInt aLeftL, const TUint16* aRight, TInt aRightL,
+ TInt aMaxLevel, const TCollationMethod* aCollationMethod);
+ IMPORT_C static TInt CollationMethods();
+ IMPORT_C static TUint CollationMethodId(TInt aIndex);
+ IMPORT_C static const TCollationMethod* CollationMethodByIndex(TInt aIndex);
+ IMPORT_C static const TCollationMethod* CollationMethodById(TUint aId);
+ IMPORT_C static const TCollationMethod* GetDefaultMatchingTable();
+ IMPORT_C static void Swap(TAny* aPtr1, TAny* aPtr2, TInt aLength);
+ IMPORT_C static void Crc(TUint16& aCrc, const TAny* aPtr, TInt aLength);
+ IMPORT_C static void Crc32(TUint32& aCrc, const TAny* aPtr, TInt aLength);
+ };
+
+
+
+
+
+/**
+@publishedAll
+@released
+
+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.
+
+@see RThread
+@see RHeap
+*/
+class User : public UserHeap
+ {
+public:
+ // Execution control
+ IMPORT_C static void InitProcess(); /**< @internalComponent */
+ IMPORT_C static void Exit(TInt aReason);
+ IMPORT_C static void Panic(const TDesC& aCategory,TInt aReason);
+ IMPORT_C static void HandleException(TAny* aInfo); /**< @internalComponent */
+ // Cleanup support
+ IMPORT_C static void Leave(TInt aReason);
+ IMPORT_C static void LeaveNoMemory();
+ IMPORT_C static TInt LeaveIfError(TInt aReason);
+ IMPORT_C static TAny* LeaveIfNull(TAny* aPtr);
+ inline static const TAny* LeaveIfNull(const TAny* aPtr);
+ IMPORT_C static TTrapHandler* SetTrapHandler(TTrapHandler* aHandler);
+ IMPORT_C static TTrapHandler* TrapHandler();
+ IMPORT_C static TTrapHandler* MarkCleanupStack(); /**< @internalComponent */
+ IMPORT_C static void UnMarkCleanupStack(TTrapHandler* aHandler); /**< @internalComponent */
+ IMPORT_C static void LeaveEnd(); /**< @internalComponent */
+ // Infoprint
+ IMPORT_C static TInt InfoPrint(const TDesC& aDes);
+ // Asynchronous service support
+ IMPORT_C static void RequestComplete(TRequestStatus*& aStatus,TInt aReason);
+ IMPORT_C static void WaitForAnyRequest();
+ IMPORT_C static void WaitForRequest(TRequestStatus& aStatus);
+ IMPORT_C static void WaitForRequest(TRequestStatus& aStatus1,TRequestStatus& aStatus2);
+ IMPORT_C static void WaitForNRequest(TRequestStatus *aStatusArray[], TInt aNum);
+ // User heap management
+ IMPORT_C static TInt AllocLen(const TAny* aCell);
+ IMPORT_C static TAny* Alloc(TInt aSize);
+ IMPORT_C static TAny* AllocL(TInt aSize);
+ IMPORT_C static TAny* AllocLC(TInt aSize);
+ IMPORT_C static TAny* AllocZ(TInt aSize);
+ IMPORT_C static TAny* AllocZL(TInt aSize);
+ IMPORT_C static TInt AllocSize(TInt& aTotalAllocSize);
+ IMPORT_C static TInt Available(TInt& aBiggestBlock);
+ IMPORT_C static TInt CountAllocCells();
+ IMPORT_C static TInt CountAllocCells(TInt& aFreeCount);
+ IMPORT_C static void Free(TAny* aCell);
+ IMPORT_C static void FreeZ(TAny*& aCell);
+ IMPORT_C static RAllocator& Allocator();
+ inline static RHeap& Heap();
+ IMPORT_C static TAny* ReAlloc(TAny* aCell, TInt aSize, TInt aMode=0);
+ IMPORT_C static TAny* ReAllocL(TAny* aCell, TInt aSize, TInt aMode=0);
+ IMPORT_C static RAllocator* SwitchAllocator(RAllocator* aAllocator);
+ inline static RHeap* SwitchHeap(RAllocator* aHeap);
+ IMPORT_C static TInt CompressAllHeaps();
+ // Synchronous timer services
+ IMPORT_C static void After(TTimeIntervalMicroSeconds32 aInterval);
+ IMPORT_C static TInt At(const TTime& aTime);
+ IMPORT_C static void AfterHighRes(TTimeIntervalMicroSeconds32 aInterval);
+ // Set time and deal with timezones
+ IMPORT_C static TInt SetHomeTime(const TTime& aTime);
+ IMPORT_C static TInt SetHomeTimeSecure(const TTime& aTime);
+ IMPORT_C static TInt SetUTCTime(const TTime& aUTCTime);
+ IMPORT_C static TInt SetUTCTimeSecure(const TTime& aUTCTime);
+ IMPORT_C static TTimeIntervalSeconds UTCOffset();
+ IMPORT_C static void SetUTCOffset(TTimeIntervalSeconds aOffset);
+ IMPORT_C static TInt SetUTCTimeAndOffset(const TTime& aUTCTime, TTimeIntervalSeconds aOffset);
+ // Set locale information
+ IMPORT_C static TInt SetCurrencySymbol(const TDesC& aSymbol);
+ // Set floating point mode
+ IMPORT_C static TInt SetFloatingPointMode(TFloatingPointMode aMode, TFloatingPointRoundingMode aRoundingMode=EFpRoundToNearest);
+ // Timers
+ IMPORT_C static TUint TickCount();
+ IMPORT_C static TUint32 NTickCount();
+ IMPORT_C static TTimerLockSpec LockPeriod();
+ IMPORT_C static TTimeIntervalSeconds InactivityTime();
+ IMPORT_C static void ResetInactivityTime();
+ IMPORT_C static TUint32 FastCounter();
+ // Atomic operations
+ IMPORT_C static TInt LockedInc(TInt& aValue);
+ IMPORT_C static TInt LockedDec(TInt& aValue);
+ IMPORT_C static TInt SafeInc(TInt& aValue);
+ IMPORT_C static TInt SafeDec(TInt& aValue);
+ // Beep
+ IMPORT_C static TInt Beep(TInt aFrequency,TTimeIntervalMicroSeconds32 aDuration);
+ // Information
+ IMPORT_C static TInt IsRomAddress(TBool& aBool,TAny* aPtr);
+ // Algorithms
+ IMPORT_C static TInt BinarySearch(TInt aCount,const TKey& aKey,TInt& aPos);
+ IMPORT_C static TInt QuickSort(TInt aCount,const TKey& aKey,const TSwap& aSwap);
+ // Language-dependent character functions
+ IMPORT_C static TLanguage Language();
+ IMPORT_C static TRegionCode RegionCode();
+ IMPORT_C static TUint Collate(TUint aChar);
+ IMPORT_C static TUint Fold(TUint aChar);
+ IMPORT_C static TUint LowerCase(TUint aChar);
+ IMPORT_C static TUint UpperCase(TUint aChar);
+ IMPORT_C static TUint Fold(TUint aChar,TInt aFlags);
+ IMPORT_C static TUint TitleCase(TUint aChar);
+ // C-style string length
+ IMPORT_C static TInt StringLength(const TUint8* aString);
+ IMPORT_C static TInt StringLength(const TUint16* aString);
+ // Device management
+ IMPORT_C static TInt FreeLogicalDevice(const TDesC& aDeviceName);
+ IMPORT_C static TInt FreePhysicalDevice(const TDesC& aDriverName);
+ IMPORT_C static TInt LoadLogicalDevice(const TDesC& aFileName);
+ IMPORT_C static TInt LoadPhysicalDevice(const TDesC& aFileName);
+ // Version information
+ IMPORT_C static TBool QueryVersionSupported(const TVersion& aCurrent,const TVersion& aRequested);
+ IMPORT_C static TVersion Version();
+ // Machine configuration
+ IMPORT_C static TInt SetMachineConfiguration(const TDesC8& aConfig);
+ IMPORT_C static TInt MachineConfiguration(TDes8& aConfig,TInt& aSize);
+ // Debugging support
+ IMPORT_C static void SetDebugMask(TUint32 aVal);
+ IMPORT_C static void SetDebugMask(TUint32 aVal, TUint aIndex);
+ IMPORT_C static void SetJustInTime(const TBool aBoolean);
+ IMPORT_C static void Check();
+ IMPORT_C static void Invariant();
+ IMPORT_C static TBool JustInTime();
+ IMPORT_C static void __DbgMarkStart(TBool aKernel);
+ IMPORT_C static void __DbgMarkCheck(TBool aKernel, TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum);
+ IMPORT_C static TUint32 __DbgMarkEnd(TBool aKernel, TInt aCount);
+ IMPORT_C static void __DbgSetAllocFail(TBool aKernel, RAllocator::TAllocFail aFail, TInt aRate);
+ IMPORT_C static void __DbgSetBurstAllocFail(TBool aKernel, RAllocator::TAllocFail aFail, TUint aRate, TUint aBurst);
+ IMPORT_C static TUint __DbgCheckFailure(TBool aKernel);
+ IMPORT_C static void PanicUnexpectedLeave(); /**< @internalComponent */
+ // Name Validation
+ IMPORT_C static TInt ValidateName(const TDesC& aName);
+ // Instruction Memory Barrier
+ IMPORT_C static void IMB_Range(TAny* aStart, TAny* aEnd);
+ //
+ IMPORT_C static TInt CommandLineLength();
+ IMPORT_C static void CommandLine(TDes &aCommand);
+ IMPORT_C static TExceptionHandler ExceptionHandler();
+ IMPORT_C static TInt SetExceptionHandler(TExceptionHandler aHandler,TUint32 aMask);
+ IMPORT_C static void ModifyExceptionMask(TUint32 aClearMask, TUint32 aSetMask);
+ IMPORT_C static TInt RaiseException(TExcType aType);
+ IMPORT_C static TBool IsExceptionHandled(TExcType aType);
+
+ /**
+ 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:
+ - User::SetCritical()
+ - User::SetProcessCritical()
+
+ 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.
+
+ @see User::SetCritical()
+ @see User::SetProcessCritical()
+ */
+ enum TCritical {
+
+
+ /**
+ 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.
+
+ @see User::SetCritical()
+ @see User::SetProcessCritical()
+ */
+ ENotCritical,
+
+
+ /**
+ 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.
+
+ @see User::SetCritical()
+ */
+ 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 terminates for any reason.
+
+ @see User::SetCritical()
+ */
+ EProcessPermanent,
+
+
+ /**
+ 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.
+
+ @see EProcessCritical
+ @see User::SetProcessCritical()
+ */
+ EAllThreadsCritical,
+
+
+ /**
+ 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:
+ -# existing threads in the current process are NOT affected when you
+ call User::SetProcessCritical() with this value.
+ -# Only a process with 'Protected Server' capability can set a
+ thread to system-critical.
+
+ @see User::SetCritical()
+ @see 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
+ 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:
+ -# existing threads in the current process are NOT affected when you
+ call User::SetProcessCritical() with this value.
+ -# Only a process with 'Protected Server' capability can set a
+ thread to system-permanent.
+
+ @see User::SetCritical()
+ @see User::SetProcessCritical()
+ */
+ ESystemPermanent
+ };
+ IMPORT_C static TCritical Critical();
+ IMPORT_C static TCritical Critical(RThread aThread);
+ IMPORT_C static TInt SetCritical(TCritical aCritical);
+ IMPORT_C static TCritical ProcessCritical();
+ IMPORT_C static TCritical ProcessCritical(RProcess aProcess);
+ IMPORT_C static TInt SetProcessCritical(TCritical aCritical);
+ IMPORT_C static TBool PriorityControl();
+ IMPORT_C static void SetPriorityControl(TBool aEnable);
+
+ /**
+ 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.
+ @publishedPartner
+ @released
+ */
+ enum TRealtimeState
+ {
+ ERealtimeStateOff, /**< Thread is not realtime */
+ ERealtimeStateOn, /**< Thread is realtime */
+ ERealtimeStateWarn /**< Thread is realtime but doesn't want this enforced */
+ };
+
+ /**
+ Set the current threads realtime state.
+ @see TRealtimeState
+ @param aState The state
+ @return KErrNone if successful. KErrArgument if aState is invalid.
+ @publishedPartner
+ @released
+ */
+ IMPORT_C static TInt SetRealtimeState(TRealtimeState aState);
+
+ /**
+ Return the Secure ID of the process that created the current process.
+ @return The Secure ID.
+ @publishedAll
+ @released
+ */
+ IMPORT_C static TSecureId CreatorSecureId();
+
+ /**
+ Return the Vendor ID of the process that created the current process.
+ @return The Vendor ID.
+ @publishedAll
+ @released
+ */
+ IMPORT_C static TVendorId CreatorVendorId();
+
+ /**
+ 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.
+
+ @param aCapability The capability to test.
+ @param aDiagnostic A 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.
+ @return ETrue if the creator process has the capability, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline static TBool CreatorHasCapability(TCapability aCapability, const char* aDiagnostic=0);
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline static TBool CreatorHasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic=NULL);
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline static TBool CreatorHasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress);
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ /**
+ 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.
+
+ @param aCapability1 The first capability to test.
+ @param aCapability2 The second capability to test.
+ @param aDiagnostic A 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.
+ @return ETrue if the creator process has both the capabilities, EFalse otherwise.
+ @publishedAll
+ @released
+ */
+#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ inline static TBool CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0);
+#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+ // Only available to NULL arguments
+ inline static TBool CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic=NULL);
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+ // For things using KSuppressPlatSecDiagnostic
+ inline static TBool CreatorHasCapability(TCapability aCapability, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress);
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
+
+ IMPORT_C static TInt ParameterLength(TInt aSlot);
+ IMPORT_C static TInt GetTIntParameter(TInt aSlot, TInt& aData);
+ IMPORT_C static TInt GetDesParameter(TInt aSlot, TDes8& aDes);
+ IMPORT_C static TInt GetDesParameter(TInt aSlot, TDes16& aDes);
+ IMPORT_C static TInt RenameThread(const TDesC &aName);
+ IMPORT_C static TInt RenameProcess(const TDesC &aName);
+ /*
+ User::Identity() has been deprecated and is available for backward
+ compatibility purposes only.
+
+ Use RProcess().SecureId() instead.
+
+ @deprecated
+ */
+ inline static TUid Identity() { return RProcess().SecureId(); }
+
+ /*
+ User::CreatorIdentity() has been deprecated and is available for backward
+ compatibility purposes only.
+
+ Use CreatorSecureId() instead.
+
+ @deprecated
+ */
+ static inline TUid CreatorIdentity() { return CreatorSecureId(); }
+
+ IMPORT_C static void NotifyOnIdle(TRequestStatus& aStatus); /**< @internalTechnology */
+ IMPORT_C static void CancelMiscNotifier(TRequestStatus& aStatus); /**< @internalTechnology */
+private:
+ // Implementations of functions with diagnostics
+ IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability, const char* aDiagnostic);
+ IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability);
+ IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic);
+ IMPORT_C static TBool DoCreatorHasCapability(TCapability aCapability1, TCapability aCapability2);
+ };
+
+
+
+
+class ExecHandler;
+
+/**
+@internalComponent
+@removed
+*/
+typedef void (*TTlsCleanupHandler)(TAny*); //don't use
+
+/**
+@publishedAll
+@released
+
+A collection of static functions involved in managing access to
+thread-local storage.
+
+Thread-local storage is a single machine word of static writable memory.
+The scope of this machine word is the thread, which means that there is one
+word per thread. The word is only accessible to code running in a DLL.
+
+In practice, this word is almost always used to hold a pointer to allocated
+memory; this makes that memory available to all DLL code running on behalf
+of the same thread.
+
+Note that DLL code running on behalf of one thread does not see the same word when
+running on behalf of another thread.
+
+The class in not intended for user derivation.
+*/
+class Dll
+ {
+public:
+ static TInt SetTls(TAny* aPtr);
+ static TAny* Tls();
+ static void FreeTls();
+ static void FileName(TFileName &aFileName);
+ };
+
+
+
+
+#ifndef __TOOLS__
+/**
+@publishedAll
+@released
+
+A thin wrapper class for C++ arrays allowing automatic checking of index values
+to ensure that all accesses are legal.
+
+The class also supports the deletion of objects.
+
+The class is templated, based on a class type and an integer value. The class
+type defines the type of object contained in the array; the integer value
+defines the size (dimension) of the array.
+
+A wrapper object can be:
+
+1. embedded in objects allocated on the heap.
+
+2. used on the program stack.
+*/
+template <class T,TInt S>
+class TFixedArray
+ {
+ typedef TFixedArray<T,S> ThisClass;
+public:
+ inline TFixedArray();
+ inline TFixedArray(const T* aList, TInt aLength);
+ //
+ inline void Copy(const T* aList, TInt aLength);
+ inline void Reset(); // zero fill
+ inline void DeleteAll();
+ //
+ inline TInt Count() const;
+ inline TInt Length() const;
+ // Accessors - debug range checking
+ inline T& operator[](TInt aIndex);
+ inline const T& operator[] (TInt aIndex) const;
+ // Accessors - always range checking
+ inline T& At(TInt aIndex);
+ inline const T& At(TInt aIndex) const;
+ // Provides pointers to the beginning and end of the array
+ inline T* Begin();
+ inline T* End();
+ inline const T* Begin() const;
+ inline const T* End() const;
+ //
+ inline TArray<T> Array() const;
+protected:
+ inline static TBool InRange(TInt aIndex);
+ inline static TInt CountFunctionR(const CBase* aThis);
+ inline static const TAny* AtFunctionR(const CBase* aThis,TInt aIndex);
+protected:
+ T iRep[S];
+ };
+
+
+
+
+/**
+@publishedAll
+@released
+*/
+#define DECLARE_ROM_ARRAY( AName, AData, AType ) \
+ const TFixedArray<AType,(sizeof(AData)/sizeof((AData)[0]))>& \
+ AName = *(reinterpret_cast<const TFixedArray<AType, \
+ (sizeof(AData)/sizeof((AData)[0]))>* > (AData))
+#endif
+
+// Global leaving operator new
+/**
+@publishedAll
+@released
+*/
+inline TAny* operator new(TUint aSize, TLeave);
+/**
+@publishedAll
+@released
+*/
+inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize);
+#if !defined(__VC32__) || defined (__MSVCDOTNET__)
+/**
+@publishedAll
+@released
+*/
+inline TAny* operator new[](TUint aSize, TLeave);
+#endif
+
+
+#ifdef __LEAVE_EQUALS_THROW__
+/** Macro to assert in all builds that code does not leave
+
+@param _s C++ statements to be executed which should not leave
+@panic USER 194 if the code being checked does leave
+
+@publishedAll
+@released
+*/
+#define __ASSERT_ALWAYS_NO_LEAVE(_s) \
+ { \
+ try { \
+ TTrapHandler* ____t = User::MarkCleanupStack(); \
+ _s; \
+ User::UnMarkCleanupStack(____t); \
+ } \
+ catch (XLeaveException& /*l*/) \
+ { \
+ User::PanicUnexpectedLeave(); \
+ } \
+ catch (...) \
+ { \
+ User::Invariant(); \
+ } \
+ }
+
+#else
+/** Macro to assert in all builds that code does not leave
+
+@param _s C++ statements to be executed which should not leave
+@panic USER 194 if the code being checked does leave
+
+@publishedAll
+@released
+*/
+#define __ASSERT_ALWAYS_NO_LEAVE(_s) \
+ { \
+ TInt _r; \
+ TTrap _t; \
+ if (_t.Trap(_r) == 0) \
+ { \
+ _s; \
+ TTrap::UnTrap(); \
+ } \
+ else \
+ User::PanicUnexpectedLeave(); \
+ }
+#endif
+
+/** Macro to assert in debug builds that code does not leave
+
+@param _s C++ statements to be executed which should not leave
+@panic USER 194 if the code being checked does leave
+
+@publishedAll
+@released
+*/
+#ifdef _DEBUG
+#define __ASSERT_DEBUG_NO_LEAVE(_s) __ASSERT_ALWAYS_NO_LEAVE(_s)
+#else
+#define __ASSERT_DEBUG_NO_LEAVE(_s) { _s; }
+#endif
+
+
+
+// Inline methods
+#include <e32std.inl>
+
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <e32std_private.h>
+#endif
+
+#endif
+