e32def.h File Reference

Typedef TAny

typedef voidTAny

Pointer to any type.

TAny* is equivalent to void* in standard C or C++. TAny* is used in preference to void* because it is more suggestive of the actual meaning, e.g. TAny* foo();.

TAny is not used where it really means "nothing", as in the declaration of functions which do not return a value; void is used instead, e.g. void Foo();.

Typedef TInt8

typedef signed charTInt8

8-bit signed integer type, used in Symbian OS to mean an 8-bit signed integer, independent of the implementation.

Typedef TUint8

typedef unsigned charTUint8

8-bit unsigned integer type; used in Symbian OS to mean an 8-bit unsigned integer, independent of the implementation.

Typedef TInt16

typedef short intTInt16

16-bit signed integer type, used in Symbian OS to mean a 16-bit signed integer, independent of the implementation.

Typedef TUint16

typedef unsigned short intTUint16

16-bit unsigned integer type. used in Symbian OS to mean a 16-bit unsigned integer, independent of the implementation.

Typedef TInt32

typedef long intTInt32

32-bit signed integer type, used in Symbian OS to mean a 32-bit signed integer, independent of the implementation.

Typedef T_IntPtr

typedef TInt32 T_IntPtr

A signed integer type of the same size as a pointer.

Typedef TIntPtr

typedef TInt32 TIntPtr

Typedef TUint32

typedef unsigned long intTUint32

32-bit unsigned integer type; used in Symbian OS to mean a 32-bit unsigned integer, independent of the implementation.

Typedef T_UintPtr

typedef TUint32 T_UintPtr

An unsigned integer type of the same size as a pointer.

Typedef TUintPtr

typedef TUint32 TUintPtr

Typedef TInt

typedef signed intTInt

Signed integer type of the natural machine word length.

This is as defined by the C++ implementation's int type. In all implementations, this is guaranteed to be at least 32 bits.

A TInt should be used in preference to a sized integer (TInt32, TInt16) for all general use. Sized integers should only be used when packing is essential. C++'s type conversion rules imply that all sized integers smaller than the natural machine word are in any case broadened to the natural machine word size when passed as function parameters.

A TInt should be used in preference to an unsigned integer (TUint) for all general use. Unsigned integers should only be used for flags (which use Boolean operations but not arithmetic) and, in very rare cases, for numbers whose range exceeds that available from signed integers. Although it is natural to attempt to use unsigned integers for quantities which cannot by nature be negative, the C++ language does not provide the support necessary to enforce the "expected" behaviour in these circumstances, and experience has shown that it is better to use signed integers unless there is good reason not to.

TUint

TInt32

TInt16

Typedef TUint

typedef unsigned intTUint

Unsigned integer type of the natural machine word length.

This is guaranteed to be at least 32 bits in all implementations.

In almost all circumstances, a TInt should be used in preference to a TUint. The main exception is in flags bytes.

TInt

Typedef TReal32

typedef floatTReal32

32-bit floating point number, providing IEEE754 single precision on all Symbian OS implementations.

TReal should normally be used in preference to TReal32.

Use of floating-point numbers should generally be avoided unless a natural part of the problem specification. Most Symbian OS implementations do not have a hardware floating point unit: as a result, their floating-point performance is hundreds of times slower than integer performance.

Typedef TReal64

typedef doubleTReal64

64-bit floating point number, providing IEEE754 double precision on all Symbian OS implementations.

Use of floating-point numbers should generally be avoided unless a natural part of the problem specification. Most Symbian OS implementations do not have a hardware floating point unit: as a result, their floating-point performance is hundreds of times slower than integer performance.

This type is identical to TReal.

TReal

Typedef TReal

typedef doubleTReal

64-bit floating point number; identical to TReal64.

Use of floating-point numbers should generally be avoided unless a natural part of the problem specification. Most Symbian OS implementations do not have a hardware floating point unit: as a result, their floating-point performance is hundreds of times slower than integer performance.

Most serious floating-point calculations require double-precision. All standard math functions (see Math class) take double-precision arguments. Single-precision should only be used where space and performance are at a premium, and when their limited precision is acceptable.

TReal64

Math

Typedef TText8

typedef unsigned charTText8

8-bit unsigned character.

Use instead of C++ built-in char type because it is guaranteed to be unsigned. Use instead of TInt8 where the application is really for text rather than 8-bit arithmetic or binary quantities.

For most purposes, you should use TText rather than TText8. TText is mapped onto either TText8 or TText16 depending on whether a non-Unicode or Unicode variant is being built. Use TText8 only when you are dealing explicitly with 8-bit text, regardless of build.

TText

Typedef TText16

typedef unsigned short intTText16

16-bit unsigned character.

Use instead of C++ wchar_t type because it is guaranteed to be unsigned. Use instead of TInt16 where the application is really for text rather than 8-bit arithmetic or binary quantities.

For most purposes, you should use TText rather than TText16. TText is mapped onto either TText8 or TText16 depending on whether a non-Unicode or Unicode variant is being built. Use TText16 only when you are dealing explicitly with 16-bit text, regardless of build.

TText

Typedef TBool

typedef intTBool

Boolean type which takes the value either ETrue or EFalse.

Although only a single bit would theoretically be necessary to represent a Boolean, a machine word is used instead, so that these quantities can be easily passed. Also, TBool must map onto int because of C++'s interpretation of operands in conditional expressions.

Typedef TLinAddr

typedef T_UintPtr TLinAddr

Defines a linear (virtual) address type.

Typedef Int64

typedef long longInt64

Defines a 64-bit signed integer type.

Typedef Uint64

typedef unsigned long longUint64

Defines a 64-bit unsigned integer type.

Typedef TInt64

typedef Int64 TInt64

Defines a 64-bit signed integer type.

NOTE: For those migrating from versions of Symbian OS before 8.1b (i.e. 8.1a, 7.0s etc) TInt64 is now defined as a built-in type instead of as a class type. This means that the member functions of the old TInt64 class are no longer exported from EUSER.LIB, and represents a compatibility break.

To ease migration of source code, a number of macros are provided. Similar macros have also been defined in Symbian OS versions 7.0s and 8.1a, but implemented in terms of the old TInt64 class. This is important for code that is common to : one or both of these Symbian OS versions, and to 8.1b and subsequent versions.

The following list shows the new macros and the functions that they replace. It also shows some alternative techniques. In this list: x, v and r are declared as TInt64, c is declared as TInt, High and Low are declared as TUint.

OLD USAGE						REPLACEMENT

TInt64(High,Low);				MAKE_TINT64(High,Low);
x.Set(High,Low);				MAKE_TINT64(High,Low);
x.Low();						I64LOW(x);
x.High();						I64HIGH(x); 
x.GetTInt();					I64INT(x); 
x.GetTReal();					I64REAL(x); 
x.Lsr(c);						I64LSR(x,c); 
x.Mul10();						x*=10; 
x.MulTop(a);					I64MULTOP(x,a); 
x.DivMod(v,r);					r=x%v; x/=v;

Typedef TUint64

typedef Uint64 TUint64

Defines a 64-bit unsigned integer type.

Typedef TText

typedef TText16 TText

Build independent general text character.

In non-Unicode builds, this is mapped to TText8. In Unicode builds, this is mapped to TText16. Use the classes with explicit width only when you wish the width to be independent of the build variant.

Use this class rather than TChar for general use.

Typedef VA_LIST

typedef TInt8 *VA_LIST

Defines a 'C' style array of pointers to TInt8 types.

The type is most commonly used by code that needs to deal with a variable number of arguments passed to a function.

TInt8

const char *const KSuppressPlatSecDiagnosticMagicValue

const char *constKSuppressPlatSecDiagnosticMagicValue[static]

const char *const KSuppressPlatSecDiagnostic

const char *constKSuppressPlatSecDiagnostic[static]

When this value is used in Platform Security APIs as the value for the aDiagnosticText argument, these APIs will not emit any form of diagnostic message.