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

Symbian

开发平台:

C/C++

  1. __declspec(dllexport) TWin32SEHTrap();
  2. public:
  3. __declspec(dllexport) void Trap();
  4. __declspec(dllexport) void UnTrap();
  5. private:
  6. static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  7.     TWin32SEHTrap* iPrevExceptionRegistrationRecord;
  8. TWin32SEHExceptionHandler* iExceptionHandler;
  9. private:
  10. TUint32 iPadding[254];
  11. };
  12. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.inl" /* stack depth 4 */
  13. #line 9
  14. inline TAny* operator new(TUint , TAny* aBase) throw()
  15. {return aBase;}
  16. inline void operator delete(TAny* , TAny* ) throw()
  17. {}
  18. inline TAny* operator new[](TUint , TAny* aBase) throw()
  19. {return aBase;}
  20. inline void operator delete[](TAny* , TAny* ) throw()
  21. {}
  22. inline RAllocator::RAllocator()
  23. {
  24. iAccessCount=1;
  25. iHandleCount=0;
  26. iHandles=0;
  27. iFlags=0;
  28. iCellCount=0;
  29. iTotalAllocSize=0;
  30. }
  31. inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)
  32. {__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}
  33. inline RHeap::RHeap()
  34. {}
  35. inline TInt RHeap::MaxLength() const
  36. {return iMaxLength;}
  37. inline void RHeap::operator delete(TAny*, TAny*)
  38. {}
  39. inline TUint8* RHeap::Base() const
  40. #line 73
  41. {return iBase;}
  42. inline TInt RHeap::Size() const
  43. #line 89
  44. {return iTop-iBase;}
  45. inline TInt RHeap::Align(TInt a) const
  46. {return (((a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  47. inline const TAny* RHeap::Align(const TAny* a) const
  48. {return (const TAny*)((((TLinAddr)a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  49. inline TBool RHeap::IsLastCell(const SCell* aCell) const
  50. {return (((TUint8*)aCell) + aCell->len) == iTop;}
  51. inline void RHeap::Lock() const
  52. {((RFastLock&)iLock).Wait();}
  53. inline void RHeap::Unlock() const
  54. {((RFastLock&)iLock).Signal();}
  55. template <class T>
  56. inline TRefByValue<T>::TRefByValue(T &aRef)
  57. : iRef(aRef)
  58. {}
  59. template <class T>
  60. inline TRefByValue<T>::operator T &()
  61. {return(iRef);}
  62. #line 201
  63. inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)
  64. { return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }
  65. inline TChar::TChar()
  66. {}
  67. inline TChar::TChar(TUint aChar)
  68. : iChar(aChar)
  69. {}
  70. inline TChar& TChar::operator-=(TUint aChar)
  71. #line 241
  72. {iChar-=aChar;return(*this);}
  73. inline TChar& TChar::operator+=(TUint aChar)
  74. #line 256
  75. {iChar+=aChar;return(*this);}
  76. inline TChar TChar::operator-(TUint aChar)
  77. #line 273
  78. {return(iChar-aChar);}
  79. inline TChar TChar::operator+(TUint aChar)
  80. #line 288
  81. {return(iChar+aChar);}
  82. inline TChar::operator TUint() const
  83. {return(iChar);}
  84. inline TBool TDesC8::operator<(const TDesC8 &aDes) const
  85. #line 320
  86. {return(Compare(aDes)<0);}
  87. inline TBool TDesC8::operator<=(const TDesC8 &aDes) const
  88. #line 339
  89. {return(Compare(aDes)<=0);}
  90. inline TBool TDesC8::operator>(const TDesC8 &aDes) const
  91. #line 358
  92. {return(Compare(aDes)>0);}
  93. inline TBool TDesC8::operator>=(const TDesC8 &aDes) const
  94. #line 377
  95. {return(Compare(aDes)>=0);}
  96. inline TBool TDesC8::operator==(const TDesC8 &aDes) const
  97. #line 396
  98. {return(Compare(aDes)==0);}
  99. inline TBool TDesC8::operator!=(const TDesC8 &aDes) const
  100. #line 415
  101. {return(Compare(aDes)!=0);}
  102. inline const TUint8 &TDesC8::operator[](TInt anIndex) const
  103. #line 433
  104. {return(AtC(anIndex));}
  105. inline TInt TDesC8::Length() const
  106. {return(iLength&KMaskDesLength8);}
  107. inline TInt TDesC8::Size() const
  108. {return(Length());}
  109. inline void TDesC8::DoSetLength(TInt aLength)
  110. {iLength=(iLength&(~KMaskDesLength8))|aLength;}
  111. inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)
  112. #line 483
  113. {new(this) TPtrC8(aBuf,aLength);}
  114. inline void TPtrC8::Set(const TDesC8 &aDes)
  115. {new(this) TPtrC8(aDes);}
  116. inline void TPtrC8::Set(const TPtrC8& aPtr)
  117. #line 510
  118. {new(this) TPtrC8(aPtr);}
  119. inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)
  120. {return TPtr8(*this,aMaxLength);}
  121. template <TInt S>
  122. inline TBufC8<S>::TBufC8()
  123. : TBufCBase8()
  124. #line 540
  125. {}
  126. template <TInt S>
  127. inline TBufC8<S>::TBufC8(const TUint8 *aString)
  128. : TBufCBase8(aString,S)
  129. #line 564
  130. {}
  131. template <TInt S>
  132. inline TBufC8<S>::TBufC8(const TDesC8 &aDes)
  133. : TBufCBase8(aDes,S)
  134. #line 588
  135. {}
  136. template <TInt S>
  137. inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)
  138. #line 607
  139. {Copy(aString,S);return(*this);}
  140. template <TInt S>
  141. inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)
  142. #line 626
  143. {Copy(aDes,S);return(*this);}
  144. template <TInt S>
  145. inline TPtr8 TBufC8<S>::Des()
  146. #line 656
  147. {return DoDes(S);}
  148. inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)
  149. #line 681
  150. {return *this=static_cast<const TDesC8&>(aLcb);}
  151. #line 710
  152. inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)
  153. {
  154. Assign(HBufC8::NewL(aStream,aMaxLength));
  155. }
  156. inline TDes8 &TDes8::operator=(const TUint8 *aString)
  157. #line 733
  158.     {Copy(aString);return(*this);}
  159. inline TDes8 &TDes8::operator=(const TDesC8 &aDes)
  160. #line 751
  161.     {Copy(aDes);return(*this);}
  162. inline TDes8 &TDes8::operator=(const TDes8 &aDes)
  163. #line 769
  164.     {Copy(aDes);return(*this);}
  165. inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)
  166. #line 788
  167. {Append(aDes);return(*this);}
  168. inline const TUint8 &TDes8::operator[](TInt anIndex) const
  169. #line 806
  170. {return(AtC(anIndex));}
  171. inline TUint8 &TDes8::operator[](TInt anIndex)
  172. #line 825
  173. {return((TUint8 &)AtC(anIndex));}
  174. inline TInt TDes8::MaxLength() const
  175. #line 839
  176. {return(iMaxLength);}
  177. inline TInt TDes8::MaxSize() const
  178. #line 853
  179. {return(iMaxLength);}
  180. inline TUint8 * TDes8::WPtr() const
  181. {return((TUint8 *)Ptr());}
  182. inline TPtr8 &TPtr8::operator=(const TUint8 *aString)
  183. #line 879
  184. {Copy(aString);return(*this);}
  185. inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)
  186. #line 899
  187. {Copy(aDes);return(*this);}
  188. inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)
  189. #line 919
  190. {Copy(aDes);return(*this);}
  191. inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)
  192. #line 940
  193. {new(this) TPtr8(aBuf,aLength,aMaxLength);}
  194. inline void TPtr8::Set(const TPtr8 &aPtr)
  195. #line 955
  196. {new(this) TPtr8(aPtr);}
  197. template <TInt S>
  198. inline TBuf8<S>::TBuf8()
  199. : TBufBase8(S)
  200. #line 972
  201. {}
  202. template <TInt S>
  203. inline TBuf8<S>::TBuf8(TInt aLength)
  204. : TBufBase8(aLength,S)
  205. #line 994
  206. {}
  207. template <TInt S>
  208. inline TBuf8<S>::TBuf8(const TUint8 *aString)
  209. : TBufBase8(aString,S)
  210. #line 1018
  211. {}
  212. template <TInt S>
  213. inline TBuf8<S>::TBuf8(const TDesC8 &aDes)
  214. : TBufBase8(aDes,S)
  215. #line 1042
  216. {}
  217. template <TInt S>
  218. inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)
  219. #line 1062
  220. {Copy(aString);return(*this);}
  221. template <TInt S>
  222. inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)
  223. #line 1082
  224. {Copy(aDes);return(*this);}
  225. template <TInt S>
  226. inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)
  227. #line 1100
  228. {Copy(aBuf);return *this;}
  229. template <TInt S>
  230. inline TAlignedBuf8<S>::TAlignedBuf8()
  231. : TBufBase8(S)
  232. #line 1117
  233. {}
  234. template <TInt S>
  235. inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)
  236. : TBufBase8(aLength,S)
  237. #line 1139
  238. {}
  239. template <TInt S>
  240. inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)
  241. : TBufBase8(aString,S)
  242. #line 1163
  243. {}
  244. template <TInt S>
  245. inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)
  246. : TBufBase8(aDes,S)
  247. #line 1187
  248. {}
  249. template <TInt S>
  250. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)
  251. #line 1207
  252. {Copy(aString);return(*this);}
  253. template <TInt S>
  254. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)
  255. #line 1227
  256. {Copy(aDes);return(*this);}
  257. template <TInt S>
  258. inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)
  259. #line 1245
  260. {Copy(aBuf);return *this;}
  261. template <TInt S>
  262. inline const TDesC8* TLitC8<S>::operator&() const
  263. {return (reinterpret_cast<const TDesC8*>(this)) ;}
  264. template <TInt S>
  265. inline const TDesC8& TLitC8<S>::operator()() const
  266. {return *operator&();}
  267. template <TInt S>
  268. inline TLitC8<S>::operator const TDesC8&() const
  269. {return *operator&();}
  270. template <TInt S>
  271. inline TLitC8<S>::operator const __TRefDesC8() const
  272. {return *operator&();}
  273. inline TBool TDesC16::operator<(const TDesC16 &aDes) const
  274. #line 1314
  275. {return(Compare(aDes)<0);}
  276. inline TBool TDesC16::operator<=(const TDesC16 &aDes) const
  277. #line 1333
  278. {return(Compare(aDes)<=0);}
  279. inline TBool TDesC16::operator>(const TDesC16 &aDes) const
  280. #line 1352
  281. {return(Compare(aDes)>0);}
  282. inline TBool TDesC16::operator>=(const TDesC16 &aDes) const
  283. #line 1371
  284. {return(Compare(aDes)>=0);}
  285. inline TBool TDesC16::operator==(const TDesC16 &aDes) const
  286. #line 1390
  287. {return(Compare(aDes)==0);}
  288. inline TBool TDesC16::operator!=(const TDesC16 &aDes) const
  289. #line 1409
  290. {return(Compare(aDes)!=0);}
  291. inline const TUint16 &TDesC16::operator[](TInt anIndex) const
  292. #line 1427
  293. {return(AtC(anIndex));}
  294. inline TInt TDesC16::Length() const
  295. {return(iLength&KMaskDesLength16);}
  296. inline TInt TDesC16::Size() const
  297. #line 1454
  298. {return(Length()<<1);}
  299. inline void TDesC16::DoSetLength(TInt aLength)
  300. {iLength=(iLength&(~KMaskDesLength16))|aLength;}
  301. inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)
  302. #line 1478
  303. {new(this) TPtrC16(aBuf,aLength);}
  304. inline void TPtrC16::Set(const TDesC16 &aDes)
  305. {new(this) TPtrC16(aDes);}
  306. inline void TPtrC16::Set(const TPtrC16& aPtr)
  307. {new(this) TPtrC16(aPtr);}
  308. inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)
  309. {return TPtr16(*this,aMaxLength);}
  310. template <TInt S>
  311. inline TBufC16<S>::TBufC16()
  312. : TBufCBase16()
  313. #line 1526
  314. {}
  315. template <TInt S>
  316. inline TBufC16<S>::TBufC16(const TUint16 *aString)
  317. : TBufCBase16(aString,S)
  318. #line 1550
  319. {}
  320. template <TInt S>
  321. inline TBufC16<S>::TBufC16(const TDesC16 &aDes)
  322. : TBufCBase16(aDes,S)
  323. #line 1574
  324. {}
  325. template <TInt S>
  326. inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)
  327. #line 1593
  328. {Copy(aString,S);return(*this);}
  329. template <TInt S>
  330. inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)
  331. #line 1612
  332. {Copy(aDes,S);return(*this);}
  333. template <TInt S>
  334. inline TPtr16 TBufC16<S>::Des()
  335. #line 1642
  336. {return(DoDes(S));}
  337. inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)
  338. #line 1667
  339. {return *this=static_cast<const TDesC16&>(aLcb);}
  340. inline TDes16 &TDes16::operator=(const TUint16 *aString)
  341. #line 1687
  342.     {Copy(aString);return(*this);}
  343. inline TDes16 &TDes16::operator=(const TDesC16 &aDes)
  344. #line 1705
  345.     {Copy(aDes);return(*this);}
  346. inline TDes16 &TDes16::operator=(const TDes16 &aDes)
  347. #line 1723
  348.     {Copy(aDes);return(*this);}
  349. inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)
  350. #line 1742
  351. {Append(aDes);return(*this);}
  352. inline const TUint16 &TDes16::operator[](TInt anIndex) const
  353. #line 1759
  354. {return(AtC(anIndex));}
  355. inline TUint16 &TDes16::operator[](TInt anIndex)
  356. #line 1778
  357. {return((TUint16 &)AtC(anIndex));}
  358. inline TInt TDes16::MaxLength() const
  359. #line 1792
  360. {return(iMaxLength);}
  361. inline TInt TDes16::MaxSize() const
  362. #line 1806
  363. {return(iMaxLength<<1);}
  364. inline TUint16 * TDes16::WPtr() const
  365. {return((TUint16 *)Ptr());}
  366. inline TPtr16 &TPtr16::operator=(const TUint16 *aString)
  367. #line 1832
  368. {Copy(aString);return(*this);}
  369. inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)
  370. #line 1852
  371. {Copy(aDes);return(*this);}
  372. inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)
  373. #line 1872
  374. {Copy(aDes);return(*this);}
  375. inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)
  376. #line 1893
  377. {new(this) TPtr16(aBuf,aLength,aMaxLength);}
  378. inline void TPtr16::Set(const TPtr16 &aPtr)
  379. #line 1908
  380. {new(this) TPtr16(aPtr);}
  381. template <TInt S>
  382. inline TBuf16<S>::TBuf16()
  383. : TBufBase16(S)
  384. #line 1925
  385. {}
  386. template <TInt S>
  387. inline TBuf16<S>::TBuf16(TInt aLength)
  388. : TBufBase16(aLength,S)
  389. #line 1947
  390. {}
  391. template <TInt S>
  392. inline TBuf16<S>::TBuf16(const TUint16 *aString)
  393. : TBufBase16(aString,S)
  394. #line 1971
  395. {}
  396. template <TInt S>
  397. inline TBuf16<S>::TBuf16(const TDesC16 &aDes)
  398. : TBufBase16(aDes,S)
  399. #line 1995
  400. {}
  401. template <TInt S>
  402. inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)
  403. #line 2015
  404. {Copy(aString);return(*this);}
  405. template <TInt S>
  406. inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)
  407. #line 2035
  408. {Copy(aDes);return(*this);}
  409. template <TInt S>
  410. inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)
  411. #line 2056
  412. {Copy(aBuf);return *this;}
  413. #line 2083
  414. inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)
  415. {
  416. Assign(HBufC16::NewL(aStream,aMaxLength));
  417. }
  418. template <TInt S>
  419. inline const TDesC16* TLitC16<S>::operator&() const
  420. {return (reinterpret_cast<const TDesC16*>(this)) ;}
  421. template <TInt S>
  422. inline const TDesC16& TLitC16<S>::operator()() const
  423. {return *operator&();}
  424. template <TInt S>
  425. inline TLitC16<S>::operator const TDesC16&() const
  426. {return *operator&();}
  427. template <TInt S>
  428. inline TLitC16<S>::operator const __TRefDesC16() const
  429. {return *operator&();}
  430. template <TInt S>
  431. inline TBufC<S>::TBufC()
  432. : TBufCBase16()
  433. #line 2157
  434. {}
  435. template <TInt S>
  436. inline TBufC<S>::TBufC(const TText *aString)
  437. : TBufCBase16(aString,S)
  438. #line 2186
  439. {}
  440. template <TInt S>
  441. inline TBufC<S>::TBufC(const TDesC &aDes)
  442. : TBufCBase16(aDes,S)
  443. #line 2219
  444. {}
  445. #line 2234
  446. template <TInt S>
  447. inline TBufC<S> &TBufC<S>::operator=(const TText *aString)
  448. #line 2253
  449. {Copy(aString,S);return(*this);}
  450. template <TInt S>
  451. inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)
  452. #line 2277
  453. {Copy(aDes,S);return(*this);}
  454. template <TInt S>
  455. inline TPtr TBufC<S>::Des()
  456. #line 2308
  457. {return(DoDes(S));}
  458. template <TInt S>
  459. inline TBuf<S>::TBuf()
  460. : TBufBase16(S)
  461. {}
  462. template <TInt S>
  463. inline TBuf<S>::TBuf(TInt aLength)
  464. : TBufBase16(aLength,S)
  465. #line 2350
  466. {}
  467. template <TInt S>
  468. inline TBuf<S>::TBuf(const TText *aString)
  469. : TBufBase16(aString,S)
  470. #line 2378
  471. {}
  472. template <TInt S>
  473. inline TBuf<S>::TBuf(const TDesC &aDes)
  474. : TBufBase16(aDes,S)
  475. #line 2407
  476. {}
  477. #line 2426
  478. template <TInt S>
  479. inline TBuf<S> &TBuf<S>::operator=(const TText *aString)
  480. {Copy(aString);return(*this);}
  481. template <TInt S>
  482. inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)
  483. {Copy(aDes);return(*this);}
  484. template <TInt S>
  485. inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)
  486. {Copy(aBuf);return(*this);}
  487. template <TInt S>
  488. inline const TDesC* TLitC<S>::operator&() const
  489. {return (reinterpret_cast<const TDesC*>(this)) ;}
  490. template <TInt S>
  491. inline const TDesC& TLitC<S>::operator()() const
  492. {return *operator&();}
  493. template <TInt S>
  494. inline TLitC<S>::operator const TDesC&() const
  495. {return *operator&();}
  496. template <TInt S>
  497. inline TLitC<S>::operator const __TRefDesC() const
  498. {return *operator&();}
  499. template <class T>
  500. inline TPckgC<T>::TPckgC(const T &aRef)
  501. : TPtrC8((const TUint8 *)&aRef,sizeof(T))
  502. {}
  503. template <class T>
  504. inline const T &TPckgC<T>::operator()() const
  505. {return(*((const T *)iPtr));}
  506. template <class T>
  507. inline TPckg<T>::TPckg(const T &aRef)
  508. : TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T))
  509. {}
  510. template <class T>
  511. inline T &TPckg<T>::operator()()
  512. {return(*((T *)iPtr));}
  513. template <class T>
  514. inline TPckgBuf<T>::TPckgBuf()
  515. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  516. {new(&this->iBuf[0]) T;}
  517. template <class T>
  518. inline TPckgBuf<T>::TPckgBuf(const T &aRef)
  519. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  520. #line 2576
  521. {new(&this->iBuf[0]) T(aRef);}
  522. template <class T>
  523. inline TPckgBuf<T> &TPckgBuf<T>::operator=(const TPckgBuf<T> &aRef)
  524. {this->Copy(aRef);return(*this);}
  525. template <class T>
  526. inline T &TPckgBuf<T>::operator=(const T &aRef)
  527. #line 2605
  528. {this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));}
  529. template <class T>
  530. inline T &TPckgBuf<T>::operator()()
  531. {return(*((T *)&this->iBuf[0]));}
  532. template <class T>
  533. inline const T &TPckgBuf<T>::operator()() const
  534. {return(*((T *)&this->iBuf[0]));}
  535. inline TRequestStatus::TRequestStatus()
  536. : iFlags(0)
  537. {}
  538. inline TRequestStatus::TRequestStatus(TInt aVal)
  539. : iStatus(aVal),
  540. iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0)
  541. {}
  542. inline TInt TRequestStatus::operator=(TInt aVal)
  543. {
  544. if(aVal==KRequestPending)
  545. iFlags|=TRequestStatus::ERequestPending;
  546. else
  547. iFlags&=~TRequestStatus::ERequestPending;
  548. return (iStatus=aVal);
  549. }
  550. inline TBool TRequestStatus::operator==(TInt aVal) const
  551. #line 2691
  552. {return(iStatus==aVal);}
  553. inline TBool TRequestStatus::operator!=(TInt aVal) const
  554. #line 2705
  555. {return(iStatus!=aVal);}
  556. inline TBool TRequestStatus::operator>=(TInt aVal) const
  557. #line 2720
  558. {return(iStatus>=aVal);}
  559. inline TBool TRequestStatus::operator<=(TInt aVal) const
  560. #line 2735
  561. {return(iStatus<=aVal);}
  562. inline TBool TRequestStatus::operator>(TInt aVal) const
  563. #line 2750
  564. {return(iStatus>aVal);}
  565. inline TBool TRequestStatus::operator<(TInt aVal) const
  566. #line 2765
  567. {return(iStatus<aVal);}
  568. inline TInt TRequestStatus::Int() const
  569. {return(iStatus);}
  570. inline TPoint::TPoint()
  571. : iX(0),iY(0)
  572. {}
  573. inline TPoint::TPoint(TInt aX,TInt aY)
  574. : iX(aX),iY(aY)
  575. {}
  576. inline TSize::TSize()
  577. : iWidth(0),iHeight(0)
  578. {}
  579. inline TSize::TSize(TInt aWidth,TInt aHeight)
  580. : iWidth(aWidth),iHeight(aHeight)
  581. {}
  582. inline RHandleBase::RHandleBase()
  583. : iHandle(0)
  584. {}
  585. inline RHandleBase::RHandleBase(TInt aHandle)
  586. : iHandle(aHandle)
  587. #line 2853
  588. {}
  589. inline void RHandleBase::SetHandle(TInt aHandle)
  590. { iHandle=aHandle; }
  591. inline TInt RHandleBase::Handle() const
  592. {return(iHandle);}
  593. inline TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError)
  594. #line 2899
  595. {
  596. if(aHandleOrError>=0)
  597. {
  598. iHandle = aHandleOrError;
  599. return KErrNone;
  600. }
  601. iHandle = 0;
  602. return aHandleOrError;
  603. }
  604. inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType)
  605. #line 2935
  606. {return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));}
  607. #line 2947
  608. inline RFastLock::RFastLock()
  609. : iCount(0)
  610. {}
  611. #line 2960
  612. inline RMessagePtr2::RMessagePtr2()
  613. : iHandle(0)
  614. {}
  615. #line 2972
  616. inline TBool RMessagePtr2::IsNull() const
  617. {return iHandle==0;}
  618. #line 2983
  619. inline TInt RMessagePtr2::Handle() const
  620. {return iHandle;}
  621. inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  622. {return aLeft.Handle()==aRight.Handle();}
  623. inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  624. {return aLeft.Handle()!=aRight.Handle();}
  625. #line 3000
  626. inline RMessage2::RMessage2()
  627. {}
  628. #line 3011
  629. inline TInt RMessage2::Function() const
  630. {return(iFunction);}
  631. #line 3022
  632. inline TInt RMessage2::Int0() const
  633. {return(iArgs[0]);}
  634. #line 3033
  635. inline TInt RMessage2::Int1() const
  636. {return(iArgs[1]);}
  637. #line 3044
  638. inline TInt RMessage2::Int2() const
  639. {return(iArgs[2]);}
  640. #line 3054
  641. inline TInt RMessage2::Int3() const
  642. {return(iArgs[3]);}
  643. #line 3064
  644. inline const TAny *RMessage2::Ptr0() const
  645. {return((const TAny *)iArgs[0]);}
  646. #line 3075
  647. inline const TAny *RMessage2::Ptr1() const
  648. {return((const TAny *)iArgs[1]);}
  649. #line 3086
  650. inline const TAny *RMessage2::Ptr2() const
  651. {return((const TAny *)iArgs[2]);}
  652. #line 3097
  653. inline const TAny *RMessage2::Ptr3() const
  654. {return((const TAny *)iArgs[3]);}
  655. #line 3107
  656. inline CSession2* RMessage2::Session() const
  657. {return (CSession2*)iSessionPtr; }
  658. inline TUid TUid::Uid(TInt aUid)
  659. #line 3123
  660. {TUid uid={aUid};return uid;}
  661. inline TUid TUid::Null()
  662. {TUid uid={KNullUidValue};return uid;}
  663. template <class T>
  664. inline TArray<T>::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr)
  665. : iPtr(aPtr),iCount(aCount),iAt(anAt)
  666. #line 3195
  667. {}
  668. template <class T>
  669. inline TInt TArray<T>::Count() const
  670. {return((*iCount)(iPtr));}
  671. template <class T>
  672. inline const T &TArray<T>::operator[](TInt anIndex) const
  673. #line 3232
  674. {return(*((const T *)(*iAt)(iPtr,anIndex)));}
  675. template <class T>
  676. inline TIdentityRelation<T>::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) )
  677. #line 3254
  678. { iIdentity=(TGeneralIdentityRelation)anIdentity; }
  679. template <class T>
  680. inline TIdentityRelation<T>::operator TGeneralIdentityRelation() const
  681. { return iIdentity; }
  682. template <class T>
  683. inline TLinearOrder<T>::TLinearOrder( TInt(*anOrder)(const T&, const T&) )
  684. #line 3288
  685. { iOrder=(TGeneralLinearOrder)anOrder; }
  686. template <class T>
  687. inline TLinearOrder<T>::operator TGeneralLinearOrder() const
  688. { return iOrder; }
  689. #line 3312
  690. template <class T>
  691. inline RPointerArray<T>::RPointerArray()
  692. : RPointerArrayBase()
  693. {}
  694. #line 3331
  695. template <class T>
  696. inline RPointerArray<T>::RPointerArray(TInt aGranularity)
  697. : RPointerArrayBase(aGranularity)
  698. {}
  699. #line 3354
  700. template <class T>
  701. inline RPointerArray<T>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  702. : RPointerArrayBase(aMinGrowBy, aFactor)
  703. {}
  704. template <class T>
  705. inline void RPointerArray<T>::Close()
  706. #line 3372
  707. {RPointerArrayBase::Close();}
  708. template <class T>
  709. inline TInt RPointerArray<T>::Count() const
  710. { return RPointerArrayBase::Count(); }
  711. template <class T>
  712. inline T* const& RPointerArray<T>::operator[](TInt anIndex) const
  713. #line 3408
  714. {return (T* const&)At(anIndex);}
  715. template <class T>
  716. inline T*& RPointerArray<T>::operator[](TInt anIndex)
  717. #line 3432
  718. {return (T*&)At(anIndex);}
  719. template <class T>
  720. inline TInt RPointerArray<T>::Append(const T* anEntry)
  721. #line 3447
  722. { return RPointerArrayBase::Append(anEntry); }
  723. template <class T>
  724. inline TInt RPointerArray<T>::Insert(const T* anEntry, TInt aPos)
  725. #line 3468
  726. { return RPointerArrayBase::Insert(anEntry,aPos); }
  727. template <class T>
  728. inline void RPointerArray<T>::Remove(TInt anIndex)
  729. #line 3488
  730. {RPointerArrayBase::Remove(anIndex);}
  731. template <class T>
  732. inline void RPointerArray<T>::Compress()
  733. #line 3503
  734. {RPointerArrayBase::Compress();}
  735. template <class T>
  736. inline void RPointerArray<T>::Reset()
  737. #line 3522
  738. {RPointerArrayBase::Reset();}
  739. template <class T>
  740. inline TInt RPointerArray<T>::Find(const T* anEntry) const
  741. #line 3542
  742. { return RPointerArrayBase::Find(anEntry); }
  743. template <class T>
  744. inline TInt RPointerArray<T>::Find(const T* anEntry, TIdentityRelation<T> anIdentity) const
  745. #line 3566
  746. { return RPointerArrayBase::Find(anEntry,anIdentity); }
  747. template <class T>
  748. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry) const
  749. #line 3584
  750. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  751. template <class T>
  752. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const
  753. #line 3606
  754. { return RPointerArrayBase::FindIsq(anEntry,anOrder); }
  755. template <class T>
  756. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry, TInt& anIndex) const
  757. #line 3631
  758. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  759. template <class T>
  760. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  761. #line 3660
  762. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); }
  763. template <class T>
  764. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const
  765. #line 3691
  766. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  767. template <class T>
  768. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  769. #line 3726
  770. { return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); }
  771. template <class T>
  772. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const
  773. #line 3766
  774. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  775. template <class T>
  776. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  777. #line 3810
  778. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); }
  779. template <class T>
  780. inline TInt RPointerArray<T>::InsertInAddressOrder(const T* anEntry)
  781. #line 3833
  782. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  783. template <class T>
  784. inline TInt RPointerArray<T>::InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder)
  785. #line 3862
  786. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); }
  787. template <class T>
  788. inline TInt RPointerArray<T>::InsertInAddressOrderAllowRepeats(const T* anEntry)
  789. #line 3885
  790. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  791. template <class T>
  792. inline TInt RPointerArray<T>::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder)
  793. #line 3911
  794. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); }
  795. template <class T>
  796. inline RPointerArray<T>::RPointerArray(T** aEntries, TInt aCount)
  797. : RPointerArrayBase((TAny **)aEntries, aCount)
  798. #line 3935
  799. {}
  800. template <class T>
  801. inline void RPointerArray<T>::GranularCompress()
  802. #line 3950
  803. {RPointerArrayBase::GranularCompress();}
  804. template <class T>
  805. inline TInt RPointerArray<T>::Reserve(TInt aCount)
  806. #line 3969
  807. { return RPointerArrayBase::DoReserve(aCount); }
  808. template <class T>
  809. inline void RPointerArray<T>::SortIntoAddressOrder()
  810. { HeapSortUnsigned(); }
  811. template <class T>
  812. inline void RPointerArray<T>::Sort(TLinearOrder<T> anOrder)
  813. #line 3996
  814. { HeapSort(anOrder); }
  815. template <class T>
  816. inline TArray<T*> RPointerArray<T>::Array() const
  817. { return TArray<T*>(GetCount,GetElementPtr,(const CBase*)this); }
  818. template <class T>
  819. void RPointerArray<T>::ResetAndDestroy()
  820. #line 4026
  821. {
  822. TInt c=Count();
  823. T** pE=(T**)Entries();
  824. ZeroCount();
  825. TInt i;
  826. for (i=0; i<c; i++)
  827. {
  828. delete *pE;
  829. pE++;
  830. }
  831. Reset();
  832. }
  833. #line 4049
  834. inline RPointerArray<TAny>::RPointerArray()
  835. : RPointerArrayBase()
  836. {}
  837. #line 4067
  838. inline RPointerArray<TAny>::RPointerArray(TInt aGranularity)
  839. : RPointerArrayBase(aGranularity)
  840. {}
  841. #line 4089
  842. inline RPointerArray<TAny>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  843. : RPointerArrayBase(aMinGrowBy, aFactor)
  844. {}
  845. inline void RPointerArray<TAny>::Close()
  846. #line 4105
  847. {RPointerArrayBase::Close();}
  848. inline TInt RPointerArray<TAny>::Count() const
  849. { return RPointerArrayBase::Count(); }
  850. inline TAny* const& RPointerArray<TAny>::operator[](TInt anIndex) const
  851. #line 4139
  852. {return At(anIndex);}
  853. inline TAny*& RPointerArray<TAny>::operator[](TInt anIndex)
  854. #line 4162
  855. {return At(anIndex);}
  856. inline TInt RPointerArray<TAny>::Append(const TAny* anEntry)
  857. #line 4176
  858. { return RPointerArrayBase::Append(anEntry); }
  859. inline TInt RPointerArray<TAny>::Insert(const TAny* anEntry, TInt aPos)
  860. #line 4196
  861. { return RPointerArrayBase::Insert(anEntry,aPos); }
  862. inline void RPointerArray<TAny>::Remove(TInt anIndex)
  863. #line 4215
  864. {RPointerArrayBase::Remove(anIndex);}
  865. inline void RPointerArray<TAny>::Compress()
  866. #line 4229
  867. {RPointerArrayBase::Compress();}
  868. inline void RPointerArray<TAny>::Reset()
  869. #line 4247
  870. {RPointerArrayBase::Reset();}
  871. inline TInt RPointerArray<TAny>::Find(const TAny* anEntry) const
  872. #line 4266
  873. { return RPointerArrayBase::Find(anEntry); }
  874. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry) const
  875. #line 4283
  876. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  877. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const
  878. #line 4307
  879. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  880. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const
  881. #line 4337
  882. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  883. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const
  884. #line 4376
  885. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  886. inline TInt RPointerArray<TAny>::InsertInAddressOrder(const TAny* anEntry)
  887. #line 4398
  888. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  889. inline TInt RPointerArray<TAny>::InsertInAddressOrderAllowRepeats(const TAny* anEntry)
  890. #line 4420
  891. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  892. inline RPointerArray<TAny>::RPointerArray(TAny** aEntries, TInt aCount)
  893. : RPointerArrayBase((TAny **)aEntries, aCount)
  894. #line 4443
  895. {}
  896. inline void RPointerArray<TAny>::GranularCompress()
  897. #line 4457
  898. {RPointerArrayBase::GranularCompress();}
  899. inline void RPointerArray<TAny>::SortIntoAddressOrder()
  900. { HeapSortUnsigned(); }
  901. inline TArray<TAny*> RPointerArray<TAny>::Array() const
  902. { return TArray<TAny*>(GetCount,GetElementPtr,(const CBase*)this); }
  903. template <class T>
  904. inline RArray<T>::RArray()
  905. : RArrayBase(sizeof(T))
  906. #line 4497
  907. {}
  908. template <class T>
  909. inline RArray<T>::RArray(TInt aGranularity)
  910. : RArrayBase(sizeof(T),aGranularity)
  911. #line 4519
  912. {}
  913. template <class T>
  914. inline RArray<T>::RArray(TInt aGranularity, TInt aKeyOffset)
  915. : RArrayBase(sizeof(T),aGranularity,aKeyOffset)
  916. #line 4543
  917. {}
  918. #line 4567
  919. template <class T>
  920. inline RArray<T>::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
  921. : RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor)
  922. {}
  923. template <class T>
  924. inline void RArray<T>::Close()
  925. {RArrayBase::Close();}
  926. template <class T>
  927. inline TInt RArray<T>::Count() const
  928. {return RArrayBase::Count();}
  929. template <class T>
  930. inline const T& RArray<T>::operator[](TInt anIndex) const
  931. #line 4616
  932. {return *(const T*)At(anIndex); }
  933. template <class T>
  934. inline T& RArray<T>::operator[](TInt anIndex)
  935. #line 4638
  936. {return *(T*)At(anIndex); }
  937. template <class T>
  938. inline TInt RArray<T>::Append(const T& anEntry)
  939. #line 4653
  940. {return RArrayBase::Append(&anEntry);}
  941. template <class T>
  942. inline TInt RArray<T>::Insert(const T& anEntry, TInt aPos)
  943. #line 4675
  944. {return RArrayBase::Insert(&anEntry,aPos);}
  945. template <class T>
  946. inline void RArray<T>::Remove(TInt anIndex)
  947. #line 4692
  948. {RArrayBase::Remove(anIndex);}
  949. template <class T>
  950. inline void RArray<T>::Compress()
  951. {RArrayBase::Compress();}
  952. template <class T>
  953. inline void RArray<T>::Reset()
  954. #line 4721
  955. {RArrayBase::Reset();}
  956. template <class T>
  957. inline TInt RArray<T>::Find(const T& anEntry) const
  958. #line 4743
  959. {return RArrayBase::Find(&anEntry);}
  960. template <class T>
  961. inline TInt RArray<T>::Find(const T& anEntry, TIdentityRelation<T> anIdentity) const
  962. #line 4768
  963. {return RArrayBase::Find(&anEntry,anIdentity);}
  964. template <class T>
  965. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry) const
  966. #line 4787
  967. {return RArrayBase::FindIsqSigned(&anEntry);}
  968. template <class T>
  969. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry) const
  970. #line 4806
  971. {return RArrayBase::FindIsqUnsigned(&anEntry);}
  972. template <class T>
  973. inline TInt RArray<T>::FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const
  974. #line 4828
  975. {return RArrayBase::FindIsq(&anEntry,anOrder);}
  976. template <class T>
  977. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const
  978. #line 4851
  979. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex);}
  980. template <class T>
  981. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const
  982. #line 4875
  983. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);}
  984. template <class T>
  985. inline TInt RArray<T>::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  986. #line 4902
  987. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);}
  988. template <class T>
  989. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const
  990. #line 4936
  991. {return RArrayBase::FindIsqSigned(&anEntry,aMode);}
  992. template <class T>
  993. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const
  994. #line 4970
  995. {return RArrayBase::FindIsqUnsigned(&anEntry,aMode);}
  996. template <class T>
  997. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  998. #line 5003
  999. {return RArrayBase::FindIsq(&anEntry,anOrder,aMode);}
  1000. template <class T>
  1001. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  1002. #line 5042
  1003. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);}
  1004. template <class T>
  1005. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  1006. #line 5081
  1007. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);}
  1008. template <class T>
  1009. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  1010. #line 5123
  1011. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);}
  1012. template <class T>
  1013. inline TInt RArray<T>::InsertInSignedKeyOrder(const T& anEntry)
  1014. #line 5146
  1015. {return RArrayBase::InsertIsqSigned(&anEntry,EFalse);}
  1016. template <class T>
  1017. inline TInt RArray<T>::InsertInUnsignedKeyOrder(const T& anEntry)
  1018. #line 5169
  1019. {return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);}
  1020. template <class T>
  1021. inline TInt RArray<T>::InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder)
  1022. #line 5197
  1023. {return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);}
  1024. template <class T>
  1025. inline TInt RArray<T>::InsertInSignedKeyOrderAllowRepeats(const T& anEntry)
  1026. #line 5221
  1027. {return RArrayBase::InsertIsqSigned(&anEntry,ETrue);}
  1028. template <class T>
  1029. inline TInt RArray<T>::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry)
  1030. #line 5245
  1031. {return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);}
  1032. template <class T>
  1033. inline TInt RArray<T>::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder)
  1034. #line 5272
  1035. {return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);}
  1036. template <class T>
  1037. inline RArray<T>::RArray(TInt aEntrySize,T* aEntries, TInt aCount)
  1038. : RArrayBase(aEntrySize,aEntries,aCount)
  1039. #line 5303
  1040. {}
  1041. template <class T>
  1042. inline void RArray<T>::GranularCompress()
  1043. #line 5318
  1044. {RArrayBase::GranularCompress();}
  1045. template <class T>
  1046. inline TInt RArray<T>::Reserve(TInt aCount)
  1047. #line 5337
  1048. { return RArrayBase::DoReserve(aCount); }
  1049. template <class T>
  1050. inline void RArray<T>::SortSigned()
  1051. {HeapSortSigned();}
  1052. template <class T>
  1053. inline void RArray<T>::SortUnsigned()
  1054. {HeapSortUnsigned();}
  1055. template <class T>
  1056. inline void RArray<T>::Sort(TLinearOrder<T> anOrder)
  1057. #line 5375
  1058. {HeapSort(anOrder);}
  1059. template <class T>
  1060. inline TArray<T> RArray<T>::Array() const
  1061. { return TArray<T>(GetCount,GetElementPtr,(const CBase*)this); }
  1062. inline RArray<TInt>::RArray()
  1063. : RPointerArrayBase()
  1064. {}
  1065. inline RArray<TInt>::RArray(TInt aGranularity)
  1066. : RPointerArrayBase(aGranularity)
  1067. #line 5417
  1068. {}
  1069. #line 5437
  1070. inline RArray<TInt>::RArray(TInt aMinGrowBy, TInt aFactor)
  1071. : RPointerArrayBase(aMinGrowBy, aFactor)
  1072. {}
  1073. inline void RArray<TInt>::Close()
  1074. {RPointerArrayBase::Close();}
  1075. inline TInt RArray<TInt>::Count() const
  1076. { return RPointerArrayBase::Count(); }
  1077. inline const TInt& RArray<TInt>::operator[](TInt anIndex) const
  1078. #line 5484
  1079. {return (const TInt&)At(anIndex);}
  1080. inline TInt& RArray<TInt>::operator[](TInt anIndex)
  1081. #line 5507
  1082. {return (TInt&)At(anIndex);}
  1083. inline TInt RArray<TInt>::Append(TInt anEntry)
  1084. #line 5521
  1085. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  1086. inline TInt RArray<TInt>::Insert(TInt anEntry, TInt aPos)
  1087. #line 5541
  1088. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  1089. inline void RArray<TInt>::Remove(TInt anIndex)
  1090. #line 5558
  1091. {RPointerArrayBase::Remove(anIndex);}
  1092. inline void RArray<TInt>::Compress()
  1093. {RPointerArrayBase::Compress();}
  1094. inline void RArray<TInt>::Reset()
  1095. #line 5586
  1096. {RPointerArrayBase::Reset();}
  1097. inline TInt RArray<TInt>::Find(TInt anEntry) const
  1098. #line 5604
  1099. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  1100. inline TInt RArray<TInt>::FindInOrder(TInt anEntry) const
  1101. #line 5621
  1102. { return RPointerArrayBase::FindIsqSigned(anEntry); }
  1103. inline TInt RArray<TInt>::FindInOrder(TInt anEntry, TInt& anIndex) const
  1104. #line 5644
  1105. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); }
  1106. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt aMode) const
  1107. #line 5675
  1108. { return RPointerArrayBase::FindIsqSigned(anEntry,aMode); }
  1109. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const
  1110. #line 5713
  1111. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); }
  1112. inline TInt RArray<TInt>::InsertInOrder(TInt anEntry)
  1113. #line 5735
  1114. { return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); }
  1115. inline TInt RArray<TInt>::InsertInOrderAllowRepeats(TInt anEntry)
  1116. #line 5758
  1117. { return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); }
  1118. inline RArray<TInt>::RArray(TInt* aEntries, TInt aCount)
  1119. : RPointerArrayBase((TAny**)aEntries, aCount)
  1120. #line 5781
  1121. {}
  1122. inline void RArray<TInt>::GranularCompress()
  1123. #line 5792
  1124. {RPointerArrayBase::GranularCompress();}
  1125. inline TInt RArray<TInt>::Reserve(TInt aCount)
  1126. #line 5810
  1127. { return RPointerArrayBase::DoReserve(aCount); }
  1128. inline void RArray<TInt>::Sort()
  1129. { HeapSortSigned(); }
  1130. inline TArray<TInt> RArray<TInt>::Array() const
  1131. { return TArray<TInt>(GetCount,GetElementPtr,(const CBase*)this); }
  1132. inline RArray<TUint>::RArray()
  1133. : RPointerArrayBase()
  1134. #line 5847
  1135. {}
  1136. inline RArray<TUint>::RArray(TInt aGranularity)
  1137. : RPointerArrayBase(aGranularity)
  1138. #line 5863
  1139. {}
  1140. #line 5883
  1141. inline RArray<TUint>::RArray(TInt aMinGrowBy, TInt aFactor)
  1142. : RPointerArrayBase(aMinGrowBy, aFactor)
  1143. {}
  1144. inline void RArray<TUint>::Close()
  1145. {RPointerArrayBase::Close();}
  1146. inline TInt RArray<TUint>::Count() const
  1147. {return RPointerArrayBase::Count(); }
  1148. inline const TUint& RArray<TUint>::operator[](TInt anIndex) const
  1149. #line 5930
  1150. {return (const TUint&)At(anIndex);}
  1151. inline TUint& RArray<TUint>::operator[](TInt anIndex)
  1152. #line 5953
  1153. {return (TUint&)At(anIndex);}
  1154. inline TInt RArray<TUint>::Append(TUint anEntry)
  1155. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  1156. inline TInt RArray<TUint>::Insert(TUint anEntry, TInt aPos)
  1157. #line 5987
  1158. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  1159. inline void RArray<TUint>::Remove(TInt anIndex)
  1160. #line 6005
  1161. {RPointerArrayBase::Remove(anIndex);}
  1162. inline void RArray<TUint>::Compress()
  1163. {RPointerArrayBase::Compress();}
  1164. inline void RArray<TUint>::Reset()
  1165. #line 6033
  1166. {RPointerArrayBase::Reset();}
  1167. inline TInt RArray<TUint>::Find(TUint anEntry) const
  1168. #line 6051
  1169. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  1170. inline TInt RArray<TUint>::FindInOrder(TUint anEntry) const
  1171. #line 6070
  1172. { return RPointerArrayBase::FindIsqUnsigned(anEntry); }
  1173. inline TInt RArray<TUint>::FindInOrder(TUint anEntry, TInt& anIndex) const
  1174. #line 6098
  1175. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); }
  1176. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt aMode) const
  1177. #line 6128
  1178. { return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); }
  1179. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const
  1180. #line 6163
  1181. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); }
  1182. inline TInt RArray<TUint>::InsertInOrder(TUint anEntry)
  1183. #line 6185
  1184. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); }
  1185. inline TInt RArray<TUint>::InsertInOrderAllowRepeats(TUint anEntry)
  1186. #line 6208
  1187. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); }
  1188. inline RArray<TUint>::RArray(TUint* aEntries, TInt aCount)
  1189. : RPointerArrayBase((TAny**)aEntries, aCount)
  1190. #line 6231
  1191. {}
  1192. inline void RArray<TUint>::GranularCompress()
  1193. #line 6244
  1194. {RPointerArrayBase::GranularCompress();}
  1195. inline TInt RArray<TUint>::Reserve(TInt aCount)
  1196. #line 6262
  1197. { return RPointerArrayBase::DoReserve(aCount); }
  1198. inline void RArray<TUint>::Sort()
  1199. { HeapSortUnsigned(); }
  1200. inline TArray<TUint> RArray<TUint>::Array() const
  1201. { return TArray<TUint>(GetCount,GetElementPtr,(const CBase*)this); }
  1202. #line 6293
  1203. inline void TIpcArgs::Set(TInt,TNothing)
  1204. {}
  1205. #line 6307
  1206. inline void TIpcArgs::Set(TInt aIndex,TInt aValue)
  1207. {
  1208. iArgs[aIndex] = aValue;
  1209. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  1210. }
  1211. #line 6324
  1212. inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue)
  1213. {
  1214. iArgs[aIndex] = (TInt)aValue;
  1215. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  1216. }
  1217. #line 6341
  1218. inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue)
  1219. {
  1220. iArgs[aIndex] = (TInt)aValue.Handle();
  1221. iFlags |= EHandle<<(aIndex*KBitsPerType);
  1222. }
  1223. #line 6358
  1224. inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue)
  1225. {
  1226. iArgs[aIndex] = (TInt)aValue;
  1227. iFlags |= EDesC8<<(aIndex*KBitsPerType);
  1228. }
  1229. #line 6377
  1230. inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue)
  1231. {
  1232. iArgs[aIndex] = (TInt)aValue;
  1233. iFlags |= EDesC16<<(aIndex*KBitsPerType);
  1234. }
  1235. #line 6396
  1236. inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue)
  1237. {
  1238. iArgs[aIndex] = (TInt)aValue;
  1239. iFlags |= EDes8<<(aIndex*KBitsPerType);
  1240. }
  1241. #line 6415
  1242. inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue)
  1243. {
  1244. iArgs[aIndex] = (TInt)aValue;
  1245. iFlags |= EDes16<<(aIndex*KBitsPerType);
  1246. }
  1247. inline TIpcArgs::TArgType TIpcArgs::Type(TNothing)
  1248. { return EUnspecified; }
  1249. inline TIpcArgs::TArgType TIpcArgs::Type(TInt)
  1250. { return EUnspecified; }
  1251. inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*)
  1252. { return EUnspecified; }
  1253. inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase)
  1254. { return EHandle; }
  1255. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*)
  1256. { return EDesC8; }
  1257. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*)
  1258. { return EDesC16; }
  1259. inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*)
  1260. { return EDes8; }
  1261. inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*)
  1262. { return EDes16; }
  1263. inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing)
  1264. {}
  1265. inline void TIpcArgs::Assign(TInt& aArg,TInt aValue)
  1266. { aArg = aValue; }
  1267. inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue)
  1268. { aArg = (TInt)aValue; }
  1269. inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue)
  1270. { aArg = (TInt)aValue.Handle(); }
  1271. inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue)
  1272. { aArg = (TInt)aValue; }
  1273. inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue)
  1274. { aArg = (TInt)aValue; }
  1275. inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue)
  1276. { aArg = (TInt)aValue; }
  1277. inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue)
  1278. { aArg = (TInt)aValue; }
  1279. inline SInt64::SInt64()
  1280. {}
  1281. inline SInt64::SInt64(Int64 a)
  1282. {
  1283. iData[0] = (TUint32)((Uint64)a);
  1284. iData[1] = (TUint32)(((Uint64)a)>>32);
  1285. }
  1286. inline SInt64& SInt64::operator=(Int64 a)
  1287. {
  1288. iData[0] = (TUint32)((Uint64)a);
  1289. iData[1] = (TUint32)(((Uint64)a)>>32);
  1290. return *this;
  1291. }
  1292. inline SInt64::operator Int64() const
  1293. {
  1294. Int64 x;
  1295. TUint32* px = (TUint32*)&x;
  1296. px[0] = iData[0];
  1297. px[1] = iData[1];
  1298. return x;
  1299. }
  1300. inline SUint64::SUint64()
  1301. {}
  1302. inline SUint64::SUint64(Uint64 a)
  1303. {
  1304. iData[0] = (TUint32)a;
  1305. iData[1] = (TUint32)(a>>32);
  1306. }
  1307. inline SUint64& SUint64::operator=(Uint64 a)
  1308. {
  1309. iData[0] = (TUint32)a;
  1310. iData[1] = (TUint32)(a>>32);
  1311. return *this;
  1312. }
  1313. inline SUint64::operator Uint64() const
  1314. {
  1315. Uint64 x;
  1316. TUint32* px = (TUint32*)&x;
  1317. px[0] = iData[0];
  1318. px[1] = iData[1];
  1319. return x;
  1320. }
  1321. inline SDouble::SDouble()
  1322. {}
  1323. inline SDouble::SDouble(TReal a)
  1324. {
  1325. const TUint32* pa = (const TUint32*)&a;
  1326. iData[0] = pa[0];
  1327. iData[1] = pa[1];
  1328. }
  1329. inline SDouble& SDouble::operator=(TReal a)
  1330. {
  1331. new (this) SDouble(a);
  1332. return *this;
  1333. }
  1334. inline SDouble::operator TReal() const
  1335. {
  1336. TReal x;
  1337. TUint32* px = (TUint32*)&x;
  1338. px[0] = iData[0];
  1339. px[1] = iData[1];
  1340. return x;
  1341. }
  1342. inline TSecureId::TSecureId()
  1343. {}
  1344. inline TSecureId::TSecureId(TUint32 aId)
  1345. : iId(aId) {}
  1346. inline TSecureId::operator TUint32() const
  1347. { return iId; }
  1348. inline TSecureId::TSecureId(TUid aId)
  1349. : iId(aId.iUid) {}
  1350. inline TSecureId::operator TUid() const
  1351. { return (TUid&)iId; }
  1352. inline const TSecureId* SSecureId::operator&() const
  1353. { return (const TSecureId*)this; }
  1354. inline SSecureId::operator const TSecureId&() const
  1355. { return (const TSecureId&)iId; }
  1356. inline SSecureId::operator TUint32() const
  1357. { return iId; }
  1358. inline SSecureId::operator TUid() const
  1359. { return (TUid&)iId; }
  1360. inline TVendorId::TVendorId()
  1361. {}
  1362. inline TVendorId::TVendorId(TUint32 aId)
  1363. : iId(aId) {}
  1364. inline TVendorId::operator TUint32() const
  1365. { return iId; }
  1366. inline TVendorId::TVendorId(TUid aId)
  1367. : iId(aId.iUid) {}
  1368. inline TVendorId::operator TUid() const
  1369. { return (TUid&)iId; }
  1370. inline const TVendorId* SVendorId::operator&() const
  1371. { return (const TVendorId*)this; }
  1372. inline SVendorId::operator const TVendorId&() const
  1373. { return (const TVendorId&)iId; }
  1374. inline SVendorId::operator TUint32() const
  1375. { return iId; }
  1376. inline SVendorId::operator TUid() const
  1377. { return (TUid&)iId; }
  1378. inline TCapabilitySet::TCapabilitySet()
  1379. {}
  1380. inline TCapabilitySet::TCapabilitySet(TCapability aCapability)
  1381. { new (this) TCapabilitySet(aCapability, aCapability); }
  1382. inline void TCapabilitySet::Set(TCapability aCapability)
  1383. { new (this) TCapabilitySet(aCapability, aCapability); }
  1384. inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2)
  1385. { new (this) TCapabilitySet(aCapability1, aCapability2); }
  1386. inline TSecurityInfo::TSecurityInfo()
  1387. {}
  1388. inline TSecurityPolicy::TSecurityPolicy()
  1389. { new (this) TSecurityPolicy(EAlwaysFail); }
  1390. inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const
  1391. { return (const TSecurityPolicy*)this; }
  1392. inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const
  1393. { return *(const TSecurityPolicy*)this; }
  1394. inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const
  1395. { return *(const TSecurityPolicy*)this; }
  1396. #line 6341 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.h" /* stack depth 3 */
  1397. #line 13 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 2 */
  1398. class TFunctor
  1399. {
  1400. public:
  1401. __declspec(dllexport) virtual void operator()() =0;
  1402. };
  1403. #line 53
  1404. class TCallBack
  1405. {
  1406. public:
  1407. inline TCallBack();
  1408. inline TCallBack(TInt (*aFunction)(TAny* aPtr));
  1409. inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
  1410. inline TInt CallBack() const;
  1411. public:
  1412. TInt (*iFunction)(TAny* aPtr);
  1413. TAny* iPtr;
  1414. };
  1415. #line 89
  1416. class TSglQueLink
  1417. {
  1418. public:
  1419. inline TSglQueLink() : iNext(0 )
  1420. {}
  1421. private:
  1422. __declspec(dllexport) void Enque(TSglQueLink* aLink);
  1423. public:
  1424. TSglQueLink* iNext;
  1425. friend class TSglQueBase;
  1426. };
  1427. #line 130
  1428. class TDblQueLinkBase
  1429. {
  1430. public:
  1431. inline TDblQueLinkBase() : iNext(0 )
  1432. {}
  1433. __declspec(dllexport) void Enque(TDblQueLinkBase* aLink);
  1434. __declspec(dllexport) void AddBefore(TDblQueLinkBase* aLink);
  1435. public:
  1436. TDblQueLinkBase* iNext;
  1437. TDblQueLinkBase* iPrev;
  1438. };
  1439. #line 166
  1440. class TDblQueLink : public TDblQueLinkBase
  1441. {
  1442. public:
  1443. __declspec(dllexport) void Deque();
  1444. };
  1445. #line 184
  1446. class TPriQueLink : public TDblQueLink
  1447. {
  1448. public:
  1449. TInt iPriority;
  1450. };
  1451. #line 205
  1452. class TDeltaQueLink : public TDblQueLinkBase
  1453. {
  1454. public:
  1455. TInt iDelta;
  1456. };
  1457. #line 224
  1458. class TTickCountQueLink : public TDblQueLink
  1459. {
  1460. public:
  1461. TUint iTickCount;
  1462. };
  1463. #line 248
  1464. class TSglQueBase
  1465. {
  1466. public:
  1467. __declspec(dllexport) TBool IsEmpty() const;
  1468. __declspec(dllexport) void SetOffset(TInt aOffset);
  1469. __declspec(dllexport) void Reset();
  1470. protected:
  1471. __declspec(dllexport) TSglQueBase();
  1472. __declspec(dllexport) TSglQueBase(TInt aOffset);
  1473. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  1474. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  1475. __declspec(dllexport) void DoRemove(TAny* aPtr);
  1476. protected:
  1477. TSglQueLink* iHead;
  1478. TSglQueLink* iLast;
  1479. TInt iOffset;
  1480. private:
  1481. TSglQueBase(const TSglQueBase& aQue);
  1482. TSglQueBase &operator=(const TSglQueBase& aQue);
  1483. friend class TSglQueIterBase;
  1484. };
  1485. #line 296
  1486. class TDblQueBase
  1487. {
  1488. public:
  1489. __declspec(dllexport) TBool IsEmpty() const;
  1490. __declspec(dllexport) void SetOffset(TInt aOffset);
  1491. __declspec(dllexport) void Reset();
  1492. protected:
  1493. __declspec(dllexport) TDblQueBase();
  1494. __declspec(dllexport) TDblQueBase(TInt aOffset);
  1495. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  1496. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  1497. __declspec(dllexport) void DoAddPriority(TAny* aPtr);
  1498. __declspec(dllexport) void __DbgTestEmpty() const;
  1499. protected:
  1500. TDblQueLink iHead;
  1501. TInt iOffset;
  1502. private:
  1503. TDblQueBase(const TDblQueBase& aQue);
  1504. TDblQueBase& operator=(const TDblQueBase& aQue);
  1505. friend class TDblQueIterBase;
  1506. };
  1507. #line 338
  1508. class TDeltaQueBase : public TDblQueBase
  1509. {
  1510. public:
  1511. __declspec(dllexport) TBool CountDown();
  1512. __declspec(dllexport) TBool CountDown(TInt aValue);
  1513. __declspec(dllexport) TBool FirstDelta(TInt& aValue);
  1514. __declspec(dllexport) void Reset();
  1515. protected:
  1516. __declspec(dllexport) TDeltaQueBase();
  1517. __declspec(dllexport) TDeltaQueBase(TInt aOffset);
  1518. __declspec(dllexport) void DoAddDelta(TAny* aPtr,TInt aDelta);
  1519. __declspec(dllexport) void DoRemove(TAny* aPtr);
  1520. __declspec(dllexport) TAny* DoRemoveFirst();
  1521. protected:
  1522. TInt* iFirstDelta;
  1523. };
  1524. #line 375
  1525. template <class T>
  1526. class TSglQue : public TSglQueBase
  1527. {
  1528. public:
  1529. inline TSglQue();
  1530. inline explicit TSglQue(TInt aOffset);
  1531. inline void AddFirst(T& aRef);
  1532. inline void AddLast(T& aRef);
  1533. inline TBool IsFirst(const T* aPtr) const;
  1534. inline TBool IsLast(const T* aPtr) const;
  1535. inline T* First() const;
  1536. inline T* Last() const;
  1537. inline void Remove(T& aRef);
  1538. };
  1539. #line 407
  1540. template <class T>
  1541. class TDblQue : public TDblQueBase
  1542. {
  1543. public:
  1544. inline TDblQue();
  1545. inline explicit TDblQue(TInt aOffset);
  1546. inline void AddFirst(T& aRef);
  1547. inline void AddLast(T& aRef);
  1548. inline TBool IsHead(const T* aPtr) const;
  1549. inline TBool IsFirst(const T* aPtr) const;
  1550. inline TBool IsLast(const T* aPtr) const;
  1551. inline T* First() const;
  1552. inline T* Last() const;
  1553. };
  1554. #line 441
  1555. template <class T>
  1556. class TPriQue : public TDblQueBase
  1557. {
  1558. public:
  1559. inline TPriQue();
  1560. inline explicit TPriQue(TInt aOffset);
  1561. inline void Add(T& aRef);
  1562. inline TBool IsHead(const T* aPtr) const;
  1563. inline TBool IsFirst(const T* aPtr) const;
  1564. inline TBool IsLast(const T* aPtr) const;
  1565. inline T* First() const;
  1566. inline T* Last() const;
  1567. };
  1568. #line 487
  1569. template <class T>
  1570. class TDeltaQue : public TDeltaQueBase
  1571. {
  1572. public:
  1573. inline TDeltaQue();
  1574. inline explicit TDeltaQue(TInt aOffset);
  1575. inline void Add(T& aRef,TInt aDelta);
  1576. inline void Remove(T& aRef);
  1577. inline T* RemoveFirst();
  1578. };
  1579. class TTickCountQueLink;
  1580. #line 520
  1581. class TTickCountQue : public TDblQueBase
  1582. {
  1583. public:
  1584. TTickCountQue();
  1585. void Add(TTickCountQueLink& aRef);
  1586. TTickCountQueLink* First() const;
  1587. TTickCountQueLink* RemoveFirst();
  1588. TTickCountQueLink* RemoveFirst(TUint aTickCount);
  1589. };
  1590. #line 543
  1591. class TSglQueIterBase
  1592. {
  1593. public:
  1594. __declspec(dllexport) void SetToFirst();
  1595. protected:
  1596. __declspec(dllexport) TSglQueIterBase(TSglQueBase& aQue);
  1597. __declspec(dllexport) TAny* DoPostInc();
  1598. __declspec(dllexport) TAny* DoCurrent();
  1599. __declspec(dllexport) void DoSet(TAny* aLink);
  1600. protected:
  1601. TInt iOffset;
  1602. TSglQueLink* iHead;
  1603. TSglQueLink* iNext;
  1604. };
  1605. #line 571
  1606. template <class T>
  1607. class TSglQueIter : public TSglQueIterBase
  1608. {
  1609. public:
  1610. inline TSglQueIter(TSglQueBase& aQue);
  1611. inline void Set(T& aLink);
  1612. inline operator T*();
  1613. inline T* operator++(TInt);
  1614. };
  1615. #line 594
  1616. class TDblQueIterBase
  1617. {
  1618. public:
  1619. __declspec(dllexport) void SetToFirst();
  1620. __declspec(dllexport) void SetToLast();
  1621. protected:
  1622. __declspec(dllexport) TDblQueIterBase(TDblQueBase& aQue);
  1623. __declspec(dllexport) TAny* DoPostInc();
  1624. __declspec(dllexport) TAny* DoPostDec();
  1625. __declspec(dllexport) TAny* DoCurrent();
  1626. __declspec(dllexport) void DoSet(TAny* aLink);
  1627. protected:
  1628. TInt iOffset;
  1629. TDblQueLinkBase* iHead;
  1630. TDblQueLinkBase* iNext;
  1631. };
  1632. #line 635
  1633. template <class T>
  1634. class TDblQueIter : public TDblQueIterBase
  1635. {
  1636. public:
  1637. inline TDblQueIter(TDblQueBase& aQue);
  1638. inline void Set(T& aLink);
  1639. inline operator T*();
  1640. inline T* operator++(TInt);
  1641. inline T* operator--(TInt);
  1642. };
  1643. #line 660
  1644. enum TKeyCmpText
  1645. {
  1646. ECmpNormal,
  1647. #line 682
  1648. ECmpNormal8,
  1649. #line 696
  1650. ECmpNormal16,
  1651. #line 706
  1652. ECmpFolded,
  1653. #line 717
  1654. ECmpFolded8,
  1655. #line 728
  1656. ECmpFolded16,
  1657. #line 738
  1658. ECmpCollated,
  1659. #line 749
  1660. ECmpCollated8,
  1661. #line 761
  1662. ECmpCollated16
  1663. };
  1664. #line 777
  1665. enum TKeyCmpNumeric
  1666. {
  1667. ECmpTInt8=((ECmpCollated16+1)<<1),
  1668. ECmpTInt16,
  1669. ECmpTInt32,
  1670. ECmpTInt,
  1671. ECmpTUint8,
  1672. ECmpTUint16,
  1673. ECmpTUint32,
  1674. ECmpTUint,
  1675. ECmpTInt64
  1676. };
  1677. #line 856
  1678. class TKey
  1679. {
  1680. public:
  1681. inline void SetPtr(const TAny* aPtr);
  1682. __declspec(dllexport) virtual TInt Compare(TInt aLeft,TInt aRight) const;
  1683. __declspec(dllexport) virtual TAny* At(TInt anIndex) const;
  1684. protected:
  1685. __declspec(dllexport) TKey();
  1686. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType);
  1687. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
  1688. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpNumeric aType);
  1689. protected:
  1690. TInt iKeyOffset;
  1691. TInt iKeyLength;
  1692. TInt iCmpType;
  1693. const TAny* iPtr;
  1694. };
  1695. #line 890
  1696. class TSwap
  1697. {
  1698. public:
  1699. __declspec(dllexport) TSwap();
  1700. __declspec(dllexport) virtual void Swap(TInt aLeft,TInt aRight) const;
  1701. };
  1702. #line 918
  1703. class TCharF : public TChar
  1704. {
  1705. public:
  1706. inline TCharF(TUint aChar);
  1707. inline TCharF(const TChar& aChar);
  1708. inline TCharF& operator=(TUint aChar);
  1709. inline TCharF& operator=(const TChar& aChar);
  1710. };
  1711. #line 937
  1712. class TCharLC : public TChar
  1713. {
  1714. public:
  1715. inline TCharLC(TUint aChar);
  1716. inline TCharLC(const TChar& aChar);
  1717. inline TCharLC& operator=(TUint aChar);
  1718. inline TCharLC& operator=(const TChar& aChar);
  1719. };
  1720. #line 956
  1721. class TCharUC : public TChar
  1722. {
  1723. public:
  1724. inline TCharUC(TUint aChar);
  1725. inline TCharUC(const TChar& aChar);
  1726. inline TCharUC& operator=(TUint aChar);
  1727. inline TCharUC& operator=(const TChar& aChar);
  1728. };
  1729. #line 982
  1730. class TRealFormat
  1731. {
  1732. public:
  1733. __declspec(dllexport) TRealFormat();
  1734. __declspec(dllexport) TRealFormat(TInt aWidth);
  1735. __declspec(dllexport) TRealFormat(TInt aWidth,TInt aDecimalPlaces);
  1736. public:
  1737. #line 1007
  1738. TInt iType;
  1739. TInt iWidth;
  1740. #line 1025
  1741. TInt iPlaces;
  1742. #line 1038
  1743. TChar iPoint;
  1744. #line 1051
  1745. TChar iTriad;
  1746. #line 1071
  1747. TInt iTriLen;
  1748. };
  1749. #line 1089
  1750. class TLexMark8
  1751. {
  1752. public:
  1753. inline TLexMark8();
  1754. private:
  1755. inline TLexMark8(const TUint8* aString);
  1756. const TUint8* iPtr;
  1757. friend class TLex8;
  1758. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  1759. };
  1760. class TRealX;
  1761. #line 1123
  1762. class TLex8
  1763. {
  1764. public:
  1765. __declspec(dllexport) TLex8();
  1766. inline TLex8(const TUint8* aString);
  1767. inline TLex8(const TDesC8& aDes);
  1768. inline TLex8& operator=(const TUint8* aString);
  1769. inline TLex8& operator=(const TDesC8& aDes);
  1770. inline TBool Eos() const;
  1771. inline void Mark(TLexMark8& aMark) const;
  1772. inline void Mark();
  1773. __declspec(dllexport) void Inc();
  1774. __declspec(dllexport) void Inc(TInt aNumber);
  1775. __declspec(dllexport) TChar Get();
  1776. __declspec(dllexport) TChar Peek() const;
  1777. __declspec(dllexport) void UnGet();
  1778. inline void UnGetToMark();
  1779. __declspec(dllexport) void UnGetToMark(const TLexMark8 aMark);
  1780. __declspec(dllexport) void SkipSpace();
  1781. inline void SkipAndMark(TInt aNumber);
  1782. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark8& aMark);
  1783. inline void SkipSpaceAndMark();
  1784. __declspec(dllexport) void SkipSpaceAndMark(TLexMark8& aMark);
  1785. __declspec(dllexport) void SkipCharacters();
  1786. inline TInt TokenLength() const;
  1787. __declspec(dllexport) TInt TokenLength(const TLexMark8 aMark) const;
  1788. __declspec(dllexport) TPtrC8 MarkedToken() const;
  1789. __declspec(dllexport) TPtrC8 MarkedToken(const TLexMark8 aMark) const;
  1790. __declspec(dllexport) TPtrC8 NextToken();
  1791. __declspec(dllexport) TPtrC8 Remainder() const;
  1792. __declspec(dllexport) TPtrC8 RemainderFromMark() const;
  1793. __declspec(dllexport) TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
  1794. __declspec(dllexport) TInt Offset() const;
  1795. inline TInt MarkedOffset() const;
  1796. __declspec(dllexport) TInt MarkedOffset(const TLexMark8 aMark) const;
  1797. __declspec(dllexport) TInt Val(TInt8& aVal);
  1798. __declspec(dllexport) TInt Val(TInt16& aVal);
  1799. __declspec(dllexport) TInt Val(TInt32& aVal);
  1800. __declspec(dllexport) TInt Val(TInt64& aVal);
  1801. inline TInt Val(TInt& aVal);
  1802. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  1803. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  1804. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  1805. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  1806. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  1807. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  1808. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  1809. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  1810. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  1811. __declspec(dllexport) TInt Val(TReal32& aVal);
  1812. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  1813. __declspec(dllexport) TInt Val(TReal64& aVal);
  1814. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  1815. inline void Assign(const TLex8& aLex);
  1816. __declspec(dllexport) void Assign(const TUint8* aString);
  1817. __declspec(dllexport) void Assign(const TDesC8& aDes);
  1818. TInt Val(TRealX& aVal);
  1819. TInt Val(TRealX& aVal, TChar aPoint);
  1820. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  1821. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  1822. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  1823. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  1824. private:
  1825. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  1826. void ScndigAfterPoint(TInt& aSig,TInt64& aDl);
  1827. void ValidateMark(const TLexMark8 aMark) const;
  1828. private:
  1829. const TUint8* iNext;
  1830. const TUint8* iBuf;
  1831. const TUint8* iEnd;
  1832. TLexMark8 iMark;
  1833. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  1834. };
  1835. #line 1220
  1836. class TLexMark16
  1837. {
  1838. public:
  1839. inline TLexMark16();
  1840. private:
  1841. inline TLexMark16(const TUint16* aString);
  1842. const TUint16* iPtr;
  1843. friend class TLex16;
  1844. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  1845. };
  1846. #line 1253
  1847. class TLex16
  1848. {
  1849. public:
  1850. __declspec(dllexport) TLex16();
  1851. inline TLex16(const TUint16* aString);
  1852. inline TLex16(const TDesC16& aDes);
  1853. inline TLex16& operator=(const TUint16* aString);
  1854. inline TLex16& operator=(const TDesC16& aDes);
  1855. inline TBool Eos() const;
  1856. inline void Mark();
  1857. inline void Mark(TLexMark16& aMark) const;
  1858. __declspec(dllexport) void Inc();
  1859. __declspec(dllexport) void Inc(TInt aNumber);
  1860. __declspec(dllexport) TChar Get();
  1861. __declspec(dllexport) TChar Peek() const;
  1862. __declspec(dllexport) void UnGet();
  1863. inline void UnGetToMark();
  1864. __declspec(dllexport) void UnGetToMark(const TLexMark16 aMark);
  1865. __declspec(dllexport) void SkipSpace();
  1866. inline void SkipAndMark(TInt aNumber);
  1867. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark16& aMark);
  1868. __declspec(dllexport) void SkipSpaceAndMark(TLexMark16& aMark);
  1869. inline void SkipSpaceAndMark();
  1870. __declspec(dllexport) void SkipCharacters();
  1871. inline TInt TokenLength() const;
  1872. __declspec(dllexport) TInt TokenLength(const TLexMark16 aMark) const;
  1873. __declspec(dllexport) TPtrC16 MarkedToken() const;
  1874. __declspec(dllexport) TPtrC16 MarkedToken(const TLexMark16 aMark) const;
  1875. __declspec(dllexport) TPtrC16 NextToken();
  1876. __declspec(dllexport) TPtrC16 Remainder() const;
  1877. __declspec(dllexport) TPtrC16 RemainderFromMark() const;
  1878. __declspec(dllexport) TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
  1879. __declspec(dllexport) TInt Offset() const;
  1880. inline TInt MarkedOffset() const;
  1881. __declspec(dllexport) TInt MarkedOffset(const TLexMark16 aMark) const;
  1882. __declspec(dllexport) TInt Val(TInt8& aVal);
  1883. __declspec(dllexport) TInt Val(TInt16& aVal);
  1884. __declspec(dllexport) TInt Val(TInt32& aVal);
  1885. __declspec(dllexport) TInt Val(TInt64& aVal);
  1886. inline TInt Val(TInt& aVal);
  1887. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  1888. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  1889. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  1890. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  1891. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  1892. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  1893. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  1894. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  1895. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  1896. __declspec(dllexport) TInt Val(TReal32& aVal);
  1897. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  1898. __declspec(dllexport) TInt Val(TReal64& aVal);
  1899. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  1900. inline void Assign(const TLex16& aLex);
  1901. __declspec(dllexport) void Assign(const TUint16* aString);
  1902. __declspec(dllexport) void Assign(const TDesC16& aDes);
  1903. TInt Val(TRealX& aVal);
  1904. TInt Val(TRealX& aVal, TChar aPoint);
  1905. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  1906. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  1907. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  1908. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  1909. private:
  1910. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  1911. void ValidateMark(const TLexMark16 aMark) const;
  1912. private:
  1913. const TUint16* iNext;
  1914. const TUint16* iBuf;
  1915. const TUint16* iEnd;
  1916. TLexMark16 iMark;
  1917. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  1918. };
  1919. #line 1355
  1920. typedef TLex16 TLex;
  1921. #line 1373
  1922. typedef TLexMark16 TLexMark;
  1923. #line 1430
  1924. class TCheckedUid
  1925. {
  1926. public:
  1927. __declspec(dllexport) TCheckedUid();
  1928. __declspec(dllexport) TCheckedUid(const TUidType& aUidType);
  1929. __declspec(dllexport) TCheckedUid(const TDesC8& aPtr);
  1930. __declspec(dllexport) void Set(const TUidType& aUidType);
  1931. __declspec(dllexport) void Set(const TDesC8& aPtr);
  1932. __declspec(dllexport) TPtrC8 Des() const;
  1933. inline const TUidType& UidType() const;
  1934. protected:
  1935. __declspec(dllexport) TUint Check() const;
  1936. private:
  1937. TUidType iType;
  1938. TUint iCheck;
  1939. };
  1940. #line 1469
  1941. class TDateTime
  1942. {
  1943. public:
  1944. inline TDateTime();
  1945. __declspec(dllexport) TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  1946. __declspec(dllexport) TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  1947. __declspec(dllexport) TInt SetYear(TInt aYear);
  1948. __declspec(dllexport) TInt SetYearLeapCheck(TInt aYear);
  1949. __declspec(dllexport) TInt SetMonth(TMonth aMonth);
  1950. __declspec(dllexport) TInt SetDay(TInt aDay);
  1951. __declspec(dllexport) TInt SetHour(TInt aHour);
  1952. __declspec(dllexport) TInt SetMinute(TInt aMinute);
  1953. __declspec(dllexport) TInt SetSecond(TInt aSecond);
  1954. __declspec(dllexport) TInt SetMicroSecond(TInt aMicroSecond);
  1955. inline TInt Year() const;
  1956. inline TMonth Month() const;
  1957. inline TInt Day() const;
  1958. inline TInt Hour() const;
  1959. inline TInt Minute() const;
  1960. inline TInt Second() const;
  1961. inline TInt MicroSecond() const;
  1962. private:
  1963. TInt iYear;
  1964. TMonth iMonth;
  1965. TInt iDay;
  1966. TInt iHour;
  1967. TInt iMinute;
  1968. TInt iSecond;
  1969. TInt iMicroSecond;
  1970. };
  1971. #line 1516
  1972. class TTimeIntervalMicroSeconds
  1973. {
  1974. public:
  1975. inline TTimeIntervalMicroSeconds();
  1976. inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
  1977. inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
  1978. inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
  1979. inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
  1980. inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
  1981. inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
  1982. inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
  1983. inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
  1984. inline const TInt64& Int64() const;
  1985. private:
  1986. TInt64 iInterval;
  1987. };
  1988. #line 1554
  1989. class TTimeIntervalBase
  1990. {
  1991. public:
  1992. inline TBool operator==(TTimeIntervalBase aInterval) const;
  1993. inline TBool operator!=(TTimeIntervalBase aInterval) const;
  1994. inline TBool operator>=(TTimeIntervalBase aInterval) const;
  1995. inline TBool operator<=(TTimeIntervalBase aInterval) const;
  1996. inline TBool operator>(TTimeIntervalBase aInterval) const;
  1997. inline TBool operator<(TTimeIntervalBase aInterval) const;
  1998. inline TInt Int() const;
  1999. protected:
  2000. inline TTimeIntervalBase();
  2001. inline TTimeIntervalBase(TInt aInterval);
  2002. protected:
  2003. TInt iInterval;
  2004. };
  2005. #line 1583
  2006. class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
  2007. {
  2008. public:
  2009. inline TTimeIntervalMicroSeconds32();
  2010. inline TTimeIntervalMicroSeconds32(TInt aInterval);
  2011. inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
  2012. };
  2013. #line 1606
  2014. class TTimeIntervalSeconds : public TTimeIntervalBase
  2015. {
  2016. public:
  2017. inline TTimeIntervalSeconds();
  2018. inline TTimeIntervalSeconds(TInt aInterval);
  2019. inline TTimeIntervalSeconds& operator=(TInt aInterval);
  2020. };
  2021. #line 1626
  2022. class TTimeIntervalMinutes : public TTimeIntervalBase
  2023. {
  2024. public:
  2025. inline TTimeIntervalMinutes();
  2026. inline TTimeIntervalMinutes(TInt aInterval);
  2027. inline TTimeIntervalMinutes& operator=(TInt aInterval);
  2028. };
  2029. #line 1646
  2030. class TTimeIntervalHours : public TTimeIntervalBase
  2031. {
  2032. public:
  2033. inline TTimeIntervalHours();
  2034. inline TTimeIntervalHours(TInt aInterval);
  2035. inline TTimeIntervalHours& operator=(TInt aInterval);
  2036. };
  2037. #line 1666
  2038. class TTimeIntervalDays : public TTimeIntervalBase
  2039. {
  2040. public:
  2041. inline TTimeIntervalDays();
  2042. inline TTimeIntervalDays(TInt aInterval);
  2043. inline TTimeIntervalDays& operator=(TInt aInterval);
  2044. };
  2045. #line 1686
  2046. class TTimeIntervalMonths : public TTimeIntervalBase
  2047. {
  2048. public:
  2049. inline TTimeIntervalMonths();
  2050. inline TTimeIntervalMonths(TInt aInterval);
  2051. inline TTimeIntervalMonths& operator=(TInt aInterval);
  2052. };
  2053. #line 1706
  2054. class TTimeIntervalYears : public TTimeIntervalBase
  2055. {
  2056. public:
  2057. inline TTimeIntervalYears();
  2058. inline TTimeIntervalYears(TInt aInterval);
  2059. inline TTimeIntervalYears& operator=(TInt aInterval);
  2060. };
  2061. #line 1725
  2062. enum {
  2063.      EParseTimePresent=0x1,
  2064.      EParseDatePresent=0x2
  2065.      };
  2066. #line 1770
  2067. class TTime
  2068. {
  2069. public:
  2070. inline TTime();
  2071. inline TTime(const TInt64& aTime);
  2072. __declspec(dllexport) TTime(const TDesC& aString);
  2073. __declspec(dllexport) TTime(const TDateTime& aDateTime);
  2074. inline TTime& operator=(const TInt64& aTime);
  2075. __declspec(dllexport) TTime& operator=(const TDateTime& aDateTime);
  2076. __declspec(dllexport) void HomeTime();
  2077. __declspec(dllexport) void UniversalTime();
  2078. __declspec(dllexport) TInt Set(const TDesC& aString);
  2079. __declspec(dllexport) TDateTime DateTime() const;
  2080. __declspec(dllexport) TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;
  2081. __declspec(dllexport) TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;
  2082. __declspec(dllexport) TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;
  2083. __declspec(dllexport) TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;
  2084. __declspec(dllexport) TTimeIntervalDays DaysFrom(TTime aTime) const;
  2085. __declspec(dllexport) TTimeIntervalMonths MonthsFrom(TTime aTime) const;
  2086. __declspec(dllexport) TTimeIntervalYears YearsFrom(TTime aTime) const;
  2087. __declspec(dllexport) TInt DaysInMonth() const;
  2088. __declspec(dllexport) TDay DayNoInWeek() const;
  2089. __declspec(dllexport) TInt DayNoInMonth() const;
  2090. __declspec(dllexport) TInt DayNoInYear() const;
  2091. __declspec(dllexport) TInt DayNoInYear(TTime aStartDate) const;
  2092. __declspec(dllexport) TInt WeekNoInYear() const;
  2093. __declspec(dllexport) TInt WeekNoInYear(TTime aStartDate) const;
  2094. __declspec(dllexport) TInt WeekNoInYear(TFirstWeekRule aRule) const;
  2095. __declspec(dllexport) TInt WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const;
  2096. __declspec(dllexport) void FormatL(TDes& aDes,const TDesC& aFormat) const;
  2097. __declspec(dllexport) void RoundUpToNextMinute();
  2098. __declspec(dllexport) TInt Parse(const TDesC& aDes,TInt aCenturyOffset=0);
  2099. __declspec(dllexport) TTime operator+(TTimeIntervalYears aYear) const;
  2100. __declspec(dllexport) TTime operator+(TTimeIntervalMonths aMonth) const;
  2101. __declspec(dllexport) TTime operator+(TTimeIntervalDays aDay) const;
  2102. __declspec(dllexport) TTime operator+(TTimeIntervalHours aHour) const;
  2103. __declspec(dllexport) TTime operator+(TTimeIntervalMinutes aMinute) const;
  2104. __declspec(dllexport) TTime operator+(TTimeIntervalSeconds aSecond) const;
  2105. __declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds aMicroSecond) const;
  2106. __declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const;
  2107. __declspec(dllexport) TTime operator-(TTimeIntervalYears aYear) const;
  2108. __declspec(dllexport) TTime operator-(TTimeIntervalMonths aMonth) const;
  2109. __declspec(dllexport) TTime operator-(TTimeIntervalDays aDay) const;
  2110. __declspec(dllexport) TTime operator-(TTimeIntervalHours aHour) const;
  2111. __declspec(dllexport) TTime operator-(TTimeIntervalMinutes aMinute) const;
  2112. __declspec(dllexport) TTime operator-(TTimeIntervalSeconds aSecond) const;
  2113. __declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds aMicroSecond) const;
  2114. __declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const;
  2115. __declspec(dllexport) TTime& operator+=(TTimeIntervalYears aYear);
  2116. __declspec(dllexport) TTime& operator+=(TTimeIntervalMonths aMonth);
  2117. __declspec(dllexport) TTime& operator+=(TTimeIntervalDays aDay);
  2118. __declspec(dllexport) TTime& operator+=(TTimeIntervalHours aHour);
  2119. __declspec(dllexport) TTime& operator+=(TTimeIntervalMinutes aMinute);
  2120. __declspec(dllexport) TTime& operator+=(TTimeIntervalSeconds aSecond);
  2121. __declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds aMicroSecond);
  2122. __declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds32 aMicroSecond);
  2123. __declspec(dllexport) TTime& operator-=(TTimeIntervalYears aYear);
  2124. __declspec(dllexport) TTime& operator-=(TTimeIntervalMonths aMonth);
  2125. __declspec(dllexport) TTime& operator-=(TTimeIntervalDays aDay);
  2126. __declspec(dllexport) TTime& operator-=(TTimeIntervalHours aHour);
  2127. __declspec(dllexport) TTime& operator-=(TTimeIntervalMinutes aMinute);
  2128. __declspec(dllexport) TTime& operator-=(TTimeIntervalSeconds aSecond);
  2129. __declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds aMicroSecond);
  2130. __declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds32 aMicroSecond);
  2131. inline TBool operator==(TTime aTime) const;
  2132. inline TBool operator!=(TTime aTime) const;
  2133. inline TBool operator>=(TTime aTime) const;
  2134. inline TBool operator<=(TTime aTime) const;
  2135. inline TBool operator>(TTime aTime) const;
  2136. inline TBool operator<(TTime aTime) const;
  2137. inline const TInt64& Int64() const;
  2138. private:
  2139. static TTime Convert(const TDateTime& aDateTime);
  2140. private:
  2141. TInt64 iTime;
  2142. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  2143. };
  2144. #line 1861
  2145. class Time
  2146. {
  2147. public:
  2148. __declspec(dllexport) static TTime NullTTime();
  2149. __declspec(dllexport) static TTime MaxTTime();
  2150. __declspec(dllexport) static TTime MinTTime();
  2151. __declspec(dllexport) static TInt DaysInMonth(TInt aYear, TMonth aMonth);
  2152. __declspec(dllexport) static TBool IsLeapYear(TInt aYear);
  2153. __declspec(dllexport) static TInt LeapYearsUpTo(TInt aYear);
  2154. };
  2155. #line 1887
  2156. class TDayName : public TBuf<KMaxDayName>
  2157. {
  2158. public:
  2159. __declspec(dllexport) TDayName();
  2160. __declspec(dllexport) TDayName(TDay aDay);
  2161. __declspec(dllexport) void Set(TDay aDay);
  2162. };
  2163. #line 1915
  2164. class TDayNameAbb : public TBuf<KMaxDayNameAbb>
  2165. {
  2166. public:
  2167. __declspec(dllexport) TDayNameAbb();
  2168. __declspec(dllexport) TDayNameAbb(TDay aDay);
  2169. __declspec(dllexport) void Set(TDay aDay);
  2170. };
  2171. #line 1938
  2172. class TMonthName : public TBuf<KMaxMonthName>
  2173. {
  2174. public:
  2175. __declspec(dllexport) TMonthName();
  2176. __declspec(dllexport) TMonthName(TMonth aMonth);
  2177. __declspec(dllexport) void Set(TMonth aMonth);
  2178. };
  2179. #line 1961
  2180. class TMonthNameAbb : public TBuf<KMaxMonthNameAbb>
  2181. {
  2182. public:
  2183. __declspec(dllexport) TMonthNameAbb();
  2184. __declspec(dllexport) TMonthNameAbb(TMonth aMonth);
  2185. __declspec(dllexport) void Set(TMonth aMonth);
  2186. };
  2187. #line 1986
  2188. class TDateSuffix : public TBuf<KMaxSuffix>
  2189. {
  2190. public:
  2191. __declspec(dllexport) TDateSuffix();
  2192. __declspec(dllexport) TDateSuffix(TInt aDateSuffix);
  2193. __declspec(dllexport) void Set(TInt aDateSuffix);
  2194. };
  2195. #line 2010
  2196. class TAmPmName : public TBuf<KMaxAmPmName>
  2197. {
  2198. public:
  2199. __declspec(dllexport) TAmPmName();
  2200. __declspec(dllexport) TAmPmName(TAmPm aSelector);
  2201. __declspec(dllexport) void Set(TAmPm aSelector);
  2202. };
  2203. #line 2031
  2204. class TCurrencySymbol : public TBuf<KMaxCurrencySymbol>
  2205. {
  2206. public:
  2207. __declspec(dllexport) TCurrencySymbol();
  2208. __declspec(dllexport) void Set();
  2209. };
  2210. #line 2067
  2211. class TShortDateFormatSpec : public TBuf<KMaxShortDateFormatSpec>
  2212. {
  2213. public:
  2214. __declspec(dllexport) TShortDateFormatSpec();
  2215. __declspec(dllexport) void Set();
  2216. };
  2217. #line 2103
  2218. class TLongDateFormatSpec : public TBuf<KMaxLongDateFormatSpec>
  2219. {
  2220. public:
  2221. __declspec(dllexport) TLongDateFormatSpec();
  2222. __declspec(dllexport) void Set();
  2223. };
  2224. #line 2136
  2225. class TTimeFormatSpec : public TBuf<KMaxTimeFormatSpec>
  2226. {
  2227. public:
  2228. __declspec(dllexport) TTimeFormatSpec();
  2229. __declspec(dllexport) void Set();
  2230. };
  2231. #line 2156
  2232. class TLocale
  2233. {
  2234. public:
  2235. enum TNegativeCurrencyFormat
  2236. {
  2237. ELeadingMinusSign,
  2238. EInBrackets,
  2239. ETrailingMinusSign,
  2240. EInterveningMinusSign
  2241. };
  2242. enum
  2243. {
  2244. EFlagNegativeLoseSpace = 0x00000001,
  2245. EFlagNegativeCurrencySymbolOpposite=0x00000002
  2246. };
  2247. enum TDeviceTimeState
  2248. {
  2249. EDeviceUserTime,
  2250. ENITZNetworkTimeSync
  2251. };
  2252. public:
  2253. __declspec(dllexport) TLocale();
  2254. inline TLocale(TInt);
  2255. __declspec(dllexport) void Refresh();
  2256. __declspec(dllexport) TInt Set() const;
  2257. __declspec(dllexport) void FormatCurrency(TDes& aText, TInt aAmount);
  2258. __declspec(dllexport) void FormatCurrency(TDes& aText, TInt64 aAmount);
  2259. __declspec(dllexport) void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt aAmount);
  2260. __declspec(dllexport) void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt64 aAmount);
  2261. inline TInt CountryCode() const;
  2262. inline void SetCountryCode(TInt aCode);
  2263. inline TTimeIntervalSeconds UniversalTimeOffset() const;
  2264. inline TDateFormat DateFormat() const;
  2265. inline void SetDateFormat(TDateFormat aFormat);
  2266. inline TTimeFormat TimeFormat() const;
  2267. inline void SetTimeFormat(TTimeFormat aFormat);
  2268. inline TLocalePos CurrencySymbolPosition() const;
  2269. inline void SetCurrencySymbolPosition(TLocalePos aPos);
  2270. inline TBool CurrencySpaceBetween() const;
  2271. inline void SetCurrencySpaceBetween(TBool aSpace);
  2272. inline TInt CurrencyDecimalPlaces() const;
  2273. inline void SetCurrencyDecimalPlaces(TInt aPlaces);
  2274. inline TBool CurrencyNegativeInBrackets() const;
  2275. inline void SetCurrencyNegativeInBrackets(TBool aBool);
  2276.   inline TBool CurrencyTriadsAllowed() const;
  2277. inline void SetCurrencyTriadsAllowed(TBool aBool);
  2278. inline TChar ThousandsSeparator() const;
  2279. inline void SetThousandsSeparator(const TChar& aChar);
  2280. inline TChar DecimalSeparator() const;
  2281. inline void SetDecimalSeparator(const TChar& aChar);
  2282. inline TChar DateSeparator(TInt aIndex) const;
  2283. inline void SetDateSeparator(const TChar& aChar,TInt aIndex);
  2284. inline TChar TimeSeparator(TInt aIndex) const;
  2285. inline void SetTimeSeparator(const TChar& aChar,TInt aIndex);
  2286. inline TBool AmPmSpaceBetween() const;
  2287. inline void SetAmPmSpaceBetween(TBool aSpace);
  2288. inline TLocalePos AmPmSymbolPosition() const;
  2289. inline void SetAmPmSymbolPosition(TLocalePos aPos);
  2290. inline TUint DaylightSaving() const;
  2291. inline TBool QueryHomeHasDaylightSavingOn() const;
  2292. inline TDaylightSavingZone HomeDaylightSavingZone() const;
  2293. inline TUint WorkDays() const;
  2294. inline void SetWorkDays(TUint aMask);
  2295. inline TDay StartOfWeek() const;
  2296. inline void SetStartOfWeek(TDay aDay);
  2297. inline TClockFormat ClockFormat() const;
  2298. inline void SetClockFormat(TClockFormat aFormat);
  2299. inline TUnitsFormat UnitsGeneral() const;
  2300. inline void SetUnitsGeneral(TUnitsFormat aFormat);
  2301. inline TUnitsFormat UnitsDistanceShort() const;
  2302. inline void SetUnitsDistanceShort(TUnitsFormat aFormat);
  2303. inline TUnitsFormat UnitsDistanceLong() const;
  2304. inline void SetUnitsDistanceLong(TUnitsFormat aFormat);
  2305. inline TNegativeCurrencyFormat NegativeCurrencyFormat() const;
  2306. inline void SetNegativeCurrencyFormat(TNegativeCurrencyFormat aNegativeCurrencyFormat);
  2307. inline TBool NegativeLoseSpace() const;
  2308. inline void SetNegativeLoseSpace(TBool aBool);
  2309. inline TBool NegativeCurrencySymbolOpposite() const;
  2310. inline void SetNegativeCurrencySymbolOpposite(TBool aBool);
  2311. inline TLanguage LanguageDowngrade(TInt aIndex) const;
  2312. inline void SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage);
  2313. inline TDigitType DigitType() const;
  2314. inline void SetDigitType(TDigitType aDigitType);
  2315. inline TDeviceTimeState DeviceTime() const;
  2316.   inline void SetDeviceTime(TDeviceTimeState aState);
  2317. void SetDefaults();
  2318. private:
  2319. friend class TExtendedLocale;
  2320. private:
  2321. TInt iCountryCode;
  2322. TTimeIntervalSeconds iUniversalTimeOffset;
  2323. TDateFormat iDateFormat;
  2324. TTimeFormat iTimeFormat;
  2325. TLocalePos iCurrencySymbolPosition;
  2326. TBool iCurrencySpaceBetween;
  2327. TInt iCurrencyDecimalPlaces;
  2328. TNegativeCurrencyFormat iNegativeCurrencyFormat;
  2329. TBool iCurrencyTriadsAllowed;
  2330. TChar iThousandsSeparator;
  2331. TChar iDecimalSeparator;
  2332. TChar iDateSeparator[KMaxDateSeparators];
  2333. TChar iTimeSeparator[KMaxTimeSeparators];
  2334. TLocalePos iAmPmSymbolPosition;
  2335. TBool iAmPmSpaceBetween;
  2336. TUint iDaylightSaving;
  2337. TDaylightSavingZone iHomeDaylightSavingZone;
  2338. TUint iWorkDays;
  2339. TDay iStartOfWeek;
  2340. TClockFormat iClockFormat;
  2341. TUnitsFormat iUnitsGeneral;
  2342. TUnitsFormat iUnitsDistanceShort;
  2343. TUnitsFormat iUnitsDistanceLong;
  2344. TUint iExtraNegativeCurrencyFormatFlags;
  2345. TUint16 iLanguageDowngrade[3];
  2346. TUint16 iSpare16;
  2347. TDigitType iDigitType;
  2348.   TDeviceTimeState iDeviceTimeState;
  2349.   TInt iSpare[0x1E];
  2350. };
  2351. const TUint KLocaleLanguageKey = 0x10208903;
  2352. const TUint KLocaleDataKey = 0x10208904;
  2353. const TUint KLocaleDataExtraKey = 0x10208905;
  2354. const TUint KLocaleTimeDateFormatKey = 0x10208907;
  2355. const TUint KLocaleDefaultCharSetKey = 0x10208908;
  2356. const TUint KLocalePreferredCharSetKey = 0x10208909;
  2357. enum TLocaleFunctions
  2358. {
  2359. FnDummy,
  2360. FnAmPmTable,
  2361. FnCharSet,
  2362. FnCollTable,
  2363. FnCurrencySymbol,
  2364. FnDateSuffixTable,
  2365. FnDayAbbTable,
  2366. FnDayTable,
  2367. FnFoldTable,
  2368. FnLanguage,
  2369. FnLocaleData,
  2370. FnLowerTable,
  2371. FnMonthAbbTable,
  2372. FnMonthTable,
  2373. FnMsgTable,
  2374. FnTypeTable,
  2375. FnUniCode,
  2376. FnUpperTable,
  2377. FnShortDateFormatSpec,
  2378. FnLongDateFormatSpec,
  2379. FnTimeFormatSpec,
  2380. FnFatUtilityFunctions
  2381. };
  2382. #line 2407
  2383. enum TLocaleAspect
  2384. {
  2385. ELocaleLanguageSettings = 0x01,
  2386. ELocaleCollateSetting = 0x02,
  2387. ELocaleLocaleSettings = 0x04,
  2388. ELocaleTimeDateSettings = 0x08,
  2389. };
  2390. struct SLocaleLanguage
  2391. {
  2392. TLanguage  iLanguage;
  2393. const TText* iDateSuffixTable;
  2394. const TText* iDayTable;
  2395. const TText* iDayAbbTable;
  2396. const TText* iMonthTable;
  2397. const TText* iMonthAbbTable;
  2398. const TText* iAmPmTable;
  2399. const TText16* const* iMsgTable;
  2400. };
  2401. struct SLocaleLocaleSettings
  2402. {
  2403. TText iCurrencySymbol[KMaxCurrencySymbol+1];
  2404. TAny* iLocaleExtraSettingsDllPtr;
  2405. };
  2406. struct SLocaleTimeDateFormat
  2407. {
  2408. TText iShortDateFormatSpec[KMaxShortDateFormatSpec+1];
  2409. TText iLongDateFormatSpec[KMaxLongDateFormatSpec+1];
  2410. TText iTimeFormatSpec[KMaxTimeFormatSpec+1];
  2411. TAny* iLocaleTimeDateFormatDllPtr;
  2412. };
  2413. struct LCharSet;
  2414. #line 2462
  2415. class TExtendedLocale
  2416. {
  2417. public:
  2418. __declspec(dllexport) TExtendedLocale();
  2419. __declspec(dllexport) void LoadSystemSettings();
  2420. __declspec(dllexport) TInt SaveSystemSettings();
  2421. __declspec(dllexport) TInt LoadLocale(const TDesC& aLocaleDllName);
  2422. #line 2488
  2423. __declspec(dllexport) TInt LoadLocaleAspect(TUint aAspectGroup, const TDesC& aLocaleDllName);
  2424. __declspec(dllexport) TInt SetCurrencySymbol(const TDesC &aSymbol);
  2425. __declspec(dllexport) TInt GetLocaleDllName(TLocaleAspect aLocaleDataSet, TDes& aDllName);
  2426. __declspec(dllexport) TCollationMethod GetPreferredCollationMethod(TInt index = 0) ;
  2427. inline TLocale* GetLocale();
  2428. private:
  2429. TInt DoLoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList);
  2430. void DoUpdateLanguageSettings(TLibraryFunction* aExportList);
  2431. void DoUpdateLocaleSettings(TLibraryFunction* aExportList);
  2432. void DoUpdateTimeDateFormat(TLibraryFunction* aExportList);
  2433. private:
  2434. TLocale iLocale;
  2435. SLocaleLanguage iLanguageSettings;
  2436. SLocaleLocaleSettings iLocaleExtraSettings;
  2437. SLocaleTimeDateFormat iLocaleTimeDateFormat;
  2438. const LCharSet* iDefaultCharSet;
  2439. const LCharSet* iPreferredCharSet;
  2440. };
  2441. #line 2544
  2442. class TRect
  2443. {
  2444. public:
  2445. enum TUninitialized { EUninitialized };
  2446. TRect(TUninitialized) {}
  2447. __declspec(dllexport) TRect();
  2448. __declspec(dllexport) TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
  2449. __declspec(dllexport) TRect(const TPoint& aPointA,const TPoint& aPointB);
  2450. __declspec(dllexport) TRect(const TPoint& aPoint,const TSize& aSize);
  2451. __declspec(dllexport) TRect(const TSize& aSize);
  2452. __declspec(dllexport) TBool operator==(const TRect& aRect) const;
  2453. __declspec(dllexport) TBool operator!=(const TRect& aRect) const;
  2454. __declspec(dllexport) void SetRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
  2455. __declspec(dllexport) void SetRect(const TPoint& aPointTL,const TPoint& aPointBR);
  2456. __declspec(dllexport) void SetRect(const TPoint& aPoint,const TSize& aSize);
  2457. __declspec(dllexport) void Move(TInt aDx,TInt aDy);
  2458. __declspec(dllexport) void Move(const TPoint& aOffset);
  2459. __declspec(dllexport) void Resize(TInt aDx,TInt aDy);
  2460. __declspec(dllexport) void Resize(const TSize& aSize);
  2461. __declspec(dllexport) void Shrink(TInt aDx,TInt aDy);
  2462. __declspec(dllexport) void Shrink(const TSize& aSize);
  2463. __declspec(dllexport) void Grow(TInt aDx,TInt aDy);
  2464. __declspec(dllexport) void Grow(const TSize& aSize);
  2465. __declspec(dllexport) void BoundingRect(const TRect& aRect);
  2466. __declspec(dllexport) TBool IsEmpty() const;
  2467. __declspec(dllexport) TBool Intersects(const TRect& aRect) const;
  2468. __declspec(dllexport) void Intersection(const TRect& aRect);
  2469. __declspec(dllexport) void Normalize();
  2470. __declspec(dllexport) TBool Contains(const TPoint& aPoint) const;
  2471. __declspec(dllexport) TSize Size() const;
  2472. __declspec(dllexport) TInt Width() const;
  2473. __declspec(dllexport) TInt Height() const;
  2474. __declspec(dllexport) TBool IsNormalized() const;
  2475. __declspec(dllexport) TPoint Center() const;
  2476. __declspec(dllexport) void SetSize(const TSize& aSize);
  2477. __declspec(dllexport) void SetWidth(TInt aWidth);
  2478. __declspec(dllexport) void SetHeight(TInt aHeight);
  2479. private:
  2480. void Adjust(TInt aDx,TInt aDy);
  2481. public:
  2482. TPoint iTl;
  2483. TPoint iBr;
  2484. };
  2485. #line 2646
  2486. class TRegion
  2487. {
  2488. public:
  2489. inline TInt Count() const;
  2490. inline const TRect* RectangleList() const;
  2491. inline TBool CheckError() const;
  2492. __declspec(dllexport) TBool IsEmpty() const;
  2493. __declspec(dllexport) TRect BoundingRect() const;
  2494. __declspec(dllexport) const TRect& operator[](TInt aIndex) const;
  2495. __declspec(dllexport) void Copy(const TRegion& aRegion);
  2496. __declspec(dllexport) void AddRect(const TRect& aRect);
  2497. __declspec(dllexport) void SubRect(const TRect& aRect,TRegion* aSubtractedRegion=0 );
  2498. __declspec(dllexport) void Offset(TInt aXoffset,TInt aYoffset);
  2499. __declspec(dllexport) void Offset(const TPoint& aOffset);
  2500. __declspec(dllexport) void Union(const TRegion& aRegion);
  2501. __declspec(dllexport) void Intersection(const TRegion& aRegion,const TRegion& aRegion2);
  2502. __declspec(dllexport) void Intersect(const TRegion& aRegion);
  2503. __declspec(dllexport) void SubRegion(const TRegion& aRegion,TRegion* aSubtractedRegion=0 );
  2504. __declspec(dllexport) void ClipRect(const TRect& aRect);
  2505. __declspec(dllexport) void Clear();
  2506. __declspec(dllexport) void Tidy();
  2507. __declspec(dllexport) TInt Sort();
  2508. __declspec(dllexport) TInt Sort(const TPoint& aOffset);
  2509. __declspec(dllexport) void ForceError();
  2510. __declspec(dllexport) TBool IsContainedBy(const TRect& aRect) const;
  2511. __declspec(dllexport) TBool Contains(const TPoint& aPoint) const;
  2512. protected:
  2513. __declspec(dllexport) TRect* RectangleListW();
  2514. __declspec(dllexport) TRegion(TInt aAllocedRects);
  2515. inline TRegion();
  2516. TBool SetListSize(TInt aCount);
  2517. void AppendRect(const TRect& aRect);
  2518. void DeleteRect(TRect* aRect);
  2519. void AppendRegion(TRegion& aRegion);
  2520. protected:
  2521. TInt iCount;
  2522. TBool iError;
  2523. TInt iAllocedRects;
  2524. protected:
  2525. enum {ERRegionBuf=0x40000000};
  2526. };
  2527. #line 2703
  2528. class RRegion : public TRegion
  2529. {
  2530. private:
  2531. enum {EDefaultGranularity=5};
  2532. protected:
  2533. __declspec(dllexport) RRegion(TInt aBuf,TInt aGran);
  2534. public:
  2535. __declspec(dllexport) RRegion();
  2536. __declspec(dllexport) RRegion(TInt aGran);
  2537. __declspec(dllexport) RRegion(const RRegion& aRegion);
  2538. __declspec(dllexport) RRegion(const TRect& aRect,TInt aGran=EDefaultGranularity);
  2539. __declspec(dllexport) RRegion(TInt aCount,TRect* aRectangleList,TInt aGran=EDefaultGranularity);
  2540. __declspec(dllexport) void Close();
  2541. __declspec(dllexport) void Destroy();
  2542. inline TInt CheckSpare() const;
  2543. private:
  2544. TInt iGranularity;
  2545. TRect* iRectangleList;
  2546. friend class TRegion;
  2547. };
  2548. #line 2744
  2549. template <TInt S>
  2550. class RRegionBuf : public RRegion
  2551. {
  2552. public:
  2553. inline RRegionBuf();
  2554. inline RRegionBuf(const RRegion& aRegion);
  2555. inline RRegionBuf(const RRegionBuf<S>& aRegion);
  2556. inline RRegionBuf(const TRect& aRect);
  2557. private:
  2558. TInt8 iRectangleBuf[S*sizeof(TRect)];
  2559. };
  2560. #line 2774
  2561. template <TInt S>
  2562. class TRegionFix : public TRegion
  2563. {
  2564. public:
  2565. inline TRegionFix();
  2566. inline TRegionFix(const TRect& aRect);
  2567. inline TRegionFix(const TRegionFix<S>& aRegion);
  2568. private:
  2569. TInt8 iRectangleBuf[S*sizeof(TRect)];
  2570. };
  2571. #line 2806
  2572. class TFindHandleBase
  2573. {
  2574. public:
  2575. __declspec(dllexport) TFindHandleBase();
  2576. __declspec(dllexport) TFindHandleBase(const TDesC& aMatch);
  2577. __declspec(dllexport) void Find(const TDesC& aMatch);
  2578. inline TInt Handle() const;
  2579. protected:
  2580. TInt NextObject(TFullName& aResult,TInt aObjectType);
  2581. private:
  2582. TInt iFindHandle;
  2583. TInt iSpare1;
  2584. TInt iSpare2;
  2585. TInt iSpare3;
  2586. TFullName iMatch;
  2587. };
  2588. #line 2859
  2589. class TFindSemaphore : public TFindHandleBase
  2590. {
  2591. public:
  2592. inline TFindSemaphore();
  2593. inline TFindSemaphore(const TDesC& aMatch);
  2594. __declspec(dllexport) TInt Next(TFullName& aResult);
  2595. };
  2596. #line 2895
  2597. class TFindMutex : public TFindHandleBase
  2598. {
  2599. public:
  2600. inline TFindMutex();
  2601. inline TFindMutex(const TDesC& aMatch);
  2602. __declspec(dllexport) TInt Next(TFullName& aResult);
  2603. };
  2604. #line 2922
  2605. class TFindChunk : public TFindHandleBase
  2606. {
  2607. public:
  2608. inline TFindChunk();
  2609. inline TFindChunk(const TDesC& aMatch);
  2610. __declspec(dllexport) TInt Next(TFullName& aResult);
  2611. };
  2612. #line 2952
  2613. class TFindThread : public TFindHandleBase
  2614. {
  2615. public:
  2616. inline TFindThread();
  2617. inline TFindThread(const TDesC& aMatch);
  2618. __declspec(dllexport) TInt Next(TFullName& aResult);
  2619. };
  2620. #line 2981
  2621. class TFindProcess : public TFindHandleBase
  2622. {
  2623. public:
  2624. inline TFindProcess();
  2625. inline TFindProcess(const TDesC& aMatch);
  2626. __declspec(dllexport) TInt Next(TFullName& aResult);
  2627. };
  2628. #line 3010
  2629. class TFindLogicalDevice : public TFindHandleBase
  2630. {
  2631. public:
  2632. inline TFindLogicalDevice();
  2633. inline TFindLogicalDevice(const TDesC& aMatch);
  2634. __declspec(dllexport) TInt Next(TFullName& aResult);
  2635. };
  2636. #line 3037
  2637. class TFindPhysicalDevice : public TFindHandleBase
  2638. {
  2639. public:
  2640. inline TFindPhysicalDevice();
  2641. inline TFindPhysicalDevice(const TDesC& aMatch);
  2642. __declspec(dllexport) TInt Next(TFullName& aResult);
  2643. };
  2644. #line 3065
  2645. class TFindServer : public TFindHandleBase
  2646. {
  2647. public:
  2648. inline TFindServer();
  2649. inline TFindServer(const TDesC& aMatch);
  2650. __declspec(dllexport) TInt Next(TFullName& aResult);
  2651. };
  2652. #line 3089
  2653. class TFindLibrary : public TFindHandleBase
  2654. {
  2655. public:
  2656. inline TFindLibrary();
  2657. inline TFindLibrary(const TDesC& aMatch);
  2658. __declspec(dllexport) TInt Next(TFullName& aResult);
  2659. };
  2660. #line 3114
  2661. class RDevice : public RHandleBase
  2662. {
  2663. public:
  2664. inline TInt Open(const TFindLogicalDevice& aFind,TOwnerType aType=EOwnerProcess);
  2665. __declspec(dllexport) TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
  2666. __declspec(dllexport) void GetCaps(TDes8& aDes) const;
  2667. __declspec(dllexport) TBool QueryVersionSupported(const TVersion& aVer) const;
  2668. __declspec(dllexport) TBool IsAvailable(TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* anInfo) const;
  2669. };
  2670. #line 3154
  2671. class RTimer : public RHandleBase
  2672. {
  2673. public:
  2674. __declspec(dllexport) TInt CreateLocal();
  2675. __declspec(dllexport) void Cancel();
  2676. __declspec(dllexport) void After(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
  2677. __declspec(dllexport) void AfterTicks(TRequestStatus &aStatus, TInt aTicks);
  2678. __declspec(dllexport) void At(TRequestStatus& aStatus,const TTime& aTime);
  2679. __declspec(dllexport) void AtUTC(TRequestStatus& aStatus,const TTime& aUTCTime);
  2680. __declspec(dllexport) void Lock(TRequestStatus& aStatus,TTimerLockSpec aLock);
  2681. __declspec(dllexport) void Inactivity(TRequestStatus& aStatus, TTimeIntervalSeconds aSeconds);
  2682. __declspec(dllexport) void HighRes(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
  2683. };
  2684. #line 3179
  2685. class RLibrary : public RHandleBase
  2686. {
  2687. public:
  2688. __declspec(dllexport) void Close();
  2689. __declspec(dllexport) TInt Load(const TDesC& aFileName, const TUidType& aType);
  2690. __declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath=KNullDesC);
  2691. __declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType);
  2692. __declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType, TUint32 aModuleVersion);
  2693. __declspec(dllexport) TInt LoadRomLibrary(const TDesC& aFileName, const TDesC& aPath);
  2694. __declspec(dllexport) TLibraryFunction Lookup(TInt anOrdinal) const;
  2695. __declspec(dllexport) TUidType Type() const;
  2696. __declspec(dllexport) TFileName FileName() const;
  2697. __declspec(dllexport) TInt GetRamSizes(TInt& aCodeSize, TInt& aConstDataSize);
  2698. __declspec(dllexport) TInt Init();
  2699. public:
  2700. struct TInfo
  2701. {
  2702. TUint32 iModuleVersion;
  2703. TUidType iUids;
  2704. TSecurityInfo iSecurityInfo;
  2705. };
  2706. struct TInfoV2 : public TInfo
  2707. {
  2708. TUint8 iHardwareFloatingPoint;
  2709. TUint8 iSpare[7];
  2710. };
  2711. typedef TPckgBuf<TInfo> TInfoBuf;
  2712. typedef TPckgBuf<TInfoV2> TInfoBufV2;
  2713. enum TRequiredImageHeaderSize
  2714. {
  2715. KRequiredImageHeaderSize = KMaxTInt
  2716. };
  2717. __declspec(dllexport) static TInt GetInfoFromHeader(const TDesC8& aHeader, TDes8& aInfoBuf);
  2718. struct SInfo
  2719. {
  2720. TUint32 iModuleVersion;
  2721. TUidType iUids;
  2722. SSecurityInfo iS;
  2723. };
  2724. typedef TPckgBuf<SInfo> SInfoBuf;
  2725. __declspec(dllexport) static TInt GetInfo(const TDesC& aFileName, TDes8& aInfoBuf);
  2726. private:
  2727. TInt InitL();
  2728. };
  2729. #line 3292
  2730. class RCriticalSection : private RSemaphore
  2731. {
  2732. public:
  2733. __declspec(dllexport) RCriticalSection();
  2734. __declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
  2735. __declspec(dllexport) void Close();
  2736. __declspec(dllexport) void Wait();
  2737. __declspec(dllexport) void Signal();
  2738. inline TBool IsBlocked() const;
  2739. private:
  2740. TInt iBlocked;
  2741. };
  2742. #line 3320
  2743. class RMutex : public RHandleBase
  2744. {
  2745. public:
  2746. inline TInt Open(const TFindMutex& aFind,TOwnerType aType=EOwnerProcess);
  2747. __declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
  2748. __declspec(dllexport) TInt CreateGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
  2749. __declspec(dllexport) TInt OpenGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
  2750. __declspec(dllexport) TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
  2751. __declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
  2752. __declspec(dllexport) void Wait();
  2753. __declspec(dllexport) void Signal();
  2754. __declspec(dllexport) TBool IsHeld();
  2755. };
  2756. #line 3349
  2757. class RCondVar : public RHandleBase
  2758. {
  2759. public:
  2760. __declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
  2761. __declspec(dllexport) TInt CreateGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
  2762. __declspec(dllexport) TInt OpenGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
  2763. __declspec(dllexport) TInt Open(RMessagePtr2 aMessage, TInt aParam, TOwnerType aType=EOwnerProcess);
  2764. __declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
  2765. __declspec(dllexport) TInt Wait(RMutex& aMutex);
  2766. __declspec(dllexport) TInt TimedWait(RMutex& aMutex, TInt aTimeout);
  2767. __declspec(dllexport) void Signal();
  2768. __declspec(dllexport) void Broadcast();
  2769. };
  2770. class UserHeap;
  2771. class TChunkCreate;
  2772. #line 3375
  2773. class RChunk : public RHandleBase
  2774. {
  2775. public:
  2776. enum TAttribs
  2777. {
  2778. ENormal=0x00,
  2779. EDoubleEnded=0x01,
  2780. EDisconnected=0x02,
  2781. ELocal=0x00,
  2782. EGlobal=0x10,
  2783. EData=0x00,
  2784. ECode=0x20,
  2785. };
  2786. enum TRestrictions
  2787. {
  2788. EPreventAdjust = 0x01,
  2789. };
  2790. public:
  2791. inline TInt Open(const TFindChunk& aFind,TOwnerType aType=EOwnerProcess);
  2792. __declspec(dllexport) TInt CreateLocal(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
  2793. __declspec(dllexport) TInt CreateLocalCode(TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
  2794. __declspec(dllexport) TInt CreateGlobal(const TDesC& aName,TInt aSize,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
  2795. __declspec(dllexport) TInt CreateDoubleEndedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
  2796. __declspec(dllexport) TInt CreateDoubleEndedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
  2797. __declspec(dllexport) TInt CreateDisconnectedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
  2798. __declspec(dllexport) TInt CreateDisconnectedGlobal(const TDesC& aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType=EOwnerProcess);
  2799. __declspec(dllexport) TInt Create(TUint aAtt, TInt aMaxSize, TInt aInitialBottom, TInt aInitialTop, const TDesC* aName, TOwnerType aType=EOwnerProcess);
  2800. __declspec(dllexport) TInt SetRestrictions(TUint aFlags);
  2801. __declspec(dllexport) TInt OpenGlobal(const TDesC& aName,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
  2802. __declspec(dllexport) TInt Open(RMessagePtr2 aMessage,TInt aParam,TBool isReadOnly,TOwnerType aType=EOwnerProcess);
  2803. __declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
  2804. __declspec(dllexport) TInt Adjust(TInt aNewSize) const;
  2805. __declspec(dllexport) TInt AdjustDoubleEnded(TInt aBottom, TInt aTop) const;
  2806. __declspec(dllexport) TInt Commit(TInt anOffset, TInt aSize) const;
  2807. __declspec(dllexport) TInt Allocate(TInt aSize) const;
  2808. __declspec(dllexport) TInt Decommit(TInt anOffset, TInt aSize) const;
  2809. __declspec(dllexport) TUint8* Base() const;
  2810. __declspec(dllexport) TInt Size() const;
  2811. __declspec(dllexport) TInt Bottom() const;
  2812. __declspec(dllexport) TInt Top() const;
  2813. __declspec(dllexport) TInt MaxSize() const;
  2814. inline TBool IsReadable() const;
  2815. inline TBool IsWritable() const;
  2816. private:
  2817. friend class UserHeap;
  2818. };
  2819. struct SStdEpocThreadCreateInfo;
  2820. #line 3445
  2821. class UserHeap
  2822. {
  2823. public:
  2824. enum TChunkHeapCreateMode {EChunkHeapSwitchTo=1, EChunkHeapDuplicate=2};
  2825. __declspec(dllexport) static RHeap* FixedHeap(TAny* aBase, TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);
  2826. __declspec(dllexport) static RHeap* ChunkHeap(const TDesC* aName, TInt aMinLength, TInt aMaxLength, TInt aGrowBy=1, TInt aAlign=0, TBool aSingleThread=EFalse);
  2827. __declspec(dllexport) static RHeap* ChunkHeap(RChunk aChunk, TInt aMinLength, TInt aGrowBy=1, TInt aMaxLength=0, TInt aAlign=0, TBool aSingleThread=EFalse, TUint32 aMode=0);
  2828. __declspec(dllexport) static TInt SetupThreadHeap(TBool aNotFirst, SStdEpocThreadCreateInfo& aInfo);
  2829. __declspec(dllexport) static TInt CreateThreadHeap(SStdEpocThreadCreateInfo& aInfo, RHeap*& aHeap, TInt aAlign=0, TBool aSingleThread=EFalse);
  2830. };
  2831. #line 3465
  2832. class TObjectId
  2833. {
  2834. public:
  2835. inline TObjectId();
  2836. inline TObjectId(TUint64 anId);
  2837. inline TUint64 Id() const;
  2838. inline operator TUint() const;
  2839. inline TBool operator==(TObjectId aId) const;
  2840. inline TBool operator!=(TObjectId aId) const;
  2841. private:
  2842. TUint64 iId;
  2843. };
  2844. #line 3493
  2845. class TThreadId : public TObjectId
  2846. {
  2847. public:
  2848. inline TThreadId();
  2849. inline TThreadId(TUint64 anId);
  2850. };
  2851. class RProcess;
  2852. #line 3514
  2853. class RThread : public RHandleBase
  2854. {
  2855. public:
  2856. inline RThread();
  2857. __declspec(dllexport) TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, TAny *aPtr, TOwnerType aType=EOwnerProcess);
  2858. __declspec(dllexport) TInt Create(const TDesC& aName, TThreadFunction aFunction, TInt aStackSize, RAllocator* aHeap, TAny* aPtr, TOwnerType aType=EOwnerProcess);
  2859. __declspec(dllexport) TInt Open(const TDesC& aFullName, TOwnerType aType=EOwnerProcess);
  2860. __declspec(dllexport) TInt Open(TThreadId aID, TOwnerType aType=EOwnerProcess);
  2861. __declspec(dllexport) TThreadId Id() const;
  2862. __declspec(dllexport) void Resume() const;
  2863. __declspec(dllexport) void Suspend() const;
  2864. inline static TInt RenameMe(const TDesC& aName);
  2865. __declspec(dllexport) void Kill(TInt aReason);
  2866. __declspec(dllexport) void Terminate(TInt aReason);
  2867. __declspec(dllexport) void Panic(const TDesC& aCategory,TInt aReason);
  2868. __declspec(dllexport) TInt Process(RProcess& aProcess) const;
  2869. __declspec(dllexport) TThreadPriority Priority() const;
  2870. __declspec(dllexport) void SetPriority(TThreadPriority aPriority) const;
  2871. __declspec(dllexport) TProcessPriority ProcessPriority() const;
  2872. __declspec(dllexport) void SetProcessPriority(TProcessPriority aPriority) const;
  2873. __declspec(dllexport) TInt RequestCount() const;
  2874. __declspec(dllexport) TExitType ExitType() const;
  2875. __declspec(dllexport) TInt ExitReason() const;
  2876. __declspec(dllexport) TExitCategoryName ExitCategory() const;
  2877. __declspec(dllexport) void RequestComplete(TRequestStatus*& aStatus,TInt aReason) const;
  2878. __declspec(dllexport) void RequestSignal() const;
  2879. __declspec(dllexport) void Logon(TRequestStatus& aStatus) const;
  2880. __declspec(dllexport) TInt LogonCancel(TRequestStatus& aStatus) const;
  2881. __declspec(dllexport) void HandleCount(TInt& aProcessHandleCount, TInt& aThreadHandleCount) const;
  2882. __declspec(dllexport) void Context(TDes8& aDes) const;
  2883. __declspec(dllexport) TInt StackInfo(TThreadStackInfo& aInfo) const;
  2884. __declspec(dllexport) TInt GetCpuTime(TTimeIntervalMicroSeconds& aCpuTime) const;
  2885. inline TInt Open(const TFindThread& aFind,TOwnerType aType=EOwnerProcess);
  2886. __declspec(dllexport) void Rendezvous(TRequestStatus& aStatus) const;