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

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

Symbian

开发平台：

C/C++

S60UIExamplePlayContainer.inc：源码内容
  1. inline TInt FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const;
  2. inline TInt FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  3. inline TInt FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  4. inline TInt FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  5. template <class K>
  6. inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const
  7. { return RArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T> *)&apfnCompare); }
  8. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const;
  9. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const;
  10. inline TInt SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  11. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  12. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  13. inline TInt SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  14. inline TInt InsertInSignedKeyOrder(const T& anEntry);
  15. inline TInt InsertInUnsignedKeyOrder(const T& anEntry);
  16. inline TInt InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder);
  17. inline TInt InsertInSignedKeyOrderAllowRepeats(const T& anEntry);
  18. inline TInt InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry);
  19. inline TInt InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder);
  21. inline void AppendL(const T& anEntry);
  22. inline void InsertL(const T& anEntry, TInt aPos);
  23. inline TInt FindL(const T& anEntry) const;
  24. inline TInt FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
  25. inline TInt FindInSignedKeyOrderL(const T& anEntry) const;
  26. inline TInt FindInUnsignedKeyOrderL(const T& anEntry) const;
  27. inline TInt FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const;
  28. inline void FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  29. inline void FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  30. inline void FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  31. inline TInt SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const;
  32. inline TInt SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const;
  33. inline TInt SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  34. inline void SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  35. inline void SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  36. inline void SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  37. inline void InsertInSignedKeyOrderL(const T& anEntry);
  38. inline void InsertInUnsignedKeyOrderL(const T& anEntry);
  39. inline void InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder);
  40. inline void InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry);
  41. inline void InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry);
  42. inline void InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder);
  44. inline RArray(TInt aEntrySize,T* aEntries, TInt aCount);
  45. inline void GranularCompress();
  46. inline TInt Reserve(TInt aCount);
  47. inline void ReserveL(TInt aCount);
  48. inline void SortSigned();
  49. inline void SortUnsigned();
  50. inline void Sort(TLinearOrder<T> anOrder);
  51. inline TArray<T> Array() const;
  53. };
  54. #line 5331
  55. template<> class RArray<TInt> : private RPointerArrayBase
  56. {
  57. public:
  58. inline RArray();
  59. inline explicit RArray(TInt aGranularity);
  60. inline RArray(TInt aMinGrowBy, TInt aFactor);
  61. inline void Close();
  62. inline TInt Count() const;
  63. inline const TInt& operator[](TInt anIndex) const;
  64. inline TInt& operator[](TInt anIndex);
  65. inline TInt Append(TInt anEntry);
  66. inline TInt Insert(TInt anEntry, TInt aPos);
  67. inline void Remove(TInt anIndex);
  68. inline void Compress();
  69. inline void Reset();
  70. inline TInt Find(TInt anEntry) const;
  71. inline TInt FindInOrder(TInt anEntry) const;
  72. inline TInt FindInOrder(TInt anEntry, TInt& anIndex) const;
  73. inline TInt SpecificFindInOrder(TInt anEntry, TInt aMode) const;
  74. inline TInt SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const;
  75. inline TInt InsertInOrder(TInt anEntry);
  76. inline TInt InsertInOrderAllowRepeats(TInt anEntry);
  78. inline void AppendL(TInt anEntry);
  79. inline void InsertL(TInt anEntry, TInt aPos);
  80. inline TInt FindL(TInt anEntry) const;
  81. inline TInt FindInOrderL(TInt anEntry) const;
  82. inline void FindInOrderL(TInt anEntry, TInt& anIndex) const;
  83. inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const;
  84. inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const;
  85. inline void InsertInOrderL(TInt anEntry);
  86. inline void InsertInOrderAllowRepeatsL(TInt anEntry);
  88. inline RArray(TInt* aEntries, TInt aCount);
  89. inline void GranularCompress();
  90. inline TInt Reserve(TInt aCount);
  91. inline void ReserveL(TInt aCount);
  92. inline void Sort();
  93. inline TArray<TInt> Array() const;
  95. };
  96. #line 5387
  97. template<> class RArray<TUint> : private RPointerArrayBase
  98. {
  99. public:
  100. inline RArray();
  101. inline explicit RArray(TInt aGranularity);
  102. inline RArray(TInt aMinGrowBy, TInt aFactor);
  103. inline void Close();
  104. inline TInt Count() const;
  105. inline const TUint& operator[](TInt anIndex) const;
  106. inline TUint& operator[](TInt anIndex);
  107. inline TInt Append(TUint anEntry);
  108. inline TInt Insert(TUint anEntry, TInt aPos);
  109. inline void Remove(TInt anIndex);
  110. inline void Compress();
  111. inline void Reset();
  112. inline TInt Find(TUint anEntry) const;
  113. inline TInt FindInOrder(TUint anEntry) const;
  114. inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const;
  115. inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const;
  116. inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const;
  117. inline TInt InsertInOrder(TUint anEntry);
  118. inline TInt InsertInOrderAllowRepeats(TUint anEntry);
  120. inline void AppendL(TUint anEntry);
  121. inline void InsertL(TUint anEntry, TInt aPos);
  122. inline TInt FindL(TUint anEntry) const;
  123. inline TInt FindInOrderL(TUint anEntry) const;
  124. inline void FindInOrderL(TUint anEntry, TInt& anIndex) const;
  125. inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const;
  126. inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const;
  127. inline void InsertInOrderL(TUint anEntry);
  128. inline void InsertInOrderAllowRepeatsL(TUint anEntry);
  130. inline RArray(TUint* aEntries, TInt aCount);
  131. inline void GranularCompress();
  132. inline TInt Reserve(TInt aCount);
  133. inline void ReserveL(TInt aCount);
  134. inline void Sort();
  135. inline TArray<TUint> Array() const;
  137. };
  138. #line 5822
  139. extern TAny* operator new(TUint aSize) throw() ;
  145. extern TAny* operator new(TUint aSize,TUint anExtraSize) throw() ;
  151. extern void operator delete(TAny* aPtr) throw() ;
  158. extern TAny* operator new[](TUint aSize) throw() ;
  164. extern void operator delete[](TAny* aPtr) throw() ;
  171. inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
  178. inline TAny* operator new[](TUint aSize, TAny* aBase) throw() ;
  186. inline void operator delete(TAny* aPtr, TAny* aBase) throw() ;
  193. inline void operator delete[](TAny* aPtr, TAny* aBase) throw() ;
  194. #line 5886
  195. TBool operator==(TTrue,volatile const TBool);
  201. TBool operator==(volatile const TBool,TTrue);
  207. TBool operator!=(TTrue,volatile const TBool);
  213. TBool operator!=(volatile const TBool,TTrue);
  214. #line 5928
  215. class TIpcArgs
  216. {
  217. public:
  224. enum TArgType
  225. {
  226. EUnspecified = 0,
  227. EHandle = 1,
  228. EFlagDes = 4,
  229. EFlagConst = 2,
  230. EFlag16Bit = 1,
  231. EDes8 = EFlagDes,
  232. EDes16 = EFlagDes|EFlag16Bit,
  233. EDesC8 = EFlagDes|EFlagConst,
  234. EDesC16 = EFlagDes|EFlagConst|EFlag16Bit,
  235. };
  243. enum {
  244.      KBitsPerType=3
  245.      };
  251. enum TNothing {
  252. #line 5976
  253.               ENothing
  254.               };
  255. public:
  263. inline TIpcArgs()
  264. :iFlags(0)
  265. {}
  266. #line 5998
  267. template <class T0>
  268. inline explicit TIpcArgs(T0 a0)
  269. {
  270. Assign(iArgs[0],a0);
  271. iFlags=(Type(a0)<<(0*KBitsPerType));
  272. }
  273. #line 6015
  274. template <class T0,class T1>
  275. inline TIpcArgs(T0 a0,T1 a1)
  276. {
  277. Assign(iArgs[0],a0);
  278. Assign(iArgs[1],a1);
  279. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType));
  280. }
  281. #line 6035
  282. template <class T0,class T1,class T2>
  283. inline TIpcArgs(T0 a0,T1 a1,T2 a2)
  284. {
  285. Assign(iArgs[0],a0);
  286. Assign(iArgs[1],a1);
  287. Assign(iArgs[2],a2);
  288. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType));
  289. }
  290. #line 6058
  291. template <class T0,class T1,class T2,class T3>
  292. inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3)
  293. {
  294. Assign(iArgs[0],a0);
  295. Assign(iArgs[1],a1);
  296. Assign(iArgs[2],a2);
  297. Assign(iArgs[3],a3);
  298. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType))|(Type(a3)<<(3*KBitsPerType));
  299. }
  301. inline void Set(TInt aIndex,TNothing);
  302. inline void Set(TInt aIndex,TInt aValue);
  303. inline void Set(TInt aIndex,const TAny* aValue);
  304. inline void Set(TInt aIndex,RHandleBase aValue);
  305. inline void Set(TInt aIndex,const TDesC8* aValue);
  307. inline void Set(TInt aIndex,const TDesC16* aValue);
  309. inline void Set(TInt aIndex,TDes8* aValue);
  311. inline void Set(TInt aIndex,TDes16* aValue);
  313. private:
  314. inline static TArgType Type(TNothing);
  315. inline static TArgType Type(TInt);
  316. inline static TArgType Type(const TAny*);
  317. inline static TArgType Type(RHandleBase aValue);
  318. inline static TArgType Type(const TDesC8*);
  320. inline static TArgType Type(const TDesC16*);
  322. inline static TArgType Type(TDes8*);
  324. inline static TArgType Type(TDes16*);
  327. inline static void Assign(TInt&,TNothing);
  328. inline static void Assign(TInt& aArg,TInt aValue);
  329. inline static void Assign(TInt& aArg,const TAny* aValue);
  330. inline static void Assign(TInt& aArg,RHandleBase aValue);
  331. inline static void Assign(TInt& aArg,const TDesC8* aValue);
  333. inline static void Assign(TInt& aArg,const TDesC16* aValue);
  335. inline static void Assign(TInt& aArg,TDes8* aValue);
  337. inline static void Assign(TInt& aArg,TDes16* aValue);
  339. public:
  347. TInt iArgs[KMaxMessageArguments];
  348. #line 6123
  349. TInt iFlags;
  350. };
  357. struct SInt64
  358. {
  359. public:
  360. inline SInt64();
  361. inline SInt64(Int64 a);
  362. inline SInt64& operator=(Int64 a);
  363. inline operator Int64() const;
  364. public:
  365. TUint32 iData[2];
  366. };
  371. struct SUint64
  372. {
  373. public:
  374. inline SUint64();
  375. inline SUint64(Uint64 a);
  376. inline SUint64& operator=(Uint64 a);
  377. inline operator Uint64() const;
  378. public:
  379. TUint32 iData[2];
  380. };
  385. struct SDouble
  386. {
  387. public:
  388. inline SDouble();
  389. inline SDouble(TReal a);
  390. inline SDouble& operator=(TReal a);
  391. inline operator TReal() const;
  392. public:
  393. TUint32 iData[2];
  394. };
  395. #line 6181
  396. class TThreadStackInfo
  397. {
  398. public:
  402. TLinAddr iBase;
  408. TLinAddr iLimit;
  415. TLinAddr iExpandLimit;
  416. };
  417. #line 6214
  418. class XLeaveException
  419. {
  420. public:
  421. inline XLeaveException() {}
  422. inline XLeaveException(TInt aReason) {iR = aReason;}
  423. inline TInt Reason() const {return iR;}
  424. __declspec(dllexport) TInt GetReason() const;
  425. private:
  426. #line 6230
  427. private:
  429. TAny* iVtable;
  431. TInt iR;
  432. };
  439. namespace std {
  440.   bool uncaught_exception(void);
  441.   void terminate(void);
  442.   void unexpected(void);
  443.   typedef void (*terminate_handler)();
  444.   terminate_handler set_terminate(terminate_handler h) throw();
  445.   typedef void (*unexpected_handler)();
  446.   unexpected_handler set_unexpected(unexpected_handler h) throw();
  447. }
  455. class __UnknownWindowsType1;
  456. class __UnknownWindowsType2;
  459. class TWin32SEHTrap;
  465. typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  470. class TWin32SEHTrap
  471. {
  472. private:
  474.     TWin32SEHTrap(TWin32SEHTrap const &);
  475.     TWin32SEHTrap& operator=(TWin32SEHTrap const &);
  476. #line 6297
  477. public:
  478. __declspec(dllexport) TWin32SEHTrap();
  480. public:
  482. __declspec(dllexport) void Trap();
  485. __declspec(dllexport) void UnTrap();
  488. private:
  491. static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  498.     TWin32SEHTrap* iPrevExceptionRegistrationRecord;
  499. TWin32SEHExceptionHandler* iExceptionHandler;
  501. private:
  502. TUint32 iPadding[254];
  503. };
  504. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.inl" /* stack depth 6 */
  505. #line 9
  506. inline TAny* operator new(TUint , TAny* aBase) throw()
  507. {return aBase;}
  510. inline void operator delete(TAny* , TAny* ) throw()
  511. {}
  517. inline TAny* operator new[](TUint , TAny* aBase) throw()
  518. {return aBase;}
  521. inline void operator delete[](TAny* , TAny* ) throw()
  522. {}
  527. inline RAllocator::RAllocator()
  528. {
  529. iAccessCount=1;
  530. iHandleCount=0;
  531. iHandles=0;
  532. iFlags=0;
  533. iCellCount=0;
  534. iTotalAllocSize=0;
  535. }
  536. inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)
  537. {__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}
  540. inline RHeap::RHeap()
  541. {}
  546. inline TInt RHeap::MaxLength() const
  550. {return iMaxLength;}
  553. inline void RHeap::operator delete(TAny*, TAny*)
  558. {}
  561. inline TUint8* RHeap::Base() const
  562. #line 73
  563. {return iBase;}
  568. inline TInt RHeap::Size() const
  569. #line 89
  570. {return iTop-iBase;}
  575. inline TInt RHeap::Align(TInt a) const
  579. {return (((a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  584. inline const TAny* RHeap::Align(const TAny* a) const
  588. {return (const TAny*)((((TLinAddr)a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  593. inline TBool RHeap::IsLastCell(const SCell* aCell) const
  597. {return (((TUint8*)aCell) + aCell->len) == iTop;}
  603. inline void RHeap::Lock() const
  607. {((RFastLock&)iLock).Wait();}
  612. inline void RHeap::Unlock() const
  616. {((RFastLock&)iLock).Signal();}
  623. template <class T>
  624. inline TRefByValue<T>::TRefByValue(T &aRef)
  625. : iRef(aRef)
  631. {}
  636. template <class T>
  637. inline TRefByValue<T>::operator T &()
  641. {return(iRef);}
  642. #line 201
  643. inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)
  644. { return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }
  650. inline TChar::TChar()
  656. {}
  661. inline TChar::TChar(TUint aChar)
  662. : iChar(aChar)
  668. {}
  673. inline TChar& TChar::operator-=(TUint aChar)
  674. #line 241
  675. {iChar-=aChar;return(*this);}
  680. inline TChar& TChar::operator+=(TUint aChar)
  681. #line 256
  682. {iChar+=aChar;return(*this);}
  687. inline TChar TChar::operator-(TUint aChar)
  688. #line 273
  689. {return(iChar-aChar);}
  694. inline TChar TChar::operator+(TUint aChar)
  695. #line 288
  696. {return(iChar+aChar);}
  701. inline TChar::operator TUint() const
  708. {return(iChar);}
  714. inline TBool TDesC8::operator<(const TDesC8 &aDes) const
  715. #line 320
  716. {return(Compare(aDes)<0);}
  721. inline TBool TDesC8::operator<=(const TDesC8 &aDes) const
  722. #line 339
  723. {return(Compare(aDes)<=0);}
  728. inline TBool TDesC8::operator>(const TDesC8 &aDes) const
  729. #line 358
  730. {return(Compare(aDes)>0);}
  735. inline TBool TDesC8::operator>=(const TDesC8 &aDes) const
  736. #line 377
  737. {return(Compare(aDes)>=0);}
  742. inline TBool TDesC8::operator==(const TDesC8 &aDes) const
  743. #line 396
  744. {return(Compare(aDes)==0);}
  749. inline TBool TDesC8::operator!=(const TDesC8 &aDes) const
  750. #line 415
  751. {return(Compare(aDes)!=0);}
  756. inline const TUint8 &TDesC8::operator[](TInt anIndex) const
  757. #line 433
  758. {return(AtC(anIndex));}
  763. inline TInt TDesC8::Length() const
  771. {return(iLength&KMaskDesLength8);}
  776. inline TInt TDesC8::Size() const
  784. {return(Length());}
  789. inline void TDesC8::DoSetLength(TInt aLength)
  790. {iLength=(iLength&(~KMaskDesLength8))|aLength;}
  796. inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)
  797. #line 483
  798. {new(this) TPtrC8(aBuf,aLength);}
  803. inline void TPtrC8::Set(const TDesC8 &aDes)
  811. {new(this) TPtrC8(aDes);}
  816. inline void TPtrC8::Set(const TPtrC8& aPtr)
  817. #line 510
  818. {new(this) TPtrC8(aPtr);}
  825. inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)
  826. {return TPtr8(*this,aMaxLength);}
  832. template <TInt S>
  833. inline TBufC8<S>::TBufC8()
  834. : TBufCBase8()
  835. #line 540
  836. {}
  841. template <TInt S>
  842. inline TBufC8<S>::TBufC8(const TUint8 *aString)
  843. : TBufCBase8(aString,S)
  844. #line 564
  845. {}
  850. template <TInt S>
  851. inline TBufC8<S>::TBufC8(const TDesC8 &aDes)
  852. : TBufCBase8(aDes,S)
  853. #line 588
  854. {}
  859. template <TInt S>
  860. inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)
  861. #line 607
  862. {Copy(aString,S);return(*this);}
  867. template <TInt S>
  868. inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)
  869. #line 626
  870. {Copy(aDes,S);return(*this);}
  875. template <TInt S>
  876. inline TPtr8 TBufC8<S>::Des()
  877. #line 656
  878. {return DoDes(S);}
  885. inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)
  886. #line 681
  887. {return *this=static_cast<const TDesC8&>(aLcb);}
  888. #line 710
  889. inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)
  890. {
  891. Assign(HBufC8::NewL(aStream,aMaxLength));
  892. }
  899. inline TDes8 &TDes8::operator=(const TUint8 *aString)
  900. #line 733
  901.     {Copy(aString);return(*this);}
  906. inline TDes8 &TDes8::operator=(const TDesC8 &aDes)
  907. #line 751
  908.     {Copy(aDes);return(*this);}
  913. inline TDes8 &TDes8::operator=(const TDes8 &aDes)
  914. #line 769
  915.     {Copy(aDes);return(*this);}
  920. inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)
  921. #line 788
  922. {Append(aDes);return(*this);}
  927. inline const TUint8 &TDes8::operator[](TInt anIndex) const
  928. #line 806
  929. {return(AtC(anIndex));}
  934. inline TUint8 &TDes8::operator[](TInt anIndex)
  935. #line 825
  936. {return((TUint8 &)AtC(anIndex));}
  941. inline TInt TDes8::MaxLength() const
  942. #line 839
  943. {return(iMaxLength);}
  948. inline TInt TDes8::MaxSize() const
  949. #line 853
  950. {return(iMaxLength);}
  955. inline TUint8 * TDes8::WPtr() const
  956. {return((TUint8 *)Ptr());}
  962. inline TPtr8 &TPtr8::operator=(const TUint8 *aString)
  963. #line 879
  964. {Copy(aString);return(*this);}
  969. inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)
  970. #line 899
  971. {Copy(aDes);return(*this);}
  976. inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)
  977. #line 919
  978. {Copy(aDes);return(*this);}
  983. inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)
  984. #line 940
  985. {new(this) TPtr8(aBuf,aLength,aMaxLength);}
  990. inline void TPtr8::Set(const TPtr8 &aPtr)
  991. #line 955
  992. {new(this) TPtr8(aPtr);}
  998. template <TInt S>
  999. inline TBuf8<S>::TBuf8()
  1000. : TBufBase8(S)
  1001. #line 972
  1002. {}
  1007. template <TInt S>
  1008. inline TBuf8<S>::TBuf8(TInt aLength)
  1009. : TBufBase8(aLength,S)
  1010. #line 994
  1011. {}
  1016. template <TInt S>
  1017. inline TBuf8<S>::TBuf8(const TUint8 *aString)
  1018. : TBufBase8(aString,S)
  1019. #line 1018
  1020. {}
  1025. template <TInt S>
  1026. inline TBuf8<S>::TBuf8(const TDesC8 &aDes)
  1027. : TBufBase8(aDes,S)
  1028. #line 1042
  1029. {}
  1034. template <TInt S>
  1035. inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)
  1036. #line 1062
  1037. {Copy(aString);return(*this);}
  1042. template <TInt S>
  1043. inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)
  1044. #line 1082
  1045. {Copy(aDes);return(*this);}
  1050. template <TInt S>
  1051. inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)
  1052. #line 1100
  1053. {Copy(aBuf);return *this;}
  1059. template <TInt S>
  1060. inline TAlignedBuf8<S>::TAlignedBuf8()
  1061. : TBufBase8(S)
  1062. #line 1117
  1063. {}
  1068. template <TInt S>
  1069. inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)
  1070. : TBufBase8(aLength,S)
  1071. #line 1139
  1072. {}
  1077. template <TInt S>
  1078. inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)
  1079. : TBufBase8(aString,S)
  1080. #line 1163
  1081. {}
  1086. template <TInt S>
  1087. inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)
  1088. : TBufBase8(aDes,S)
  1089. #line 1187
  1090. {}
  1095. template <TInt S>
  1096. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)
  1097. #line 1207
  1098. {Copy(aString);return(*this);}
  1103. template <TInt S>
  1104. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)
  1105. #line 1227
  1106. {Copy(aDes);return(*this);}
  1111. template <TInt S>
  1112. inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)
  1113. #line 1245
  1114. {Copy(aBuf);return *this;}
  1120. template <TInt S>
  1121. inline const TDesC8* TLitC8<S>::operator&() const
  1127. {return (reinterpret_cast<const TDesC8*>(this)) ;}
  1132. template <TInt S>
  1133. inline const TDesC8& TLitC8<S>::operator()() const
  1139. {return *operator&();}
  1144. template <TInt S>
  1145. inline TLitC8<S>::operator const TDesC8&() const
  1150. {return *operator&();}
  1154. template <TInt S>
  1155. inline TLitC8<S>::operator const __TRefDesC8() const
  1162. {return *operator&();}
  1169. inline TBool TDesC16::operator<(const TDesC16 &aDes) const
  1170. #line 1314
  1171. {return(Compare(aDes)<0);}
  1176. inline TBool TDesC16::operator<=(const TDesC16 &aDes) const
  1177. #line 1333
  1178. {return(Compare(aDes)<=0);}
  1183. inline TBool TDesC16::operator>(const TDesC16 &aDes) const
  1184. #line 1352
  1185. {return(Compare(aDes)>0);}
  1190. inline TBool TDesC16::operator>=(const TDesC16 &aDes) const
  1191. #line 1371
  1192. {return(Compare(aDes)>=0);}
  1197. inline TBool TDesC16::operator==(const TDesC16 &aDes) const
  1198. #line 1390
  1199. {return(Compare(aDes)==0);}
  1204. inline TBool TDesC16::operator!=(const TDesC16 &aDes) const
  1205. #line 1409
  1206. {return(Compare(aDes)!=0);}
  1211. inline const TUint16 &TDesC16::operator[](TInt anIndex) const
  1212. #line 1427
  1213. {return(AtC(anIndex));}
  1218. inline TInt TDesC16::Length() const
  1226. {return(iLength&KMaskDesLength16);}
  1231. inline TInt TDesC16::Size() const
  1232. #line 1454
  1233. {return(Length()<<1);}
  1238. inline void TDesC16::DoSetLength(TInt aLength)
  1239. {iLength=(iLength&(~KMaskDesLength16))|aLength;}
  1245. inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)
  1246. #line 1478
  1247. {new(this) TPtrC16(aBuf,aLength);}
  1252. inline void TPtrC16::Set(const TDesC16 &aDes)
  1260. {new(this) TPtrC16(aDes);}
  1265. inline void TPtrC16::Set(const TPtrC16& aPtr)
  1266. {new(this) TPtrC16(aPtr);}
  1272. inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)
  1273. {return TPtr16(*this,aMaxLength);}
  1279. template <TInt S>
  1280. inline TBufC16<S>::TBufC16()
  1281. : TBufCBase16()
  1282. #line 1526
  1283. {}
  1288. template <TInt S>
  1289. inline TBufC16<S>::TBufC16(const TUint16 *aString)
  1290. : TBufCBase16(aString,S)
  1291. #line 1550
  1292. {}
  1297. template <TInt S>
  1298. inline TBufC16<S>::TBufC16(const TDesC16 &aDes)
  1299. : TBufCBase16(aDes,S)
  1300. #line 1574
  1301. {}
  1306. template <TInt S>
  1307. inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)
  1308. #line 1593
  1309. {Copy(aString,S);return(*this);}
  1314. template <TInt S>
  1315. inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)
  1316. #line 1612
  1317. {Copy(aDes,S);return(*this);}
  1322. template <TInt S>
  1323. inline TPtr16 TBufC16<S>::Des()
  1324. #line 1642
  1325. {return(DoDes(S));}
  1332. inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)
  1333. #line 1667
  1334. {return *this=static_cast<const TDesC16&>(aLcb);}
  1341. inline TDes16 &TDes16::operator=(const TUint16 *aString)
  1342. #line 1687
  1343.     {Copy(aString);return(*this);}
  1348. inline TDes16 &TDes16::operator=(const TDesC16 &aDes)
  1349. #line 1705
  1350.     {Copy(aDes);return(*this);}
  1355. inline TDes16 &TDes16::operator=(const TDes16 &aDes)
  1356. #line 1723
  1357.     {Copy(aDes);return(*this);}
  1362. inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)
  1363. #line 1742
  1364. {Append(aDes);return(*this);}
  1369. inline const TUint16 &TDes16::operator[](TInt anIndex) const
  1370. #line 1759
  1371. {return(AtC(anIndex));}
  1376. inline TUint16 &TDes16::operator[](TInt anIndex)
  1377. #line 1778
  1378. {return((TUint16 &)AtC(anIndex));}
  1383. inline TInt TDes16::MaxLength() const
  1384. #line 1792
  1385. {return(iMaxLength);}
  1390. inline TInt TDes16::MaxSize() const
  1391. #line 1806
  1392. {return(iMaxLength<<1);}
  1397. inline TUint16 * TDes16::WPtr() const
  1398. {return((TUint16 *)Ptr());}
  1404. inline TPtr16 &TPtr16::operator=(const TUint16 *aString)
  1405. #line 1832
  1406. {Copy(aString);return(*this);}
  1411. inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)
  1412. #line 1852
  1413. {Copy(aDes);return(*this);}
  1418. inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)
  1419. #line 1872
  1420. {Copy(aDes);return(*this);}
  1425. inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)
  1426. #line 1893
  1427. {new(this) TPtr16(aBuf,aLength,aMaxLength);}
  1432. inline void TPtr16::Set(const TPtr16 &aPtr)
  1433. #line 1908
  1434. {new(this) TPtr16(aPtr);}
  1440. template <TInt S>
  1441. inline TBuf16<S>::TBuf16()
  1442. : TBufBase16(S)
  1443. #line 1925
  1444. {}
  1449. template <TInt S>
  1450. inline TBuf16<S>::TBuf16(TInt aLength)
  1451. : TBufBase16(aLength,S)
  1452. #line 1947
  1453. {}
  1458. template <TInt S>
  1459. inline TBuf16<S>::TBuf16(const TUint16 *aString)
  1460. : TBufBase16(aString,S)
  1461. #line 1971
  1462. {}
  1467. template <TInt S>
  1468. inline TBuf16<S>::TBuf16(const TDesC16 &aDes)
  1469. : TBufBase16(aDes,S)
  1470. #line 1995
  1471. {}
  1476. template <TInt S>
  1477. inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)
  1478. #line 2015
  1479. {Copy(aString);return(*this);}
  1484. template <TInt S>
  1485. inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)
  1486. #line 2035
  1487. {Copy(aDes);return(*this);}
  1492. template <TInt S>
  1493. inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)
  1494. #line 2056
  1495. {Copy(aBuf);return *this;}
  1496. #line 2083
  1497. inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)
  1498. {
  1499. Assign(HBufC16::NewL(aStream,aMaxLength));
  1500. }
  1504. template <TInt S>
  1505. inline const TDesC16* TLitC16<S>::operator&() const
  1511. {return (reinterpret_cast<const TDesC16*>(this)) ;}
  1516. template <TInt S>
  1517. inline const TDesC16& TLitC16<S>::operator()() const
  1523. {return *operator&();}
  1528. template <TInt S>
  1529. inline TLitC16<S>::operator const TDesC16&() const
  1534. {return *operator&();}
  1539. template <TInt S>
  1540. inline TLitC16<S>::operator const __TRefDesC16() const
  1547. {return *operator&();}
  1555. template <TInt S>
  1556. inline TBufC<S>::TBufC()
  1557. : TBufCBase16()
  1558. #line 2157
  1559. {}
  1564. template <TInt S>
  1565. inline TBufC<S>::TBufC(const TText *aString)
  1566. : TBufCBase16(aString,S)
  1567. #line 2186
  1568. {}
  1573. template <TInt S>
  1574. inline TBufC<S>::TBufC(const TDesC &aDes)
  1575. : TBufCBase16(aDes,S)
  1576. #line 2219
  1577. {}
  1578. #line 2234
  1579. template <TInt S>
  1580. inline TBufC<S> &TBufC<S>::operator=(const TText *aString)
  1581. #line 2253
  1582. {Copy(aString,S);return(*this);}
  1587. template <TInt S>
  1588. inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)
  1589. #line 2277
  1590. {Copy(aDes,S);return(*this);}
  1595. template <TInt S>
  1596. inline TPtr TBufC<S>::Des()
  1597. #line 2308
  1598. {return(DoDes(S));}
  1605. template <TInt S>
  1606. inline TBuf<S>::TBuf()
  1607. : TBufBase16(S)
  1615. {}
  1620. template <TInt S>
  1621. inline TBuf<S>::TBuf(TInt aLength)
  1622. : TBufBase16(aLength,S)
  1623. #line 2350
  1624. {}
  1629. template <TInt S>
  1630. inline TBuf<S>::TBuf(const TText *aString)
  1631. : TBufBase16(aString,S)
  1632. #line 2378
  1633. {}
  1638. template <TInt S>
  1639. inline TBuf<S>::TBuf(const TDesC &aDes)
  1640. : TBufBase16(aDes,S)
  1641. #line 2407
  1642. {}
  1643. #line 2426
  1644. template <TInt S>
  1645. inline TBuf<S> &TBuf<S>::operator=(const TText *aString)
  1646. {Copy(aString);return(*this);}
  1647. template <TInt S>
  1648. inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)
  1649. {Copy(aDes);return(*this);}
  1650. template <TInt S>
  1651. inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)
  1652. {Copy(aBuf);return(*this);}
  1658. template <TInt S>
  1659. inline const TDesC* TLitC<S>::operator&() const
  1665. {return (reinterpret_cast<const TDesC*>(this)) ;}
  1670. template <TInt S>
  1671. inline const TDesC& TLitC<S>::operator()() const
  1677. {return *operator&();}
  1682. template <TInt S>
  1683. inline TLitC<S>::operator const TDesC&() const
  1688. {return *operator&();}
  1693. template <TInt S>
  1694. inline TLitC<S>::operator const __TRefDesC() const
  1701. {return *operator&();}
  1707. template <class T>
  1708. inline TPckgC<T>::TPckgC(const T &aRef)
  1709. : TPtrC8((const TUint8 *)&aRef,sizeof(T))
  1717. {}
  1722. template <class T>
  1723. inline const T &TPckgC<T>::operator()() const
  1730. {return(*((const T *)iPtr));}
  1736. template <class T>
  1737. inline TPckg<T>::TPckg(const T &aRef)
  1738. : TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T))
  1746. {}
  1751. template <class T>
  1752. inline T &TPckg<T>::operator()()
  1759. {return(*((T *)iPtr));}
  1765. template <class T>
  1766. inline TPckgBuf<T>::TPckgBuf()
  1767. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1775. {new(&this->iBuf[0]) T;}
  1780. template <class T>
  1781. inline TPckgBuf<T>::TPckgBuf(const T &aRef)
  1782. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1783. #line 2576
  1784. {new(&this->iBuf[0]) T(aRef);}
  1789. template <class T>
  1790. inline TPckgBuf<T> &TPckgBuf<T>::operator=(const TPckgBuf<T> &aRef)
  1798. {this->Copy(aRef);return(*this);}
  1803. template <class T>
  1804. inline T &TPckgBuf<T>::operator=(const T &aRef)
  1805. #line 2605
  1806. {this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));}
  1811. template <class T>
  1812. inline T &TPckgBuf<T>::operator()()
  1819. {return(*((T *)&this->iBuf[0]));}
  1824. template <class T>
  1825. inline const T &TPckgBuf<T>::operator()() const
  1832. {return(*((T *)&this->iBuf[0]));}
  1838. inline TRequestStatus::TRequestStatus()
  1842. : iFlags(0)
  1843. {}
  1848. inline TRequestStatus::TRequestStatus(TInt aVal)
  1856. : iStatus(aVal),
  1857. iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0)
  1859. {}
  1864. inline TInt TRequestStatus::operator=(TInt aVal)
  1872. {
  1873. if(aVal==KRequestPending)
  1874. iFlags|=TRequestStatus::ERequestPending;
  1875. else
  1876. iFlags&=~TRequestStatus::ERequestPending;
  1877. return (iStatus=aVal);
  1878. }
  1883. inline TBool TRequestStatus::operator==(TInt aVal) const
  1884. #line 2691
  1885. {return(iStatus==aVal);}
  1890. inline TBool TRequestStatus::operator!=(TInt aVal) const
  1891. #line 2705
  1892. {return(iStatus!=aVal);}
  1897. inline TBool TRequestStatus::operator>=(TInt aVal) const
  1898. #line 2720
  1899. {return(iStatus>=aVal);}
  1904. inline TBool TRequestStatus::operator<=(TInt aVal) const
  1905. #line 2735
  1906. {return(iStatus<=aVal);}
  1911. inline TBool TRequestStatus::operator>(TInt aVal) const
  1912. #line 2750
  1913. {return(iStatus>aVal);}
  1918. inline TBool TRequestStatus::operator<(TInt aVal) const
  1919. #line 2765
  1920. {return(iStatus<aVal);}
  1925. inline TInt TRequestStatus::Int() const
  1931. {return(iStatus);}
  1938. inline TPoint::TPoint()
  1939. : iX(0),iY(0)
  1943. {}
  1948. inline TPoint::TPoint(TInt aX,TInt aY)
  1949. : iX(aX),iY(aY)
  1956. {}
  1962. inline TSize::TSize()
  1963. : iWidth(0),iHeight(0)
  1967. {}
  1972. inline TSize::TSize(TInt aWidth,TInt aHeight)
  1973. : iWidth(aWidth),iHeight(aHeight)
  1980. {}
  1987. inline RHandleBase::RHandleBase()
  1988. : iHandle(0)
  1992. {}
  1998. inline RHandleBase::RHandleBase(TInt aHandle)
  1999. : iHandle(aHandle)
  2000. #line 2853
  2001. {}
  2007. inline void RHandleBase::SetHandle(TInt aHandle)
  2014. { iHandle=aHandle; }
  2019. inline TInt RHandleBase::Handle() const
  2025. {return(iHandle);}
  2030. inline TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError)
  2031. #line 2899
  2032. {
  2033. if(aHandleOrError>=0)
  2034. {
  2035. iHandle = aHandleOrError;
  2036. return KErrNone;
  2037. }
  2038. iHandle = 0;
  2039. return aHandleOrError;
  2040. }
  2047. inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType)
  2048. #line 2935
  2049. {return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));}
  2050. #line 2947
  2051. inline RFastLock::RFastLock()
  2052. : iCount(0)
  2053. {}
  2054. #line 2960
  2055. inline RMessagePtr2::RMessagePtr2()
  2056. : iHandle(0)
  2057. {}
  2058. #line 2972
  2059. inline TBool RMessagePtr2::IsNull() const
  2060. {return iHandle==0;}
  2061. #line 2983
  2062. inline TInt RMessagePtr2::Handle() const
  2063. {return iHandle;}
  2064. inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2065. {return aLeft.Handle()==aRight.Handle();}
  2066. inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2067. {return aLeft.Handle()!=aRight.Handle();}
  2068. #line 3000
  2069. inline RMessage2::RMessage2()
  2070. {}
  2071. #line 3011
  2072. inline TInt RMessage2::Function() const
  2073. {return(iFunction);}
  2074. #line 3022
  2075. inline TInt RMessage2::Int0() const
  2076. {return(iArgs[0]);}
  2077. #line 3033
  2078. inline TInt RMessage2::Int1() const
  2079. {return(iArgs[1]);}
  2080. #line 3044
  2081. inline TInt RMessage2::Int2() const
  2082. {return(iArgs[2]);}
  2083. #line 3054
  2084. inline TInt RMessage2::Int3() const
  2085. {return(iArgs[3]);}
  2086. #line 3064
  2087. inline const TAny *RMessage2::Ptr0() const
  2088. {return((const TAny *)iArgs[0]);}
  2089. #line 3075
  2090. inline const TAny *RMessage2::Ptr1() const
  2091. {return((const TAny *)iArgs[1]);}
  2092. #line 3086
  2093. inline const TAny *RMessage2::Ptr2() const
  2094. {return((const TAny *)iArgs[2]);}
  2095. #line 3097
  2096. inline const TAny *RMessage2::Ptr3() const
  2097. {return((const TAny *)iArgs[3]);}
  2098. #line 3107
  2099. inline CSession2* RMessage2::Session() const
  2100. {return (CSession2*)iSessionPtr; }
  2106. inline TUid TUid::Uid(TInt aUid)
  2107. #line 3123
  2108. {TUid uid={aUid};return uid;}
  2113. inline TUid TUid::Null()
  2119. {TUid uid={KNullUidValue};return uid;}
  2126. template <class T>
  2127. inline TArray<T>::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr)
  2128. : iPtr(aPtr),iCount(aCount),iAt(anAt)
  2129. #line 3195
  2130. {}
  2135. template <class T>
  2136. inline TInt TArray<T>::Count() const
  2143. {return((*iCount)(iPtr));}
  2148. template <class T>
  2149. inline const T &TArray<T>::operator[](TInt anIndex) const
  2150. #line 3232
  2151. {return(*((const T *)(*iAt)(iPtr,anIndex)));}
  2158. template <class T>
  2159. inline TIdentityRelation<T>::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) )
  2160. #line 3254
  2161. { iIdentity=(TGeneralIdentityRelation)anIdentity; }
  2166. template <class T>
  2167. inline TIdentityRelation<T>::operator TGeneralIdentityRelation() const
  2172. { return iIdentity; }
  2178. template <class T>
  2179. inline TLinearOrder<T>::TLinearOrder( TInt(*anOrder)(const T&, const T&) )
  2180. #line 3288
  2181. { iOrder=(TGeneralLinearOrder)anOrder; }
  2186. template <class T>
  2187. inline TLinearOrder<T>::operator TGeneralLinearOrder() const
  2192. { return iOrder; }
  2193. #line 3312
  2194. template <class T>
  2195. inline RPointerArray<T>::RPointerArray()
  2196. : RPointerArrayBase()
  2197. {}
  2198. #line 3331
  2199. template <class T>
  2200. inline RPointerArray<T>::RPointerArray(TInt aGranularity)
  2201. : RPointerArrayBase(aGranularity)
  2202. {}
  2203. #line 3354
  2204. template <class T>
  2205. inline RPointerArray<T>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2206. : RPointerArrayBase(aMinGrowBy, aFactor)
  2207. {}
  2212. template <class T>
  2213. inline void RPointerArray<T>::Close()
  2214. #line 3372
  2215. {RPointerArrayBase::Close();}
  2220. template <class T>
  2221. inline TInt RPointerArray<T>::Count() const
  2227. { return RPointerArrayBase::Count(); }
  2232. template <class T>
  2233. inline T* const& RPointerArray<T>::operator[](TInt anIndex) const
  2234. #line 3408
  2235. {return (T* const&)At(anIndex);}
  2240. template <class T>
  2241. inline T*& RPointerArray<T>::operator[](TInt anIndex)
  2242. #line 3432
  2243. {return (T*&)At(anIndex);}
  2248. template <class T>
  2249. inline TInt RPointerArray<T>::Append(const T* anEntry)
  2250. #line 3447
  2251. { return RPointerArrayBase::Append(anEntry); }
  2256. template <class T>
  2257. inline TInt RPointerArray<T>::Insert(const T* anEntry, TInt aPos)
  2258. #line 3468
  2259. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2264. template <class T>
  2265. inline void RPointerArray<T>::Remove(TInt anIndex)
  2266. #line 3488
  2267. {RPointerArrayBase::Remove(anIndex);}
  2272. template <class T>
  2273. inline void RPointerArray<T>::Compress()
  2274. #line 3503
  2275. {RPointerArrayBase::Compress();}
  2280. template <class T>
  2281. inline void RPointerArray<T>::Reset()
  2282. #line 3522
  2283. {RPointerArrayBase::Reset();}
  2288. template <class T>
  2289. inline TInt RPointerArray<T>::Find(const T* anEntry) const
  2290. #line 3542
  2291. { return RPointerArrayBase::Find(anEntry); }
  2296. template <class T>
  2297. inline TInt RPointerArray<T>::Find(const T* anEntry, TIdentityRelation<T> anIdentity) const
  2298. #line 3566
  2299. { return RPointerArrayBase::Find(anEntry,anIdentity); }
  2304. template <class T>
  2305. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry) const
  2306. #line 3584
  2307. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2312. template <class T>
  2313. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const
  2314. #line 3606
  2315. { return RPointerArrayBase::FindIsq(anEntry,anOrder); }
  2320. template <class T>
  2321. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry, TInt& anIndex) const
  2322. #line 3631
  2323. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2328. template <class T>
  2329. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2330. #line 3660
  2331. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); }
  2336. template <class T>
  2337. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const
  2338. #line 3691
  2339. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2344. template <class T>
  2345. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2346. #line 3726
  2347. { return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); }
  2352. template <class T>
  2353. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const
  2354. #line 3766
  2355. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2360. template <class T>
  2361. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2362. #line 3810
  2363. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); }
  2368. template <class T>
  2369. inline TInt RPointerArray<T>::InsertInAddressOrder(const T* anEntry)
  2370. #line 3833
  2371. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2376. template <class T>
  2377. inline TInt RPointerArray<T>::InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder)
  2378. #line 3862
  2379. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); }
  2384. template <class T>
  2385. inline TInt RPointerArray<T>::InsertInAddressOrderAllowRepeats(const T* anEntry)
  2386. #line 3885
  2387. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2392. template <class T>
  2393. inline TInt RPointerArray<T>::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder)
  2394. #line 3911
  2395. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); }
  2401. template <class T>
  2402. inline RPointerArray<T>::RPointerArray(T** aEntries, TInt aCount)
  2403. : RPointerArrayBase((TAny **)aEntries, aCount)
  2404. #line 3935
  2405. {}
  2410. template <class T>
  2411. inline void RPointerArray<T>::GranularCompress()
  2412. #line 3950
  2413. {RPointerArrayBase::GranularCompress();}
  2418. template <class T>
  2419. inline TInt RPointerArray<T>::Reserve(TInt aCount)
  2420. #line 3969
  2421. { return RPointerArrayBase::DoReserve(aCount); }
  2426. template <class T>
  2427. inline void RPointerArray<T>::SortIntoAddressOrder()
  2431. { HeapSortUnsigned(); }
  2436. template <class T>
  2437. inline void RPointerArray<T>::Sort(TLinearOrder<T> anOrder)
  2438. #line 3996
  2439. { HeapSort(anOrder); }
  2444. template <class T>
  2445. inline TArray<T*> RPointerArray<T>::Array() const
  2453. { return TArray<T*>(GetCount,GetElementPtr,(const CBase*)this); }
  2458. template <class T>
  2459. void RPointerArray<T>::ResetAndDestroy()
  2460. #line 4026
  2461. {
  2462. TInt c=Count();
  2463. T** pE=(T**)Entries();
  2464. ZeroCount();
  2465. TInt i;
  2466. for (i=0; i<c; i++)
  2467. {
  2468. delete *pE;
  2469. pE++;
  2470. }
  2471. Reset();
  2472. }
  2473. #line 4049
  2474. inline RPointerArray<TAny>::RPointerArray()
  2475. : RPointerArrayBase()
  2476. {}
  2477. #line 4067
  2478. inline RPointerArray<TAny>::RPointerArray(TInt aGranularity)
  2479. : RPointerArrayBase(aGranularity)
  2480. {}
  2481. #line 4089
  2482. inline RPointerArray<TAny>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2483. : RPointerArrayBase(aMinGrowBy, aFactor)
  2484. {}
  2489. inline void RPointerArray<TAny>::Close()
  2490. #line 4105
  2491. {RPointerArrayBase::Close();}
  2496. inline TInt RPointerArray<TAny>::Count() const
  2502. { return RPointerArrayBase::Count(); }
  2507. inline TAny* const& RPointerArray<TAny>::operator[](TInt anIndex) const
  2508. #line 4139
  2509. {return At(anIndex);}
  2514. inline TAny*& RPointerArray<TAny>::operator[](TInt anIndex)
  2515. #line 4162
  2516. {return At(anIndex);}
  2521. inline TInt RPointerArray<TAny>::Append(const TAny* anEntry)
  2522. #line 4176
  2523. { return RPointerArrayBase::Append(anEntry); }
  2528. inline TInt RPointerArray<TAny>::Insert(const TAny* anEntry, TInt aPos)
  2529. #line 4196
  2530. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2535. inline void RPointerArray<TAny>::Remove(TInt anIndex)
  2536. #line 4215
  2537. {RPointerArrayBase::Remove(anIndex);}
  2542. inline void RPointerArray<TAny>::Compress()
  2543. #line 4229
  2544. {RPointerArrayBase::Compress();}
  2549. inline void RPointerArray<TAny>::Reset()
  2550. #line 4247
  2551. {RPointerArrayBase::Reset();}
  2556. inline TInt RPointerArray<TAny>::Find(const TAny* anEntry) const
  2557. #line 4266
  2558. { return RPointerArrayBase::Find(anEntry); }
  2563. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry) const
  2564. #line 4283
  2565. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2570. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const
  2571. #line 4307
  2572. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2577. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const
  2578. #line 4337
  2579. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2584. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const
  2585. #line 4376
  2586. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2591. inline TInt RPointerArray<TAny>::InsertInAddressOrder(const TAny* anEntry)
  2592. #line 4398
  2593. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2598. inline TInt RPointerArray<TAny>::InsertInAddressOrderAllowRepeats(const TAny* anEntry)
  2599. #line 4420
  2600. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2606. inline RPointerArray<TAny>::RPointerArray(TAny** aEntries, TInt aCount)
  2607. : RPointerArrayBase((TAny **)aEntries, aCount)
  2608. #line 4443
  2609. {}
  2614. inline void RPointerArray<TAny>::GranularCompress()
  2615. #line 4457
  2616. {RPointerArrayBase::GranularCompress();}
  2621. inline void RPointerArray<TAny>::SortIntoAddressOrder()
  2625. { HeapSortUnsigned(); }
  2630. inline TArray<TAny*> RPointerArray<TAny>::Array() const
  2638. { return TArray<TAny*>(GetCount,GetElementPtr,(const CBase*)this); }
  2643. template <class T>
  2644. inline RArray<T>::RArray()
  2645. : RArrayBase(sizeof(T))
  2646. #line 4497
  2647. {}
  2652. template <class T>
  2653. inline RArray<T>::RArray(TInt aGranularity)
  2654. : RArrayBase(sizeof(T),aGranularity)
  2655. #line 4519
  2656. {}
  2661. template <class T>
  2662. inline RArray<T>::RArray(TInt aGranularity, TInt aKeyOffset)
  2663. : RArrayBase(sizeof(T),aGranularity,aKeyOffset)
  2664. #line 4543
  2665. {}
  2666. #line 4567
  2667. template <class T>
  2668. inline RArray<T>::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
  2669. : RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor)
  2670. {}
  2675. template <class T>
  2676. inline void RArray<T>::Close()
  2682. {RArrayBase::Close();}
  2687. template <class T>
  2688. inline TInt RArray<T>::Count() const
  2694. {return RArrayBase::Count();}
  2699. template <class T>
  2700. inline const T& RArray<T>::operator[](TInt anIndex) const
  2701. #line 4616
  2702. {return *(const T*)At(anIndex); }
  2707. template <class T>
  2708. inline T& RArray<T>::operator[](TInt anIndex)
  2709. #line 4638
  2710. {return *(T*)At(anIndex); }
  2715. template <class T>
  2716. inline TInt RArray<T>::Append(const T& anEntry)
  2717. #line 4653
  2718. {return RArrayBase::Append(&anEntry);}
  2723. template <class T>
  2724. inline TInt RArray<T>::Insert(const T& anEntry, TInt aPos)
  2725. #line 4675
  2726. {return RArrayBase::Insert(&anEntry,aPos);}
  2731. template <class T>
  2732. inline void RArray<T>::Remove(TInt anIndex)
  2733. #line 4692
  2734. {RArrayBase::Remove(anIndex);}
  2739. template <class T>
  2740. inline void RArray<T>::Compress()
  2748. {RArrayBase::Compress();}
  2753. template <class T>
  2754. inline void RArray<T>::Reset()
  2755. #line 4721
  2756. {RArrayBase::Reset();}
  2761. template <class T>
  2762. inline TInt RArray<T>::Find(const T& anEntry) const
  2763. #line 4743
  2764. {return RArrayBase::Find(&anEntry);}
  2769. template <class T>
  2770. inline TInt RArray<T>::Find(const T& anEntry, TIdentityRelation<T> anIdentity) const
  2771. #line 4768
  2772. {return RArrayBase::Find(&anEntry,anIdentity);}
  2777. template <class T>
  2778. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry) const
  2779. #line 4787
  2780. {return RArrayBase::FindIsqSigned(&anEntry);}
  2785. template <class T>
  2786. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry) const
  2787. #line 4806
  2788. {return RArrayBase::FindIsqUnsigned(&anEntry);}
  2793. template <class T>
  2794. inline TInt RArray<T>::FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const
  2795. #line 4828
  2796. {return RArrayBase::FindIsq(&anEntry,anOrder);}
  2801. template <class T>
  2802. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2803. #line 4851
  2804. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex);}
  2809. template <class T>
  2810. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2811. #line 4875
  2812. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);}
  2817. template <class T>
  2818. inline TInt RArray<T>::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2819. #line 4902
  2820. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);}
  2825. template <class T>
  2826. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const
  2827. #line 4936
  2828. {return RArrayBase::FindIsqSigned(&anEntry,aMode);}
  2833. template <class T>
  2834. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const
  2835. #line 4970
  2836. {return RArrayBase::FindIsqUnsigned(&anEntry,aMode);}
  2841. template <class T>
  2842. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2843. #line 5003
  2844. {return RArrayBase::FindIsq(&anEntry,anOrder,aMode);}
  2849. template <class T>
  2850. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2851. #line 5042
  2852. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);}
  2857. template <class T>
  2858. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2859. #line 5081
  2860. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);}
  2865. template <class T>
  2866. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2867. #line 5123
  2868. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);}
  2873. template <class T>
  2874. inline TInt RArray<T>::InsertInSignedKeyOrder(const T& anEntry)
  2875. #line 5146
  2876. {return RArrayBase::InsertIsqSigned(&anEntry,EFalse);}
  2881. template <class T>
  2882. inline TInt RArray<T>::InsertInUnsignedKeyOrder(const T& anEntry)
  2883. #line 5169
  2884. {return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);}
  2889. template <class T>
  2890. inline TInt RArray<T>::InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder)
  2891. #line 5197
  2892. {return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);}
  2897. template <class T>
  2898. inline TInt RArray<T>::InsertInSignedKeyOrderAllowRepeats(const T& anEntry)
  2899. #line 5221
  2900. {return RArrayBase::InsertIsqSigned(&anEntry,ETrue);}
  2905. template <class T>
  2906. inline TInt RArray<T>::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry)
  2907. #line 5245
  2908. {return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);}
  2913. template <class T>
  2914. inline TInt RArray<T>::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder)
  2915. #line 5272
  2916. {return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);}
  2922. template <class T>
  2923. inline RArray<T>::RArray(TInt aEntrySize,T* aEntries, TInt aCount)
  2924. : RArrayBase(aEntrySize,aEntries,aCount)
  2925. #line 5303
  2926. {}
  2931. template <class T>
  2932. inline void RArray<T>::GranularCompress()
  2933. #line 5318
  2934. {RArrayBase::GranularCompress();}
  2939. template <class T>
  2940. inline TInt RArray<T>::Reserve(TInt aCount)
  2941. #line 5337
  2942. { return RArrayBase::DoReserve(aCount); }
  2947. template <class T>
  2948. inline void RArray<T>::SortSigned()
  2953. {HeapSortSigned();}
  2958. template <class T>
  2959. inline void RArray<T>::SortUnsigned()
  2964. {HeapSortUnsigned();}
  2969. template <class T>
  2970. inline void RArray<T>::Sort(TLinearOrder<T> anOrder)
  2971. #line 5375
  2972. {HeapSort(anOrder);}
  2977. template <class T>
  2978. inline TArray<T> RArray<T>::Array() const
  2984. { return TArray<T>(GetCount,GetElementPtr,(const CBase*)this); }
  2990. inline RArray<TInt>::RArray()
  2991. : RPointerArrayBase()
  2998. {}
  3003. inline RArray<TInt>::RArray(TInt aGranularity)
  3004. : RPointerArrayBase(aGranularity)
  3005. #line 5417
  3006. {}
  3007. #line 5437
  3008. inline RArray<TInt>::RArray(TInt aMinGrowBy, TInt aFactor)
  3009. : RPointerArrayBase(aMinGrowBy, aFactor)
  3010. {}
  3015. inline void RArray<TInt>::Close()
  3021. {RPointerArrayBase::Close();}
  3026. inline TInt RArray<TInt>::Count() const
  3032. { return RPointerArrayBase::Count(); }
  3037. inline const TInt& RArray<TInt>::operator[](TInt anIndex) const
  3038. #line 5484
  3039. {return (const TInt&)At(anIndex);}
  3044. inline TInt& RArray<TInt>::operator[](TInt anIndex)
  3045. #line 5507
  3046. {return (TInt&)At(anIndex);}
  3051. inline TInt RArray<TInt>::Append(TInt anEntry)
  3052. #line 5521
  3053. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3058. inline TInt RArray<TInt>::Insert(TInt anEntry, TInt aPos)
  3059. #line 5541
  3060. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3065. inline void RArray<TInt>::Remove(TInt anIndex)
  3066. #line 5558
  3067. {RPointerArrayBase::Remove(anIndex);}
  3072. inline void RArray<TInt>::Compress()
  3080. {RPointerArrayBase::Compress();}
  3085. inline void RArray<TInt>::Reset()
  3086. #line 5586
  3087. {RPointerArrayBase::Reset();}
  3092. inline TInt RArray<TInt>::Find(TInt anEntry) const
  3093. #line 5604
  3094. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3099. inline TInt RArray<TInt>::FindInOrder(TInt anEntry) const
  3100. #line 5621
  3101. { return RPointerArrayBase::FindIsqSigned(anEntry); }
  3106. inline TInt RArray<TInt>::FindInOrder(TInt anEntry, TInt& anIndex) const
  3107. #line 5644
  3108. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); }
  3113. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt aMode) const
  3114. #line 5675
  3115. { return RPointerArrayBase::FindIsqSigned(anEntry,aMode); }
  3120. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const
  3121. #line 5713
  3122. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); }
  3127. inline TInt RArray<TInt>::InsertInOrder(TInt anEntry)
  3128. #line 5735
  3129. { return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); }
  3134. inline TInt RArray<TInt>::InsertInOrderAllowRepeats(TInt anEntry)
  3135. #line 5758
  3136. { return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); }
  3142. inline RArray<TInt>::RArray(TInt* aEntries, TInt aCount)
  3143. : RPointerArrayBase((TAny**)aEntries, aCount)
  3144. #line 5781
  3145. {}
  3147. inline void RArray<TInt>::GranularCompress()
  3148. #line 5792
  3149. {RPointerArrayBase::GranularCompress();}
  3154. inline TInt RArray<TInt>::Reserve(TInt aCount)
  3155. #line 5810
  3156. { return RPointerArrayBase::DoReserve(aCount); }
  3161. inline void RArray<TInt>::Sort()
  3165. { HeapSortSigned(); }
  3170. inline TArray<TInt> RArray<TInt>::Array() const
  3178. { return TArray<TInt>(GetCount,GetElementPtr,(const CBase*)this); }
  3183. inline RArray<TUint>::RArray()
  3184. : RPointerArrayBase()
  3185. #line 5847
  3186. {}
  3191. inline RArray<TUint>::RArray(TInt aGranularity)
  3192. : RPointerArrayBase(aGranularity)
  3193. #line 5863
  3194. {}
  3195. #line 5883
  3196. inline RArray<TUint>::RArray(TInt aMinGrowBy, TInt aFactor)
  3197. : RPointerArrayBase(aMinGrowBy, aFactor)
  3198. {}
  3203. inline void RArray<TUint>::Close()
  3209. {RPointerArrayBase::Close();}
  3214. inline TInt RArray<TUint>::Count() const
  3220. {return RPointerArrayBase::Count(); }
  3225. inline const TUint& RArray<TUint>::operator[](TInt anIndex) const
  3226. #line 5930
  3227. {return (const TUint&)At(anIndex);}
  3232. inline TUint& RArray<TUint>::operator[](TInt anIndex)
  3233. #line 5953
  3234. {return (TUint&)At(anIndex);}
  3239. inline TInt RArray<TUint>::Append(TUint anEntry)
  3247. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3252. inline TInt RArray<TUint>::Insert(TUint anEntry, TInt aPos)
  3253. #line 5987
  3254. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3259. inline void RArray<TUint>::Remove(TInt anIndex)
  3260. #line 6005
  3261. {RPointerArrayBase::Remove(anIndex);}
  3266. inline void RArray<TUint>::Compress()
  3274. {RPointerArrayBase::Compress();}
  3279. inline void RArray<TUint>::Reset()
  3280. #line 6033
  3281. {RPointerArrayBase::Reset();}
  3286. inline TInt RArray<TUint>::Find(TUint anEntry) const
  3287. #line 6051
  3288. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3293. inline TInt RArray<TUint>::FindInOrder(TUint anEntry) const
  3294. #line 6070
  3295. { return RPointerArrayBase::FindIsqUnsigned(anEntry); }
  3300. inline TInt RArray<TUint>::FindInOrder(TUint anEntry, TInt& anIndex) const
  3301. #line 6098
  3302. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); }
  3307. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt aMode) const
  3308. #line 6128
  3309. { return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); }
  3314. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const
  3315. #line 6163
  3316. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); }
  3321. inline TInt RArray<TUint>::InsertInOrder(TUint anEntry)
  3322. #line 6185
  3323. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); }
  3328. inline TInt RArray<TUint>::InsertInOrderAllowRepeats(TUint anEntry)
  3329. #line 6208
  3330. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); }
  3336. inline RArray<TUint>::RArray(TUint* aEntries, TInt aCount)
  3337. : RPointerArrayBase((TAny**)aEntries, aCount)
  3338. #line 6231
  3339. {}
  3343. inline void RArray<TUint>::GranularCompress()
  3344. #line 6244
  3345. {RPointerArrayBase::GranularCompress();}
  3350. inline TInt RArray<TUint>::Reserve(TInt aCount)
  3351. #line 6262
  3352. { return RPointerArrayBase::DoReserve(aCount); }
  3357. inline void RArray<TUint>::Sort()
  3361. { HeapSortUnsigned(); }
  3366. inline TArray<TUint> RArray<TUint>::Array() const
  3374. { return TArray<TUint>(GetCount,GetElementPtr,(const CBase*)this); }
  3375. #line 6293
  3376. inline void TIpcArgs::Set(TInt,TNothing)
  3377. {}
  3378. #line 6307
  3379. inline void TIpcArgs::Set(TInt aIndex,TInt aValue)
  3380. {
  3381. iArgs[aIndex] = aValue;
  3382. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3383. }
  3384. #line 6324
  3385. inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue)
  3386. {
  3387. iArgs[aIndex] = (TInt)aValue;
  3388. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3389. }
  3390. #line 6341
  3391. inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue)
  3392. {
  3393. iArgs[aIndex] = (TInt)aValue.Handle();
  3394. iFlags |= EHandle<<(aIndex*KBitsPerType);
  3395. }
  3396. #line 6358
  3397. inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue)
  3398. {
  3399. iArgs[aIndex] = (TInt)aValue;
  3400. iFlags |= EDesC8<<(aIndex*KBitsPerType);
  3401. }
  3402. #line 6377
  3403. inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue)
  3404. {
  3405. iArgs[aIndex] = (TInt)aValue;
  3406. iFlags |= EDesC16<<(aIndex*KBitsPerType);
  3407. }
  3408. #line 6396
  3409. inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue)
  3410. {
  3411. iArgs[aIndex] = (TInt)aValue;
  3412. iFlags |= EDes8<<(aIndex*KBitsPerType);
  3413. }
  3414. #line 6415
  3415. inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue)
  3416. {
  3417. iArgs[aIndex] = (TInt)aValue;
  3418. iFlags |= EDes16<<(aIndex*KBitsPerType);
  3419. }
  3426. inline TIpcArgs::TArgType TIpcArgs::Type(TNothing)
  3427. { return EUnspecified; }
  3428. inline TIpcArgs::TArgType TIpcArgs::Type(TInt)
  3429. { return EUnspecified; }
  3430. inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*)
  3431. { return EUnspecified; }
  3432. inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase)
  3433. { return EHandle; }
  3434. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*)
  3435. { return EDesC8; }
  3437. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*)
  3438. { return EDesC16; }
  3440. inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*)
  3441. { return EDes8; }
  3443. inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*)
  3444. { return EDes16; }
  3446. inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing)
  3447. {}
  3448. inline void TIpcArgs::Assign(TInt& aArg,TInt aValue)
  3449. { aArg = aValue; }
  3450. inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue)
  3451. { aArg = (TInt)aValue; }
  3452. inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue)
  3453. { aArg = (TInt)aValue.Handle(); }
  3454. inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue)
  3455. { aArg = (TInt)aValue; }
  3457. inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue)
  3458. { aArg = (TInt)aValue; }
  3460. inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue)
  3461. { aArg = (TInt)aValue; }
  3463. inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue)
  3464. { aArg = (TInt)aValue; }
  3471. inline SInt64::SInt64()
  3472. {}
  3474. inline SInt64::SInt64(Int64 a)
  3475. {
  3476. iData[0] = (TUint32)((Uint64)a);
  3477. iData[1] = (TUint32)(((Uint64)a)>>32);
  3478. }
  3480. inline SInt64& SInt64::operator=(Int64 a)
  3481. {
  3482. iData[0] = (TUint32)((Uint64)a);
  3483. iData[1] = (TUint32)(((Uint64)a)>>32);
  3484. return *this;
  3485. }
  3487. inline SInt64::operator Int64() const
  3488. {
  3489. Int64 x;
  3490. TUint32* px = (TUint32*)&x;
  3491. px[0] = iData[0];
  3492. px[1] = iData[1];
  3493. return x;
  3494. }
  3496. inline SUint64::SUint64()
  3497. {}
  3499. inline SUint64::SUint64(Uint64 a)
  3500. {
  3501. iData[0] = (TUint32)a;
  3502. iData[1] = (TUint32)(a>>32);
  3503. }
  3505. inline SUint64& SUint64::operator=(Uint64 a)
  3506. {
  3507. iData[0] = (TUint32)a;
  3508. iData[1] = (TUint32)(a>>32);
  3509. return *this;
  3510. }
  3512. inline SUint64::operator Uint64() const
  3513. {
  3514. Uint64 x;
  3515. TUint32* px = (TUint32*)&x;
  3516. px[0] = iData[0];
  3517. px[1] = iData[1];
  3518. return x;
  3519. }
  3521. inline SDouble::SDouble()
  3522. {}
  3524. inline SDouble::SDouble(TReal a)
  3525. {
  3526. const TUint32* pa = (const TUint32*)&a;
  3531. iData[0] = pa[0];
  3532. iData[1] = pa[1];
  3534. }
  3536. inline SDouble& SDouble::operator=(TReal a)
  3537. {
  3538. new (this) SDouble(a);
  3539. return *this;
  3540. }
  3542. inline SDouble::operator TReal() const
  3543. {
  3544. TReal x;
  3545. TUint32* px = (TUint32*)&x;
  3550. px[0] = iData[0];
  3551. px[1] = iData[1];
  3553. return x;
  3554. }
  3561. inline TSecureId::TSecureId()
  3562. {}
  3566. inline TSecureId::TSecureId(TUint32 aId)
  3567. : iId(aId) {}
  3571. inline TSecureId::operator TUint32() const
  3572. { return iId; }
  3576. inline TSecureId::TSecureId(TUid aId)
  3577. : iId(aId.iUid) {}
  3581. inline TSecureId::operator TUid() const
  3582. { return (TUid&)iId; }
  3587. inline const TSecureId* SSecureId::operator&() const
  3588. { return (const TSecureId*)this; }
  3589. inline SSecureId::operator const TSecureId&() const
  3590. { return (const TSecureId&)iId; }
  3591. inline SSecureId::operator TUint32() const
  3592. { return iId; }
  3593. inline SSecureId::operator TUid() const
  3594. { return (TUid&)iId; }
  3601. inline TVendorId::TVendorId()
  3602. {}
  3606. inline TVendorId::TVendorId(TUint32 aId)
  3607. : iId(aId) {}
  3611. inline TVendorId::operator TUint32() const
  3612. { return iId; }
  3616. inline TVendorId::TVendorId(TUid aId)
  3617. : iId(aId.iUid) {}
  3621. inline TVendorId::operator TUid() const
  3622. { return (TUid&)iId; }
  3627. inline const TVendorId* SVendorId::operator&() const
  3628. { return (const TVendorId*)this; }
  3629. inline SVendorId::operator const TVendorId&() const
  3630. { return (const TVendorId&)iId; }
  3631. inline SVendorId::operator TUint32() const
  3632. { return iId; }
  3633. inline SVendorId::operator TUid() const
  3634. { return (TUid&)iId; }
  3640. inline TCapabilitySet::TCapabilitySet()
  3641. {}
  3647. inline TCapabilitySet::TCapabilitySet(TCapability aCapability)
  3648. { new (this) TCapabilitySet(aCapability, aCapability); }
  3654. inline void TCapabilitySet::Set(TCapability aCapability)
  3655. { new (this) TCapabilitySet(aCapability, aCapability); }
  3662. inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2)
  3663. { new (this) TCapabilitySet(aCapability1, aCapability2); }
  3669. inline TSecurityInfo::TSecurityInfo()
  3670. {}
  3675. inline TSecurityPolicy::TSecurityPolicy()
  3676. { new (this) TSecurityPolicy(EAlwaysFail); }
  3682. inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const
  3683. { return (const TSecurityPolicy*)this; }
  3689. inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const
  3690. { return *(const TSecurityPolicy*)this; }
  3696. inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const
  3697. { return *(const TSecurityPolicy*)this; }
  3698. #line 6341 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.h" /* stack depth 5 */
  3699. #line 13 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 4 */
  3706. class TFunctor
  3707. {
  3708. public:
  3709. __declspec(dllexport) virtual void operator()() =0;
  3710. };
  3711. #line 53
  3712. class TCallBack
  3713. {
  3714. public:
  3715. inline TCallBack();
  3716. inline TCallBack(TInt (*aFunction)(TAny* aPtr));
  3717. inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
  3718. inline TInt CallBack() const;
  3719. public:
  3724. TInt (*iFunction)(TAny* aPtr);
  3731. TAny* iPtr;
  3732. };
  3733. #line 89
  3734. class TSglQueLink
  3735. {
  3737. public:
  3738. inline TSglQueLink() : iNext(0 )
  3746. {}
  3748. private:
  3749. __declspec(dllexport) void Enque(TSglQueLink* aLink);
  3750. public:
  3754. TSglQueLink* iNext;
  3755. friend class TSglQueBase;
  3756. };
  3757. #line 130
  3758. class TDblQueLinkBase
  3759. {
  3760. public:
  3761. inline TDblQueLinkBase() : iNext(0 )
  3769. {}
  3770. __declspec(dllexport) void Enque(TDblQueLinkBase* aLink);
  3771. __declspec(dllexport) void AddBefore(TDblQueLinkBase* aLink);
  3772. public:
  3776. TDblQueLinkBase* iNext;
  3781. TDblQueLinkBase* iPrev;
  3782. };
  3783. #line 166
  3784. class TDblQueLink : public TDblQueLinkBase
  3785. {
  3786. public:
  3787. __declspec(dllexport) void Deque();
  3788. };
  3789. #line 184
  3790. class TPriQueLink : public TDblQueLink
  3791. {
  3792. public:
  3798. TInt iPriority;
  3799. };
  3800. #line 205
  3801. class TDeltaQueLink : public TDblQueLinkBase
  3802. {
  3803. public:
  3807. TInt iDelta;
  3808. };
  3809. #line 224
  3810. class TTickCountQueLink : public TDblQueLink
  3811. {
  3812. public:
  3816. TUint iTickCount;
  3817. };
  3818. #line 248
  3819. class TSglQueBase
  3820. {
  3821. public:
  3822. __declspec(dllexport) TBool IsEmpty() const;
  3823. __declspec(dllexport) void SetOffset(TInt aOffset);
  3824. __declspec(dllexport) void Reset();
  3825. protected:
  3826. __declspec(dllexport) TSglQueBase();
  3827. __declspec(dllexport) TSglQueBase(TInt aOffset);
  3828. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3829. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3830. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3831. protected:
  3835. TSglQueLink* iHead;
  3840. TSglQueLink* iLast;
  3845. TInt iOffset;
  3846. private:
  3847. TSglQueBase(const TSglQueBase& aQue);
  3848. TSglQueBase &operator=(const TSglQueBase& aQue);
  3849. friend class TSglQueIterBase;
  3850. };
  3851. #line 296
  3852. class TDblQueBase
  3853. {
  3854. public:
  3855. __declspec(dllexport) TBool IsEmpty() const;
  3856. __declspec(dllexport) void SetOffset(TInt aOffset);
  3857. __declspec(dllexport) void Reset();
  3858. protected:
  3859. __declspec(dllexport) TDblQueBase();
  3860. __declspec(dllexport) TDblQueBase(TInt aOffset);
  3861. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3862. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3863. __declspec(dllexport) void DoAddPriority(TAny* aPtr);
  3864. __declspec(dllexport) void __DbgTestEmpty() const;
  3865. protected:
  3869. TDblQueLink iHead;
  3874. TInt iOffset;
  3875. private:
  3876. TDblQueBase(const TDblQueBase& aQue);
  3877. TDblQueBase& operator=(const TDblQueBase& aQue);
  3878. friend class TDblQueIterBase;
  3879. };
  3880. #line 338
  3881. class TDeltaQueBase : public TDblQueBase
  3882. {
  3883. public:
  3884. __declspec(dllexport) TBool CountDown();
  3885. __declspec(dllexport) TBool CountDown(TInt aValue);
  3886. __declspec(dllexport) TBool FirstDelta(TInt& aValue);
  3887. __declspec(dllexport) void Reset();
  3888. protected:
  3889. __declspec(dllexport) TDeltaQueBase();
  3890. __declspec(dllexport) TDeltaQueBase(TInt aOffset);
  3891. __declspec(dllexport) void DoAddDelta(TAny* aPtr,TInt aDelta);
  3892. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3893. __declspec(dllexport) TAny* DoRemoveFirst();
  3894. protected:
  3898. TInt* iFirstDelta;
  3899. };
  3900. #line 375
  3901. template <class T>
  3902. class TSglQue : public TSglQueBase
  3903. {
  3904. public:
  3905. inline TSglQue();
  3906. inline explicit TSglQue(TInt aOffset);
  3907. inline void AddFirst(T& aRef);
  3908. inline void AddLast(T& aRef);
  3909. inline TBool IsFirst(const T* aPtr) const;
  3910. inline TBool IsLast(const T* aPtr) const;
  3911. inline T* First() const;
  3912. inline T* Last() const;
  3913. inline void Remove(T& aRef);
  3914. };
  3915. #line 407
  3916. template <class T>
  3917. class TDblQue : public TDblQueBase
  3918. {
  3919. public:
  3920. inline TDblQue();
  3921. inline explicit TDblQue(TInt aOffset);
  3922. inline void AddFirst(T& aRef);
  3923. inline void AddLast(T& aRef);
  3924. inline TBool IsHead(const T* aPtr) const;
  3925. inline TBool IsFirst(const T* aPtr) const;
  3926. inline TBool IsLast(const T* aPtr) const;
  3927. inline T* First() const;
  3928. inline T* Last() const;
  3929. };
  3930. #line 441
  3931. template <class T>
  3932. class TPriQue : public TDblQueBase
  3933. {
  3934. public:
  3935. inline TPriQue();
  3936. inline explicit TPriQue(TInt aOffset);
  3937. inline void Add(T& aRef);
  3938. inline TBool IsHead(const T* aPtr) const;
  3939. inline TBool IsFirst(const T* aPtr) const;
  3940. inline TBool IsLast(const T* aPtr) const;
  3941. inline T* First() const;
  3942. inline T* Last() const;
  3943. };
  3944. #line 487
  3945. template <class T>
  3946. class TDeltaQue : public TDeltaQueBase
  3947. {
  3948. public:
  3949. inline TDeltaQue();
  3950. inline explicit TDeltaQue(TInt aOffset);
  3951. inline void Add(T& aRef,TInt aDelta);
  3952. inline void Remove(T& aRef);
  3953. inline T* RemoveFirst();
  3954. };
  3960. class TTickCountQueLink;
  3961. #line 520
  3962. class TTickCountQue : public TDblQueBase
  3963. {
  3964. public:
  3965. TTickCountQue();
  3966. void Add(TTickCountQueLink& aRef);
  3967. TTickCountQueLink* First() const;
  3968. TTickCountQueLink* RemoveFirst();
  3969. TTickCountQueLink* RemoveFirst(TUint aTickCount);
  3970. };
  3971. #line 543
  3972. class TSglQueIterBase
  3973. {
  3974. public:
  3975. __declspec(dllexport) void SetToFirst();
  3976. protected:
  3977. __declspec(dllexport) TSglQueIterBase(TSglQueBase& aQue);
  3978. __declspec(dllexport) TAny* DoPostInc();
  3979. __declspec(dllexport) TAny* DoCurrent();
  3980. __declspec(dllexport) void DoSet(TAny* aLink);
  3981. protected:
  3982. TInt iOffset;
  3983. TSglQueLink* iHead;
  3984. TSglQueLink* iNext;
  3985. };
  3986. #line 571
  3987. template <class T>
  3988. class TSglQueIter : public TSglQueIterBase
  3989. {
  3990. public:
  3991. inline TSglQueIter(TSglQueBase& aQue);
  3992. inline void Set(T& aLink);
  3993. inline operator T*();
  3994. inline T* operator++(TInt);
  3995. };
  3996. #line 594
  3997. class TDblQueIterBase
  3998. {
  3999. public:
  4000. __declspec(dllexport) void SetToFirst();
  4001. __declspec(dllexport) void SetToLast();
  4002. protected:
  4003. __declspec(dllexport) TDblQueIterBase(TDblQueBase& aQue);
  4004. __declspec(dllexport) TAny* DoPostInc();
  4005. __declspec(dllexport) TAny* DoPostDec();
  4006. __declspec(dllexport) TAny* DoCurrent();
  4007. __declspec(dllexport) void DoSet(TAny* aLink);
  4008. protected:
  4012. TInt iOffset;
  4017. TDblQueLinkBase* iHead;
  4022. TDblQueLinkBase* iNext;
  4023. };
  4024. #line 635
  4025. template <class T>
  4026. class TDblQueIter : public TDblQueIterBase
  4027. {
  4028. public:
  4029. inline TDblQueIter(TDblQueBase& aQue);
  4030. inline void Set(T& aLink);
  4031. inline operator T*();
  4032. inline T* operator++(TInt);
  4033. inline T* operator--(TInt);
  4034. };
  4035. #line 660
  4036. enum TKeyCmpText
  4037. {
  4045. ECmpNormal,
  4046. #line 682
  4047. ECmpNormal8,
  4048. #line 696
  4049. ECmpNormal16,
  4050. #line 706
  4051. ECmpFolded,
  4052. #line 717
  4053. ECmpFolded8,
  4054. #line 728
  4055. ECmpFolded16,
  4056. #line 738
  4057. ECmpCollated,
  4058. #line 749
  4059. ECmpCollated8,
  4060. #line 761
  4061. ECmpCollated16
  4062. };
  4063. #line 777
  4064. enum TKeyCmpNumeric
  4065. {
  4069. ECmpTInt8=((ECmpCollated16+1)<<1),
  4075. ECmpTInt16,
  4081. ECmpTInt32,
  4087. ECmpTInt,
  4093. ECmpTUint8,
  4099. ECmpTUint16,
  4105. ECmpTUint32,
  4111. ECmpTUint,
  4117. ECmpTInt64
  4118. };
  4119. #line 856
  4120. class TKey
  4121. {
  4122. public:
  4123. inline void SetPtr(const TAny* aPtr);
  4124. __declspec(dllexport) virtual TInt Compare(TInt aLeft,TInt aRight) const;
  4125. __declspec(dllexport) virtual TAny* At(TInt anIndex) const;
  4126. protected:
  4127. __declspec(dllexport) TKey();
  4128. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType);
  4129. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
  4130. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpNumeric aType);
  4131. protected:
  4132. TInt iKeyOffset;
  4133. TInt iKeyLength;
  4134. TInt iCmpType;
  4135. const TAny* iPtr;
  4136. };
  4137. #line 890
  4138. class TSwap
  4139. {
  4140. public:
  4141. __declspec(dllexport) TSwap();
  4142. __declspec(dllexport) virtual void Swap(TInt aLeft,TInt aRight) const;
  4143. };
  4144. #line 918
  4145. class TCharF : public TChar
  4146. {
  4147. public:
  4148. inline TCharF(TUint aChar);
  4149. inline TCharF(const TChar& aChar);
  4150. inline TCharF& operator=(TUint aChar);
  4151. inline TCharF& operator=(const TChar& aChar);
  4152. };
  4153. #line 937
  4154. class TCharLC : public TChar
  4155. {
  4156. public:
  4157. inline TCharLC(TUint aChar);
  4158. inline TCharLC(const TChar& aChar);
  4159. inline TCharLC& operator=(TUint aChar);
  4160. inline TCharLC& operator=(const TChar& aChar);
  4161. };
  4162. #line 956
  4163. class TCharUC : public TChar
  4164. {
  4165. public:
  4166. inline TCharUC(TUint aChar);
  4167. inline TCharUC(const TChar& aChar);
  4168. inline TCharUC& operator=(TUint aChar);
  4169. inline TCharUC& operator=(const TChar& aChar);
  4170. };
  4171. #line 982
  4172. class TRealFormat
  4173. {
  4174. public:
  4175. __declspec(dllexport) TRealFormat();
  4176. __declspec(dllexport) TRealFormat(TInt aWidth);
  4177. __declspec(dllexport) TRealFormat(TInt aWidth,TInt aDecimalPlaces);
  4178. public:
  4179. #line 1007
  4180. TInt iType;
  4186. TInt iWidth;
  4187. #line 1025
  4188. TInt iPlaces;
  4189. #line 1038
  4190. TChar iPoint;
  4191. #line 1051
  4192. TChar iTriad;
  4193. #line 1071
  4194. TInt iTriLen;
  4195. };
  4196. #line 1089
  4197. class TLexMark8
  4198. {
  4199. public:
  4200. inline TLexMark8();
  4201. private:
  4202. inline TLexMark8(const TUint8* aString);
  4203. const TUint8* iPtr;
  4204. friend class TLex8;
  4205. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4206. };
  4211. class TRealX;
  4212. #line 1123
  4213. class TLex8
  4214. {
  4215. public:
  4216. __declspec(dllexport) TLex8();
  4217. inline TLex8(const TUint8* aString);
  4218. inline TLex8(const TDesC8& aDes);
  4219. inline TLex8& operator=(const TUint8* aString);
  4220. inline TLex8& operator=(const TDesC8& aDes);
  4221. inline TBool Eos() const;
  4222. inline void Mark(TLexMark8& aMark) const;
  4223. inline void Mark();
  4224. __declspec(dllexport) void Inc();
  4225. __declspec(dllexport) void Inc(TInt aNumber);
  4226. __declspec(dllexport) TChar Get();
  4227. __declspec(dllexport) TChar Peek() const;
  4228. __declspec(dllexport) void UnGet();
  4229. inline void UnGetToMark();
  4230. __declspec(dllexport) void UnGetToMark(const TLexMark8 aMark);
  4231. __declspec(dllexport) void SkipSpace();
  4232. inline void SkipAndMark(TInt aNumber);
  4233. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark8& aMark);
  4234. inline void SkipSpaceAndMark();
  4235. __declspec(dllexport) void SkipSpaceAndMark(TLexMark8& aMark);
  4236. __declspec(dllexport) void SkipCharacters();
  4237. inline TInt TokenLength() const;
  4238. __declspec(dllexport) TInt TokenLength(const TLexMark8 aMark) const;
  4239. __declspec(dllexport) TPtrC8 MarkedToken() const;
  4240. __declspec(dllexport) TPtrC8 MarkedToken(const TLexMark8 aMark) const;
  4241. __declspec(dllexport) TPtrC8 NextToken();
  4242. __declspec(dllexport) TPtrC8 Remainder() const;
  4243. __declspec(dllexport) TPtrC8 RemainderFromMark() const;
  4244. __declspec(dllexport) TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
  4245. __declspec(dllexport) TInt Offset() const;
  4246. inline TInt MarkedOffset() const;
  4247. __declspec(dllexport) TInt MarkedOffset(const TLexMark8 aMark) const;
  4248. __declspec(dllexport) TInt Val(TInt8& aVal);
  4249. __declspec(dllexport) TInt Val(TInt16& aVal);
  4250. __declspec(dllexport) TInt Val(TInt32& aVal);
  4251. __declspec(dllexport) TInt Val(TInt64& aVal);
  4252. inline TInt Val(TInt& aVal);
  4253. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4254. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4255. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4256. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4257. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4258. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4259. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4260. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4261. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4262. __declspec(dllexport) TInt Val(TReal32& aVal);
  4263. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4264. __declspec(dllexport) TInt Val(TReal64& aVal);
  4265. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4266. inline void Assign(const TLex8& aLex);
  4267. __declspec(dllexport) void Assign(const TUint8* aString);
  4268. __declspec(dllexport) void Assign(const TDesC8& aDes);
  4269. TInt Val(TRealX& aVal);
  4270. TInt Val(TRealX& aVal, TChar aPoint);
  4273. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4276. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4279. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4282. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4283. private:
  4284. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4285. void ScndigAfterPoint(TInt& aSig,TInt64& aDl);
  4286. void ValidateMark(const TLexMark8 aMark) const;
  4287. private:
  4288. const TUint8* iNext;
  4289. const TUint8* iBuf;
  4290. const TUint8* iEnd;
  4291. TLexMark8 iMark;
  4292. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4293. };
  4294. #line 1220
  4295. class TLexMark16
  4296. {
  4297. public:
  4298. inline TLexMark16();
  4299. private:
  4300. inline TLexMark16(const TUint16* aString);
  4301. const TUint16* iPtr;
  4302. friend class TLex16;
  4303. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4304. };
  4305. #line 1253
  4306. class TLex16
  4307. {
  4308. public:
  4309. __declspec(dllexport) TLex16();
  4310. inline TLex16(const TUint16* aString);
  4311. inline TLex16(const TDesC16& aDes);
  4312. inline TLex16& operator=(const TUint16* aString);
  4313. inline TLex16& operator=(const TDesC16& aDes);
  4314. inline TBool Eos() const;
  4315. inline void Mark();
  4316. inline void Mark(TLexMark16& aMark) const;
  4317. __declspec(dllexport) void Inc();
  4318. __declspec(dllexport) void Inc(TInt aNumber);
  4319. __declspec(dllexport) TChar Get();
  4320. __declspec(dllexport) TChar Peek() const;
  4321. __declspec(dllexport) void UnGet();
  4322. inline void UnGetToMark();
  4323. __declspec(dllexport) void UnGetToMark(const TLexMark16 aMark);
  4324. __declspec(dllexport) void SkipSpace();
  4325. inline void SkipAndMark(TInt aNumber);
  4326. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark16& aMark);
  4327. __declspec(dllexport) void SkipSpaceAndMark(TLexMark16& aMark);
  4328. inline void SkipSpaceAndMark();
  4329. __declspec(dllexport) void SkipCharacters();
  4330. inline TInt TokenLength() const;
  4331. __declspec(dllexport) TInt TokenLength(const TLexMark16 aMark) const;
  4332. __declspec(dllexport) TPtrC16 MarkedToken() const;
  4333. __declspec(dllexport) TPtrC16 MarkedToken(const TLexMark16 aMark) const;
  4334. __declspec(dllexport) TPtrC16 NextToken();
  4335. __declspec(dllexport) TPtrC16 Remainder() const;
  4336. __declspec(dllexport) TPtrC16 RemainderFromMark() const;
  4337. __declspec(dllexport) TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
  4338. __declspec(dllexport) TInt Offset() const;
  4339. inline TInt MarkedOffset() const;
  4340. __declspec(dllexport) TInt MarkedOffset(const TLexMark16 aMark) const;
  4341. __declspec(dllexport) TInt Val(TInt8& aVal);
  4342. __declspec(dllexport) TInt Val(TInt16& aVal);
  4343. __declspec(dllexport) TInt Val(TInt32& aVal);
  4344. __declspec(dllexport) TInt Val(TInt64& aVal);
  4345. inline TInt Val(TInt& aVal);
  4346. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4347. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4348. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4349. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4351. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4352. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4353. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4354. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4355. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4356. __declspec(dllexport) TInt Val(TReal32& aVal);
  4357. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4358. __declspec(dllexport) TInt Val(TReal64& aVal);
  4359. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4360. inline void Assign(const TLex16& aLex);
  4361. __declspec(dllexport) void Assign(const TUint16* aString);
  4362. __declspec(dllexport) void Assign(const TDesC16& aDes);
  4363. TInt Val(TRealX& aVal);
  4364. TInt Val(TRealX& aVal, TChar aPoint);
  4367. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4370. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4373. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4376. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4377. private:
  4378. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4379. void ValidateMark(const TLexMark16 aMark) const;
  4380. private:
  4381. const TUint16* iNext;
  4382. const TUint16* iBuf;
  4383. const TUint16* iEnd;
  4384. TLexMark16 iMark;
  4385. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4386. };
  4387. #line 1355
  4388. typedef TLex16 TLex;
  4389. #line 1373
  4390. typedef TLexMark16 TLexMark;
  4391. #line 1430
  4392. class TCheckedUid
  4393. {
  4394. public:
  4395. __declspec(dllexport) TCheckedUid();
  4396. __declspec(dllexport) TCheckedUid(const TUidType& aUidType);
  4397. __declspec(dllexport) TCheckedUid(const TDesC8& aPtr);
  4398. __declspec(dllexport) void Set(const TUidType& aUidType);
  4399. __declspec(dllexport) void Set(const TDesC8& aPtr);
  4400. __declspec(dllexport) TPtrC8 Des() const;
  4401. inline const TUidType& UidType() const;
  4402. protected:
  4403. __declspec(dllexport) TUint Check() const;
  4404. private:
  4405. TUidType iType;
  4406. TUint iCheck;
  4407. };
  4408. #line 1469
  4409. class TDateTime
  4410. {
  4411. public:
  4412. inline TDateTime();
  4413. __declspec(dllexport) TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4414. __declspec(dllexport) TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4415. __declspec(dllexport) TInt SetYear(TInt aYear);
  4416. __declspec(dllexport) TInt SetYearLeapCheck(TInt aYear);
  4417. __declspec(dllexport) TInt SetMonth(TMonth aMonth);
  4418. __declspec(dllexport) TInt SetDay(TInt aDay);
  4419. __declspec(dllexport) TInt SetHour(TInt aHour);
  4420. __declspec(dllexport) TInt SetMinute(TInt aMinute);
  4421. __declspec(dllexport) TInt SetSecond(TInt aSecond);
  4422. __declspec(dllexport) TInt SetMicroSecond(TInt aMicroSecond);
  4423. inline TInt Year() const;
  4424. inline TMonth Month() const;
  4425. inline TInt Day() const;
  4426. inline TInt Hour() const;
  4427. inline TInt Minute() const;
  4428. inline TInt Second() const;
  4429. inline TInt MicroSecond() const;
  4430. private:
  4431. TInt iYear;
  4432. TMonth iMonth;
  4433. TInt iDay;
  4434. TInt iHour;
  4435. TInt iMinute;
  4436. TInt iSecond;
  4437. TInt iMicroSecond;
  4438. };
  4439. #line 1516
  4440. class TTimeIntervalMicroSeconds
  4441. {
  4442. public:
  4443. inline TTimeIntervalMicroSeconds();
  4444. inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
  4445. inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
  4446. inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
  4447. inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
  4448. inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
  4449. inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
  4450. inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
  4451. inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
  4452. inline const TInt64& Int64() const;
  4453. private:
  4454. TInt64 iInterval;
  4455. };
  4456. #line 1554
  4457. class TTimeIntervalBase
  4458. {
  4459. public:
  4460. inline TBool operator==(TTimeIntervalBase aInterval) const;
  4461. inline TBool operator!=(TTimeIntervalBase aInterval) const;
  4462. inline TBool operator>=(TTimeIntervalBase aInterval) const;
  4463. inline TBool operator<=(TTimeIntervalBase aInterval) const;
  4464. inline TBool operator>(TTimeIntervalBase aInterval) const;
  4465. inline TBool operator<(TTimeIntervalBase aInterval) const;
  4466. inline TInt Int() const;
  4467. protected:
  4468. inline TTimeIntervalBase();
  4469. inline TTimeIntervalBase(TInt aInterval);
  4470. protected:
  4471. TInt iInterval;
  4472. };
  4473. #line 1583
  4474. class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
  4475. {
  4476. public:
  4477. inline TTimeIntervalMicroSeconds32();
  4478. inline TTimeIntervalMicroSeconds32(TInt aInterval);
  4479. inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
  4480. };
  4481. #line 1606
  4482. class TTimeIntervalSeconds : public TTimeIntervalBase
  4483. {
  4484. public:
  4485. inline TTimeIntervalSeconds();
  4486. inline TTimeIntervalSeconds(TInt aInterval);
  4487. inline TTimeIntervalSeconds& operator=(TInt aInterval);
  4488. };
  4489. #line 1626
  4490. class TTimeIntervalMinutes : public TTimeIntervalBase
  4491. {
  4492. public:
  4493. inline TTimeIntervalMinutes();
  4494. inline TTimeIntervalMinutes(TInt aInterval);
  4495. inline TTimeIntervalMinutes& operator=(TInt aInterval);
  4496. };
  4497. #line 1646
  4498. class TTimeIntervalHours : public TTimeIntervalBase
  4499. {
  4500. public:
  4501. inline TTimeIntervalHours();
  4502. inline TTimeIntervalHours(TInt aInterval);
  4503. inline TTimeIntervalHours& operator=(TInt aInterval);
  4504. };
  4505. #line 1666
  4506. class TTimeIntervalDays : public TTimeIntervalBase
  4507. {
  4508. public:
  4509. inline TTimeIntervalDays();
  4510. inline TTimeIntervalDays(TInt aInterval);
  4511. inline TTimeIntervalDays& operator=(TInt aInterval);
  4512. };
  4513. #line 1686
  4514. class TTimeIntervalMonths : public TTimeIntervalBase
  4515. {
  4516. public:
  4517. inline TTimeIntervalMonths();
  4518. inline TTimeIntervalMonths(TInt aInterval);
  4519. inline TTimeIntervalMonths& operator=(TInt aInterval);
  4520. };
  4521. #line 1706
  4522. class TTimeIntervalYears : public TTimeIntervalBase
  4523. {
  4524. public:
  4525. inline TTimeIntervalYears();
  4526. inline TTimeIntervalYears(TInt aInterval);
  4527. inline TTimeIntervalYears& operator=(TInt aInterval);
  4528. };
  4529. #line 1725
  4530. enum {
  4536.      EParseTimePresent=0x1,
  4542.      EParseDatePresent=0x2
  4543.      };
  4544. #line 1770
  4545. class TTime
  4546. {
  4547. public:
  4548. inline TTime();
  4549. inline TTime(const TInt64& aTime);
  4550. __declspec(dllexport) TTime(const TDesC& aString);
  4551. __declspec(dllexport) TTime(const TDateTime& aDateTime);
  4552. inline TTime& operator=(const TInt64& aTime);
  4553. __declspec(dllexport) TTime& operator=(const TDateTime& aDateTime);
  4554. __declspec(dllexport) void HomeTime();
  4555. __declspec(dllexport) void UniversalTime();
  4556. __declspec(dllexport) TInt Set(const TDesC& aString);
  4558. __declspec(dllexport) TDateTime DateTime() const;
  4559. __declspec(dllexport) TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;
  4560. __declspec(dllexport) TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;
  4561. __declspec(dllexport) TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;
  4562. __declspec(dllexport) TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;
  4563. __declspec(dllexport) TTimeIntervalDays DaysFrom(TTime aTime) const;
  4564. __declspec(dllexport) TTimeIntervalMonths MonthsFrom(TTime aTime) const;
  4565. __declspec(dllexport) TTimeIntervalYears YearsFrom(TTime aTime) const;
  4567. __declspec(dllexport) TInt DaysInMonth() const;
  4568. __declspec(dllexport) TDay DayNoInWeek() const;
  4569. __declspec(dllexport) TInt DayNoInMonth() const;
  4570. __declspec(dllexport) TInt DayNoInYear() const;
  4571. __declspec(dllexport) TInt DayNoInYear(TTime aStartDate) const;
  4572. __declspec(dllexport) TInt WeekNoInYear() const;
  4573. __declspec(dllexport) TInt WeekNoInYear(TTime aStartDate) const;
  4574. __declspec(dllexport) TInt WeekNoInYear(TFirstWeekRule aRule) const;
  4575. __declspec(dllexport) TInt WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const;
  4576. __declspec(dllexport) void FormatL(TDes& aDes,const TDesC& aFormat) const;
  4577. __declspec(dllexport) void RoundUpToNextMinute();
  4578. __declspec(dllexport) TInt Parse(const TDesC& aDes,TInt aCenturyOffset=0);
  4580. __declspec(dllexport) TTime operator+(TTimeIntervalYears aYear) const;
  4581. __declspec(dllexport) TTime operator+(TTimeIntervalMonths aMonth) const;
  4582. __declspec(dllexport) TTime operator+(TTimeIntervalDays aDay) const;
  4583. __declspec(dllexport) TTime operator+(TTimeIntervalHours aHour) const;
  4584. __declspec(dllexport) TTime operator+(TTimeIntervalMinutes aMinute) const;
  4585. __declspec(dllexport) TTime operator+(TTimeIntervalSeconds aSecond) const;
  4586. __declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds aMicroSecond) const;
  4587. __declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const;
  4588. __declspec(dllexport) TTime operator-(TTimeIntervalYears aYear) const;
  4589. __declspec(dllexport) TTime operator-(TTimeIntervalMonths aMonth) const;
  4590. __declspec(dllexport) TTime operator-(TTimeIntervalDays aDay) const;
  4591. __declspec(dllexport) TTime operator-(TTimeIntervalHours aHour) const;
  4592. __declspec(dllexport) TTime operator-(TTimeIntervalMinutes aMinute) const;
  4593. __declspec(dllexport) TTime operator-(TTimeIntervalSeconds aSecond) const;
  4594. __declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds aMicroSecond) const;
  4595. __declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const;
  4596. __declspec(dllexport) TTime& operator+=(TTimeIntervalYears aYear);
  4597. __declspec(dllexport) TTime& operator+=(TTimeIntervalMonths aMonth);
  4598. __declspec(dllexport) TTime& operator+=(TTimeIntervalDays aDay);
  4599. __declspec(dllexport) TTime& operator+=(TTimeIntervalHours aHour);
  4600. __declspec(dllexport) TTime& operator+=(TTimeIntervalMinutes aMinute);
  4601. __declspec(dllexport) TTime& operator+=(TTimeIntervalSeconds aSecond);
  4602. __declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds aMicroSecond);
  4603. __declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds32 aMicroSecond);
  4604. __declspec(dllexport) TTime& operator-=(TTimeIntervalYears aYear);
  4605. __declspec(dllexport) TTime& operator-=(TTimeIntervalMonths aMonth);
  4606. __declspec(dllexport) TTime& operator-=(TTimeIntervalDays aDay);
  4607. __declspec(dllexport) TTime& operator-=(TTimeIntervalHours aHour);
  4608. __declspec(dllexport) TTime& operator-=(TTimeIntervalMinutes aMinute);
  4609. __declspec(dllexport) TTime& operator-=(TTimeIntervalSeconds aSecond);
  4610. __declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds aMicroSecond);
  4611. __declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds32 aMicroSecond);
  4612. inline TBool operator==(TTime aTime) const;
  4613. inline TBool operator!=(TTime aTime) const;
  4614. inline TBool operator>=(TTime aTime) const;
  4615. inline TBool operator<=(TTime aTime) const;
  4616. inline TBool operator>(TTime aTime) const;
  4617. inline TBool operator<(TTime aTime) const;
  4618. inline const TInt64& Int64() const;