开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
S60UIExampleHighScoreContainer.inc
资源名称：Symbian_S60_3rd_Labs.rar　[点击查看]
上传用户：laixiong
上传日期：2007-03-11
资源大小：2994k
文件大小：1690k
源码类别：

Symbian

开发平台：

C/C++

S60UIExampleHighScoreContainer.inc：源码内容
  1. TInt iSpare1;
  2. TInt iSpare2;
  3. };
  4. #line 5244
  5. template <class T>
  6. class RArray : private RArrayBase
  7. {
  8. public:
  9. inline RArray();
  10. inline explicit RArray(TInt aGranularity);
  11. inline RArray(TInt aGranularity, TInt aKeyOffset);
  12. inline RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
  13. inline void Close();
  14. inline TInt Count() const;
  15. inline const T& operator[](TInt anIndex) const;
  16. inline T& operator[](TInt anIndex);
  17. inline TInt Append(const T& anEntry);
  18. inline TInt Insert(const T& anEntry, TInt aPos);
  19. inline void Remove(TInt anIndex);
  20. inline void Compress();
  21. inline void Reset();
  22. inline TInt Find(const T& anEntry) const;
  23. inline TInt Find(const T& anEntry, TIdentityRelation<T> anIdentity) const;
  24. inline TInt FindInSignedKeyOrder(const T& anEntry) const;
  25. inline TInt FindInUnsignedKeyOrder(const T& anEntry) const;
  26. inline TInt FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const;
  27. inline TInt FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  28. inline TInt FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  29. inline TInt FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  30. template <class K>
  31. inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const
  32. { return RArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T> *)&apfnCompare); }
  33. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const;
  34. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const;
  35. inline TInt SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  36. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  37. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  38. inline TInt SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  39. inline TInt InsertInSignedKeyOrder(const T& anEntry);
  40. inline TInt InsertInUnsignedKeyOrder(const T& anEntry);
  41. inline TInt InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder);
  42. inline TInt InsertInSignedKeyOrderAllowRepeats(const T& anEntry);
  43. inline TInt InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry);
  44. inline TInt InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder);
  46. inline void AppendL(const T& anEntry);
  47. inline void InsertL(const T& anEntry, TInt aPos);
  48. inline TInt FindL(const T& anEntry) const;
  49. inline TInt FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
  50. inline TInt FindInSignedKeyOrderL(const T& anEntry) const;
  51. inline TInt FindInUnsignedKeyOrderL(const T& anEntry) const;
  52. inline TInt FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const;
  53. inline void FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  54. inline void FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  55. inline void FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  56. inline TInt SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const;
  57. inline TInt SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const;
  58. inline TInt SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  59. inline void SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  60. inline void SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  61. inline void SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  62. inline void InsertInSignedKeyOrderL(const T& anEntry);
  63. inline void InsertInUnsignedKeyOrderL(const T& anEntry);
  64. inline void InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder);
  65. inline void InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry);
  66. inline void InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry);
  67. inline void InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder);
  69. inline RArray(TInt aEntrySize,T* aEntries, TInt aCount);
  70. inline void GranularCompress();
  71. inline TInt Reserve(TInt aCount);
  72. inline void ReserveL(TInt aCount);
  73. inline void SortSigned();
  74. inline void SortUnsigned();
  75. inline void Sort(TLinearOrder<T> anOrder);
  76. inline TArray<T> Array() const;
  78. };
  79. #line 5331
  80. template<> class RArray<TInt> : private RPointerArrayBase
  81. {
  82. public:
  83. inline RArray();
  84. inline explicit RArray(TInt aGranularity);
  85. inline RArray(TInt aMinGrowBy, TInt aFactor);
  86. inline void Close();
  87. inline TInt Count() const;
  88. inline const TInt& operator[](TInt anIndex) const;
  89. inline TInt& operator[](TInt anIndex);
  90. inline TInt Append(TInt anEntry);
  91. inline TInt Insert(TInt anEntry, TInt aPos);
  92. inline void Remove(TInt anIndex);
  93. inline void Compress();
  94. inline void Reset();
  95. inline TInt Find(TInt anEntry) const;
  96. inline TInt FindInOrder(TInt anEntry) const;
  97. inline TInt FindInOrder(TInt anEntry, TInt& anIndex) const;
  98. inline TInt SpecificFindInOrder(TInt anEntry, TInt aMode) const;
  99. inline TInt SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const;
  100. inline TInt InsertInOrder(TInt anEntry);
  101. inline TInt InsertInOrderAllowRepeats(TInt anEntry);
  103. inline void AppendL(TInt anEntry);
  104. inline void InsertL(TInt anEntry, TInt aPos);
  105. inline TInt FindL(TInt anEntry) const;
  106. inline TInt FindInOrderL(TInt anEntry) const;
  107. inline void FindInOrderL(TInt anEntry, TInt& anIndex) const;
  108. inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const;
  109. inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const;
  110. inline void InsertInOrderL(TInt anEntry);
  111. inline void InsertInOrderAllowRepeatsL(TInt anEntry);
  113. inline RArray(TInt* aEntries, TInt aCount);
  114. inline void GranularCompress();
  115. inline TInt Reserve(TInt aCount);
  116. inline void ReserveL(TInt aCount);
  117. inline void Sort();
  118. inline TArray<TInt> Array() const;
  120. };
  121. #line 5387
  122. template<> class RArray<TUint> : private RPointerArrayBase
  123. {
  124. public:
  125. inline RArray();
  126. inline explicit RArray(TInt aGranularity);
  127. inline RArray(TInt aMinGrowBy, TInt aFactor);
  128. inline void Close();
  129. inline TInt Count() const;
  130. inline const TUint& operator[](TInt anIndex) const;
  131. inline TUint& operator[](TInt anIndex);
  132. inline TInt Append(TUint anEntry);
  133. inline TInt Insert(TUint anEntry, TInt aPos);
  134. inline void Remove(TInt anIndex);
  135. inline void Compress();
  136. inline void Reset();
  137. inline TInt Find(TUint anEntry) const;
  138. inline TInt FindInOrder(TUint anEntry) const;
  139. inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const;
  140. inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const;
  141. inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const;
  142. inline TInt InsertInOrder(TUint anEntry);
  143. inline TInt InsertInOrderAllowRepeats(TUint anEntry);
  145. inline void AppendL(TUint anEntry);
  146. inline void InsertL(TUint anEntry, TInt aPos);
  147. inline TInt FindL(TUint anEntry) const;
  148. inline TInt FindInOrderL(TUint anEntry) const;
  149. inline void FindInOrderL(TUint anEntry, TInt& anIndex) const;
  150. inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const;
  151. inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const;
  152. inline void InsertInOrderL(TUint anEntry);
  153. inline void InsertInOrderAllowRepeatsL(TUint anEntry);
  155. inline RArray(TUint* aEntries, TInt aCount);
  156. inline void GranularCompress();
  157. inline TInt Reserve(TInt aCount);
  158. inline void ReserveL(TInt aCount);
  159. inline void Sort();
  160. inline TArray<TUint> Array() const;
  162. };
  163. #line 5822
  164. extern TAny* operator new(TUint aSize) throw() ;
  170. extern TAny* operator new(TUint aSize,TUint anExtraSize) throw() ;
  176. extern void operator delete(TAny* aPtr) throw() ;
  183. extern TAny* operator new[](TUint aSize) throw() ;
  189. extern void operator delete[](TAny* aPtr) throw() ;
  196. inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
  203. inline TAny* operator new[](TUint aSize, TAny* aBase) throw() ;
  211. inline void operator delete(TAny* aPtr, TAny* aBase) throw() ;
  218. inline void operator delete[](TAny* aPtr, TAny* aBase) throw() ;
  219. #line 5886
  220. TBool operator==(TTrue,volatile const TBool);
  226. TBool operator==(volatile const TBool,TTrue);
  232. TBool operator!=(TTrue,volatile const TBool);
  238. TBool operator!=(volatile const TBool,TTrue);
  239. #line 5928
  240. class TIpcArgs
  241. {
  242. public:
  249. enum TArgType
  250. {
  251. EUnspecified = 0,
  252. EHandle = 1,
  253. EFlagDes = 4,
  254. EFlagConst = 2,
  255. EFlag16Bit = 1,
  256. EDes8 = EFlagDes,
  257. EDes16 = EFlagDes|EFlag16Bit,
  258. EDesC8 = EFlagDes|EFlagConst,
  259. EDesC16 = EFlagDes|EFlagConst|EFlag16Bit,
  260. };
  268. enum {
  269.      KBitsPerType=3
  270.      };
  276. enum TNothing {
  277. #line 5976
  278.               ENothing
  279.               };
  280. public:
  288. inline TIpcArgs()
  289. :iFlags(0)
  290. {}
  291. #line 5998
  292. template <class T0>
  293. inline explicit TIpcArgs(T0 a0)
  294. {
  295. Assign(iArgs[0],a0);
  296. iFlags=(Type(a0)<<(0*KBitsPerType));
  297. }
  298. #line 6015
  299. template <class T0,class T1>
  300. inline TIpcArgs(T0 a0,T1 a1)
  301. {
  302. Assign(iArgs[0],a0);
  303. Assign(iArgs[1],a1);
  304. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType));
  305. }
  306. #line 6035
  307. template <class T0,class T1,class T2>
  308. inline TIpcArgs(T0 a0,T1 a1,T2 a2)
  309. {
  310. Assign(iArgs[0],a0);
  311. Assign(iArgs[1],a1);
  312. Assign(iArgs[2],a2);
  313. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType));
  314. }
  315. #line 6058
  316. template <class T0,class T1,class T2,class T3>
  317. inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3)
  318. {
  319. Assign(iArgs[0],a0);
  320. Assign(iArgs[1],a1);
  321. Assign(iArgs[2],a2);
  322. Assign(iArgs[3],a3);
  323. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType))|(Type(a3)<<(3*KBitsPerType));
  324. }
  326. inline void Set(TInt aIndex,TNothing);
  327. inline void Set(TInt aIndex,TInt aValue);
  328. inline void Set(TInt aIndex,const TAny* aValue);
  329. inline void Set(TInt aIndex,RHandleBase aValue);
  330. inline void Set(TInt aIndex,const TDesC8* aValue);
  332. inline void Set(TInt aIndex,const TDesC16* aValue);
  334. inline void Set(TInt aIndex,TDes8* aValue);
  336. inline void Set(TInt aIndex,TDes16* aValue);
  338. private:
  339. inline static TArgType Type(TNothing);
  340. inline static TArgType Type(TInt);
  341. inline static TArgType Type(const TAny*);
  342. inline static TArgType Type(RHandleBase aValue);
  343. inline static TArgType Type(const TDesC8*);
  345. inline static TArgType Type(const TDesC16*);
  347. inline static TArgType Type(TDes8*);
  349. inline static TArgType Type(TDes16*);
  352. inline static void Assign(TInt&,TNothing);
  353. inline static void Assign(TInt& aArg,TInt aValue);
  354. inline static void Assign(TInt& aArg,const TAny* aValue);
  355. inline static void Assign(TInt& aArg,RHandleBase aValue);
  356. inline static void Assign(TInt& aArg,const TDesC8* aValue);
  358. inline static void Assign(TInt& aArg,const TDesC16* aValue);
  360. inline static void Assign(TInt& aArg,TDes8* aValue);
  362. inline static void Assign(TInt& aArg,TDes16* aValue);
  364. public:
  372. TInt iArgs[KMaxMessageArguments];
  373. #line 6123
  374. TInt iFlags;
  375. };
  382. struct SInt64
  383. {
  384. public:
  385. inline SInt64();
  386. inline SInt64(Int64 a);
  387. inline SInt64& operator=(Int64 a);
  388. inline operator Int64() const;
  389. public:
  390. TUint32 iData[2];
  391. };
  396. struct SUint64
  397. {
  398. public:
  399. inline SUint64();
  400. inline SUint64(Uint64 a);
  401. inline SUint64& operator=(Uint64 a);
  402. inline operator Uint64() const;
  403. public:
  404. TUint32 iData[2];
  405. };
  410. struct SDouble
  411. {
  412. public:
  413. inline SDouble();
  414. inline SDouble(TReal a);
  415. inline SDouble& operator=(TReal a);
  416. inline operator TReal() const;
  417. public:
  418. TUint32 iData[2];
  419. };
  420. #line 6181
  421. class TThreadStackInfo
  422. {
  423. public:
  427. TLinAddr iBase;
  433. TLinAddr iLimit;
  440. TLinAddr iExpandLimit;
  441. };
  442. #line 6214
  443. class XLeaveException
  444. {
  445. public:
  446. inline XLeaveException() {}
  447. inline XLeaveException(TInt aReason) {iR = aReason;}
  448. inline TInt Reason() const {return iR;}
  449. __declspec(dllexport) TInt GetReason() const;
  450. private:
  451. #line 6230
  452. private:
  454. TAny* iVtable;
  456. TInt iR;
  457. };
  464. namespace std {
  465.   bool uncaught_exception(void);
  466.   void terminate(void);
  467.   void unexpected(void);
  468.   typedef void (*terminate_handler)();
  469.   terminate_handler set_terminate(terminate_handler h) throw();
  470.   typedef void (*unexpected_handler)();
  471.   unexpected_handler set_unexpected(unexpected_handler h) throw();
  472. }
  480. class __UnknownWindowsType1;
  481. class __UnknownWindowsType2;
  484. class TWin32SEHTrap;
  490. typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  495. class TWin32SEHTrap
  496. {
  497. private:
  499.     TWin32SEHTrap(TWin32SEHTrap const &);
  500.     TWin32SEHTrap& operator=(TWin32SEHTrap const &);
  501. #line 6297
  502. public:
  503. __declspec(dllexport) TWin32SEHTrap();
  505. public:
  507. __declspec(dllexport) void Trap();
  510. __declspec(dllexport) void UnTrap();
  513. private:
  516. static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  523.     TWin32SEHTrap* iPrevExceptionRegistrationRecord;
  524. TWin32SEHExceptionHandler* iExceptionHandler;
  526. private:
  527. TUint32 iPadding[254];
  528. };
  529. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.inl" /* stack depth 6 */
  530. #line 9
  531. inline TAny* operator new(TUint , TAny* aBase) throw()
  532. {return aBase;}
  535. inline void operator delete(TAny* , TAny* ) throw()
  536. {}
  542. inline TAny* operator new[](TUint , TAny* aBase) throw()
  543. {return aBase;}
  546. inline void operator delete[](TAny* , TAny* ) throw()
  547. {}
  552. inline RAllocator::RAllocator()
  553. {
  554. iAccessCount=1;
  555. iHandleCount=0;
  556. iHandles=0;
  557. iFlags=0;
  558. iCellCount=0;
  559. iTotalAllocSize=0;
  560. }
  561. inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)
  562. {__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}
  565. inline RHeap::RHeap()
  566. {}
  571. inline TInt RHeap::MaxLength() const
  575. {return iMaxLength;}
  578. inline void RHeap::operator delete(TAny*, TAny*)
  583. {}
  586. inline TUint8* RHeap::Base() const
  587. #line 73
  588. {return iBase;}
  593. inline TInt RHeap::Size() const
  594. #line 89
  595. {return iTop-iBase;}
  600. inline TInt RHeap::Align(TInt a) const
  604. {return (((a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  609. inline const TAny* RHeap::Align(const TAny* a) const
  613. {return (const TAny*)((((TLinAddr)a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  618. inline TBool RHeap::IsLastCell(const SCell* aCell) const
  622. {return (((TUint8*)aCell) + aCell->len) == iTop;}
  628. inline void RHeap::Lock() const
  632. {((RFastLock&)iLock).Wait();}
  637. inline void RHeap::Unlock() const
  641. {((RFastLock&)iLock).Signal();}
  648. template <class T>
  649. inline TRefByValue<T>::TRefByValue(T &aRef)
  650. : iRef(aRef)
  656. {}
  661. template <class T>
  662. inline TRefByValue<T>::operator T &()
  666. {return(iRef);}
  667. #line 201
  668. inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)
  669. { return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }
  675. inline TChar::TChar()
  681. {}
  686. inline TChar::TChar(TUint aChar)
  687. : iChar(aChar)
  693. {}
  698. inline TChar& TChar::operator-=(TUint aChar)
  699. #line 241
  700. {iChar-=aChar;return(*this);}
  705. inline TChar& TChar::operator+=(TUint aChar)
  706. #line 256
  707. {iChar+=aChar;return(*this);}
  712. inline TChar TChar::operator-(TUint aChar)
  713. #line 273
  714. {return(iChar-aChar);}
  719. inline TChar TChar::operator+(TUint aChar)
  720. #line 288
  721. {return(iChar+aChar);}
  726. inline TChar::operator TUint() const
  733. {return(iChar);}
  739. inline TBool TDesC8::operator<(const TDesC8 &aDes) const
  740. #line 320
  741. {return(Compare(aDes)<0);}
  746. inline TBool TDesC8::operator<=(const TDesC8 &aDes) const
  747. #line 339
  748. {return(Compare(aDes)<=0);}
  753. inline TBool TDesC8::operator>(const TDesC8 &aDes) const
  754. #line 358
  755. {return(Compare(aDes)>0);}
  760. inline TBool TDesC8::operator>=(const TDesC8 &aDes) const
  761. #line 377
  762. {return(Compare(aDes)>=0);}
  767. inline TBool TDesC8::operator==(const TDesC8 &aDes) const
  768. #line 396
  769. {return(Compare(aDes)==0);}
  774. inline TBool TDesC8::operator!=(const TDesC8 &aDes) const
  775. #line 415
  776. {return(Compare(aDes)!=0);}
  781. inline const TUint8 &TDesC8::operator[](TInt anIndex) const
  782. #line 433
  783. {return(AtC(anIndex));}
  788. inline TInt TDesC8::Length() const
  796. {return(iLength&KMaskDesLength8);}
  801. inline TInt TDesC8::Size() const
  809. {return(Length());}
  814. inline void TDesC8::DoSetLength(TInt aLength)
  815. {iLength=(iLength&(~KMaskDesLength8))|aLength;}
  821. inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)
  822. #line 483
  823. {new(this) TPtrC8(aBuf,aLength);}
  828. inline void TPtrC8::Set(const TDesC8 &aDes)
  836. {new(this) TPtrC8(aDes);}
  841. inline void TPtrC8::Set(const TPtrC8& aPtr)
  842. #line 510
  843. {new(this) TPtrC8(aPtr);}
  850. inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)
  851. {return TPtr8(*this,aMaxLength);}
  857. template <TInt S>
  858. inline TBufC8<S>::TBufC8()
  859. : TBufCBase8()
  860. #line 540
  861. {}
  866. template <TInt S>
  867. inline TBufC8<S>::TBufC8(const TUint8 *aString)
  868. : TBufCBase8(aString,S)
  869. #line 564
  870. {}
  875. template <TInt S>
  876. inline TBufC8<S>::TBufC8(const TDesC8 &aDes)
  877. : TBufCBase8(aDes,S)
  878. #line 588
  879. {}
  884. template <TInt S>
  885. inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)
  886. #line 607
  887. {Copy(aString,S);return(*this);}
  892. template <TInt S>
  893. inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)
  894. #line 626
  895. {Copy(aDes,S);return(*this);}
  900. template <TInt S>
  901. inline TPtr8 TBufC8<S>::Des()
  902. #line 656
  903. {return DoDes(S);}
  910. inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)
  911. #line 681
  912. {return *this=static_cast<const TDesC8&>(aLcb);}
  913. #line 710
  914. inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)
  915. {
  916. Assign(HBufC8::NewL(aStream,aMaxLength));
  917. }
  924. inline TDes8 &TDes8::operator=(const TUint8 *aString)
  925. #line 733
  926.     {Copy(aString);return(*this);}
  931. inline TDes8 &TDes8::operator=(const TDesC8 &aDes)
  932. #line 751
  933.     {Copy(aDes);return(*this);}
  938. inline TDes8 &TDes8::operator=(const TDes8 &aDes)
  939. #line 769
  940.     {Copy(aDes);return(*this);}
  945. inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)
  946. #line 788
  947. {Append(aDes);return(*this);}
  952. inline const TUint8 &TDes8::operator[](TInt anIndex) const
  953. #line 806
  954. {return(AtC(anIndex));}
  959. inline TUint8 &TDes8::operator[](TInt anIndex)
  960. #line 825
  961. {return((TUint8 &)AtC(anIndex));}
  966. inline TInt TDes8::MaxLength() const
  967. #line 839
  968. {return(iMaxLength);}
  973. inline TInt TDes8::MaxSize() const
  974. #line 853
  975. {return(iMaxLength);}
  980. inline TUint8 * TDes8::WPtr() const
  981. {return((TUint8 *)Ptr());}
  987. inline TPtr8 &TPtr8::operator=(const TUint8 *aString)
  988. #line 879
  989. {Copy(aString);return(*this);}
  994. inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)
  995. #line 899
  996. {Copy(aDes);return(*this);}
  1001. inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)
  1002. #line 919
  1003. {Copy(aDes);return(*this);}
  1008. inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)
  1009. #line 940
  1010. {new(this) TPtr8(aBuf,aLength,aMaxLength);}
  1015. inline void TPtr8::Set(const TPtr8 &aPtr)
  1016. #line 955
  1017. {new(this) TPtr8(aPtr);}
  1023. template <TInt S>
  1024. inline TBuf8<S>::TBuf8()
  1025. : TBufBase8(S)
  1026. #line 972
  1027. {}
  1032. template <TInt S>
  1033. inline TBuf8<S>::TBuf8(TInt aLength)
  1034. : TBufBase8(aLength,S)
  1035. #line 994
  1036. {}
  1041. template <TInt S>
  1042. inline TBuf8<S>::TBuf8(const TUint8 *aString)
  1043. : TBufBase8(aString,S)
  1044. #line 1018
  1045. {}
  1050. template <TInt S>
  1051. inline TBuf8<S>::TBuf8(const TDesC8 &aDes)
  1052. : TBufBase8(aDes,S)
  1053. #line 1042
  1054. {}
  1059. template <TInt S>
  1060. inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)
  1061. #line 1062
  1062. {Copy(aString);return(*this);}
  1067. template <TInt S>
  1068. inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)
  1069. #line 1082
  1070. {Copy(aDes);return(*this);}
  1075. template <TInt S>
  1076. inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)
  1077. #line 1100
  1078. {Copy(aBuf);return *this;}
  1084. template <TInt S>
  1085. inline TAlignedBuf8<S>::TAlignedBuf8()
  1086. : TBufBase8(S)
  1087. #line 1117
  1088. {}
  1093. template <TInt S>
  1094. inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)
  1095. : TBufBase8(aLength,S)
  1096. #line 1139
  1097. {}
  1102. template <TInt S>
  1103. inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)
  1104. : TBufBase8(aString,S)
  1105. #line 1163
  1106. {}
  1111. template <TInt S>
  1112. inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)
  1113. : TBufBase8(aDes,S)
  1114. #line 1187
  1115. {}
  1120. template <TInt S>
  1121. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)
  1122. #line 1207
  1123. {Copy(aString);return(*this);}
  1128. template <TInt S>
  1129. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)
  1130. #line 1227
  1131. {Copy(aDes);return(*this);}
  1136. template <TInt S>
  1137. inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)
  1138. #line 1245
  1139. {Copy(aBuf);return *this;}
  1145. template <TInt S>
  1146. inline const TDesC8* TLitC8<S>::operator&() const
  1152. {return (reinterpret_cast<const TDesC8*>(this)) ;}
  1157. template <TInt S>
  1158. inline const TDesC8& TLitC8<S>::operator()() const
  1164. {return *operator&();}
  1169. template <TInt S>
  1170. inline TLitC8<S>::operator const TDesC8&() const
  1175. {return *operator&();}
  1179. template <TInt S>
  1180. inline TLitC8<S>::operator const __TRefDesC8() const
  1187. {return *operator&();}
  1194. inline TBool TDesC16::operator<(const TDesC16 &aDes) const
  1195. #line 1314
  1196. {return(Compare(aDes)<0);}
  1201. inline TBool TDesC16::operator<=(const TDesC16 &aDes) const
  1202. #line 1333
  1203. {return(Compare(aDes)<=0);}
  1208. inline TBool TDesC16::operator>(const TDesC16 &aDes) const
  1209. #line 1352
  1210. {return(Compare(aDes)>0);}
  1215. inline TBool TDesC16::operator>=(const TDesC16 &aDes) const
  1216. #line 1371
  1217. {return(Compare(aDes)>=0);}
  1222. inline TBool TDesC16::operator==(const TDesC16 &aDes) const
  1223. #line 1390
  1224. {return(Compare(aDes)==0);}
  1229. inline TBool TDesC16::operator!=(const TDesC16 &aDes) const
  1230. #line 1409
  1231. {return(Compare(aDes)!=0);}
  1236. inline const TUint16 &TDesC16::operator[](TInt anIndex) const
  1237. #line 1427
  1238. {return(AtC(anIndex));}
  1243. inline TInt TDesC16::Length() const
  1251. {return(iLength&KMaskDesLength16);}
  1256. inline TInt TDesC16::Size() const
  1257. #line 1454
  1258. {return(Length()<<1);}
  1263. inline void TDesC16::DoSetLength(TInt aLength)
  1264. {iLength=(iLength&(~KMaskDesLength16))|aLength;}
  1270. inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)
  1271. #line 1478
  1272. {new(this) TPtrC16(aBuf,aLength);}
  1277. inline void TPtrC16::Set(const TDesC16 &aDes)
  1285. {new(this) TPtrC16(aDes);}
  1290. inline void TPtrC16::Set(const TPtrC16& aPtr)
  1291. {new(this) TPtrC16(aPtr);}
  1297. inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)
  1298. {return TPtr16(*this,aMaxLength);}
  1304. template <TInt S>
  1305. inline TBufC16<S>::TBufC16()
  1306. : TBufCBase16()
  1307. #line 1526
  1308. {}
  1313. template <TInt S>
  1314. inline TBufC16<S>::TBufC16(const TUint16 *aString)
  1315. : TBufCBase16(aString,S)
  1316. #line 1550
  1317. {}
  1322. template <TInt S>
  1323. inline TBufC16<S>::TBufC16(const TDesC16 &aDes)
  1324. : TBufCBase16(aDes,S)
  1325. #line 1574
  1326. {}
  1331. template <TInt S>
  1332. inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)
  1333. #line 1593
  1334. {Copy(aString,S);return(*this);}
  1339. template <TInt S>
  1340. inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)
  1341. #line 1612
  1342. {Copy(aDes,S);return(*this);}
  1347. template <TInt S>
  1348. inline TPtr16 TBufC16<S>::Des()
  1349. #line 1642
  1350. {return(DoDes(S));}
  1357. inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)
  1358. #line 1667
  1359. {return *this=static_cast<const TDesC16&>(aLcb);}
  1366. inline TDes16 &TDes16::operator=(const TUint16 *aString)
  1367. #line 1687
  1368.     {Copy(aString);return(*this);}
  1373. inline TDes16 &TDes16::operator=(const TDesC16 &aDes)
  1374. #line 1705
  1375.     {Copy(aDes);return(*this);}
  1380. inline TDes16 &TDes16::operator=(const TDes16 &aDes)
  1381. #line 1723
  1382.     {Copy(aDes);return(*this);}
  1387. inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)
  1388. #line 1742
  1389. {Append(aDes);return(*this);}
  1394. inline const TUint16 &TDes16::operator[](TInt anIndex) const
  1395. #line 1759
  1396. {return(AtC(anIndex));}
  1401. inline TUint16 &TDes16::operator[](TInt anIndex)
  1402. #line 1778
  1403. {return((TUint16 &)AtC(anIndex));}
  1408. inline TInt TDes16::MaxLength() const
  1409. #line 1792
  1410. {return(iMaxLength);}
  1415. inline TInt TDes16::MaxSize() const
  1416. #line 1806
  1417. {return(iMaxLength<<1);}
  1422. inline TUint16 * TDes16::WPtr() const
  1423. {return((TUint16 *)Ptr());}
  1429. inline TPtr16 &TPtr16::operator=(const TUint16 *aString)
  1430. #line 1832
  1431. {Copy(aString);return(*this);}
  1436. inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)
  1437. #line 1852
  1438. {Copy(aDes);return(*this);}
  1443. inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)
  1444. #line 1872
  1445. {Copy(aDes);return(*this);}
  1450. inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)
  1451. #line 1893
  1452. {new(this) TPtr16(aBuf,aLength,aMaxLength);}
  1457. inline void TPtr16::Set(const TPtr16 &aPtr)
  1458. #line 1908
  1459. {new(this) TPtr16(aPtr);}
  1465. template <TInt S>
  1466. inline TBuf16<S>::TBuf16()
  1467. : TBufBase16(S)
  1468. #line 1925
  1469. {}
  1474. template <TInt S>
  1475. inline TBuf16<S>::TBuf16(TInt aLength)
  1476. : TBufBase16(aLength,S)
  1477. #line 1947
  1478. {}
  1483. template <TInt S>
  1484. inline TBuf16<S>::TBuf16(const TUint16 *aString)
  1485. : TBufBase16(aString,S)
  1486. #line 1971
  1487. {}
  1492. template <TInt S>
  1493. inline TBuf16<S>::TBuf16(const TDesC16 &aDes)
  1494. : TBufBase16(aDes,S)
  1495. #line 1995
  1496. {}
  1501. template <TInt S>
  1502. inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)
  1503. #line 2015
  1504. {Copy(aString);return(*this);}
  1509. template <TInt S>
  1510. inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)
  1511. #line 2035
  1512. {Copy(aDes);return(*this);}
  1517. template <TInt S>
  1518. inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)
  1519. #line 2056
  1520. {Copy(aBuf);return *this;}
  1521. #line 2083
  1522. inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)
  1523. {
  1524. Assign(HBufC16::NewL(aStream,aMaxLength));
  1525. }
  1529. template <TInt S>
  1530. inline const TDesC16* TLitC16<S>::operator&() const
  1536. {return (reinterpret_cast<const TDesC16*>(this)) ;}
  1541. template <TInt S>
  1542. inline const TDesC16& TLitC16<S>::operator()() const
  1548. {return *operator&();}
  1553. template <TInt S>
  1554. inline TLitC16<S>::operator const TDesC16&() const
  1559. {return *operator&();}
  1564. template <TInt S>
  1565. inline TLitC16<S>::operator const __TRefDesC16() const
  1572. {return *operator&();}
  1580. template <TInt S>
  1581. inline TBufC<S>::TBufC()
  1582. : TBufCBase16()
  1583. #line 2157
  1584. {}
  1589. template <TInt S>
  1590. inline TBufC<S>::TBufC(const TText *aString)
  1591. : TBufCBase16(aString,S)
  1592. #line 2186
  1593. {}
  1598. template <TInt S>
  1599. inline TBufC<S>::TBufC(const TDesC &aDes)
  1600. : TBufCBase16(aDes,S)
  1601. #line 2219
  1602. {}
  1603. #line 2234
  1604. template <TInt S>
  1605. inline TBufC<S> &TBufC<S>::operator=(const TText *aString)
  1606. #line 2253
  1607. {Copy(aString,S);return(*this);}
  1612. template <TInt S>
  1613. inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)
  1614. #line 2277
  1615. {Copy(aDes,S);return(*this);}
  1620. template <TInt S>
  1621. inline TPtr TBufC<S>::Des()
  1622. #line 2308
  1623. {return(DoDes(S));}
  1630. template <TInt S>
  1631. inline TBuf<S>::TBuf()
  1632. : TBufBase16(S)
  1640. {}
  1645. template <TInt S>
  1646. inline TBuf<S>::TBuf(TInt aLength)
  1647. : TBufBase16(aLength,S)
  1648. #line 2350
  1649. {}
  1654. template <TInt S>
  1655. inline TBuf<S>::TBuf(const TText *aString)
  1656. : TBufBase16(aString,S)
  1657. #line 2378
  1658. {}
  1663. template <TInt S>
  1664. inline TBuf<S>::TBuf(const TDesC &aDes)
  1665. : TBufBase16(aDes,S)
  1666. #line 2407
  1667. {}
  1668. #line 2426
  1669. template <TInt S>
  1670. inline TBuf<S> &TBuf<S>::operator=(const TText *aString)
  1671. {Copy(aString);return(*this);}
  1672. template <TInt S>
  1673. inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)
  1674. {Copy(aDes);return(*this);}
  1675. template <TInt S>
  1676. inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)
  1677. {Copy(aBuf);return(*this);}
  1683. template <TInt S>
  1684. inline const TDesC* TLitC<S>::operator&() const
  1690. {return (reinterpret_cast<const TDesC*>(this)) ;}
  1695. template <TInt S>
  1696. inline const TDesC& TLitC<S>::operator()() const
  1702. {return *operator&();}
  1707. template <TInt S>
  1708. inline TLitC<S>::operator const TDesC&() const
  1713. {return *operator&();}
  1718. template <TInt S>
  1719. inline TLitC<S>::operator const __TRefDesC() const
  1726. {return *operator&();}
  1732. template <class T>
  1733. inline TPckgC<T>::TPckgC(const T &aRef)
  1734. : TPtrC8((const TUint8 *)&aRef,sizeof(T))
  1742. {}
  1747. template <class T>
  1748. inline const T &TPckgC<T>::operator()() const
  1755. {return(*((const T *)iPtr));}
  1761. template <class T>
  1762. inline TPckg<T>::TPckg(const T &aRef)
  1763. : TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T))
  1771. {}
  1776. template <class T>
  1777. inline T &TPckg<T>::operator()()
  1784. {return(*((T *)iPtr));}
  1790. template <class T>
  1791. inline TPckgBuf<T>::TPckgBuf()
  1792. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1800. {new(&this->iBuf[0]) T;}
  1805. template <class T>
  1806. inline TPckgBuf<T>::TPckgBuf(const T &aRef)
  1807. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1808. #line 2576
  1809. {new(&this->iBuf[0]) T(aRef);}
  1814. template <class T>
  1815. inline TPckgBuf<T> &TPckgBuf<T>::operator=(const TPckgBuf<T> &aRef)
  1823. {this->Copy(aRef);return(*this);}
  1828. template <class T>
  1829. inline T &TPckgBuf<T>::operator=(const T &aRef)
  1830. #line 2605
  1831. {this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));}
  1836. template <class T>
  1837. inline T &TPckgBuf<T>::operator()()
  1844. {return(*((T *)&this->iBuf[0]));}
  1849. template <class T>
  1850. inline const T &TPckgBuf<T>::operator()() const
  1857. {return(*((T *)&this->iBuf[0]));}
  1863. inline TRequestStatus::TRequestStatus()
  1867. : iFlags(0)
  1868. {}
  1873. inline TRequestStatus::TRequestStatus(TInt aVal)
  1881. : iStatus(aVal),
  1882. iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0)
  1884. {}
  1889. inline TInt TRequestStatus::operator=(TInt aVal)
  1897. {
  1898. if(aVal==KRequestPending)
  1899. iFlags|=TRequestStatus::ERequestPending;
  1900. else
  1901. iFlags&=~TRequestStatus::ERequestPending;
  1902. return (iStatus=aVal);
  1903. }
  1908. inline TBool TRequestStatus::operator==(TInt aVal) const
  1909. #line 2691
  1910. {return(iStatus==aVal);}
  1915. inline TBool TRequestStatus::operator!=(TInt aVal) const
  1916. #line 2705
  1917. {return(iStatus!=aVal);}
  1922. inline TBool TRequestStatus::operator>=(TInt aVal) const
  1923. #line 2720
  1924. {return(iStatus>=aVal);}
  1929. inline TBool TRequestStatus::operator<=(TInt aVal) const
  1930. #line 2735
  1931. {return(iStatus<=aVal);}
  1936. inline TBool TRequestStatus::operator>(TInt aVal) const
  1937. #line 2750
  1938. {return(iStatus>aVal);}
  1943. inline TBool TRequestStatus::operator<(TInt aVal) const
  1944. #line 2765
  1945. {return(iStatus<aVal);}
  1950. inline TInt TRequestStatus::Int() const
  1956. {return(iStatus);}
  1963. inline TPoint::TPoint()
  1964. : iX(0),iY(0)
  1968. {}
  1973. inline TPoint::TPoint(TInt aX,TInt aY)
  1974. : iX(aX),iY(aY)
  1981. {}
  1987. inline TSize::TSize()
  1988. : iWidth(0),iHeight(0)
  1992. {}
  1997. inline TSize::TSize(TInt aWidth,TInt aHeight)
  1998. : iWidth(aWidth),iHeight(aHeight)
  2005. {}
  2012. inline RHandleBase::RHandleBase()
  2013. : iHandle(0)
  2017. {}
  2023. inline RHandleBase::RHandleBase(TInt aHandle)
  2024. : iHandle(aHandle)
  2025. #line 2853
  2026. {}
  2032. inline void RHandleBase::SetHandle(TInt aHandle)
  2039. { iHandle=aHandle; }
  2044. inline TInt RHandleBase::Handle() const
  2050. {return(iHandle);}
  2055. inline TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError)
  2056. #line 2899
  2057. {
  2058. if(aHandleOrError>=0)
  2059. {
  2060. iHandle = aHandleOrError;
  2061. return KErrNone;
  2062. }
  2063. iHandle = 0;
  2064. return aHandleOrError;
  2065. }
  2072. inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType)
  2073. #line 2935
  2074. {return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));}
  2075. #line 2947
  2076. inline RFastLock::RFastLock()
  2077. : iCount(0)
  2078. {}
  2079. #line 2960
  2080. inline RMessagePtr2::RMessagePtr2()
  2081. : iHandle(0)
  2082. {}
  2083. #line 2972
  2084. inline TBool RMessagePtr2::IsNull() const
  2085. {return iHandle==0;}
  2086. #line 2983
  2087. inline TInt RMessagePtr2::Handle() const
  2088. {return iHandle;}
  2089. inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2090. {return aLeft.Handle()==aRight.Handle();}
  2091. inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2092. {return aLeft.Handle()!=aRight.Handle();}
  2093. #line 3000
  2094. inline RMessage2::RMessage2()
  2095. {}
  2096. #line 3011
  2097. inline TInt RMessage2::Function() const
  2098. {return(iFunction);}
  2099. #line 3022
  2100. inline TInt RMessage2::Int0() const
  2101. {return(iArgs[0]);}
  2102. #line 3033
  2103. inline TInt RMessage2::Int1() const
  2104. {return(iArgs[1]);}
  2105. #line 3044
  2106. inline TInt RMessage2::Int2() const
  2107. {return(iArgs[2]);}
  2108. #line 3054
  2109. inline TInt RMessage2::Int3() const
  2110. {return(iArgs[3]);}
  2111. #line 3064
  2112. inline const TAny *RMessage2::Ptr0() const
  2113. {return((const TAny *)iArgs[0]);}
  2114. #line 3075
  2115. inline const TAny *RMessage2::Ptr1() const
  2116. {return((const TAny *)iArgs[1]);}
  2117. #line 3086
  2118. inline const TAny *RMessage2::Ptr2() const
  2119. {return((const TAny *)iArgs[2]);}
  2120. #line 3097
  2121. inline const TAny *RMessage2::Ptr3() const
  2122. {return((const TAny *)iArgs[3]);}
  2123. #line 3107
  2124. inline CSession2* RMessage2::Session() const
  2125. {return (CSession2*)iSessionPtr; }
  2131. inline TUid TUid::Uid(TInt aUid)
  2132. #line 3123
  2133. {TUid uid={aUid};return uid;}
  2138. inline TUid TUid::Null()
  2144. {TUid uid={KNullUidValue};return uid;}
  2151. template <class T>
  2152. inline TArray<T>::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr)
  2153. : iPtr(aPtr),iCount(aCount),iAt(anAt)
  2154. #line 3195
  2155. {}
  2160. template <class T>
  2161. inline TInt TArray<T>::Count() const
  2168. {return((*iCount)(iPtr));}
  2173. template <class T>
  2174. inline const T &TArray<T>::operator[](TInt anIndex) const
  2175. #line 3232
  2176. {return(*((const T *)(*iAt)(iPtr,anIndex)));}
  2183. template <class T>
  2184. inline TIdentityRelation<T>::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) )
  2185. #line 3254
  2186. { iIdentity=(TGeneralIdentityRelation)anIdentity; }
  2191. template <class T>
  2192. inline TIdentityRelation<T>::operator TGeneralIdentityRelation() const
  2197. { return iIdentity; }
  2203. template <class T>
  2204. inline TLinearOrder<T>::TLinearOrder( TInt(*anOrder)(const T&, const T&) )
  2205. #line 3288
  2206. { iOrder=(TGeneralLinearOrder)anOrder; }
  2211. template <class T>
  2212. inline TLinearOrder<T>::operator TGeneralLinearOrder() const
  2217. { return iOrder; }
  2218. #line 3312
  2219. template <class T>
  2220. inline RPointerArray<T>::RPointerArray()
  2221. : RPointerArrayBase()
  2222. {}
  2223. #line 3331
  2224. template <class T>
  2225. inline RPointerArray<T>::RPointerArray(TInt aGranularity)
  2226. : RPointerArrayBase(aGranularity)
  2227. {}
  2228. #line 3354
  2229. template <class T>
  2230. inline RPointerArray<T>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2231. : RPointerArrayBase(aMinGrowBy, aFactor)
  2232. {}
  2237. template <class T>
  2238. inline void RPointerArray<T>::Close()
  2239. #line 3372
  2240. {RPointerArrayBase::Close();}
  2245. template <class T>
  2246. inline TInt RPointerArray<T>::Count() const
  2252. { return RPointerArrayBase::Count(); }
  2257. template <class T>
  2258. inline T* const& RPointerArray<T>::operator[](TInt anIndex) const
  2259. #line 3408
  2260. {return (T* const&)At(anIndex);}
  2265. template <class T>
  2266. inline T*& RPointerArray<T>::operator[](TInt anIndex)
  2267. #line 3432
  2268. {return (T*&)At(anIndex);}
  2273. template <class T>
  2274. inline TInt RPointerArray<T>::Append(const T* anEntry)
  2275. #line 3447
  2276. { return RPointerArrayBase::Append(anEntry); }
  2281. template <class T>
  2282. inline TInt RPointerArray<T>::Insert(const T* anEntry, TInt aPos)
  2283. #line 3468
  2284. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2289. template <class T>
  2290. inline void RPointerArray<T>::Remove(TInt anIndex)
  2291. #line 3488
  2292. {RPointerArrayBase::Remove(anIndex);}
  2297. template <class T>
  2298. inline void RPointerArray<T>::Compress()
  2299. #line 3503
  2300. {RPointerArrayBase::Compress();}
  2305. template <class T>
  2306. inline void RPointerArray<T>::Reset()
  2307. #line 3522
  2308. {RPointerArrayBase::Reset();}
  2313. template <class T>
  2314. inline TInt RPointerArray<T>::Find(const T* anEntry) const
  2315. #line 3542
  2316. { return RPointerArrayBase::Find(anEntry); }
  2321. template <class T>
  2322. inline TInt RPointerArray<T>::Find(const T* anEntry, TIdentityRelation<T> anIdentity) const
  2323. #line 3566
  2324. { return RPointerArrayBase::Find(anEntry,anIdentity); }
  2329. template <class T>
  2330. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry) const
  2331. #line 3584
  2332. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2337. template <class T>
  2338. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const
  2339. #line 3606
  2340. { return RPointerArrayBase::FindIsq(anEntry,anOrder); }
  2345. template <class T>
  2346. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry, TInt& anIndex) const
  2347. #line 3631
  2348. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2353. template <class T>
  2354. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2355. #line 3660
  2356. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); }
  2361. template <class T>
  2362. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const
  2363. #line 3691
  2364. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2369. template <class T>
  2370. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2371. #line 3726
  2372. { return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); }
  2377. template <class T>
  2378. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const
  2379. #line 3766
  2380. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2385. template <class T>
  2386. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2387. #line 3810
  2388. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); }
  2393. template <class T>
  2394. inline TInt RPointerArray<T>::InsertInAddressOrder(const T* anEntry)
  2395. #line 3833
  2396. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2401. template <class T>
  2402. inline TInt RPointerArray<T>::InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder)
  2403. #line 3862
  2404. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); }
  2409. template <class T>
  2410. inline TInt RPointerArray<T>::InsertInAddressOrderAllowRepeats(const T* anEntry)
  2411. #line 3885
  2412. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2417. template <class T>
  2418. inline TInt RPointerArray<T>::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder)
  2419. #line 3911
  2420. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); }
  2426. template <class T>
  2427. inline RPointerArray<T>::RPointerArray(T** aEntries, TInt aCount)
  2428. : RPointerArrayBase((TAny **)aEntries, aCount)
  2429. #line 3935
  2430. {}
  2435. template <class T>
  2436. inline void RPointerArray<T>::GranularCompress()
  2437. #line 3950
  2438. {RPointerArrayBase::GranularCompress();}
  2443. template <class T>
  2444. inline TInt RPointerArray<T>::Reserve(TInt aCount)
  2445. #line 3969
  2446. { return RPointerArrayBase::DoReserve(aCount); }
  2451. template <class T>
  2452. inline void RPointerArray<T>::SortIntoAddressOrder()
  2456. { HeapSortUnsigned(); }
  2461. template <class T>
  2462. inline void RPointerArray<T>::Sort(TLinearOrder<T> anOrder)
  2463. #line 3996
  2464. { HeapSort(anOrder); }
  2469. template <class T>
  2470. inline TArray<T*> RPointerArray<T>::Array() const
  2478. { return TArray<T*>(GetCount,GetElementPtr,(const CBase*)this); }
  2483. template <class T>
  2484. void RPointerArray<T>::ResetAndDestroy()
  2485. #line 4026
  2486. {
  2487. TInt c=Count();
  2488. T** pE=(T**)Entries();
  2489. ZeroCount();
  2490. TInt i;
  2491. for (i=0; i<c; i++)
  2492. {
  2493. delete *pE;
  2494. pE++;
  2495. }
  2496. Reset();
  2497. }
  2498. #line 4049
  2499. inline RPointerArray<TAny>::RPointerArray()
  2500. : RPointerArrayBase()
  2501. {}
  2502. #line 4067
  2503. inline RPointerArray<TAny>::RPointerArray(TInt aGranularity)
  2504. : RPointerArrayBase(aGranularity)
  2505. {}
  2506. #line 4089
  2507. inline RPointerArray<TAny>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2508. : RPointerArrayBase(aMinGrowBy, aFactor)
  2509. {}
  2514. inline void RPointerArray<TAny>::Close()
  2515. #line 4105
  2516. {RPointerArrayBase::Close();}
  2521. inline TInt RPointerArray<TAny>::Count() const
  2527. { return RPointerArrayBase::Count(); }
  2532. inline TAny* const& RPointerArray<TAny>::operator[](TInt anIndex) const
  2533. #line 4139
  2534. {return At(anIndex);}
  2539. inline TAny*& RPointerArray<TAny>::operator[](TInt anIndex)
  2540. #line 4162
  2541. {return At(anIndex);}
  2546. inline TInt RPointerArray<TAny>::Append(const TAny* anEntry)
  2547. #line 4176
  2548. { return RPointerArrayBase::Append(anEntry); }
  2553. inline TInt RPointerArray<TAny>::Insert(const TAny* anEntry, TInt aPos)
  2554. #line 4196
  2555. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2560. inline void RPointerArray<TAny>::Remove(TInt anIndex)
  2561. #line 4215
  2562. {RPointerArrayBase::Remove(anIndex);}
  2567. inline void RPointerArray<TAny>::Compress()
  2568. #line 4229
  2569. {RPointerArrayBase::Compress();}
  2574. inline void RPointerArray<TAny>::Reset()
  2575. #line 4247
  2576. {RPointerArrayBase::Reset();}
  2581. inline TInt RPointerArray<TAny>::Find(const TAny* anEntry) const
  2582. #line 4266
  2583. { return RPointerArrayBase::Find(anEntry); }
  2588. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry) const
  2589. #line 4283
  2590. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2595. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const
  2596. #line 4307
  2597. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2602. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const
  2603. #line 4337
  2604. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2609. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const
  2610. #line 4376
  2611. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2616. inline TInt RPointerArray<TAny>::InsertInAddressOrder(const TAny* anEntry)
  2617. #line 4398
  2618. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2623. inline TInt RPointerArray<TAny>::InsertInAddressOrderAllowRepeats(const TAny* anEntry)
  2624. #line 4420
  2625. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2631. inline RPointerArray<TAny>::RPointerArray(TAny** aEntries, TInt aCount)
  2632. : RPointerArrayBase((TAny **)aEntries, aCount)
  2633. #line 4443
  2634. {}
  2639. inline void RPointerArray<TAny>::GranularCompress()
  2640. #line 4457
  2641. {RPointerArrayBase::GranularCompress();}
  2646. inline void RPointerArray<TAny>::SortIntoAddressOrder()
  2650. { HeapSortUnsigned(); }
  2655. inline TArray<TAny*> RPointerArray<TAny>::Array() const
  2663. { return TArray<TAny*>(GetCount,GetElementPtr,(const CBase*)this); }
  2668. template <class T>
  2669. inline RArray<T>::RArray()
  2670. : RArrayBase(sizeof(T))
  2671. #line 4497
  2672. {}
  2677. template <class T>
  2678. inline RArray<T>::RArray(TInt aGranularity)
  2679. : RArrayBase(sizeof(T),aGranularity)
  2680. #line 4519
  2681. {}
  2686. template <class T>
  2687. inline RArray<T>::RArray(TInt aGranularity, TInt aKeyOffset)
  2688. : RArrayBase(sizeof(T),aGranularity,aKeyOffset)
  2689. #line 4543
  2690. {}
  2691. #line 4567
  2692. template <class T>
  2693. inline RArray<T>::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
  2694. : RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor)
  2695. {}
  2700. template <class T>
  2701. inline void RArray<T>::Close()
  2707. {RArrayBase::Close();}
  2712. template <class T>
  2713. inline TInt RArray<T>::Count() const
  2719. {return RArrayBase::Count();}
  2724. template <class T>
  2725. inline const T& RArray<T>::operator[](TInt anIndex) const
  2726. #line 4616
  2727. {return *(const T*)At(anIndex); }
  2732. template <class T>
  2733. inline T& RArray<T>::operator[](TInt anIndex)
  2734. #line 4638
  2735. {return *(T*)At(anIndex); }
  2740. template <class T>
  2741. inline TInt RArray<T>::Append(const T& anEntry)
  2742. #line 4653
  2743. {return RArrayBase::Append(&anEntry);}
  2748. template <class T>
  2749. inline TInt RArray<T>::Insert(const T& anEntry, TInt aPos)
  2750. #line 4675
  2751. {return RArrayBase::Insert(&anEntry,aPos);}
  2756. template <class T>
  2757. inline void RArray<T>::Remove(TInt anIndex)
  2758. #line 4692
  2759. {RArrayBase::Remove(anIndex);}
  2764. template <class T>
  2765. inline void RArray<T>::Compress()
  2773. {RArrayBase::Compress();}
  2778. template <class T>
  2779. inline void RArray<T>::Reset()
  2780. #line 4721
  2781. {RArrayBase::Reset();}
  2786. template <class T>
  2787. inline TInt RArray<T>::Find(const T& anEntry) const
  2788. #line 4743
  2789. {return RArrayBase::Find(&anEntry);}
  2794. template <class T>
  2795. inline TInt RArray<T>::Find(const T& anEntry, TIdentityRelation<T> anIdentity) const
  2796. #line 4768
  2797. {return RArrayBase::Find(&anEntry,anIdentity);}
  2802. template <class T>
  2803. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry) const
  2804. #line 4787
  2805. {return RArrayBase::FindIsqSigned(&anEntry);}
  2810. template <class T>
  2811. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry) const
  2812. #line 4806
  2813. {return RArrayBase::FindIsqUnsigned(&anEntry);}
  2818. template <class T>
  2819. inline TInt RArray<T>::FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const
  2820. #line 4828
  2821. {return RArrayBase::FindIsq(&anEntry,anOrder);}
  2826. template <class T>
  2827. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2828. #line 4851
  2829. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex);}
  2834. template <class T>
  2835. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2836. #line 4875
  2837. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);}
  2842. template <class T>
  2843. inline TInt RArray<T>::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2844. #line 4902
  2845. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);}
  2850. template <class T>
  2851. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const
  2852. #line 4936
  2853. {return RArrayBase::FindIsqSigned(&anEntry,aMode);}
  2858. template <class T>
  2859. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const
  2860. #line 4970
  2861. {return RArrayBase::FindIsqUnsigned(&anEntry,aMode);}
  2866. template <class T>
  2867. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2868. #line 5003
  2869. {return RArrayBase::FindIsq(&anEntry,anOrder,aMode);}
  2874. template <class T>
  2875. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2876. #line 5042
  2877. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);}
  2882. template <class T>
  2883. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2884. #line 5081
  2885. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);}
  2890. template <class T>
  2891. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2892. #line 5123
  2893. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);}
  2898. template <class T>
  2899. inline TInt RArray<T>::InsertInSignedKeyOrder(const T& anEntry)
  2900. #line 5146
  2901. {return RArrayBase::InsertIsqSigned(&anEntry,EFalse);}
  2906. template <class T>
  2907. inline TInt RArray<T>::InsertInUnsignedKeyOrder(const T& anEntry)
  2908. #line 5169
  2909. {return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);}
  2914. template <class T>
  2915. inline TInt RArray<T>::InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder)
  2916. #line 5197
  2917. {return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);}
  2922. template <class T>
  2923. inline TInt RArray<T>::InsertInSignedKeyOrderAllowRepeats(const T& anEntry)
  2924. #line 5221
  2925. {return RArrayBase::InsertIsqSigned(&anEntry,ETrue);}
  2930. template <class T>
  2931. inline TInt RArray<T>::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry)
  2932. #line 5245
  2933. {return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);}
  2938. template <class T>
  2939. inline TInt RArray<T>::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder)
  2940. #line 5272
  2941. {return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);}
  2947. template <class T>
  2948. inline RArray<T>::RArray(TInt aEntrySize,T* aEntries, TInt aCount)
  2949. : RArrayBase(aEntrySize,aEntries,aCount)
  2950. #line 5303
  2951. {}
  2956. template <class T>
  2957. inline void RArray<T>::GranularCompress()
  2958. #line 5318
  2959. {RArrayBase::GranularCompress();}
  2964. template <class T>
  2965. inline TInt RArray<T>::Reserve(TInt aCount)
  2966. #line 5337
  2967. { return RArrayBase::DoReserve(aCount); }
  2972. template <class T>
  2973. inline void RArray<T>::SortSigned()
  2978. {HeapSortSigned();}
  2983. template <class T>
  2984. inline void RArray<T>::SortUnsigned()
  2989. {HeapSortUnsigned();}
  2994. template <class T>
  2995. inline void RArray<T>::Sort(TLinearOrder<T> anOrder)
  2996. #line 5375
  2997. {HeapSort(anOrder);}
  3002. template <class T>
  3003. inline TArray<T> RArray<T>::Array() const
  3009. { return TArray<T>(GetCount,GetElementPtr,(const CBase*)this); }
  3015. inline RArray<TInt>::RArray()
  3016. : RPointerArrayBase()
  3023. {}
  3028. inline RArray<TInt>::RArray(TInt aGranularity)
  3029. : RPointerArrayBase(aGranularity)
  3030. #line 5417
  3031. {}
  3032. #line 5437
  3033. inline RArray<TInt>::RArray(TInt aMinGrowBy, TInt aFactor)
  3034. : RPointerArrayBase(aMinGrowBy, aFactor)
  3035. {}
  3040. inline void RArray<TInt>::Close()
  3046. {RPointerArrayBase::Close();}
  3051. inline TInt RArray<TInt>::Count() const
  3057. { return RPointerArrayBase::Count(); }
  3062. inline const TInt& RArray<TInt>::operator[](TInt anIndex) const
  3063. #line 5484
  3064. {return (const TInt&)At(anIndex);}
  3069. inline TInt& RArray<TInt>::operator[](TInt anIndex)
  3070. #line 5507
  3071. {return (TInt&)At(anIndex);}
  3076. inline TInt RArray<TInt>::Append(TInt anEntry)
  3077. #line 5521
  3078. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3083. inline TInt RArray<TInt>::Insert(TInt anEntry, TInt aPos)
  3084. #line 5541
  3085. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3090. inline void RArray<TInt>::Remove(TInt anIndex)
  3091. #line 5558
  3092. {RPointerArrayBase::Remove(anIndex);}
  3097. inline void RArray<TInt>::Compress()
  3105. {RPointerArrayBase::Compress();}
  3110. inline void RArray<TInt>::Reset()
  3111. #line 5586
  3112. {RPointerArrayBase::Reset();}
  3117. inline TInt RArray<TInt>::Find(TInt anEntry) const
  3118. #line 5604
  3119. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3124. inline TInt RArray<TInt>::FindInOrder(TInt anEntry) const
  3125. #line 5621
  3126. { return RPointerArrayBase::FindIsqSigned(anEntry); }
  3131. inline TInt RArray<TInt>::FindInOrder(TInt anEntry, TInt& anIndex) const
  3132. #line 5644
  3133. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); }
  3138. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt aMode) const
  3139. #line 5675
  3140. { return RPointerArrayBase::FindIsqSigned(anEntry,aMode); }
  3145. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const
  3146. #line 5713
  3147. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); }
  3152. inline TInt RArray<TInt>::InsertInOrder(TInt anEntry)
  3153. #line 5735
  3154. { return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); }
  3159. inline TInt RArray<TInt>::InsertInOrderAllowRepeats(TInt anEntry)
  3160. #line 5758
  3161. { return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); }
  3167. inline RArray<TInt>::RArray(TInt* aEntries, TInt aCount)
  3168. : RPointerArrayBase((TAny**)aEntries, aCount)
  3169. #line 5781
  3170. {}
  3172. inline void RArray<TInt>::GranularCompress()
  3173. #line 5792
  3174. {RPointerArrayBase::GranularCompress();}
  3179. inline TInt RArray<TInt>::Reserve(TInt aCount)
  3180. #line 5810
  3181. { return RPointerArrayBase::DoReserve(aCount); }
  3186. inline void RArray<TInt>::Sort()
  3190. { HeapSortSigned(); }
  3195. inline TArray<TInt> RArray<TInt>::Array() const
  3203. { return TArray<TInt>(GetCount,GetElementPtr,(const CBase*)this); }
  3208. inline RArray<TUint>::RArray()
  3209. : RPointerArrayBase()
  3210. #line 5847
  3211. {}
  3216. inline RArray<TUint>::RArray(TInt aGranularity)
  3217. : RPointerArrayBase(aGranularity)
  3218. #line 5863
  3219. {}
  3220. #line 5883
  3221. inline RArray<TUint>::RArray(TInt aMinGrowBy, TInt aFactor)
  3222. : RPointerArrayBase(aMinGrowBy, aFactor)
  3223. {}
  3228. inline void RArray<TUint>::Close()
  3234. {RPointerArrayBase::Close();}
  3239. inline TInt RArray<TUint>::Count() const
  3245. {return RPointerArrayBase::Count(); }
  3250. inline const TUint& RArray<TUint>::operator[](TInt anIndex) const
  3251. #line 5930
  3252. {return (const TUint&)At(anIndex);}
  3257. inline TUint& RArray<TUint>::operator[](TInt anIndex)
  3258. #line 5953
  3259. {return (TUint&)At(anIndex);}
  3264. inline TInt RArray<TUint>::Append(TUint anEntry)
  3272. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3277. inline TInt RArray<TUint>::Insert(TUint anEntry, TInt aPos)
  3278. #line 5987
  3279. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3284. inline void RArray<TUint>::Remove(TInt anIndex)
  3285. #line 6005
  3286. {RPointerArrayBase::Remove(anIndex);}
  3291. inline void RArray<TUint>::Compress()
  3299. {RPointerArrayBase::Compress();}
  3304. inline void RArray<TUint>::Reset()
  3305. #line 6033
  3306. {RPointerArrayBase::Reset();}
  3311. inline TInt RArray<TUint>::Find(TUint anEntry) const
  3312. #line 6051
  3313. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3318. inline TInt RArray<TUint>::FindInOrder(TUint anEntry) const
  3319. #line 6070
  3320. { return RPointerArrayBase::FindIsqUnsigned(anEntry); }
  3325. inline TInt RArray<TUint>::FindInOrder(TUint anEntry, TInt& anIndex) const
  3326. #line 6098
  3327. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); }
  3332. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt aMode) const
  3333. #line 6128
  3334. { return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); }
  3339. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const
  3340. #line 6163
  3341. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); }
  3346. inline TInt RArray<TUint>::InsertInOrder(TUint anEntry)
  3347. #line 6185
  3348. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); }
  3353. inline TInt RArray<TUint>::InsertInOrderAllowRepeats(TUint anEntry)
  3354. #line 6208
  3355. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); }
  3361. inline RArray<TUint>::RArray(TUint* aEntries, TInt aCount)
  3362. : RPointerArrayBase((TAny**)aEntries, aCount)
  3363. #line 6231
  3364. {}
  3368. inline void RArray<TUint>::GranularCompress()
  3369. #line 6244
  3370. {RPointerArrayBase::GranularCompress();}
  3375. inline TInt RArray<TUint>::Reserve(TInt aCount)
  3376. #line 6262
  3377. { return RPointerArrayBase::DoReserve(aCount); }
  3382. inline void RArray<TUint>::Sort()
  3386. { HeapSortUnsigned(); }
  3391. inline TArray<TUint> RArray<TUint>::Array() const
  3399. { return TArray<TUint>(GetCount,GetElementPtr,(const CBase*)this); }
  3400. #line 6293
  3401. inline void TIpcArgs::Set(TInt,TNothing)
  3402. {}
  3403. #line 6307
  3404. inline void TIpcArgs::Set(TInt aIndex,TInt aValue)
  3405. {
  3406. iArgs[aIndex] = aValue;
  3407. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3408. }
  3409. #line 6324
  3410. inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue)
  3411. {
  3412. iArgs[aIndex] = (TInt)aValue;
  3413. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3414. }
  3415. #line 6341
  3416. inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue)
  3417. {
  3418. iArgs[aIndex] = (TInt)aValue.Handle();
  3419. iFlags |= EHandle<<(aIndex*KBitsPerType);
  3420. }
  3421. #line 6358
  3422. inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue)
  3423. {
  3424. iArgs[aIndex] = (TInt)aValue;
  3425. iFlags |= EDesC8<<(aIndex*KBitsPerType);
  3426. }
  3427. #line 6377
  3428. inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue)
  3429. {
  3430. iArgs[aIndex] = (TInt)aValue;
  3431. iFlags |= EDesC16<<(aIndex*KBitsPerType);
  3432. }
  3433. #line 6396
  3434. inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue)
  3435. {
  3436. iArgs[aIndex] = (TInt)aValue;
  3437. iFlags |= EDes8<<(aIndex*KBitsPerType);
  3438. }
  3439. #line 6415
  3440. inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue)
  3441. {
  3442. iArgs[aIndex] = (TInt)aValue;
  3443. iFlags |= EDes16<<(aIndex*KBitsPerType);
  3444. }
  3451. inline TIpcArgs::TArgType TIpcArgs::Type(TNothing)
  3452. { return EUnspecified; }
  3453. inline TIpcArgs::TArgType TIpcArgs::Type(TInt)
  3454. { return EUnspecified; }
  3455. inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*)
  3456. { return EUnspecified; }
  3457. inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase)
  3458. { return EHandle; }
  3459. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*)
  3460. { return EDesC8; }
  3462. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*)
  3463. { return EDesC16; }
  3465. inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*)
  3466. { return EDes8; }
  3468. inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*)
  3469. { return EDes16; }
  3471. inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing)
  3472. {}
  3473. inline void TIpcArgs::Assign(TInt& aArg,TInt aValue)
  3474. { aArg = aValue; }
  3475. inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue)
  3476. { aArg = (TInt)aValue; }
  3477. inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue)
  3478. { aArg = (TInt)aValue.Handle(); }
  3479. inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue)
  3480. { aArg = (TInt)aValue; }
  3482. inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue)
  3483. { aArg = (TInt)aValue; }
  3485. inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue)
  3486. { aArg = (TInt)aValue; }
  3488. inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue)
  3489. { aArg = (TInt)aValue; }
  3496. inline SInt64::SInt64()
  3497. {}
  3499. inline SInt64::SInt64(Int64 a)
  3500. {
  3501. iData[0] = (TUint32)((Uint64)a);
  3502. iData[1] = (TUint32)(((Uint64)a)>>32);
  3503. }
  3505. inline SInt64& SInt64::operator=(Int64 a)
  3506. {
  3507. iData[0] = (TUint32)((Uint64)a);
  3508. iData[1] = (TUint32)(((Uint64)a)>>32);
  3509. return *this;
  3510. }
  3512. inline SInt64::operator Int64() const
  3513. {
  3514. Int64 x;
  3515. TUint32* px = (TUint32*)&x;
  3516. px[0] = iData[0];
  3517. px[1] = iData[1];
  3518. return x;
  3519. }
  3521. inline SUint64::SUint64()
  3522. {}
  3524. inline SUint64::SUint64(Uint64 a)
  3525. {
  3526. iData[0] = (TUint32)a;
  3527. iData[1] = (TUint32)(a>>32);
  3528. }
  3530. inline SUint64& SUint64::operator=(Uint64 a)
  3531. {
  3532. iData[0] = (TUint32)a;
  3533. iData[1] = (TUint32)(a>>32);
  3534. return *this;
  3535. }
  3537. inline SUint64::operator Uint64() const
  3538. {
  3539. Uint64 x;
  3540. TUint32* px = (TUint32*)&x;
  3541. px[0] = iData[0];
  3542. px[1] = iData[1];
  3543. return x;
  3544. }
  3546. inline SDouble::SDouble()
  3547. {}
  3549. inline SDouble::SDouble(TReal a)
  3550. {
  3551. const TUint32* pa = (const TUint32*)&a;
  3556. iData[0] = pa[0];
  3557. iData[1] = pa[1];
  3559. }
  3561. inline SDouble& SDouble::operator=(TReal a)
  3562. {
  3563. new (this) SDouble(a);
  3564. return *this;
  3565. }
  3567. inline SDouble::operator TReal() const
  3568. {
  3569. TReal x;
  3570. TUint32* px = (TUint32*)&x;
  3575. px[0] = iData[0];
  3576. px[1] = iData[1];
  3578. return x;
  3579. }
  3586. inline TSecureId::TSecureId()
  3587. {}
  3591. inline TSecureId::TSecureId(TUint32 aId)
  3592. : iId(aId) {}
  3596. inline TSecureId::operator TUint32() const
  3597. { return iId; }
  3601. inline TSecureId::TSecureId(TUid aId)
  3602. : iId(aId.iUid) {}
  3606. inline TSecureId::operator TUid() const
  3607. { return (TUid&)iId; }
  3612. inline const TSecureId* SSecureId::operator&() const
  3613. { return (const TSecureId*)this; }
  3614. inline SSecureId::operator const TSecureId&() const
  3615. { return (const TSecureId&)iId; }
  3616. inline SSecureId::operator TUint32() const
  3617. { return iId; }
  3618. inline SSecureId::operator TUid() const
  3619. { return (TUid&)iId; }
  3626. inline TVendorId::TVendorId()
  3627. {}
  3631. inline TVendorId::TVendorId(TUint32 aId)
  3632. : iId(aId) {}
  3636. inline TVendorId::operator TUint32() const
  3637. { return iId; }
  3641. inline TVendorId::TVendorId(TUid aId)
  3642. : iId(aId.iUid) {}
  3646. inline TVendorId::operator TUid() const
  3647. { return (TUid&)iId; }
  3652. inline const TVendorId* SVendorId::operator&() const
  3653. { return (const TVendorId*)this; }
  3654. inline SVendorId::operator const TVendorId&() const
  3655. { return (const TVendorId&)iId; }
  3656. inline SVendorId::operator TUint32() const
  3657. { return iId; }
  3658. inline SVendorId::operator TUid() const
  3659. { return (TUid&)iId; }
  3665. inline TCapabilitySet::TCapabilitySet()
  3666. {}
  3672. inline TCapabilitySet::TCapabilitySet(TCapability aCapability)
  3673. { new (this) TCapabilitySet(aCapability, aCapability); }
  3679. inline void TCapabilitySet::Set(TCapability aCapability)
  3680. { new (this) TCapabilitySet(aCapability, aCapability); }
  3687. inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2)
  3688. { new (this) TCapabilitySet(aCapability1, aCapability2); }
  3694. inline TSecurityInfo::TSecurityInfo()
  3695. {}
  3700. inline TSecurityPolicy::TSecurityPolicy()
  3701. { new (this) TSecurityPolicy(EAlwaysFail); }
  3707. inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const
  3708. { return (const TSecurityPolicy*)this; }
  3714. inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const
  3715. { return *(const TSecurityPolicy*)this; }
  3721. inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const
  3722. { return *(const TSecurityPolicy*)this; }
  3723. #line 6341 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.h" /* stack depth 5 */
  3724. #line 13 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 4 */
  3731. class TFunctor
  3732. {
  3733. public:
  3734. __declspec(dllexport) virtual void operator()() =0;
  3735. };
  3736. #line 53
  3737. class TCallBack
  3738. {
  3739. public:
  3740. inline TCallBack();
  3741. inline TCallBack(TInt (*aFunction)(TAny* aPtr));
  3742. inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
  3743. inline TInt CallBack() const;
  3744. public:
  3749. TInt (*iFunction)(TAny* aPtr);
  3756. TAny* iPtr;
  3757. };
  3758. #line 89
  3759. class TSglQueLink
  3760. {
  3762. public:
  3763. inline TSglQueLink() : iNext(0 )
  3771. {}
  3773. private:
  3774. __declspec(dllexport) void Enque(TSglQueLink* aLink);
  3775. public:
  3779. TSglQueLink* iNext;
  3780. friend class TSglQueBase;
  3781. };
  3782. #line 130
  3783. class TDblQueLinkBase
  3784. {
  3785. public:
  3786. inline TDblQueLinkBase() : iNext(0 )
  3794. {}
  3795. __declspec(dllexport) void Enque(TDblQueLinkBase* aLink);
  3796. __declspec(dllexport) void AddBefore(TDblQueLinkBase* aLink);
  3797. public:
  3801. TDblQueLinkBase* iNext;
  3806. TDblQueLinkBase* iPrev;
  3807. };
  3808. #line 166
  3809. class TDblQueLink : public TDblQueLinkBase
  3810. {
  3811. public:
  3812. __declspec(dllexport) void Deque();
  3813. };
  3814. #line 184
  3815. class TPriQueLink : public TDblQueLink
  3816. {
  3817. public:
  3823. TInt iPriority;
  3824. };
  3825. #line 205
  3826. class TDeltaQueLink : public TDblQueLinkBase
  3827. {
  3828. public:
  3832. TInt iDelta;
  3833. };
  3834. #line 224
  3835. class TTickCountQueLink : public TDblQueLink
  3836. {
  3837. public:
  3841. TUint iTickCount;
  3842. };
  3843. #line 248
  3844. class TSglQueBase
  3845. {
  3846. public:
  3847. __declspec(dllexport) TBool IsEmpty() const;
  3848. __declspec(dllexport) void SetOffset(TInt aOffset);
  3849. __declspec(dllexport) void Reset();
  3850. protected:
  3851. __declspec(dllexport) TSglQueBase();
  3852. __declspec(dllexport) TSglQueBase(TInt aOffset);
  3853. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3854. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3855. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3856. protected:
  3860. TSglQueLink* iHead;
  3865. TSglQueLink* iLast;
  3870. TInt iOffset;
  3871. private:
  3872. TSglQueBase(const TSglQueBase& aQue);
  3873. TSglQueBase &operator=(const TSglQueBase& aQue);
  3874. friend class TSglQueIterBase;
  3875. };
  3876. #line 296
  3877. class TDblQueBase
  3878. {
  3879. public:
  3880. __declspec(dllexport) TBool IsEmpty() const;
  3881. __declspec(dllexport) void SetOffset(TInt aOffset);
  3882. __declspec(dllexport) void Reset();
  3883. protected:
  3884. __declspec(dllexport) TDblQueBase();
  3885. __declspec(dllexport) TDblQueBase(TInt aOffset);
  3886. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3887. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3888. __declspec(dllexport) void DoAddPriority(TAny* aPtr);
  3889. __declspec(dllexport) void __DbgTestEmpty() const;
  3890. protected:
  3894. TDblQueLink iHead;
  3899. TInt iOffset;
  3900. private:
  3901. TDblQueBase(const TDblQueBase& aQue);
  3902. TDblQueBase& operator=(const TDblQueBase& aQue);
  3903. friend class TDblQueIterBase;
  3904. };
  3905. #line 338
  3906. class TDeltaQueBase : public TDblQueBase
  3907. {
  3908. public:
  3909. __declspec(dllexport) TBool CountDown();
  3910. __declspec(dllexport) TBool CountDown(TInt aValue);
  3911. __declspec(dllexport) TBool FirstDelta(TInt& aValue);
  3912. __declspec(dllexport) void Reset();
  3913. protected:
  3914. __declspec(dllexport) TDeltaQueBase();
  3915. __declspec(dllexport) TDeltaQueBase(TInt aOffset);
  3916. __declspec(dllexport) void DoAddDelta(TAny* aPtr,TInt aDelta);
  3917. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3918. __declspec(dllexport) TAny* DoRemoveFirst();
  3919. protected:
  3923. TInt* iFirstDelta;
  3924. };
  3925. #line 375
  3926. template <class T>
  3927. class TSglQue : public TSglQueBase
  3928. {
  3929. public:
  3930. inline TSglQue();
  3931. inline explicit TSglQue(TInt aOffset);
  3932. inline void AddFirst(T& aRef);
  3933. inline void AddLast(T& aRef);
  3934. inline TBool IsFirst(const T* aPtr) const;
  3935. inline TBool IsLast(const T* aPtr) const;
  3936. inline T* First() const;
  3937. inline T* Last() const;
  3938. inline void Remove(T& aRef);
  3939. };
  3940. #line 407
  3941. template <class T>
  3942. class TDblQue : public TDblQueBase
  3943. {
  3944. public:
  3945. inline TDblQue();
  3946. inline explicit TDblQue(TInt aOffset);
  3947. inline void AddFirst(T& aRef);
  3948. inline void AddLast(T& aRef);
  3949. inline TBool IsHead(const T* aPtr) const;
  3950. inline TBool IsFirst(const T* aPtr) const;
  3951. inline TBool IsLast(const T* aPtr) const;
  3952. inline T* First() const;
  3953. inline T* Last() const;
  3954. };
  3955. #line 441
  3956. template <class T>
  3957. class TPriQue : public TDblQueBase
  3958. {
  3959. public:
  3960. inline TPriQue();
  3961. inline explicit TPriQue(TInt aOffset);
  3962. inline void Add(T& aRef);
  3963. inline TBool IsHead(const T* aPtr) const;
  3964. inline TBool IsFirst(const T* aPtr) const;
  3965. inline TBool IsLast(const T* aPtr) const;
  3966. inline T* First() const;
  3967. inline T* Last() const;
  3968. };
  3969. #line 487
  3970. template <class T>
  3971. class TDeltaQue : public TDeltaQueBase
  3972. {
  3973. public:
  3974. inline TDeltaQue();
  3975. inline explicit TDeltaQue(TInt aOffset);
  3976. inline void Add(T& aRef,TInt aDelta);
  3977. inline void Remove(T& aRef);
  3978. inline T* RemoveFirst();
  3979. };
  3985. class TTickCountQueLink;
  3986. #line 520
  3987. class TTickCountQue : public TDblQueBase
  3988. {
  3989. public:
  3990. TTickCountQue();
  3991. void Add(TTickCountQueLink& aRef);
  3992. TTickCountQueLink* First() const;
  3993. TTickCountQueLink* RemoveFirst();
  3994. TTickCountQueLink* RemoveFirst(TUint aTickCount);
  3995. };
  3996. #line 543
  3997. class TSglQueIterBase
  3998. {
  3999. public:
  4000. __declspec(dllexport) void SetToFirst();
  4001. protected:
  4002. __declspec(dllexport) TSglQueIterBase(TSglQueBase& aQue);
  4003. __declspec(dllexport) TAny* DoPostInc();
  4004. __declspec(dllexport) TAny* DoCurrent();
  4005. __declspec(dllexport) void DoSet(TAny* aLink);
  4006. protected:
  4007. TInt iOffset;
  4008. TSglQueLink* iHead;
  4009. TSglQueLink* iNext;
  4010. };
  4011. #line 571
  4012. template <class T>
  4013. class TSglQueIter : public TSglQueIterBase
  4014. {
  4015. public:
  4016. inline TSglQueIter(TSglQueBase& aQue);
  4017. inline void Set(T& aLink);
  4018. inline operator T*();
  4019. inline T* operator++(TInt);
  4020. };
  4021. #line 594
  4022. class TDblQueIterBase
  4023. {
  4024. public:
  4025. __declspec(dllexport) void SetToFirst();
  4026. __declspec(dllexport) void SetToLast();
  4027. protected:
  4028. __declspec(dllexport) TDblQueIterBase(TDblQueBase& aQue);
  4029. __declspec(dllexport) TAny* DoPostInc();
  4030. __declspec(dllexport) TAny* DoPostDec();
  4031. __declspec(dllexport) TAny* DoCurrent();
  4032. __declspec(dllexport) void DoSet(TAny* aLink);
  4033. protected:
  4037. TInt iOffset;
  4042. TDblQueLinkBase* iHead;
  4047. TDblQueLinkBase* iNext;
  4048. };
  4049. #line 635
  4050. template <class T>
  4051. class TDblQueIter : public TDblQueIterBase
  4052. {
  4053. public:
  4054. inline TDblQueIter(TDblQueBase& aQue);
  4055. inline void Set(T& aLink);
  4056. inline operator T*();
  4057. inline T* operator++(TInt);
  4058. inline T* operator--(TInt);
  4059. };
  4060. #line 660
  4061. enum TKeyCmpText
  4062. {
  4070. ECmpNormal,
  4071. #line 682
  4072. ECmpNormal8,
  4073. #line 696
  4074. ECmpNormal16,
  4075. #line 706
  4076. ECmpFolded,
  4077. #line 717
  4078. ECmpFolded8,
  4079. #line 728
  4080. ECmpFolded16,
  4081. #line 738
  4082. ECmpCollated,
  4083. #line 749
  4084. ECmpCollated8,
  4085. #line 761
  4086. ECmpCollated16
  4087. };
  4088. #line 777
  4089. enum TKeyCmpNumeric
  4090. {
  4094. ECmpTInt8=((ECmpCollated16+1)<<1),
  4100. ECmpTInt16,
  4106. ECmpTInt32,
  4112. ECmpTInt,
  4118. ECmpTUint8,
  4124. ECmpTUint16,
  4130. ECmpTUint32,
  4136. ECmpTUint,
  4142. ECmpTInt64
  4143. };
  4144. #line 856
  4145. class TKey
  4146. {
  4147. public:
  4148. inline void SetPtr(const TAny* aPtr);
  4149. __declspec(dllexport) virtual TInt Compare(TInt aLeft,TInt aRight) const;
  4150. __declspec(dllexport) virtual TAny* At(TInt anIndex) const;
  4151. protected:
  4152. __declspec(dllexport) TKey();
  4153. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType);
  4154. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
  4155. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpNumeric aType);
  4156. protected:
  4157. TInt iKeyOffset;
  4158. TInt iKeyLength;
  4159. TInt iCmpType;
  4160. const TAny* iPtr;
  4161. };
  4162. #line 890
  4163. class TSwap
  4164. {
  4165. public:
  4166. __declspec(dllexport) TSwap();
  4167. __declspec(dllexport) virtual void Swap(TInt aLeft,TInt aRight) const;
  4168. };
  4169. #line 918
  4170. class TCharF : public TChar
  4171. {
  4172. public:
  4173. inline TCharF(TUint aChar);
  4174. inline TCharF(const TChar& aChar);
  4175. inline TCharF& operator=(TUint aChar);
  4176. inline TCharF& operator=(const TChar& aChar);
  4177. };
  4178. #line 937
  4179. class TCharLC : public TChar
  4180. {
  4181. public:
  4182. inline TCharLC(TUint aChar);
  4183. inline TCharLC(const TChar& aChar);
  4184. inline TCharLC& operator=(TUint aChar);
  4185. inline TCharLC& operator=(const TChar& aChar);
  4186. };
  4187. #line 956
  4188. class TCharUC : public TChar
  4189. {
  4190. public:
  4191. inline TCharUC(TUint aChar);
  4192. inline TCharUC(const TChar& aChar);
  4193. inline TCharUC& operator=(TUint aChar);
  4194. inline TCharUC& operator=(const TChar& aChar);
  4195. };
  4196. #line 982
  4197. class TRealFormat
  4198. {
  4199. public:
  4200. __declspec(dllexport) TRealFormat();
  4201. __declspec(dllexport) TRealFormat(TInt aWidth);
  4202. __declspec(dllexport) TRealFormat(TInt aWidth,TInt aDecimalPlaces);
  4203. public:
  4204. #line 1007
  4205. TInt iType;
  4211. TInt iWidth;
  4212. #line 1025
  4213. TInt iPlaces;
  4214. #line 1038
  4215. TChar iPoint;
  4216. #line 1051
  4217. TChar iTriad;
  4218. #line 1071
  4219. TInt iTriLen;
  4220. };
  4221. #line 1089
  4222. class TLexMark8
  4223. {
  4224. public:
  4225. inline TLexMark8();
  4226. private:
  4227. inline TLexMark8(const TUint8* aString);
  4228. const TUint8* iPtr;
  4229. friend class TLex8;
  4230. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4231. };
  4236. class TRealX;
  4237. #line 1123
  4238. class TLex8
  4239. {
  4240. public:
  4241. __declspec(dllexport) TLex8();
  4242. inline TLex8(const TUint8* aString);
  4243. inline TLex8(const TDesC8& aDes);
  4244. inline TLex8& operator=(const TUint8* aString);
  4245. inline TLex8& operator=(const TDesC8& aDes);
  4246. inline TBool Eos() const;
  4247. inline void Mark(TLexMark8& aMark) const;
  4248. inline void Mark();
  4249. __declspec(dllexport) void Inc();
  4250. __declspec(dllexport) void Inc(TInt aNumber);
  4251. __declspec(dllexport) TChar Get();
  4252. __declspec(dllexport) TChar Peek() const;
  4253. __declspec(dllexport) void UnGet();
  4254. inline void UnGetToMark();
  4255. __declspec(dllexport) void UnGetToMark(const TLexMark8 aMark);
  4256. __declspec(dllexport) void SkipSpace();
  4257. inline void SkipAndMark(TInt aNumber);
  4258. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark8& aMark);
  4259. inline void SkipSpaceAndMark();
  4260. __declspec(dllexport) void SkipSpaceAndMark(TLexMark8& aMark);
  4261. __declspec(dllexport) void SkipCharacters();
  4262. inline TInt TokenLength() const;
  4263. __declspec(dllexport) TInt TokenLength(const TLexMark8 aMark) const;
  4264. __declspec(dllexport) TPtrC8 MarkedToken() const;
  4265. __declspec(dllexport) TPtrC8 MarkedToken(const TLexMark8 aMark) const;
  4266. __declspec(dllexport) TPtrC8 NextToken();
  4267. __declspec(dllexport) TPtrC8 Remainder() const;
  4268. __declspec(dllexport) TPtrC8 RemainderFromMark() const;
  4269. __declspec(dllexport) TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
  4270. __declspec(dllexport) TInt Offset() const;
  4271. inline TInt MarkedOffset() const;
  4272. __declspec(dllexport) TInt MarkedOffset(const TLexMark8 aMark) const;
  4273. __declspec(dllexport) TInt Val(TInt8& aVal);
  4274. __declspec(dllexport) TInt Val(TInt16& aVal);
  4275. __declspec(dllexport) TInt Val(TInt32& aVal);
  4276. __declspec(dllexport) TInt Val(TInt64& aVal);
  4277. inline TInt Val(TInt& aVal);
  4278. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4279. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4280. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4281. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4282. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4283. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4284. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4285. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4286. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4287. __declspec(dllexport) TInt Val(TReal32& aVal);
  4288. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4289. __declspec(dllexport) TInt Val(TReal64& aVal);
  4290. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4291. inline void Assign(const TLex8& aLex);
  4292. __declspec(dllexport) void Assign(const TUint8* aString);
  4293. __declspec(dllexport) void Assign(const TDesC8& aDes);
  4294. TInt Val(TRealX& aVal);
  4295. TInt Val(TRealX& aVal, TChar aPoint);
  4298. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4301. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4304. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4307. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4308. private:
  4309. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4310. void ScndigAfterPoint(TInt& aSig,TInt64& aDl);
  4311. void ValidateMark(const TLexMark8 aMark) const;
  4312. private:
  4313. const TUint8* iNext;
  4314. const TUint8* iBuf;
  4315. const TUint8* iEnd;
  4316. TLexMark8 iMark;
  4317. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4318. };
  4319. #line 1220
  4320. class TLexMark16
  4321. {
  4322. public:
  4323. inline TLexMark16();
  4324. private:
  4325. inline TLexMark16(const TUint16* aString);
  4326. const TUint16* iPtr;
  4327. friend class TLex16;
  4328. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4329. };
  4330. #line 1253
  4331. class TLex16
  4332. {
  4333. public:
  4334. __declspec(dllexport) TLex16();
  4335. inline TLex16(const TUint16* aString);
  4336. inline TLex16(const TDesC16& aDes);
  4337. inline TLex16& operator=(const TUint16* aString);
  4338. inline TLex16& operator=(const TDesC16& aDes);
  4339. inline TBool Eos() const;
  4340. inline void Mark();
  4341. inline void Mark(TLexMark16& aMark) const;
  4342. __declspec(dllexport) void Inc();
  4343. __declspec(dllexport) void Inc(TInt aNumber);
  4344. __declspec(dllexport) TChar Get();
  4345. __declspec(dllexport) TChar Peek() const;
  4346. __declspec(dllexport) void UnGet();
  4347. inline void UnGetToMark();
  4348. __declspec(dllexport) void UnGetToMark(const TLexMark16 aMark);
  4349. __declspec(dllexport) void SkipSpace();
  4350. inline void SkipAndMark(TInt aNumber);
  4351. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark16& aMark);
  4352. __declspec(dllexport) void SkipSpaceAndMark(TLexMark16& aMark);
  4353. inline void SkipSpaceAndMark();
  4354. __declspec(dllexport) void SkipCharacters();
  4355. inline TInt TokenLength() const;
  4356. __declspec(dllexport) TInt TokenLength(const TLexMark16 aMark) const;
  4357. __declspec(dllexport) TPtrC16 MarkedToken() const;
  4358. __declspec(dllexport) TPtrC16 MarkedToken(const TLexMark16 aMark) const;
  4359. __declspec(dllexport) TPtrC16 NextToken();
  4360. __declspec(dllexport) TPtrC16 Remainder() const;
  4361. __declspec(dllexport) TPtrC16 RemainderFromMark() const;
  4362. __declspec(dllexport) TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
  4363. __declspec(dllexport) TInt Offset() const;
  4364. inline TInt MarkedOffset() const;
  4365. __declspec(dllexport) TInt MarkedOffset(const TLexMark16 aMark) const;
  4366. __declspec(dllexport) TInt Val(TInt8& aVal);
  4367. __declspec(dllexport) TInt Val(TInt16& aVal);
  4368. __declspec(dllexport) TInt Val(TInt32& aVal);
  4369. __declspec(dllexport) TInt Val(TInt64& aVal);
  4370. inline TInt Val(TInt& aVal);
  4371. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4372. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4373. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4374. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4376. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4377. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4378. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4379. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4380. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4381. __declspec(dllexport) TInt Val(TReal32& aVal);
  4382. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4383. __declspec(dllexport) TInt Val(TReal64& aVal);
  4384. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4385. inline void Assign(const TLex16& aLex);
  4386. __declspec(dllexport) void Assign(const TUint16* aString);
  4387. __declspec(dllexport) void Assign(const TDesC16& aDes);
  4388. TInt Val(TRealX& aVal);
  4389. TInt Val(TRealX& aVal, TChar aPoint);
  4392. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4395. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4398. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4401. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4402. private:
  4403. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4404. void ValidateMark(const TLexMark16 aMark) const;
  4405. private:
  4406. const TUint16* iNext;
  4407. const TUint16* iBuf;
  4408. const TUint16* iEnd;
  4409. TLexMark16 iMark;
  4410. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4411. };
  4412. #line 1355
  4413. typedef TLex16 TLex;
  4414. #line 1373
  4415. typedef TLexMark16 TLexMark;
  4416. #line 1430
  4417. class TCheckedUid
  4418. {
  4419. public:
  4420. __declspec(dllexport) TCheckedUid();
  4421. __declspec(dllexport) TCheckedUid(const TUidType& aUidType);
  4422. __declspec(dllexport) TCheckedUid(const TDesC8& aPtr);
  4423. __declspec(dllexport) void Set(const TUidType& aUidType);
  4424. __declspec(dllexport) void Set(const TDesC8& aPtr);
  4425. __declspec(dllexport) TPtrC8 Des() const;
  4426. inline const TUidType& UidType() const;
  4427. protected:
  4428. __declspec(dllexport) TUint Check() const;
  4429. private:
  4430. TUidType iType;
  4431. TUint iCheck;
  4432. };
  4433. #line 1469
  4434. class TDateTime
  4435. {
  4436. public:
  4437. inline TDateTime();
  4438. __declspec(dllexport) TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4439. __declspec(dllexport) TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4440. __declspec(dllexport) TInt SetYear(TInt aYear);
  4441. __declspec(dllexport) TInt SetYearLeapCheck(TInt aYear);
  4442. __declspec(dllexport) TInt SetMonth(TMonth aMonth);
  4443. __declspec(dllexport) TInt SetDay(TInt aDay);
  4444. __declspec(dllexport) TInt SetHour(TInt aHour);
  4445. __declspec(dllexport) TInt SetMinute(TInt aMinute);
  4446. __declspec(dllexport) TInt SetSecond(TInt aSecond);
  4447. __declspec(dllexport) TInt SetMicroSecond(TInt aMicroSecond);
  4448. inline TInt Year() const;
  4449. inline TMonth Month() const;
  4450. inline TInt Day() const;
  4451. inline TInt Hour() const;
  4452. inline TInt Minute() const;
  4453. inline TInt Second() const;
  4454. inline TInt MicroSecond() const;
  4455. private:
  4456. TInt iYear;
  4457. TMonth iMonth;
  4458. TInt iDay;
  4459. TInt iHour;
  4460. TInt iMinute;
  4461. TInt iSecond;
  4462. TInt iMicroSecond;
  4463. };
  4464. #line 1516
  4465. class TTimeIntervalMicroSeconds
  4466. {
  4467. public:
  4468. inline TTimeIntervalMicroSeconds();
  4469. inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
  4470. inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
  4471. inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
  4472. inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
  4473. inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
  4474. inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
  4475. inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
  4476. inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
  4477. inline const TInt64& Int64() const;
  4478. private:
  4479. TInt64 iInterval;
  4480. };
  4481. #line 1554
  4482. class TTimeIntervalBase
  4483. {
  4484. public:
  4485. inline TBool operator==(TTimeIntervalBase aInterval) const;
  4486. inline TBool operator!=(TTimeIntervalBase aInterval) const;
  4487. inline TBool operator>=(TTimeIntervalBase aInterval) const;
  4488. inline TBool operator<=(TTimeIntervalBase aInterval) const;
  4489. inline TBool operator>(TTimeIntervalBase aInterval) const;
  4490. inline TBool operator<(TTimeIntervalBase aInterval) const;
  4491. inline TInt Int() const;
  4492. protected:
  4493. inline TTimeIntervalBase();
  4494. inline TTimeIntervalBase(TInt aInterval);
  4495. protected:
  4496. TInt iInterval;
  4497. };
  4498. #line 1583
  4499. class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
  4500. {
  4501. public:
  4502. inline TTimeIntervalMicroSeconds32();
  4503. inline TTimeIntervalMicroSeconds32(TInt aInterval);
  4504. inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
  4505. };
  4506. #line 1606
  4507. class TTimeIntervalSeconds : public TTimeIntervalBase
  4508. {
  4509. public:
  4510. inline TTimeIntervalSeconds();
  4511. inline TTimeIntervalSeconds(TInt aInterval);
  4512. inline TTimeIntervalSeconds& operator=(TInt aInterval);
  4513. };
  4514. #line 1626
  4515. class TTimeIntervalMinutes : public TTimeIntervalBase
  4516. {
  4517. public:
  4518. inline TTimeIntervalMinutes();
  4519. inline TTimeIntervalMinutes(TInt aInterval);
  4520. inline TTimeIntervalMinutes& operator=(TInt aInterval);
  4521. };
  4522. #line 1646
  4523. class TTimeIntervalHours : public TTimeIntervalBase
  4524. {
  4525. public:
  4526. inline TTimeIntervalHours();
  4527. inline TTimeIntervalHours(TInt aInterval);
  4528. inline TTimeIntervalHours& operator=(TInt aInterval);
  4529. };
  4530. #line 1666
  4531. class TTimeIntervalDays : public TTimeIntervalBase
  4532. {
  4533. public:
  4534. inline TTimeIntervalDays();
  4535. inline TTimeIntervalDays(TInt aInterval);
  4536. inline TTimeIntervalDays& operator=(TInt aInterval);
  4537. };
  4538. #line 1686
  4539. class TTimeIntervalMonths : public TTimeIntervalBase
  4540. {
  4541. public:
  4542. inline TTimeIntervalMonths();
  4543. inline TTimeIntervalMonths(TInt aInterval);
  4544. inline TTimeIntervalMonths& operator=(TInt aInterval);
  4545. };
  4546. #line 1706
  4547. class TTimeIntervalYears : public TTimeIntervalBase
  4548. {
  4549. public:
  4550. inline TTimeIntervalYears();
  4551. inline TTimeIntervalYears(TInt aInterval);
  4552. inline TTimeIntervalYears& operator=(TInt aInterval);
  4553. };
  4554. #line 1725
  4555. enum {
  4561.      EParseTimePresent=0x1,
  4567.      EParseDatePresent=0x2
  4568.      };
  4569. #line 1770
  4570. class TTime
  4571. {
  4572. public:
  4573. inline TTime();
  4574. inline TTime(const TInt64& aTime);
  4575. __declspec(dllexport) TTime(const TDesC& aString);
  4576. __declspec(dllexport) TTime(const TDateTime& aDateTime);
  4577. inline TTime& operator=(const TInt64& aTime);
  4578. __declspec(dllexport) TTime& operator=(const TDateTime& aDateTime);
  4579. __declspec(dllexport) void HomeTime();
  4580. __declspec(dllexport) void UniversalTime();
  4581. __declspec(dllexport) TInt Set(const TDesC& aString);
  4583. __declspec(dllexport) TDateTime DateTime() const;
  4584. __declspec(dllexport) TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;
  4585. __declspec(dllexport) TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;
  4586. __declspec(dllexport) TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;
  4587. __declspec(dllexport) TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;
  4588. __declspec(dllexport) TTimeIntervalDays DaysFrom(TTime aTime) const;
  4589. __declspec(dllexport) TTimeIntervalMonths MonthsFrom(TTime aTime) const;
  4590. __declspec(dllexport) TTimeIntervalYears YearsFrom(TTime aTime) const;
  4592. __declspec(dllexport) TInt DaysInMonth() const;
  4593. __declspec(dllexport) TDay DayNoInWeek() const;