Symaptic: os/kernelhwsrv/kernel/eka/include/e32cmn.h@bde4ae8d615e (annotated)

sl@0	1	// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of the License "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	// e32\include\e32cmn.h
sl@0	15	//
sl@0	16	//
sl@0	17
sl@0	18	#ifndef __E32CMN_H__
sl@0	19	#define __E32CMN_H__
sl@0	20	#include <e32const.h>
sl@0	21
sl@0	22	extern "C" {
sl@0	23	/**
sl@0	24	@publishedAll
sl@0	25	@released
sl@0	26
sl@0	27	A Nanokernel utility function that compares two memory buffers for equality.
sl@0	28
sl@0	29	The two buffers are considered equal only if:
sl@0	30
sl@0	31	1. the buffers have the same length
sl@0	32
sl@0	33	and
sl@0	34
sl@0	35	2. the binary content of both buffers is the same.
sl@0	36
sl@0	37	@param aLeft The start address of the first buffer in the comparison.
sl@0	38	@param aLeftLen The length of the first buffer in the comparison.
sl@0	39	@param aRight The start address of the second buffer in the comparison.
sl@0	40	@param aRightLen The length of the second buffer in the comparison.
sl@0	41
sl@0	42	@return Zero if both buffers are equal; non-zero, otherwise.
sl@0	43
sl@0	44	@panic USER 88 In debug mode only, if aLeftL is negative,
sl@0	45	and the function is called on the user side.
sl@0	46	@panic KERN-COMMON 88 In debug mode only, if aLeftL is negative,
sl@0	47	and the function is called on the kernel side.
sl@0	48	@panic USER 89 In debug mode only, if aRightL is negative,
sl@0	49	and the function is called on the user side.
sl@0	50	@panic KERN-COMMON 89 In debug mode only, if aRightL is negative,
sl@0	51	and the function is called on the kernel side.
sl@0	52	*/
sl@0	53	IMPORT_C TInt memcompare(const TUint8* aLeft, TInt aLeftLen, const TUint8* aRight, TInt aRightLen);
sl@0	54
sl@0	55
sl@0	56
sl@0	57
sl@0	58	/**
sl@0	59	@publishedAll
sl@0	60	@released
sl@0	61
sl@0	62	A Nanokernel utility function that moves (copies) bytes in memory.
sl@0	63
sl@0	64	The function assumes that the addresses are aligned on word boundaries,
sl@0	65	and that the length value is a multiple of 4.
sl@0	66
sl@0	67	@param aTrg The target address.
sl@0	68	@param aSrc The source address.
sl@0	69	@param aLength The number of bytes to be moved.
sl@0	70
sl@0	71	@return The target address.
sl@0	72
sl@0	73	@panic USER 91 In debug mode only, if aLength is not a multiple of 4,
sl@0	74	and the function is called on the user side.
sl@0	75	@panic KERN-COMMON 91 In debug mode only, if aLength is not a multiple of 4,
sl@0	76	and the function is called on the kernel side.
sl@0	77	@panic USER 92 In debug mode only, if aSrc is not aligned on a word boundary,
sl@0	78	and the function is called on the user side.
sl@0	79	@panic KERN-COMMON 92 In debug mode only, if aSrc is not aligned on a word boundary,
sl@0	80	and the function is called on the kernel side.
sl@0	81	@panic USER 93 In debug mode only, if aTrg is not aligned on a word boundary,
sl@0	82	and the function is called on the user side.
sl@0	83	@panic KERN-COMMON 93 In debug mode only, if aTrg is not aligned on a word boundary,
sl@0	84	and the function is called on the kernel side.
sl@0	85	*/
sl@0	86	IMPORT_C TAny* wordmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength);
sl@0	87
sl@0	88
sl@0	89
sl@0	90
sl@0	91	/**
sl@0	92	@publishedAll
sl@0	93	@released
sl@0	94
sl@0	95	A Nanokernel utility function that sets the specified number of bytes
sl@0	96	to binary zero.
sl@0	97
sl@0	98	@param aTrg The start address.
sl@0	99	@param aLength The number of bytes to be set.
sl@0	100
sl@0	101	@return The target address.
sl@0	102	*/
sl@0	103	IMPORT_C TAny* memclr(TAny* aTrg, unsigned int aLength);
sl@0	104	}
sl@0	105
sl@0	106
sl@0	107
sl@0	108
sl@0	109	#ifndef __TOOLS__
sl@0	110	extern "C" {
sl@0	111	/**
sl@0	112	@publishedAll
sl@0	113	@released
sl@0	114
sl@0	115	A Nanokernel utility function that sets all of the specified number of bytes to
sl@0	116	the specified fill value.
sl@0	117
sl@0	118	@param aTrg The start address.
sl@0	119	@param aValue The fill value (the first or junior byte).
sl@0	120	@param aLength The number of bytes to be set.
sl@0	121
sl@0	122	@return The target address.
sl@0	123	*/
sl@0	124	IMPORT_C TAny* memset(TAny* aTrg, TInt aValue, unsigned int aLength);
sl@0	125
sl@0	126
sl@0	127
sl@0	128
sl@0	129	/**
sl@0	130	@publishedAll
sl@0	131	@released
sl@0	132
sl@0	133	A Nanokernel utility function that copies bytes in memory.
sl@0	134
sl@0	135	@param aTrg The target address.
sl@0	136	@param aSrc The source address.
sl@0	137	@param aLength The number of bytes to be moved.
sl@0	138
sl@0	139	@return The target address.
sl@0	140	*/
sl@0	141	IMPORT_C TAny* memcpy(TAny* aTrg, const TAny* aSrc, unsigned int aLength);
sl@0	142
sl@0	143
sl@0	144
sl@0	145
sl@0	146	/**
sl@0	147	@publishedAll
sl@0	148	@released
sl@0	149
sl@0	150	A Nanokernel utility function that moves (copies) bytes in memory.
sl@0	151
sl@0	152	@param aTrg The target address.
sl@0	153	@param aSrc The source address.
sl@0	154	@param aLength The number of bytes to be moved.
sl@0	155
sl@0	156	@return The target address.
sl@0	157	*/
sl@0	158	IMPORT_C TAny* memmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength);
sl@0	159	}
sl@0	160	#else
sl@0	161	#include <string.h>
sl@0	162	#endif
sl@0	163
sl@0	164
sl@0	165
sl@0	166
sl@0	167	/**
sl@0	168	@publishedAll
sl@0	169	@released
sl@0	170
sl@0	171	Tests whether the specified value is less than or equal to the
sl@0	172	specified upper limit.
sl@0	173
sl@0	174	@param aVal The value to be tested.
sl@0	175	@param aLimit The upper limit.
sl@0	176
sl@0	177	@return True, if the value is less than or equal to the specified upper limit;
sl@0	178	false, otherwise.
sl@0	179	*/
sl@0	180	inline TInt Lim(TInt aVal,TUint aLimit)
sl@0	181	{return(((TUint)aVal)<=aLimit);}
sl@0	182
sl@0	183
sl@0	184
sl@0	185
sl@0	186	/**
sl@0	187	@publishedAll
sl@0	188	@released
sl@0	189
sl@0	190	Tests whether the specified value is strictly less than the
sl@0	191	specified upper limit.
sl@0	192
sl@0	193	@param aVal The value to be tested.
sl@0	194	@param aLimit The upper limit.
sl@0	195
sl@0	196	@return True, if the value is strictly less than the specified upper limit;
sl@0	197	false, otherwise.
sl@0	198	*/
sl@0	199	inline TInt LimX(TInt aVal,TUint aLimit)
sl@0	200	{return(((TUint)aVal)<aLimit);}
sl@0	201
sl@0	202
sl@0	203
sl@0	204
sl@0	205	/**
sl@0	206	@publishedAll
sl@0	207	@released
sl@0	208
sl@0	209	Returns the smaller of two values.
sl@0	210
sl@0	211	@param aLeft The first value to be compared.
sl@0	212	@param aRight The second value to be compared.
sl@0	213
sl@0	214	@return The smaller value.
sl@0	215	*/
sl@0	216	template <class T>
sl@0	217	inline T Min(T aLeft,T aRight)
sl@0	218	{return(aLeft<aRight ? aLeft : aRight);}
sl@0	219
sl@0	220
sl@0	221
sl@0	222
sl@0	223	/**
sl@0	224	@publishedAll
sl@0	225	@released
sl@0	226
sl@0	227	Returns the smaller of two objects, where the right hand object is a treated
sl@0	228	as a TInt for the purpose of comparison.
sl@0	229
sl@0	230	@param aLeft The first value to be compared.
sl@0	231	@param aRight The second value to be compared.
sl@0	232
sl@0	233	@return The smaller value.
sl@0	234	*/
sl@0	235	template <class T>
sl@0	236	inline T Min(T aLeft,TUint aRight)
sl@0	237	{return(aLeft<(TInt)aRight ? aLeft : (T)aRight);}
sl@0	238
sl@0	239
sl@0	240
sl@0	241
sl@0	242	/**
sl@0	243	@publishedAll
sl@0	244	@released
sl@0	245
sl@0	246	Returns the larger of two values.
sl@0	247
sl@0	248	@param aLeft The first value to be compared.
sl@0	249	@param aRight The second value to be compared.
sl@0	250
sl@0	251	@return The larger value.
sl@0	252	*/
sl@0	253	template <class T>
sl@0	254	inline T Max(T aLeft,T aRight)
sl@0	255	{return(aLeft<aRight ? aRight : aLeft);}
sl@0	256
sl@0	257
sl@0	258
sl@0	259
sl@0	260	/**
sl@0	261	@publishedAll
sl@0	262	@released
sl@0	263
sl@0	264	Returns the larger of two objects, where the right hand object is a treated
sl@0	265	as a TInt for the purpose of comparison.
sl@0	266
sl@0	267	@param aLeft The first value to be compared.
sl@0	268	@param aRight The second value to be compared.
sl@0	269
sl@0	270	@return The larger value.
sl@0	271	*/
sl@0	272	template <class T>
sl@0	273	inline T Max(T aLeft,TUint aRight)
sl@0	274	{return(aLeft<(TInt)aRight ? (TInt)aRight : aLeft);}
sl@0	275
sl@0	276
sl@0	277
sl@0	278
sl@0	279	/**
sl@0	280	@publishedAll
sl@0	281	@released
sl@0	282
sl@0	283	Returns an absolute value.
sl@0	284
sl@0	285	@param aVal The source value.
sl@0	286
sl@0	287	@return The absolute value
sl@0	288	*/
sl@0	289	template <class T>
sl@0	290	inline T Abs(T aVal)
sl@0	291	{return(aVal<0 ? -aVal : aVal);}
sl@0	292
sl@0	293
sl@0	294
sl@0	295
sl@0	296	/**
sl@0	297	@publishedAll
sl@0	298	@released
sl@0	299
sl@0	300	Determines whether a specified value lies within a defined range of values.
sl@0	301
sl@0	302	@param aMin The lower value of the range.
sl@0	303	@param aVal The value to be compared.
sl@0	304	@param aMax The higher value of the range.
sl@0	305
sl@0	306	@return True, if the specified value lies within the range; false, otherwise.
sl@0	307	*/
sl@0	308	template <class T>
sl@0	309	inline TBool Rng(T aMin,T aVal,T aMax)
sl@0	310	{return(aVal>=aMin && aVal<=aMax);}
sl@0	311
sl@0	312
sl@0	313
sl@0	314
sl@0	315	/**
sl@0	316	@publishedAll
sl@0	317	@released
sl@0	318
sl@0	319	Adds a value to a pointer.
sl@0	320
sl@0	321	@param aPtr Pointer to an object of type T.
sl@0	322	@param aVal The value to be added.
sl@0	323
sl@0	324	@return The resulting pointer value, as a pointer to a type T.
sl@0	325	*/
sl@0	326	template <class T,class S>
sl@0	327	inline T* PtrAdd(T* aPtr,S aVal)
sl@0	328	{return((T)(((TUint8)aPtr)+aVal));}
sl@0	329
sl@0	330
sl@0	331
sl@0	332
sl@0	333	/**
sl@0	334	@publishedAll
sl@0	335	@released
sl@0	336
sl@0	337	Subtracts a value from a pointer.
sl@0	338
sl@0	339	@param aPtr Pointer to an object of type T.
sl@0	340	@param aVal The value to be added.
sl@0	341
sl@0	342	@return The resulting pointer value, as a pointer to a type T.
sl@0	343	*/
sl@0	344	template <class T,class S>
sl@0	345	inline T* PtrSub(T* aPtr,S aVal)
sl@0	346	{return((T)(((TUint8)aPtr)-aVal));}
sl@0	347
sl@0	348
sl@0	349
sl@0	350
sl@0	351	/**
sl@0	352	@publishedAll
sl@0	353	@released
sl@0	354
sl@0	355	Aligns the specified value onto a 2-byte boundary.
sl@0	356
sl@0	357	@param aValue The value to be aligned.
sl@0	358
sl@0	359	@return The aligned value.
sl@0	360	*/
sl@0	361	template <class T>
sl@0	362	inline T Align2(T aValue)
sl@0	363	{return((T)((((TUint)aValue)+sizeof(TUint16)-1)&~(sizeof(TUint16)-1)));}
sl@0	364
sl@0	365
sl@0	366
sl@0	367
sl@0	368	/**
sl@0	369	@publishedAll
sl@0	370	@released
sl@0	371
sl@0	372	Aligns the specified value onto a 4-byte boundary.
sl@0	373
sl@0	374	@param aValue The value to be aligned.
sl@0	375
sl@0	376	@return The aligned value.
sl@0	377	*/
sl@0	378	template <class T>
sl@0	379	inline T Align4(T aValue)
sl@0	380	{return((T)((((TUint)aValue)+sizeof(TUint32)-1)&~(sizeof(TUint32)-1)));}
sl@0	381
sl@0	382
sl@0	383
sl@0	384
sl@0	385	/**
sl@0	386	@publishedAll
sl@0	387	@released
sl@0	388
sl@0	389	A templated class which encapsulates a reference to an object within a wrapper.
sl@0	390
sl@0	391	The wrapper object can be passed to a function as a value type. This allows
sl@0	392	a reference to be passed to a function as a value type.
sl@0	393
sl@0	394	This wrapper object is commonly termed a value reference.
sl@0	395	*/
sl@0	396	template <class T>
sl@0	397	class TRefByValue
sl@0	398	{
sl@0	399	public:
sl@0	400	inline TRefByValue(T& aRef);
sl@0	401	inline operator T&();
sl@0	402	private:
sl@0	403	TRefByValue& operator=(TRefByValue aRef);
sl@0	404	private:
sl@0	405	T &iRef;
sl@0	406	};
sl@0	407
sl@0	408
sl@0	409
sl@0	410
sl@0	411	#if !defined (__KERNEL_MODE__)
sl@0	412	class TDesC16; // forward declaration for TChar member functions
sl@0	413	class TPtrC16; // forward declaration for TChar member functions
sl@0	414	#endif
sl@0	415
sl@0	416
sl@0	417
sl@0	418
sl@0	419	/**
sl@0	420	@publishedAll
sl@0	421	@released
sl@0	422
sl@0	423	Holds a character value and provides a number of utility functions to
sl@0	424	manipulate it and test its properties.
sl@0	425
sl@0	426	For example, there are functions to convert the character
sl@0	427	to uppercase and test whether or not it is a control character.
sl@0	428
sl@0	429	The character value is stored as a 32-bit unsigned integer. The shorthand
sl@0	430	"TChar value" is used to describe the character value wrapped by a TChar
sl@0	431	object.
sl@0	432
sl@0	433	TChar can be used to represent Unicode values outside plane 0 (that is, the
sl@0	434	extended Unicode range from 0x10000 to 0xFFFFF). This differentiates it from
sl@0	435	TText which can only be used for 16-bit Unicode character values.
sl@0	436
sl@0	437	@see TText
sl@0	438	*/
sl@0	439	class TChar
sl@0	440	{
sl@0	441	public:
sl@0	442
sl@0	443
sl@0	444	/**
sl@0	445	General Unicode character category.
sl@0	446
sl@0	447	The high nibble encodes the major category (Mark, Number, etc.) and a low
sl@0	448	nibble encodes the subdivisions of that category.
sl@0	449
sl@0	450	The category codes can be used in three ways:
sl@0	451
sl@0	452	(i) as unique constants: there is one for each Unicode category, with a
sl@0	453	name of the form
sl@0	454	@code
sl@0	455	E<XX>Category
sl@0	456	@endcode
sl@0	457	where
sl@0	458	@code
sl@0	459	<XX>
sl@0	460	@endcode
sl@0	461	is the category name given by
sl@0	462	the Unicode database (e.g., the constant ELuCategory is used for lowercase
sl@0	463	letters, category Lu);
sl@0	464
sl@0	465	(ii) as numbers in certain ranges: letter categories are all <= EMaxLetterCategory;
sl@0	466
sl@0	467	(iii) as codes in which the upper nibble gives the category group
sl@0	468	(e.g., punctuation categories all yield TRUE for
sl@0	469	the test (category & 0xF0) ==EPunctuationGroup).
sl@0	470	*/
sl@0	471	enum TCategory
sl@0	472	{
sl@0	473	/**
sl@0	474	Alphabetic letters.
sl@0	475
sl@0	476	Includes ELuCategory, ELlCategory and ELtCategory.
sl@0	477	*/
sl@0	478	EAlphaGroup = 0x00,
sl@0	479
sl@0	480
sl@0	481	/**
sl@0	482	Other letters.
sl@0	483
sl@0	484	Includes ELoCategory.
sl@0	485	*/
sl@0	486	ELetterOtherGroup = 0x10,
sl@0	487
sl@0	488
sl@0	489	/**
sl@0	490	Letter modifiers.
sl@0	491
sl@0	492	Includes ELmCategory.
sl@0	493	*/
sl@0	494	ELetterModifierGroup = 0x20,
sl@0	495
sl@0	496
sl@0	497	/**
sl@0	498	Marks group.
sl@0	499
sl@0	500	Includes EMnCategory, EMcCategory and EMeCategory.
sl@0	501	*/
sl@0	502	EMarkGroup = 0x30,
sl@0	503
sl@0	504
sl@0	505	/**
sl@0	506	Numbers group.
sl@0	507
sl@0	508	Includes ENdCategory, ENlCategory and ENoCategory.
sl@0	509	*/
sl@0	510	ENumberGroup = 0x40,
sl@0	511
sl@0	512
sl@0	513	/**
sl@0	514	Punctuation group.
sl@0	515
sl@0	516	IncludesEPcCategory, PdCategory, EpeCategory, EPsCategory and EPoCategory.
sl@0	517	*/
sl@0	518	EPunctuationGroup = 0x50,
sl@0	519
sl@0	520
sl@0	521	/**
sl@0	522	Symbols group.
sl@0	523
sl@0	524	Includes ESmCategory, EScCategory, ESkCategory and ESoCategory.
sl@0	525	*/
sl@0	526	ESymbolGroup = 0x60,
sl@0	527
sl@0	528
sl@0	529	/**
sl@0	530	Separators group.
sl@0	531
sl@0	532	Includes EZsCategory, EZlCategory and EZlpCategory.
sl@0	533	*/
sl@0	534	ESeparatorGroup = 0x70,
sl@0	535
sl@0	536
sl@0	537	/**
sl@0	538	Control, format, private use, unassigned.
sl@0	539
sl@0	540	Includes ECcCategory, ECtCategory, ECsCategory,
sl@0	541	ECoCategory and ECnCategory.
sl@0	542	*/
sl@0	543	EControlGroup = 0x80,
sl@0	544
sl@0	545
sl@0	546	/**
sl@0	547	The highest possible groups category.
sl@0	548	*/
sl@0	549	EMaxAssignedGroup = 0xE0,
sl@0	550
sl@0	551
sl@0	552	/**
sl@0	553	Unassigned to any other group.
sl@0	554	*/
sl@0	555	EUnassignedGroup = 0xF0,
sl@0	556
sl@0	557
sl@0	558	/**
sl@0	559	Letter, Uppercase.
sl@0	560	*/
sl@0	561	ELuCategory = EAlphaGroup \| 0,
sl@0	562
sl@0	563
sl@0	564	/**
sl@0	565	Letter, Lowercase.
sl@0	566	*/
sl@0	567	ELlCategory = EAlphaGroup \| 1,
sl@0	568
sl@0	569
sl@0	570	/**
sl@0	571	Letter, Titlecase.
sl@0	572	*/
sl@0	573	ELtCategory = EAlphaGroup \| 2,
sl@0	574
sl@0	575
sl@0	576	/**
sl@0	577	Letter, Other.
sl@0	578	*/
sl@0	579	ELoCategory = ELetterOtherGroup \| 0,
sl@0	580
sl@0	581
sl@0	582	/**
sl@0	583	The highest possible (non-modifier) letter category.
sl@0	584	*/
sl@0	585	EMaxLetterCategory = ELetterOtherGroup \| 0x0F,
sl@0	586
sl@0	587	/**
sl@0	588	Letter, Modifier.
sl@0	589	*/
sl@0	590	ELmCategory = ELetterModifierGroup \| 0,
sl@0	591
sl@0	592
sl@0	593	/**
sl@0	594	The highest possible letter category.
sl@0	595	*/
sl@0	596	EMaxLetterOrLetterModifierCategory = ELetterModifierGroup \| 0x0F,
sl@0	597
sl@0	598	/**
sl@0	599	Mark, Non-Spacing
sl@0	600	*/
sl@0	601	EMnCategory = EMarkGroup \| 0,
sl@0	602
sl@0	603
sl@0	604	/**
sl@0	605	Mark, Combining.
sl@0	606	*/
sl@0	607	EMcCategory = EMarkGroup \| 1,
sl@0	608
sl@0	609
sl@0	610	/**
sl@0	611	Mark, Enclosing.
sl@0	612	*/
sl@0	613	EMeCategory = EMarkGroup \| 2,
sl@0	614
sl@0	615
sl@0	616	/**
sl@0	617	Number, Decimal Digit.
sl@0	618	*/
sl@0	619	ENdCategory = ENumberGroup \| 0,
sl@0	620
sl@0	621
sl@0	622	/**
sl@0	623	Number, Letter.
sl@0	624	*/
sl@0	625	ENlCategory = ENumberGroup \| 1,
sl@0	626
sl@0	627
sl@0	628	/**
sl@0	629	Number, Other.
sl@0	630	*/
sl@0	631	ENoCategory = ENumberGroup \| 2,
sl@0	632
sl@0	633
sl@0	634	/**
sl@0	635	Punctuation, Connector.
sl@0	636	*/
sl@0	637	EPcCategory = EPunctuationGroup \| 0,
sl@0	638
sl@0	639
sl@0	640	/**
sl@0	641	Punctuation, Dash.
sl@0	642	*/
sl@0	643	EPdCategory = EPunctuationGroup \| 1,
sl@0	644
sl@0	645
sl@0	646	/**
sl@0	647	Punctuation, Open.
sl@0	648	*/
sl@0	649	EPsCategory = EPunctuationGroup \| 2,
sl@0	650
sl@0	651
sl@0	652	/**
sl@0	653	Punctuation, Close.
sl@0	654	*/
sl@0	655	EPeCategory = EPunctuationGroup \| 3,
sl@0	656
sl@0	657
sl@0	658	/**
sl@0	659	Punctuation, Initial Quote
sl@0	660	*/
sl@0	661	EPiCategory = EPunctuationGroup \| 4,
sl@0	662
sl@0	663
sl@0	664	/**
sl@0	665	Punctuation, Final Quote
sl@0	666	*/
sl@0	667	EPfCategory = EPunctuationGroup \| 5,
sl@0	668
sl@0	669
sl@0	670	/**
sl@0	671	Punctuation, Other.
sl@0	672	*/
sl@0	673	EPoCategory = EPunctuationGroup \| 6,
sl@0	674
sl@0	675
sl@0	676	/**
sl@0	677	Symbol, Math.
sl@0	678	*/
sl@0	679	ESmCategory = ESymbolGroup \| 0,
sl@0	680
sl@0	681
sl@0	682	/**
sl@0	683	Symbol, Currency.
sl@0	684	*/
sl@0	685	EScCategory = ESymbolGroup \| 1,
sl@0	686
sl@0	687
sl@0	688	/**
sl@0	689	Symbol, Modifier.
sl@0	690	*/
sl@0	691	ESkCategory = ESymbolGroup \| 2,
sl@0	692
sl@0	693
sl@0	694	/**
sl@0	695	Symbol, Other.
sl@0	696	*/
sl@0	697	ESoCategory = ESymbolGroup \| 3,
sl@0	698
sl@0	699
sl@0	700	/**
sl@0	701	The highest possible graphic character category.
sl@0	702	*/
sl@0	703	EMaxGraphicCategory = ESymbolGroup \| 0x0F,
sl@0	704
sl@0	705
sl@0	706	/**
sl@0	707	Separator, Space.
sl@0	708	*/
sl@0	709	EZsCategory = ESeparatorGroup \| 0,
sl@0	710
sl@0	711
sl@0	712	/**
sl@0	713	The highest possible printable character category.
sl@0	714	*/
sl@0	715	EMaxPrintableCategory = EZsCategory,
sl@0	716
sl@0	717
sl@0	718	/**
sl@0	719	Separator, Line.
sl@0	720	*/
sl@0	721	EZlCategory = ESeparatorGroup \| 1,
sl@0	722
sl@0	723
sl@0	724	/**
sl@0	725	Separator, Paragraph.
sl@0	726	*/
sl@0	727	EZpCategory = ESeparatorGroup \| 2,
sl@0	728
sl@0	729
sl@0	730	/**
sl@0	731	Other, Control.
sl@0	732	*/
sl@0	733	ECcCategory = EControlGroup \| 0,
sl@0	734
sl@0	735
sl@0	736	/**
sl@0	737	Other, Format.
sl@0	738	*/
sl@0	739	ECfCategory = EControlGroup \| 1,
sl@0	740
sl@0	741
sl@0	742	/**
sl@0	743	The highest possible category for assigned 16-bit characters; does not
sl@0	744	include surrogates, which are interpreted as pairs and have no meaning
sl@0	745	on their own.
sl@0	746	*/
sl@0	747	EMaxAssignedCategory = EMaxAssignedGroup \| 0x0F,
sl@0	748
sl@0	749
sl@0	750	/**
sl@0	751	Other, Surrogate.
sl@0	752	*/
sl@0	753	ECsCategory = EUnassignedGroup \| 0,
sl@0	754
sl@0	755
sl@0	756	/**
sl@0	757	Other, Private Use.
sl@0	758	*/
sl@0	759	ECoCategory = EUnassignedGroup \| 1,
sl@0	760
sl@0	761
sl@0	762	/**
sl@0	763	Other, Not Assigned.
sl@0	764	*/
sl@0	765	ECnCategory = EUnassignedGroup \| 2
sl@0	766	};
sl@0	767
sl@0	768
sl@0	769	/**
sl@0	770	The bi-directional Unicode character category.
sl@0	771
sl@0	772	For more information on the bi-directional algorithm, see Unicode Technical
sl@0	773	Report No. 9 available at: http://www.unicode.org/unicode/reports/tr9.
sl@0	774	*/
sl@0	775	enum TBdCategory
sl@0	776	{
sl@0	777	/**
sl@0	778	Left to right.
sl@0	779	*/
sl@0	780	ELeftToRight, // L Left-to-Right
sl@0	781
sl@0	782
sl@0	783	/**
sl@0	784	Left to right embedding.
sl@0	785	*/
sl@0	786	ELeftToRightEmbedding, // LRE Left-to-Right Embedding
sl@0	787
sl@0	788
sl@0	789	/**
sl@0	790	Left-to-Right Override.
sl@0	791	*/
sl@0	792	ELeftToRightOverride, // LRO Left-to-Right Override
sl@0	793
sl@0	794
sl@0	795	/**
sl@0	796	Right to left.
sl@0	797	*/
sl@0	798	ERightToLeft, // R Right-to-Left
sl@0	799
sl@0	800
sl@0	801	/**
sl@0	802	Right to left Arabic.
sl@0	803	*/
sl@0	804	ERightToLeftArabic, // AL Right-to-Left Arabic
sl@0	805
sl@0	806
sl@0	807	/**
sl@0	808	Right to left embedding.
sl@0	809	*/
sl@0	810	ERightToLeftEmbedding, // RLE Right-to-Left Embedding
sl@0	811
sl@0	812
sl@0	813	/**
sl@0	814	Right-to-Left Override.
sl@0	815	*/
sl@0	816	ERightToLeftOverride, // RLO Right-to-Left Override
sl@0	817
sl@0	818
sl@0	819	/**
sl@0	820	Pop Directional Format.
sl@0	821	*/
sl@0	822	EPopDirectionalFormat, // PDF Pop Directional Format
sl@0	823
sl@0	824
sl@0	825	/**
sl@0	826	European number.
sl@0	827	*/
sl@0	828	EEuropeanNumber, // EN European Number
sl@0	829
sl@0	830
sl@0	831	/**
sl@0	832	European number separator.
sl@0	833	*/
sl@0	834	EEuropeanNumberSeparator, // ES European Number Separator
sl@0	835
sl@0	836
sl@0	837	/**
sl@0	838	European number terminator.
sl@0	839	*/
sl@0	840	EEuropeanNumberTerminator, // ET European Number Terminator
sl@0	841
sl@0	842
sl@0	843	/**
sl@0	844	Arabic number.
sl@0	845	*/
sl@0	846	EArabicNumber, // AN Arabic Number
sl@0	847
sl@0	848
sl@0	849	/**
sl@0	850	Common number separator.
sl@0	851	*/
sl@0	852	ECommonNumberSeparator, // CS Common Number Separator
sl@0	853
sl@0	854
sl@0	855	/**
sl@0	856	Non Spacing Mark.
sl@0	857	*/
sl@0	858	ENonSpacingMark, // NSM Non-Spacing Mark
sl@0	859
sl@0	860
sl@0	861	/**
sl@0	862	Boundary Neutral.
sl@0	863	*/
sl@0	864	EBoundaryNeutral, // BN Boundary Neutral
sl@0	865
sl@0	866
sl@0	867	/**
sl@0	868	Paragraph Separator.
sl@0	869	*/
sl@0	870	EParagraphSeparator, // B Paragraph Separator
sl@0	871
sl@0	872
sl@0	873	/**
sl@0	874	Segment separator.
sl@0	875	*/
sl@0	876	ESegmentSeparator, // S Segment Separator
sl@0	877
sl@0	878
sl@0	879	/**
sl@0	880	Whitespace
sl@0	881	*/
sl@0	882	EWhitespace, // WS Whitespace
sl@0	883
sl@0	884
sl@0	885	/**
sl@0	886	Other neutrals; all other characters: punctuation, symbols.
sl@0	887	*/
sl@0	888	EOtherNeutral // ON Other Neutrals
sl@0	889	};
sl@0	890
sl@0	891
sl@0	892	/**
sl@0	893	Notional character width as known to East Asian (Chinese, Japanese,
sl@0	894	Korean (CJK)) coding systems.
sl@0	895	*/
sl@0	896	enum TCjkWidth
sl@0	897	{
sl@0	898	/**
sl@0	899	Includes 'ambiguous width' defined in Unicode Technical Report 11: East Asian Width
sl@0	900	*/
sl@0	901	ENeutralWidth,
sl@0	902
sl@0	903
sl@0	904	/**
sl@0	905	Character which occupies a single cell.
sl@0	906	*/
sl@0	907	EHalfWidth, // other categories are as defined in the report
sl@0	908
sl@0	909
sl@0	910	/**
sl@0	911	Character which occupies 2 cells.
sl@0	912	*/
sl@0	913	EFullWidth,
sl@0	914
sl@0	915
sl@0	916	/**
sl@0	917	Characters that are always narrow and have explicit full-width
sl@0	918	counterparts. All of ASCII is an example of East Asian Narrow
sl@0	919	characters.
sl@0	920	*/
sl@0	921	ENarrow,
sl@0	922
sl@0	923	/**
sl@0	924	Characters that are always wide. This category includes characters that
sl@0	925	have explicit half-width counterparts.
sl@0	926	*/
sl@0	927	EWide
sl@0	928	};
sl@0	929
sl@0	930
sl@0	931	/**
sl@0	932	@deprecated
sl@0	933
sl@0	934	Encoding systems used by the translation functions.
sl@0	935	*/
sl@0	936	enum TEncoding
sl@0	937	{
sl@0	938	/**
sl@0	939	The Unicode encoding.
sl@0	940	*/
sl@0	941	EUnicode,
sl@0	942
sl@0	943
sl@0	944	/**
sl@0	945	The shift-JIS encoding (used in Japan).
sl@0	946	*/
sl@0	947	EShiftJIS
sl@0	948	};
sl@0	949
sl@0	950
sl@0	951	/**
sl@0	952	Flags defining operations to be performed using TChar::Fold().
sl@0	953
sl@0	954	The flag values are passed to the Fold() funtion.
sl@0	955
sl@0	956	@see TChar::Fold
sl@0	957	*/
sl@0	958	enum
sl@0	959	{
sl@0	960	/**
sl@0	961	Convert characters to their lower case form if any.
sl@0	962	*/
sl@0	963	EFoldCase = 1,
sl@0	964
sl@0	965
sl@0	966	/**
sl@0	967	Strip accents
sl@0	968	*/
sl@0	969	EFoldAccents = 2,
sl@0	970
sl@0	971
sl@0	972	/**
sl@0	973	Convert digits representing values 0..9 to characters '0'..'9'
sl@0	974	*/
sl@0	975	EFoldDigits = 4,
sl@0	976
sl@0	977
sl@0	978	/**
sl@0	979	Convert all spaces (ordinary, fixed-width, ideographic, etc.) to ' '
sl@0	980	*/
sl@0	981	EFoldSpaces = 8,
sl@0	982
sl@0	983
sl@0	984	/**
sl@0	985	Convert hiragana to katakana.
sl@0	986	*/
sl@0	987	EFoldKana = 16,
sl@0	988
sl@0	989
sl@0	990	/**
sl@0	991	Fold fullwidth and halfwidth variants to their standard forms
sl@0	992	*/
sl@0	993	EFoldWidth = 32,
sl@0	994
sl@0	995
sl@0	996	/**
sl@0	997	Perform standard folding operations, i.e.those done by Fold() with no argument
sl@0	998	*/
sl@0	999	EFoldStandard = EFoldCase \| EFoldAccents \| EFoldDigits \| EFoldSpaces,
sl@0	1000
sl@0	1001
sl@0	1002	/**
sl@0	1003	Perform all possible folding operations
sl@0	1004	*/
sl@0	1005	EFoldAll = -1
sl@0	1006	};
sl@0	1007
sl@0	1008
sl@0	1009	struct TCharInfo
sl@0	1010	/**
sl@0	1011	A structure to hold information about a Unicode character.
sl@0	1012
sl@0	1013	An object of this type is passed to TChar::GetInfo().
sl@0	1014
sl@0	1015	@see TChar::GetInfo
sl@0	1016	*/
sl@0	1017	{
sl@0	1018	/**
sl@0	1019	General category.
sl@0	1020	*/
sl@0	1021	TCategory iCategory;
sl@0	1022
sl@0	1023
sl@0	1024	/**
sl@0	1025	Bi-directional category.
sl@0	1026	*/
sl@0	1027	TBdCategory iBdCategory;
sl@0	1028
sl@0	1029
sl@0	1030	/**
sl@0	1031	Combining class: number (currently) in the range 0..234
sl@0	1032	*/
sl@0	1033	TInt iCombiningClass;
sl@0	1034
sl@0	1035
sl@0	1036	/**
sl@0	1037	Lower case form.
sl@0	1038	*/
sl@0	1039	TUint iLowerCase;
sl@0	1040
sl@0	1041
sl@0	1042	/**
sl@0	1043	Upper case form.
sl@0	1044	*/
sl@0	1045	TUint iUpperCase;
sl@0	1046
sl@0	1047
sl@0	1048	/**
sl@0	1049	Title case form.
sl@0	1050	*/
sl@0	1051	TUint iTitleCase;
sl@0	1052
sl@0	1053
sl@0	1054	/**
sl@0	1055	True, if the character is mirrored.
sl@0	1056	*/
sl@0	1057	TBool iMirrored;
sl@0	1058
sl@0	1059
sl@0	1060	/**
sl@0	1061	Integer numeric value: -1 if none, -2 if a fraction.
sl@0	1062	*/
sl@0	1063	TInt iNumericValue;
sl@0	1064	};
sl@0	1065
sl@0	1066	inline TChar();
sl@0	1067	inline TChar(TUint aChar);
sl@0	1068	inline TChar& operator-=(TUint aChar);
sl@0	1069	inline TChar& operator+=(TUint aChar);
sl@0	1070	inline TChar operator-(TUint aChar);
sl@0	1071	inline TChar operator+(TUint aChar);
sl@0	1072	inline operator TUint() const;
sl@0	1073	#ifndef __KERNEL_MODE__
sl@0	1074	inline void Fold();
sl@0	1075	inline void LowerCase();
sl@0	1076	inline void UpperCase();
sl@0	1077	inline TBool Eos() const;
sl@0	1078	IMPORT_C TUint GetUpperCase() const;
sl@0	1079	IMPORT_C TUint GetLowerCase() const;
sl@0	1080	IMPORT_C TBool IsLower() const;
sl@0	1081	IMPORT_C TBool IsUpper() const;
sl@0	1082	IMPORT_C TBool IsAlpha() const;
sl@0	1083	IMPORT_C TBool IsDigit() const;
sl@0	1084	IMPORT_C TBool IsAlphaDigit() const;
sl@0	1085	IMPORT_C TBool IsHexDigit() const;
sl@0	1086	IMPORT_C TBool IsSpace() const;
sl@0	1087	IMPORT_C TBool IsPunctuation() const;
sl@0	1088	IMPORT_C TBool IsGraph() const;
sl@0	1089	IMPORT_C TBool IsPrint() const;
sl@0	1090	IMPORT_C TBool IsControl() const;
sl@0	1091	inline void Fold(TInt aFlags);
sl@0	1092	inline void TitleCase();
sl@0	1093	IMPORT_C TUint GetTitleCase() const;
sl@0	1094	IMPORT_C TBool IsTitle() const;
sl@0	1095	IMPORT_C TBool IsAssigned() const;
sl@0	1096	IMPORT_C void GetInfo(TCharInfo& aInfo) const;
sl@0	1097	IMPORT_C TCategory GetCategory() const;
sl@0	1098	IMPORT_C TBdCategory GetBdCategory() const;
sl@0	1099	IMPORT_C TInt GetCombiningClass() const;
sl@0	1100	IMPORT_C TBool IsMirrored() const;
sl@0	1101	IMPORT_C TInt GetNumericValue() const;
sl@0	1102	IMPORT_C TCjkWidth GetCjkWidth() const;
sl@0	1103	IMPORT_C static TBool Compose(TUint& aResult,const TDesC16& aSource);
sl@0	1104	IMPORT_C TBool Decompose(TPtrC16& aResult) const;
sl@0	1105
sl@0	1106	protected:
sl@0	1107	inline void SetChar(TUint aChar);
sl@0	1108	#endif
sl@0	1109	private:
sl@0	1110	TUint iChar;
sl@0	1111	__DECLARE_TEST;
sl@0	1112	};
sl@0	1113
sl@0	1114	#include <e32des8.h>
sl@0	1115	#ifndef __KERNEL_MODE__
sl@0	1116	#include <e32des16.h>
sl@0	1117	#endif
sl@0	1118
sl@0	1119
sl@0	1120
sl@0	1121
sl@0	1122	#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
sl@0	1123	#define __Size (sizeof(TUint)/sizeof(TUint16))
sl@0	1124	/**
sl@0	1125	@publishedAll
sl@0	1126	@released
sl@0	1127
sl@0	1128	Defines a build-independent non-modifiable descriptor.
sl@0	1129
sl@0	1130	A 16-bit build variant is generated for a Unicode, non-kernel
sl@0	1131	mode build.
sl@0	1132
sl@0	1133	A build-independent type should always be used unless an explicit 8-bit
sl@0	1134	or 16-bit type is required.
sl@0	1135
sl@0	1136	@see TDesC8
sl@0	1137	@see TDesC16
sl@0	1138	*/
sl@0	1139	typedef TDesC16 TDesC;
sl@0	1140
sl@0	1141
sl@0	1142
sl@0	1143
sl@0	1144	/**
sl@0	1145	@publishedAll
sl@0	1146	@released
sl@0	1147
sl@0	1148	Defines a build-independent non-modifiable pointer descriptor.
sl@0	1149
sl@0	1150	A 16-bit build variant is generated for a Unicode, non-kernel
sl@0	1151	mode build.
sl@0	1152
sl@0	1153	A build-independent type should always be used unless an explicit 8-bit
sl@0	1154	or 16-bit type is required.
sl@0	1155
sl@0	1156	@see TPtrC8
sl@0	1157	@see TPtrC16
sl@0	1158	*/
sl@0	1159	typedef TPtrC16 TPtrC;
sl@0	1160
sl@0	1161
sl@0	1162
sl@0	1163
sl@0	1164	/**
sl@0	1165	@publishedAll
sl@0	1166	@released
sl@0	1167
sl@0	1168	Defines a build-independent modifiable descriptor.
sl@0	1169
sl@0	1170	A 16-bit build variant is generated for a Unicode, non-kernel
sl@0	1171	mode build.
sl@0	1172
sl@0	1173	A build-independent type should always be used unless an explicit 8-bit
sl@0	1174	or 16-bit type is required.
sl@0	1175
sl@0	1176	@see TDes8
sl@0	1177	@see TDes16
sl@0	1178	*/
sl@0	1179	typedef TDes16 TDes;
sl@0	1180
sl@0	1181
sl@0	1182
sl@0	1183
sl@0	1184	/**
sl@0	1185	@publishedAll
sl@0	1186	@released
sl@0	1187
sl@0	1188	Defines a build-independent modifiable pointer descriptor.
sl@0	1189
sl@0	1190	A 16-bit build variant is generated for a Unicode, non-kernel
sl@0	1191	mode build.
sl@0	1192
sl@0	1193	A build-independent type should always be used unless an explicit 8-bit
sl@0	1194	or 16-bit type is required.
sl@0	1195
sl@0	1196	@see TPtr8
sl@0	1197	@see TPtr16
sl@0	1198	*/
sl@0	1199	typedef TPtr16 TPtr;
sl@0	1200
sl@0	1201
sl@0	1202
sl@0	1203
sl@0	1204	#ifndef __KERNEL_MODE__
sl@0	1205	/**
sl@0	1206	@publishedAll
sl@0	1207	@released
sl@0	1208
sl@0	1209	Defines a build-independent heap descriptor.
sl@0	1210
sl@0	1211	A 16-bit build variant is generated for a Unicode, non-kernel
sl@0	1212	mode build.
sl@0	1213
sl@0	1214	A build-independent type should always be used unless an explicit 8-bit
sl@0	1215	or 16-bit type is required.
sl@0	1216
sl@0	1217	@see HBufC8
sl@0	1218	@see HBufC16
sl@0	1219	*/
sl@0	1220	typedef HBufC16 HBufC;
sl@0	1221
sl@0	1222
sl@0	1223
sl@0	1224
sl@0	1225	/**
sl@0	1226	@publishedAll
sl@0	1227	@released
sl@0	1228
sl@0	1229	Defines a build-independent descriptor overflow handler.
sl@0	1230
sl@0	1231	A 16-bit build variant is generated for a Unicode, non-kernel
sl@0	1232	mode build.
sl@0	1233
sl@0	1234	A build-independent type should always be used unless an explicit 8-bit
sl@0	1235	or 16-bit type is required.
sl@0	1236
sl@0	1237	@see TDes8Overflow
sl@0	1238	@see TDes16Overflow
sl@0	1239	*/
sl@0	1240	typedef TDes16Overflow TDesOverflow;
sl@0	1241
sl@0	1242
sl@0	1243	/**
sl@0	1244	@publishedAll
sl@0	1245	@released
sl@0	1246
sl@0	1247	Defines a build-independent resizable buffer descriptor.
sl@0	1248
sl@0	1249	A 16-bit build variant is generated for a Unicode, non-kernel mode build.
sl@0	1250
sl@0	1251	A build-independent type should always be used unless an explicit 8-bit
sl@0	1252	or 16-bit type is required.
sl@0	1253
sl@0	1254	@see RBuf8
sl@0	1255	@see RBuf16
sl@0	1256	*/
sl@0	1257	typedef RBuf16 RBuf;
sl@0	1258
sl@0	1259	#endif
sl@0	1260	#else
sl@0	1261	#define __Size (sizeof(TUint)/sizeof(TUint8))
sl@0	1262
sl@0	1263
sl@0	1264
sl@0	1265
sl@0	1266	/**
sl@0	1267	@publishedAll
sl@0	1268	@released
sl@0	1269
sl@0	1270	Defines a build-independent non-modifiable descriptor.
sl@0	1271
sl@0	1272	An 8-bit build variant is generated for a non-Unicode build.
sl@0	1273
sl@0	1274	This build-independent type should always be used unless an explicit 8-bit
sl@0	1275	or 16-bit build variant is required.
sl@0	1276
sl@0	1277	@see TDesC8
sl@0	1278	@see TDesC16
sl@0	1279	*/
sl@0	1280	typedef TDesC8 TDesC;
sl@0	1281
sl@0	1282
sl@0	1283
sl@0	1284
sl@0	1285	/**
sl@0	1286	@publishedAll
sl@0	1287	@released
sl@0	1288
sl@0	1289	Defines a build-independent non-modifiable pointer descriptor.
sl@0	1290
sl@0	1291	An 8-bit build variant is generated for a non-Unicode build.
sl@0	1292
sl@0	1293	This build-independent type should always be used unless an explicit 8-bit
sl@0	1294	or 16-bit build variant is required.
sl@0	1295
sl@0	1296	@see TPtrC8
sl@0	1297	@see TPtrC16
sl@0	1298	*/
sl@0	1299	typedef TPtrC8 TPtrC;
sl@0	1300
sl@0	1301
sl@0	1302
sl@0	1303
sl@0	1304	/**
sl@0	1305	@publishedAll
sl@0	1306	@released
sl@0	1307
sl@0	1308	Defines a build-independent modifiable descriptor.
sl@0	1309
sl@0	1310	An 8-bit build variant is generated for a non-Unicode build.
sl@0	1311
sl@0	1312	This build-independent type should always be used unless an explicit 8-bit
sl@0	1313	or 16-bit build variant is required.
sl@0	1314
sl@0	1315	@see TDes8
sl@0	1316	@see TDes16
sl@0	1317	*/
sl@0	1318	typedef TDes8 TDes;
sl@0	1319
sl@0	1320
sl@0	1321
sl@0	1322
sl@0	1323	/**
sl@0	1324	@publishedAll
sl@0	1325	@released
sl@0	1326
sl@0	1327	Defines a build-independent modifiable pointer descriptor.
sl@0	1328
sl@0	1329	An 8-bit build variant is generated for a non-Unicode build.
sl@0	1330
sl@0	1331	This build-independent type should always be used unless an explicit 8-bit
sl@0	1332	or 16-bit build variant is required.
sl@0	1333
sl@0	1334	@see TPtr8
sl@0	1335	@see TPtr16
sl@0	1336	*/
sl@0	1337	typedef TPtr8 TPtr;
sl@0	1338	#ifndef __KERNEL_MODE__
sl@0	1339
sl@0	1340
sl@0	1341
sl@0	1342
sl@0	1343	/**
sl@0	1344	@publishedAll
sl@0	1345	@released
sl@0	1346
sl@0	1347	Defines a build-independent heap descriptor.
sl@0	1348
sl@0	1349	An 8-bit build variant is generated for a non-Unicode, non-kernel
sl@0	1350	mode build.
sl@0	1351
sl@0	1352	This build-independent type should always be used unless an explicit 8-bit
sl@0	1353	or 16-bit build variant is required.
sl@0	1354
sl@0	1355	@see HBufC8
sl@0	1356	@see HBufC16
sl@0	1357	*/
sl@0	1358	typedef HBufC8 HBufC;
sl@0	1359
sl@0	1360
sl@0	1361
sl@0	1362
sl@0	1363	/**
sl@0	1364	@publishedAll
sl@0	1365	@released
sl@0	1366
sl@0	1367	Defines a build-independent descriptor overflow handler.
sl@0	1368
sl@0	1369	An 8-bit build variant is generated for a non-Unicode, non-kernel
sl@0	1370	mode build.
sl@0	1371
sl@0	1372	This build-independent type should always be used unless an explicit 8-bit
sl@0	1373	or 16-bit build variant is required.
sl@0	1374
sl@0	1375	@see TDes8Overflow
sl@0	1376	@see TDes16Overflow
sl@0	1377	*/
sl@0	1378	typedef TDes8Overflow TDesOverflow;
sl@0	1379
sl@0	1380
sl@0	1381	/**
sl@0	1382	@publishedAll
sl@0	1383	@released
sl@0	1384
sl@0	1385	Defines a build-independent resizable buffer descriptor.
sl@0	1386
sl@0	1387	An 8-bit build variant is generated for a non-Unicode, non-kernel mode build.
sl@0	1388
sl@0	1389	This build-independent type should always be used unless an explicit 8-bit
sl@0	1390	or 16-bit build variant is required.
sl@0	1391
sl@0	1392	@see RBuf8
sl@0	1393	@see RBuf16
sl@0	1394	*/
sl@0	1395	typedef RBuf8 RBuf;
sl@0	1396
sl@0	1397	#endif
sl@0	1398	#endif
sl@0	1399
sl@0	1400
sl@0	1401	#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
sl@0	1402	typedef TBufCBase16 TBufCBase;
sl@0	1403	#else
sl@0	1404	typedef TBufCBase8 TBufCBase;
sl@0	1405	#endif
sl@0	1406
sl@0	1407	/**
sl@0	1408	@publishedAll
sl@0	1409	@released
sl@0	1410
sl@0	1411	A build-independent non-modifiable buffer descriptor.
sl@0	1412
sl@0	1413	This is a descriptor class which provides a buffer of fixed length for
sl@0	1414	containing and accessing TUint16 or TUint8 data, depending on the build.
sl@0	1415
sl@0	1416	The class intended for instantiation. The data that the descriptor represents
sl@0	1417	is part of the descriptor object itself.
sl@0	1418
sl@0	1419	The class is templated, based on an integer value which defines the size of
sl@0	1420	the descriptor's data area.
sl@0	1421
sl@0	1422	The data is intended to be accessed, but not modified; however, it can be
sl@0	1423	completely replaced using the assignment operators of this class. The base
sl@0	1424	class provides the functions through which the data is accessed.
sl@0	1425
sl@0	1426	This class derives from TBufCBase16 for a Unicode, non-kernel build, but
sl@0	1427	derives from TBufCBase8 for a non-Unicode build.
sl@0	1428
sl@0	1429	@see TDesC
sl@0	1430	@see TDesC8
sl@0	1431	@see TDesC16
sl@0	1432	@see TPtr
sl@0	1433	@see TPtr8
sl@0	1434	@see TPtr16
sl@0	1435	@see TBufC8
sl@0	1436	@see TBufC16
sl@0	1437	*/
sl@0	1438	template <TInt S>
sl@0	1439	#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
sl@0	1440	class TBufC : public TBufCBase16
sl@0	1441	#else
sl@0	1442	class TBufC : public TBufCBase8
sl@0	1443	#endif
sl@0	1444	{
sl@0	1445	public:
sl@0	1446	inline TBufC();
sl@0	1447	inline TBufC(const TText* aString);
sl@0	1448	inline TBufC(const TDesC& aDes);
sl@0	1449	inline TBufC<S>& operator=(const TText* aString);
sl@0	1450	inline TBufC<S>& operator=(const TDesC& aDes);
sl@0	1451	inline TPtr Des();
sl@0	1452	private:
sl@0	1453	TText iBuf[__Align(S)];
sl@0	1454	};
sl@0	1455
sl@0	1456
sl@0	1457
sl@0	1458	/**
sl@0	1459	@publishedAll
sl@0	1460	@released
sl@0	1461
sl@0	1462	A build-independent modifiable buffer descriptor.
sl@0	1463
sl@0	1464	This is a descriptor class which provides a buffer of fixed length for
sl@0	1465	containing, accessing and manipulating TUint16 or TUint8 data, depending
sl@0	1466	on the build.
sl@0	1467
sl@0	1468	The class is intended for instantiation. The data that the descriptor represents
sl@0	1469	is part of the descriptor object itself.
sl@0	1470
sl@0	1471	The class is templated, based on an integer value which determines the size
sl@0	1472	of the data area created as part of the buffer descriptor object; this is
sl@0	1473	also the maximum length of the descriptor.
sl@0	1474
sl@0	1475	The data is intended to be both accessed and modified. The base classes provide
sl@0	1476	the functions through which the data is accessed.
sl@0	1477
sl@0	1478	This class derives from TBufCBase16 for a Unicode, non-kernel build, but
sl@0	1479	derives from TBufCBase8 for a non-Unicode build.
sl@0	1480
sl@0	1481	@see TDesC
sl@0	1482	@see TDesC8
sl@0	1483	@see TDesC16
sl@0	1484	@see TDes
sl@0	1485	@see TDes8
sl@0	1486	@see TDes16
sl@0	1487	@see TPtr
sl@0	1488	@see TPtr8
sl@0	1489	@see TPtr16
sl@0	1490	*/
sl@0	1491	template <TInt S>
sl@0	1492	#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
sl@0	1493	class TBuf : public TBufBase16
sl@0	1494	#else
sl@0	1495	class TBuf : public TBufBase8
sl@0	1496	#endif
sl@0	1497	{
sl@0	1498	public:
sl@0	1499	inline TBuf();
sl@0	1500	inline explicit TBuf(TInt aLength);
sl@0	1501	inline TBuf(const TText* aString);
sl@0	1502	inline TBuf(const TDesC& aDes);
sl@0	1503	inline TBuf<S>& operator=(const TText* aString);
sl@0	1504	inline TBuf<S>& operator=(const TDesC& aDes);
sl@0	1505	inline TBuf<S>& operator=(const TBuf<S>& aBuf);
sl@0	1506	private:
sl@0	1507	TText iBuf[__Align(S)];
sl@0	1508	};
sl@0	1509
sl@0	1510
sl@0	1511
sl@0	1512
sl@0	1513	/**
sl@0	1514	@publishedAll
sl@0	1515	@released
sl@0	1516
sl@0	1517	Value reference used in operator TLitC::__TRefDesC().
sl@0	1518
sl@0	1519	@see TRefByValue
sl@0	1520	*/
sl@0	1521	typedef TRefByValue<const TDesC> __TRefDesC;
sl@0	1522
sl@0	1523
sl@0	1524
sl@0	1525
sl@0	1526	/**
sl@0	1527	@publishedAll
sl@0	1528	@released
sl@0	1529
sl@0	1530	Encapsulates literal text.
sl@0	1531
sl@0	1532	This is always constructed using an _LIT macro.
sl@0	1533
sl@0	1534	This class is build independent; i.e. for a non-Unicode build, an 8-bit build
sl@0	1535	variant is generated; for a Unicode build, a 16 bit build variant is generated.
sl@0	1536
sl@0	1537	The class has no explicit constructors. See the _LIT macro definition.
sl@0	1538	*/
sl@0	1539	template <TInt S>
sl@0	1540	class TLitC
sl@0	1541	{
sl@0	1542	public:
sl@0	1543	/**
sl@0	1544	@internalComponent
sl@0	1545	*/
sl@0	1546	enum {BufferSize=S-1};
sl@0	1547	inline const TDesC* operator&() const;
sl@0	1548	inline operator const TDesC&() const;
sl@0	1549	inline const TDesC& operator()() const;
sl@0	1550	inline operator const __TRefDesC() const;
sl@0	1551	public:
sl@0	1552	#if !defined(_UNICODE) \|\| defined(__KERNEL_MODE__)
sl@0	1553
sl@0	1554	/**
sl@0	1555	@internalComponent
sl@0	1556	*/
sl@0	1557	typedef TUint8 __TText;
sl@0	1558	#elif defined(__GCC32__)
sl@0	1559
sl@0	1560	/**
sl@0	1561	@internalComponent
sl@0	1562	*/
sl@0	1563	typedef wchar_t __TText;
sl@0	1564	#elif defined(__VC32__)
sl@0	1565
sl@0	1566	/**
sl@0	1567	@internalComponent
sl@0	1568	*/
sl@0	1569	typedef wchar_t __TText;
sl@0	1570
sl@0	1571	#elif defined(__CW32__)
sl@0	1572
sl@0	1573	/**
sl@0	1574	@internalComponent
sl@0	1575	*/
sl@0	1576	typedef TUint16 __TText;
sl@0	1577	#elif !defined(__TText_defined)
sl@0	1578	#error no typedef for __TText
sl@0	1579	#endif
sl@0	1580	public:
sl@0	1581	/**
sl@0	1582	@internalComponent
sl@0	1583	*/
sl@0	1584	TUint iTypeLength;
sl@0	1585
sl@0	1586	/**
sl@0	1587	@internalComponent
sl@0	1588	*/
sl@0	1589	__TText iBuf[__Align(S)];
sl@0	1590	};
sl@0	1591
sl@0	1592
sl@0	1593	/**
sl@0	1594	@publishedAll
sl@0	1595	@released
sl@0	1596
sl@0	1597	Defines an empty or null literal descriptor.
sl@0	1598
sl@0	1599	This is the build independent form.
sl@0	1600	An 8 bit build variant is generated for a non-Unicode build;
sl@0	1601	a 16 bit build variant is generated for a Unicode build.
sl@0	1602	*/
sl@0	1603	_LIT(KNullDesC,"");
sl@0	1604
sl@0	1605
sl@0	1606
sl@0	1607	/**
sl@0	1608	@publishedAll
sl@0	1609	@released
sl@0	1610
sl@0	1611	Defines an empty or null literal descriptor for use with 8-bit descriptors.
sl@0	1612	*/
sl@0	1613	_LIT8(KNullDesC8,"");
sl@0	1614	#ifndef __KERNEL_MODE__
sl@0	1615
sl@0	1616
sl@0	1617
sl@0	1618	/**
sl@0	1619	@publishedAll
sl@0	1620	@released
sl@0	1621
sl@0	1622	Defines an empty or null literal descriptor for use with 16-bit descriptors
sl@0	1623	*/
sl@0	1624	_LIT16(KNullDesC16,"");
sl@0	1625	#endif
sl@0	1626
sl@0	1627
sl@0	1628
sl@0	1629
sl@0	1630	/**
sl@0	1631	@publishedAll
sl@0	1632	@released
sl@0	1633
sl@0	1634	Packages a non-modifiable pointer descriptor which represents an object of
sl@0	1635	specific type.
sl@0	1636
sl@0	1637	The template parameter defines the type of object.
sl@0	1638
sl@0	1639	The object represented by the packaged pointer descriptor is accessible through
sl@0	1640	the package but cannot be changed. */
sl@0	1641	template <class T>
sl@0	1642	class TPckgC : public TPtrC8
sl@0	1643	{
sl@0	1644	public:
sl@0	1645	inline TPckgC(const T& aRef);
sl@0	1646	inline const T& operator()() const;
sl@0	1647	private:
sl@0	1648	TPckgC<T>& operator=(const TPckgC<T>& aRef);
sl@0	1649	};
sl@0	1650
sl@0	1651
sl@0	1652
sl@0	1653
sl@0	1654	/**
sl@0	1655	@publishedAll
sl@0	1656	@released
sl@0	1657
sl@0	1658	Packages a modifiable pointer descriptor which represents an object of specific
sl@0	1659	type.
sl@0	1660
sl@0	1661	The template parameter defines the type of object.
sl@0	1662
sl@0	1663	The object represented by the packaged pointer descriptor is accessible through
sl@0	1664	the package.
sl@0	1665	*/
sl@0	1666	template <class T>
sl@0	1667	class TPckg : public TPtr8
sl@0	1668	{
sl@0	1669	public:
sl@0	1670	inline TPckg(const T& aRef);
sl@0	1671	inline T& operator()();
sl@0	1672	private:
sl@0	1673	TPckg<T>& operator=(const TPckg<T>& aRef);
sl@0	1674	};
sl@0	1675
sl@0	1676
sl@0	1677
sl@0	1678
sl@0	1679	/**
sl@0	1680	@publishedAll
sl@0	1681	@released
sl@0	1682
sl@0	1683	Packages an object into a modifiable buffer descriptor.
sl@0	1684
sl@0	1685	The template parameter defines the type of object to be packaged.
sl@0	1686
sl@0	1687	The package provides a type safe way of transferring an object or data structure
sl@0	1688	which is contained within a modifiable buffer descriptor. Typically, a package
sl@0	1689	is used for passing data via inter thread communication.
sl@0	1690
sl@0	1691	The contained object is accessible through the package.
sl@0	1692	*/
sl@0	1693	template <class T>
sl@0	1694	class TPckgBuf : public TAlignedBuf8<sizeof(T)>
sl@0	1695	{
sl@0	1696	public:
sl@0	1697	inline TPckgBuf();
sl@0	1698	inline TPckgBuf(const T& aRef);
sl@0	1699	inline TPckgBuf& operator=(const TPckgBuf<T>& aRef);
sl@0	1700	inline T& operator=(const T& aRef);
sl@0	1701	inline T& operator()();
sl@0	1702	inline const T& operator()() const;
sl@0	1703	};
sl@0	1704
sl@0	1705
sl@0	1706
sl@0	1707
sl@0	1708	/**
sl@0	1709	@publishedAll
sl@0	1710	@released
sl@0	1711
sl@0	1712	Defines a modifiable buffer descriptor that can contain the name of a reference
sl@0	1713	counting object.
sl@0	1714
sl@0	1715	@see TBuf
sl@0	1716	@see CObject
sl@0	1717	*/
sl@0	1718	typedef TBuf<KMaxName> TName;
sl@0	1719
sl@0	1720
sl@0	1721	/**
sl@0	1722	@publishedAll
sl@0	1723	@released
sl@0	1724
sl@0	1725	Defines a modifiable buffer descriptor that can contain the full name of a
sl@0	1726	reference counting object.
sl@0	1727
sl@0	1728	@see TBuf
sl@0	1729	@see CObject
sl@0	1730	*/
sl@0	1731	typedef TBuf<KMaxFullName> TFullName;
sl@0	1732
sl@0	1733
sl@0	1734
sl@0	1735	/**
sl@0	1736	@publishedAll
sl@0	1737	@released
sl@0	1738
sl@0	1739	Defines a modifiable buffer descriptor to contain the category name identifying
sl@0	1740	the cause of thread or process termination. The buffer takes a maximum length
sl@0	1741	of KMaxExitCategoryName.
sl@0	1742
sl@0	1743	@see RThread::ExitCategory
sl@0	1744	@see RThread::ExitCategory
sl@0	1745	*/
sl@0	1746	typedef TBuf<KMaxExitCategoryName> TExitCategoryName;
sl@0	1747
sl@0	1748
sl@0	1749
sl@0	1750	/**
sl@0	1751	@publishedAll
sl@0	1752	@released
sl@0	1753
sl@0	1754	A buffer that can contain the name of a file.
sl@0	1755	The name can have a maximum length of KMaxFileName
sl@0	1756	(currently 256 but check the definition of KMaxFileName).
sl@0	1757
sl@0	1758	@see KMaxFileName
sl@0	1759	*/
sl@0	1760	typedef TBuf<KMaxFileName> TFileName;
sl@0	1761
sl@0	1762
sl@0	1763
sl@0	1764	/**
sl@0	1765	@publishedAll
sl@0	1766	@released
sl@0	1767
sl@0	1768	A buffer that can contain the name of a path.
sl@0	1769	The name can have a maximum length of KMaxPath
sl@0	1770	(currently 256 but check the definition of KMaxPath).
sl@0	1771
sl@0	1772	@see KMaxPath
sl@0	1773	*/
sl@0	1774	typedef TBuf<KMaxPath> TPath;
sl@0	1775
sl@0	1776
sl@0	1777
sl@0	1778
sl@0	1779	/**
sl@0	1780	@publishedAll
sl@0	1781	@released
sl@0	1782
sl@0	1783	Version name type.
sl@0	1784
sl@0	1785	This is a buffer descriptor with a maximum length of KMaxVersionName.
sl@0	1786	A TVersion object returns the formatted character representation of its version
sl@0	1787	information in a descriptor of this type.
sl@0	1788
sl@0	1789	@see TVersion
sl@0	1790	*/
sl@0	1791	typedef TBuf<KMaxVersionName> TVersionName;
sl@0	1792
sl@0	1793
sl@0	1794
sl@0	1795
sl@0	1796	/**
sl@0	1797	@publishedAll
sl@0	1798	@released
sl@0	1799
sl@0	1800	Defines a modifiable buffer descriptor for the text form of the UID.
sl@0	1801	The descriptor has a maximum length of KMaxUidName and is used to contain
sl@0	1802	the standard text format returned by the function TUid::Name().
sl@0	1803
sl@0	1804	@see TUid::Name
sl@0	1805	*/
sl@0	1806	typedef TBuf<KMaxUidName> TUidName;
sl@0	1807
sl@0	1808
sl@0	1809
sl@0	1810
sl@0	1811	/**
sl@0	1812	@publishedAll
sl@0	1813	@released
sl@0	1814
sl@0	1815	Defines a null UID
sl@0	1816	*/
sl@0	1817	#define KNullUid TUid::Null()
sl@0	1818
sl@0	1819
sl@0	1820
sl@0	1821
sl@0	1822	/**
sl@0	1823	@publishedAll
sl@0	1824	@released
sl@0	1825
sl@0	1826	A globally unique 32-bit number.
sl@0	1827	*/
sl@0	1828	class TUid
sl@0	1829	{
sl@0	1830	public:
sl@0	1831	#ifndef __KERNEL_MODE__
sl@0	1832	IMPORT_C TBool operator==(const TUid& aUid) const;
sl@0	1833	IMPORT_C TBool operator!=(const TUid& aUid) const;
sl@0	1834	IMPORT_C TUidName Name() const;
sl@0	1835	#endif
sl@0	1836	static inline TUid Uid(TInt aUid);
sl@0	1837	static inline TUid Null();
sl@0	1838	public:
sl@0	1839	/**
sl@0	1840	The 32-bit integer UID value.
sl@0	1841	*/
sl@0	1842	TInt32 iUid;
sl@0	1843	};
sl@0	1844
sl@0	1845
sl@0	1846
sl@0	1847
sl@0	1848	/**
sl@0	1849	@publishedAll
sl@0	1850	@released
sl@0	1851
sl@0	1852	Encapsulates a set of three unique identifiers (UIDs) which, in combination,
sl@0	1853	identify a system object such as a GUI application or a DLL. The three
sl@0	1854	component UIDs are referred to as UID1, UID2 and UID3.
sl@0	1855
sl@0	1856	An object of this type is referred to as a compound identifier or a UID type.
sl@0	1857	*/
sl@0	1858	class TUidType
sl@0	1859	{
sl@0	1860	public:
sl@0	1861	#ifndef __KERNEL_MODE__
sl@0	1862	IMPORT_C TUidType();
sl@0	1863	IMPORT_C TUidType(TUid aUid1);
sl@0	1864	IMPORT_C TUidType(TUid aUid1,TUid aUid2);
sl@0	1865	IMPORT_C TUidType(TUid aUid1,TUid aUid2,TUid aUid3);
sl@0	1866	IMPORT_C TBool operator==(const TUidType& aUidType) const;
sl@0	1867	IMPORT_C TBool operator!=(const TUidType& aUidType) const;
sl@0	1868	IMPORT_C const TUid& operator[](TInt anIndex) const;
sl@0	1869	IMPORT_C TUid MostDerived() const;
sl@0	1870	IMPORT_C TBool IsPresent(TUid aUid) const;
sl@0	1871	IMPORT_C TBool IsValid() const;
sl@0	1872	private:
sl@0	1873	#endif
sl@0	1874	TUid iUid[KMaxCheckedUid];
sl@0	1875	};
sl@0	1876
sl@0	1877
sl@0	1878
sl@0	1879
sl@0	1880	/**
sl@0	1881	A class used to represent the Secure ID of a process or executable image.
sl@0	1882
sl@0	1883	Constructors and conversion operators are provided to enable conversion
sl@0	1884	of this class to and from both TUint32 and TUid objects.
sl@0	1885
sl@0	1886	Because this class has non-default constructors, compilers will not initialise
sl@0	1887	this objects at compile time, instead code will be generated to construct the object
sl@0	1888	at run-time. This is wastefull, and Symbian OS DLLs are not permitted to have
sl@0	1889	such uninitialised data. To overcome these problems a macro is provided to construct
sl@0	1890	a const object which behaves like a TSecureId. This is _LIT_SECURE_ID.
sl@0	1891	This macro should be used where it is desirable to define const TSecureId objects,
sl@0	1892	like in header files. E.g. Instead of writing:
sl@0	1893	@code
sl@0	1894	const TSecureId MyId=0x1234567
sl@0	1895	@endcode
sl@0	1896	use
sl@0	1897	@code
sl@0	1898	_LIT_SECURE_ID(MyId,0x1234567)
sl@0	1899	@endcode
sl@0	1900
sl@0	1901	@publishedAll
sl@0	1902	@released
sl@0	1903
sl@0	1904	@see _LIT_SECURE_ID
sl@0	1905	*/
sl@0	1906	class TSecureId
sl@0	1907	{
sl@0	1908	public:
sl@0	1909	inline TSecureId();
sl@0	1910	inline TSecureId(TUint32 aId);
sl@0	1911	inline operator TUint32() const;
sl@0	1912	inline TSecureId(TUid aId);
sl@0	1913	inline operator TUid() const;
sl@0	1914	public:
sl@0	1915	TUint32 iId;
sl@0	1916	};
sl@0	1917
sl@0	1918
sl@0	1919
sl@0	1920
sl@0	1921	/**
sl@0	1922	A class used to represent the Vendor ID of a process or executable image
sl@0	1923
sl@0	1924	Constructors and conversion operators are provided to enable conversion
sl@0	1925	of this class to and from both TUint32 and TUid objects.
sl@0	1926
sl@0	1927	Because this class has non-default constructors, compilers will not initialise
sl@0	1928	this objects at compile time, instead code will be generated to construct the object
sl@0	1929	at run-time. This is wastefull, and Symbian OS DLLs are not permitted to have
sl@0	1930	such uninitialised data. To overcome these problems a macro is provided to construct
sl@0	1931	a const object which behaves like a TSecureId. This is _LIT_VENDOR_ID.
sl@0	1932	This macro should be used where it is desirable to define const TSecureId objects,
sl@0	1933	like in header files. E.g. Instead of writing:
sl@0	1934	@code
sl@0	1935	const TVendorId MyId=0x1234567
sl@0	1936	@endcode
sl@0	1937	use
sl@0	1938	@code
sl@0	1939	_LIT_VENDOR_ID(MyId,0x1234567)
sl@0	1940	@endcode
sl@0	1941
sl@0	1942	@publishedAll
sl@0	1943	@released
sl@0	1944
sl@0	1945	@see _LIT_VENDOR_ID
sl@0	1946	*/
sl@0	1947	class TVendorId
sl@0	1948	{
sl@0	1949	public:
sl@0	1950	inline TVendorId();
sl@0	1951	inline TVendorId(TUint32 aId);
sl@0	1952	inline operator TUint32() const;
sl@0	1953	inline TVendorId(TUid aId);
sl@0	1954	inline operator TUid() const;
sl@0	1955	public:
sl@0	1956	TUint32 iId;
sl@0	1957	};
sl@0	1958
sl@0	1959
sl@0	1960
sl@0	1961	/**
sl@0	1962	Structure for compile-time definition of a secure ID
sl@0	1963	@internalComponent
sl@0	1964	*/
sl@0	1965	class SSecureId
sl@0	1966	{
sl@0	1967	public:
sl@0	1968	inline const TSecureId* operator&() const;
sl@0	1969	inline operator const TSecureId&() const;
sl@0	1970	inline operator TUint32() const;
sl@0	1971	inline operator TUid() const;
sl@0	1972	public:
sl@0	1973	TUint32 iId;
sl@0	1974	};
sl@0	1975
sl@0	1976
sl@0	1977
sl@0	1978
sl@0	1979	/**
sl@0	1980	Structure for compile-time definition of a vendor ID
sl@0	1981	@internalComponent
sl@0	1982	*/
sl@0	1983	class SVendorId
sl@0	1984	{
sl@0	1985	public:
sl@0	1986	inline const TVendorId* operator&() const;
sl@0	1987	inline operator const TVendorId&() const;
sl@0	1988	inline operator TUint32() const;
sl@0	1989	inline operator TUid() const;
sl@0	1990	public:
sl@0	1991	TUint32 iId;
sl@0	1992	};
sl@0	1993
sl@0	1994
sl@0	1995
sl@0	1996
sl@0	1997	/**
sl@0	1998	Macro for compile-time definition of a secure ID
sl@0	1999	@param name Name to use for secure ID
sl@0	2000	@param value Value of secure ID
sl@0	2001	@publishedAll
sl@0	2002	@released
sl@0	2003	*/
sl@0	2004	#define _LIT_SECURE_ID(name,value) const SSecureId name={value}
sl@0	2005
sl@0	2006
sl@0	2007
sl@0	2008
sl@0	2009	/**
sl@0	2010	Macro for compile-time definition of a vendor ID
sl@0	2011	@param name Name to use for vendor ID
sl@0	2012	@param value Value of vendor ID
sl@0	2013	@publishedAll
sl@0	2014	@released
sl@0	2015	*/
sl@0	2016	#define _LIT_VENDOR_ID(name,value) const SVendorId name={value}
sl@0	2017
sl@0	2018
sl@0	2019
sl@0	2020
sl@0	2021	/**
sl@0	2022	@publishedAll
sl@0	2023	@released
sl@0	2024
sl@0	2025	Contains version information.
sl@0	2026
sl@0	2027	A version is defined by a set of three numbers:
sl@0	2028
sl@0	2029	1. the major version number, ranging from 0 to 127, inclusive
sl@0	2030
sl@0	2031	2. the minor version number, ranging from 0 to 99 inclusive
sl@0	2032
sl@0	2033	3. the build number, ranging from 0 to 32767 inclusive.
sl@0	2034
sl@0	2035	The class provides a constructor for setting all three numbers.
sl@0	2036	It also provides a member function to build a character representation of
sl@0	2037	this information in a TVersionName descriptor.
sl@0	2038
sl@0	2039	@see TVersionName
sl@0	2040	*/
sl@0	2041	class TVersion
sl@0	2042	{
sl@0	2043	public:
sl@0	2044	IMPORT_C TVersion();
sl@0	2045	IMPORT_C TVersion(TInt aMajor,TInt aMinor,TInt aBuild);
sl@0	2046	IMPORT_C TVersionName Name() const;
sl@0	2047	public:
sl@0	2048	/**
sl@0	2049	The major version number.
sl@0	2050	*/
sl@0	2051	TInt8 iMajor;
sl@0	2052
sl@0	2053
sl@0	2054	/**
sl@0	2055	The minor version number.
sl@0	2056	*/
sl@0	2057	TInt8 iMinor;
sl@0	2058
sl@0	2059
sl@0	2060	/**
sl@0	2061	The build number.
sl@0	2062	*/
sl@0	2063	TInt16 iBuild;
sl@0	2064	};
sl@0	2065
sl@0	2066
sl@0	2067
sl@0	2068
sl@0	2069	/**
sl@0	2070	@publishedAll
sl@0	2071	@released
sl@0	2072
sl@0	2073	Indicates the completion status of a request made to a service provider.
sl@0	2074
sl@0	2075	When a thread makes a request, it passes a request status as a parameter.
sl@0	2076	On completion, the provider signals the requesting thread's request semaphore
sl@0	2077	and stores a completion code in the request status. Typically, this is KErrNone
sl@0	2078	or one of the other system-wide error codes.
sl@0	2079
sl@0	2080	This class is not intended for user derivation.
sl@0	2081	*/
sl@0	2082	class TRequestStatus
sl@0	2083	{
sl@0	2084	public:
sl@0	2085	inline TRequestStatus();
sl@0	2086	inline TRequestStatus(TInt aVal);
sl@0	2087	inline TInt operator=(TInt aVal);
sl@0	2088	inline TBool operator==(TInt aVal) const;
sl@0	2089	inline TBool operator!=(TInt aVal) const;
sl@0	2090	inline TBool operator>=(TInt aVal) const;
sl@0	2091	inline TBool operator<=(TInt aVal) const;
sl@0	2092	inline TBool operator>(TInt aVal) const;
sl@0	2093	inline TBool operator<(TInt aVal) const;
sl@0	2094	inline TInt Int() const;
sl@0	2095	private:
sl@0	2096	enum
sl@0	2097	{
sl@0	2098	EActive = 1, //bit0
sl@0	2099	ERequestPending = 2, //bit1
sl@0	2100	};
sl@0	2101	TInt iStatus;
sl@0	2102	TUint iFlags;
sl@0	2103	friend class CActive;
sl@0	2104	friend class CActiveScheduler;
sl@0	2105	friend class CServer2;
sl@0	2106	//SL: Added this so that upon request completion a thread can set iStatus without touching iFlag
sl@0	2107	//That stuff is usually probably handled by some exec call accessing the memory directly (just a guess)
sl@0	2108	//@see RThread::RequestComplete
sl@0	2109	friend class RThread;
sl@0	2110	};
sl@0	2111
sl@0	2112
sl@0	2113
sl@0	2114
sl@0	2115	class TSize;
sl@0	2116	/**
sl@0	2117	@publishedAll
sl@0	2118	@released
sl@0	2119
sl@0	2120	Stores a two-dimensional point in Cartesian co-ordinates.
sl@0	2121
sl@0	2122	Its data members (iX and iY) are public and can be manipulated directly, or
sl@0	2123	by means of the functions provided. Functions are provided to set and manipulate
sl@0	2124	the point, and to compare points for equality.
sl@0	2125	*/
sl@0	2126	class TPoint
sl@0	2127	{
sl@0	2128	public:
sl@0	2129	#ifndef __KERNEL_MODE__
sl@0	2130	enum TUninitialized { EUninitialized };
sl@0	2131	/**
sl@0	2132	Constructs default point, initialising its iX and iY members to zero.
sl@0	2133	*/
sl@0	2134	TPoint(TUninitialized) {}
sl@0	2135	inline TPoint();
sl@0	2136	inline TPoint(TInt aX,TInt aY);
sl@0	2137	IMPORT_C TBool operator==(const TPoint& aPoint) const;
sl@0	2138	IMPORT_C TBool operator!=(const TPoint& aPoint) const;
sl@0	2139	IMPORT_C TPoint& operator-=(const TPoint& aPoint);
sl@0	2140	IMPORT_C TPoint& operator+=(const TPoint& aPoint);
sl@0	2141	IMPORT_C TPoint& operator-=(const TSize& aSize);
sl@0	2142	IMPORT_C TPoint& operator+=(const TSize& aSize);
sl@0	2143	IMPORT_C TPoint operator-(const TPoint& aPoint) const;
sl@0	2144	IMPORT_C TPoint operator+(const TPoint& aPoint) const;
sl@0	2145	IMPORT_C TPoint operator-(const TSize& aSize) const;
sl@0	2146	IMPORT_C TPoint operator+(const TSize& aSize) const;
sl@0	2147	IMPORT_C TPoint operator-() const;
sl@0	2148	IMPORT_C void SetXY(TInt aX,TInt aY);
sl@0	2149	IMPORT_C TSize AsSize() const;
sl@0	2150	#endif
sl@0	2151	public:
sl@0	2152	/**
sl@0	2153	The x co-ordinate.
sl@0	2154	*/
sl@0	2155	TInt iX;
sl@0	2156	/**
sl@0	2157	The y co-ordinate.
sl@0	2158	*/
sl@0	2159	TInt iY;
sl@0	2160	};
sl@0	2161
sl@0	2162
sl@0	2163
sl@0	2164
sl@0	2165	/**
sl@0	2166	@publishedAll
sl@0	2167	@prototype
sl@0	2168
sl@0	2169	Stores a three-dimensional point in Cartesian or polar co-ordinates.
sl@0	2170	Its data members (iX, iY and iZ) are public and can be manipulated directly.
sl@0	2171
sl@0	2172	*/
sl@0	2173	class TPoint3D
sl@0	2174	{
sl@0	2175	public:
sl@0	2176	#ifndef __KERNEL_MODE__
sl@0	2177	enum TUninitialized { EUninitialized };
sl@0	2178
sl@0	2179	/**
sl@0	2180	TUninitialized Constructor
sl@0	2181	*/
sl@0	2182	TPoint3D(TUninitialized) {}
sl@0	2183	/**
sl@0	2184	Constructs default TPoint3D, initialising its iX , iY and iZ members to zero.
sl@0	2185	*/
sl@0	2186	inline TPoint3D();
sl@0	2187	/**
sl@0	2188	Constructs TPoint3D with the specified x,y and z co-ordinates.
sl@0	2189	*/
sl@0	2190	inline TPoint3D(TInt aX,TInt aY,TInt aZ);
sl@0	2191	/**
sl@0	2192	Copy Construct from TPoint , initialises Z co-ordinate to Zero
sl@0	2193	*/
sl@0	2194	inline TPoint3D(const TPoint& aPoint);
sl@0	2195
sl@0	2196	IMPORT_C TBool operator==(const TPoint3D& aPoint3D) const;
sl@0	2197	IMPORT_C TBool operator!=(const TPoint3D& aPoint3D) const;
sl@0	2198
sl@0	2199	IMPORT_C TPoint3D& operator-=(const TPoint3D& aPoint3D);
sl@0	2200	IMPORT_C TPoint3D& operator-=(const TPoint& aPoint);
sl@0	2201
sl@0	2202	IMPORT_C TPoint3D& operator+=(const TPoint3D& aPoint3D);
sl@0	2203	IMPORT_C TPoint3D& operator+=(const TPoint& aPoint);
sl@0	2204
sl@0	2205	IMPORT_C TPoint3D operator-(const TPoint3D& aPoint3D) const;
sl@0	2206	IMPORT_C TPoint3D operator-(const TPoint& aPoint) const;
sl@0	2207
sl@0	2208	IMPORT_C TPoint3D operator+(const TPoint3D& aPoint3D) const;
sl@0	2209	IMPORT_C TPoint3D operator+(const TPoint& aPoint) const;
sl@0	2210	/**
sl@0	2211	Unary minus operator. The operator returns the negation of this Point3D
sl@0	2212	*/
sl@0	2213	IMPORT_C TPoint3D operator-() const;
sl@0	2214
sl@0	2215	/**
sl@0	2216	Set Method to set the xyz co-ordinates of TPoint3D
sl@0	2217	*/
sl@0	2218	IMPORT_C void SetXYZ(TInt aX,TInt aY,TInt aZ);
sl@0	2219
sl@0	2220	/**
sl@0	2221	TPoint3D from TPoint, sets the Z co-ordinate to Zero
sl@0	2222	*/
sl@0	2223	IMPORT_C void SetPoint(const TPoint& aPoint);
sl@0	2224
sl@0	2225	/**
sl@0	2226	Returns TPoint from TPoint3D
sl@0	2227	*/
sl@0	2228	IMPORT_C TPoint AsPoint() const;
sl@0	2229	#endif
sl@0	2230	public:
sl@0	2231	/**
sl@0	2232	The x co-ordinate.
sl@0	2233	*/
sl@0	2234	TInt iX;
sl@0	2235	/**
sl@0	2236	The y co-ordinate.
sl@0	2237	*/
sl@0	2238	TInt iY;
sl@0	2239	/**
sl@0	2240	The z co-ordinate.
sl@0	2241	*/
sl@0	2242	TInt iZ;
sl@0	2243	};
sl@0	2244
sl@0	2245
sl@0	2246
sl@0	2247	/**
sl@0	2248	@internalTechnology
sl@0	2249	@prototype For now, only intended to be used by TRwEvent and the Windows Server
sl@0	2250
sl@0	2251	Stores the angular spherical coordinates (Phi,Theta) of a three-dimensional point.
sl@0	2252
sl@0	2253	Its data members (iPhi, iTheta) are public and can be manipulated directly.
sl@0	2254	*/
sl@0	2255	class TAngle3D
sl@0	2256	{
sl@0	2257	public:
sl@0	2258	/**
sl@0	2259	The Phi co-ordinate (angle between X-axis and the line that links the projection of the point on the X-Y plane and the origin).
sl@0	2260	*/
sl@0	2261	TInt iPhi;
sl@0	2262	/**
sl@0	2263	The Theta co-ordinate (angle between the Z-axis and the line that links the point and the origin).
sl@0	2264	*/
sl@0	2265	TInt iTheta;
sl@0	2266	};
sl@0	2267
sl@0	2268
sl@0	2269	/**
sl@0	2270	@publishedAll
sl@0	2271	@released
sl@0	2272
sl@0	2273	Stores a two-dimensional size as a width and a height value.
sl@0	2274
sl@0	2275	Its data members are public and can be manipulated directly, or by means of
sl@0	2276	the functions provided.
sl@0	2277	*/
sl@0	2278	class TSize
sl@0	2279	{
sl@0	2280	public:
sl@0	2281	#ifndef __KERNEL_MODE__
sl@0	2282	enum TUninitialized { EUninitialized };
sl@0	2283	/**
sl@0	2284	Constructs the size object with its iWidth and iHeight members set to zero.
sl@0	2285	*/
sl@0	2286	TSize(TUninitialized) {}
sl@0	2287	inline TSize();
sl@0	2288	inline TSize(TInt aWidth,TInt aHeight);
sl@0	2289	IMPORT_C TBool operator==(const TSize& aSize) const;
sl@0	2290	IMPORT_C TBool operator!=(const TSize& aSize) const;
sl@0	2291	IMPORT_C TSize& operator-=(const TSize& aSize);
sl@0	2292	IMPORT_C TSize& operator-=(const TPoint& aPoint);
sl@0	2293	IMPORT_C TSize& operator+=(const TSize& aSize);
sl@0	2294	IMPORT_C TSize& operator+=(const TPoint& aPoint);
sl@0	2295	IMPORT_C TSize operator-(const TSize& aSize) const;
sl@0	2296	IMPORT_C TSize operator-(const TPoint& aPoint) const;
sl@0	2297	IMPORT_C TSize operator+(const TSize& aSize) const;
sl@0	2298	IMPORT_C TSize operator+(const TPoint& aPoint) const;
sl@0	2299	IMPORT_C TSize operator-() const;
sl@0	2300	IMPORT_C void SetSize(TInt aWidth,TInt aHeight);
sl@0	2301	IMPORT_C TPoint AsPoint() const;
sl@0	2302	#endif
sl@0	2303	public:
sl@0	2304	/**
sl@0	2305	The width of this TSize object.
sl@0	2306	*/
sl@0	2307	TInt iWidth;
sl@0	2308	/**
sl@0	2309	The height of this TSize object.
sl@0	2310	*/
sl@0	2311	TInt iHeight;
sl@0	2312	};
sl@0	2313
sl@0	2314
sl@0	2315
sl@0	2316
sl@0	2317	/**
sl@0	2318	@publishedAll
sl@0	2319	@released
sl@0	2320
sl@0	2321	Information about a kernel object.
sl@0	2322
sl@0	2323	This type of object is passed to RHandleBase::HandleInfo(). The function
sl@0	2324	fetches information on the usage of the kernel object associated with that
sl@0	2325	handle and stores the information in the THandleInfo object.
sl@0	2326
sl@0	2327	The class contains four data members and no explicitly defined function
sl@0	2328	members.
sl@0	2329	*/
sl@0	2330	class THandleInfo
sl@0	2331	{
sl@0	2332	public:
sl@0	2333	/**
sl@0	2334	The number of times that the kernel object is open in the current process.
sl@0	2335	*/
sl@0	2336	TInt iNumOpenInProcess;
sl@0	2337
sl@0	2338	/**
sl@0	2339	The number of times that the kernel object is open in the current thread.
sl@0	2340	*/
sl@0	2341	TInt iNumOpenInThread;
sl@0	2342
sl@0	2343	/**
sl@0	2344	The number of processes which have a handle on the kernel object.
sl@0	2345	*/
sl@0	2346	TInt iNumProcesses;
sl@0	2347
sl@0	2348	/**
sl@0	2349	The number of threads which have a handle on the kernel object.
sl@0	2350	*/
sl@0	2351	TInt iNumThreads;
sl@0	2352	};
sl@0	2353
sl@0	2354
sl@0	2355
sl@0	2356
sl@0	2357	/**
sl@0	2358	@internalComponent
sl@0	2359	*/
sl@0	2360	class TFindHandle
sl@0	2361	{
sl@0	2362	public:
sl@0	2363	inline TFindHandle();
sl@0	2364	inline TInt Handle() const;
sl@0	2365	#ifdef __KERNEL_MODE__
sl@0	2366	inline TInt Index() const;
sl@0	2367	inline TInt UniqueID() const;
sl@0	2368	inline TUint64 ObjectID() const;
sl@0	2369	inline void Set(TInt aIndex, TInt aUniqueId, TUint64 aObjectId);
sl@0	2370	#else
sl@0	2371	protected:
sl@0	2372	inline void Reset();
sl@0	2373	#endif
sl@0	2374	private:
sl@0	2375	TInt iHandle;
sl@0	2376	TInt iSpare1;
sl@0	2377	TInt iObjectIdLow;
sl@0	2378	TInt iObjectIdHigh;
sl@0	2379	};
sl@0	2380
sl@0	2381
sl@0	2382
sl@0	2383	class RThread;
sl@0	2384	class TFindHandleBase;
sl@0	2385	class TFindSemaphore;
sl@0	2386	/**
sl@0	2387	@publishedAll
sl@0	2388	@released
sl@0	2389
sl@0	2390	A handle to an object.
sl@0	2391
sl@0	2392	The class encapsulates the basic behaviour of a handle, hiding the
sl@0	2393	handle-number which identifies the object which the handle represents.
sl@0	2394
sl@0	2395	The class is abstract in the sense that a RHandleBase object is never
sl@0	2396	explicitly instantiated. It is always a base class to a concrete handle class;
sl@0	2397	for example, RSemaphore, RThread, RProcess, RCriticalSection etc.
sl@0	2398	*/
sl@0	2399	class RHandleBase
sl@0	2400	{
sl@0	2401	public:
sl@0	2402	/**
sl@0	2403	@publishedAll
sl@0	2404	@released
sl@0	2405
sl@0	2406	Read/Write attributes for the handle.
sl@0	2407	*/
sl@0	2408	enum TAttributes
sl@0	2409	{
sl@0	2410	EReadAccess=0x1,
sl@0	2411	EWriteAccess=0x2,
sl@0	2412	EDirectReadAccess=0x4,
sl@0	2413	EDirectWriteAccess=0x8,
sl@0	2414	};
sl@0	2415	public:
sl@0	2416	inline RHandleBase();
sl@0	2417	inline TInt Handle() const;
sl@0	2418	inline void SetHandle(TInt aHandle);
sl@0	2419	inline TInt SetReturnedHandle(TInt aHandleOrError);
sl@0	2420	static void DoExtendedClose();
sl@0	2421	#ifndef __KERNEL_MODE__
sl@0	2422	IMPORT_C void Close();
sl@0	2423	IMPORT_C TName Name() const;
sl@0	2424	IMPORT_C TFullName FullName() const;
sl@0	2425	IMPORT_C void FullName(TDes& aName) const;
sl@0	2426	IMPORT_C void SetHandleNC(TInt aHandle);
sl@0	2427	IMPORT_C TInt Duplicate(const RThread& aSrc,TOwnerType aType=EOwnerProcess);
sl@0	2428	IMPORT_C void HandleInfo(THandleInfo* anInfo);
sl@0	2429	IMPORT_C TUint Attributes() const;
sl@0	2430	IMPORT_C TInt BTraceId() const;
sl@0	2431	IMPORT_C void NotifyDestruction(TRequestStatus& aStatus); /*< @internalTechnology /
sl@0	2432	protected:
sl@0	2433	inline RHandleBase(TInt aHandle);
sl@0	2434	IMPORT_C TInt Open(const TFindHandleBase& aHandle,TOwnerType aType);
sl@0	2435	static TInt SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle);
sl@0	2436	TInt OpenByName(const TDesC &aName,TOwnerType aOwnerType,TInt aObjectType);
sl@0	2437	#endif
sl@0	2438	private:
sl@0	2439	static void DoExtendedCloseL();
sl@0	2440	protected:
sl@0	2441	TInt iHandle;
sl@0	2442	};
sl@0	2443
sl@0	2444
sl@0	2445
sl@0	2446
sl@0	2447	class RMessagePtr2;
sl@0	2448	/**
sl@0	2449	@publishedAll
sl@0	2450	@released
sl@0	2451
sl@0	2452	A handle to a semaphore.
sl@0	2453
sl@0	2454	The semaphore itself is a Kernel side object.
sl@0	2455
sl@0	2456	As with all handles, they should be closed after use. RHandleBase provides
sl@0	2457	the necessary Close() function, which should be called when the handle is
sl@0	2458	no longer required.
sl@0	2459
sl@0	2460	@see RHandleBase::Close
sl@0	2461	*/
sl@0	2462	class RSemaphore : public RHandleBase
sl@0	2463	{
sl@0	2464	public:
sl@0	2465	#ifndef __KERNEL_MODE__
sl@0	2466	inline TInt Open(const TFindSemaphore& aFind,TOwnerType aType=EOwnerProcess);
sl@0	2467	IMPORT_C TInt CreateLocal(TInt aCount,TOwnerType aType=EOwnerProcess);
sl@0	2468	IMPORT_C TInt CreateGlobal(const TDesC& aName,TInt aCount,TOwnerType aType=EOwnerProcess);
sl@0	2469	IMPORT_C TInt OpenGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
sl@0	2470	IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
sl@0	2471	IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
sl@0	2472	IMPORT_C void Wait();
sl@0	2473	IMPORT_C TInt Wait(TInt aTimeout); // timeout in microseconds
sl@0	2474	IMPORT_C void Signal();
sl@0	2475	IMPORT_C void Signal(TInt aCount);
sl@0	2476	#endif
sl@0	2477	};
sl@0	2478
sl@0	2479
sl@0	2480
sl@0	2481
sl@0	2482	/**
sl@0	2483	@publishedAll
sl@0	2484	@released
sl@0	2485
sl@0	2486	A fast semaphore.
sl@0	2487
sl@0	2488	This is a layer over a standard semaphore, and only calls into the kernel side
sl@0	2489	if there is contention.
sl@0	2490	*/
sl@0	2491	class RFastLock : public RSemaphore
sl@0	2492	{
sl@0	2493	public:
sl@0	2494	inline RFastLock();
sl@0	2495	IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess);
sl@0	2496	IMPORT_C void Wait();
sl@0	2497	IMPORT_C void Signal();
sl@0	2498	private:
sl@0	2499	TInt iCount;
sl@0	2500	};
sl@0	2501
sl@0	2502
sl@0	2503
sl@0	2504
sl@0	2505	/**
sl@0	2506	@publishedAll
sl@0	2507	@released
sl@0	2508
sl@0	2509	A read-write lock.
sl@0	2510
sl@0	2511	This is a lock for co-ordinating readers and writers to shared resources.
sl@0	2512	It is designed to allow multiple concurrent readers.
sl@0	2513	It is not a kernel side object and so does not inherit from RHandleBase.
sl@0	2514	*/
sl@0	2515	class RReadWriteLock
sl@0	2516	{
sl@0	2517	public:
sl@0	2518	enum TReadWriteLockPriority
sl@0	2519	{
sl@0	2520	/** Pending writers always get the lock before pending readers */
sl@0	2521	EWriterPriority,
sl@0	2522	/** Lock is given alternately to pending readers and writers */
sl@0	2523	EAlternatePriority,
sl@0	2524	/** Pending readers always get the lock before pending writers - beware writer starvation! */
sl@0	2525	EReaderPriority,
sl@0	2526	};
sl@0	2527	enum TReadWriteLockClientCategoryLimit
sl@0	2528	{
sl@0	2529	/** Maximum number of clients in each category: read locked, read lock pending, write lock pending */
sl@0	2530	EReadWriteLockClientCategoryLimit = KMaxTUint16
sl@0	2531	};
sl@0	2532
sl@0	2533	public:
sl@0	2534	inline RReadWriteLock();
sl@0	2535	IMPORT_C TInt CreateLocal(TReadWriteLockPriority aPriority = EWriterPriority);
sl@0	2536	IMPORT_C void Close();
sl@0	2537
sl@0	2538	IMPORT_C void ReadLock();
sl@0	2539	IMPORT_C void WriteLock();
sl@0	2540	IMPORT_C TBool TryReadLock();
sl@0	2541	IMPORT_C TBool TryWriteLock();
sl@0	2542	IMPORT_C TBool TryUpgradeReadLock();
sl@0	2543	IMPORT_C void DowngradeWriteLock();
sl@0	2544	IMPORT_C void Unlock();
sl@0	2545
sl@0	2546	private:
sl@0	2547	RReadWriteLock(const RReadWriteLock& aLock);
sl@0	2548	RReadWriteLock& operator=(const RReadWriteLock& aLock);
sl@0	2549
sl@0	2550	TInt UnlockWriter();
sl@0	2551	TInt UnlockAlternate();
sl@0	2552	TInt UnlockReader();
sl@0	2553
sl@0	2554	private:
sl@0	2555	volatile TUint64 iValues; // Bits 0-15: readers; bit 16: writer; bits 32-47: readersPending; bits 48-63: writersPending
sl@0	2556	TReadWriteLockPriority iPriority;
sl@0	2557	RSemaphore iReaderSem;
sl@0	2558	RSemaphore iWriterSem;
sl@0	2559	TUint32 iSpare[4]; // Reserved for future development
sl@0	2560	};
sl@0	2561
sl@0	2562
sl@0	2563
sl@0	2564
sl@0	2565	/**
sl@0	2566	@publishedAll
sl@0	2567	@released
sl@0	2568
sl@0	2569	The user-side handle to a logical channel.
sl@0	2570
sl@0	2571	The class provides functions that are used to open a channel
sl@0	2572	to a device driver, and to make requests. A device driver provides
sl@0	2573	a derived class to give the user-side a tailored interface to the driver.
sl@0	2574	*/
sl@0	2575	class RBusLogicalChannel : public RHandleBase
sl@0	2576	{
sl@0	2577	public:
sl@0	2578	IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
sl@0	2579	IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
sl@0	2580	protected:
sl@0	2581	inline TInt DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* anInfo, TOwnerType aType=EOwnerProcess, TBool aProtected=EFalse);
sl@0	2582	IMPORT_C void DoCancel(TUint aReqMask);
sl@0	2583	IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus);
sl@0	2584	IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TAny* a1);
sl@0	2585	IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TAny* a1,TAny* a2);
sl@0	2586	IMPORT_C TInt DoControl(TInt aFunction);
sl@0	2587	IMPORT_C TInt DoControl(TInt aFunction,TAny* a1);
sl@0	2588	IMPORT_C TInt DoControl(TInt aFunction,TAny* a1,TAny* a2);
sl@0	2589	inline TInt DoSvControl(TInt aFunction) { return DoControl(aFunction); }
sl@0	2590	inline TInt DoSvControl(TInt aFunction,TAny* a1) { return DoControl(aFunction, a1); }
sl@0	2591	inline TInt DoSvControl(TInt aFunction,TAny* a1,TAny* a2) { return DoControl(aFunction, a1, a2); }
sl@0	2592	private:
sl@0	2593	IMPORT_C TInt DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TInt aType);
sl@0	2594	private:
sl@0	2595	// Padding for Binary Compatibility purposes
sl@0	2596	TInt iPadding1;
sl@0	2597	TInt iPadding2;
sl@0	2598	};
sl@0	2599
sl@0	2600
sl@0	2601
sl@0	2602
sl@0	2603	/**
sl@0	2604	@internalComponent
sl@0	2605
sl@0	2606	Base class for memory allocators.
sl@0	2607	*/
sl@0	2608	// Put pure virtual functions into a separate base class so that vptr is at same
sl@0	2609	// place in both GCC98r2 and EABI builds.
sl@0	2610	class MAllocator
sl@0	2611	{
sl@0	2612	public:
sl@0	2613	virtual TAny* Alloc(TInt aSize)=0;
sl@0	2614	virtual void Free(TAny* aPtr)=0;
sl@0	2615	virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0)=0;
sl@0	2616	virtual TInt AllocLen(const TAny* aCell) const =0;
sl@0	2617	virtual TInt Compress()=0;
sl@0	2618	virtual void Reset()=0;
sl@0	2619	virtual TInt AllocSize(TInt& aTotalAllocSize) const =0;
sl@0	2620	virtual TInt Available(TInt& aBiggestBlock) const =0;
sl@0	2621	virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL)=0;
sl@0	2622	virtual TInt Extension_(TUint aExtensionId, TAny& a0, TAny a1)=0;
sl@0	2623	};
sl@0	2624
sl@0	2625
sl@0	2626
sl@0	2627
sl@0	2628	/**
sl@0	2629	@publishedAll
sl@0	2630	@released
sl@0	2631
sl@0	2632	Base class for heaps.
sl@0	2633	*/
sl@0	2634	class RAllocator : public MAllocator
sl@0	2635	{
sl@0	2636	public:
sl@0	2637
sl@0	2638
sl@0	2639	/**
sl@0	2640	A set of heap allocation failure flags.
sl@0	2641
sl@0	2642	This enumeration indicates how to simulate heap allocation failure.
sl@0	2643
sl@0	2644	@see RAllocator::__DbgSetAllocFail()
sl@0	2645	*/
sl@0	2646	enum TAllocFail {
sl@0	2647	/**
sl@0	2648	Attempts to allocate from this heap fail at a random rate;
sl@0	2649	however, the interval pattern between failures is the same
sl@0	2650	every time simulation is started.
sl@0	2651	*/
sl@0	2652	ERandom,
sl@0	2653
sl@0	2654
sl@0	2655	/**
sl@0	2656	Attempts to allocate from this heap fail at a random rate.
sl@0	2657	The interval pattern between failures may be different every
sl@0	2658	time the simulation is started.
sl@0	2659	*/
sl@0	2660	ETrueRandom,
sl@0	2661
sl@0	2662
sl@0	2663	/**
sl@0	2664	Attempts to allocate from this heap fail at a rate aRate;
sl@0	2665	for example, if aRate is 3, allocation fails at every
sl@0	2666	third attempt.
sl@0	2667	*/
sl@0	2668	EDeterministic,
sl@0	2669
sl@0	2670
sl@0	2671	/**
sl@0	2672	Cancels simulated heap allocation failure.
sl@0	2673	*/
sl@0	2674	ENone,
sl@0	2675
sl@0	2676
sl@0	2677	/**
sl@0	2678	An allocation from this heap will fail after the next aRate - 1
sl@0	2679	allocation attempts. For example, if aRate = 1 then the next
sl@0	2680	attempt to allocate from this heap will fail.
sl@0	2681	*/
sl@0	2682	EFailNext,
sl@0	2683
sl@0	2684	/**
sl@0	2685	Cancels simulated heap allocation failure, and sets
sl@0	2686	the nesting level for all allocated cells to zero.
sl@0	2687	*/
sl@0	2688	EReset,
sl@0	2689
sl@0	2690	/**
sl@0	2691	aBurst allocations from this heap fail at a random rate;
sl@0	2692	however, the interval pattern between failures is the same
sl@0	2693	every time the simulation is started.
sl@0	2694	*/
sl@0	2695	EBurstRandom,
sl@0	2696
sl@0	2697
sl@0	2698	/**
sl@0	2699	aBurst allocations from this heap fail at a random rate.
sl@0	2700	The interval pattern between failures may be different every
sl@0	2701	time the simulation is started.
sl@0	2702	*/
sl@0	2703	EBurstTrueRandom,
sl@0	2704
sl@0	2705
sl@0	2706	/**
sl@0	2707	aBurst allocations from this heap fail at a rate aRate.
sl@0	2708	For example, if aRate is 10 and aBurst is 2, then 2 allocations
sl@0	2709	will fail at every tenth attempt.
sl@0	2710	*/
sl@0	2711	EBurstDeterministic,
sl@0	2712
sl@0	2713	/**
sl@0	2714	aBurst allocations from this heap will fail after the next aRate - 1
sl@0	2715	allocation attempts have occurred. For example, if aRate = 1 and
sl@0	2716	aBurst = 3 then the next 3 attempts to allocate from this heap will fail.
sl@0	2717	*/
sl@0	2718	EBurstFailNext,
sl@0	2719
sl@0	2720	/**
sl@0	2721	Use this to determine how many times the current debug
sl@0	2722	failure mode has failed so far.
sl@0	2723	@see RAllocator::__DbgCheckFailure()
sl@0	2724	*/
sl@0	2725	ECheckFailure,
sl@0	2726	};
sl@0	2727
sl@0	2728
sl@0	2729	/**
sl@0	2730	Heap debug checking type flag.
sl@0	2731	*/
sl@0	2732	enum TDbgHeapType {
sl@0	2733	/**
sl@0	2734	The heap is a user heap.
sl@0	2735	*/
sl@0	2736	EUser,
sl@0	2737
sl@0	2738	/**
sl@0	2739	The heap is the Kernel heap.
sl@0	2740	*/
sl@0	2741	EKernel
sl@0	2742	};
sl@0	2743
sl@0	2744
sl@0	2745	enum TAllocDebugOp {ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail};
sl@0	2746
sl@0	2747
sl@0	2748	/**
sl@0	2749	Flags controlling reallocation.
sl@0	2750	*/
sl@0	2751	enum TReAllocMode {
sl@0	2752	/**
sl@0	2753	A reallocation of a cell must not change
sl@0	2754	the start address of the cell.
sl@0	2755	*/
sl@0	2756	ENeverMove=1,
sl@0	2757
sl@0	2758	/**
sl@0	2759	Allows the start address of the cell to change
sl@0	2760	if the cell shrinks in size.
sl@0	2761	*/
sl@0	2762	EAllowMoveOnShrink=2
sl@0	2763	};
sl@0	2764
sl@0	2765
sl@0	2766	enum TFlags {ESingleThreaded=1, EFixedSize=2, ETraceAllocs=4, EMonitorMemory=8,};
sl@0	2767	struct SCheckInfo {TBool iAll; TInt iCount; const TDesC8* iFileName; TInt iLineNum;};
sl@0	2768	#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
sl@0	2769	struct SRAllocatorBurstFail {TInt iBurst; TInt iRate; TInt iUnused[2];};
sl@0	2770	#endif
sl@0	2771	enum {EMaxHandles=32};
sl@0	2772
sl@0	2773	public:
sl@0	2774	inline RAllocator();
sl@0	2775	#ifndef __KERNEL_MODE__
sl@0	2776	IMPORT_C TInt Open();
sl@0	2777	IMPORT_C void Close();
sl@0	2778	IMPORT_C TAny* AllocZ(TInt aSize);
sl@0	2779	IMPORT_C TAny* AllocZL(TInt aSize);
sl@0	2780	IMPORT_C TAny* AllocL(TInt aSize);
sl@0	2781	IMPORT_C TAny* AllocLC(TInt aSize);
sl@0	2782	IMPORT_C void FreeZ(TAny*& aCell);
sl@0	2783	IMPORT_C TAny* ReAllocL(TAny* aCell, TInt aSize, TInt aMode=0);
sl@0	2784	IMPORT_C TInt Count() const;
sl@0	2785	IMPORT_C TInt Count(TInt& aFreeCount) const;
sl@0	2786	#endif
sl@0	2787	UIMPORT_C void Check() const;
sl@0	2788	UIMPORT_C void __DbgMarkStart();
sl@0	2789	UIMPORT_C TUint32 __DbgMarkEnd(TInt aCount);
sl@0	2790	UIMPORT_C TInt __DbgMarkCheck(TBool aCountAll, TInt aCount, const TDesC8& aFileName, TInt aLineNum);
sl@0	2791	inline void __DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum);
sl@0	2792	UIMPORT_C void __DbgSetAllocFail(TAllocFail aType, TInt aRate);
sl@0	2793	UIMPORT_C void __DbgSetBurstAllocFail(TAllocFail aType, TUint aRate, TUint aBurst);
sl@0	2794	UIMPORT_C TUint __DbgCheckFailure();
sl@0	2795	protected:
sl@0	2796	UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny& a0, TAny a1);
sl@0	2797	#ifndef __KERNEL_MODE__
sl@0	2798	IMPORT_C virtual void DoClose();
sl@0	2799	#endif
sl@0	2800	protected:
sl@0	2801	TInt iAccessCount;
sl@0	2802	TInt iHandleCount;
sl@0	2803	TInt* iHandles;
sl@0	2804	TUint32 iFlags;
sl@0	2805	TInt iCellCount;
sl@0	2806	TInt iTotalAllocSize;
sl@0	2807	};
sl@0	2808
sl@0	2809
sl@0	2810
sl@0	2811
sl@0	2812	class UserHeap;
sl@0	2813	/**
sl@0	2814	@publishedAll
sl@0	2815	@released
sl@0	2816
sl@0	2817	Represents the default implementation for a heap.
sl@0	2818
sl@0	2819	The default implementation uses an address-ordered first fit type algorithm.
sl@0	2820
sl@0	2821	The heap itself is contained in a chunk and may be the only occupant of the
sl@0	2822	chunk or may share the chunk with the program stack.
sl@0	2823
sl@0	2824	The class contains member functions for allocating, adjusting, freeing individual
sl@0	2825	cells and generally managing the heap.
sl@0	2826
sl@0	2827	The class is not a handle in the same sense that RChunk is a handle; i.e.
sl@0	2828	there is no Kernel object which corresponds to the heap.
sl@0	2829	*/
sl@0	2830	class RHeap : public RAllocator
sl@0	2831	{
sl@0	2832	public:
sl@0	2833	/**
sl@0	2834	The structure of a heap cell header for a heap cell on the free list.
sl@0	2835	*/
sl@0	2836	struct SCell {
sl@0	2837	/**
sl@0	2838	The length of the cell, which includes the length of
sl@0	2839	this header.
sl@0	2840	*/
sl@0	2841	TInt len;
sl@0	2842
sl@0	2843
sl@0	2844	/**
sl@0	2845	A pointer to the next cell in the free list.
sl@0	2846	*/
sl@0	2847	SCell* next;
sl@0	2848	};
sl@0	2849
sl@0	2850
sl@0	2851	/**
sl@0	2852	The structure of a heap cell header for an allocated heap cell in a debug build.
sl@0	2853	*/
sl@0	2854	struct SDebugCell {
sl@0	2855	/**
sl@0	2856	The length of the cell, which includes the length of
sl@0	2857	this header.
sl@0	2858	*/
sl@0	2859	TInt len;
sl@0	2860
sl@0	2861
sl@0	2862	/**
sl@0	2863	The nested level.
sl@0	2864	*/
sl@0	2865	TInt nestingLevel;
sl@0	2866
sl@0	2867
sl@0	2868	/**
sl@0	2869	The cumulative number of allocated cells
sl@0	2870	*/
sl@0	2871	TInt allocCount;
sl@0	2872	};
sl@0	2873
sl@0	2874	/**
sl@0	2875	@internalComponent
sl@0	2876	*/
sl@0	2877	struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc; TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; };
sl@0	2878
sl@0	2879	/**
sl@0	2880	@internalComponent
sl@0	2881	*/
sl@0	2882	struct _s_align {char c; double d;};
sl@0	2883
sl@0	2884	/**
sl@0	2885	The default cell alignment.
sl@0	2886	*/
sl@0	2887	enum {ECellAlignment = sizeof(_s_align)-sizeof(double)};
sl@0	2888
sl@0	2889	/**
sl@0	2890	Size of a free cell header.
sl@0	2891	*/
sl@0	2892	enum {EFreeCellSize = sizeof(SCell)};
sl@0	2893
sl@0	2894
sl@0	2895	#ifdef _DEBUG
sl@0	2896	/**
sl@0	2897	Size of an allocated cell header in a debug build.
sl@0	2898	*/
sl@0	2899	enum {EAllocCellSize = sizeof(SDebugCell)};
sl@0	2900	#else
sl@0	2901	/**
sl@0	2902	Size of an allocated cell header in a release build.
sl@0	2903	*/
sl@0	2904	enum {EAllocCellSize = sizeof(SCell*)};
sl@0	2905	#endif
sl@0	2906
sl@0	2907
sl@0	2908	/**
sl@0	2909	@internalComponent
sl@0	2910	*/
sl@0	2911	enum TDebugOp {EWalk=128};
sl@0	2912
sl@0	2913
sl@0	2914	/**
sl@0	2915	@internalComponent
sl@0	2916	*/
sl@0	2917	enum TCellType
sl@0	2918	{EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress,
sl@0	2919	EBadFreeCellAddress, EBadFreeCellSize};
sl@0	2920
sl@0	2921
sl@0	2922	/**
sl@0	2923	@internalComponent
sl@0	2924	*/
sl@0	2925	enum TDebugHeapId {EUser=0, EKernel=1};
sl@0	2926
sl@0	2927	/**
sl@0	2928	@internalComponent
sl@0	2929	*/
sl@0	2930	enum TDefaultShrinkRatios {EShrinkRatio1=256, EShrinkRatioDflt=512};
sl@0	2931
sl@0	2932	#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
sl@0	2933	/**
sl@0	2934	@internalComponent
sl@0	2935	*/
sl@0	2936	#else
sl@0	2937	private:
sl@0	2938	#endif
sl@0	2939	typedef void (TWalkFunc)(TAny, TCellType, TAny*, TInt);
sl@0	2940
sl@0	2941	public:
sl@0	2942	UIMPORT_C virtual TAny* Alloc(TInt aSize);
sl@0	2943	UIMPORT_C virtual void Free(TAny* aPtr);
sl@0	2944	UIMPORT_C virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0);
sl@0	2945	UIMPORT_C virtual TInt AllocLen(const TAny* aCell) const;
sl@0	2946	#ifndef __KERNEL_MODE__
sl@0	2947	UIMPORT_C virtual TInt Compress();
sl@0	2948	UIMPORT_C virtual void Reset();
sl@0	2949	UIMPORT_C virtual TInt AllocSize(TInt& aTotalAllocSize) const;
sl@0	2950	UIMPORT_C virtual TInt Available(TInt& aBiggestBlock) const;
sl@0	2951	#endif
sl@0	2952	UIMPORT_C virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL);
sl@0	2953	protected:
sl@0	2954	UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny& a0, TAny a1);
sl@0	2955	public:
sl@0	2956	UIMPORT_C RHeap(TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);
sl@0	2957	UIMPORT_C RHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign=0, TBool aSingleThread=EFalse);
sl@0	2958	UIMPORT_C TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;
sl@0	2959	inline void operator delete(TAny* aPtr, TAny* aBase);
sl@0	2960	inline TUint8* Base() const;
sl@0	2961	inline TInt Size() const;
sl@0	2962	inline TInt MaxLength() const;
sl@0	2963	inline TInt Align(TInt a) const;
sl@0	2964	inline const TAny* Align(const TAny* a) const;
sl@0	2965	inline TBool IsLastCell(const SCell* aCell) const;
sl@0	2966	inline void Lock() const;
sl@0	2967	inline void Unlock() const;
sl@0	2968	inline TInt ChunkHandle() const;
sl@0	2969	protected:
sl@0	2970	inline RHeap();
sl@0	2971	void Initialise();
sl@0	2972	SCell* DoAlloc(TInt aSize, SCell*& aLastFree);
sl@0	2973	void DoFree(SCell* pC);
sl@0	2974	TInt TryToGrowHeap(TInt aSize, SCell* aLastFree);
sl@0	2975	inline void FindFollowingFreeCell(SCell* aCell, SCell& pPrev, SCell& aNext);
sl@0	2976	TInt TryToGrowCell(SCell* pC, SCell* pP, SCell* pE, TInt aSize);
sl@0	2977	TInt Reduce(SCell* aCell);
sl@0	2978	UIMPORT_C SCell* GetAddress(const TAny* aCell) const;
sl@0	2979	void CheckCell(const SCell* aCell) const;
sl@0	2980	void Walk(TWalkFunc aFunc, TAny* aPtr);
sl@0	2981	static void WalkCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen);
sl@0	2982	TInt DoCountAllocFree(TInt& aFree);
sl@0	2983	TInt DoCheckHeap(SCheckInfo* aInfo);
sl@0	2984	void DoMarkStart();
sl@0	2985	TUint32 DoMarkEnd(TInt aExpected);
sl@0	2986	void DoSetAllocFail(TAllocFail aType, TInt aRate);
sl@0	2987	TBool CheckForSimulatedAllocFail();
sl@0	2988	inline TInt SetBrk(TInt aBrk);
sl@0	2989	inline TAny* ReAllocImpl(TAny* aPtr, TInt aSize, TInt aMode);
sl@0	2990	void DoSetAllocFail(TAllocFail aType, TInt aRate, TUint aBurst);
sl@0	2991	protected:
sl@0	2992	TInt iMinLength;
sl@0	2993	TInt iMaxLength;
sl@0	2994	TInt iOffset;
sl@0	2995	TInt iGrowBy;
sl@0	2996	TInt iChunkHandle;
sl@0	2997	RFastLock iLock;
sl@0	2998	TUint8* iBase;
sl@0	2999	TUint8* iTop;
sl@0	3000	TInt iAlign;
sl@0	3001	TInt iMinCell;
sl@0	3002	TInt iPageSize;
sl@0	3003	SCell iFree;
sl@0	3004	protected:
sl@0	3005	TInt iNestingLevel;
sl@0	3006	TInt iAllocCount;
sl@0	3007	TAllocFail iFailType;
sl@0	3008	TInt iFailRate;
sl@0	3009	TBool iFailed;
sl@0	3010	TInt iFailAllocCount;
sl@0	3011	TInt iRand;
sl@0	3012	TAny* iTestData;
sl@0	3013
sl@0	3014	friend class UserHeap;
sl@0	3015	};
sl@0	3016
sl@0	3017
sl@0	3018
sl@0	3019
sl@0	3020
sl@0	3021	class OnlyCreateWithNull;
sl@0	3022
sl@0	3023	/** @internalTechnology */
sl@0	3024	typedef void (OnlyCreateWithNull::* __NullPMF)();
sl@0	3025
sl@0	3026	/** @internalTechnology */
sl@0	3027	class OnlyCreateWithNull
sl@0	3028	{
sl@0	3029	public:
sl@0	3030	inline OnlyCreateWithNull(__NullPMF /aPointerToNull/) {}
sl@0	3031	};
sl@0	3032
sl@0	3033	/**
sl@0	3034	@publishedAll
sl@0	3035	@released
sl@0	3036
sl@0	3037	A handle to a message sent by the client to the server.
sl@0	3038
sl@0	3039	A server's interaction with its clients is channelled through an RMessagePtr2
sl@0	3040	object, which acts as a handle to a message sent by the client.
sl@0	3041	The details of the original message are kept by the kernel allowing it enforce
sl@0	3042	correct usage of the member functions of this class.
sl@0	3043
sl@0	3044	@see RMessage2
sl@0	3045	*/
sl@0	3046	class RMessagePtr2
sl@0	3047	{
sl@0	3048	public:
sl@0	3049	inline RMessagePtr2();
sl@0	3050	inline TBool IsNull() const;
sl@0	3051	inline TInt Handle() const;
sl@0	3052	#ifndef __KERNEL_MODE__
sl@0	3053	IMPORT_C void Complete(TInt aReason) const;
sl@0	3054	IMPORT_C void Complete(RHandleBase aHandle) const;
sl@0	3055	IMPORT_C TInt GetDesLength(TInt aParam) const;
sl@0	3056	IMPORT_C TInt GetDesLengthL(TInt aParam) const;
sl@0	3057	IMPORT_C TInt GetDesMaxLength(TInt aParam) const;
sl@0	3058	IMPORT_C TInt GetDesMaxLengthL(TInt aParam) const;
sl@0	3059	IMPORT_C void ReadL(TInt aParam,TDes8& aDes,TInt aOffset=0) const;
sl@0	3060	IMPORT_C void ReadL(TInt aParam,TDes16 &aDes,TInt aOffset=0) const;
sl@0	3061	IMPORT_C void WriteL(TInt aParam,const TDesC8& aDes,TInt aOffset=0) const;
sl@0	3062	IMPORT_C void WriteL(TInt aParam,const TDesC16& aDes,TInt aOffset=0) const;
sl@0	3063	IMPORT_C TInt Read(TInt aParam,TDes8& aDes,TInt aOffset=0) const;
sl@0	3064	IMPORT_C TInt Read(TInt aParam,TDes16 &aDes,TInt aOffset=0) const;
sl@0	3065	IMPORT_C TInt Write(TInt aParam,const TDesC8& aDes,TInt aOffset=0) const;
sl@0	3066	IMPORT_C TInt Write(TInt aParam,const TDesC16& aDes,TInt aOffset=0) const;
sl@0	3067	IMPORT_C void Panic(const TDesC& aCategory,TInt aReason) const;
sl@0	3068	IMPORT_C void Kill(TInt aReason) const;
sl@0	3069	IMPORT_C void Terminate(TInt aReason) const;
sl@0	3070	IMPORT_C TInt SetProcessPriority(TProcessPriority aPriority) const;
sl@0	3071	inline void SetProcessPriorityL(TProcessPriority aPriority) const;
sl@0	3072	IMPORT_C TInt Client(RThread& aClient, TOwnerType aOwnerType=EOwnerProcess) const;
sl@0	3073	inline void ClientL(RThread& aClient, TOwnerType aOwnerType=EOwnerProcess) const;
sl@0	3074	IMPORT_C TUint ClientProcessFlags() const;
sl@0	3075	IMPORT_C const TRequestStatus* ClientStatus() const;
sl@0	3076	IMPORT_C TBool ClientIsRealtime() const;
sl@0	3077
sl@0	3078	/**
sl@0	3079	Return the Secure ID of the process which sent this message.
sl@0	3080
sl@0	3081	If an intended use of this method is to check that the Secure ID is
sl@0	3082	a given value, then the use of a TSecurityPolicy object should be
sl@0	3083	considered. E.g. Instead of something like:
sl@0	3084
sl@0	3085	@code
sl@0	3086	RMessagePtr2& message;
sl@0	3087	TInt error = message.SecureId()==KRequiredSecureId ? KErrNone : KErrPermissionDenied;
sl@0	3088	@endcode
sl@0	3089
sl@0	3090	this could be used;
sl@0	3091
sl@0	3092	@code
sl@0	3093	RMessagePtr2& message;
sl@0	3094	static _LIT_SECURITY_POLICY_S0(mySidPolicy, KRequiredSecureId);
sl@0	3095	TBool pass = mySidPolicy().CheckPolicy(message);
sl@0	3096	@endcode
sl@0	3097
sl@0	3098	This has the benefit that the TSecurityPolicy::CheckPolicy methods are
sl@0	3099	configured by the system wide Platform Security configuration. I.e. are
sl@0	3100	capable of emitting diagnostic messages when a check fails and/or the
sl@0	3101	check can be forced to always pass.
sl@0	3102
sl@0	3103	@see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
sl@0	3104	@see _LIT_SECURITY_POLICY_S0
sl@0	3105
sl@0	3106	@return The Secure ID.
sl@0	3107
sl@0	3108	@publishedAll
sl@0	3109	@released
sl@0	3110	*/
sl@0	3111	IMPORT_C TSecureId SecureId() const;
sl@0	3112
sl@0	3113	/**
sl@0	3114	Return the Vendor ID of the process which sent this message.
sl@0	3115
sl@0	3116	If an intended use of this method is to check that the Vendor ID is
sl@0	3117	a given value, then the use of a TSecurityPolicy object should be
sl@0	3118	considered. E.g. Instead of something like:
sl@0	3119
sl@0	3120	@code
sl@0	3121	RMessagePtr2& message;
sl@0	3122	TInt error = message.VendorId()==KRequiredVendorId ? KErrNone : KErrPermissionDenied;
sl@0	3123	@endcode
sl@0	3124
sl@0	3125	this could be used;
sl@0	3126
sl@0	3127	@code
sl@0	3128	RMessagePtr2& message;
sl@0	3129	static _LIT_SECURITY_POLICY_V0(myVidPolicy, KRequiredVendorId);
sl@0	3130	TBool pass = myVidPolicy().CheckPolicy(message);
sl@0	3131	@endcode
sl@0	3132
sl@0	3133	This has the benefit that the TSecurityPolicy::CheckPolicy methods are
sl@0	3134	configured by the system wide Platform Security configuration. I.e. are
sl@0	3135	capable of emitting diagnostic messages when a check fails and/or the
sl@0	3136	check can be forced to always pass.
sl@0	3137
sl@0	3138	@see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
sl@0	3139	@see _LIT_SECURITY_POLICY_V0
sl@0	3140
sl@0	3141	@return The Vendor ID.
sl@0	3142	@publishedAll
sl@0	3143	@released
sl@0	3144	*/
sl@0	3145	IMPORT_C TVendorId VendorId() const;
sl@0	3146
sl@0	3147	/**
sl@0	3148	Check if the process which sent this message has a given capability.
sl@0	3149
sl@0	3150	When a check fails the action taken is determined by the system wide Platform Security
sl@0	3151	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0	3152	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0	3153	check failed.
sl@0	3154
sl@0	3155	@param aCapability The capability to test.
sl@0	3156	@param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0	3157	that may be issued if the test finds the capability is not present.
sl@0	3158	This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0	3159	which enables it to be easily removed from the system.
sl@0	3160	@return ETrue if process which sent this message has the capability, EFalse otherwise.
sl@0	3161	@publishedAll
sl@0	3162	@released
sl@0	3163	*/
sl@0	3164	#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3165	inline TBool HasCapability(TCapability aCapability, const char* aDiagnostic=0) const;
sl@0	3166	#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3167	// Only available to NULL arguments
sl@0	3168	inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3169	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3170	// For things using KSuppressPlatSecDiagnostic
sl@0	3171	inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3172	#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3173	#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3174
sl@0	3175	/**
sl@0	3176	Check if the process which sent this message has a given capability.
sl@0	3177
sl@0	3178	When a check fails the action taken is determined by the system wide Platform Security
sl@0	3179	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0	3180	If PlatSecEnforcement is OFF, then this function will not leave even though the
sl@0	3181	check failed.
sl@0	3182
sl@0	3183	@param aCapability The capability to test.
sl@0	3184	@param aDiagnosticMessage A string that will be emitted along with any diagnostic message
sl@0	3185	that may be issued if the test finds the capability is not present.
sl@0	3186	This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0	3187	which enables it to be easily removed from the system.
sl@0	3188	@leave KErrPermissionDenied, if the process does not have the capability.
sl@0	3189	@publishedAll
sl@0	3190	@released
sl@0	3191	*/
sl@0	3192	#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3193	inline void HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage=0) const;
sl@0	3194	#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3195	// Only available to NULL arguments
sl@0	3196	inline void HasCapabilityL(TCapability aCapability, OnlyCreateWithNull aDiagnosticMessage=NULL) const;
sl@0	3197	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3198	// For things using KSuppressPlatSecDiagnostic
sl@0	3199	inline void HasCapabilityL(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3200	#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3201	#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3202
sl@0	3203	/**
sl@0	3204	Check if the process which sent this message has both of the given capabilities.
sl@0	3205
sl@0	3206	When a check fails the action taken is determined by the system wide Platform Security
sl@0	3207	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0	3208	If PlatSecEnforcement is OFF, then this function will return ETrue even though the
sl@0	3209	check failed.
sl@0	3210
sl@0	3211	@param aCapability1 The first capability to test.
sl@0	3212	@param aCapability2 The second capability to test.
sl@0	3213	@param aDiagnostic A string that will be emitted along with any diagnostic message
sl@0	3214	that may be issued if the test finds a capability is not present.
sl@0	3215	This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0	3216	which enables it to be easily removed from the system.
sl@0	3217	@return ETrue if the process which sent this message has both the capabilities, EFalse otherwise.
sl@0	3218	@publishedAll
sl@0	3219	@released
sl@0	3220	*/
sl@0	3221	#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3222	inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0) const;
sl@0	3223	#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3224	// Only available to NULL arguments
sl@0	3225	inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3226	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3227	// For things using KSuppressPlatSecDiagnostic
sl@0	3228	inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3229	#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3230	#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3231
sl@0	3232	/**
sl@0	3233	Check if the process which sent this message has both of the given capabilities.
sl@0	3234
sl@0	3235	When a check fails the action taken is determined by the system wide Platform Security
sl@0	3236	configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted.
sl@0	3237	If PlatSecEnforcement is OFF, then this function will not leave even though the
sl@0	3238	check failed.
sl@0	3239
sl@0	3240	@param aCapability1 The first capability to test.
sl@0	3241	@param aCapability2 The second capability to test.
sl@0	3242	@param aDiagnosticMessage A string that will be emitted along with any diagnostic message
sl@0	3243	that may be issued if the test finds a capability is not present.
sl@0	3244	This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro
sl@0	3245	which enables it to be easily removed from the system.
sl@0	3246	@leave KErrPermissionDenied, if the process does not have the capabilities.
sl@0	3247	@publishedAll
sl@0	3248	@released
sl@0	3249	*/
sl@0	3250	#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3251	inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, const char* aDiagnosticMessage=0) const;
sl@0	3252	#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3253	// Only available to NULL arguments
sl@0	3254	inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnosticMessage=NULL) const;
sl@0	3255	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3256	// For things using KSuppressPlatSecDiagnostic
sl@0	3257	inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3258	#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3259	#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3260
sl@0	3261	/**
sl@0	3262	@deprecated Use SecureId()
sl@0	3263	*/
sl@0	3264	inline TUid Identity() const { return SecureId(); }
sl@0	3265	#endif
sl@0	3266
sl@0	3267	private:
sl@0	3268	// Implementations of functions with diagnostics
sl@0	3269	IMPORT_C TBool DoHasCapability(TCapability aCapability, const char* aDiagnostic) const;
sl@0	3270	IMPORT_C TBool DoHasCapability(TCapability aCapability) const;
sl@0	3271	IMPORT_C TBool DoHasCapability(TCapability aCapability, TCapability aCapability2, const char* aDiagnostic) const;
sl@0	3272	IMPORT_C TBool DoHasCapability(TCapability aCapability, TCapability aCapability2) const;
sl@0	3273
sl@0	3274	protected:
sl@0	3275	TInt iHandle;
sl@0	3276	};
sl@0	3277	inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight);
sl@0	3278	inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight);
sl@0	3279
sl@0	3280	class CSession2;
sl@0	3281
sl@0	3282	#define __IPC_V2_PRESENT__
sl@0	3283
sl@0	3284	/**
sl@0	3285	@publishedAll
sl@0	3286	@released
sl@0	3287
sl@0	3288	An object that encapsulates the details of a client request.
sl@0	3289	*/
sl@0	3290	class RMessage2 : public RMessagePtr2
sl@0	3291	{
sl@0	3292	friend class CServer2;
sl@0	3293	public:
sl@0	3294
sl@0	3295	/**
sl@0	3296	Defines internal message types.
sl@0	3297	*/
sl@0	3298	enum TSessionMessages {
sl@0	3299	/**
sl@0	3300	A message type used internally that means connect.
sl@0	3301	*/
sl@0	3302	EConnect=-1,
sl@0	3303
sl@0	3304	/**
sl@0	3305	A message type used internally that means disconnect.
sl@0	3306	*/
sl@0	3307	EDisConnect=-2
sl@0	3308	};
sl@0	3309	public:
sl@0	3310	inline RMessage2();
sl@0	3311	#ifndef __KERNEL_MODE__
sl@0	3312	IMPORT_C explicit RMessage2(const RMessagePtr2& aPtr);
sl@0	3313	void SetAuthorised() const;
sl@0	3314	void ClearAuthorised() const;
sl@0	3315	TBool Authorised() const;
sl@0	3316	#endif
sl@0	3317	inline TInt Function() const;
sl@0	3318	inline TInt Int0() const;
sl@0	3319	inline TInt Int1() const;
sl@0	3320	inline TInt Int2() const;
sl@0	3321	inline TInt Int3() const;
sl@0	3322	inline const TAny* Ptr0() const;
sl@0	3323	inline const TAny* Ptr1() const;
sl@0	3324	inline const TAny* Ptr2() const;
sl@0	3325	inline const TAny* Ptr3() const;
sl@0	3326	inline CSession2* Session() const;
sl@0	3327	protected:
sl@0	3328
sl@0	3329	/**
sl@0	3330	The request type.
sl@0	3331	*/
sl@0	3332	TInt iFunction;
sl@0	3333
sl@0	3334	/**
sl@0	3335	A copy of the message arguments.
sl@0	3336	*/
sl@0	3337	TInt iArgs[KMaxMessageArguments];
sl@0	3338	private:
sl@0	3339	TInt iSpare1;
sl@0	3340	protected:
sl@0	3341	/**
sl@0	3342	@internalComponent
sl@0	3343	*/
sl@0	3344	const TAny* iSessionPtr;
sl@0	3345	private:
sl@0	3346	mutable TInt iFlags;// Currently only used for *Authorised above
sl@0	3347	TInt iSpare3; // Reserved for future use
sl@0	3348
sl@0	3349	friend class RMessage;
sl@0	3350	};
sl@0	3351
sl@0	3352
sl@0	3353
sl@0	3354
sl@0	3355	/**
sl@0	3356	@publishedAll
sl@0	3357	@released
sl@0	3358
sl@0	3359	Defines an 8-bit modifiable buffer descriptor to contain passwords when dealing
sl@0	3360	with password security support in a file server session.
sl@0	3361
sl@0	3362	The descriptor takes a maximum length of KMaxMediaPassword.
sl@0	3363
sl@0	3364	@see KMaxMediaPassword
sl@0	3365	*/
sl@0	3366	typedef TBuf8<KMaxMediaPassword> TMediaPassword; // 128 bit
sl@0	3367
sl@0	3368
sl@0	3369
sl@0	3370	/**
sl@0	3371	@publishedPartner
sl@0	3372	@prototype
sl@0	3373	A configuration flag for the shared chunk buffer configuration class (used by the multimedia device drivers). This being
sl@0	3374	set signifies that a buffer offset list follows the buffer configuration class. This list holds the offset of each buffer.
sl@0	3375	*/
sl@0	3376	const TUint KScFlagBufOffsetListInUse=0x00000001;
sl@0	3377
sl@0	3378	/**
sl@0	3379	@publishedPartner
sl@0	3380	@prototype
sl@0	3381	A configuration flag for the shared chunk buffer configuration class (used by the multimedia device drivers). This being
sl@0	3382	set is a suggestion that the shared chunk should be configured leaving guard pages around each buffers.
sl@0	3383	*/
sl@0	3384	const TUint KScFlagUseGuardPages=0x00000002;
sl@0	3385
sl@0	3386	/**
sl@0	3387	@publishedPartner
sl@0	3388	@prototype
sl@0	3389	The shared chunk buffer configuration class (used by the multimedia device drivers). This is used to hold information
sl@0	3390	on the current buffer configuration within a shared chunk.
sl@0	3391	*/
sl@0	3392	class TSharedChunkBufConfigBase
sl@0	3393	{
sl@0	3394	public:
sl@0	3395	inline TSharedChunkBufConfigBase();
sl@0	3396	public:
sl@0	3397	/** The number of buffers. */
sl@0	3398	TInt iNumBuffers;
sl@0	3399	/** The size of each buffer in bytes. */
sl@0	3400	TInt iBufferSizeInBytes;
sl@0	3401	/** Reserved field. */
sl@0	3402	TInt iReserved1;
sl@0	3403	/** Shared chunk buffer flag settings. */
sl@0	3404	TUint iFlags;
sl@0	3405	};
sl@0	3406
sl@0	3407
sl@0	3408	/** Maximum size of capability set
sl@0	3409
sl@0	3410	@internalTechnology
sl@0	3411	*/
sl@0	3412	const TInt KCapabilitySetMaxSize = (((TInt)ECapability_HardLimit + 7)>>3);
sl@0	3413
sl@0	3414	/** Maximum size of any future extension to TSecurityPolicy
sl@0	3415
sl@0	3416	@internalTechnology
sl@0	3417	*/
sl@0	3418	const TInt KMaxSecurityPolicySize = KCapabilitySetMaxSize + 3*sizeof(TUint32);
sl@0	3419
sl@0	3420
sl@0	3421	/** Class representing an arbitrary set of capabilities.
sl@0	3422
sl@0	3423	This class can only contain capabilities supported by the current OS version.
sl@0	3424
sl@0	3425	@publishedAll
sl@0	3426	@released
sl@0	3427	*/
sl@0	3428	class TCapabilitySet
sl@0	3429	{
sl@0	3430	public:
sl@0	3431	inline TCapabilitySet();
sl@0	3432	inline TCapabilitySet(TCapability aCapability);
sl@0	3433	IMPORT_C TCapabilitySet(TCapability aCapability1, TCapability aCapability2);
sl@0	3434	IMPORT_C void SetEmpty();
sl@0	3435	inline void Set(TCapability aCapability);
sl@0	3436	inline void Set(TCapability aCapability1, TCapability aCapability2);
sl@0	3437	IMPORT_C void SetAllSupported();
sl@0	3438	IMPORT_C void AddCapability(TCapability aCapability);
sl@0	3439	IMPORT_C void RemoveCapability(TCapability aCapability);
sl@0	3440	IMPORT_C void Union(const TCapabilitySet& aCapabilities);
sl@0	3441	IMPORT_C void Intersection(const TCapabilitySet& aCapabilities);
sl@0	3442	IMPORT_C void Remove(const TCapabilitySet& aCapabilities);
sl@0	3443	IMPORT_C TBool HasCapability(TCapability aCapability) const;
sl@0	3444	IMPORT_C TBool HasCapabilities(const TCapabilitySet& aCapabilities) const;
sl@0	3445
sl@0	3446	/**
sl@0	3447	Make this set consist of the capabilities which are disabled on this platform.
sl@0	3448	@internalTechnology
sl@0	3449	*/
sl@0	3450	IMPORT_C void SetDisabled();
sl@0	3451	/**
sl@0	3452	@internalComponent
sl@0	3453	*/
sl@0	3454	TBool NotEmpty() const;
sl@0	3455
sl@0	3456	private:
sl@0	3457	TUint32 iCaps[KCapabilitySetMaxSize / sizeof(TUint32)];
sl@0	3458	};
sl@0	3459
sl@0	3460	#ifndef __SECURITY_INFO_DEFINED__
sl@0	3461	#define __SECURITY_INFO_DEFINED__
sl@0	3462	/**
sl@0	3463	@internalTechnology
sl@0	3464	*/
sl@0	3465	struct SCapabilitySet
sl@0	3466	{
sl@0	3467	enum {ENCapW=2};
sl@0	3468
sl@0	3469	inline void AddCapability(TCapability aCap1) {((TCapabilitySet*)this)->AddCapability(aCap1);}
sl@0	3470	inline void Remove(const SCapabilitySet& aCaps) {((TCapabilitySet)this)->Remove(((TCapabilitySet*)&aCaps));}
sl@0	3471	inline TBool NotEmpty() const {return ((TCapabilitySet*)this)->NotEmpty();}
sl@0	3472
sl@0	3473	inline const TUint32& operator[] (TInt aIndex) const { return iCaps[aIndex]; }
sl@0	3474	inline TUint32& operator[] (TInt aIndex) { return iCaps[aIndex]; }
sl@0	3475
sl@0	3476	TUint32 iCaps[ENCapW];
sl@0	3477	};
sl@0	3478
sl@0	3479	/**
sl@0	3480	@internalTechnology
sl@0	3481	*/
sl@0	3482	struct SSecurityInfo
sl@0	3483	{
sl@0	3484	TUint32 iSecureId;
sl@0	3485	TUint32 iVendorId;
sl@0	3486	SCapabilitySet iCaps; // Capabilities re. platform security
sl@0	3487	};
sl@0	3488
sl@0	3489	#endif
sl@0	3490
sl@0	3491	/** Define this macro to reference the set of all capabilities.
sl@0	3492	@internalTechnology
sl@0	3493	*/
sl@0	3494	#ifdef __REFERENCE_ALL_SUPPORTED_CAPABILITIES__
sl@0	3495
sl@0	3496	extern const SCapabilitySet AllSupportedCapabilities;
sl@0	3497
sl@0	3498	#endif //__REFERENCE_ALL_SUPPORTED_CAPABILITIES__
sl@0	3499
sl@0	3500	/** Define this macro to include the set of all capabilities.
sl@0	3501	@internalTechnology
sl@0	3502	*/
sl@0	3503	#ifdef __INCLUDE_ALL_SUPPORTED_CAPABILITIES__
sl@0	3504
sl@0	3505	/** The set of all capabilities.
sl@0	3506	@internalTechnology
sl@0	3507	*/
sl@0	3508	const SCapabilitySet AllSupportedCapabilities = {
sl@0	3509	{
sl@0	3510	ECapability_Limit<32 ? (TUint32)((1u<<(ECapability_Limit&31))-1u) : 0xffffffffu
sl@0	3511	,
sl@0	3512	ECapability_Limit>=32 ? (TUint32)((1u<<(ECapability_Limit&31))-1u) : 0u
sl@0	3513	}
sl@0	3514	};
sl@0	3515
sl@0	3516	#endif // __INCLUDE_ALL_SUPPORTED_CAPABILITIES__
sl@0	3517
sl@0	3518	#ifndef __KERNEL_MODE__
sl@0	3519	class RProcess;
sl@0	3520	class RThread;
sl@0	3521	class RMessagePtr2;
sl@0	3522	class RSessionBase;
sl@0	3523	#else
sl@0	3524	class DProcess;
sl@0	3525	class DThread;
sl@0	3526	#endif
sl@0	3527
sl@0	3528	/** Class representing all security attributes of a process or DLL.
sl@0	3529	These comprise a set of capabilities, a Secure ID and a Vendor ID.
sl@0	3530
sl@0	3531	@publishedAll
sl@0	3532	@released
sl@0	3533	*/
sl@0	3534	class TSecurityInfo
sl@0	3535	{
sl@0	3536	public:
sl@0	3537	inline TSecurityInfo();
sl@0	3538	#ifdef __KERNEL_MODE__
sl@0	3539	IMPORT_C TSecurityInfo(DProcess* aProcess);
sl@0	3540	IMPORT_C TSecurityInfo(DThread* aThread);
sl@0	3541	#else
sl@0	3542	IMPORT_C TSecurityInfo(RProcess aProcess);
sl@0	3543	IMPORT_C TSecurityInfo(RThread aThread);
sl@0	3544	IMPORT_C TSecurityInfo(RMessagePtr2 aMesPtr);
sl@0	3545	inline void Set(RProcess aProcess);
sl@0	3546	inline void Set(RThread aThread);
sl@0	3547	inline void Set(RMessagePtr2 aMsgPtr);
sl@0	3548	TInt Set(RSessionBase aSession); /*< @internalComponent /
sl@0	3549	inline void SetToCurrentInfo();
sl@0	3550	IMPORT_C void SetToCreatorInfo();
sl@0	3551	#endif //__KERNEL_MODE__
sl@0	3552	public:
sl@0	3553	TSecureId iSecureId; /*< Secure ID /
sl@0	3554	TVendorId iVendorId; /*< Vendor ID /
sl@0	3555	TCapabilitySet iCaps; /*< Capability Set /
sl@0	3556	};
sl@0	3557
sl@0	3558
sl@0	3559	/** Class representing a generic security policy
sl@0	3560
sl@0	3561	This class can specify a security policy consisting of either:
sl@0	3562
sl@0	3563	-# A check for between 0 and 7 capabilities
sl@0	3564	-# A check for a given Secure ID along with 0-3 capabilities
sl@0	3565	-# A check for a given Vendor ID along with 0-3 capabilities
sl@0	3566
sl@0	3567	If multiple capabilities are specified, all of them must be present for the
sl@0	3568	security check to succeed ('AND' relation).
sl@0	3569
sl@0	3570	The envisaged use case for this class is to specify access rights to an object
sl@0	3571	managed either by the kernel or by a server but in principle owned by a client
sl@0	3572	and usable in a limited way by other clients. For example
sl@0	3573	- Publish and Subscribe properties
sl@0	3574	- DBMS databases
sl@0	3575
sl@0	3576	In these cases the owning client would pass one (or more) of these objects to
sl@0	3577	the server to specify which security checks should be done on other clients
sl@0	3578	before allowing access to the object.
sl@0	3579
sl@0	3580	To pass a TSecurityPolicy object via IPC, a client should obtain a descriptor
sl@0	3581	for the object using Package() and send this. When a server receives this descriptor
sl@0	3582	it should read the descriptor contents into a TSecurityPolicyBuf and then
sl@0	3583	Set() should be used to create a policy object from this.
sl@0	3584
sl@0	3585	Because this class has non-default constructors, compilers will not initialise
sl@0	3586	this object at compile time, instead code will be generated to construct the object
sl@0	3587	at run-time. This is wasteful - and Symbian OS DLLs are not permitted to have
sl@0	3588	such uninitialised data. To overcome these problems a set of macros are provided to
sl@0	3589	construct a const object which behaves like a TSecurityPolicy. These are:
sl@0	3590
sl@0	3591	_LIT_SECURITY_POLICY_C1 through _LIT_SECURITY_POLICY_C7,
sl@0	3592	_LIT_SECURITY_POLICY_S0 through _LIT_SECURITY_POLICY_S3 and
sl@0	3593	_LIT_SECURITY_POLICY_V0 through _LIT_SECURITY_POLICY_V3.
sl@0	3594
sl@0	3595	Also, the macros _LIT_SECURITY_POLICY_PASS and _LIT_SECURITY_POLICY_FAIL are provided
sl@0	3596	in order to allow easy construction of a const object which can be used as a
sl@0	3597	TSecuityPolicy which always passes or always fails, respectively.
sl@0	3598
sl@0	3599	If a security policy object is needed to be embedded in another class then the
sl@0	3600	TStaticSecurityPolicy structure can be used. This behaves in the same way as a
sl@0	3601	TSecurityPolicy object but may be initialised at compile time.
sl@0	3602
sl@0	3603	@see TStaticSecurityPolicy
sl@0	3604	@see TSecurityPolicyBuf
sl@0	3605	@see _LIT_SECURITY_POLICY_PASS
sl@0	3606	@see _LIT_SECURITY_POLICY_FAIL
sl@0	3607	@see _LIT_SECURITY_POLICY_C1
sl@0	3608	@see _LIT_SECURITY_POLICY_C2
sl@0	3609	@see _LIT_SECURITY_POLICY_C3
sl@0	3610	@see _LIT_SECURITY_POLICY_C4
sl@0	3611	@see _LIT_SECURITY_POLICY_C5
sl@0	3612	@see _LIT_SECURITY_POLICY_C6
sl@0	3613	@see _LIT_SECURITY_POLICY_C7
sl@0	3614	@see _LIT_SECURITY_POLICY_S0
sl@0	3615	@see _LIT_SECURITY_POLICY_S1
sl@0	3616	@see _LIT_SECURITY_POLICY_S2
sl@0	3617	@see _LIT_SECURITY_POLICY_S3
sl@0	3618	@see _LIT_SECURITY_POLICY_V0
sl@0	3619	@see _LIT_SECURITY_POLICY_V1
sl@0	3620	@see _LIT_SECURITY_POLICY_V2
sl@0	3621	@see _LIT_SECURITY_POLICY_V3
sl@0	3622
sl@0	3623	@publishedAll
sl@0	3624	@released
sl@0	3625	*/
sl@0	3626	class TSecurityPolicy
sl@0	3627	{
sl@0	3628	public:
sl@0	3629	enum TSecPolicyType
sl@0	3630	{
sl@0	3631	EAlwaysFail=0,
sl@0	3632	EAlwaysPass=1,
sl@0	3633	};
sl@0	3634
sl@0	3635	public:
sl@0	3636	inline TSecurityPolicy();
sl@0	3637	IMPORT_C TSecurityPolicy(TSecPolicyType aType);
sl@0	3638	IMPORT_C TSecurityPolicy(TCapability aCap1, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None);
sl@0	3639	IMPORT_C TSecurityPolicy(TCapability aCap1, TCapability aCap2, TCapability aCap3, TCapability aCap4, TCapability aCap5 = ECapability_None, TCapability aCap6 = ECapability_None, TCapability aCap7 = ECapability_None);
sl@0	3640	IMPORT_C TSecurityPolicy(TSecureId aSecureId, TCapability aCap1 = ECapability_None, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None);
sl@0	3641	IMPORT_C TSecurityPolicy(TVendorId aVendorId, TCapability aCap1 = ECapability_None, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None);
sl@0	3642	IMPORT_C TInt Set(const TDesC8& aDes);
sl@0	3643	IMPORT_C TPtrC8 Package() const;
sl@0	3644
sl@0	3645	#ifdef __KERNEL_MODE__
sl@0	3646
sl@0	3647	#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3648	inline TBool CheckPolicy(DProcess* aProcess, const char* aDiagnostic=0) const;
sl@0	3649	inline TBool CheckPolicy(DThread* aThread, const char* aDiagnostic=0) const;
sl@0	3650	#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3651	// Only available to NULL arguments
sl@0	3652	inline TBool CheckPolicy(DProcess* aProcess, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3653	inline TBool CheckPolicy(DThread* aThread, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3654	#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3655
sl@0	3656	#else // !__KERNEL_MODE__
sl@0	3657
sl@0	3658	#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3659	inline TBool CheckPolicy(RProcess aProcess, const char* aDiagnostic=0) const;
sl@0	3660	inline TBool CheckPolicy(RThread aThread, const char* aDiagnostic=0) const;
sl@0	3661	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic=0) const;
sl@0	3662	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic=0) const;
sl@0	3663	inline TBool CheckPolicyCreator(const char* aDiagnostic=0) const;
sl@0	3664	#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3665	// Only available to NULL arguments
sl@0	3666	inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3667	inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3668	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3669	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3670	inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3671	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3672	// For things using KSuppressPlatSecDiagnostic
sl@0	3673	inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3674	inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3675	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3676	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3677	inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3678	#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3679	#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3680	TInt CheckPolicy(RSessionBase aSession) const; /*< @internalComponent /
sl@0	3681
sl@0	3682	#endif //__KERNEL_MODE__
sl@0	3683
sl@0	3684	TBool Validate() const;
sl@0	3685
sl@0	3686	private:
sl@0	3687	#ifdef __KERNEL_MODE__
sl@0	3688	IMPORT_C TBool DoCheckPolicy(DProcess* aProcess, const char* aDiagnostic) const;
sl@0	3689	IMPORT_C TBool DoCheckPolicy(DProcess* aProcess) const;
sl@0	3690	IMPORT_C TBool DoCheckPolicy(DThread* aThread, const char* aDiagnostic) const;
sl@0	3691	IMPORT_C TBool DoCheckPolicy(DThread* aThread) const;
sl@0	3692	#else // !__KERNEL_MODE__
sl@0	3693	IMPORT_C TBool DoCheckPolicy(RProcess aProcess, const char* aDiagnostic) const;
sl@0	3694	IMPORT_C TBool DoCheckPolicy(RProcess aProcess) const;
sl@0	3695	IMPORT_C TBool DoCheckPolicy(RThread aThread, const char* aDiagnostic) const;
sl@0	3696	IMPORT_C TBool DoCheckPolicy(RThread aThread) const;
sl@0	3697	IMPORT_C TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const;
sl@0	3698	IMPORT_C TBool DoCheckPolicy(RMessagePtr2 aMsgPtr) const;
sl@0	3699	IMPORT_C TBool DoCheckPolicyCreator(const char* aDiagnostic) const;
sl@0	3700	IMPORT_C TBool DoCheckPolicyCreator() const;
sl@0	3701	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3702	TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const;
sl@0	3703	#endif //__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3704	TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing) const;
sl@0	3705	#endif //__KERNEL_MODE__
sl@0	3706
sl@0	3707	public:
sl@0	3708	/** Constants to specify the type of TSecurityPolicy objects.
sl@0	3709	*/
sl@0	3710	enum TType
sl@0	3711	{
sl@0	3712	ETypeFail=0, /*< Always fail/
sl@0	3713	ETypePass=1, /*< Always pass/
sl@0	3714	ETypeC3=2, /*< Up to 3 capabilities/
sl@0	3715	ETypeC7=3, /*< Up to 7 capabilities/
sl@0	3716	ETypeS3=4, /*< Secure ID and up to 3 capabilities/
sl@0	3717	ETypeV3=5, /*< Vendor ID and up to 3 capabilities/
sl@0	3718
sl@0	3719	/** The number of possible TSecurityPolicy types
sl@0	3720	This is intended for internal Symbian use only.
sl@0	3721	@internalTechnology
sl@0	3722	*/
sl@0	3723	ETypeLimit
sl@0	3724
sl@0	3725	// other values may be added to indicate expanded policy objects (future extensions)
sl@0	3726	};
sl@0	3727	protected:
sl@0	3728	TBool CheckPolicy(const SSecurityInfo& aSecInfo, SSecurityInfo& aMissing) const;
sl@0	3729	private:
sl@0	3730	void ConstructAndCheck3(TCapability aCap1, TCapability aCap2, TCapability aCap3);
sl@0	3731	private:
sl@0	3732	TUint8 iType;
sl@0	3733	TUint8 iCaps[3]; // missing capabilities are set to 0xff
sl@0	3734	union
sl@0	3735	{
sl@0	3736	TUint32 iSecureId;
sl@0	3737	TUint32 iVendorId;
sl@0	3738	TUint8 iExtraCaps[4]; // missing capabilities are set to 0xff
sl@0	3739	};
sl@0	3740	friend class TCompiledSecurityPolicy;
sl@0	3741	};
sl@0	3742
sl@0	3743	/** Provides a TPkcgBuf wrapper for a descriptorised TSecurityPolicy. This a
sl@0	3744	suitable container for passing a security policy across IPC.
sl@0	3745	@publishedAll
sl@0	3746	@released
sl@0	3747	*/
sl@0	3748	typedef TPckgBuf<TSecurityPolicy> TSecurityPolicyBuf;
sl@0	3749
sl@0	3750
sl@0	3751	/** Structure for compile-time initialisation of a security policy.
sl@0	3752
sl@0	3753	This structure behaves in the same way as a TSecurityPolicy object but has
sl@0	3754	the advantage that it may be initialised at compile time. E.g.
sl@0	3755	the following line defines a security policy 'KSecurityPolictReadUserData'
sl@0	3756	which checks ReadUserData capability.
sl@0	3757
sl@0	3758	@code
sl@0	3759	_LIT_SECURITY_POLICY_C1(KSecurityPolictReadUserData,ECapabilityReadUserData)
sl@0	3760	@endcode
sl@0	3761
sl@0	3762	Or, an array of security policies may be created like this:
sl@0	3763	@code
sl@0	3764	static const TStaticSecurityPolicy MyPolicies[] =
sl@0	3765	{
sl@0	3766	_INIT_SECURITY_POLICY_C1(ECapabilityReadUserData),
sl@0	3767	_INIT_SECURITY_POLICY_PASS(),
sl@0	3768	_INIT_SECURITY_POLICY_S0(0x1234567)
sl@0	3769	}
sl@0	3770	@endcode
sl@0	3771
sl@0	3772	This class should not be initialised directly, instead one of the following
sl@0	3773	macros should be used:
sl@0	3774
sl@0	3775	- _INIT_SECURITY_POLICY_PASS
sl@0	3776	- _INIT_SECURITY_POLICY_FAIL
sl@0	3777	- _INIT_SECURITY_POLICY_C1
sl@0	3778	- _INIT_SECURITY_POLICY_C2
sl@0	3779	- _INIT_SECURITY_POLICY_C3
sl@0	3780	- _INIT_SECURITY_POLICY_C4
sl@0	3781	- _INIT_SECURITY_POLICY_C5
sl@0	3782	- _INIT_SECURITY_POLICY_C6
sl@0	3783	- _INIT_SECURITY_POLICY_C7
sl@0	3784	- _INIT_SECURITY_POLICY_S0
sl@0	3785	- _INIT_SECURITY_POLICY_S1
sl@0	3786	- _INIT_SECURITY_POLICY_S2
sl@0	3787	- _INIT_SECURITY_POLICY_S3
sl@0	3788	- _INIT_SECURITY_POLICY_V0
sl@0	3789	- _INIT_SECURITY_POLICY_V1
sl@0	3790	- _INIT_SECURITY_POLICY_V2
sl@0	3791	- _INIT_SECURITY_POLICY_V3
sl@0	3792	- _LIT_SECURITY_POLICY_PASS
sl@0	3793	- _LIT_SECURITY_POLICY_FAIL
sl@0	3794	- _LIT_SECURITY_POLICY_C1
sl@0	3795	- _LIT_SECURITY_POLICY_C2
sl@0	3796	- _LIT_SECURITY_POLICY_C3
sl@0	3797	- _LIT_SECURITY_POLICY_C4
sl@0	3798	- _LIT_SECURITY_POLICY_C5
sl@0	3799	- _LIT_SECURITY_POLICY_C6
sl@0	3800	- _LIT_SECURITY_POLICY_C7
sl@0	3801	- _LIT_SECURITY_POLICY_S0
sl@0	3802	- _LIT_SECURITY_POLICY_S1
sl@0	3803	- _LIT_SECURITY_POLICY_S2
sl@0	3804	- _LIT_SECURITY_POLICY_S3
sl@0	3805	- _LIT_SECURITY_POLICY_V0
sl@0	3806	- _LIT_SECURITY_POLICY_V1
sl@0	3807	- _LIT_SECURITY_POLICY_V2
sl@0	3808	- _LIT_SECURITY_POLICY_V3
sl@0	3809
sl@0	3810	@see TSecurityPolicy
sl@0	3811	@publishedAll
sl@0	3812	@released
sl@0	3813	*/
sl@0	3814	struct TStaticSecurityPolicy
sl@0	3815	{
sl@0	3816	inline const TSecurityPolicy* operator&() const;
sl@0	3817	inline operator const TSecurityPolicy&() const;
sl@0	3818	inline const TSecurityPolicy& operator()() const;
sl@0	3819
sl@0	3820	#ifndef __KERNEL_MODE__
sl@0	3821	#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3822	inline TBool CheckPolicy(RProcess aProcess, const char* aDiagnostic=0) const;
sl@0	3823	inline TBool CheckPolicy(RThread aThread, const char* aDiagnostic=0) const;
sl@0	3824	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic=0) const;
sl@0	3825	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic=0) const;
sl@0	3826	inline TBool CheckPolicyCreator(const char* aDiagnostic=0) const;
sl@0	3827	#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3828	// Only available to NULL arguments
sl@0	3829	inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3830	inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3831	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3832	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3833	inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic=NULL) const;
sl@0	3834	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3835	// For things using KSuppressPlatSecDiagnostic
sl@0	3836	inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3837	inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3838	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3839	inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3840	inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const;
sl@0	3841	#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	3842	#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__
sl@0	3843	#endif // !__KERNEL_MODE__
sl@0	3844
sl@0	3845	TUint32 iA; /*< @internalComponent /
sl@0	3846	TUint32 iB; /*< @internalComponent /
sl@0	3847	};
sl@0	3848
sl@0	3849
sl@0	3850	/**
sl@0	3851	A dummy enum for use by the CAPABILITY_AS_TUINT8 macro
sl@0	3852	@internalComponent
sl@0	3853	*/
sl@0	3854	enum __invalid_capability_value {};
sl@0	3855
sl@0	3856	/**
sl@0	3857	A macro to cast a TCapability to a TUint8.
sl@0	3858
sl@0	3859	If an invlid capability value is specified then, dependant on the compiler,
sl@0	3860	a compile time error or warning will be produced which includes the label
sl@0	3861	"__invalid_capability_value"
sl@0	3862
sl@0	3863	@param cap The capability value
sl@0	3864	@internalComponent
sl@0	3865	*/
sl@0	3866	#define CAPABILITY_AS_TUINT8(cap) \
sl@0	3867	((TUint8)(int)( \
sl@0	3868	(cap)==ECapability_None \
sl@0	3869	? (__invalid_capability_value(*)[1])(ECapability_None) \
sl@0	3870	: (__invalid_capability_value(*)[((TUint)(cap+1)<=(TUint)ECapability_Limit)?1:2])(cap) \
sl@0	3871	))
sl@0	3872
sl@0	3873
sl@0	3874	/**
sl@0	3875	A macro to construct a TUint32 from four TUint8s. The TUint32 is in BigEndian
sl@0	3876	ordering useful for class layout rather than number generation.
sl@0	3877
sl@0	3878	@param i1 The first TUint8
sl@0	3879	@param i2 The second TUint8
sl@0	3880	@param i3 The third TUint8
sl@0	3881	@param i4 The fourth TUint8
sl@0	3882	@internalComponent
sl@0	3883	*/
sl@0	3884	#define FOUR_TUINT8(i1,i2,i3,i4) \
sl@0	3885	(TUint32)( \
sl@0	3886	(TUint8)i1 \| \
sl@0	3887	(TUint8)i2 << 8 \| \
sl@0	3888	(TUint8)i3 << 16 \| \
sl@0	3889	(TUint8)i4 << 24 \
sl@0	3890	)
sl@0	3891
sl@0	3892
sl@0	3893	/** Macro for compile-time initialisation of a security policy object that
sl@0	3894	always fails. That is, checks against this policy will always fail,
sl@0	3895	irrespective of the security attributes of the item being checked.
sl@0	3896
sl@0	3897	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	3898	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	3899	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	3900	function call operator n().
sl@0	3901	@publishedAll
sl@0	3902	@released
sl@0	3903	*/
sl@0	3904	#define _INIT_SECURITY_POLICY_FAIL \
sl@0	3905	{ \
sl@0	3906	FOUR_TUINT8( \
sl@0	3907	(TUint8)TSecurityPolicy::ETypeFail, \
sl@0	3908	(TUint8)0xff, \
sl@0	3909	(TUint8)0xff, \
sl@0	3910	(TUint8)0xff \
sl@0	3911	), \
sl@0	3912	(TUint32)0xffffffff \
sl@0	3913	}
sl@0	3914
sl@0	3915
sl@0	3916	/** Macro for compile-time definition of a security policy object that always
sl@0	3917	fails. That is, checks against this policy will always fail, irrespective of
sl@0	3918	the security attributes of the item being checked.
sl@0	3919
sl@0	3920	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	3921	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	3922	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	3923	function call operator n().
sl@0	3924	@param n Name to use for policy object
sl@0	3925	@publishedAll
sl@0	3926	@released
sl@0	3927	*/
sl@0	3928	#define _LIT_SECURITY_POLICY_FAIL(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_FAIL
sl@0	3929
sl@0	3930
sl@0	3931	/** Macro for compile-time initialisation of a security policy object that
sl@0	3932	always passes. That is, checks against this policy will always pass,
sl@0	3933	irrespective of the security attributes of the item being checked.
sl@0	3934
sl@0	3935	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	3936	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	3937	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	3938	function call operator n().
sl@0	3939	@publishedAll
sl@0	3940	@released
sl@0	3941	*/
sl@0	3942	#define _INIT_SECURITY_POLICY_PASS \
sl@0	3943	{ \
sl@0	3944	FOUR_TUINT8( \
sl@0	3945	(TUint8)TSecurityPolicy::ETypePass, \
sl@0	3946	(TUint8)0xff, \
sl@0	3947	(TUint8)0xff, \
sl@0	3948	(TUint8)0xff \
sl@0	3949	), \
sl@0	3950	(TUint32)0xffffffff \
sl@0	3951	}
sl@0	3952
sl@0	3953
sl@0	3954	/** Macro for compile-time definition of a security policy object that always
sl@0	3955	passes. That is, checks against this policy will always pass, irrespective of
sl@0	3956	the security attributes of the item being checked.
sl@0	3957
sl@0	3958	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	3959	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	3960	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	3961	function call operator n().
sl@0	3962	@param n Name to use for policy object
sl@0	3963	@publishedAll
sl@0	3964	@released
sl@0	3965	*/
sl@0	3966	#define _LIT_SECURITY_POLICY_PASS(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_PASS
sl@0	3967
sl@0	3968
sl@0	3969	/** Macro for compile-time initialisation of a security policy object
sl@0	3970	The policy will check for seven capabilities.
sl@0	3971
sl@0	3972	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	3973	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	3974	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	3975	function call operator n().
sl@0	3976
sl@0	3977	If an invlid capability value is specified then, dependant on the compiler,
sl@0	3978	a compile time error or warning will be produced which includes the label
sl@0	3979	"__invalid_capability_value"
sl@0	3980
sl@0	3981	@param c1 The first capability to check (enumerator of TCapability)
sl@0	3982	@param c2 The second capability to check (enumerator of TCapability)
sl@0	3983	@param c3 The third capability to check (enumerator of TCapability)
sl@0	3984	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	3985	@param c5 The fifth capability to check (enumerator of TCapability)
sl@0	3986	@param c6 The sixth capability to check (enumerator of TCapability)
sl@0	3987	@param c7 The seventh capability to check (enumerator of TCapability)
sl@0	3988
sl@0	3989	@publishedAll
sl@0	3990	@released
sl@0	3991	*/
sl@0	3992	#define _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,c7) \
sl@0	3993	{ \
sl@0	3994	FOUR_TUINT8( \
sl@0	3995	(TUint8)TSecurityPolicy::ETypeC7, \
sl@0	3996	CAPABILITY_AS_TUINT8(c1), \
sl@0	3997	CAPABILITY_AS_TUINT8(c2), \
sl@0	3998	CAPABILITY_AS_TUINT8(c3) \
sl@0	3999	), \
sl@0	4000	FOUR_TUINT8( \
sl@0	4001	CAPABILITY_AS_TUINT8(c4), \
sl@0	4002	CAPABILITY_AS_TUINT8(c5), \
sl@0	4003	CAPABILITY_AS_TUINT8(c6), \
sl@0	4004	CAPABILITY_AS_TUINT8(c7) \
sl@0	4005	) \
sl@0	4006	}
sl@0	4007
sl@0	4008
sl@0	4009	/** Macro for compile-time definition of a security policy object
sl@0	4010	The policy will check for seven capabilities.
sl@0	4011
sl@0	4012	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4013	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4014	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4015	function call operator n().
sl@0	4016
sl@0	4017	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4018	a compile time error or warning will be produced which includes the label
sl@0	4019	"__invalid_capability_value"
sl@0	4020
sl@0	4021	@param n Name to use for policy object
sl@0	4022	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4023	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4024	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4025	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	4026	@param c5 The fifth capability to check (enumerator of TCapability)
sl@0	4027	@param c6 The sixth capability to check (enumerator of TCapability)
sl@0	4028	@param c7 The seventh capability to check (enumerator of TCapability)
sl@0	4029
sl@0	4030	@publishedAll
sl@0	4031	@released
sl@0	4032	*/
sl@0	4033	#define _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,c6,c7) \
sl@0	4034	const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,c7)
sl@0	4035
sl@0	4036
sl@0	4037	/** Macro for compile-time initialisation of a security policy object
sl@0	4038	The policy will check for six capabilities.
sl@0	4039
sl@0	4040	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4041	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4042	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4043	function call operator n().
sl@0	4044
sl@0	4045	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4046	a compile time error or warning will be produced which includes the label
sl@0	4047	"__invalid_capability_value"
sl@0	4048
sl@0	4049	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4050	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4051	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4052	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	4053	@param c5 The fifth capability to check (enumerator of TCapability)
sl@0	4054	@param c6 The sixth capability to check (enumerator of TCapability)
sl@0	4055
sl@0	4056	@publishedAll
sl@0	4057	@released
sl@0	4058	*/
sl@0	4059	#define _INIT_SECURITY_POLICY_C6(c1,c2,c3,c4,c5,c6) \
sl@0	4060	_INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,ECapability_None)
sl@0	4061
sl@0	4062
sl@0	4063	/** Macro for compile-time definition of a security policy object
sl@0	4064	The policy will check for six capabilities.
sl@0	4065
sl@0	4066	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4067	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4068	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4069	function call operator n().
sl@0	4070
sl@0	4071	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4072	a compile time error or warning will be produced which includes the label
sl@0	4073	"__invalid_capability_value"
sl@0	4074
sl@0	4075	@param n Name to use for policy object
sl@0	4076	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4077	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4078	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4079	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	4080	@param c5 The fifth capability to check (enumerator of TCapability)
sl@0	4081	@param c6 The sixth capability to check (enumerator of TCapability)
sl@0	4082
sl@0	4083	@publishedAll
sl@0	4084	@released
sl@0	4085	*/
sl@0	4086	#define _LIT_SECURITY_POLICY_C6(n,c1,c2,c3,c4,c5,c6) \
sl@0	4087	_LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,c6,ECapability_None)
sl@0	4088
sl@0	4089
sl@0	4090	/** Macro for compile-time initialisation of a security policy object
sl@0	4091	The policy will check for five capabilities.
sl@0	4092
sl@0	4093	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4094	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4095	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4096	function call operator n().
sl@0	4097
sl@0	4098	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4099	a compile time error or warning will be produced which includes the label
sl@0	4100	"__invalid_capability_value"
sl@0	4101
sl@0	4102	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4103	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4104	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4105	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	4106	@param c5 The fifth capability to check (enumerator of TCapability)
sl@0	4107
sl@0	4108	@publishedAll
sl@0	4109	@released
sl@0	4110	*/
sl@0	4111	#define _INIT_SECURITY_POLICY_C5(c1,c2,c3,c4,c5) \
sl@0	4112	_INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,ECapability_None,ECapability_None)
sl@0	4113
sl@0	4114
sl@0	4115	/** Macro for compile-time definition of a security policy object
sl@0	4116	The policy will check for five capabilities.
sl@0	4117
sl@0	4118	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4119	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4120	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4121	function call operator n().
sl@0	4122
sl@0	4123	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4124	a compile time error or warning will be produced which includes the label
sl@0	4125	"__invalid_capability_value"
sl@0	4126
sl@0	4127	@param n Name to use for policy object
sl@0	4128	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4129	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4130	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4131	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	4132	@param c5 The fifth capability to check (enumerator of TCapability)
sl@0	4133
sl@0	4134	@publishedAll
sl@0	4135	@released
sl@0	4136	*/
sl@0	4137	#define _LIT_SECURITY_POLICY_C5(n,c1,c2,c3,c4,c5) \
sl@0	4138	_LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,ECapability_None,ECapability_None)
sl@0	4139
sl@0	4140
sl@0	4141	/** Macro for compile-time initialisation of a security policy object
sl@0	4142	The policy will check for four capabilities.
sl@0	4143
sl@0	4144	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4145	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4146	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4147	function call operator n().
sl@0	4148
sl@0	4149	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4150	a compile time error or warning will be produced which includes the label
sl@0	4151	"__invalid_capability_value"
sl@0	4152
sl@0	4153	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4154	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4155	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4156	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	4157
sl@0	4158	@publishedAll
sl@0	4159	@released
sl@0	4160	*/
sl@0	4161	#define _INIT_SECURITY_POLICY_C4(c1,c2,c3,c4) \
sl@0	4162	_INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,ECapability_None,ECapability_None,ECapability_None)
sl@0	4163
sl@0	4164
sl@0	4165	/** Macro for compile-time definition of a security policy object
sl@0	4166	The policy will check for four capabilities.
sl@0	4167
sl@0	4168	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4169	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4170	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4171	function call operator n().
sl@0	4172
sl@0	4173	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4174	a compile time error or warning will be produced which includes the label
sl@0	4175	"__invalid_capability_value"
sl@0	4176
sl@0	4177	@param n Name to use for policy object
sl@0	4178	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4179	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4180	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4181	@param c4 The fourth capability to check (enumerator of TCapability)
sl@0	4182
sl@0	4183	@publishedAll
sl@0	4184	@released
sl@0	4185	*/
sl@0	4186	#define _LIT_SECURITY_POLICY_C4(n,c1,c2,c3,c4) \
sl@0	4187	_LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,ECapability_None,ECapability_None,ECapability_None)
sl@0	4188
sl@0	4189
sl@0	4190	/** Macro for compile-time initialisation of a security policy object
sl@0	4191	The policy will check for three capabilities.
sl@0	4192
sl@0	4193	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4194	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4195	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4196	function call operator n().
sl@0	4197
sl@0	4198	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4199	a compile time error or warning will be produced which includes the label
sl@0	4200	"__invalid_capability_value"
sl@0	4201
sl@0	4202	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4203	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4204	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4205
sl@0	4206	@publishedAll
sl@0	4207	@released
sl@0	4208	*/
sl@0	4209	#define _INIT_SECURITY_POLICY_C3(c1,c2,c3) \
sl@0	4210	{ \
sl@0	4211	FOUR_TUINT8( \
sl@0	4212	(TUint8)TSecurityPolicy::ETypeC3, \
sl@0	4213	CAPABILITY_AS_TUINT8(c1), \
sl@0	4214	CAPABILITY_AS_TUINT8(c2), \
sl@0	4215	CAPABILITY_AS_TUINT8(c3) \
sl@0	4216	), \
sl@0	4217	(TUint32)0xffffffff \
sl@0	4218	}
sl@0	4219
sl@0	4220
sl@0	4221	/** Macro for compile-time definition of a security policy object
sl@0	4222	The policy will check for three capabilities.
sl@0	4223
sl@0	4224	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4225	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4226	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4227	function call operator n().
sl@0	4228
sl@0	4229	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4230	a compile time error or warning will be produced which includes the label
sl@0	4231	"__invalid_capability_value"
sl@0	4232
sl@0	4233	@param n Name to use for policy object
sl@0	4234	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4235	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4236	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4237
sl@0	4238	@publishedAll
sl@0	4239	@released
sl@0	4240	*/
sl@0	4241	#define _LIT_SECURITY_POLICY_C3(n,c1,c2,c3) \
sl@0	4242	const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_C3(c1,c2,c3)
sl@0	4243
sl@0	4244
sl@0	4245	/** Macro for compile-time initialisation of a security policy object
sl@0	4246	The policy will check for two capabilities.
sl@0	4247
sl@0	4248	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4249	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4250	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4251	function call operator n().
sl@0	4252
sl@0	4253	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4254	a compile time error or warning will be produced which includes the label
sl@0	4255	"__invalid_capability_value"
sl@0	4256
sl@0	4257	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4258	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4259
sl@0	4260	@publishedAll
sl@0	4261	@released
sl@0	4262	*/
sl@0	4263	#define _INIT_SECURITY_POLICY_C2(c1,c2) \
sl@0	4264	_INIT_SECURITY_POLICY_C3(c1,c2,ECapability_None)
sl@0	4265
sl@0	4266
sl@0	4267	/** Macro for compile-time definition of a security policy object
sl@0	4268	The policy will check for two capabilities.
sl@0	4269
sl@0	4270	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4271	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4272	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4273	function call operator n().
sl@0	4274
sl@0	4275	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4276	a compile time error or warning will be produced which includes the label
sl@0	4277	"__invalid_capability_value"
sl@0	4278
sl@0	4279	@param n Name to use for policy object
sl@0	4280	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4281	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4282
sl@0	4283	@publishedAll
sl@0	4284	@released
sl@0	4285	*/
sl@0	4286	#define _LIT_SECURITY_POLICY_C2(n,c1,c2) \
sl@0	4287	_LIT_SECURITY_POLICY_C3(n,c1,c2,ECapability_None)
sl@0	4288
sl@0	4289
sl@0	4290	/** Macro for compile-time initialisation of a security policy object
sl@0	4291	The policy will check for one capability.
sl@0	4292
sl@0	4293	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4294	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4295	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4296	function call operator n().
sl@0	4297
sl@0	4298	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4299	a compile time error or warning will be produced which includes the label
sl@0	4300	"__invalid_capability_value"
sl@0	4301
sl@0	4302	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4303
sl@0	4304
sl@0	4305	@publishedAll
sl@0	4306	@released
sl@0	4307	*/
sl@0	4308	#define _INIT_SECURITY_POLICY_C1(c1) \
sl@0	4309	_INIT_SECURITY_POLICY_C3(c1,ECapability_None,ECapability_None)
sl@0	4310
sl@0	4311
sl@0	4312	/** Macro for compile-time definition of a security policy object
sl@0	4313	The policy will check for one capability.
sl@0	4314
sl@0	4315	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4316	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4317	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4318	function call operator n().
sl@0	4319
sl@0	4320	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4321	a compile time error or warning will be produced which includes the label
sl@0	4322	"__invalid_capability_value"
sl@0	4323
sl@0	4324	@param n Name to use for policy object
sl@0	4325	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4326
sl@0	4327	@publishedAll
sl@0	4328	@released
sl@0	4329	*/
sl@0	4330	#define _LIT_SECURITY_POLICY_C1(n,c1) \
sl@0	4331	_LIT_SECURITY_POLICY_C3(n,c1,ECapability_None,ECapability_None)
sl@0	4332
sl@0	4333
sl@0	4334	/** Macro for compile-time initialisation of a security policy object
sl@0	4335	The policy will check for a secure ID and three capabilities.
sl@0	4336
sl@0	4337	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4338	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4339	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4340	function call operator n().
sl@0	4341
sl@0	4342	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4343	a compile time error or warning be produced which includes the label
sl@0	4344	"__invalid_capability_value"
sl@0	4345
sl@0	4346	@param sid The SID value to check for
sl@0	4347	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4348	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4349	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4350
sl@0	4351	@publishedAll
sl@0	4352	@released
sl@0	4353	*/
sl@0	4354	#define _INIT_SECURITY_POLICY_S3(sid,c1,c2,c3) \
sl@0	4355	{ \
sl@0	4356	FOUR_TUINT8( \
sl@0	4357	(TUint8)TSecurityPolicy::ETypeS3, \
sl@0	4358	CAPABILITY_AS_TUINT8(c1), \
sl@0	4359	CAPABILITY_AS_TUINT8(c2), \
sl@0	4360	CAPABILITY_AS_TUINT8(c3) \
sl@0	4361	), \
sl@0	4362	(TUint32)(sid) \
sl@0	4363	}
sl@0	4364
sl@0	4365
sl@0	4366	/** Macro for compile-time definition of a security policy object
sl@0	4367	The policy will check for a secure ID and three capabilities.
sl@0	4368
sl@0	4369	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4370	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4371	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4372	function call operator n().
sl@0	4373
sl@0	4374	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4375	a compile time error or warning be produced which includes the label
sl@0	4376	"__invalid_capability_value"
sl@0	4377
sl@0	4378	@param n Name to use for policy object
sl@0	4379	@param sid The SID value to check for
sl@0	4380	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4381	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4382	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4383
sl@0	4384	@publishedAll
sl@0	4385	@released
sl@0	4386	*/
sl@0	4387	#define _LIT_SECURITY_POLICY_S3(n,sid,c1,c2,c3) \
sl@0	4388	const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_S3(sid,c1,c2,c3)
sl@0	4389
sl@0	4390
sl@0	4391	/** Macro for compile-time initialisation of a security policy object
sl@0	4392	The policy will check for a secure ID and two capabilities.
sl@0	4393
sl@0	4394	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4395	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4396	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4397	function call operator n().
sl@0	4398
sl@0	4399	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4400	a compile time error or warning be produced which includes the label
sl@0	4401	"__invalid_capability_value"
sl@0	4402
sl@0	4403	@param sid The SID value to check for
sl@0	4404	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4405	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4406
sl@0	4407	@publishedAll
sl@0	4408	@released
sl@0	4409	*/
sl@0	4410	#define _INIT_SECURITY_POLICY_S2(sid,c1,c2) \
sl@0	4411	_INIT_SECURITY_POLICY_S3(sid,c1,c2,ECapability_None)
sl@0	4412
sl@0	4413
sl@0	4414	/** Macro for compile-time definition of a security policy object
sl@0	4415	The policy will check for a secure ID and two capabilities.
sl@0	4416
sl@0	4417	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4418	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4419	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4420	function call operator n().
sl@0	4421
sl@0	4422	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4423	a compile time error or warning be produced which includes the label
sl@0	4424	"__invalid_capability_value"
sl@0	4425
sl@0	4426	@param n Name to use for policy object
sl@0	4427	@param sid The SID value to check for
sl@0	4428	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4429	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4430
sl@0	4431	@publishedAll
sl@0	4432	@released
sl@0	4433	*/
sl@0	4434	#define _LIT_SECURITY_POLICY_S2(n,sid,c1,c2) \
sl@0	4435	_LIT_SECURITY_POLICY_S3(n,sid,c1,c2,ECapability_None)
sl@0	4436
sl@0	4437
sl@0	4438	/** Macro for compile-time initialisation of a security policy object
sl@0	4439	The policy will check for a secure ID and one capability.
sl@0	4440
sl@0	4441	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4442	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4443	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4444	function call operator n().
sl@0	4445
sl@0	4446	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4447	a compile time error or warning be produced which includes the label
sl@0	4448	"__invalid_capability_value"
sl@0	4449
sl@0	4450	@param sid The SID value to check for
sl@0	4451	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4452
sl@0	4453	@publishedAll
sl@0	4454	@released
sl@0	4455	*/
sl@0	4456	#define _INIT_SECURITY_POLICY_S1(sid,c1) \
sl@0	4457	_INIT_SECURITY_POLICY_S3(sid,c1,ECapability_None,ECapability_None)
sl@0	4458
sl@0	4459
sl@0	4460	/** Macro for compile-time definition of a security policy object
sl@0	4461	The policy will check for a secure ID and one capability.
sl@0	4462
sl@0	4463	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4464	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4465	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4466	function call operator n().
sl@0	4467
sl@0	4468	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4469	a compile time error or warning be produced which includes the label
sl@0	4470	"__invalid_capability_value"
sl@0	4471
sl@0	4472	@param n Name to use for policy object
sl@0	4473	@param sid The SID value to check for
sl@0	4474	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4475
sl@0	4476	@publishedAll
sl@0	4477	@released
sl@0	4478	*/
sl@0	4479	#define _LIT_SECURITY_POLICY_S1(n,sid,c1) \
sl@0	4480	_LIT_SECURITY_POLICY_S3(n,sid,c1,ECapability_None,ECapability_None)
sl@0	4481
sl@0	4482
sl@0	4483	/** Macro for compile-time initialisation of a security policy object
sl@0	4484	The policy will check for a secure ID.
sl@0	4485
sl@0	4486	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4487	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4488	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4489	function call operator n().
sl@0	4490
sl@0	4491	@param sid The SID value to check for
sl@0	4492
sl@0	4493	@publishedAll
sl@0	4494	@released
sl@0	4495	*/
sl@0	4496	#define _INIT_SECURITY_POLICY_S0(sid) \
sl@0	4497	_INIT_SECURITY_POLICY_S3(sid,ECapability_None,ECapability_None,ECapability_None)
sl@0	4498
sl@0	4499
sl@0	4500	/** Macro for compile-time definition of a security policy object
sl@0	4501	The policy will check for a secure ID.
sl@0	4502
sl@0	4503	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4504	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4505	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4506	function call operator n().
sl@0	4507
sl@0	4508	@param n Name to use for policy object
sl@0	4509	@param sid The SID value to check for
sl@0	4510
sl@0	4511	@publishedAll
sl@0	4512	@released
sl@0	4513	*/
sl@0	4514	#define _LIT_SECURITY_POLICY_S0(n,sid) \
sl@0	4515	_LIT_SECURITY_POLICY_S3(n,sid,ECapability_None,ECapability_None,ECapability_None)
sl@0	4516
sl@0	4517
sl@0	4518	/** Macro for compile-time initialisation of a security policy object
sl@0	4519	The policy will check for a vendor ID and three capabilities.
sl@0	4520
sl@0	4521	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4522	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4523	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4524	function call operator n().
sl@0	4525
sl@0	4526	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4527	a compile time error or warning be produced which includes the label
sl@0	4528	"__invalid_capability_value"
sl@0	4529
sl@0	4530	@param vid The VID value to check for
sl@0	4531	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4532	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4533	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4534
sl@0	4535	@publishedAll
sl@0	4536	@released
sl@0	4537	*/
sl@0	4538	#define _INIT_SECURITY_POLICY_V3(vid,c1,c2,c3) \
sl@0	4539	{ \
sl@0	4540	FOUR_TUINT8( \
sl@0	4541	(TUint8)TSecurityPolicy::ETypeV3, \
sl@0	4542	CAPABILITY_AS_TUINT8(c1), \
sl@0	4543	CAPABILITY_AS_TUINT8(c2), \
sl@0	4544	CAPABILITY_AS_TUINT8(c3) \
sl@0	4545	), \
sl@0	4546	(TUint32)(vid) \
sl@0	4547	}
sl@0	4548
sl@0	4549
sl@0	4550	/** Macro for compile-time definition of a security policy object
sl@0	4551	The policy will check for a vendor ID and three capabilities.
sl@0	4552
sl@0	4553	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4554	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4555	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4556	function call operator n().
sl@0	4557
sl@0	4558	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4559	a compile time error or warning be produced which includes the label
sl@0	4560	"__invalid_capability_value"
sl@0	4561
sl@0	4562	@param n Name to use for policy object
sl@0	4563	@param vid The VID value to check for
sl@0	4564	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4565	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4566	@param c3 The third capability to check (enumerator of TCapability)
sl@0	4567
sl@0	4568	@publishedAll
sl@0	4569	@released
sl@0	4570	*/
sl@0	4571	#define _LIT_SECURITY_POLICY_V3(n,vid,c1,c2,c3) \
sl@0	4572	const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_V3(vid,c1,c2,c3)
sl@0	4573
sl@0	4574
sl@0	4575	/** Macro for compile-time initialisation of a security policy object
sl@0	4576	The policy will check for a vendor ID and two capabilities.
sl@0	4577
sl@0	4578	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4579	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4580	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4581	function call operator n().
sl@0	4582
sl@0	4583	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4584	a compile time error or warning be produced which includes the label
sl@0	4585	"__invalid_capability_value"
sl@0	4586
sl@0	4587	@param vid The VID value to check for
sl@0	4588	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4589	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4590
sl@0	4591	@publishedAll
sl@0	4592	@released
sl@0	4593	*/
sl@0	4594	#define _INIT_SECURITY_POLICY_V2(vid,c1,c2) \
sl@0	4595	_INIT_SECURITY_POLICY_V3(vid,c1,c2,ECapability_None)
sl@0	4596
sl@0	4597
sl@0	4598	/** Macro for compile-time definition of a security policy object
sl@0	4599	The policy will check for a vendor ID and two capabilities.
sl@0	4600
sl@0	4601	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4602	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4603	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4604	function call operator n().
sl@0	4605
sl@0	4606	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4607	a compile time error or warning be produced which includes the label
sl@0	4608	"__invalid_capability_value"
sl@0	4609
sl@0	4610	@param n Name to use for policy object
sl@0	4611	@param vid The VID value to check for
sl@0	4612	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4613	@param c2 The second capability to check (enumerator of TCapability)
sl@0	4614
sl@0	4615	@publishedAll
sl@0	4616	@released
sl@0	4617	*/
sl@0	4618	#define _LIT_SECURITY_POLICY_V2(n,vid,c1,c2) \
sl@0	4619	_LIT_SECURITY_POLICY_V3(n,vid,c1,c2,ECapability_None)
sl@0	4620
sl@0	4621
sl@0	4622	/** Macro for compile-time initialisation of a security policy object
sl@0	4623	The policy will check for a vendor ID and one capability.
sl@0	4624
sl@0	4625	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4626	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4627	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4628	function call operator n().
sl@0	4629
sl@0	4630	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4631	a compile time error or warning be produced which includes the label
sl@0	4632	"__invalid_capability_value"
sl@0	4633
sl@0	4634	@param vid The VID value to check for
sl@0	4635	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4636
sl@0	4637	@publishedAll
sl@0	4638	@released
sl@0	4639	*/
sl@0	4640	#define _INIT_SECURITY_POLICY_V1(vid,c1) \
sl@0	4641	_INIT_SECURITY_POLICY_V3(vid,c1,ECapability_None,ECapability_None)
sl@0	4642
sl@0	4643
sl@0	4644	/** Macro for compile-time definition of a security policy object
sl@0	4645	The policy will check for a vendor ID and one capability.
sl@0	4646
sl@0	4647	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4648	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4649	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4650	function call operator n().
sl@0	4651
sl@0	4652	If an invlid capability value is specified then, dependant on the compiler,
sl@0	4653	a compile time error or warning be produced which includes the label
sl@0	4654	"__invalid_capability_value"
sl@0	4655
sl@0	4656	@param n Name to use for policy object
sl@0	4657	@param vid The VID value to check for
sl@0	4658	@param c1 The first capability to check (enumerator of TCapability)
sl@0	4659
sl@0	4660	@publishedAll
sl@0	4661	@released
sl@0	4662	*/
sl@0	4663	#define _LIT_SECURITY_POLICY_V1(n,vid,c1) \
sl@0	4664	_LIT_SECURITY_POLICY_V3(n,vid,c1,ECapability_None,ECapability_None)
sl@0	4665
sl@0	4666
sl@0	4667	/** Macro for compile-time initialisation of a security policy object
sl@0	4668	The policy will check for a vendor ID.
sl@0	4669
sl@0	4670	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4671	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4672	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4673	function call operator n().
sl@0	4674
sl@0	4675	@param vid The VID value to check for
sl@0	4676
sl@0	4677	@publishedAll
sl@0	4678	@released
sl@0	4679	*/
sl@0	4680	#define _INIT_SECURITY_POLICY_V0(vid) \
sl@0	4681	_INIT_SECURITY_POLICY_V3(vid,ECapability_None,ECapability_None,ECapability_None)
sl@0	4682
sl@0	4683
sl@0	4684	/** Macro for compile-time definition of a security policy object
sl@0	4685	The policy will check for a vendor ID.
sl@0	4686
sl@0	4687	The object declared has an implicit conversion to const TSecurityPolicy&.
sl@0	4688	Taking the address of the object will return a const TSecurityPolicy*.
sl@0	4689	Explicit conversion to const TSecurityPolicy& may be effected by using the
sl@0	4690	function call operator n().
sl@0	4691
sl@0	4692	@param n Name to use for policy object
sl@0	4693	@param vid The VID value to check for
sl@0	4694
sl@0	4695	@publishedAll
sl@0	4696	@released
sl@0	4697	*/
sl@0	4698	#define _LIT_SECURITY_POLICY_V0(n,vid) \
sl@0	4699	_LIT_SECURITY_POLICY_V3(n,vid,ECapability_None,ECapability_None,ECapability_None)
sl@0	4700
sl@0	4701
sl@0	4702
sl@0	4703	#ifdef __KERNEL_MODE__
sl@0	4704	class DThread;
sl@0	4705	class RMessageK;
sl@0	4706	#endif
sl@0	4707	class TPlatSecDiagnostic;
sl@0	4708
sl@0	4709	/**
sl@0	4710	Class containing Platform Security related methods
sl@0	4711	@internalTechnology
sl@0	4712	*/
sl@0	4713	class PlatSec
sl@0	4714	{
sl@0	4715	#ifndef __KERNEL_MODE__
sl@0	4716	public:
sl@0	4717	/**
sl@0	4718	Tests whether a given Platform Security capability is enforced by the system.
sl@0	4719
sl@0	4720	Capabilities may not be enforced for several reasons:
sl@0	4721	-# The capability has been explicitly disabled on this system
sl@0	4722	by use of the PlatSecDisabledCaps configuration parameter
sl@0	4723	-# Platform Security checks have been globally disabled
sl@0	4724	by use of the EPlatSecEnforcement configuration parameter
sl@0	4725	-# The capability value is unknown. I.e. Is not part of the set of supported
sl@0	4726	capabilities. See TCapabilitySet::SetAllSupported().
sl@0	4727
sl@0	4728	@param aCapability The capability to test
sl@0	4729	@return A non-zero value if the capability is enforced, zero if it is not.
sl@0	4730
sl@0	4731	@publishedAll
sl@0	4732	@released
sl@0	4733	*/
sl@0	4734	IMPORT_C static TBool IsCapabilityEnforced(TCapability aCapability);
sl@0	4735
sl@0	4736	/**
sl@0	4737	An enumeration used with PlatSecSetting()
sl@0	4738	@see PlatSecSetting()
sl@0	4739	@publishedAll
sl@0	4740	@test
sl@0	4741	*/
sl@0	4742	enum TConfigSetting
sl@0	4743	{
sl@0	4744	EPlatSecEnforcement, /*< Used to request the value of the PlatSecEnforcement setting /
sl@0	4745	EPlatSecDiagnotics, /*< Used to request the value of the PlatSecDiagnotics setting /
sl@0	4746	EPlatSecProcessIsolation, /*< Used to request the value of the PlatSecProcessIsolation setting /
sl@0	4747	EPlatSecEnforceSysBin, /*< Used to request the value of the PlatSecEnforceSysBin setting /
sl@0	4748	EPlatSecLocked, /*< Used to request the value of the PlatSecLocked setting /
sl@0	4749	};
sl@0	4750
sl@0	4751	/**
sl@0	4752	A test function to return the state of a given Platform Security configuration setting.
sl@0	4753	@param aSetting An enumerated value representing the required setting
sl@0	4754	@return A value representing the setting. 0 represents 'OFF', 1 represents 'ON'
sl@0	4755	Other values may be returned for some settings, these exceptions are documented
sl@0	4756	in the description for individual enumerations of TConfigSetting.
sl@0	4757	@see TConfigSetting
sl@0	4758	@publishedAll
sl@0	4759	@test
sl@0	4760	*/
sl@0	4761	IMPORT_C static TInt ConfigSetting(TConfigSetting aSetting);
sl@0	4762
sl@0	4763	#endif // Not __KERNEL_MODE__
sl@0	4764
sl@0	4765	//
sl@0	4766	// All methods below here are internalTechnology
sl@0	4767	//
sl@0	4768
sl@0	4769	#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	4770	public:
sl@0	4771	/** @internalTechnology */
sl@0	4772	static inline TInt LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
sl@0	4773	#ifdef __KERNEL_MODE__
sl@0	4774	/** @internalTechnology */
sl@0	4775	static inline TInt CapabilityCheckFail(const DProcess* aViolatingProcess, TCapability aCapability, const char* aContextText);
sl@0	4776	/** @internalTechnology */
sl@0	4777	static inline TInt CapabilityCheckFail(const DThread* aViolatingThread, TCapability aCapability, const char* aContextText);
sl@0	4778	/** @internalTechnology */
sl@0	4779	static inline TInt SecureIdCheckFail(const DProcess* aViolatingProcess, TSecureId aSid, const char* aContextText);
sl@0	4780	/** @internalTechnology */
sl@0	4781	static inline TInt PolicyCheckFail(const DProcess* aProcess, const SSecurityInfo& aMissing, const char* aContextText);
sl@0	4782	/** @internalTechnology */
sl@0	4783	static inline TInt PolicyCheckFail(const DThread* aProcess, const SSecurityInfo& aMissing, const char* aContextText);
sl@0	4784	/** @internalTechnology */
sl@0	4785	static inline TInt ProcessIsolationFail(const char* aContextText);
sl@0	4786	/** @internalTechnology */
sl@0	4787	static inline TInt ProcessIsolationIPCFail(RMessageK* aMessage, const char* aContextText);
sl@0	4788	#else // !__KERNEL_MODE__
sl@0	4789	/** @internalTechnology */
sl@0	4790	static inline TInt LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
sl@0	4791	/** @internalTechnology */
sl@0	4792	static inline TInt CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText);
sl@0	4793	/** @internalTechnology */
sl@0	4794	static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText);
sl@0	4795	/** @internalTechnology */
sl@0	4796	static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText);
sl@0	4797	/** @internalTechnology */
sl@0	4798	static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText);
sl@0	4799	/** @internalTechnology */
sl@0	4800	static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing, const char* aContextText);
sl@0	4801	/** @internalTechnology */
sl@0	4802	static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText);
sl@0	4803	/** @internalTechnology */
sl@0	4804	static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText);
sl@0	4805	/** @internalTechnology */
sl@0	4806	static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps, const char* aContextText);
sl@0	4807	/** @internalTechnology */
sl@0	4808	static inline TInt PolicyCheckFail(RSessionBase aSession, const SSecurityInfo& aMissingCaps, const char* aContextText);
sl@0	4809	/** @internalTechnology */
sl@0	4810	static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps, const char* aContextText);
sl@0	4811	/** @internalTechnology */
sl@0	4812	static inline TInt CreatorCapabilityCheckFail(TCapability aCapability);
sl@0	4813	/** @internalTechnology */
sl@0	4814	static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps);
sl@0	4815	/** @internalTechnology */
sl@0	4816	static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability);
sl@0	4817	/** @internalTechnology */
sl@0	4818	static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps);
sl@0	4819	/** @internalTechnology */
sl@0	4820	static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing);
sl@0	4821	/** @internalTechnology */
sl@0	4822	static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability);
sl@0	4823	/** @internalTechnology */
sl@0	4824	static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps);
sl@0	4825	/** @internalTechnology */
sl@0	4826	static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps);
sl@0	4827	/** @internalTechnology */
sl@0	4828	static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps);
sl@0	4829	#endif //__KERNEL_MODE__
sl@0	4830
sl@0	4831	private:
sl@0	4832	UIMPORT_C static TInt EmitDiagnostic(TPlatSecDiagnostic& aDiagnostic, const char* aContextText);
sl@0	4833	#else //__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	4834	#ifndef __KERNEL_MODE__
sl@0	4835	private:
sl@0	4836	IMPORT_C static TInt EmitDiagnostic(TPlatSecDiagnostic& aDiagnostic, const char* aContextText);
sl@0	4837	#endif // !__KERNEL_MODE__
sl@0	4838	#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
sl@0	4839
sl@0	4840	public:
sl@0	4841	/** @internalTechnology */
sl@0	4842	UIMPORT_C static TInt EmitDiagnostic();
sl@0	4843	};
sl@0	4844
sl@0	4845
sl@0	4846	#define KMaxSerialNumLength 64
sl@0	4847	typedef TBuf8<KMaxSerialNumLength> TMediaSerialNumber;
sl@0	4848
sl@0	4849
sl@0	4850	/**
sl@0	4851	@publishedAll
sl@0	4852	@released
sl@0	4853
sl@0	4854	Contains information about the code and data sections belonging to a process.
sl@0	4855
sl@0	4856	@see RProcess::GetMemoryInfo
sl@0	4857	*/
sl@0	4858	class TProcessMemoryInfo
sl@0	4859	{
sl@0	4860	public:
sl@0	4861	/**
sl@0	4862	The code base address (.text).
sl@0	4863	*/
sl@0	4864	TUint32 iCodeBase;
sl@0	4865
sl@0	4866
sl@0	4867	/**
sl@0	4868	The size of the code section (.text).
sl@0	4869	*/
sl@0	4870	TUint32 iCodeSize;
sl@0	4871
sl@0	4872
sl@0	4873	/**
sl@0	4874	The base address of the constant data section (.radata).
sl@0	4875	*/
sl@0	4876	TUint32 iConstDataBase;
sl@0	4877
sl@0	4878
sl@0	4879	/**
sl@0	4880	The size of the constant data section (.radata).
sl@0	4881	*/
sl@0	4882
sl@0	4883	TUint32 iConstDataSize;
sl@0	4884
sl@0	4885
sl@0	4886	/**
sl@0	4887	The base address of the initialised data section (.data).
sl@0	4888	*/
sl@0	4889	TUint32 iInitialisedDataBase;
sl@0	4890
sl@0	4891
sl@0	4892	/**
sl@0	4893	The size of the initialised data section (.data).
sl@0	4894	*/
sl@0	4895	TUint32 iInitialisedDataSize;
sl@0	4896
sl@0	4897
sl@0	4898	/**
sl@0	4899	The base address of the uninitialised data section (.bss).
sl@0	4900	*/
sl@0	4901	TUint32 iUninitialisedDataBase;
sl@0	4902
sl@0	4903
sl@0	4904	/**
sl@0	4905	The size of the uninitialised data section (.bss).
sl@0	4906	*/
sl@0	4907	TUint32 iUninitialisedDataSize;
sl@0	4908	};
sl@0	4909
sl@0	4910
sl@0	4911
sl@0	4912
sl@0	4913	/**
sl@0	4914	@publishedAll
sl@0	4915	@released
sl@0	4916
sl@0	4917	Defines a more useful synonym for TProcessMemoryInfo.
sl@0	4918	*/
sl@0	4919	typedef TProcessMemoryInfo TModuleMemoryInfo; // more accurate name - remove old one later
sl@0	4920
sl@0	4921
sl@0	4922
sl@0	4923
sl@0	4924	#ifndef __KERNEL_MODE__
sl@0	4925	class CBase;
sl@0	4926	/**
sl@0	4927	@publishedAll
sl@0	4928	@released
sl@0	4929
sl@0	4930	Generic array.
sl@0	4931
sl@0	4932	This class defines a generic array which can be constructed by any of the
sl@0	4933	following templated concrete arrays:
sl@0	4934
sl@0	4935	1. CArrayFixFlat<class T>
sl@0	4936
sl@0	4937	2. CArrayFixSeg<class T>
sl@0	4938
sl@0	4939	3. CArrayVarFlat<class T>
sl@0	4940
sl@0	4941	4. CArrayVarSeg<class T>
sl@0	4942
sl@0	4943	5. CArrayPakFlat<class T>
sl@0	4944
sl@0	4945	6. RArray<class T>
sl@0	4946
sl@0	4947	7. RPointerArray<class T>
sl@0	4948
sl@0	4949	and also by the following template specialisation classes:
sl@0	4950
sl@0	4951	1. RArray<TInt>
sl@0	4952
sl@0	4953	2. RArray<TUint>
sl@0	4954
sl@0	4955	It allows a degree of polymorphism amongst the array classes. It permits the
sl@0	4956	operator[] and the Count() member functions of an array to be invoked without
sl@0	4957	knowing which array class has been used to construct that array.
sl@0	4958
sl@0	4959	TArray allows access to elements of an array but does not permit changes to
sl@0	4960	those elements.
sl@0	4961
sl@0	4962	Use the Array() member function of an array to construct and return
sl@0	4963	a TArray<class T> object for that array.
sl@0	4964
sl@0	4965	A TArray<class T> type object is not intended to be constructed explicitly
sl@0	4966	by user code.
sl@0	4967
sl@0	4968	@see CArrayFixFlat
sl@0	4969	@see CArrayFixSeg
sl@0	4970	@see CArrayVarFlat
sl@0	4971	@see CArrayVarSeg
sl@0	4972	@see CArrayPakFlat
sl@0	4973	@see RArray
sl@0	4974	@see RPointerArray
sl@0	4975	@see RArray<TInt>
sl@0	4976	@see RArray<TUint>
sl@0	4977	*/
sl@0	4978	template <class T>
sl@0	4979	class TArray
sl@0	4980	{
sl@0	4981	public:
sl@0	4982	inline TArray(TInt (aCount)(const CBase aPtr),const TAny(anAt)(const CBase* aPtr,TInt anIndex),const CBase* aPtr);
sl@0	4983	inline TInt Count() const;
sl@0	4984	inline const T& operator[](TInt anIndex) const;
sl@0	4985	private:
sl@0	4986	const CBase* iPtr;
sl@0	4987	TInt (iCount)(const CBase aPtr);
sl@0	4988	const TAny(iAt)(const CBase* aPtr,TInt anIndex);
sl@0	4989	};
sl@0	4990	#endif
sl@0	4991
sl@0	4992
sl@0	4993
sl@0	4994
sl@0	4995	/**
sl@0	4996	@publishedAll
sl@0	4997	@released
sl@0	4998
sl@0	4999	Defines a function type used by a TIdentityRelation object.
sl@0	5000
sl@0	5001	A function of this type implements an algorithm for determining whether
sl@0	5002	two objects match.
sl@0	5003
sl@0	5004	@see TIdentityRelation
sl@0	5005	*/
sl@0	5006	typedef TBool (TGeneralIdentityRelation)(const TAny, const TAny*);
sl@0	5007
sl@0	5008
sl@0	5009
sl@0	5010
sl@0	5011	/**
sl@0	5012	@publishedAll
sl@0	5013	@released
sl@0	5014
sl@0	5015	Defines a function type used by a TLinearOrder object
sl@0	5016
sl@0	5017	A function of this type implements an algorithm that determines
sl@0	5018	the order of two objects.
sl@0	5019
sl@0	5020	@see TLinearOrder
sl@0	5021	*/
sl@0	5022	typedef TInt (TGeneralLinearOrder)(const TAny, const TAny*);
sl@0	5023
sl@0	5024
sl@0	5025
sl@0	5026
sl@0	5027	/**
sl@0	5028	@publishedAll
sl@0	5029	@released
sl@0	5030
sl@0	5031	A templated class which packages a function that determines whether two
sl@0	5032	objects of a given class type match. During linear search operations the search
sl@0	5033	term is always passed as the first argument and the second argument is an
sl@0	5034	element of the array being searched.
sl@0	5035
sl@0	5036	A TIdentityRelation<T> object is constructed and passed as a parameter to
sl@0	5037	member functions of the array classes RArray<T> and RPointerArray<T>.
sl@0	5038
sl@0	5039	@see RArray
sl@0	5040	@see RPointerArray
sl@0	5041	*/
sl@0	5042	template <class T>
sl@0	5043	class TIdentityRelation
sl@0	5044	{
sl@0	5045	public:
sl@0	5046	inline TIdentityRelation();
sl@0	5047	inline TIdentityRelation( TBool (*anIdentity)(const T&, const T&) );
sl@0	5048	inline operator TGeneralIdentityRelation() const;
sl@0	5049	private:
sl@0	5050	inline static TBool EqualityOperatorCompare(const T& aLeft, const T& aRight);
sl@0	5051	private:
sl@0	5052	TGeneralIdentityRelation iIdentity;
sl@0	5053	};
sl@0	5054
sl@0	5055
sl@0	5056
sl@0	5057	/**
sl@0	5058	@publishedAll
sl@0	5059	@released
sl@0	5060
sl@0	5061	A set of common identity relations for frequently occurring types.
sl@0	5062
sl@0	5063	@see RArray
sl@0	5064	@see RPointerArray
sl@0	5065	@see RHashSet
sl@0	5066	@see RPtrHashSet
sl@0	5067	@see RHashMap
sl@0	5068	@see RPtrHashMap
sl@0	5069	*/
sl@0	5070	class DefaultIdentity
sl@0	5071	{
sl@0	5072	public:
sl@0	5073	IMPORT_C static TBool Integer(const TInt&, const TInt&);
sl@0	5074	IMPORT_C static TBool Des8(const TDesC8&, const TDesC8&);
sl@0	5075	IMPORT_C static TBool Des16(const TDesC16&, const TDesC16&);
sl@0	5076	IMPORT_C static TBool IntegerPtr(TInt* const&, TInt* const&);
sl@0	5077	IMPORT_C static TBool Des8Ptr(TDesC8* const&, TDesC8* const&);
sl@0	5078	IMPORT_C static TBool Des16Ptr(TDesC16* const&, TDesC16* const&);
sl@0	5079	};
sl@0	5080
sl@0	5081
sl@0	5082
sl@0	5083
sl@0	5084	/**
sl@0	5085	@publishedAll
sl@0	5086	@released
sl@0	5087
sl@0	5088	A templated class which packages a function that determines the order of two
sl@0	5089	objects of a given class type. During binary search operations the search term
sl@0	5090	is always passed as the first argument and the second argument is an element
sl@0	5091	of the array being searched.
sl@0	5092
sl@0	5093	A TLinearOrder<T> object is constructed and passed as a parameter to member
sl@0	5094	functions of the array classes RArray<T> and RPointerArray<T>.
sl@0	5095
sl@0	5096	@see RArray
sl@0	5097	@see RPointerArray
sl@0	5098	*/
sl@0	5099	template <class T>
sl@0	5100	class TLinearOrder
sl@0	5101	{
sl@0	5102	public:
sl@0	5103	inline TLinearOrder( TInt(*anOrder)(const T&, const T&) );
sl@0	5104	inline operator TGeneralLinearOrder() const;
sl@0	5105	private:
sl@0	5106	TGeneralLinearOrder iOrder;
sl@0	5107	};
sl@0	5108
sl@0	5109
sl@0	5110	/*
sl@0	5111	@publishedAll
sl@0	5112	@released
sl@0	5113
sl@0	5114	A set of values that tell array search functions which array element is to be
sl@0	5115	returned when there are duplicate elements in the array.
sl@0	5116
sl@0	5117	These values are used by RArray, RPointerArray, RArray<TInt>,
sl@0	5118	and RArray<TUint> search functions.
sl@0	5119
sl@0	5120	Examples of functions that take
sl@0	5121	these enum values are: RPointerArray::SpecificFindInOrderL(),
sl@0	5122	and RArray::SpecificFindInSignedKeyOrder().
sl@0	5123
sl@0	5124	@see RArray
sl@0	5125	@see RPointerArray
sl@0	5126	@see RArray<TInt>
sl@0	5127	@see RArray<TUint>
sl@0	5128	*/
sl@0	5129	enum TArrayFindMode
sl@0	5130	{
sl@0	5131	/**
sl@0	5132	Indicates that any element in a block of duplicate elements can be
sl@0	5133	returned by a search function.
sl@0	5134
sl@0	5135	Note that using this mode, there can be no guarantee that the element
sl@0	5136	returned by the search functions will be the same if the size of the array
sl@0	5137	changes between successive calls to those functions.
sl@0	5138	*/
sl@0	5139	EArrayFindMode_Any = 0,
sl@0	5140
sl@0	5141	/**
sl@0	5142	Indicates that the first element in a block of duplicate elements
sl@0	5143	is returned.
sl@0	5144	*/
sl@0	5145	EArrayFindMode_First = 1,
sl@0	5146
sl@0	5147	/**
sl@0	5148	Indicates that the first element after the last element in a block
sl@0	5149	of duplicate elements is returned.
sl@0	5150	*/
sl@0	5151	EArrayFindMode_Last = 2,
sl@0	5152
sl@0	5153	/**
sl@0	5154	@internalTechnology
sl@0	5155	*/
sl@0	5156	EArrayFindMode_Limit = 3
sl@0	5157	};
sl@0	5158
sl@0	5159
sl@0	5160	/**
sl@0	5161	@internalComponent
sl@0	5162
sl@0	5163	Base class used in the derivation of RPointerArray, RArray<TInt>,
sl@0	5164	and RArray<TUint>.
sl@0	5165
sl@0	5166	The base class is inherited privately.
sl@0	5167
sl@0	5168	The class is internal and is not intended for use.
sl@0	5169	*/
sl@0	5170	class RPointerArrayBase
sl@0	5171	{
sl@0	5172	protected:
sl@0	5173	IMPORT_C RPointerArrayBase();
sl@0	5174	IMPORT_C RPointerArrayBase(TInt aGranularity);
sl@0	5175	IMPORT_C RPointerArrayBase(TInt aMinGrowBy, TInt aFactor);
sl@0	5176	IMPORT_C void Close();
sl@0	5177	IMPORT_C TInt Count() const;
sl@0	5178	inline void ZeroCount() {iCount=0;}
sl@0	5179	inline TAny** Entries() {return iEntries;}
sl@0	5180	IMPORT_C TAny*& At(TInt anIndex) const;
sl@0	5181	IMPORT_C TInt Append(const TAny* anEntry);
sl@0	5182	IMPORT_C TInt Insert(const TAny* anEntry, TInt aPos);
sl@0	5183	IMPORT_C void Remove(TInt anIndex);
sl@0	5184	IMPORT_C void Compress();
sl@0	5185	IMPORT_C void Reset();
sl@0	5186	IMPORT_C TInt Find(const TAny* anEntry) const;
sl@0	5187	IMPORT_C TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const;
sl@0	5188	IMPORT_C TInt FindReverse(const TAny* aEntry) const;
sl@0	5189	IMPORT_C TInt FindReverse(const TAny* aEntry, TGeneralIdentityRelation aIdentity) const;
sl@0	5190	IMPORT_C TInt FindIsqSigned(TInt anEntry) const;
sl@0	5191	IMPORT_C TInt FindIsqUnsigned(TUint anEntry) const;
sl@0	5192	IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const;
sl@0	5193	IMPORT_C TInt FindIsqSigned(TInt anEntry, TInt aMode) const;
sl@0	5194	IMPORT_C TInt FindIsqUnsigned(TUint anEntry, TInt aMode) const;
sl@0	5195	IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const;
sl@0	5196	IMPORT_C TInt InsertIsqSigned(TInt anEntry, TBool aAllowRepeats);
sl@0	5197	IMPORT_C TInt InsertIsqUnsigned(TUint anEntry, TBool aAllowRepeats);
sl@0	5198	IMPORT_C TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats);
sl@0	5199	IMPORT_C TInt BinarySearchSigned(TInt anEntry, TInt& anIndex) const;
sl@0	5200	IMPORT_C TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex) const;
sl@0	5201	IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const;
sl@0	5202	IMPORT_C TInt BinarySearchSigned(TInt anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5203	IMPORT_C TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5204	IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const;
sl@0	5205	#ifndef __KERNEL_MODE__
sl@0	5206	IMPORT_C RPointerArrayBase(TAny** aEntries, TInt aCount);
sl@0	5207	IMPORT_C void GranularCompress();
sl@0	5208	IMPORT_C TInt DoReserve(TInt aCount);
sl@0	5209	IMPORT_C void HeapSortSigned();
sl@0	5210	IMPORT_C void HeapSortUnsigned();
sl@0	5211	IMPORT_C void HeapSort(TGeneralLinearOrder anOrder);
sl@0	5212	IMPORT_C static TInt GetCount(const CBase* aPtr);
sl@0	5213	IMPORT_C static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex);
sl@0	5214	#endif
sl@0	5215	private:
sl@0	5216	TInt Grow();
sl@0	5217	private:
sl@0	5218	TInt iCount;
sl@0	5219	TAny** iEntries;
sl@0	5220	TInt iAllocated;
sl@0	5221	TInt iGranularity; // positive means linear, negative means exponential growth
sl@0	5222	TInt iSpare1;
sl@0	5223	TInt iSpare2;
sl@0	5224	};
sl@0	5225
sl@0	5226
sl@0	5227
sl@0	5228
sl@0	5229	/**
sl@0	5230	@publishedAll
sl@0	5231	@released
sl@0	5232
sl@0	5233	A simple and efficient array of pointers to objects.
sl@0	5234
sl@0	5235	The elements of the array are pointers to instances of a class; this class
sl@0	5236	is specified as the template parameter T.
sl@0	5237
sl@0	5238	The class offers standard array behaviour which includes insertion, appending
sl@0	5239	and sorting of pointers.
sl@0	5240
sl@0	5241	Derivation from RPointerArrayBase is private.
sl@0	5242	*/
sl@0	5243	template <class T>
sl@0	5244	class RPointerArray : private RPointerArrayBase
sl@0	5245	{
sl@0	5246	public:
sl@0	5247	inline RPointerArray();
sl@0	5248	inline explicit RPointerArray(TInt aGranularity);
sl@0	5249	inline RPointerArray(TInt aMinGrowBy, TInt aFactor);
sl@0	5250	inline void Close();
sl@0	5251	inline TInt Count() const;
sl@0	5252	inline T* const& operator[](TInt anIndex) const;
sl@0	5253	inline T*& operator[](TInt anIndex);
sl@0	5254	inline TInt Append(const T* anEntry);
sl@0	5255	inline TInt Insert(const T* anEntry, TInt aPos);
sl@0	5256	inline void Remove(TInt anIndex);
sl@0	5257	inline void Compress();
sl@0	5258	inline void Reset();
sl@0	5259	void ResetAndDestroy();
sl@0	5260	inline TInt Find(const T* anEntry) const;
sl@0	5261	inline TInt Find(const T* anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5262	template <class K>
sl@0	5263	inline TInt Find(const K& aKey, TBool (apfnCompare)(const K k, const T& t)) const
sl@0	5264	/**
sl@0	5265	Finds the first object pointer in the array which matches aKey using
sl@0	5266	the comparison algorithm provided by apfnCompare.
sl@0	5267
sl@0	5268	The find operation always starts at the low index end of the array. There
sl@0	5269	is no assumption about the order of objects in the array.
sl@0	5270
sl@0	5271	@param aKey The key of type K to be compared with the elements of the array using apfnCompare.
sl@0	5272	@param apfnCompare A function defining the identity relation between the
sl@0	5273	object pointers in the array, and their keys of type K. The
sl@0	5274	function returns true if k and t match based on this relationship.
sl@0	5275
sl@0	5276	@return The index of the first matching object pointer within the array.
sl@0	5277	KErrNotFound, if no suitable object pointer can be found.
sl@0	5278	*/
sl@0	5279	{ return RPointerArrayBase::Find((T)&aKey,(TIdentityRelation<T>*)&apfnCompare); }
sl@0	5280	inline TInt FindReverse(const T* anEntry) const;
sl@0	5281	inline TInt FindReverse(const T* anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5282	template <class K>
sl@0	5283	inline TInt FindReverse(const K& aKey, TInt (apfnMatch)(const K k, const T& t)) const
sl@0	5284	/**
sl@0	5285	Finds the first object pointer in the array which matches aKey using
sl@0	5286	the comparison algorithm provided by apfnCompare.
sl@0	5287
sl@0	5288	The find operation always starts at the high index end of the array. There
sl@0	5289	is no assumption about the order of objects in the array.
sl@0	5290
sl@0	5291	@param aKey The key of type K to be compared with the elements of the array using apfnMatch.
sl@0	5292	@param apfnMatch A function defining the identity relation between the
sl@0	5293	object pointers in the array, and their keys of type K. The
sl@0	5294	function returns true if k and t match based on this relationship.
sl@0	5295
sl@0	5296	@return The index of the first matching object pointer within the array.
sl@0	5297	KErrNotFound, if no suitable object pointer can be found.
sl@0	5298	*/
sl@0	5299
sl@0	5300	{ return RPointerArrayBase::FindReverse((T)&aKey,(TIdentityRelation<T>*)&apfnMatch); }
sl@0	5301	inline TInt FindInAddressOrder(const T* anEntry) const;
sl@0	5302	inline TInt FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const;
sl@0	5303	inline TInt FindInAddressOrder(const T* anEntry, TInt& anIndex) const;
sl@0	5304	inline TInt FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
sl@0	5305	template <class K>
sl@0	5306	inline TInt FindInOrder(const K& aKey, TInt (apfnCompare)(const K k, const T& t)) const
sl@0	5307	/**
sl@0	5308	Finds the object pointer in the array whose object matches the specified
sl@0	5309	key, (Using the relationship defined within apfnCompare) using a binary search
sl@0	5310	technique and an ordering algorithm.
sl@0	5311
sl@0	5312	The function assumes that existing object pointers in the array are ordered
sl@0	5313	so that the objects themselves are in object order as determined by an algorithm
sl@0	5314	supplied by the caller and packaged as a TLinearOrder<T>.
sl@0	5315
sl@0	5316	@param aKey The key of type K to be compared with the elements of the array using apfnCompare.
sl@0	5317	@param apfnCompare A function which defines the order that the array was sorted,
sl@0	5318	where in it aKey (via the defined relationship) should fit, and if the key is present.
sl@0	5319
sl@0	5320	@return The index of the matching object pointer within the array.
sl@0	5321	KErrNotFound, if no suitable object pointer can be found.
sl@0	5322	*/
sl@0	5323	{ return RPointerArrayBase::FindIsq((T)&aKey,(TLinearOrder<T>*)&apfnCompare); }
sl@0	5324	inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const;
sl@0	5325	inline TInt SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5326	inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5327	inline TInt SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5328	inline TInt InsertInAddressOrder(const T* anEntry);
sl@0	5329	inline TInt InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder);
sl@0	5330	inline TInt InsertInAddressOrderAllowRepeats(const T* anEntry);
sl@0	5331	inline TInt InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder);
sl@0	5332	#ifndef __KERNEL_MODE__
sl@0	5333	inline void AppendL(const T* anEntry);
sl@0	5334	inline void InsertL(const T* anEntry, TInt aPos);
sl@0	5335	inline TInt FindL(const T* anEntry) const;
sl@0	5336	inline TInt FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5337	inline TInt FindReverseL(const T* anEntry) const;
sl@0	5338	inline TInt FindReverseL(const T* anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5339	inline TInt FindInAddressOrderL(const T* anEntry) const;
sl@0	5340	inline TInt FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const;
sl@0	5341	inline void FindInAddressOrderL(const T* anEntry, TInt& anIndex) const;
sl@0	5342	inline void FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
sl@0	5343	inline TInt SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const;
sl@0	5344	inline TInt SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5345	inline void SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5346	inline void SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5347	inline void InsertInAddressOrderL(const T* anEntry);
sl@0	5348	inline void InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder);
sl@0	5349	inline void InsertInAddressOrderAllowRepeatsL(const T* anEntry);
sl@0	5350	inline void InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder);
sl@0	5351
sl@0	5352	inline RPointerArray(T** aEntries, TInt aCount);
sl@0	5353	inline void GranularCompress();
sl@0	5354	inline TInt Reserve(TInt aCount);
sl@0	5355	inline void ReserveL(TInt aCount);
sl@0	5356	inline void SortIntoAddressOrder();
sl@0	5357	inline void Sort(TLinearOrder<T> anOrder);
sl@0	5358	inline TArray<T*> Array() const;
sl@0	5359	#endif
sl@0	5360	};
sl@0	5361
sl@0	5362
sl@0	5363
sl@0	5364	/**
sl@0	5365	@publishedAll
sl@0	5366	@released
sl@0	5367
sl@0	5368	Array of raw pointers.
sl@0	5369
sl@0	5370	The array is a simple and efficient specialized array of TAny pointers offering
sl@0	5371	standard array behaviour.
sl@0	5372
sl@0	5373	The derivation from RPointerArrayBase is private.
sl@0	5374	*/
sl@0	5375	TEMPLATE_SPECIALIZATION class RPointerArray<TAny> : private RPointerArrayBase
sl@0	5376	{
sl@0	5377	public:
sl@0	5378	inline RPointerArray();
sl@0	5379	inline explicit RPointerArray(TInt aGranularity);
sl@0	5380	inline RPointerArray(TInt aMinGrowBy, TInt aFactor);
sl@0	5381	inline void Close();
sl@0	5382	inline TInt Count() const;
sl@0	5383	inline TAny* const& operator[](TInt anIndex) const;
sl@0	5384	inline TAny*& operator[](TInt anIndex);
sl@0	5385	inline TInt Append(const TAny* anEntry);
sl@0	5386	inline TInt Insert(const TAny* anEntry, TInt aPos);
sl@0	5387	inline void Remove(TInt anIndex);
sl@0	5388	inline void Compress();
sl@0	5389	inline void Reset();
sl@0	5390	inline TInt Find(const TAny* anEntry) const;
sl@0	5391	inline TInt FindReverse(const TAny* anEntry) const;
sl@0	5392	inline TInt FindInAddressOrder(const TAny* anEntry) const;
sl@0	5393	inline TInt FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const;
sl@0	5394	inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const;
sl@0	5395	inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5396	inline TInt InsertInAddressOrder(const TAny* anEntry);
sl@0	5397	inline TInt InsertInAddressOrderAllowRepeats(const TAny* anEntry);
sl@0	5398	#ifndef __KERNEL_MODE__
sl@0	5399	inline void AppendL(const TAny* anEntry);
sl@0	5400	inline void InsertL(const TAny* anEntry, TInt aPos);
sl@0	5401	inline TInt FindL(const TAny* anEntry) const;
sl@0	5402	inline TInt FindReverseL(const TAny* anEntry) const;
sl@0	5403	inline TInt FindInAddressOrderL(const TAny* anEntry) const;
sl@0	5404	inline void FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const;
sl@0	5405	inline TInt SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const;
sl@0	5406	inline void SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5407	inline void InsertInAddressOrderL(const TAny* anEntry);
sl@0	5408	inline void InsertInAddressOrderAllowRepeatsL(const TAny* anEntry);
sl@0	5409
sl@0	5410	inline RPointerArray(TAny** aEntries, TInt aCount);
sl@0	5411	inline void GranularCompress();
sl@0	5412	inline void SortIntoAddressOrder();
sl@0	5413	inline TArray<TAny*> Array() const;
sl@0	5414	#endif
sl@0	5415	};
sl@0	5416
sl@0	5417
sl@0	5418
sl@0	5419	/**
sl@0	5420	@internalComponent
sl@0	5421
sl@0	5422	Base class used in the derivation of RArray.
sl@0	5423
sl@0	5424	The base class is inherited privately.
sl@0	5425
sl@0	5426	The class is internal and is not intended for use.
sl@0	5427	*/
sl@0	5428	class RArrayBase
sl@0	5429	{
sl@0	5430	protected:
sl@0	5431	IMPORT_C RArrayBase(TInt anEntrySize);
sl@0	5432	IMPORT_C RArrayBase(TInt anEntrySize, TInt aGranularity);
sl@0	5433	IMPORT_C RArrayBase(TInt anEntrySize, TInt aGranularity, TInt aKeyOffset);
sl@0	5434	IMPORT_C RArrayBase(TInt anEntrySize, TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
sl@0	5435	IMPORT_C RArrayBase(TInt aEntrySize,TAny* aEntries, TInt aCount);
sl@0	5436	IMPORT_C void Close();
sl@0	5437	IMPORT_C TInt Count() const;
sl@0	5438	IMPORT_C TAny* At(TInt anIndex) const;
sl@0	5439	IMPORT_C TInt Append(const TAny* anEntry);
sl@0	5440	IMPORT_C TInt Insert(const TAny* anEntry, TInt aPos);
sl@0	5441	IMPORT_C void Remove(TInt anIndex);
sl@0	5442	IMPORT_C void Compress();
sl@0	5443	IMPORT_C void Reset();
sl@0	5444	IMPORT_C TInt Find(const TAny* anEntry) const;
sl@0	5445	IMPORT_C TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const;
sl@0	5446	IMPORT_C TInt FindReverse(const TAny* aEntry) const;
sl@0	5447	IMPORT_C TInt FindReverse(const TAny* aEntry, TGeneralIdentityRelation aIdentity) const;
sl@0	5448	IMPORT_C TInt FindIsqSigned(const TAny* anEntry) const;
sl@0	5449	IMPORT_C TInt FindIsqUnsigned(const TAny* anEntry) const;
sl@0	5450	IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const;
sl@0	5451	IMPORT_C TInt FindIsqSigned(const TAny* anEntry, TInt aMode) const;
sl@0	5452	IMPORT_C TInt FindIsqUnsigned(const TAny* anEntry, TInt aMode) const;
sl@0	5453	IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const;
sl@0	5454	IMPORT_C TInt InsertIsqSigned(const TAny* anEntry, TBool aAllowRepeats);
sl@0	5455	IMPORT_C TInt InsertIsqUnsigned(const TAny* anEntry, TBool aAllowRepeats);
sl@0	5456	IMPORT_C TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats);
sl@0	5457	IMPORT_C TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex) const;
sl@0	5458	IMPORT_C TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex) const;
sl@0	5459	IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const;
sl@0	5460	IMPORT_C TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5461	IMPORT_C TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5462	IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const;
sl@0	5463	#ifndef __KERNEL_MODE__
sl@0	5464	IMPORT_C void GranularCompress();
sl@0	5465	IMPORT_C TInt DoReserve(TInt aCount);
sl@0	5466	IMPORT_C void HeapSortSigned();
sl@0	5467	IMPORT_C void HeapSortUnsigned();
sl@0	5468	IMPORT_C void HeapSort(TGeneralLinearOrder anOrder);
sl@0	5469	IMPORT_C static TInt GetCount(const CBase* aPtr);
sl@0	5470	IMPORT_C static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex);
sl@0	5471	#endif
sl@0	5472	private:
sl@0	5473	TInt Grow();
sl@0	5474	private:
sl@0	5475	TInt iCount;
sl@0	5476	TAny* iEntries;
sl@0	5477	TInt iEntrySize;
sl@0	5478	TInt iKeyOffset;
sl@0	5479	TInt iAllocated;
sl@0	5480	TInt iGranularity; // positive means linear, negative means exponential growth
sl@0	5481	TInt iSpare1;
sl@0	5482	TInt iSpare2;
sl@0	5483	};
sl@0	5484
sl@0	5485
sl@0	5486
sl@0	5487
sl@0	5488	/**
sl@0	5489	@publishedAll
sl@0	5490	@released
sl@0	5491
sl@0	5492	A simple and efficient array of fixed length objects.
sl@0	5493
sl@0	5494	The elements of the array are instances of a class; this class is specified
sl@0	5495	as the template parameter T.
sl@0	5496
sl@0	5497	The array offers standard array behaviour which includes insertion, appending
sl@0	5498	and sorting of elements.
sl@0	5499
sl@0	5500	Note:
sl@0	5501
sl@0	5502	1. where possible, this class should be used in preference to
sl@0	5503	CArrayFixFlat<classT>.
sl@0	5504
sl@0	5505	2. the derivation from RArrayBase is private.
sl@0	5506
sl@0	5507	3. for performance reasons, RArray stores objects in the array as
sl@0	5508	word (4 byte) aligned quantities. This means that some member functions
sl@0	5509	do not work when RArray is instantiated for classes of less than 4 bytes
sl@0	5510	in size, or when the class's alignment requirement is not 4.
sl@0	5511	Be aware that it is possible to get an unhandled exception on hardware
sl@0	5512	that enforces strict alignment.
sl@0	5513
sl@0	5514	The affected functions are:
sl@0	5515
sl@0	5516	3.1 the constructor: RArray(TInt, T*, TInt)
sl@0	5517
sl@0	5518	3.2 Append(const T&)
sl@0	5519
sl@0	5520	3.3 Insert(const T&, TInt)
sl@0	5521
sl@0	5522	3.4 the [] operator, and then using the pointer to iterate through
sl@0	5523	the array as you would with a C array.
sl@0	5524	*/
sl@0	5525	template <class T>
sl@0	5526	class RArray : private RArrayBase
sl@0	5527	{
sl@0	5528	public:
sl@0	5529	inline RArray();
sl@0	5530	inline explicit RArray(TInt aGranularity);
sl@0	5531	inline RArray(TInt aGranularity, TInt aKeyOffset);
sl@0	5532	inline RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
sl@0	5533	inline RArray(TInt aEntrySize,T* aEntries, TInt aCount);
sl@0	5534	inline void Close();
sl@0	5535	inline TInt Count() const;
sl@0	5536	inline const T& operator[](TInt anIndex) const;
sl@0	5537	inline T& operator[](TInt anIndex);
sl@0	5538	inline TInt Append(const T& anEntry);
sl@0	5539	inline TInt Insert(const T& anEntry, TInt aPos);
sl@0	5540	inline void Remove(TInt anIndex);
sl@0	5541	inline void Compress();
sl@0	5542	inline void Reset();
sl@0	5543	inline TInt Find(const T& anEntry) const;
sl@0	5544	inline TInt Find(const T& anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5545	template <class K>
sl@0	5546	inline TInt Find(const K& aKey, TBool (apfnCompare)(const K k, const T& t)) const
sl@0	5547	/**
sl@0	5548	Finds the first object in the array which matches aKey using
sl@0	5549	the comparison algorithm provided by apfnCompare.
sl@0	5550
sl@0	5551	The find operation always starts at the low index end of the array. There
sl@0	5552	is no assumption about the order of objects in the array.
sl@0	5553
sl@0	5554	@param aKey The key of type K to be compared with the elements of the array using apfnCompare.
sl@0	5555	@param apfnCompare A function defining the identity relation between the
sl@0	5556	object in the array, and their keys of type K. The function
sl@0	5557	returns true if k and t match based on this relationship.
sl@0	5558
sl@0	5559	@return The index of the first matching object within the array.
sl@0	5560	KErrNotFound, if no suitable object can be found.
sl@0	5561	*/
sl@0	5562	{ return RArrayBase::Find((T)&aKey,(TIdentityRelation<T>*)&apfnCompare); }
sl@0	5563	inline TInt FindReverse(const T& anEntry) const;
sl@0	5564	inline TInt FindReverse(const T& anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5565	template <class K>
sl@0	5566	inline TInt FindReverse(const K& aKey, TInt (apfnMatch)(const K k, const T& t)) const
sl@0	5567	/**
sl@0	5568	Finds the first object in the array which matches aKey using the comparison
sl@0	5569	algorithm provided by apfnCompare.
sl@0	5570
sl@0	5571	The find operation always starts at the high index end of the array. There
sl@0	5572	is no assumption about the order of objects in the array.
sl@0	5573
sl@0	5574	@param aKey The key of type K to be compared with the elements of the array using apfnMatch.
sl@0	5575	@param apfnMatch A function defining the identity relation between the
sl@0	5576	object in the array, and their keys of type K. The function
sl@0	5577	returns true if k and t match based on this relationship.
sl@0	5578
sl@0	5579	@return The index of the first matching object within the array.
sl@0	5580	KErrNotFound, if no suitable object can be found.
sl@0	5581	*/
sl@0	5582	{ return RArrayBase::FindReverse((T)&aKey,(TIdentityRelation<T>*)&apfnMatch); }
sl@0	5583	inline TInt FindInSignedKeyOrder(const T& anEntry) const;
sl@0	5584	inline TInt FindInUnsignedKeyOrder(const T& anEntry) const;
sl@0	5585	inline TInt FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const;
sl@0	5586	inline TInt FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const;
sl@0	5587	inline TInt FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const;
sl@0	5588	inline TInt FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
sl@0	5589	template <class K>
sl@0	5590	inline TInt FindInOrder(const K& aKey, TInt (apfnCompare)(const K k, const T& t)) const
sl@0	5591	/**
sl@0	5592	Finds the object in the array whose object matches the specified
sl@0	5593	key, (Using the relationship defined within apfnCompare) using a binary search
sl@0	5594	technique and an ordering algorithm.
sl@0	5595
sl@0	5596	The function assumes that existing objects in the array are ordered so
sl@0	5597	that the objects themselves are in object order as determined by an algorithm
sl@0	5598	supplied by the caller and packaged as a TLinearOrder<T>.
sl@0	5599
sl@0	5600	@param aKey The key of type K to be compared with the elements of the array using apfnCompare.
sl@0	5601	@param apfnCompare A function which defines the order that the array was sorted,
sl@0	5602	where in it aKey (via the defined relationship) should fit, and if the key is present.
sl@0	5603
sl@0	5604	@return The index of the matching object within the array.
sl@0	5605	KErrNotFound, if no suitable object can be found.
sl@0	5606	*/
sl@0	5607
sl@0	5608	{ return RArrayBase::FindIsq((T)&aKey,(TLinearOrder<T>*)&apfnCompare); }
sl@0	5609	inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const;
sl@0	5610	inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const;
sl@0	5611	inline TInt SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5612	inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5613	inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5614	inline TInt SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5615	inline TInt InsertInSignedKeyOrder(const T& anEntry);
sl@0	5616	inline TInt InsertInUnsignedKeyOrder(const T& anEntry);
sl@0	5617	inline TInt InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder);
sl@0	5618	inline TInt InsertInSignedKeyOrderAllowRepeats(const T& anEntry);
sl@0	5619	inline TInt InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry);
sl@0	5620	inline TInt InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder);
sl@0	5621	#ifndef __KERNEL_MODE__
sl@0	5622	inline void AppendL(const T& anEntry);
sl@0	5623	inline void InsertL(const T& anEntry, TInt aPos);
sl@0	5624	inline TInt FindL(const T& anEntry) const;
sl@0	5625	inline TInt FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5626	inline TInt FindReverseL(const T& anEntry) const;
sl@0	5627	inline TInt FindReverseL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
sl@0	5628	inline TInt FindInSignedKeyOrderL(const T& anEntry) const;
sl@0	5629	inline TInt FindInUnsignedKeyOrderL(const T& anEntry) const;
sl@0	5630	inline TInt FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const;
sl@0	5631	inline void FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
sl@0	5632	inline void FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
sl@0	5633	inline void FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
sl@0	5634	inline TInt SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const;
sl@0	5635	inline TInt SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const;
sl@0	5636	inline TInt SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5637	inline void SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5638	inline void SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5639	inline void SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
sl@0	5640	inline void InsertInSignedKeyOrderL(const T& anEntry);
sl@0	5641	inline void InsertInUnsignedKeyOrderL(const T& anEntry);
sl@0	5642	inline void InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder);
sl@0	5643	inline void InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry);
sl@0	5644	inline void InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry);
sl@0	5645	inline void InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder);
sl@0	5646
sl@0	5647	inline void GranularCompress();
sl@0	5648	inline TInt Reserve(TInt aCount);
sl@0	5649	inline void ReserveL(TInt aCount);
sl@0	5650	inline void SortSigned();
sl@0	5651	inline void SortUnsigned();
sl@0	5652	inline void Sort(TLinearOrder<T> anOrder);
sl@0	5653	inline TArray<T> Array() const;
sl@0	5654	#endif
sl@0	5655	};
sl@0	5656
sl@0	5657
sl@0	5658
sl@0	5659
sl@0	5660	/**
sl@0	5661	@publishedAll
sl@0	5662	@released
sl@0	5663
sl@0	5664	A simple and efficient specialized array of signed integers offering standard
sl@0	5665	array behaviour.
sl@0	5666
sl@0	5667	Note that derivation from RPointerArrayBase is private.
sl@0	5668	*/
sl@0	5669	TEMPLATE_SPECIALIZATION class RArray<TInt> : private RPointerArrayBase
sl@0	5670	{
sl@0	5671	public:
sl@0	5672	inline RArray();
sl@0	5673	inline explicit RArray(TInt aGranularity);
sl@0	5674	inline RArray(TInt aMinGrowBy, TInt aFactor);
sl@0	5675	inline void Close();
sl@0	5676	inline TInt Count() const;
sl@0	5677	inline const TInt& operator[](TInt anIndex) const;
sl@0	5678	inline TInt& operator[](TInt anIndex);
sl@0	5679	inline TInt Append(TInt anEntry);
sl@0	5680	inline TInt Insert(TInt anEntry, TInt aPos);
sl@0	5681	inline void Remove(TInt anIndex);
sl@0	5682	inline void Compress();
sl@0	5683	inline void Reset();
sl@0	5684	inline TInt Find(TInt anEntry) const;
sl@0	5685	inline TInt FindReverse(TInt anEntry) const;
sl@0	5686	inline TInt FindInOrder(TInt anEntry) const;
sl@0	5687	inline TInt FindInOrder(TInt anEntry, TInt& anIndex) const;
sl@0	5688	inline TInt SpecificFindInOrder(TInt anEntry, TInt aMode) const;
sl@0	5689	inline TInt SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5690	inline TInt InsertInOrder(TInt anEntry);
sl@0	5691	inline TInt InsertInOrderAllowRepeats(TInt anEntry);
sl@0	5692	#ifndef __KERNEL_MODE__
sl@0	5693	inline void AppendL(TInt anEntry);
sl@0	5694	inline void InsertL(TInt anEntry, TInt aPos);
sl@0	5695	inline TInt FindL(TInt anEntry) const;
sl@0	5696	inline TInt FindReverseL(TInt anEntry) const;
sl@0	5697	inline TInt FindInOrderL(TInt anEntry) const;
sl@0	5698	inline void FindInOrderL(TInt anEntry, TInt& anIndex) const;
sl@0	5699	inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const;
sl@0	5700	inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5701	inline void InsertInOrderL(TInt anEntry);
sl@0	5702	inline void InsertInOrderAllowRepeatsL(TInt anEntry);
sl@0	5703
sl@0	5704	inline RArray(TInt* aEntries, TInt aCount);
sl@0	5705	inline void GranularCompress();
sl@0	5706	inline TInt Reserve(TInt aCount);
sl@0	5707	inline void ReserveL(TInt aCount);
sl@0	5708	inline void Sort();
sl@0	5709	inline TArray<TInt> Array() const;
sl@0	5710	#endif
sl@0	5711	};
sl@0	5712
sl@0	5713
sl@0	5714
sl@0	5715
sl@0	5716	/**
sl@0	5717	@publishedAll
sl@0	5718	@released
sl@0	5719
sl@0	5720	Array of unsigned integers.
sl@0	5721
sl@0	5722	The array is a simple and efficient specialized array of unsigned integers
sl@0	5723	offering standard array behaviour.
sl@0	5724
sl@0	5725	The derivation from RPointerArrayBase is private.
sl@0	5726	*/
sl@0	5727	TEMPLATE_SPECIALIZATION class RArray<TUint> : private RPointerArrayBase
sl@0	5728	{
sl@0	5729	public:
sl@0	5730	inline RArray();
sl@0	5731	inline explicit RArray(TInt aGranularity);
sl@0	5732	inline RArray(TInt aMinGrowBy, TInt aFactor);
sl@0	5733	inline void Close();
sl@0	5734	inline TInt Count() const;
sl@0	5735	inline const TUint& operator[](TInt anIndex) const;
sl@0	5736	inline TUint& operator[](TInt anIndex);
sl@0	5737	inline TInt Append(TUint anEntry);
sl@0	5738	inline TInt Insert(TUint anEntry, TInt aPos);
sl@0	5739	inline void Remove(TInt anIndex);
sl@0	5740	inline void Compress();
sl@0	5741	inline void Reset();
sl@0	5742	inline TInt Find(TUint anEntry) const;
sl@0	5743	inline TInt FindReverse(TUint anEntry) const;
sl@0	5744	inline TInt FindInOrder(TUint anEntry) const;
sl@0	5745	inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const;
sl@0	5746	inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const;
sl@0	5747	inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5748	inline TInt InsertInOrder(TUint anEntry);
sl@0	5749	inline TInt InsertInOrderAllowRepeats(TUint anEntry);
sl@0	5750	#ifndef __KERNEL_MODE__
sl@0	5751	inline void AppendL(TUint anEntry);
sl@0	5752	inline void InsertL(TUint anEntry, TInt aPos);
sl@0	5753	inline TInt FindL(TUint anEntry) const;
sl@0	5754	inline TInt FindReverseL(TUint anEntry) const;
sl@0	5755	inline TInt FindInOrderL(TUint anEntry) const;
sl@0	5756	inline void FindInOrderL(TUint anEntry, TInt& anIndex) const;
sl@0	5757	inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const;
sl@0	5758	inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const;
sl@0	5759	inline void InsertInOrderL(TUint anEntry);
sl@0	5760	inline void InsertInOrderAllowRepeatsL(TUint anEntry);
sl@0	5761
sl@0	5762	inline RArray(TUint* aEntries, TInt aCount);
sl@0	5763	inline void GranularCompress();
sl@0	5764	inline TInt Reserve(TInt aCount);
sl@0	5765	inline void ReserveL(TInt aCount);
sl@0	5766	inline void Sort();
sl@0	5767	inline TArray<TUint> Array() const;
sl@0	5768	#endif
sl@0	5769	};
sl@0	5770
sl@0	5771	#ifndef __LEAVE_EQUALS_THROW__
sl@0	5772
sl@0	5773	class TTrapHandler;
sl@0	5774
sl@0	5775	/**
sl@0	5776	@internalComponent
sl@0	5777	*/
sl@0	5778	class TTrap
sl@0	5779	{
sl@0	5780	public:
sl@0	5781	#ifndef __KERNEL_MODE__
sl@0	5782	IMPORT_C TInt Trap(TInt& aResult);
sl@0	5783	IMPORT_C static void UnTrap();
sl@0	5784	#endif
sl@0	5785	public:
sl@0	5786	enum {EMaxState=0x10};
sl@0	5787	public:
sl@0	5788	TInt iState[EMaxState];
sl@0	5789	TTrap* iNext;
sl@0	5790	TInt* iResult;
sl@0	5791	TTrapHandler* iHandler;
sl@0	5792	};
sl@0	5793
sl@0	5794
sl@0	5795
sl@0	5796	/**
sl@0	5797	@publishedAll
sl@0	5798	@released
sl@0	5799
sl@0	5800	Executes the set of C++ statements _s under a trap harness.
sl@0	5801
sl@0	5802	Use this macro as a C++ statement.
sl@0	5803
sl@0	5804	_r must be a TInt which has already been declared; if any of the
sl@0	5805	C++ statements _s leaves, then the leave code is returned in _r,
sl@0	5806	otherwise _r is set to KErrNone.
sl@0	5807
sl@0	5808	_s can consist of multiple C++ statements; in theory, _s can consist
sl@0	5809	of any legal C++ code but in practice, such statements consist of simple
sl@0	5810	function calls, e.g. Foo() or an assignment of some value to the result of
sl@0	5811	a function call, e.g. functionValue=GetFoo().
sl@0	5812
sl@0	5813	A cleanup stack is constructed for the set of C++ statements _s.
sl@0	5814	If any function in _s leaves, objects pushed to the cleanup stack are
sl@0	5815	cleaned-up. In addition, if any of the C++ statements in _s leaves,
sl@0	5816	then remaining C++ code in _s is not executed and any variables which
sl@0	5817	are assigned within that remaining code are not defined.
sl@0	5818
sl@0	5819	@param _r An lvalue, convertible to TInt&, which will receive the result of
sl@0	5820	any User::Leave() executed within _s or, if no leave occurred,
sl@0	5821	it will be set to KErrNone. The value of _r on entry is not used.
sl@0	5822
sl@0	5823	@param _s C++ statements which will be executed under a trap harness.
sl@0	5824
sl@0	5825	@see TRAPD
sl@0	5826	*/
sl@0	5827	#define TRAP(_r,_s) {TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}}
sl@0	5828
sl@0	5829	/**
sl@0	5830	@publishedAll
sl@0	5831	@released
sl@0	5832
sl@0	5833	Executes the set of C++ statements _s under a trap harness.
sl@0	5834
sl@0	5835	Use this macro in the same way as you would TRAP, except that the
sl@0	5836	variable _r is defined as part of the macro (and is therefore valid for the
sl@0	5837	rest of the block in which the macro occurs). Often, this saves a line of code.
sl@0	5838
sl@0	5839	@param _r A name, which will be declared as a TInt, and will receive the result
sl@0	5840	of any User::Leave() executed within _s or, if no leave occurred, it
sl@0	5841	will be set to KErrNone. After the macro, _r remains in scope until
sl@0	5842	the end of its enclosing block.
sl@0	5843
sl@0	5844	@param _s C++ statements which will be executed under a trap harness.
sl@0	5845
sl@0	5846	@see TRAP
sl@0	5847	*/
sl@0	5848	#define TRAPD(_r,_s) TInt _r;{TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}}
sl@0	5849
sl@0	5850	/**
sl@0	5851	@publishedAll
sl@0	5852	@released
sl@0	5853
sl@0	5854	Executes the set of C++ statements _s under a trap harness.
sl@0	5855	Any leave code generated is ignored.
sl@0	5856
sl@0	5857	Use this macro as a C++ statement.
sl@0	5858
sl@0	5859	This macro is functionally equivalent to:
sl@0	5860	@code
sl@0	5861	TInt x;
sl@0	5862	TRAP(x,_s)
sl@0	5863	@endcode
sl@0	5864	or
sl@0	5865	@code
sl@0	5866	TRAPD(x,_s)
sl@0	5867	@endcode
sl@0	5868	where the value in 'x' is not used by any subsequent code.
sl@0	5869
sl@0	5870	_s can consist of multiple C++ statements; in theory, _s can consist
sl@0	5871	of any legal C++ code but in practice, such statements consist of simple
sl@0	5872	function calls, e.g. Foo() or an assignment of some value to the result of
sl@0	5873	a function call, e.g. functionValue=GetFoo().
sl@0	5874
sl@0	5875	A cleanup stack is constructed for the set of C++ statements _s.
sl@0	5876	If any function in _s leaves, objects pushed to the cleanup stack are
sl@0	5877	cleaned-up. In addition, if any of the C++ statements in _s leaves,
sl@0	5878	then remaining C++ code in _s is not executed and any variables which
sl@0	5879	are assigned within that remaining code are not defined.
sl@0	5880
sl@0	5881	@param _s C++ statements which will be executed under a trap harness.
sl@0	5882
sl@0	5883	@see TRAPD
sl@0	5884	@see TRAP
sl@0	5885	*/
sl@0	5886	#define TRAP_IGNORE(_s) {TInt _ignore;TTrap __t;if (__t.Trap(_ignore)==0){_s;TTrap::UnTrap();}}
sl@0	5887
sl@0	5888
sl@0	5889	#else //__LEAVE_EQUALS_THROW__
sl@0	5890
sl@0	5891	#if defined(__WINS__) && !defined(__SYMC__)
sl@0	5892	/** @internalComponent */
sl@0	5893	#define __WIN32SEHTRAP TWin32SEHTrap __trap; __trap.Trap();
sl@0	5894	/** @internalComponent */
sl@0	5895	#define __WIN32SEHUNTRAP __trap.UnTrap();
sl@0	5896	IMPORT_C void EmptyFunction();
sl@0	5897	#define __CALL_EMPTY_FUNCTION EmptyFunction();
sl@0	5898	#else // !__WINS__
sl@0	5899	#define __WIN32SEHTRAP
sl@0	5900	#define __WIN32SEHUNTRAP
sl@0	5901	#define __CALL_EMPTY_FUNCTION
sl@0	5902	#endif //__WINS__
sl@0	5903
sl@0	5904	/**
sl@0	5905	This macro is used by the TRAP and TRAPD macros and provides a means
sl@0	5906	of inserting code into uses of these.
sl@0	5907
sl@0	5908	This macro is invoked before any 'trapped' code is called, and it should be
sl@0	5909	redefined to do whatever task is required. E.g. this code:
sl@0	5910
sl@0	5911	@code
sl@0	5912	#undef TRAP_INSTRUMENTATION_START
sl@0	5913	#define TRAP_INSTRUMENTATION_START DoMyLoging(__LINE__)
sl@0	5914	@endcode
sl@0	5915
sl@0	5916	Will cause all subsequent uses of the TRAP macros to behave in an
sl@0	5917	equivalent way to:
sl@0	5918
sl@0	5919	@code
sl@0	5920	DoMyLoging(__LINE__)
sl@0	5921	TRAP(r,SomeCodeL());
sl@0	5922	@endcode
sl@0	5923
sl@0	5924
sl@0	5925	@publishedPartner
sl@0	5926	@released
sl@0	5927
sl@0	5928	@see TRAP
sl@0	5929	@see TRAPD
sl@0	5930	*/
sl@0	5931	#define TRAP_INSTRUMENTATION_START
sl@0	5932
sl@0	5933
sl@0	5934
sl@0	5935	/**
sl@0	5936	This macro is used by the TRAP and TRAPD macros and provides a means
sl@0	5937	of inserting code into uses of these.
sl@0	5938
sl@0	5939	This macro is invoked if the 'trapped' code did not Leave.
sl@0	5940	E.g. this code:
sl@0	5941
sl@0	5942	@code
sl@0	5943	#undef TRAP_INSTRUMENTATION_NOLEAVE
sl@0	5944	#define TRAP_INSTRUMENTATION_NOLEAVE DoMyLoging(__LINE__)
sl@0	5945	@endcode
sl@0	5946
sl@0	5947	Will cause all subsequent uses of the TRAP macros to behave in an
sl@0	5948	equivalent way to:
sl@0	5949
sl@0	5950	@code
sl@0	5951	TRAP(r,SomeCodeL());
sl@0	5952	if(r==KErrNone) DoMyLoging(__LINE__);
sl@0	5953	@endcode
sl@0	5954
sl@0	5955
sl@0	5956	@param aLine The line number in the C++ source file where the TRAP or TRAPD
sl@0	5957	macro was used.
sl@0	5958
sl@0	5959	@publishedPartner
sl@0	5960	@released
sl@0	5961
sl@0	5962	@see TRAP
sl@0	5963	@see TRAPD
sl@0	5964	*/
sl@0	5965	#define TRAP_INSTRUMENTATION_NOLEAVE
sl@0	5966
sl@0	5967
sl@0	5968	/**
sl@0	5969	This macro is used by the TRAP and TRAPD macros and provides a means
sl@0	5970	of inserting code into uses of these.
sl@0	5971
sl@0	5972	This macro is invoked if the 'trapped' code did Leave. E.g. this code:
sl@0	5973
sl@0	5974	@code
sl@0	5975	#undef TRAP_INSTRUMENTATION_LEAVE
sl@0	5976	#define TRAP_INSTRUMENTATION_LEAVE(aResult) DoMyLoging(aResult,__LINE__)
sl@0	5977	@endcode
sl@0	5978
sl@0	5979	Will cause all subsequent uses of the TRAP macros to behave in an
sl@0	5980	equivalent way to:
sl@0	5981
sl@0	5982	@code
sl@0	5983	TRAP(r,SomeCodeL());
sl@0	5984	if(r!=KErrNone) DoMyLoging(r,__LINE__);
sl@0	5985	@endcode
sl@0	5986
sl@0	5987
sl@0	5988	@param aResult A reference to the result value used in the TRAP macro.
sl@0	5989
sl@0	5990
sl@0	5991	@publishedPartner
sl@0	5992	@released
sl@0	5993
sl@0	5994	@see TRAP
sl@0	5995	@see TRAPD
sl@0	5996	*/
sl@0	5997	#define TRAP_INSTRUMENTATION_LEAVE(aResult)
sl@0	5998
sl@0	5999
sl@0	6000
sl@0	6001	/**
sl@0	6002	This macro is used by the TRAP and TRAPD macros and provides a means
sl@0	6003	of inserting code into uses of these.
sl@0	6004
sl@0	6005	This macro is invoked after the 'trapped' code is called, regardless of whether
sl@0	6006	or not it did Leave. It should be redefined to do whatever task is
sl@0	6007	required. E.g. this code:
sl@0	6008
sl@0	6009	@code
sl@0	6010	#undef TRAP_INSTRUMENTATION_END
sl@0	6011	#define TRAP_INSTRUMENTATION_END DoMyLoging(__LINE__)
sl@0	6012	@endcode
sl@0	6013
sl@0	6014	Will cause all subsequent uses of the TRAP macros to behave in an
sl@0	6015	equivalent way to:
sl@0	6016
sl@0	6017	@code
sl@0	6018	TRAP(r,SomeCodeL());
sl@0	6019	DoMyLoging(__LINE__)
sl@0	6020	@endcode
sl@0	6021
sl@0	6022
sl@0	6023	@publishedPartner
sl@0	6024	@released
sl@0	6025
sl@0	6026	@see TRAP
sl@0	6027	@see TRAPD
sl@0	6028	*/
sl@0	6029	#define TRAP_INSTRUMENTATION_END
sl@0	6030
sl@0	6031
sl@0	6032
sl@0	6033	/**
sl@0	6034	@publishedAll
sl@0	6035	@released
sl@0	6036
sl@0	6037	Executes the set of C++ statements _s under a trap harness.
sl@0	6038
sl@0	6039	Use this macro as a C++ statement.
sl@0	6040
sl@0	6041	_r must be a TInt which has already been declared; if any of the
sl@0	6042	C++ statements _s leaves, then the leave code is returned in _r,
sl@0	6043	otherwise _r is set to KErrNone.
sl@0	6044
sl@0	6045	_s can consist of multiple C++ statements; in theory, _s can consist
sl@0	6046	of any legal C++ code but in practice, such statements consist of simple
sl@0	6047	function calls, e.g. Foo() or an assignment of some value to the result of
sl@0	6048	a function call, e.g. functionValue=GetFoo().
sl@0	6049
sl@0	6050	A cleanup stack is constructed for the set of C++ statements _s.
sl@0	6051	If any function in _s leaves, objects pushed to the cleanup stack are
sl@0	6052	cleaned-up. In addition, if any of the C++ statements in _s leaves,
sl@0	6053	then remaining C++ code in _s is not executed and any variables which
sl@0	6054	are assigned within that remaining code are not defined.
sl@0	6055
sl@0	6056	@param _r An lvalue, convertible to TInt&, which will receive the result of
sl@0	6057	any User::Leave() executed within _s or, if no leave occurred,
sl@0	6058	it will be set to KErrNone. The value of _r on entry is not used.
sl@0	6059
sl@0	6060	@param _s C++ statements which will be executed under a trap harness.
sl@0	6061
sl@0	6062	@see TRAPD
sl@0	6063	*/
sl@0	6064
sl@0	6065	/*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a
sl@0	6066	workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect
sl@0	6067	trap handler to be invoked when multiple nested TRAP's were present and
sl@0	6068	User::Leave(..) was called. */
sl@0	6069
sl@0	6070	#define TRAP(_r, _s) \
sl@0	6071	{ \
sl@0	6072	TInt& __rref = _r; \
sl@0	6073	__rref = 0; \
sl@0	6074	{ TRAP_INSTRUMENTATION_START; } \
sl@0	6075	try { \
sl@0	6076	__WIN32SEHTRAP \
sl@0	6077	TTrapHandler* ____t = User::MarkCleanupStack(); \
sl@0	6078	_s; \
sl@0	6079	User::UnMarkCleanupStack(____t); \
sl@0	6080	{ TRAP_INSTRUMENTATION_NOLEAVE; } \
sl@0	6081	__WIN32SEHUNTRAP \
sl@0	6082	} \
sl@0	6083	catch (XLeaveException& l) \
sl@0	6084	{ \
sl@0	6085	__rref = l.GetReason(); \
sl@0	6086	{ TRAP_INSTRUMENTATION_LEAVE(__rref); } \
sl@0	6087	} \
sl@0	6088	catch (...) \
sl@0	6089	{ \
sl@0	6090	User::Invariant(); \
sl@0	6091	} \
sl@0	6092	__CALL_EMPTY_FUNCTION \
sl@0	6093	{ TRAP_INSTRUMENTATION_END; } \
sl@0	6094	}
sl@0	6095
sl@0	6096
sl@0	6097	/**
sl@0	6098	@publishedAll
sl@0	6099	@released
sl@0	6100
sl@0	6101	Executes the set of C++ statements _s under a trap harness.
sl@0	6102
sl@0	6103	Use this macro in the same way as you would TRAP, except that the
sl@0	6104	variable _r is defined as part of the macro (and is therefore valid for the
sl@0	6105	rest of the block in which the macro occurs). Often, this saves a line of code.
sl@0	6106
sl@0	6107	@param _r A name, which will be declared as a TInt, and will receive the result
sl@0	6108	of any User::Leave() executed within _s or, if no leave occurred, it
sl@0	6109	will be set to KErrNone. After the macro, _r remains in scope until
sl@0	6110	the end of its enclosing block.
sl@0	6111
sl@0	6112	@param _s C++ statements which will be executed under a trap harness.
sl@0	6113
sl@0	6114	@see TRAP
sl@0	6115	*/
sl@0	6116
sl@0	6117	/*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a
sl@0	6118	workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect
sl@0	6119	trap handler to be invoked when multiple nested TRAP's were present and
sl@0	6120	User::Leave(..) was called. */
sl@0	6121
sl@0	6122
sl@0	6123	#define TRAPD(_r, _s) \
sl@0	6124	TInt _r; \
sl@0	6125	{ \
sl@0	6126	_r = 0; \
sl@0	6127	{ TRAP_INSTRUMENTATION_START; } \
sl@0	6128	try { \
sl@0	6129	__WIN32SEHTRAP \
sl@0	6130	TTrapHandler* ____t = User::MarkCleanupStack(); \
sl@0	6131	_s; \
sl@0	6132	User::UnMarkCleanupStack(____t); \
sl@0	6133	{ TRAP_INSTRUMENTATION_NOLEAVE; } \
sl@0	6134	__WIN32SEHUNTRAP \
sl@0	6135	} \
sl@0	6136	catch (XLeaveException& l) \
sl@0	6137	{ \
sl@0	6138	_r = l.GetReason(); \
sl@0	6139	{ TRAP_INSTRUMENTATION_LEAVE(_r); } \
sl@0	6140	} \
sl@0	6141	catch (...) \
sl@0	6142	{ \
sl@0	6143	User::Invariant(); \
sl@0	6144	} \
sl@0	6145	__CALL_EMPTY_FUNCTION \
sl@0	6146	{ TRAP_INSTRUMENTATION_END; } \
sl@0	6147	}
sl@0	6148
sl@0	6149	/**
sl@0	6150	@publishedAll
sl@0	6151	@released
sl@0	6152
sl@0	6153	Executes the set of C++ statements _s under a trap harness.
sl@0	6154	Any leave code generated is ignored.
sl@0	6155
sl@0	6156	Use this macro as a C++ statement.
sl@0	6157
sl@0	6158	This macro is functionally equivalent to:
sl@0	6159	@code
sl@0	6160	TInt x;
sl@0	6161	TRAP(x,_s)
sl@0	6162	@endcode
sl@0	6163	or
sl@0	6164	@code
sl@0	6165	TRAPD(x,_s)
sl@0	6166	@endcode
sl@0	6167	where the value in 'x' is not used by any subsequent code.
sl@0	6168
sl@0	6169	Use this macro as a C++ statement.
sl@0	6170
sl@0	6171	_s can consist of multiple C++ statements; in theory, _s can consist
sl@0	6172	of any legal C++ code but in practice, such statements consist of simple
sl@0	6173	function calls, e.g. Foo() or an assignment of some value to the result of
sl@0	6174	a function call, e.g. functionValue=GetFoo().
sl@0	6175
sl@0	6176	A cleanup stack is constructed for the set of C++ statements _s.
sl@0	6177	If any function in _s leaves, objects pushed to the cleanup stack are
sl@0	6178	cleaned-up. In addition, if any of the C++ statements in _s leaves,
sl@0	6179	then remaining C++ code in _s is not executed and any variables which
sl@0	6180	are assigned within that remaining code are not defined.
sl@0	6181
sl@0	6182	@param _s C++ statements which will be executed under a trap harness.
sl@0	6183
sl@0	6184	@see TRAPD
sl@0	6185	@see TRAP
sl@0	6186	*/
sl@0	6187
sl@0	6188	/*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a
sl@0	6189	workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect
sl@0	6190	trap handler to be invoked when multiple nested TRAP's were present and
sl@0	6191	User::Leave(..) was called. */
sl@0	6192
sl@0	6193	#define TRAP_IGNORE(_s) \
sl@0	6194	{ \
sl@0	6195	{ TRAP_INSTRUMENTATION_START; } \
sl@0	6196	try { \
sl@0	6197	__WIN32SEHTRAP \
sl@0	6198	TTrapHandler* ____t = User::MarkCleanupStack(); \
sl@0	6199	_s; \
sl@0	6200	User::UnMarkCleanupStack(____t); \
sl@0	6201	{ TRAP_INSTRUMENTATION_NOLEAVE; } \
sl@0	6202	__WIN32SEHUNTRAP \
sl@0	6203	} \
sl@0	6204	catch (XLeaveException& l) \
sl@0	6205	{ \
sl@0	6206	l.GetReason(); \
sl@0	6207	{ TRAP_INSTRUMENTATION_LEAVE(l.Reason()); } \
sl@0	6208	} \
sl@0	6209	catch (...) \
sl@0	6210	{ \
sl@0	6211	User::Invariant(); \
sl@0	6212	} \
sl@0	6213	__CALL_EMPTY_FUNCTION \
sl@0	6214	{ TRAP_INSTRUMENTATION_END; } \
sl@0	6215	}
sl@0	6216
sl@0	6217
sl@0	6218	#endif //__LEAVE_EQUALS_THROW__
sl@0	6219
sl@0	6220	/* The macro __SYMBIAN_STDCPP_SUPPORT__ is defined when building a StdC++ target.
sl@0	6221	* In this case, operator new and operator delete below should not be declared
sl@0	6222	* to avoid clashing with StdC++ declarations.
sl@0	6223	*/
sl@0	6224
sl@0	6225	#ifndef __SYMBIAN_STDCPP_SUPPORT__
sl@0	6226
sl@0	6227	#ifndef __OPERATOR_NEW_DECLARED__
sl@0	6228
sl@0	6229	/* Some operator new and operator delete overloads may be declared in compiler
sl@0	6230	* pre-include files.
sl@0	6231	*
sl@0	6232	* __OPERATOR_NEW_DECLARED__ is #defined if they are, so that we can avoid
sl@0	6233	* re-declaring them here.
sl@0	6234	*/
sl@0	6235
sl@0	6236	#define __OPERATOR_NEW_DECLARED__
sl@0	6237
sl@0	6238	/**
sl@0	6239	@publishedAll
sl@0	6240	@released
sl@0	6241	*/
sl@0	6242	GLREF_C TAny* operator new(TUint aSize) __NO_THROW;
sl@0	6243
sl@0	6244	/**
sl@0	6245	@publishedAll
sl@0	6246	@released
sl@0	6247	*/
sl@0	6248	GLREF_C TAny* operator new(TUint aSize,TUint anExtraSize) __NO_THROW;
sl@0	6249
sl@0	6250	/**
sl@0	6251	@publishedAll
sl@0	6252	@released
sl@0	6253	*/
sl@0	6254	GLREF_C void operator delete(TAny* aPtr) __NO_THROW;
sl@0	6255
sl@0	6256	#ifndef __OMIT_VEC_OPERATOR_NEW_DECL__
sl@0	6257	/**
sl@0	6258	@publishedAll
sl@0	6259	@released
sl@0	6260	*/
sl@0	6261	GLREF_C TAny* operator new[](TUint aSize) __NO_THROW;
sl@0	6262
sl@0	6263	/**
sl@0	6264	@publishedAll
sl@0	6265	@released
sl@0	6266	*/
sl@0	6267	GLREF_C void operator delete[](TAny* aPtr) __NO_THROW;
sl@0	6268	#endif // !__OMIT_VEC_OPERATOR_NEW_DECL__
sl@0	6269
sl@0	6270	#endif // !__OPERATOR_NEW_DECLARED__
sl@0	6271
sl@0	6272	#endif // !__SYMBIAN_STDCPP_SUPPORT__
sl@0	6273
sl@0	6274	/**
sl@0	6275	@publishedAll
sl@0	6276	@released
sl@0	6277	*/
sl@0	6278	inline TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;
sl@0	6279
sl@0	6280	/**
sl@0	6281	@publishedAll
sl@0	6282	@released
sl@0	6283	*/
sl@0	6284	inline void operator delete(TAny* aPtr, TAny* aBase) __NO_THROW;
sl@0	6285
sl@0	6286	#ifndef __PLACEMENT_VEC_NEW_INLINE
sl@0	6287	/**
sl@0	6288	@publishedAll
sl@0	6289	@released
sl@0	6290	*/
sl@0	6291	inline TAny* operator new[](TUint aSize, TAny* aBase) __NO_THROW;
sl@0	6292
sl@0	6293	/**
sl@0	6294	@publishedAll
sl@0	6295	@released
sl@0	6296	*/
sl@0	6297	inline void operator delete[](TAny* aPtr, TAny* aBase) __NO_THROW;
sl@0	6298
sl@0	6299	#endif // !__PLACEMENT_VEC_NEW_INLINE
sl@0	6300
sl@0	6301	#if !defined(__BOOL_NO_TRUE_TRAP__)
sl@0	6302
sl@0	6303	/**
sl@0	6304	@publishedAll
sl@0	6305	@released
sl@0	6306	*/
sl@0	6307	TBool operator==(TTrue,volatile const TBool);
sl@0	6308
sl@0	6309	/**
sl@0	6310	@publishedAll
sl@0	6311	@released
sl@0	6312	*/
sl@0	6313	TBool operator==(volatile const TBool,TTrue);
sl@0	6314
sl@0	6315	/**
sl@0	6316	@publishedAll
sl@0	6317	@released
sl@0	6318	*/
sl@0	6319	TBool operator!=(TTrue,volatile const TBool);
sl@0	6320
sl@0	6321	/**
sl@0	6322	@publishedAll
sl@0	6323	@released
sl@0	6324	*/
sl@0	6325	TBool operator!=(volatile const TBool,TTrue);
sl@0	6326	#endif
sl@0	6327
sl@0	6328
sl@0	6329
sl@0	6330
sl@0	6331	/**
sl@0	6332	@publishedAll
sl@0	6333	@released
sl@0	6334
sl@0	6335	A Version 2 client/server class that clients use to package
sl@0	6336	the arguments to be sent to a server.
sl@0	6337
sl@0	6338	The object can package up to 4 arguments together with information about each
sl@0	6339	argument's type, width and accessibility; it is also possible for
sl@0	6340	the package to contain zero arguments. In addition to the default constructor,
sl@0	6341	the class has four templated constructors, allowing an object of this type to
sl@0	6342	be constructed for 0, 1, 2, 3 or 4 arguments.
sl@0	6343
sl@0	6344	Internally, the arguments are stored in a simple TInt array.
sl@0	6345	Consecutive arguments in a constructor's parameter list are put into
sl@0	6346	consecutive slots in the array. The Set() overloaded functions can be used
sl@0	6347	to set argument values into specific slots within this array.
sl@0	6348	*/
sl@0	6349	class TIpcArgs
sl@0	6350	{
sl@0	6351	public:
sl@0	6352	/**
sl@0	6353	@internalComponent
sl@0	6354
sl@0	6355	Argument types; some of these may be ORed together to specify
sl@0	6356	type, accessibility, and width.
sl@0	6357	*/
sl@0	6358	enum TArgType
sl@0	6359	{
sl@0	6360	EUnspecified = 0, /*< Type not specified./
sl@0	6361	EHandle = 1, /*< Handle type./
sl@0	6362	EFlagDes = 4, /*< Descriptor type./
sl@0	6363	EFlagConst = 2, /*< Read only type./
sl@0	6364	EFlag16Bit = 1, /*< 16 bit rather than 8 bit./
sl@0	6365	EDes8 = EFlagDes, /*< 8 bit read/write descriptor./
sl@0	6366	EDes16 = EFlagDes\|EFlag16Bit, /*< 16 bit read/write descriptor./
sl@0	6367	EDesC8 = EFlagDes\|EFlagConst, /*< 8 bit read only descriptor./
sl@0	6368	EDesC16 = EFlagDes\|EFlagConst\|EFlag16Bit, /*< 16 bit read only descriptor./
sl@0	6369	};
sl@0	6370
sl@0	6371
sl@0	6372	/**
sl@0	6373	@internalComponent
sl@0	6374	*/
sl@0	6375	enum
sl@0	6376	{
sl@0	6377	KBitsPerType = 3, /*< Number of bits of type information used for each of the 4 arguments./
sl@0	6378	KPinArgShift = KBitsPerTypeKMaxMessageArguments, /< Bit number of the start of the pin flags. /
sl@0	6379	KPinArg0 = 1<<(KPinArgShift+0), /*< Set to pin argument at index 0./
sl@0	6380	KPinArg1 = 1<<(KPinArgShift+1), /*< Set to pin argument at index 1./
sl@0	6381	KPinArg2 = 1<<(KPinArgShift+2), /*< Set to pin argument at index 2./
sl@0	6382	KPinArg3 = 1<<(KPinArgShift+3), /*< Set to pin argument at index 3./
sl@0	6383	KPinMask = 0xf<<KPinArgShift, /*< The bits used for the pinning attributes of each argument./
sl@0	6384	};
sl@0	6385
sl@0	6386
sl@0	6387	/**
sl@0	6388	Indicates a Null argument.
sl@0	6389	*/
sl@0	6390	enum TNothing {
sl@0	6391	/**
sl@0	6392	An enum value that can be used to indicate an empty or
sl@0	6393	unused argument to a server. For example:
sl@0	6394
sl@0	6395	@code
sl@0	6396	TIpcArgs args(arg1, TIpcArgs::ENothing, arg2);
sl@0	6397	@endcode
sl@0	6398
sl@0	6399	This argument will have an undefined value when the server
sl@0	6400	receives the message.
sl@0	6401	*/
sl@0	6402	ENothing
sl@0	6403	};
sl@0	6404	public:
sl@0	6405	/**
sl@0	6406	Default constructor.
sl@0	6407
sl@0	6408	An argument package constructed using this constructor has no arguments;
sl@0	6409	however, arguments can subsequently be set into this argument package object
sl@0	6410	using the Set() member functions.
sl@0	6411	*/
sl@0	6412	inline TIpcArgs()
sl@0	6413	:iFlags(0)
sl@0	6414	{}
sl@0	6415
sl@0	6416
sl@0	6417	/**
sl@0	6418	A templated constructor that constructs the argument package; it takes
sl@0	6419	1 argument.
sl@0	6420
sl@0	6421	@param a0 An argument of general class type T0 to be contained by
sl@0	6422	this object.
sl@0	6423	*/
sl@0	6424	template <class T0>
sl@0	6425	inline explicit TIpcArgs(T0 a0)
sl@0	6426	{
sl@0	6427	Assign(iArgs[0],a0);
sl@0	6428	iFlags=(Type(a0)<<(0*KBitsPerType));
sl@0	6429	}
sl@0	6430
sl@0	6431
sl@0	6432	/**
sl@0	6433	A templated constructor that constructs the argument package; it takes
sl@0	6434	2 arguments.
sl@0	6435
sl@0	6436	@param a0 An argument of general class type T0 to be contained by
sl@0	6437	this object.
sl@0	6438	@param a1 An argument of general class type T1 to be contained by
sl@0	6439	this object.
sl@0	6440	*/
sl@0	6441	template <class T0,class T1>
sl@0	6442	inline TIpcArgs(T0 a0,T1 a1)
sl@0	6443	{
sl@0	6444	Assign(iArgs[0],a0);
sl@0	6445	Assign(iArgs[1],a1);
sl@0	6446	iFlags=(Type(a0)<<(0KBitsPerType))\|(Type(a1)<<(1KBitsPerType));
sl@0	6447	}
sl@0	6448
sl@0	6449
sl@0	6450	/**
sl@0	6451	A templated constructor that constructs the argument package; it takes
sl@0	6452	3 arguments.
sl@0	6453
sl@0	6454	@param a0 An argument of general class type T0 to be contained by
sl@0	6455	this object.
sl@0	6456	@param a1 An argument of general class type T1 to be contained by
sl@0	6457	this object.
sl@0	6458	@param a2 An argument of general class type T2 to be contained by
sl@0	6459	this object.
sl@0	6460	*/
sl@0	6461	template <class T0,class T1,class T2>
sl@0	6462	inline TIpcArgs(T0 a0,T1 a1,T2 a2)
sl@0	6463	{
sl@0	6464	Assign(iArgs[0],a0);
sl@0	6465	Assign(iArgs[1],a1);
sl@0	6466	Assign(iArgs[2],a2);
sl@0	6467	iFlags=(Type(a0)<<(0KBitsPerType))\|(Type(a1)<<(1KBitsPerType))\|(Type(a2)<<(2*KBitsPerType));
sl@0	6468	}
sl@0	6469
sl@0	6470
sl@0	6471	/**
sl@0	6472	A templated constructor that constructs the argument package; it takes
sl@0	6473	4 arguments.
sl@0	6474
sl@0	6475	@param a0 An argument of general class type T0 to be contained by
sl@0	6476	this object.
sl@0	6477	@param a1 An argument of general class type T1 to be contained by
sl@0	6478	this object.
sl@0	6479	@param a2 An argument of general class type T2 to be contained by
sl@0	6480	this object.
sl@0	6481	@param a3 An argument of general class type T3 to be contained by
sl@0	6482	this object.
sl@0	6483	*/
sl@0	6484	template <class T0,class T1,class T2,class T3>
sl@0	6485	inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3)
sl@0	6486	{
sl@0	6487	Assign(iArgs[0],a0);
sl@0	6488	Assign(iArgs[1],a1);
sl@0	6489	Assign(iArgs[2],a2);
sl@0	6490	Assign(iArgs[3],a3);
sl@0	6491	iFlags=(Type(a0)<<(0KBitsPerType))\|(Type(a1)<<(1KBitsPerType))\|(Type(a2)<<(2KBitsPerType))\|(Type(a3)<<(3KBitsPerType));
sl@0	6492	}
sl@0	6493	//
sl@0	6494	inline void Set(TInt aIndex,TNothing);
sl@0	6495	inline void Set(TInt aIndex,TInt aValue);
sl@0	6496	inline void Set(TInt aIndex,const TAny* aValue);
sl@0	6497	inline void Set(TInt aIndex,RHandleBase aValue);
sl@0	6498	inline void Set(TInt aIndex,const TDesC8* aValue);
sl@0	6499	#ifndef __KERNEL_MODE__
sl@0	6500	inline void Set(TInt aIndex,const TDesC16* aValue);
sl@0	6501	#endif
sl@0	6502	inline void Set(TInt aIndex,TDes8* aValue);
sl@0	6503	#ifndef __KERNEL_MODE__
sl@0	6504	inline void Set(TInt aIndex,TDes16* aValue);
sl@0	6505	#endif
sl@0	6506
sl@0	6507	inline TIpcArgs& PinArgs(TBool aPinArg0=ETrue, TBool aPinArg1=ETrue, TBool aPinArg2=ETrue, TBool aPinArg3=ETrue);
sl@0	6508	private:
sl@0	6509	inline static TArgType Type(TNothing);
sl@0	6510	inline static TArgType Type(TInt);
sl@0	6511	inline static TArgType Type(const TAny*);
sl@0	6512	inline static TArgType Type(RHandleBase aValue);
sl@0	6513	inline static TArgType Type(const TDesC8*);
sl@0	6514	#ifndef __KERNEL_MODE__
sl@0	6515	inline static TArgType Type(const TDesC16*);
sl@0	6516	#endif
sl@0	6517	inline static TArgType Type(TDes8*);
sl@0	6518	#ifndef __KERNEL_MODE__
sl@0	6519	inline static TArgType Type(TDes16*);
sl@0	6520	#endif
sl@0	6521	//
sl@0	6522	inline static void Assign(TInt&,TNothing);
sl@0	6523	inline static void Assign(TInt& aArg,TInt aValue);
sl@0	6524	inline static void Assign(TInt& aArg,const TAny* aValue);
sl@0	6525	inline static void Assign(TInt& aArg,RHandleBase aValue);
sl@0	6526	inline static void Assign(TInt& aArg,const TDesC8* aValue);
sl@0	6527	#ifndef __KERNEL_MODE__
sl@0	6528	inline static void Assign(TInt& aArg,const TDesC16* aValue);
sl@0	6529	#endif
sl@0	6530	inline static void Assign(TInt& aArg,TDes8* aValue);
sl@0	6531	#ifndef __KERNEL_MODE__
sl@0	6532	inline static void Assign(TInt& aArg,TDes16* aValue);
sl@0	6533	#endif
sl@0	6534	public:
sl@0	6535
sl@0	6536	/**
sl@0	6537	The location where the message arguments are stored.
sl@0	6538
sl@0	6539	There is no reason to access this data member directly and it should be
sl@0	6540	considered as internal.
sl@0	6541	*/
sl@0	6542	TInt iArgs[KMaxMessageArguments];
sl@0	6543
sl@0	6544	/**
sl@0	6545	The location where the flag bits describing the argument types are stored.
sl@0	6546
sl@0	6547	The symbolic values describing the argument types are internal to Symbian,
sl@0	6548	and there is therefore no reason to access this data member directly.
sl@0	6549	It should be considered as internal.
sl@0	6550	*/
sl@0	6551	TInt iFlags;
sl@0	6552	};
sl@0	6553
sl@0	6554	// Structures for passing 64 bit integers and doubles across GCC/EABI boundaries
sl@0	6555
sl@0	6556	/**
sl@0	6557	@internalComponent
sl@0	6558	*/
sl@0	6559	struct SInt64
sl@0	6560	{
sl@0	6561	public:
sl@0	6562	inline SInt64();
sl@0	6563	inline SInt64(Int64 a);
sl@0	6564	inline SInt64& operator=(Int64 a);
sl@0	6565	inline operator Int64() const;
sl@0	6566	public:
sl@0	6567	TUint32 iData[2]; // little endian
sl@0	6568	};
sl@0	6569
sl@0	6570	/**
sl@0	6571	@internalComponent
sl@0	6572	*/
sl@0	6573	struct SUint64
sl@0	6574	{
sl@0	6575	public:
sl@0	6576	inline SUint64();
sl@0	6577	inline SUint64(Uint64 a);
sl@0	6578	inline SUint64& operator=(Uint64 a);
sl@0	6579	inline operator Uint64() const;
sl@0	6580	public:
sl@0	6581	TUint32 iData[2]; // little endian
sl@0	6582	};
sl@0	6583
sl@0	6584	/**
sl@0	6585	@internalComponent
sl@0	6586	*/
sl@0	6587	struct SDouble
sl@0	6588	{
sl@0	6589	public:
sl@0	6590	inline SDouble();
sl@0	6591	inline SDouble(TReal a);
sl@0	6592	inline SDouble& operator=(TReal a);
sl@0	6593	inline operator TReal() const;
sl@0	6594	public:
sl@0	6595	TUint32 iData[2]; // always little endian
sl@0	6596	};
sl@0	6597
sl@0	6598	/**
sl@0	6599	@publishedAll
sl@0	6600	@released
sl@0	6601
sl@0	6602	Stores information about a thread's stack.
sl@0	6603
sl@0	6604	Note, on the emulator, the memory between iLimit and the thread's current stack pointer
sl@0	6605	may not actually be committed.
sl@0	6606
sl@0	6607	@see RThread::StackInfo()
sl@0	6608	*/
sl@0	6609	class TThreadStackInfo
sl@0	6610	{
sl@0	6611	public:
sl@0	6612	/**
sl@0	6613	The address which the stack pointer would contain if the stack were empty.
sl@0	6614	*/
sl@0	6615	TLinAddr iBase;
sl@0	6616
sl@0	6617	/**
sl@0	6618	The address which the stack pointer would contain if the stack were full,
sl@0	6619	(The lowest valid address).
sl@0	6620	*/
sl@0	6621	TLinAddr iLimit;
sl@0	6622
sl@0	6623	/**
sl@0	6624	The limit value for the stack if it were expanded to its maximum size.
sl@0	6625
sl@0	6626	Currently expanding stacks is not supported so iExpandLimit==iLimit
sl@0	6627	*/
sl@0	6628	TLinAddr iExpandLimit;
sl@0	6629	};
sl@0	6630
sl@0	6631
sl@0	6632
sl@0	6633
sl@0	6634	#ifdef __SUPPORT_CPP_EXCEPTIONS__
sl@0	6635	/**
sl@0	6636	@internalComponent
sl@0	6637	@released
sl@0	6638
sl@0	6639	The class used to implement User::Leave in term of throw and TRAP in terms of catch.
sl@0	6640
sl@0	6641	*/
sl@0	6642	class XLeaveException
sl@0	6643	{
sl@0	6644	public:
sl@0	6645	inline XLeaveException() {}
sl@0	6646	inline XLeaveException(TInt aReason) {iR = aReason;}
sl@0	6647	inline TInt Reason() const {return iR;}
sl@0	6648	IMPORT_C TInt GetReason() const;
sl@0	6649	private:
sl@0	6650	#if __ARMCC_VERSION >= 220000
sl@0	6651	// From rvct 2.2 onwards we want the class impedimenta to be shared, so create a key function.
sl@0	6652	// Unfortunately we can't make this the key function the dtor since this would make it impossible for existing 2.1
sl@0	6653	// derived binaries to be 'BC' with 2.2 binaries (in the general case (which I wont attempt to describe coz its
sl@0	6654	// too complex) so its best to be safe). As a clue: if 2.1 is used to compile with a key function its not possible
sl@0	6655	// for catch handlers to work :-( (see the old code).
sl@0	6656	virtual void ForceKeyFunction();
sl@0	6657	#endif
sl@0	6658	private:
sl@0	6659	#if __ARMCC_VERSION < 220000
sl@0	6660	TAny* iVtable; // reserve space for vtable
sl@0	6661	#endif
sl@0	6662	TInt iR;
sl@0	6663	};
sl@0	6664
sl@0	6665	// The standard header file <exception> defines the following guard macro for EDG and CW, VC++, GCC respectively.
sl@0	6666	// The guard below is ugly. It will surely come back and bite us unless we resolve the whole issue of standard headers
sl@0	6667	// when we move to supporting Standard C++.
sl@0	6668
sl@0	6669	// The macro __SYMBIAN_STDCPP_SUPPORT__ is defined when building a StdC++ target.
sl@0	6670	// In this case, we include the StdC++ specification <exception> rather than declaring uncaught_exception.
sl@0	6671
sl@0	6672	#ifdef __SYMBIAN_STDCPP_SUPPORT__
sl@0	6673	#include <stdapis/stlportv5/exception>
sl@0	6674	#elif !defined(_EXCEPTION) && !defined(_EXCEPTION_) && !defined(__EXCEPTION__)
sl@0	6675	// Declare standard C++ functions relating to exceptions here
sl@0	6676	namespace std {
sl@0	6677	#if defined(__VC32__) \|\| defined(__CW32__)
sl@0	6678	bool uncaught_exception();
sl@0	6679	#else
sl@0	6680	IMPORT_C bool uncaught_exception();
sl@0	6681	#endif
sl@0	6682	void terminate(void);
sl@0	6683	void unexpected(void);
sl@0	6684	typedef void (*terminate_handler)();
sl@0	6685	terminate_handler set_terminate(terminate_handler h) throw();
sl@0	6686	typedef void (*unexpected_handler)();
sl@0	6687	unexpected_handler set_unexpected(unexpected_handler h) throw();
sl@0	6688	}
sl@0	6689
sl@0	6690	#endif
sl@0	6691	#endif //__SUPPORT_CPP_EXCEPTIONS__
sl@0	6692
sl@0	6693	#ifdef __WINS__
sl@0	6694
sl@0	6695	#ifndef __WIN32_SEH_TYPES_KNOWN__
sl@0	6696	class __UnknownWindowsType1;
sl@0	6697	class __UnknownWindowsType2;
sl@0	6698	#endif
sl@0	6699
sl@0	6700	class TWin32SEHTrap;
sl@0	6701
sl@0	6702	/**
sl@0	6703	* Typedef for the SEH handler function
sl@0	6704	* @internalComponent
sl@0	6705	*/
sl@0	6706	typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
sl@0	6707
sl@0	6708	/**
sl@0	6709	* @internalComponent
sl@0	6710	*/
sl@0	6711	class TWin32SEHTrap
sl@0	6712	{
sl@0	6713	private:
sl@0	6714	// Prevent copy/assign
sl@0	6715	TWin32SEHTrap(TWin32SEHTrap const &);
sl@0	6716	TWin32SEHTrap& operator=(TWin32SEHTrap const &);
sl@0	6717
sl@0	6718	#ifdef __KERNEL_MODE__
sl@0	6719	//
sl@0	6720	// Kernel-side functions for nkern exception handler
sl@0	6721	//
sl@0	6722	public:
sl@0	6723	/** Find final exception handler in SEH chain */
sl@0	6724	static TWin32SEHTrap* IterateForFinal();
sl@0	6725
sl@0	6726	/** Access exception handler */
sl@0	6727	TWin32SEHExceptionHandler* ExceptionHandler();
sl@0	6728
sl@0	6729	private:
sl@0	6730
sl@0	6731	#else // !__KERNEL_MODE__
sl@0	6732	//
sl@0	6733	// User-side functions for use in TRAP(...)
sl@0	6734	//
sl@0	6735	public:
sl@0	6736	UIMPORT_C TWin32SEHTrap();
sl@0	6737
sl@0	6738	public:
sl@0	6739	/** Add object to SEH chain */
sl@0	6740	UIMPORT_C void Trap();
sl@0	6741
sl@0	6742	/** Remove object from SEH chain */
sl@0	6743	UIMPORT_C void UnTrap();
sl@0	6744
sl@0	6745	#ifndef __IN_SEH_CPP__
sl@0	6746	private:
sl@0	6747	#endif
sl@0	6748	/** Handle Win32 exceptions */
sl@0	6749	static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
sl@0	6750
sl@0	6751	#endif //__KERNEL_MODE__
sl@0	6752
sl@0	6753	//
sl@0	6754	// NB: This is really an _EXCEPTION_REGISTRATION_RECORD
sl@0	6755	//
sl@0	6756	TWin32SEHTrap* iPrevExceptionRegistrationRecord; /** Link to previous SEH record */
sl@0	6757	TWin32SEHExceptionHandler* iExceptionHandler; /** SEH handler function */
sl@0	6758
sl@0	6759	private:
sl@0	6760	TUint32 iPadding[254]; // discourage the compiler from putting this in reused function parameter space
sl@0	6761	};
sl@0	6762
sl@0	6763	#else // !__WINS__
sl@0	6764
sl@0	6765	#ifdef __X86__
sl@0	6766	/**
sl@0	6767	* @internalComponent
sl@0	6768	*/
sl@0	6769	class TWin32SEHTrap
sl@0	6770	{
sl@0	6771	public:
sl@0	6772	UIMPORT_C TWin32SEHTrap();
sl@0	6773	UIMPORT_C void Trap();
sl@0	6774	UIMPORT_C void UnTrap();
sl@0	6775	};
sl@0	6776	#endif //__X86__
sl@0	6777	#endif //__WINS__
sl@0	6778
sl@0	6779	/**
sl@0	6780	@internalTechnology
sl@0	6781	*/
sl@0	6782	struct TEmulatorImageHeader
sl@0	6783	{
sl@0	6784	TUid iUids[KMaxCheckedUid];
sl@0	6785	TProcessPriority iPriority;
sl@0	6786	SSecurityInfo iS;
sl@0	6787	TUint32 iSpare1;
sl@0	6788	TUint32 iSpare2;
sl@0	6789	TUint32 iModuleVersion;
sl@0	6790	TUint32 iFlags;
sl@0	6791	};
sl@0	6792
sl@0	6793	// forward declaration of shareable data buffers pool infomation
sl@0	6794	class TShPoolInfo;
sl@0	6795
sl@0	6796	#include <e32cmn.inl>
sl@0	6797
sl@0	6798	#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
sl@0	6799	#include <e32cmn_private.h>
sl@0	6800	#endif
sl@0	6801
sl@0	6802	#endif //__E32CMN_H__
sl@0	6803

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--