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

Symbian

开发平台:

C/C++

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