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