S60UIExampleappui.inc
上传用户:laixiong
上传日期:2007-03-11
资源大小:2994k
文件大小:1144k
源码类别:

Symbian

开发平台:

C/C++

  1. template <class T>
  2. inline TSglQue<T>::TSglQue(TInt aOffset)
  3. : TSglQueBase(aOffset)
  4. #line 354
  5. {}
  6. template <class T>
  7. inline void TSglQue<T>::AddFirst(T &aRef)
  8. #line 370
  9. {DoAddFirst(&aRef);}
  10. template <class T>
  11. inline void TSglQue<T>::AddLast(T &aRef)
  12. #line 387
  13. {DoAddLast(&aRef);}
  14. template <class T>
  15. inline TBool TSglQue<T>::IsFirst(const T *aPtr) const
  16. #line 402
  17. {return(PtrAdd(aPtr,iOffset)==(T *)iHead);}
  18. template <class T>
  19. inline TBool TSglQue<T>::IsLast(const T *aPtr) const
  20. #line 417
  21. {return(PtrAdd(aPtr,iOffset)==(T *)iLast);}
  22. template <class T>
  23. inline T *TSglQue<T>::First() const
  24. {return(PtrSub((T *)iHead,iOffset));}
  25. template <class T>
  26. inline T *TSglQue<T>::Last() const
  27. {return(PtrSub((T *)iLast,iOffset));}
  28. template <class T>
  29. inline void TSglQue<T>::Remove(T &aRef)
  30. #line 461
  31. {DoRemove(&aRef);}
  32. template <class T>
  33. inline TDblQue<T>::TDblQue()
  34. #line 482
  35. {}
  36. template <class T>
  37. inline TDblQue<T>::TDblQue(TInt aOffset)
  38. : TDblQueBase(aOffset)
  39. #line 501
  40. {}
  41. template <class T>
  42. inline void TDblQue<T>::AddFirst(T &aRef)
  43. #line 517
  44. {DoAddFirst(&aRef);}
  45. template <class T>
  46. inline void TDblQue<T>::AddLast(T &aRef)
  47. #line 534
  48. {DoAddLast(&aRef);}
  49. template <class T>
  50. inline TBool TDblQue<T>::IsHead(const T *aPtr) const
  51. #line 554
  52. {return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
  53. template <class T>
  54. inline TBool TDblQue<T>::IsFirst(const T *aPtr) const
  55. {return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
  56. template <class T>
  57. inline TBool TDblQue<T>::IsLast(const T *aPtr) const
  58. {return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
  59. template <class T>
  60. inline T *TDblQue<T>::First() const
  61. {
  62. __DbgTestEmpty();
  63.     return(PtrSub((T *)iHead.iNext,iOffset));
  64.     }
  65. template <class T>
  66. inline T *TDblQue<T>::Last() const
  67. {
  68. __DbgTestEmpty();
  69. return(PtrSub((T *)iHead.iPrev,iOffset));
  70. }
  71. template <class T>
  72. inline TPriQue<T>::TPriQue()
  73. #line 643
  74. {}
  75. template <class T>
  76. inline TPriQue<T>::TPriQue(TInt aOffset)
  77. : TDblQueBase(aOffset)
  78. #line 660
  79. {}
  80. template <class T>
  81. inline void TPriQue<T>::Add(T &aRef)
  82. #line 675
  83. {DoAddPriority(&aRef);}
  84. template <class T>
  85. inline TBool TPriQue<T>::IsHead(const T *aPtr) const
  86. #line 695
  87. {return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
  88. template <class T>
  89. inline TBool TPriQue<T>::IsFirst(const T *aPtr) const
  90. #line 710
  91. {return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
  92. template <class T>
  93. inline TBool TPriQue<T>::IsLast(const T *aPtr) const
  94. #line 725
  95. {return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
  96. template <class T>
  97. inline T *TPriQue<T>::First() const
  98. {return(PtrSub((T *)iHead.iNext,iOffset));}
  99. template <class T>
  100. inline T *TPriQue<T>::Last() const
  101. {return(PtrSub((T *)iHead.iPrev,iOffset));}
  102. template <class T>
  103. inline TDeltaQue<T>::TDeltaQue()
  104. #line 776
  105. {}
  106. template <class T>
  107. inline TDeltaQue<T>::TDeltaQue(TInt aOffset)
  108. : TDeltaQueBase(aOffset)
  109. #line 797
  110. {}
  111. template <class T>
  112. inline void TDeltaQue<T>::Add(T &aRef,TInt aDelta)
  113. #line 815
  114. {DoAddDelta(&aRef,aDelta);}
  115. template <class T>
  116. inline void TDeltaQue<T>::Remove(T &aRef)
  117. #line 830
  118. {DoRemove(&aRef);}
  119. template <class T>
  120. inline T *TDeltaQue<T>::RemoveFirst()
  121. {return((T *) DoRemoveFirst());}
  122. template <class T>
  123. inline TSglQueIter<T>::TSglQueIter(TSglQueBase &aQue)
  124. : TSglQueIterBase(aQue)
  125. #line 871
  126. {}
  127. template <class T>
  128. inline void TSglQueIter<T>::Set(T &aLink)
  129. #line 887
  130. {DoSet(&aLink);}
  131. template <class T>
  132. inline TSglQueIter<T>::operator T *()
  133. #line 902
  134. {return((T *)DoCurrent());}
  135. template <class T>
  136. inline T *TSglQueIter<T>::operator++(TInt)
  137. #line 919
  138. {return((T *)DoPostInc());}
  139. template <class T>
  140. inline TDblQueIter<T>::TDblQueIter(TDblQueBase &aQue)
  141. : TDblQueIterBase(aQue)
  142. #line 948
  143. {}
  144. template <class T>
  145. inline void TDblQueIter<T>::Set(T &aLink)
  146. #line 964
  147. {DoSet(&aLink);}
  148. template <class T>
  149. inline TDblQueIter<T>::operator T *()
  150. #line 985
  151. {return((T *) DoCurrent());}
  152. template <class T>
  153. inline T *TDblQueIter<T>::operator++(TInt)
  154. #line 1003
  155. {return((T *) DoPostInc());}
  156. template <class T>
  157. inline T *TDblQueIter<T>::operator--(TInt)
  158. #line 1021
  159. {return((T *) DoPostDec());}
  160. inline void TKey::SetPtr(const TAny *aPtr)
  161. #line 1042
  162. {iPtr=aPtr;}
  163. inline TCharF::TCharF(TUint aChar)
  164. : TChar(User::Fold(aChar))
  165. {}
  166. inline TCharF::TCharF(const TChar& aChar)
  167. : TChar(User::Fold(aChar))
  168. {}
  169. inline TCharF& TCharF::operator=(TUint aChar)
  170. {SetChar(User::Fold(aChar));return(*this);}
  171. inline TCharF& TCharF::operator=(const TChar& aChar)
  172. {SetChar(User::Fold(aChar));return(*this);}
  173. inline TCharLC::TCharLC(TUint aChar)
  174. : TChar(User::LowerCase(aChar))
  175. {}
  176. inline TCharLC::TCharLC(const TChar& aChar)
  177. : TChar(User::LowerCase(aChar))
  178. {}
  179. inline TCharLC& TCharLC::operator=(TUint aChar)
  180. {SetChar(User::LowerCase(aChar));return(*this);}
  181. inline TCharLC& TCharLC::operator=(const TChar& aChar)
  182. #line 1150
  183. {SetChar(User::LowerCase(aChar));return(*this);}
  184. inline TCharUC::TCharUC(TUint aChar)
  185. : TChar(User::UpperCase(aChar))
  186. {}
  187. inline TCharUC::TCharUC(const TChar& aChar)
  188. : TChar(User::UpperCase(aChar))
  189. {}
  190. inline TCharUC& TCharUC::operator=(TUint aChar)
  191. {SetChar(User::UpperCase(aChar));return(*this);}
  192. inline TCharUC& TCharUC::operator=(const TChar& aChar)
  193. #line 1204
  194. {SetChar(User::UpperCase(aChar));return(*this);}
  195. inline TDateTime::TDateTime()
  196. : iYear(1980),
  197.   iMonth(EJanuary),
  198.   iDay(1),
  199.   iHour(0),
  200.   iMinute(0),
  201.   iSecond(0),
  202.   iMicroSecond(0)
  203. {}
  204. inline TInt TDateTime::Year() const
  205. {return(iYear);}
  206. inline TMonth TDateTime::Month() const
  207. {return(iMonth);}
  208. inline TInt TDateTime::Day() const
  209. {return(iDay);}
  210. inline TInt TDateTime::Hour() const
  211. {return(iHour);}
  212. inline TInt TDateTime::Minute() const
  213. {return(iMinute);}
  214. inline TInt TDateTime::Second() const
  215. {return(iSecond);}
  216. inline TInt TDateTime::MicroSecond() const
  217. {return(iMicroSecond);}
  218. inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds()
  219. {}
  220. inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds(const TInt64& aInterval)
  221. : iInterval(aInterval)
  222. {}
  223. inline TTimeIntervalMicroSeconds& TTimeIntervalMicroSeconds::operator=(const TInt64& aInterval)
  224. {iInterval=aInterval;return(*this);}
  225. inline TBool TTimeIntervalMicroSeconds::operator==(const TTimeIntervalMicroSeconds& aInterval) const
  226. #line 1354
  227. {return(iInterval==aInterval.iInterval);}
  228. inline TBool TTimeIntervalMicroSeconds::operator!=(const TTimeIntervalMicroSeconds& aInterval) const
  229. #line 1368
  230. {return(iInterval!=aInterval.iInterval);}
  231. inline TBool TTimeIntervalMicroSeconds::operator>=(const TTimeIntervalMicroSeconds& aInterval) const
  232. #line 1383
  233. {return(iInterval>=aInterval.iInterval);}
  234. inline TBool TTimeIntervalMicroSeconds::operator<=(const TTimeIntervalMicroSeconds& aInterval) const
  235. #line 1398
  236. {return(iInterval<=aInterval.iInterval);}
  237. inline TBool TTimeIntervalMicroSeconds::operator>(const TTimeIntervalMicroSeconds& aInterval) const
  238. #line 1413
  239. {return(iInterval>aInterval.iInterval);}
  240. inline TBool TTimeIntervalMicroSeconds::operator<(const TTimeIntervalMicroSeconds& aInterval) const
  241. #line 1428
  242. {return(iInterval<aInterval.iInterval);}
  243. inline const TInt64& TTimeIntervalMicroSeconds::Int64() const
  244. {return(iInterval);}
  245. inline TTimeIntervalBase::TTimeIntervalBase()
  246. {}
  247. inline TTimeIntervalBase::TTimeIntervalBase(TInt aInterval)
  248. : iInterval(aInterval)
  249. {}
  250. inline TBool TTimeIntervalBase::operator==(TTimeIntervalBase aInterval) const
  251. {return(iInterval==aInterval.iInterval);}
  252. inline TBool TTimeIntervalBase::operator!=(TTimeIntervalBase aInterval) const
  253. #line 1488
  254. {return(iInterval!=aInterval.iInterval);}
  255. inline TBool TTimeIntervalBase::operator>=(TTimeIntervalBase aInterval) const
  256. #line 1503
  257. {return(iInterval>=aInterval.iInterval);}
  258. inline TBool TTimeIntervalBase::operator<=(TTimeIntervalBase aInterval) const
  259. #line 1518
  260. {return(iInterval<=aInterval.iInterval);}
  261. inline TBool TTimeIntervalBase::operator>(TTimeIntervalBase aInterval) const
  262. #line 1532
  263. {return(iInterval>aInterval.iInterval);}
  264. inline TBool TTimeIntervalBase::operator<(TTimeIntervalBase aInterval) const
  265. #line 1546
  266. {return(iInterval<aInterval.iInterval);}
  267. inline TInt TTimeIntervalBase::Int() const
  268. {return(iInterval);}
  269. inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32()
  270. {}
  271. inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32(TInt aInterval)
  272.     : TTimeIntervalBase(aInterval)
  273. {}
  274. inline TTimeIntervalMicroSeconds32& TTimeIntervalMicroSeconds32::operator=(TInt aInterval)
  275. {iInterval=aInterval;return(*this);}
  276. inline TTimeIntervalSeconds::TTimeIntervalSeconds()
  277. {}
  278. inline TTimeIntervalSeconds::TTimeIntervalSeconds(TInt aInterval)
  279. : TTimeIntervalBase(aInterval)
  280. {}
  281. inline TTimeIntervalSeconds& TTimeIntervalSeconds::operator=(TInt aInterval)
  282. {iInterval=aInterval;return(*this);}
  283. inline TTimeIntervalMinutes::TTimeIntervalMinutes()
  284. {}
  285. inline TTimeIntervalMinutes::TTimeIntervalMinutes(TInt aInterval)
  286. : TTimeIntervalBase(aInterval)
  287. {}
  288. inline TTimeIntervalMinutes& TTimeIntervalMinutes::operator=(TInt aInterval)
  289. {iInterval=aInterval;return(*this);}
  290. inline TTimeIntervalHours::TTimeIntervalHours()
  291. {}
  292. inline TTimeIntervalHours::TTimeIntervalHours(TInt aInterval)
  293. : TTimeIntervalBase(aInterval)
  294. {}
  295. inline TTimeIntervalHours& TTimeIntervalHours::operator=(TInt aInterval)
  296. {iInterval=aInterval;return(*this);}
  297. inline TTimeIntervalDays::TTimeIntervalDays()
  298. {}
  299. inline TTimeIntervalDays::TTimeIntervalDays(TInt aInterval)
  300. : TTimeIntervalBase(aInterval)
  301. {}
  302. inline TTimeIntervalDays& TTimeIntervalDays::operator=(TInt aInterval)
  303. {iInterval=aInterval;return(*this);}
  304. inline TTimeIntervalMonths::TTimeIntervalMonths()
  305. {}
  306. inline TTimeIntervalMonths::TTimeIntervalMonths(TInt aInterval)
  307. : TTimeIntervalBase(aInterval)
  308. {}
  309. inline TTimeIntervalMonths& TTimeIntervalMonths::operator=(TInt aInterval)
  310. {iInterval=aInterval;return(*this);}
  311. inline TTimeIntervalYears::TTimeIntervalYears()
  312. {}
  313. inline TTimeIntervalYears::TTimeIntervalYears(TInt aInterval)
  314. : TTimeIntervalBase(aInterval)
  315. {}
  316. inline TTimeIntervalYears& TTimeIntervalYears::operator=(TInt aInterval)
  317. {iInterval=aInterval;return(*this);}
  318. inline TTime::TTime()
  319. {}
  320. inline TTime::TTime(const TInt64& aTime)
  321. : iTime(aTime)
  322. {}
  323. inline TTime &TTime::operator=(const TInt64& aTime)
  324. {iTime=aTime;return(*this);}
  325. inline TBool TTime::operator==(TTime aTime) const
  326. {return(iTime==aTime.iTime);}
  327. inline TBool TTime::operator!=(TTime aTime) const
  328. {return(iTime!=aTime.iTime);}
  329. inline TBool TTime::operator>=(TTime aTime) const
  330. #line 1890
  331. {return(iTime>=aTime.iTime);}
  332. inline TBool TTime::operator<=(TTime aTime) const
  333. #line 1905
  334. {return(iTime<=aTime.iTime);}
  335. inline TBool TTime::operator>(TTime aTime) const
  336. #line 1919
  337. {return(iTime>aTime.iTime);}
  338. inline TBool TTime::operator<(TTime aTime) const
  339. #line 1933
  340. {return(iTime<aTime.iTime);}
  341. inline const TInt64& TTime::Int64() const
  342. {return(iTime);}
  343. inline TLexMark8::TLexMark8()
  344. : iPtr(0 )
  345. {}
  346. inline TLexMark8::TLexMark8(const TUint8 *aString)
  347. : iPtr(aString)
  348. {}
  349. inline TLex8::TLex8(const TUint8 *aString)
  350. #line 1977
  351. {Assign(TPtrC8(aString));}
  352. inline TLex8::TLex8(const TDesC8 &aDes)
  353. #line 1991
  354. {Assign(aDes);}
  355. inline TLex8& TLex8::operator=(const TUint8* aString)
  356. {Assign(TPtrC8(aString));return(*this);}
  357. inline TLex8& TLex8::operator=(const TDesC8& aBuf)
  358. {Assign(aBuf);return(*this);}
  359. inline TBool TLex8::Eos() const
  360. {return(iNext==iEnd);}
  361. inline void TLex8::Mark()
  362. {Mark(iMark);}
  363. inline void TLex8::Mark(TLexMark8& aMark) const
  364. {aMark.iPtr=iNext;}
  365. inline void TLex8::UnGetToMark()
  366.     {UnGetToMark(iMark);}
  367. inline void TLex8::SkipAndMark(TInt aNumber)
  368. #line 2074
  369.     {SkipAndMark(aNumber,iMark);}
  370. inline void TLex8::SkipSpaceAndMark()
  371.     {SkipSpaceAndMark(iMark);}
  372. inline TInt TLex8::TokenLength() const
  373. #line 2100
  374. {return(iNext-iMark.iPtr);}
  375. inline TInt TLex8::MarkedOffset() const
  376.     {return(iMark.iPtr-iBuf);}
  377. inline TInt TLex8::Val(TInt &aVal)
  378. #line 2129
  379. {return(Val((TInt32&)aVal));}
  380. inline TInt TLex8::Val(TUint &aVal,TRadix aRadix)
  381. #line 2149
  382. {return(Val((TUint32&)aVal,aRadix));}
  383. inline void TLex8::Assign(const TLex8& aLex)
  384. {new(this) TLex8(aLex);}
  385. inline TLexMark16::TLexMark16()
  386. : iPtr(0 )
  387. {}
  388. inline TLexMark16::TLexMark16(const TUint16 *aString)
  389. : iPtr(aString)
  390. {}
  391. inline TLex16::TLex16(const TUint16 *aString)
  392. #line 2193
  393. {Assign(TPtrC16(aString));}
  394. inline TLex16::TLex16(const TDesC16 &aDes)
  395. #line 2207
  396. {Assign(aDes);}
  397. inline TLex16& TLex16::operator=(const TUint16* aString)
  398. {Assign(TPtrC16(aString));return(*this);}
  399. inline TLex16& TLex16::operator=(const TDesC16& aBuf)
  400. {Assign(aBuf);return(*this);}
  401. inline TBool TLex16::Eos() const
  402. {return(iNext==iEnd);}
  403. inline void TLex16::Mark(TLexMark16& aMark) const
  404. {aMark.iPtr=iNext;}
  405. inline void TLex16::Mark()
  406. {iMark.iPtr=iNext;}
  407. inline void TLex16::UnGetToMark()
  408.     {UnGetToMark(iMark);}
  409. inline void TLex16::SkipAndMark(TInt aNumber)
  410. #line 2289
  411.     {SkipAndMark(aNumber,iMark);}
  412. inline void TLex16::SkipSpaceAndMark()
  413.     {SkipSpaceAndMark(iMark);}
  414. inline TInt TLex16::TokenLength() const
  415. #line 2315
  416. {return(iNext-iMark.iPtr);}
  417. inline TInt TLex16::MarkedOffset() const
  418.     {return(iMark.iPtr-iBuf);}
  419. inline TInt TLex16::Val(TInt &aVal)
  420. #line 2344
  421. {return(Val((TInt32&)aVal));}
  422. inline TInt TLex16::Val(TUint &aVal,TRadix aRadix)
  423. #line 2364
  424. {return(Val((TUint32&)aVal,aRadix));}
  425. inline void TLex16::Assign(const TLex16& aLex)
  426. {new(this) TLex16(aLex);}
  427. inline TLocale::TLocale(TInt)
  428. {}
  429. inline TInt TLocale::CountryCode() const
  430. #line 2393
  431. {return(iCountryCode);}
  432. inline void TLocale::SetCountryCode(TInt aCode)
  433. #line 2410
  434. {iCountryCode=aCode;}
  435. inline TTimeIntervalSeconds TLocale::UniversalTimeOffset() const
  436. #line 2426
  437. {return(iUniversalTimeOffset);}
  438. inline TDateFormat TLocale::DateFormat() const
  439. {return(iDateFormat);}
  440. inline void TLocale::SetDateFormat(TDateFormat aFormat)
  441. {iDateFormat=aFormat;}
  442. inline TTimeFormat TLocale::TimeFormat() const
  443. {return(iTimeFormat);}
  444. inline void TLocale::SetTimeFormat(TTimeFormat aFormat)
  445. {iTimeFormat=aFormat;}
  446. inline TLocalePos TLocale::CurrencySymbolPosition() const
  447. #line 2486
  448. {return(iCurrencySymbolPosition);}
  449. inline void TLocale::SetCurrencySymbolPosition(TLocalePos aPos)
  450. {iCurrencySymbolPosition=aPos;}
  451. inline TBool TLocale::CurrencySpaceBetween() const
  452. #line 2513
  453. {return(iCurrencySpaceBetween);}
  454. inline void TLocale::SetCurrencySpaceBetween(TBool aSpace)
  455. {iCurrencySpaceBetween=aSpace;}
  456. inline TInt TLocale::CurrencyDecimalPlaces() const
  457. {return(iCurrencyDecimalPlaces);}
  458. inline void TLocale::SetCurrencyDecimalPlaces(TInt aPlaces)
  459. {iCurrencyDecimalPlaces=aPlaces;}
  460. inline TBool TLocale::CurrencyNegativeInBrackets() const
  461. #line 2567
  462. {return((TBool)iNegativeCurrencyFormat);}
  463. inline void TLocale::SetCurrencyNegativeInBrackets(TBool aBool)
  464. #line 2587
  465. {iNegativeCurrencyFormat=(aBool)?EInBrackets:ELeadingMinusSign;}
  466. inline TBool TLocale::CurrencyTriadsAllowed() const
  467. {return(iCurrencyTriadsAllowed);}
  468. inline void TLocale::SetCurrencyTriadsAllowed(TBool aBool)
  469. {iCurrencyTriadsAllowed=aBool;}
  470. inline TChar TLocale::ThousandsSeparator() const
  471. #line 2625
  472. {return(iThousandsSeparator);}
  473. inline void TLocale::SetThousandsSeparator(const TChar& aChar)
  474. #line 2640
  475. {iThousandsSeparator=aChar;}
  476. inline TChar TLocale::DecimalSeparator() const
  477. {return(iDecimalSeparator);}
  478. inline void TLocale::SetDecimalSeparator(const TChar& aChar)
  479. {iDecimalSeparator=aChar;}
  480. inline TChar TLocale::DateSeparator(TInt aIndex) const
  481. #line 2682
  482. {return(iDateSeparator[aIndex]);}
  483. inline void TLocale::SetDateSeparator(const TChar& aChar,TInt aIndex)
  484. #line 2700
  485. {(void)((aIndex>=0 && aIndex<KMaxDateSeparators)||(User::Invariant(),0)) ;
  486. iDateSeparator[aIndex]=aChar;}
  487. inline TChar TLocale::TimeSeparator(TInt aIndex) const
  488. #line 2721
  489. {return(iTimeSeparator[aIndex]);}
  490. inline void TLocale::SetTimeSeparator(const TChar& aChar,TInt aIndex)
  491. #line 2739
  492. {(void)((aIndex>=0 && aIndex<KMaxTimeSeparators)||(User::Invariant(),0)) ;
  493. iTimeSeparator[aIndex]=aChar;}
  494. inline TLocalePos TLocale::AmPmSymbolPosition() const
  495. {return(iAmPmSymbolPosition);}
  496. inline void TLocale::SetAmPmSymbolPosition(TLocalePos aPos)
  497. {iAmPmSymbolPosition=aPos;}
  498. inline TBool TLocale::AmPmSpaceBetween() const
  499. {return(iAmPmSpaceBetween);}
  500. inline void TLocale::SetAmPmSpaceBetween(TBool aSpace)
  501. {iAmPmSpaceBetween=aSpace;}
  502. inline TUint TLocale::DaylightSaving() const
  503. #line 2817
  504. {return(iDaylightSaving);}
  505. inline TBool TLocale::QueryHomeHasDaylightSavingOn() const
  506. #line 2832
  507. {return((iHomeDaylightSavingZone|EDstHome) & iDaylightSaving);}
  508. inline TDaylightSavingZone TLocale::HomeDaylightSavingZone() const
  509. {return(iHomeDaylightSavingZone);}
  510. inline TUint TLocale::WorkDays() const
  511. #line 2859
  512. {return(iWorkDays);}
  513. inline void TLocale::SetWorkDays(TUint aMask)
  514. {iWorkDays=aMask;}
  515. inline TDay TLocale::StartOfWeek() const
  516. {return(iStartOfWeek);}
  517. inline void TLocale::SetStartOfWeek(TDay aDay)
  518. {iStartOfWeek=aDay;}
  519. inline TClockFormat TLocale::ClockFormat() const
  520. {return(iClockFormat);}
  521. inline void TLocale::SetClockFormat(TClockFormat aFormat)
  522. {iClockFormat=aFormat;}
  523. inline TUnitsFormat TLocale::UnitsGeneral() const
  524. #line 2930
  525. {return(iUnitsGeneral);}
  526. inline void TLocale::SetUnitsGeneral(TUnitsFormat aFormat)
  527. {iUnitsGeneral=aFormat;}
  528. inline TUnitsFormat TLocale::UnitsDistanceShort() const
  529. #line 2957
  530. {return(iUnitsDistanceShort);}
  531. inline void TLocale::SetUnitsDistanceShort(TUnitsFormat aFormat)
  532. #line 2971
  533. {iUnitsDistanceShort=aFormat;}
  534. inline TUnitsFormat TLocale::UnitsDistanceLong() const
  535. #line 2985
  536. {return(iUnitsDistanceLong);}
  537. inline void TLocale::SetUnitsDistanceLong(TUnitsFormat aFormat)
  538. #line 2999
  539. {iUnitsDistanceLong=aFormat;}
  540. inline void TLocale::SetNegativeCurrencyFormat(TLocale::TNegativeCurrencyFormat aNegativeCurrencyFormat)
  541. {iNegativeCurrencyFormat = aNegativeCurrencyFormat;}
  542. inline TLocale::TNegativeCurrencyFormat TLocale::NegativeCurrencyFormat() const
  543. {return(iNegativeCurrencyFormat);}
  544. inline TBool TLocale::NegativeLoseSpace() const
  545. {
  546. if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeLoseSpace)==iExtraNegativeCurrencyFormatFlags)
  547. return ETrue;
  548. else
  549. return EFalse;
  550. }
  551. inline void TLocale::SetNegativeLoseSpace(TBool aBool)
  552. {
  553. if(aBool)
  554. iExtraNegativeCurrencyFormatFlags |= EFlagNegativeLoseSpace;
  555. else
  556. iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeLoseSpace;
  557. }
  558. inline TBool TLocale::NegativeCurrencySymbolOpposite() const
  559. #line 3074
  560. {
  561. if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeCurrencySymbolOpposite)==iExtraNegativeCurrencyFormatFlags)
  562. return ETrue;
  563. else
  564. return EFalse;
  565. }
  566. inline void TLocale::SetNegativeCurrencySymbolOpposite(TBool aBool)
  567. #line 3097
  568. {
  569. if (aBool)
  570. iExtraNegativeCurrencyFormatFlags |= EFlagNegativeCurrencySymbolOpposite;
  571. else
  572. iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeCurrencySymbolOpposite;
  573. }
  574. inline TLanguage TLocale::LanguageDowngrade(TInt aIndex) const
  575. #line 3130
  576. {
  577. (void)((0 <= aIndex && aIndex < 3)||( User::Invariant(),0)) ;
  578. return static_cast<TLanguage>(iLanguageDowngrade[aIndex]);
  579. }
  580. inline void TLocale::SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage)
  581. #line 3151
  582. {
  583. (void)((0 <= aIndex && aIndex < 3)||( User::Invariant(),0)) ;
  584. iLanguageDowngrade[aIndex] = static_cast<TUint16>(aLanguage);
  585. }
  586. #line 3164
  587. inline TDigitType TLocale::DigitType() const
  588. { return iDigitType; }
  589. #line 3175
  590. inline void TLocale::SetDigitType(TDigitType aDigitType)
  591. { iDigitType=aDigitType; }
  592. #line 3188
  593. inline void TLocale::SetDeviceTime(TDeviceTimeState aState)
  594.     {
  595.     iDeviceTimeState=aState;
  596.     }
  597. inline TLocale* TExtendedLocale::GetLocale()
  598. { return &iLocale; }
  599. #line 3205
  600. inline TLocale::TDeviceTimeState TLocale::DeviceTime() const
  601.     {
  602.     return iDeviceTimeState;
  603.     }
  604. inline TInt TFindHandleBase::Handle() const
  605. #line 3225
  606. {return(iFindHandle);}
  607. inline TFindSemaphore::TFindSemaphore()
  608.     : TFindHandleBase()
  609. #line 3244
  610.     {}
  611. inline TFindSemaphore::TFindSemaphore(const TDesC &aMatch)
  612.     : TFindHandleBase(aMatch)
  613. #line 3264
  614.     {}
  615. inline TFindMutex::TFindMutex()
  616.     : TFindHandleBase()
  617. #line 3283
  618.     {}
  619. inline TFindMutex::TFindMutex(const TDesC &aMatch)
  620.     : TFindHandleBase(aMatch)
  621. #line 3303
  622.     {}
  623. inline TFindChunk::TFindChunk()
  624.     : TFindHandleBase()
  625. #line 3322
  626.     {}
  627. inline TFindChunk::TFindChunk(const TDesC &aMatch)
  628.     : TFindHandleBase(aMatch)
  629. #line 3339
  630.     {}
  631. inline TFindThread::TFindThread()
  632.     : TFindHandleBase()
  633. #line 3358
  634.     {}
  635. inline TFindThread::TFindThread(const TDesC &aMatch)
  636.     : TFindHandleBase(aMatch)
  637. #line 3373
  638.     {}
  639. inline TFindProcess::TFindProcess()
  640.     : TFindHandleBase()
  641. #line 3392
  642.     {}
  643. inline TFindProcess::TFindProcess(const TDesC &aMatch)
  644.     : TFindHandleBase(aMatch)
  645. #line 3407
  646.     {}
  647. inline TFindLogicalDevice::TFindLogicalDevice()
  648.     : TFindHandleBase()
  649.     {}
  650. inline TFindLogicalDevice::TFindLogicalDevice(const TDesC &aMatch)
  651.     : TFindHandleBase(aMatch)
  652.     {}
  653. inline TFindPhysicalDevice::TFindPhysicalDevice()
  654.     : TFindHandleBase()
  655.     {}
  656. inline TFindPhysicalDevice::TFindPhysicalDevice(const TDesC &aMatch)
  657.     : TFindHandleBase(aMatch)
  658.     {}
  659. inline TFindServer::TFindServer()
  660.     : TFindHandleBase()
  661. #line 3446
  662.     {}
  663. inline TFindServer::TFindServer(const TDesC &aMatch)
  664.     : TFindHandleBase(aMatch)
  665. #line 3463
  666.     {}
  667. inline TFindLibrary::TFindLibrary()
  668.     : TFindHandleBase()
  669.     {}
  670. inline TFindLibrary::TFindLibrary(const TDesC &aMatch)
  671.     : TFindHandleBase(aMatch)
  672.     {}
  673. inline TInt RDevice::Open(const TFindLogicalDevice& aFind,TOwnerType aType)
  674. {return(RHandleBase::Open(aFind,aType));}
  675. inline TBool RCriticalSection::IsBlocked() const
  676. {return(iBlocked!=1);}
  677. inline TInt RMutex::Open(const TFindMutex& aFind,TOwnerType aType)
  678. #line 3536
  679. {return(RHandleBase::Open(aFind,aType));}
  680. inline TInt RChunk::Open(const TFindChunk& aFind,TOwnerType aType)
  681. #line 3560
  682. {return(RHandleBase::Open(aFind,aType));}
  683. inline TBool RChunk::IsReadable() const
  684. {return (Attributes()&RHandleBase::EDirectReadAccess); }
  685. inline TBool RChunk::IsWritable() const
  686. {return (Attributes()&RHandleBase::EDirectWriteAccess); }
  687. inline TObjectId::TObjectId()
  688. {}
  689. inline TObjectId::TObjectId(TUint64 aId)
  690. : iId(aId)
  691. {}
  692. inline TUint64 TObjectId::Id() const
  693. { return iId; }
  694. inline TObjectId::operator TUint() const
  695. { return TUint(iId); }
  696. inline TBool TObjectId::operator==(TObjectId aId) const
  697. {return iId==aId.iId;}
  698. inline TBool TObjectId::operator!=(TObjectId aId) const
  699. {return iId!=aId.iId;}
  700. inline TThreadId::TThreadId()
  701. : TObjectId()
  702. {}
  703. inline TThreadId::TThreadId(TUint64 aId)
  704. : TObjectId(aId)
  705. {}
  706. inline RThread::RThread()
  707. : RHandleBase(KCurrentThreadHandle)
  708. #line 3691
  709. {}
  710. inline TInt RThread::Open(const TFindThread& aFind,TOwnerType aType)
  711. #line 3714
  712. {return(RHandleBase::Open(aFind,aType));}
  713. inline TBool RThread::HasCapability(TCapability aCapability, const char* aDiagnostic) const
  714. {
  715. return DoHasCapability(aCapability, aDiagnostic);
  716. }
  717. inline TBool RThread::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
  718. {
  719. return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
  720. }
  721. #line 3761
  722. inline TProcessId::TProcessId()
  723. : TObjectId()
  724. {}
  725. inline TProcessId::TProcessId(TUint64 aId)
  726. : TObjectId(aId)
  727. {}
  728. inline RProcess::RProcess()
  729. : RHandleBase(KCurrentProcessHandle)
  730. #line 3795
  731. {}
  732. inline RProcess::RProcess(TInt aHandle)
  733. : RHandleBase(aHandle)
  734. {}
  735. inline TInt RProcess::Open(const TFindProcess& aFind,TOwnerType aType)
  736. #line 3830
  737. {return(RHandleBase::Open(aFind,aType));}
  738. inline TBool RProcess::HasCapability(TCapability aCapability, const char* aDiagnostic) const
  739. {
  740. return DoHasCapability(aCapability, aDiagnostic);
  741. }
  742. inline TBool RProcess::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
  743. {
  744. return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
  745. }
  746. #line 3902
  747. inline TInt RSessionBase::CreateSession(const TDesC& aServer,const TVersion& aVersion)
  748. {return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,0 ,0);}
  749. #line 3926
  750. inline TInt RSessionBase::CreateSession(RServer2 aServer,const TVersion& aVersion)
  751. {return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,0 ,0);}
  752. #line 3950
  753. inline TInt RSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
  754. {return DoSend(aFunction,&aArgs);}
  755. #line 3971
  756. inline void RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
  757. {DoSendReceive(aFunction,&aArgs,aStatus);}
  758. #line 3992
  759. inline TInt RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
  760. {return DoSendReceive(aFunction,&aArgs);}
  761. #line 4014
  762. inline TInt RSessionBase::Send(TInt aFunction) const
  763. {return DoSend(aFunction,0 );}
  764. #line 4033
  765. inline void RSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
  766. { DoSendReceive(aFunction,0 ,aStatus);}
  767. #line 4055
  768. inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError)
  769. { return RHandleBase::SetReturnedHandle(aHandleOrError);}
  770. inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle)
  771. { return RHandleBase::SetReturnedHandle(aHandleOrError,aHandle);}
  772. #line 4076
  773. inline TInt RSessionBase::SendReceive(TInt aFunction) const
  774. {return DoSendReceive(aFunction,0 );}
  775. inline RSubSessionBase::RSubSessionBase()
  776. : iSubSessionHandle(0)
  777. {}
  778. inline TInt RSubSessionBase::SubSessionHandle() const
  779. #line 4102
  780. {return iSubSessionHandle;}
  781. inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs)
  782. { return DoCreateSubSession(aSession,aFunction,&aArgs); }
  783. inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction)
  784. { return DoCreateSubSession(aSession,aFunction,0 ); }
  785. inline TInt RSubSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
  786. {return DoSend(aFunction,&aArgs);}
  787. inline void RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
  788. {DoSendReceive(aFunction,&aArgs,aStatus);}
  789. inline TInt RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
  790. {return DoSendReceive(aFunction,&aArgs);}
  791. inline TInt RSubSessionBase::Send(TInt aFunction) const
  792. {return DoSend(aFunction,0 );}
  793. inline void RSubSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
  794. { DoSendReceive(aFunction,0 ,aStatus);}
  795. inline TInt RSubSessionBase::SendReceive(TInt aFunction) const
  796. {return DoSendReceive(aFunction,0 );}
  797. #line 4132
  798. inline RRefBase::RRefBase()
  799. : iPtr(0 )
  800. {}
  801. #line 4143
  802. inline RRefBase::RRefBase(const RRefBase &aRef)
  803. {Copy(aRef);}
  804. #line 4155
  805. template <class T>
  806. inline RRef<T>::RRef()
  807. {}
  808. #line 4171
  809. template <class T>
  810. inline RRef<T>::RRef(const RRef<T> &anObject)
  811. {Copy(anObject);}
  812. #line 4188
  813. template <class T>
  814. inline void RRef<T>::operator=(const RRef<T> &anObject)
  815. {Copy(anObject);}
  816. #line 4200
  817. template <class T>
  818. inline T *RRef<T>::operator->()
  819. {return((T *)iPtr);}
  820. #line 4212
  821. template <class T>
  822. inline RRef<T>::operator T*()
  823. {return((T *)iPtr);}
  824. #line 4228
  825. template <class T>
  826. void RRef<T>::Alloc(const T &anObject)
  827. {DoAlloc(&anObject,sizeof(T));}
  828. #line 4245
  829. template <class T>
  830. void RRef<T>::Alloc(const T &anObject,TInt aSize)
  831. {DoAlloc(&anObject,aSize);}
  832. #line 4261
  833. template <class T>
  834. void RRef<T>::AllocL(const T &anObject)
  835. {DoAllocL(&anObject,sizeof(T));}
  836. #line 4278
  837. template <class T>
  838. void RRef<T>::AllocL(const T &anObject,TInt aSize)
  839. {DoAllocL(&anObject,aSize);}
  840. inline TBool TRegion::CheckError() const
  841. #line 4307
  842. {return(iError);}
  843. inline TInt TRegion::Count() const
  844. {return(iCount);}
  845. inline const TRect *TRegion::RectangleList() const
  846. #line 4333
  847. {return(((TRegion *)this)->RectangleListW());}
  848. inline TRegion::TRegion()
  849. {}
  850. inline TInt RRegion::CheckSpare() const
  851. #line 4354
  852. {return(iAllocedRects-iCount);}
  853. template <TInt S>
  854. inline TRegionFix<S>::TRegionFix() : TRegion(-S)
  855. {}
  856. template <TInt S>
  857. inline TRegionFix<S>::TRegionFix(const TRect &aRect) : TRegion(-S)
  858. {AddRect(aRect);}
  859. template <TInt S>
  860. inline TRegionFix<S>::TRegionFix(const TRegionFix<S> &aRegion)
  861. {*this=aRegion;}
  862. template <TInt S>
  863. inline RRegionBuf<S>::RRegionBuf() : RRegion(-S&(~ERRegionBuf),S)
  864. {}
  865. template <TInt S>
  866. inline RRegionBuf<S>::RRegionBuf(const RRegion &aRegion)
  867. {*this=aRegion;}
  868. template <TInt S>
  869. inline RRegionBuf<S>::RRegionBuf(const TRect &aRect) : RRegion(-S&(~ERRegionBuf),S)
  870. #line 4427
  871. {AddRect(aRect);}
  872. template <TInt S>
  873. inline RRegionBuf<S>::RRegionBuf(const RRegionBuf<S> &aRegion)
  874.     {*this=aRegion;}
  875. inline TTimerLockSpec &operator++(TTimerLockSpec &aLock)
  876. {
  877. return aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
  878. }
  879. inline TTimerLockSpec operator++(TTimerLockSpec &aLock, TInt)
  880. {
  881. TTimerLockSpec l=aLock;
  882. aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
  883. return l;
  884. }
  885. inline const TUidType& TCheckedUid::UidType() const
  886.     {return(iType);}
  887. template <class T>
  888. void _DeleteArray(T** aBegin,T** aEnd)
  889. {for (;;) if (aBegin<aEnd) delete *aBegin++; else return;}
  890. template <class T>
  891. struct _ArrayUtil
  892. {
  893. static inline void Delete(T* aBegin,T* aEnd,CBase*)
  894. {::_DeleteArray((CBase**)aBegin,(CBase**)aEnd);}
  895. static inline void Delete(T* aBegin,T* aEnd,TAny*)
  896. {::_DeleteArray(aBegin,aEnd);}
  897. static inline void Delete(T* aArray,TInt aCount)
  898. {Delete(aArray,aArray+aCount,*aArray);}
  899. };
  900. __declspec(dllexport) void PanicTFixedArray();
  901. template <class T,TInt S>
  902. inline TFixedArray<T,S>::TFixedArray()
  903. {}
  904. template <class T,TInt S>
  905. inline void TFixedArray<T,S>::Copy(const T* aList,TInt aLength)
  906. #line 4529
  907. {(void)((TUint(aLength)<=TUint(S))||(PanicTFixedArray(),0)) ;Mem::Copy(iRep,aList,aLength*sizeof(T));}
  908. template <class T,TInt S>
  909. inline TFixedArray<T,S>::TFixedArray(const T* aList,TInt aLength)
  910. #line 4547
  911. {Copy(aList,aLength);}
  912. template <class T,TInt S>
  913. inline void TFixedArray<T,S>::Reset()
  914. {Mem::FillZ(iRep,sizeof(iRep));}
  915. template <class T,TInt S>
  916. inline TInt TFixedArray<T,S>::Count() const
  917. #line 4572
  918. {return S;}
  919. template <class T,TInt S>
  920. inline TInt TFixedArray<T,S>::Length() const
  921. {return sizeof(T);}
  922. template <class T,TInt S>
  923. inline TBool TFixedArray<T,S>::InRange(TInt aIndex)
  924. {return TUint(aIndex)<S;}
  925. template <class T,TInt S>
  926. inline T& TFixedArray<T,S>::operator[](TInt aIndex)
  927. #line 4610
  928. {(void)((InRange(aIndex))||(PanicTFixedArray(),0)) ;return iRep[aIndex];}
  929. template <class T,TInt S>
  930. inline const T& TFixedArray<T,S>::operator[](TInt aIndex) const
  931. #line 4630
  932. {return (const_cast<ThisClass&>(*this)) [aIndex];}
  933. template <class T,TInt S>
  934. inline T& TFixedArray<T,S>::At(TInt aIndex)
  935. #line 4649
  936. {(void)((InRange(aIndex))||(PanicTFixedArray(),0)) ;return iRep[aIndex];}
  937. template <class T,TInt S>
  938. inline const T& TFixedArray<T,S>::At(TInt aIndex) const
  939. #line 4669
  940. {return (const_cast<ThisClass&>(*this)) .At(aIndex);}
  941. template <class T,TInt S>
  942. inline T* TFixedArray<T,S>::Begin()
  943. {return &iRep[0];}
  944. template <class T,TInt S>
  945. inline T* TFixedArray<T,S>::End()
  946. {return &iRep[S];}
  947. template <class T,TInt S>
  948. inline const T* TFixedArray<T,S>::Begin() const
  949. {return &iRep[0];}
  950. template <class T,TInt S>
  951. inline const T* TFixedArray<T,S>::End() const
  952. {return &iRep[S];}
  953. template <class T,TInt S>
  954. inline TInt TFixedArray<T,S>::CountFunctionR(const CBase*)
  955. {return S;}
  956. template <class T,TInt S>
  957. inline const TAny* TFixedArray<T,S>::AtFunctionR(const CBase* aThis,TInt aIndex)
  958. {return &(reinterpret_cast<const ThisClass&>(*aThis)) [aIndex];}
  959. template <class T,TInt S>
  960. inline TArray<T> TFixedArray<T,S>::Array() const
  961. {return TArray<T>(CountFunctionR,AtFunctionR,(reinterpret_cast<const CBase*>(this)) );}
  962. template <class T,TInt S>
  963. inline void TFixedArray<T,S>::DeleteAll()
  964. #line 4759
  965. {_ArrayUtil<T>::Delete(iRep,S);}
  966. inline RHeap* User::SwitchHeap(RAllocator* aHeap)
  967. { return (RHeap*)SwitchAllocator(aHeap); }
  968. inline RHeap& User::Heap()
  969. { return (RHeap&)Allocator(); }
  970. inline TBool User::CreatorHasCapability(TCapability aCapability, const char* aDiagnostic)
  971. {
  972. return DoCreatorHasCapability(aCapability, aDiagnostic);
  973. }
  974. inline TBool User::CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic)
  975. {
  976. return DoCreatorHasCapability(aCapability1, aCapability2, aDiagnostic);
  977. }
  978. #line 4833
  979. inline void TSecurityInfo::SetToCurrentInfo()
  980. { new (this) TSecurityInfo(RProcess()); }
  981. inline void TSecurityInfo::Set(RProcess aProcess)
  982. { new (this) TSecurityInfo(aProcess); }
  983. inline void TSecurityInfo::Set(RThread aThread)
  984. { new (this) TSecurityInfo(aThread); }
  985. inline void TSecurityInfo::Set(RMessagePtr2 aMsgPtr)
  986. { new (this) TSecurityInfo(aMsgPtr); }
  987. #line 4869
  988. inline TBool TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
  989. {
  990. return DoCheckPolicy(aProcess, aDiagnostic);
  991. }
  992. #line 4892
  993. inline TBool TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
  994. {
  995. return DoCheckPolicy(aThread, aDiagnostic);
  996. }
  997. #line 4914
  998. inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
  999. {
  1000. return DoCheckPolicy(aMsgPtr, aDiagnostic);
  1001. }
  1002. #line 4938
  1003. inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
  1004. {
  1005. return DoCheckPolicy(aMsgPtr, aMissing, aDiagnostic);
  1006. }
  1007. #line 4958
  1008. inline TBool TSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
  1009. {
  1010. return DoCheckPolicyCreator(aDiagnostic);
  1011. }
  1012. inline TBool TStaticSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
  1013. {
  1014. return (&(*this))->CheckPolicy(aProcess, aDiagnostic);
  1015. }
  1016. inline TBool TStaticSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
  1017. {
  1018. return (&(*this))->CheckPolicy(aThread, aDiagnostic);
  1019. }
  1020. inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
  1021. {
  1022. return (&(*this))->CheckPolicy(aMsgPtr, aDiagnostic);
  1023. }
  1024. inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
  1025. {
  1026. return (&(*this))->CheckPolicy(aMsgPtr, aMissing, aDiagnostic);
  1027. }
  1028. inline TBool TStaticSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
  1029. {
  1030. return (&(*this))->CheckPolicyCreator(aDiagnostic);
  1031. }
  1032. #line 5241
  1033. template <class T>
  1034. inline void RPointerArray<T>::AppendL(const T* anEntry)
  1035. { User::LeaveIfError(Append(anEntry));}
  1036. #line 5262
  1037. template <class T>
  1038. inline void RPointerArray<T>::InsertL(const T* anEntry, TInt aPos)
  1039. { User::LeaveIfError(Insert(anEntry,aPos)); }
  1040. #line 5282
  1041. template <class T>
  1042. inline TInt RPointerArray<T>::FindL(const T* anEntry) const
  1043. { return User::LeaveIfError(Find(anEntry));}
  1044. #line 5306
  1045. template <class T>
  1046. inline TInt RPointerArray<T>::FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const
  1047. { return User::LeaveIfError(Find(anEntry, anIdentity));}
  1048. #line 5324
  1049. template <class T>
  1050. inline TInt RPointerArray<T>::FindInAddressOrderL(const T* anEntry) const
  1051. { return User::LeaveIfError(FindInAddressOrder(anEntry));}
  1052. #line 5347
  1053. template <class T>
  1054. inline TInt RPointerArray<T>::FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const
  1055. { return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
  1056. #line 5370
  1057. template <class T>
  1058. inline void RPointerArray<T>::FindInAddressOrderL(const T* anEntry, TInt& anIndex) const
  1059. { User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
  1060. #line 5398
  1061. template <class T>
  1062. inline void RPointerArray<T>::FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  1063. { User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder)); }
  1064. #line 5430
  1065. template <class T>
  1066. inline TInt RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const
  1067. { return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
  1068. #line 5466
  1069. template <class T>
  1070. inline TInt RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  1071. { return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
  1072. #line 5504
  1073. template <class T>
  1074. inline void RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const
  1075. { User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
  1076. #line 5546
  1077. template <class T>
  1078. inline void RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  1079. { User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode)); }
  1080. #line 5564
  1081. template <class T>
  1082. inline void RPointerArray<T>::InsertInAddressOrderL(const T* anEntry)
  1083. { User::LeaveIfError(InsertInAddressOrder(anEntry)); }
  1084. #line 5592
  1085. template <class T>
  1086. inline void RPointerArray<T>::InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder)
  1087. { User::LeaveIfError(InsertInOrder(anEntry, anOrder)); }
  1088. #line 5614
  1089. template <class T>
  1090. inline void RPointerArray<T>::InsertInAddressOrderAllowRepeatsL(const T* anEntry)
  1091. { User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
  1092. #line 5639
  1093. template <class T>
  1094. inline void RPointerArray<T>::InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder)
  1095. { User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder)); }
  1096. #line 5656
  1097. template <class T>
  1098. inline void RPointerArray<T>::ReserveL(TInt aCount)
  1099. { User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
  1100. #line 5673
  1101. inline void RPointerArray<TAny>::AppendL(const TAny* anEntry)
  1102. { User::LeaveIfError(Append(anEntry));}
  1103. #line 5693
  1104. inline void RPointerArray<TAny>::InsertL(const TAny* anEntry, TInt aPos)
  1105. { User::LeaveIfError(Insert(anEntry,aPos)); }
  1106. #line 5712
  1107. inline TInt RPointerArray<TAny>::FindL(const TAny* anEntry) const
  1108. { return User::LeaveIfError(Find(anEntry));}
  1109. #line 5729
  1110. inline TInt RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry) const
  1111. { return User::LeaveIfError(FindInAddressOrder(anEntry));}
  1112. #line 5751
  1113. inline void RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const
  1114. { User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
  1115. #line 5782
  1116. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const
  1117. { return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
  1118. #line 5819
  1119. inline void RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const
  1120. { User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
  1121. #line 5835
  1122. inline void RPointerArray<TAny>::InsertInAddressOrderL(const TAny* anEntry)
  1123. { User::LeaveIfError(InsertInAddressOrder(anEntry)); }
  1124. #line 5856
  1125. inline void RPointerArray<TAny>::InsertInAddressOrderAllowRepeatsL(const TAny* anEntry)
  1126. { User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
  1127. #line 5869
  1128. template <class T>
  1129. inline void RArray<T>::AppendL(const T& anEntry)
  1130. { User::LeaveIfError(Append(anEntry));}
  1131. #line 5890
  1132. template <class T>
  1133. inline void RArray<T>::InsertL(const T& anEntry, TInt aPos)
  1134. { User::LeaveIfError(Insert(anEntry, aPos));}
  1135. #line 5912
  1136. template <class T>
  1137. inline TInt RArray<T>::FindL(const T& anEntry) const
  1138. { return User::LeaveIfError(Find(anEntry));}
  1139. #line 5937
  1140. template <class T>
  1141. inline TInt RArray<T>::FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const
  1142. { return User::LeaveIfError(Find(anEntry, anIdentity));}
  1143. #line 5956
  1144. template <class T>
  1145. inline TInt RArray<T>::FindInSignedKeyOrderL(const T& anEntry) const
  1146. { return User::LeaveIfError(FindInSignedKeyOrder(anEntry));}
  1147. #line 5975
  1148. template <class T>
  1149. inline TInt RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry) const
  1150. { return User::LeaveIfError(FindInUnsignedKeyOrder(anEntry));}
  1151. #line 5997
  1152. template <class T>
  1153. inline TInt RArray<T>::FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const
  1154. { return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
  1155. #line 6018
  1156. template <class T>
  1157. inline void RArray<T>::FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const
  1158. { User::LeaveIfError(FindInSignedKeyOrder(anEntry, anIndex));}
  1159. #line 6039
  1160. template <class T>
  1161. inline void RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const
  1162. { User::LeaveIfError(FindInUnsignedKeyOrder(anEntry, anIndex));}
  1163. #line 6063
  1164. template <class T>
  1165. inline void RArray<T>::FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  1166. { User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder));}
  1167. #line 6096
  1168. template <class T>
  1169. inline TInt RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const
  1170. { return User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, aMode));}
  1171. #line 6130
  1172. template <class T>
  1173. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const
  1174. { return User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, aMode));}
  1175. #line 6166
  1176. template <class T>
  1177. inline TInt RArray<T>::SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  1178. { return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
  1179. #line 6207
  1180. template <class T>
  1181. inline void RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
  1182. { User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, anIndex, aMode));}
  1183. #line 6246
  1184. template <class T>
  1185. inline void RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
  1186. { User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, anIndex, aMode));}
  1187. #line 6288
  1188. template <class T>
  1189. inline void RArray<T>::SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  1190. { User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode));}
  1191. #line 6309
  1192. template <class T>
  1193. inline void RArray<T>::InsertInSignedKeyOrderL(const T& anEntry)
  1194. { User::LeaveIfError(InsertInSignedKeyOrder(anEntry));}
  1195. #line 6329
  1196. template <class T>
  1197. inline void RArray<T>::InsertInUnsignedKeyOrderL(const T& anEntry)
  1198. { User::LeaveIfError(InsertInUnsignedKeyOrder(anEntry));}
  1199. #line 6355
  1200. template <class T>
  1201. inline void RArray<T>::InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder)
  1202. { User::LeaveIfError(InsertInOrder(anEntry, anOrder));}
  1203. #line 6378
  1204. template <class T>
  1205. inline void RArray<T>::InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry)
  1206. { User::LeaveIfError(InsertInSignedKeyOrderAllowRepeats(anEntry));}
  1207. #line 6401
  1208. template <class T>
  1209. inline void RArray<T>::InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry)
  1210. { User::LeaveIfError(InsertInUnsignedKeyOrderAllowRepeats(anEntry));}
  1211. #line 6427
  1212. template <class T>
  1213. inline void RArray<T>::InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder)
  1214. { User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder));}
  1215. #line 6444
  1216. template <class T>
  1217. inline void RArray<T>::ReserveL(TInt aCount)
  1218. { User::LeaveIfError(RArrayBase::DoReserve(aCount)); }
  1219. #line 6460
  1220. inline void RArray<TInt>::AppendL(TInt anEntry)
  1221. { User::LeaveIfError(Append(anEntry));}
  1222. #line 6479
  1223. inline void RArray<TInt>::InsertL(TInt anEntry, TInt aPos)
  1224. { User::LeaveIfError(Insert(anEntry, aPos));}
  1225. #line 6497
  1226. inline TInt RArray<TInt>::FindL(TInt anEntry) const
  1227. { return User::LeaveIfError(Find(anEntry));}
  1228. #line 6514
  1229. inline TInt RArray<TInt>::FindInOrderL(TInt anEntry) const
  1230. { return User::LeaveIfError(FindInOrder(anEntry));}
  1231. #line 6535
  1232. inline void RArray<TInt>::FindInOrderL(TInt anEntry, TInt& anIndex) const
  1233. { User::LeaveIfError(FindInOrder(anEntry, anIndex));}
  1234. #line 6566
  1235. inline TInt RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt aMode) const
  1236. { return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
  1237. #line 6603
  1238. inline void RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const
  1239. { User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
  1240. #line 6623
  1241. inline void RArray<TInt>::InsertInOrderL(TInt anEntry)
  1242. { User::LeaveIfError(InsertInOrder(anEntry));}
  1243. #line 6645
  1244. inline void RArray<TInt>::InsertInOrderAllowRepeatsL(TInt anEntry)
  1245. { User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
  1246. #line 6661
  1247. inline void RArray<TInt>::ReserveL(TInt aCount)
  1248. { User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
  1249. #line 6676
  1250. inline void RArray<TUint>::AppendL(TUint anEntry)
  1251. { User::LeaveIfError(Append(anEntry));}
  1252. #line 6696
  1253. inline void RArray<TUint>::InsertL(TUint anEntry, TInt aPos)
  1254. { User::LeaveIfError(Insert(anEntry, aPos));}
  1255. #line 6713
  1256. inline TInt RArray<TUint>::FindL(TUint anEntry) const
  1257. { return User::LeaveIfError(Find(anEntry));}
  1258. #line 6731
  1259. inline TInt RArray<TUint>::FindInOrderL(TUint anEntry) const
  1260. { return User::LeaveIfError(FindInOrder(anEntry));}
  1261. #line 6755
  1262. inline void RArray<TUint>::FindInOrderL(TUint anEntry, TInt& anIndex) const
  1263. { User::LeaveIfError(FindInOrder(anEntry, anIndex));}
  1264. #line 6786
  1265. inline TInt RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt aMode) const
  1266. { return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
  1267. #line 6822
  1268. inline void RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const
  1269. { User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
  1270. #line 6842
  1271. inline void RArray<TUint>::InsertInOrderL(TUint anEntry)
  1272. { User::LeaveIfError(InsertInOrder(anEntry));}
  1273. #line 6864
  1274. inline void RArray<TUint>::InsertInOrderAllowRepeatsL(TUint anEntry)
  1275. { User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
  1276. #line 6880
  1277. inline void RArray<TUint>::ReserveL(TInt aCount)
  1278. { User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
  1279. #line 6891
  1280. inline void RMessagePtr2::SetProcessPriorityL(TProcessPriority aPriority) const
  1281. { User::LeaveIfError(SetProcessPriority(aPriority));}
  1282. #line 6903
  1283. inline void RMessagePtr2::ClientL(RThread& aClient, TOwnerType aOwnerType) const
  1284. { User::LeaveIfError(Client(aClient, aOwnerType));}
  1285. inline TBool RMessagePtr2::HasCapability(TCapability aCapability, const char* aDiagnostic) const
  1286. {
  1287. return DoHasCapability(aCapability, aDiagnostic);
  1288. }
  1289. inline void RMessagePtr2::HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage) const
  1290. {
  1291. if (!HasCapability(aCapability, aDiagnosticMessage))
  1292. {
  1293. User::Leave(KErrPermissionDenied);
  1294. }
  1295. }
  1296. inline TBool RMessagePtr2::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
  1297. {
  1298. return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
  1299. }
  1300. inline void RMessagePtr2::HasCapabilityL(TCapability aCapability1, TCapability aCapability2, const char* aDiagnosticMessage) const
  1301. {
  1302. if (!HasCapability(aCapability1, aCapability2, aDiagnosticMessage))
  1303. {
  1304. User::Leave(KErrPermissionDenied);
  1305. }
  1306. }
  1307. #line 6995
  1308. inline TInt RThread::RenameMe(const TDesC& aName)
  1309. { return User::RenameThread(aName); }
  1310. inline TInt RProcess::RenameMe(const TDesC& aName)
  1311. { return User::RenameProcess(aName); }
  1312. #line 7044
  1313. extern "C" bool __uncaught_exception(void);
  1314. namespace std {
  1315. inline bool uncaught_exception(void) { return ::__uncaught_exception(); }
  1316. }
  1317. #line 4892 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 1 */
  1318. #line 3 "C:\gbtukmanpf01\NOK124\Courses\S60\05300-S60_C++_Introduction\Working\LabCode\Lab_05304-s2.cb1\starter\src\S60UIExampleappui.cpp" /* stack depth 0 */
  1319. #line 1 "C:\gbtukmanpf01\NOK124\Courses\S60\05300-S60_C++_Introduction\Working\LabCode\Lab_05304-s2.cb1\starter\inc\S60UIExample.pan" /* stack depth 1 */
  1320. enum TS60UIExamplePanics
  1321.     {
  1322.     ES60UIExampleBasicUi = 1
  1323.     };
  1324. inline void Panic( TS60UIExamplePanics aReason )
  1325.     {
  1326.     const static TLitC<sizeof(L"S60UIExample")/2> applicationName={sizeof(L"S60UIExample")/2-1,L"S60UIExample"} ;
  1327.     User::Panic( applicationName, aReason );
  1328.     }
  1329. #line 4 "C:\gbtukmanpf01\NOK124\Courses\S60\05300-S60_C++_Introduction\Working\LabCode\Lab_05304-s2.cb1\starter\src\S60UIExampleappui.cpp" /* stack depth 0 */
  1330. #line 1 "C:\gbtukmanpf01\NOK124\Courses\S60\05300-S60_C++_Introduction\Working\LabCode\Lab_05304-s2.cb1\starter\inc\S60UIExampleAppUi.h" /* stack depth 1 */
  1331. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\aknViewAppUi.h" /* stack depth 2 */
  1332. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\aknappui.h" /* stack depth 3 */
  1333. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\eikappui.h" /* stack depth 4 */
  1334. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\coeaui.h" /* stack depth 5 */
  1335. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.h" /* stack depth 6 */
  1336. #line 13
  1337. class CBase
  1338. #line 42
  1339. {
  1340. public:
  1341. inline CBase() {}
  1342. __declspec(dllexport) virtual ~CBase();
  1343. inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
  1344. inline TAny* operator new(TUint aSize) throw() ;
  1345. inline TAny* operator new(TUint aSize, TLeave);
  1346. inline TAny* operator new(TUint aSize, TUint aExtraSize) throw() ;
  1347. inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize);
  1348. __declspec(dllexport) static void Delete(CBase* aPtr);
  1349. protected:
  1350. __declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
  1351. private:
  1352. CBase(const CBase&);
  1353. CBase& operator=(const CBase&);
  1354. private:
  1355. };
  1356. class CBufBase : public CBase
  1357. #line 86
  1358. {
  1359. public:
  1360. __declspec(dllexport) ~CBufBase();
  1361. inline TInt Size() const;
  1362. __declspec(dllexport) void Reset();
  1363. __declspec(dllexport) void Read(TInt aPos,TDes8& aDes) const;
  1364. __declspec(dllexport) void Read(TInt aPos,TDes8& aDes,TInt aLength) const;
  1365. __declspec(dllexport) void Read(TInt aPos,TAny* aPtr,TInt aLength) const;
  1366. __declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes);
  1367. __declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes,TInt aLength);
  1368. __declspec(dllexport) void Write(TInt aPos,const TAny* aPtr,TInt aLength);
  1369. __declspec(dllexport) void InsertL(TInt aPos,const TDesC8& aDes);
  1370. __declspec(dllexport) void InsertL(TInt aPos,const TDesC8& aDes,TInt aLength);
  1371. __declspec(dllexport) void InsertL(TInt aPos,const TAny* aPtr,TInt aLength);
  1372. __declspec(dllexport) void ExpandL(TInt aPos,TInt aLength);
  1373. __declspec(dllexport) void ResizeL(TInt aSize);
  1374. #line 117
  1375.     virtual void Compress()=0;
  1376. #line 131
  1377. virtual void Delete(TInt aPos,TInt aLength)=0;
  1378. #line 147
  1379. virtual TPtr8 Ptr(TInt aPos)=0;
  1380. #line 168
  1381. virtual TPtr8 BackPtr(TInt aPos)=0;
  1382. private:
  1383. virtual void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength)=0;
  1384. protected:
  1385. __declspec(dllexport) CBufBase(TInt anExpandSize);
  1386. protected:
  1387. TInt iSize;
  1388. TInt iExpandSize;
  1389. };
  1390. class CBufFlat : public CBufBase
  1391. #line 195
  1392. {
  1393. public:
  1394. __declspec(dllexport) ~CBufFlat();
  1395. __declspec(dllexport) static CBufFlat* NewL(TInt anExpandSize);
  1396. inline TInt Capacity() const;
  1397. __declspec(dllexport) void SetReserveL(TInt aSize);
  1398. __declspec(dllexport) void Compress();
  1399. __declspec(dllexport) void Delete(TInt aPos,TInt aLength);
  1400. __declspec(dllexport) TPtr8 Ptr(TInt aPos);
  1401. __declspec(dllexport) TPtr8 BackPtr(TInt aPos);
  1402. protected:
  1403. __declspec(dllexport) CBufFlat(TInt anExpandSize);
  1404. private:
  1405. __declspec(dllexport) void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
  1406. private:
  1407. TInt iMaxSize;
  1408. TUint8* iPtr;
  1409. };
  1410. class TBufSegLink;
  1411. class CBufSeg : public CBufBase
  1412. #line 238
  1413. {
  1414. public:
  1415. __declspec(dllexport) ~CBufSeg();
  1416. __declspec(dllexport) static CBufSeg* NewL(TInt anExpandSize);
  1417.     __declspec(dllexport) void Compress();
  1418. __declspec(dllexport) void Delete(TInt aPos,TInt aLength);
  1419. __declspec(dllexport) TPtr8 Ptr(TInt aPos);
  1420. __declspec(dllexport) TPtr8 BackPtr(TInt aPos);
  1421. protected:
  1422. __declspec(dllexport) CBufSeg(TInt anExpandSize);
  1423. void InsertIntoSegment(TBufSegLink* aSeg,TInt anOffset,const TAny* aPtr,TInt aLength);
  1424. void DeleteFromSegment(TBufSegLink* aSeg,TInt anOffset,TInt aLength);
  1425. void FreeSegment(TBufSegLink* aSeg);
  1426.     void SetSBO(TInt aPos);
  1427. void AllocSegL(TBufSegLink* aSeg,TInt aNumber);
  1428. private:
  1429. __declspec(dllexport) void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
  1430. private:
  1431.     TDblQue<TBufSegLink> iQue;
  1432. TBufSegLink* iSeg;
  1433. TInt iBase;
  1434. TInt iOffset;
  1435. };
  1436. class TKeyArrayFix : public TKey
  1437. #line 289
  1438. {
  1439. public:
  1440. __declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpText aType);
  1441. __declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpText aType,TInt aLength);
  1442. __declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpNumeric aType);
  1443. protected:
  1444. __declspec(dllexport) virtual void Set(CBufBase* aBase,TInt aRecordLength);
  1445. __declspec(dllexport) TAny* At(TInt anIndex) const;
  1446. protected:
  1447. TInt iRecordLength;
  1448. CBufBase* iBase;
  1449. friend class CArrayFixBase;
  1450. };
  1451. typedef CBufBase*(*TBufRep)(TInt anExpandSize);
  1452. class CArrayFixBase : public CBase
  1453. #line 319
  1454. {
  1455. public:
  1456. __declspec(dllexport) ~CArrayFixBase();
  1457. inline TInt Count() const;
  1458. inline TInt Length() const;
  1459. __declspec(dllexport) void Compress();
  1460. __declspec(dllexport) void Reset();
  1461. __declspec(dllexport) TInt Sort(TKeyArrayFix& aKey);
  1462. __declspec(dllexport) TAny* At(TInt anIndex) const;
  1463. __declspec(dllexport) TAny* End(TInt anIndex) const;
  1464. __declspec(dllexport) TAny* Back(TInt anIndex) const;
  1465. __declspec(dllexport) void Delete(TInt anIndex);
  1466. __declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
  1467. __declspec(dllexport) TAny* ExpandL(TInt anIndex);
  1468. __declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
  1469. __declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
  1470. __declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr);
  1471. __declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aCount);
  1472. __declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TKeyArrayFix& aKey);
  1473. __declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TKeyArrayFix& aKey);
  1474. __declspec(dllexport) void ResizeL(TInt aCount,const TAny* aPtr);
  1475. protected:
  1476. __declspec(dllexport) CArrayFixBase(TBufRep aRep,TInt aRecordLength,TInt aGranularity);
  1477. __declspec(dllexport) void InsertRepL(TInt anIndex,const TAny* aPtr,TInt aReplicas);
  1478. __declspec(dllexport) void SetKey(TKeyArrayFix& aKey) const;
  1479. __declspec(dllexport) void SetReserveFlatL(TInt aCount);
  1480. __declspec(dllexport) static TInt CountR(const CBase* aPtr);
  1481. __declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
  1482. private:
  1483. TInt iCount;
  1484. TInt iGranularity;
  1485. TInt iLength;
  1486. TBufRep iCreateRep;
  1487. CBufBase* iBase;
  1488. };
  1489. template <class T>
  1490. class CArrayFix : public CArrayFixBase
  1491. #line 370
  1492. {
  1493. public:
  1494. inline CArrayFix(TBufRep aRep,TInt aGranularity);
  1495. inline const T& operator[](TInt anIndex) const;
  1496. inline T& operator[](TInt anIndex);
  1497. inline const T& At(TInt anIndex) const;
  1498. inline const T* End(TInt anIndex) const;
  1499. inline const T* Back(TInt anIndex) const;
  1500. inline T& At(TInt anIndex);
  1501. inline T* End(TInt anIndex);
  1502. inline T* Back(TInt anIndex);
  1503. inline void AppendL(const T& aRef);
  1504. inline void AppendL(const T* aPtr,TInt aCount);
  1505. inline void AppendL(const T& aRef,TInt aReplicas);
  1506. inline T& ExpandL(TInt anIndex);
  1507. inline T& ExtendL();
  1508. inline TInt Find(const T& aRef,TKeyArrayFix& aKey,TInt& anIndex) const;
  1509. inline TInt FindIsq(const T& aRef,TKeyArrayFix& aKey,TInt& anIndex) const;
  1510. inline void InsertL(TInt anIndex,const T& aRef);
  1511. inline void InsertL(TInt anIndex,const T* aPtr,TInt aCount);
  1512. inline void InsertL(TInt anIndex,const T& aRef,TInt aReplicas);
  1513. inline TInt InsertIsqL(const T& aRef,TKeyArrayFix& aKey);
  1514. inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TKeyArrayFix& aKey);
  1515. inline void ResizeL(TInt aCount);
  1516. inline void ResizeL(TInt aCount,const T& aRef);
  1517. inline const TArray<T> Array() const;
  1518. };
  1519. template<> class CArrayFix<TAny> : public CArrayFixBase
  1520. #line 413
  1521. {
  1522. public:
  1523. inline CArrayFix(TBufRep aRep,TInt aRecordLength,TInt aGranularity);
  1524. inline const TAny* At(TInt anIndex) const;
  1525. inline const TAny* End(TInt anIndex) const;
  1526. inline const TAny* Back(TInt anIndex) const;
  1527. inline TAny* At(TInt anIndex);
  1528. inline TAny* End(TInt anIndex);
  1529. inline TAny* Back(TInt anIndex);
  1530. inline void AppendL(const TAny* aPtr);
  1531. inline void AppendL(const TAny* aPtr,TInt aCount);
  1532. inline TAny* ExtendL();
  1533. };
  1534. template <class T>
  1535. class CArrayFixFlat : public CArrayFix<T>
  1536. #line 452
  1537. {
  1538. public:
  1539. inline explicit CArrayFixFlat(TInt aGranularity);
  1540. inline void SetReserveL(TInt aCount);
  1541. };
  1542. template<> class CArrayFixFlat<TAny> : public CArrayFix<TAny>
  1543. #line 479
  1544. {
  1545. public:
  1546. inline CArrayFixFlat(TInt aRecordLength,TInt aGranularity);
  1547. inline void SetReserveL(TInt aCount);
  1548. };
  1549. template<> class CArrayFixFlat<TInt> : public CArrayFix<TInt>
  1550. #line 498
  1551. {
  1552. public:
  1553. __declspec(dllexport) explicit CArrayFixFlat(TInt aGranularity);
  1554. __declspec(dllexport) ~CArrayFixFlat();
  1555. inline void SetReserveL(TInt aCount);
  1556. };
  1557. template<> class CArrayFixFlat<TUid> : public CArrayFix<TUid>
  1558. #line 518
  1559. {
  1560. public:
  1561. __declspec(dllexport) explicit CArrayFixFlat(TInt aGranularity);
  1562. __declspec(dllexport) ~CArrayFixFlat();
  1563. inline void SetReserveL(TInt aCount);
  1564. };
  1565. template <class T>
  1566. class CArrayFixSeg : public CArrayFix<T>
  1567. #line 545
  1568. {
  1569. public:
  1570. inline explicit CArrayFixSeg(TInt aGranularity);
  1571. };
  1572. template<> class CArrayFixSeg<TAny> : public CArrayFix<TAny>
  1573. #line 571
  1574. {
  1575. public:
  1576. inline CArrayFixSeg(TInt aRecordLength,TInt aGranularity);
  1577. };
  1578. template <class T>
  1579. class CArrayPtr : public CArrayFix<T*>
  1580. #line 591
  1581. {
  1582. public:
  1583. inline CArrayPtr(TBufRep aRep,TInt aGranularity);
  1584.     void ResetAndDestroy();
  1585. };
  1586. template <class T>
  1587. class CArrayPtrFlat : public CArrayPtr<T>
  1588. #line 624
  1589. {
  1590. public:
  1591. inline explicit CArrayPtrFlat(TInt aGranularity);
  1592. inline void SetReserveL(TInt aCount);
  1593. };
  1594. template <class T>
  1595. class CArrayPtrSeg : public CArrayPtr<T>
  1596. #line 652
  1597. {
  1598. public:
  1599. inline explicit CArrayPtrSeg(TInt aGranularity);
  1600. };
  1601. class TKeyArrayVar : public TKey
  1602. #line 689
  1603. {
  1604. public:
  1605. __declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpText aType);
  1606. __declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpText aType,TInt aLength);
  1607. __declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpNumeric aType);
  1608. protected:
  1609. __declspec(dllexport) virtual void Set(CBufBase* aBase);
  1610. __declspec(dllexport) TAny* At(TInt anIndex) const;
  1611. protected:
  1612. CBufBase* iBase;
  1613. friend class CArrayVarBase;
  1614. };
  1615. class CArrayVarBase : public CBase
  1616. #line 718
  1617. {
  1618. public:
  1619. __declspec(dllexport) ~CArrayVarBase();
  1620. inline TInt Count() const;
  1621. __declspec(dllexport) TInt Length(TInt anIndex) const;
  1622. __declspec(dllexport) void Compress();
  1623. __declspec(dllexport) void Reset();
  1624. __declspec(dllexport) TInt Sort(TKeyArrayVar& aKey);
  1625. __declspec(dllexport) TAny* At(TInt anIndex) const;
  1626. __declspec(dllexport) void Delete(TInt anIndex);
  1627. __declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
  1628. __declspec(dllexport) TAny* ExpandL(TInt anIndex,TInt aLength);
  1629. __declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
  1630. __declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
  1631. __declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
  1632. __declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
  1633. __declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
  1634. protected:
  1635. __declspec(dllexport) CArrayVarBase(TBufRep aRep,TInt aGranularity);
  1636. __declspec(dllexport) void SetKey(TKeyArrayVar& aKey) const;
  1637. __declspec(dllexport) static TInt CountR(const CBase* aPtr);
  1638. __declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
  1639. private:
  1640. TInt iCount;
  1641. TInt iGranularity;
  1642. TBufRep iCreateRep;
  1643. CBufBase* iBase;
  1644. };
  1645. template <class T>
  1646. class CArrayVar : public CArrayVarBase
  1647. #line 762
  1648. {
  1649. public:
  1650. inline CArrayVar(TBufRep aRep,TInt aGranularity);
  1651. inline const T& operator[](TInt anIndex) const;
  1652. inline T& operator[](TInt anIndex);
  1653. inline const T& At(TInt anIndex) const;
  1654. inline T& At(TInt anIndex);
  1655. inline void AppendL(const T& aRef,TInt aLength);
  1656. inline T& ExpandL(TInt anIndex,TInt aLength);
  1657. inline T& ExtendL(TInt aLength);
  1658. inline TInt Find(const T& aRef,TKeyArrayVar& aKey,TInt& anIndex) const;
  1659. inline TInt FindIsq(const T& aRef,TKeyArrayVar& aKey,TInt& anIndex) const;
  1660. inline void InsertL(TInt anIndex,const T& aRef,TInt aLength);
  1661. inline TInt InsertIsqL(const T& aRef,TInt aLength,TKeyArrayVar& aKey);
  1662.   inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TInt aLength,TKeyArrayVar& aKey);
  1663. inline const TArray<T> Array() const;
  1664. };
  1665. template<> class CArrayVar<TAny> : public CArrayVarBase
  1666. #line 799
  1667. {
  1668. public:
  1669. inline CArrayVar(TBufRep aRep,TInt aGranularity);
  1670. inline const TAny* At(TInt anIndex) const;
  1671. inline TAny* At(TInt anIndex);
  1672. inline void AppendL(const TAny* aPtr,TInt aLength);
  1673. inline TAny* ExtendL(TInt aLength);
  1674. };
  1675. template <class T>
  1676. class CArrayVarFlat : public CArrayVar<T>
  1677. #line 828
  1678. {
  1679. public:
  1680. inline explicit CArrayVarFlat(TInt aGranularity);
  1681. };
  1682. template <class T>
  1683. class CArrayVarSeg : public CArrayVar<T>
  1684. #line 853
  1685. {
  1686. public:
  1687. inline explicit CArrayVarSeg(TInt aGranularity);
  1688. };
  1689. class TKeyArrayPak : public TKeyArrayVar
  1690. #line 890
  1691. {
  1692. public:
  1693. __declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpText aType);
  1694. __declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpText aType,TInt aLength);
  1695. __declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpNumeric aType);
  1696. protected:
  1697. __declspec(dllexport) virtual void Set(CBufBase* aBase);
  1698. __declspec(dllexport) TAny* At(TInt anIndex) const;
  1699. private:
  1700. TInt iCacheIndex;
  1701. TInt iCacheOffset;
  1702. friend class CArrayPakBase;
  1703. };
  1704. class CArrayPakBase : public CBase
  1705. #line 916
  1706. {
  1707. public:
  1708. __declspec(dllexport) ~CArrayPakBase();
  1709. inline TInt Count() const;
  1710. __declspec(dllexport) TInt Length(TInt anIndex) const;
  1711. __declspec(dllexport) void Compress();
  1712. __declspec(dllexport) void Reset();
  1713. __declspec(dllexport) void SortL(TKeyArrayVar& aKey);
  1714. __declspec(dllexport) TAny* At(TInt anIndex) const;
  1715. __declspec(dllexport) void Delete(TInt anIndex);
  1716. __declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
  1717. __declspec(dllexport) TAny* ExpandL(TInt anIndex,TInt aLength);
  1718. __declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
  1719. __declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
  1720. __declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
  1721. __declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
  1722. __declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
  1723. protected:
  1724. __declspec(dllexport) CArrayPakBase(TBufRep aRep,TInt aGranularity);
  1725. __declspec(dllexport) void SetKey(TKeyArrayPak& aKey) const;
  1726. __declspec(dllexport) TInt GetOffset(TInt anIndex) const;
  1727. __declspec(dllexport) void BuildVarArrayL(CArrayVarFlat<TAny> *& aVarFlat);
  1728. __declspec(dllexport) static TInt CountR(const CBase* aPtr);
  1729. __declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
  1730. private:
  1731. TInt iCount;
  1732. TInt iGranularity;
  1733. TBufRep iCreateRep;
  1734. CBufBase* iBase;
  1735. TInt iCacheIndex;
  1736. TInt iCacheOffset;
  1737. };
  1738. template <class T>
  1739. class CArrayPak : public CArrayPakBase
  1740. #line 964
  1741. {
  1742. public:
  1743. inline CArrayPak(TBufRep aRep,TInt aGranularity);
  1744. inline const T& operator[](TInt anIndex) const;
  1745. inline T& operator[](TInt anIndex);
  1746. inline const T& At(TInt anIndex) const;
  1747. inline T& At(TInt anIndex);
  1748. inline void AppendL(const T& aRef,TInt aLength);
  1749. inline T& ExpandL(TInt anIndex,TInt aLength);
  1750. inline T& ExtendL(TInt aLength);
  1751. inline TInt Find(const T& aRef,TKeyArrayPak& aKey,TInt& anIndex) const;
  1752. inline TInt FindIsq(const T& aRef,TKeyArrayPak& aKey,TInt& anIndex) const;
  1753. inline void InsertL(TInt anIndex,const T& aRef,TInt aLength);
  1754. inline TInt InsertIsqL(const T& aRef,TInt aLength,TKeyArrayPak& aKey);
  1755. inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TInt aLength,TKeyArrayPak& aKey);
  1756. inline const TArray<T> Array() const;
  1757. };
  1758. template<> class CArrayPak<TAny> : public CArrayPakBase
  1759. #line 1001
  1760. {
  1761. public:
  1762. inline CArrayPak(TBufRep aRep,TInt aGranularity);
  1763. inline const TAny* At(TInt anIndex) const;
  1764. inline TAny* At(TInt anIndex);
  1765. inline void AppendL(const TAny* aPtr,TInt aLength);
  1766. inline TAny* ExtendL(TInt aLength);
  1767. };
  1768. template <class T>
  1769. class CArrayPakFlat : public CArrayPak<T>
  1770. #line 1029
  1771. {
  1772. public:
  1773. inline explicit CArrayPakFlat(TInt aGranularity);
  1774. };
  1775. class CObjectCon;
  1776. class CObject : public CBase
  1777. #line 1055
  1778. {
  1779. public:
  1780. __declspec(dllexport) CObject();
  1781. __declspec(dllexport) ~CObject();
  1782. __declspec(dllexport) virtual TInt Open();
  1783. __declspec(dllexport) virtual void Close();
  1784. __declspec(dllexport) virtual TName Name() const;
  1785. __declspec(dllexport) virtual TFullName FullName() const;
  1786. __declspec(dllexport) TInt SetName(const TDesC* aName);
  1787. __declspec(dllexport) void SetNameL(const TDesC* aName);
  1788. inline CObject* Owner() const;
  1789. inline void SetOwner(CObject* anOwner);
  1790. inline TInt AccessCount() const;
  1791. protected:
  1792. __declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
  1793. protected:
  1794. inline TInt UniqueID() const;
  1795. inline void Inc();
  1796. inline void Dec();
  1797. private:
  1798. TInt iAccessCount;
  1799. CObject* iOwner;
  1800. CObjectCon* iContainer;
  1801. HBufC* iName;
  1802. TAny* iSpare1;
  1803. TAny* iSpare2;
  1804. friend class CObjectCon;
  1805. friend class CObjectIx;
  1806. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  1807. };
  1808. struct TObjectDataStr
  1809. {
  1810. TInt16 instance;
  1811. TInt16 uniqueID;
  1812. };
  1813. struct SObjectIxRec
  1814. {
  1815. union
  1816. {
  1817. TObjectDataStr str;
  1818. TInt nextEmpty;
  1819. };
  1820. CObject* obj;
  1821. };
  1822. class CObjectIx : public CBase
  1823. #line 1129
  1824. {
  1825. public:
  1826. enum {
  1827.          ENoClose=KHandleNoClose,
  1828.          ELocalHandle=KHandleFlagLocal
  1829.          };
  1830. public:
  1831. __declspec(dllexport) static CObjectIx* NewL();
  1832. __declspec(dllexport) ~CObjectIx();
  1833. __declspec(dllexport) TInt AddL(CObject* anObj);
  1834. __declspec(dllexport) void Remove(TInt aHandle);
  1835. __declspec(dllexport) CObject* At(TInt aHandle,TInt aUniqueID);
  1836. __declspec(dllexport) CObject* At(TInt aHandle);
  1837. __declspec(dllexport) CObject* AtL(TInt aHandle,TInt aUniqueID);
  1838. __declspec(dllexport) CObject* AtL(TInt aHandle);
  1839. __declspec(dllexport) TInt At(const CObject* anObject) const;
  1840. __declspec(dllexport) TInt Count(CObject* anObject) const;
  1841. __declspec(dllexport) CObject* operator[](TInt anIndex);
  1842. inline TInt Count() const;
  1843. inline TInt ActiveCount() const;
  1844. protected:
  1845. __declspec(dllexport) CObjectIx();
  1846. private:
  1847. void UpdateState();
  1848. private:
  1849. TInt iNumEntries;
  1850. TInt iHighWaterMark;
  1851. TInt iAllocated;
  1852. TInt iNextInstance;
  1853. SObjectIxRec *iObjects;
  1854. TInt iFree;
  1855. TInt iUpdateDisabled;
  1856. TAny* iSpare1;
  1857. TAny* iSpare2;
  1858. };
  1859. inline TBool IsLocalHandle(TInt aHandle)
  1860. {return(aHandle&CObjectIx::ELocalHandle);}
  1861. inline void SetLocalHandle(TInt &aHandle)
  1862. {aHandle|=CObjectIx::ELocalHandle;}
  1863. inline void UnSetLocalHandle(TInt &aHandle)
  1864. {aHandle&=(~CObjectIx::ELocalHandle);}
  1865. class CObjectCon : public CBase
  1866. #line 1208
  1867. {
  1868. protected:
  1869. enum {ENotOwnerID};
  1870. public:
  1871. __declspec(dllexport) static CObjectCon* NewL();
  1872. __declspec(dllexport) ~CObjectCon();
  1873. __declspec(dllexport) void Remove(CObject* anObj);
  1874. __declspec(dllexport) void AddL(CObject* anObj);
  1875. __declspec(dllexport) CObject* operator[](TInt anIndex);
  1876. __declspec(dllexport) CObject* At(TInt aFindHandle) const;
  1877. __declspec(dllexport) CObject* AtL(TInt aFindHandle) const;
  1878. __declspec(dllexport) TInt CheckUniqueFullName(const CObject* anOwner,const TDesC& aName) const;
  1879. __declspec(dllexport) TInt CheckUniqueFullName(const CObject* anObject) const;
  1880. __declspec(dllexport) TInt FindByName(TInt& aFindHandle,const TDesC& aMatch,TName& aName) const;
  1881. __declspec(dllexport) TInt FindByFullName(TInt& aFindHandle,const TDesC& aMatch,TFullName& aFullName) const;
  1882. inline TInt UniqueID() const;
  1883. inline TInt Count() const;
  1884. protected:
  1885. __declspec(dllexport) CObjectCon(TInt aUniqueID);
  1886. TBool NamesMatch(const CObject* anObject, const CObject* aCurrentObject) const;
  1887. TBool NamesMatch(const CObject* anObject, const TName& anObjectName, const CObject* aCurrentObject) const;
  1888. public:
  1889. TInt iUniqueID;
  1890. private:
  1891. TInt iCount;
  1892. TInt iAllocated;
  1893. CObject** iObjects;
  1894. TAny* iSpare1;
  1895. TAny* iSpare2;
  1896. friend class CObjectConIx;
  1897. };
  1898. class CObjectConIx : public CBase
  1899. #line 1264
  1900. {
  1901. public:
  1902. __declspec(dllexport) static CObjectConIx* NewL();
  1903. __declspec(dllexport) ~CObjectConIx();
  1904. __declspec(dllexport) CObjectCon* Lookup(TInt aFindHandle) const;
  1905. __declspec(dllexport) CObjectCon* CreateL();
  1906. __declspec(dllexport) void Remove(CObjectCon* aCon);
  1907. protected:
  1908. __declspec(dllexport) CObjectConIx();
  1909. __declspec(dllexport) void CreateContainerL(CObjectCon*& anObject);
  1910. private:
  1911. TInt iCount;
  1912. TInt iAllocated;
  1913. TInt iNextUniqueID;
  1914. CObjectCon** iContainers;
  1915. TAny* iSpare1;
  1916. TAny* iSpare2;
  1917. };
  1918. class CBitMapAllocator : public CBase
  1919. {
  1920. public:
  1921. __declspec(dllexport) static CBitMapAllocator* New(TInt aSize);
  1922. __declspec(dllexport) static CBitMapAllocator* NewL(TInt aSize);
  1923. __declspec(dllexport) ~CBitMapAllocator();
  1924. __declspec(dllexport) TInt Alloc();
  1925. __declspec(dllexport) TInt AllocFrom(TInt aPos);
  1926. __declspec(dllexport) TInt Alloc(TInt aCount, TInt& aConsecutive);
  1927. __declspec(dllexport) TInt AllocAligned(TInt anAlignment);
  1928. __declspec(dllexport) TInt AllocAlignedBlock(TInt anAlignment);
  1929. __declspec(dllexport) TInt AllocFromTop();
  1930. __declspec(dllexport) TInt AllocFromTopFrom(TInt aPos);
  1931. __declspec(dllexport) void AllocAt(TInt aPos);
  1932. __declspec(dllexport) void AllocAt(TInt aPos, TInt aCount);
  1933. __declspec(dllexport) TBool IsFree(TInt aPos);
  1934. __declspec(dllexport) TBool IsFree(TInt aPos, TInt aCount);
  1935. __declspec(dllexport) void Free(TInt aPos);
  1936. __declspec(dllexport) void Free(TInt aPos, TInt aCount);
  1937. __declspec(dllexport) TInt Avail();
  1938. __declspec(dllexport) TInt Size();
  1939. __declspec(dllexport) TInt ExtractRamPages(TInt aConsecutive,TInt& aPageNo);
  1940. protected:
  1941. __declspec(dllexport) CBitMapAllocator(TInt aSize,TInt aLength);
  1942. protected:
  1943. TInt iAvail;
  1944. TInt iSize;
  1945. TInt iLength;
  1946. TUint iMap[1];
  1947. };
  1948. class TCleanupStackItem;
  1949. #line 1334
  1950. typedef void (*TCleanupOperation)(TAny*);
  1951. class TCleanupItem
  1952. #line 1350
  1953. {
  1954. public:
  1955. inline TCleanupItem(TCleanupOperation anOperation);
  1956. inline TCleanupItem(TCleanupOperation anOperation,TAny* aPtr);
  1957. private:
  1958. TCleanupOperation iOperation;
  1959. TAny* iPtr;
  1960. friend class TCleanupStackItem;
  1961. };
  1962. class CCleanup : public CBase
  1963. #line 1373
  1964. {
  1965. public:
  1966. __declspec(dllexport) static CCleanup* New();
  1967. __declspec(dllexport) static CCleanup* NewL();
  1968. __declspec(dllexport) ~CCleanup();
  1969. __declspec(dllexport) void NextLevel();
  1970. __declspec(dllexport) void PreviousLevel();
  1971. __declspec(dllexport) void PushL(TAny* aPtr);
  1972. __declspec(dllexport) void PushL(CBase* anObject);
  1973. __declspec(dllexport) void PushL(TCleanupItem anItem);
  1974. __declspec(dllexport) void Pop();
  1975. __declspec(dllexport) void Pop(TInt aCount);
  1976. __declspec(dllexport) void PopAll();
  1977. __declspec(dllexport) void PopAndDestroy();
  1978. __declspec(dllexport) void PopAndDestroy(TInt aCount);
  1979. __declspec(dllexport) void PopAndDestroyAll();
  1980. __declspec(dllexport) void Check(TAny* aExpectedItem);
  1981. protected:
  1982. __declspec(dllexport) void DoPop(TInt aCount,TBool aDestroy);
  1983. __declspec(dllexport) void DoPopAll(TBool aDestroy);
  1984. protected:
  1985. __declspec(dllexport) CCleanup();
  1986. protected:
  1987. TCleanupStackItem* iBase;
  1988. TCleanupStackItem* iTop;
  1989. TCleanupStackItem* iNext;
  1990. };
  1991. class TCleanupTrapHandler : public TTrapHandler
  1992. #line 1427
  1993. {
  1994. public:
  1995. TCleanupTrapHandler();
  1996. virtual void Trap();
  1997. virtual void UnTrap();
  1998. virtual void Leave(TInt aValue);
  1999. inline CCleanup& Cleanup();
  2000. private:
  2001. CCleanup* iCleanup;
  2002. friend class CTrapCleanup;
  2003. };
  2004. template <class T>
  2005. class TAutoClose
  2006. #line 1454
  2007. {
  2008. public:
  2009. inline ~TAutoClose();
  2010. inline void PushL();
  2011. inline void Pop();
  2012. private:
  2013. static void Close(TAny *aObj);
  2014. public:
  2015. T iObj;
  2016. };
  2017. class CTrapCleanup : public CBase
  2018. #line 1481
  2019. {
  2020. public:
  2021. __declspec(dllexport) static CTrapCleanup* New();
  2022. __declspec(dllexport) ~CTrapCleanup();
  2023. protected:
  2024. __declspec(dllexport) CTrapCleanup();
  2025. private:
  2026. TCleanupTrapHandler iHandler;
  2027. TTrapHandler* iOldHandler;
  2028. };
  2029. class CCirBufBase : public CBase
  2030. #line 1507
  2031. {
  2032. public:
  2033. __declspec(dllexport) ~CCirBufBase();
  2034. inline TInt Count() const;
  2035. inline TInt Length() const;
  2036. __declspec(dllexport) void SetLengthL(TInt aLength);
  2037. __declspec(dllexport) void Reset();
  2038. protected:
  2039. __declspec(dllexport) CCirBufBase(TInt aSize);
  2040. __declspec(dllexport) TInt DoAdd(const TUint8* aPtr);
  2041. __declspec(dllexport) TInt DoAdd(const TUint8* aPtr,TInt aCount);
  2042. __declspec(dllexport) TInt DoRemove(TUint8* aPtr);
  2043. __declspec(dllexport) TInt DoRemove(TUint8* aPtr,TInt aCount);
  2044. protected:
  2045. TInt iCount;
  2046. TInt iSize;
  2047. TInt iLength;
  2048. TUint8* iPtr;
  2049. TUint8* iPtrE;
  2050. TUint8* iHead;
  2051. TUint8* iTail;
  2052. };
  2053. template <class T>
  2054. class CCirBuf : public CCirBufBase
  2055. {
  2056. public:
  2057. inline CCirBuf();
  2058. inline TInt Add(const T* aPtr);
  2059. inline TInt Add(const T* aPtr,TInt aCount);
  2060. inline TInt Remove(T* aPtr);
  2061. inline TInt Remove(T* aPtr,TInt aCount);
  2062. };
  2063. class CCirBuffer : public CCirBuf<TUint8>
  2064. #line 1566
  2065. {
  2066. public:
  2067. __declspec(dllexport) CCirBuffer();
  2068. __declspec(dllexport) ~CCirBuffer();
  2069. __declspec(dllexport) TInt Get();
  2070. __declspec(dllexport) TInt Put(TInt aVal);
  2071. };
  2072. class CActive : public CBase
  2073. #line 1588
  2074. {
  2075. public:
  2076. enum TPriority
  2077. {
  2078. EPriorityIdle=-100,
  2079. EPriorityLow=-20,
  2080. EPriorityStandard=0,
  2081. EPriorityUserInput=10,
  2082. EPriorityHigh=20,
  2083. };
  2084. public:
  2085. __declspec(dllexport) ~CActive();
  2086. __declspec(dllexport) void Cancel();
  2087. __declspec(dllexport) void Deque();
  2088. __declspec(dllexport) void SetPriority(TInt aPriority);
  2089. inline TBool IsActive() const;
  2090. inline TBool IsAdded() const;
  2091. inline TInt Priority() const;
  2092. protected:
  2093. __declspec(dllexport) CActive(TInt aPriority);
  2094. __declspec(dllexport) void SetActive();
  2095. #line 1653
  2096. virtual void DoCancel() =0;
  2097. #line 1687
  2098. virtual void RunL() =0;
  2099. __declspec(dllexport) virtual TInt RunError(TInt aError);
  2100. protected:
  2101. __declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
  2102. public:
  2103. #line 1704
  2104. TRequestStatus iStatus;
  2105. private:
  2106. TPriQueLink iLink;
  2107. TAny* iSpare;
  2108. friend class CActiveScheduler;
  2109. friend class CServer;
  2110. friend class CServer2;
  2111. };
  2112. class CIdle : public CActive
  2113. #line 1729
  2114. {
  2115. public:
  2116. __declspec(dllexport) static CIdle* New(TInt aPriority);
  2117. __declspec(dllexport) static CIdle* NewL(TInt aPriority);
  2118. __declspec(dllexport) ~CIdle();
  2119. __declspec(dllexport) void Start(TCallBack aCallBack);
  2120. protected:
  2121. __declspec(dllexport) CIdle(TInt aPriority);
  2122. __declspec(dllexport) void RunL();
  2123. __declspec(dllexport) void DoCancel();
  2124. protected:
  2125. TCallBack iCallBack;
  2126. };
  2127. class CAsyncOneShot : public CActive
  2128. #line 1782
  2129. {
  2130. public:
  2131. __declspec(dllexport) CAsyncOneShot(TInt aPriority);
  2132. __declspec(dllexport) virtual void DoCancel();
  2133. __declspec(dllexport) virtual void Call();
  2134. __declspec(dllexport) virtual ~CAsyncOneShot();
  2135. inline RThread& Thread();
  2136. private:
  2137. void Setup();
  2138. RThread iThread;
  2139. };
  2140. class CAsyncCallBack : public CAsyncOneShot
  2141. {
  2142. public:
  2143. __declspec(dllexport) CAsyncCallBack(TInt aPriority);
  2144. __declspec(dllexport) CAsyncCallBack(const TCallBack& aCallBack, TInt aPriority);
  2145. __declspec(dllexport) void Set(const TCallBack& aCallBack);
  2146. __declspec(dllexport) void CallBack();
  2147. __declspec(dllexport) virtual ~CAsyncCallBack();
  2148. protected:
  2149. virtual void RunL();
  2150. protected:
  2151. TCallBack iCallBack;
  2152. };
  2153. class TDeltaTimerEntry
  2154. #line 1838
  2155. {
  2156. friend class CDeltaTimer;
  2157. public:
  2158. inline TDeltaTimerEntry(TCallBack& aCallback);
  2159. inline TDeltaTimerEntry();
  2160. inline void Set(TCallBack& aCallback);
  2161. private:
  2162. TCallBack iCallBack;
  2163. TTickCountQueLink iLink;
  2164. };
  2165. class CDeltaTimer : public CActive
  2166. #line 1893
  2167. {
  2168. public:
  2169. __declspec(dllexport) virtual void Queue(TTimeIntervalMicroSeconds32 aTimeInMicroSeconds, TDeltaTimerEntry& aEntry);
  2170. __declspec(dllexport) virtual void Remove(TDeltaTimerEntry& aEntry);
  2171. __declspec(dllexport) TInt QueueLong(TTimeIntervalMicroSeconds aTimeInMicroSeconds, TDeltaTimerEntry& aEntry);
  2172. __declspec(dllexport) static CDeltaTimer* NewL(TInt aPriority);
  2173. __declspec(dllexport) static CDeltaTimer* NewL(TInt aPriority, TTimeIntervalMicroSeconds32 aGranularity);
  2174. ~CDeltaTimer();
  2175. private:
  2176. CDeltaTimer(TInt aPriority, TInt aTickPeriod);
  2177. void DoCancel();
  2178. void RunL();
  2179. void Activate(TBool aRequeueTimer = EFalse);
  2180. private:
  2181. RTimer iTimer;
  2182. TTickCountQue iQueue;
  2183. const TInt iTickPeriod;
  2184. TBool iQueueBusy;
  2185. };
  2186. class CTimer : public CActive
  2187. #line 1974
  2188. {
  2189. public:
  2190. __declspec(dllexport) ~CTimer();
  2191. __declspec(dllexport) void At(const TTime& aTime);
  2192. __declspec(dllexport) void AtUTC(const TTime& aTimeInUTC);
  2193. __declspec(dllexport) void After(TTimeIntervalMicroSeconds32 anInterval);
  2194. __declspec(dllexport) void Lock(TTimerLockSpec aLock);
  2195. __declspec(dllexport) void Inactivity(TTimeIntervalSeconds aSeconds);
  2196. __declspec(dllexport) void HighRes(TTimeIntervalMicroSeconds32 aInterval);
  2197. protected:
  2198. __declspec(dllexport) CTimer(TInt aPriority);
  2199. __declspec(dllexport) void ConstructL();
  2200. __declspec(dllexport) void DoCancel();
  2201. private:
  2202. RTimer iTimer;
  2203. };
  2204. class CPeriodic : public CTimer
  2205. #line 2035
  2206. {
  2207. public:
  2208. __declspec(dllexport) static CPeriodic* New(TInt aPriority);
  2209. __declspec(dllexport) static CPeriodic* NewL(TInt aPriority);
  2210. __declspec(dllexport) ~CPeriodic();
  2211. __declspec(dllexport) void Start(TTimeIntervalMicroSeconds32 aDelay,TTimeIntervalMicroSeconds32 anInterval,TCallBack aCallBack);
  2212. protected:
  2213. __declspec(dllexport) CPeriodic(TInt aPriority);
  2214. __declspec(dllexport) void RunL();
  2215. private:
  2216. TTimeIntervalMicroSeconds32 iInterval;
  2217. TCallBack iCallBack;
  2218. };
  2219. class MBeating
  2220. #line 2067
  2221. {
  2222. public:
  2223. virtual void Beat() =0;
  2224. #line 2084
  2225. virtual void Synchronize() =0;
  2226. };
  2227. class CHeartbeat : public CTimer
  2228. #line 2131
  2229. {
  2230. public:
  2231. __declspec(dllexport) static CHeartbeat* New(TInt aPriority);
  2232. __declspec(dllexport) static CHeartbeat* NewL(TInt aPriority);
  2233. __declspec(dllexport) ~CHeartbeat();
  2234. __declspec(dllexport) void Start(TTimerLockSpec aLock,MBeating *aBeating);
  2235. protected:
  2236. __declspec(dllexport) CHeartbeat(TInt aPriority);
  2237. __declspec(dllexport) void RunL();
  2238. private:
  2239. TTimerLockSpec iLock;
  2240. MBeating *iBeating;
  2241. };
  2242. class CServer2;
  2243. #line 2170
  2244. class CSession2 : public CBase
  2245. {
  2246. friend class CServer2;
  2247. public:
  2248. __declspec(dllexport) virtual ~CSession2() =0;
  2249. private:
  2250. __declspec(dllexport) virtual void CreateL();
  2251. public:
  2252. inline const CServer2* Server() const;
  2253. __declspec(dllexport) void ResourceCountMarkStart();
  2254. __declspec(dllexport) void ResourceCountMarkEnd(const RMessage2& aMessage);
  2255. __declspec(dllexport) virtual TInt CountResources();
  2256. #line 2192
  2257. virtual void ServiceL(const RMessage2& aMessage) =0;
  2258. __declspec(dllexport) virtual void ServiceError(const RMessage2& aMessage,TInt aError);
  2259. protected:
  2260. __declspec(dllexport) CSession2();
  2261. __declspec(dllexport) virtual void Disconnect(const RMessage2& aMessage);
  2262. __declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
  2263. public:
  2264. enum TPanicNo {ESesCountResourcesNotImplemented=1,ESesFoundResCountHeaven};
  2265. private:
  2266. TInt iResourceCountMark;
  2267. TDblQueLink iLink;
  2268. const CServer2* iServer;
  2269. TAny* iSpare;
  2270. };
  2271. #line 2224
  2272. class CServer2 : public CActive
  2273. {
  2274. public:
  2275. enum TServerType
  2276. {
  2277. EUnsharableSessions = EIpcSession_Unsharable,
  2278. ESharableSessions = EIpcSession_Sharable,
  2279. EGlobalSharableSessions = EIpcSession_GlobalSharable,
  2280. };
  2281. public:
  2282. __declspec(dllexport) virtual ~CServer2() =0;
  2283. __declspec(dllexport) TInt Start(const TDesC& aName);
  2284. __declspec(dllexport) void StartL(const TDesC& aName);
  2285. __declspec(dllexport) void ReStart();
  2286. #line 2264
  2287. inline RServer2 Server() const { return iServer; }
  2288. protected:
  2289. inline const RMessage2& Message() const;
  2290. __declspec(dllexport) CServer2(TInt aPriority, TServerType aType=EUnsharableSessions);
  2291. __declspec(dllexport) void DoCancel();
  2292. __declspec(dllexport) void RunL();
  2293. __declspec(dllexport) TInt RunError(TInt aError);
  2294. __declspec(dllexport) virtual void DoConnect(const RMessage2& aMessage);
  2295. __declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
  2296. private:
  2297. #line 2298
  2298. __declspec(dllexport) virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const =0;
  2299. void Connect(const RMessage2& aMessage);
  2300. void DoConnectL(const RMessage2& aMessage,CSession2* volatile& aSession);
  2301. public:
  2302. enum TPanic
  2303. {
  2304. EBadMessageNumber,
  2305. ESessionNotConnected,
  2306. ESessionAlreadyConnected,
  2307. EClientDoesntHaveRequiredCaps,
  2308. };
  2309. private:
  2310. TInt iSessionType;
  2311. RServer2 iServer;
  2312. RMessage2 iMessage;
  2313. TAny* iSpare;
  2314. TDblQue<CSession2> iSessionQ;
  2315. protected:
  2316. TDblQueIter<CSession2> iSessionIter;
  2317. private:
  2318. void Disconnect(const RMessage2& aMessage);
  2319. static void BadMessage(const RMessage2& aMessage);
  2320. static void NotConnected(const RMessage2& aMessage);
  2321. friend class CPolicyServer;
  2322. };
  2323. #line 2405
  2324. class CPolicyServer : public CServer2
  2325. {
  2326. public:
  2327. enum TFailureAction
  2328. {
  2329. EFailClient = 0,
  2330. EPanicClient= 1,
  2331. };
  2332. #line 2428
  2333. enum TCustomResult
  2334. {
  2335. EPass = 0,
  2336. EFail = 1,
  2337. EAsync = 2,
  2338. };
  2339. #line 2442
  2340. class TPolicyElement
  2341. {
  2342. public:
  2343. #line 2475
  2344. TStaticSecurityPolicy   iPolicy;
  2345. TInt iAction;
  2346. };
  2347. enum TSpecialCase
  2348. {
  2349. ECustomCheck  =255u,
  2350. ENotSupported =254u,
  2351. EAlwaysPass =253u,
  2352. ESpecialCaseLimit  =252u,
  2353. ESpecialCaseHardLimit =250u
  2354. };
  2355. #line 2548
  2356. class TPolicy
  2357. {
  2358. public:
  2359. TUint8 iOnConnect;
  2360. TUint16 iRangeCount;
  2361. #line 2578
  2362. const TInt* iRanges;
  2363. #line 2616
  2364. const TUint8* iElementsIndex;
  2365. #line 2645
  2366. const TPolicyElement* iElements;
  2367. };
  2368. public:
  2369. #line 2663
  2370. __declspec(dllexport) void ProcessL(const RMessage2& aMsg);
  2371. #line 2681
  2372. __declspec(dllexport) void CheckFailedL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);
  2373. #line 2696
  2374. __declspec(dllexport) void ProcessError(const RMessage2& aMsg, TInt aError);
  2375. protected:
  2376. #line 2709
  2377. __declspec(dllexport) CPolicyServer(TInt aPriority, const TPolicy& aPolicy, TServerType aType=EUnsharableSessions);
  2378. #line 2759
  2379. __declspec(dllexport) virtual TCustomResult CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction, TSecurityInfo& aMissing);
  2380. #line 2810
  2381. __declspec(dllexport) virtual TCustomResult CustomFailureActionL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);
  2382. protected:
  2383. __declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
  2384. private:
  2385. __declspec(dllexport) virtual void RunL();
  2386. __declspec(dllexport) virtual TInt RunError(TInt aError);
  2387. const CPolicyServer::TPolicyElement* FindPolicyElement(TInt aFn, TUint& aSpecialCase) const;
  2388. private:
  2389. const TPolicy& iPolicy;
  2390. };
  2391. class CActiveScheduler : public CBase
  2392. #line 2853
  2393. {
  2394. friend class CActiveSchedulerWait;
  2395. public:
  2396. struct TLoop;
  2397. typedef TLoop* TLoopOwner;
  2398. public:
  2399. __declspec(dllexport) CActiveScheduler();
  2400. __declspec(dllexport) ~CActiveScheduler();
  2401. __declspec(dllexport) static void Install(CActiveScheduler* aScheduler);
  2402. __declspec(dllexport) static CActiveScheduler* Current();
  2403. __declspec(dllexport) static void Add(CActive* aActive);
  2404. __declspec(dllexport) static void Start();
  2405. __declspec(dllexport) static void Stop();
  2406. __declspec(dllexport) static TBool RunIfReady(TInt& aError, TInt aMinimumPriority);
  2407. __declspec(dllexport) static CActiveScheduler* Replace(CActiveScheduler* aNewActiveScheduler);
  2408. __declspec(dllexport) virtual void WaitForAnyRequest();
  2409. __declspec(dllexport) virtual void Error(TInt aError) const;
  2410. __declspec(dllexport) void Halt(TInt aExitCode) const;
  2411. __declspec(dllexport) TInt StackDepth() const;
  2412. private:
  2413. static void Start(TLoopOwner* aOwner);
  2414. __declspec(dllexport) virtual void OnStarting();
  2415. __declspec(dllexport) virtual void OnStopping();
  2416. __declspec(dllexport) virtual void Reserved_1();
  2417. __declspec(dllexport) virtual void Reserved_2();
  2418. void Run(TLoopOwner* const volatile& aLoop);
  2419. void DoRunL(TLoopOwner* const volatile& aLoop, CActive* volatile & aCurrentObj);
  2420. protected:
  2421. __declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
  2422. protected:
  2423. inline TInt Level() const;
  2424. private:
  2425. TLoop* iStack;
  2426. TPriQue<CActive> iActiveQ;
  2427. TAny* iSpare;
  2428. };
  2429. class CActiveSchedulerWait : public CBase
  2430. #line 2908
  2431. {
  2432. public:
  2433. __declspec(dllexport) CActiveSchedulerWait();
  2434. __declspec(dllexport) ~CActiveSchedulerWait();
  2435. __declspec(dllexport) void Start();
  2436. __declspec(dllexport) void AsyncStop();
  2437. __declspec(dllexport) void AsyncStop(const TCallBack& aCallMeWhenStopped);
  2438. inline TBool IsStarted() const;
  2439. __declspec(dllexport) TBool CanStopNow() const;
  2440. private:
  2441. CActiveScheduler::TLoopOwner iLoop;
  2442. };
  2443. class CleanupStack
  2444. {
  2445. public:
  2446. __declspec(dllexport) static void PushL(TAny* aPtr);
  2447. __declspec(dllexport) static void PushL(CBase* aPtr);
  2448. __declspec(dllexport) static void PushL(TCleanupItem anItem);
  2449. __declspec(dllexport) static void Pop();
  2450. __declspec(dllexport) static void Pop(TInt aCount);
  2451. __declspec(dllexport) static void PopAndDestroy();
  2452. __declspec(dllexport) static void PopAndDestroy(TInt aCount);
  2453. __declspec(dllexport) static void Check(TAny* aExpectedItem);
  2454. inline static void Pop(TAny* aExpectedItem);
  2455. inline static void Pop(TInt aCount, TAny* aLastExpectedItem);
  2456. inline static void PopAndDestroy(TAny* aExpectedItem);
  2457. inline static void PopAndDestroy(TInt aCount, TAny* aLastExpectedItem);
  2458. };
  2459. #line 2961
  2460. template <class T>
  2461. class CleanupDelete
  2462. {
  2463. public:
  2464. inline static void PushL(T* aPtr);
  2465. private:
  2466. static void Delete(TAny *aPtr);
  2467. };
  2468. #line 3009
  2469. template <class T>
  2470. inline void CleanupDeletePushL(T* aPtr);
  2471. #line 3025
  2472. template <class T>
  2473. class CleanupArrayDelete
  2474. {
  2475. public:
  2476. inline static void PushL(T* aPtr);
  2477. private:
  2478. static void ArrayDelete(TAny *aPtr);
  2479. };
  2480. #line 3075
  2481. template <class T>
  2482. inline void CleanupArrayDeletePushL(T* aPtr);
  2483. #line 3091
  2484. template <class T>
  2485. class CleanupClose
  2486. {
  2487. public:
  2488. inline static void PushL(T& aRef);
  2489. private:
  2490. static void Close(TAny *aPtr);
  2491. };
  2492. #line 3153
  2493. template <class T>
  2494. inline void CleanupClosePushL(T& aRef);
  2495. #line 3169
  2496. template <class T>
  2497. class CleanupRelease
  2498. {
  2499. public:
  2500. inline static void PushL(T& aRef);
  2501. private:
  2502. static void Release(TAny *aPtr);
  2503. };
  2504. #line 3227
  2505. template <class T>
  2506. inline void CleanupReleasePushL(T& aRef);
  2507. class CConsoleBase;
  2508. class Console
  2509. {
  2510. public:
  2511. __declspec(dllexport) static CConsoleBase* NewL(const TDesC& aTitle,TSize aSize);
  2512. };
  2513. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.inl" /* stack depth 7 */
  2514. inline TAny* CBase::operator new(TUint aSize, TAny* aBase) throw()
  2515. #line 19
  2516. { Mem::FillZ(aBase, aSize); return aBase; }
  2517. inline TAny* CBase::operator new(TUint aSize) throw()
  2518. #line 36
  2519. { return User::AllocZ(aSize); }
  2520. inline TAny* CBase::operator new(TUint aSize, TLeave)
  2521. #line 53
  2522. { return User::AllocZL(aSize); }
  2523. inline TAny* CBase::operator new(TUint aSize, TUint aExtraSize) throw()
  2524. #line 74
  2525. { return User::AllocZ(aSize + aExtraSize); }
  2526. inline TAny* CBase::operator new(TUint aSize, TLeave, TUint aExtraSize)
  2527. #line 95
  2528. { return User::AllocZL(aSize + aExtraSize); }
  2529. inline TInt CBufBase::Size() const
  2530. #line 111
  2531. {return(iSize);}
  2532. inline TInt CBufFlat::Capacity() const
  2533. {return(iMaxSize);}
  2534. inline TInt CArrayFixBase::Count() const
  2535. {return(iCount);}
  2536. inline TInt CArrayFixBase::Length() const
  2537. {return(iLength);}
  2538. template <class T>
  2539. inline CArrayFix<T>::CArrayFix(TBufRep aRep,TInt aGranularity)
  2540. : CArrayFixBase(aRep,sizeof(T),aGranularity)
  2541. {}
  2542. template <class T>
  2543. inline const T &CArrayFix<T>::operator[](TInt anIndex) const
  2544. #line 183
  2545. {return(*((const T *)CArrayFixBase::At(anIndex)));}
  2546. template <class T>
  2547. inline T &CArrayFix<T>::operator[](TInt anIndex)
  2548. #line 207
  2549. {return(*((T *)CArrayFixBase::At(anIndex)));}
  2550. template <class T>
  2551. inline const T &CArrayFix<T>::At(TInt anIndex) const
  2552. #line 231
  2553. {return(*((const T *)CArrayFixBase::At(anIndex)));}
  2554. template <class T>
  2555. inline const T *CArrayFix<T>::End(TInt anIndex) const
  2556. #line 259
  2557. {return((const T *)CArrayFixBase::End(anIndex));}
  2558. template <class T>
  2559. inline const T *CArrayFix<T>::Back(TInt anIndex) const
  2560. #line 288
  2561. {return((const T *)CArrayFixBase::Back(anIndex));}
  2562. template <class T>
  2563. inline T &CArrayFix<T>::At(TInt anIndex)
  2564. #line 312
  2565. {return(*((T *)CArrayFixBase::At(anIndex)));}
  2566. template <class T>
  2567. inline T *CArrayFix<T>::End(TInt anIndex)
  2568. #line 338
  2569. {return(((T *)CArrayFixBase::End(anIndex)));}
  2570. template <class T>
  2571. inline T *CArrayFix<T>::Back(TInt anIndex)
  2572. #line 367
  2573. {return(((T *)CArrayFixBase::Back(anIndex)));}
  2574. template <class T>
  2575. inline void CArrayFix<T>::AppendL(const T &aRef)
  2576. #line 383
  2577. {CArrayFixBase::InsertL(Count(),&aRef);}
  2578. template <class T>
  2579. inline void CArrayFix<T>::AppendL(const T *aPtr,TInt aCount)
  2580. #line 404
  2581. {CArrayFixBase::InsertL(Count(),aPtr,aCount);}
  2582. template <class T>
  2583. inline void CArrayFix<T>::AppendL(const T &aRef,TInt aReplicas)
  2584. #line 423
  2585. {CArrayFixBase::InsertRepL(Count(),&aRef,aReplicas);}
  2586. template <class T>
  2587. inline T &CArrayFix<T>::ExpandL(TInt anIndex)
  2588. #line 461
  2589. {return(*new(CArrayFixBase::ExpandL(anIndex)) T);}
  2590. template <class T>
  2591. inline T &CArrayFix<T>::ExtendL()
  2592. #line 492
  2593. {return(*new(CArrayFixBase::ExpandL(Count())) T);}
  2594. template <class T>
  2595. inline TInt CArrayFix<T>::Find(const T &aRef,TKeyArrayFix &aKey,TInt &anIndex) const
  2596. #line 525
  2597. {return(CArrayFixBase::Find(&aRef,aKey,anIndex));}
  2598. template <class T>
  2599. inline TInt CArrayFix<T>::FindIsq(const T &aRef,TKeyArrayFix &aKey,TInt &anIndex) const
  2600. #line 562
  2601. {return(CArrayFixBase::FindIsq(&aRef,aKey,anIndex));}
  2602. template <class T>
  2603. inline void CArrayFix<T>::InsertL(TInt anIndex,const T &aRef)
  2604. #line 589
  2605. {CArrayFixBase::InsertL(anIndex,&aRef);}
  2606. template <class T>
  2607. inline void CArrayFix<T>::InsertL(TInt anIndex,const T *aPtr,TInt aCount)
  2608. #line 622
  2609. {CArrayFixBase::InsertL(anIndex,aPtr,aCount);}
  2610. template <class T>
  2611. inline void CArrayFix<T>::InsertL(TInt anIndex,const T &aRef,TInt aReplicas)
  2612. #line 655
  2613. {CArrayFixBase::InsertRepL(anIndex,&aRef,aReplicas);}
  2614. template <class T>
  2615. inline TInt CArrayFix<T>::InsertIsqL(const T &aRef,TKeyArrayFix &aKey)
  2616. #line 684
  2617. {return(CArrayFixBase::InsertIsqL(&aRef,aKey));}
  2618. template <class T>
  2619. inline TInt CArrayFix<T>::InsertIsqAllowDuplicatesL(const T &aRef,TKeyArrayFix &aKey)
  2620. #line 711
  2621. {return(CArrayFixBase::InsertIsqAllowDuplicatesL(&aRef,aKey));}
  2622. template <class T>
  2623. inline void CArrayFix<T>::ResizeL(TInt aCount)
  2624. #line 746
  2625. {TUint8 b[sizeof(T)]; new(&b[0]) T; CArrayFixBase::ResizeL(aCount,&b[0]);}
  2626. template <class T>
  2627. inline void CArrayFix<T>::ResizeL(TInt aCount,const T &aRef)
  2628. #line 783
  2629. {CArrayFixBase::ResizeL(aCount,&aRef);}
  2630. template <class T>
  2631. inline const TArray<T> CArrayFix<T>::Array() const
  2632. {return(TArray<T>(CountR,AtR,this));}
  2633. inline CArrayFix<TAny>::CArrayFix(TBufRep aRep,TInt aRecordLength,TInt aGranularity)
  2634. : CArrayFixBase(aRep,aRecordLength,aGranularity)
  2635. {}
  2636. inline const TAny *CArrayFix<TAny>::At(TInt anIndex) const
  2637. #line 825
  2638. {return(CArrayFixBase::At(anIndex));}
  2639. inline const TAny *CArrayFix<TAny>::End(TInt anIndex) const
  2640. #line 850
  2641. {return(CArrayFixBase::End(anIndex));}
  2642. inline const TAny *CArrayFix<TAny>::Back(TInt anIndex) const
  2643. #line 877
  2644. {return(CArrayFixBase::Back(anIndex));}
  2645. inline TAny *CArrayFix<TAny>::At(TInt anIndex)
  2646. #line 897
  2647. {return(CArrayFixBase::At(anIndex));}
  2648. inline TAny *CArrayFix<TAny>::End(TInt anIndex)
  2649. #line 922
  2650. {return(CArrayFixBase::End(anIndex));}
  2651. inline TAny *CArrayFix<TAny>::Back(TInt anIndex)
  2652. #line 949
  2653. {return(CArrayFixBase::Back(anIndex));}
  2654. inline void CArrayFix<TAny>::AppendL(const TAny *aPtr)
  2655. #line 964
  2656. {CArrayFixBase::InsertL(Count(),aPtr);}
  2657. inline void CArrayFix<TAny>::AppendL(const TAny *aPtr,TInt aCount)
  2658. #line 982
  2659. {CArrayFixBase::InsertL(Count(),aPtr,aCount);}
  2660. inline TAny *CArrayFix<TAny>::ExtendL()
  2661. #line 1001
  2662. {return(CArrayFixBase::ExpandL(Count()));}
  2663. template <class T>
  2664. inline CArrayFixFlat<T>::CArrayFixFlat(TInt aGranularity)
  2665. : CArrayFix<T>((TBufRep)CBufFlat::NewL,aGranularity)
  2666. #line 1024
  2667. {}
  2668. template <class T>
  2669. inline void CArrayFixFlat<T>::SetReserveL(TInt aCount)
  2670. #line 1050
  2671. {this->SetReserveFlatL(aCount);}
  2672. inline CArrayFixFlat<TAny>::CArrayFixFlat(TInt aRecordLength,TInt aGranularity)
  2673. : CArrayFix<TAny>((TBufRep)CBufFlat::NewL,aRecordLength,aGranularity)
  2674. #line 1069
  2675. {}
  2676. inline void CArrayFixFlat<TAny>::SetReserveL(TInt aCount)
  2677. #line 1094
  2678. {SetReserveFlatL(aCount);}
  2679. inline void CArrayFixFlat<TInt>::SetReserveL(TInt aCount)
  2680. #line 1119
  2681. {SetReserveFlatL(aCount);}
  2682. inline void CArrayFixFlat<TUid>::SetReserveL(TInt aCount)
  2683. #line 1144
  2684. {SetReserveFlatL(aCount);}
  2685. template <class T>
  2686. inline CArrayFixSeg<T>::CArrayFixSeg(TInt aGranularity)
  2687. : CArrayFix<T>((TBufRep)CBufSeg::NewL,aGranularity)
  2688. #line 1168
  2689. {}
  2690. inline CArrayFixSeg<TAny>::CArrayFixSeg(TInt aRecordLength,TInt aGranularity)
  2691. : CArrayFix<TAny>((TBufRep)CBufSeg::NewL,aRecordLength,aGranularity)
  2692. #line 1188
  2693. {}
  2694. template <class T>
  2695. inline CArrayPtr<T>::CArrayPtr(TBufRep aRep,TInt aGranularity)
  2696. : CArrayFix<T*>(aRep,aGranularity)
  2697. {}
  2698. template <class T>
  2699. void CArrayPtr<T>::ResetAndDestroy()
  2700. #line 1221
  2701. {
  2702. for (TInt i=0;i<this->Count();++i)
  2703. delete this->At(i);
  2704. this->Reset();
  2705. }
  2706. template <class T>
  2707. inline CArrayPtrFlat<T>::CArrayPtrFlat(TInt aGranularity)
  2708. : CArrayPtr<T>((TBufRep)CBufFlat::NewL,aGranularity)
  2709. #line 1243
  2710. {}
  2711. template <class T>
  2712. inline void CArrayPtrFlat<T>::SetReserveL(TInt aCount)
  2713. #line 1269
  2714. {this->SetReserveFlatL(aCount);}
  2715. template <class T>
  2716. inline CArrayPtrSeg<T>::CArrayPtrSeg(TInt aGranularity)
  2717. : CArrayPtr<T>((TBufRep)CBufSeg::NewL,aGranularity)
  2718. #line 1287
  2719. {}
  2720. inline TInt CArrayVarBase::Count() const
  2721. {return(iCount);}
  2722. template <class T>
  2723. inline CArrayVar<T>::CArrayVar(TBufRep aRep,TInt aGranularity)
  2724. : CArrayVarBase(aRep,aGranularity)
  2725. {}
  2726. template <class T>
  2727. inline const T &CArrayVar<T>::operator[](TInt anIndex) const
  2728. #line 1334
  2729. {return(*((const T *)CArrayVarBase::At(anIndex)));}
  2730. template <class T>
  2731. inline T &CArrayVar<T>::operator[](TInt anIndex)
  2732. #line 1358
  2733. {return(*((T *)CArrayVarBase::At(anIndex)));}
  2734. template <class T>
  2735. inline const T &CArrayVar<T>::At(TInt anIndex) const
  2736. #line 1381
  2737. {return(*((const T *)CArrayVarBase::At(anIndex)));}
  2738. template <class T>
  2739. inline T &CArrayVar<T>::At(TInt anIndex)
  2740. #line 1403
  2741. {return(*((T *)CArrayVarBase::At(anIndex)));}
  2742. template <class T>
  2743. inline void CArrayVar<T>::AppendL(const T &aRef,TInt aLength)
  2744. #line 1423
  2745. {CArrayVarBase::InsertL(Count(),&aRef,aLength);}
  2746. template <class T>
  2747. inline T &CArrayVar<T>::ExpandL(TInt anIndex,TInt aLength)
  2748. #line 1465
  2749. {return(*new(CArrayVarBase::ExpandL(anIndex,aLength)) T);}
  2750. template <class T>
  2751. inline T &CArrayVar<T>::ExtendL(TInt aLength)
  2752. #line 1499
  2753. {return(*new(CArrayVarBase::ExpandL(Count(),aLength)) T);}
  2754. template <class T>
  2755. inline TInt CArrayVar<T>::Find(const T &aRef,TKeyArrayVar &aKey,TInt &anIndex) const
  2756. #line 1529
  2757. {return(CArrayVarBase::Find(&aRef,aKey,anIndex));}
  2758. template <class T>
  2759. inline TInt CArrayVar<T>::FindIsq(const T &aRef,TKeyArrayVar &aKey,TInt &anIndex) const
  2760. #line 1565
  2761. {return(CArrayVarBase::FindIsq(&aRef,aKey,anIndex));}