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

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

Symbian

开发平台：

C/C++

S60UIExampleInitialContainer.inc：源码内容
  1. __declspec(dllexport) TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
  2. __declspec(dllexport) TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const;
  4. __declspec(dllexport) RArrayBase(TInt aEntrySize,TAny* aEntries, TInt aCount);
  5. __declspec(dllexport) void GranularCompress();
  6. __declspec(dllexport) TInt DoReserve(TInt aCount);
  7. __declspec(dllexport) void HeapSortSigned();
  8. __declspec(dllexport) void HeapSortUnsigned();
  9. __declspec(dllexport) void HeapSort(TGeneralLinearOrder anOrder);
  10. __declspec(dllexport) static TInt GetCount(const CBase* aPtr);
  11. __declspec(dllexport) static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex);
  13. private:
  14. TInt Grow();
  15. private:
  16. TInt iCount;
  17. TAny* iEntries;
  18. TInt iEntrySize;
  19. TInt iKeyOffset;
  20. TInt iAllocated;
  21. TInt iGranularity;
  22. TInt iSpare1;
  23. TInt iSpare2;
  24. };
  25. #line 5244
  26. template <class T>
  27. class RArray : private RArrayBase
  28. {
  29. public:
  30. inline RArray();
  31. inline explicit RArray(TInt aGranularity);
  32. inline RArray(TInt aGranularity, TInt aKeyOffset);
  33. inline RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
  34. inline void Close();
  35. inline TInt Count() const;
  36. inline const T& operator[](TInt anIndex) const;
  37. inline T& operator[](TInt anIndex);
  38. inline TInt Append(const T& anEntry);
  39. inline TInt Insert(const T& anEntry, TInt aPos);
  40. inline void Remove(TInt anIndex);
  41. inline void Compress();
  42. inline void Reset();
  43. inline TInt Find(const T& anEntry) const;
  44. inline TInt Find(const T& anEntry, TIdentityRelation<T> anIdentity) const;
  45. inline TInt FindInSignedKeyOrder(const T& anEntry) const;
  46. inline TInt FindInUnsignedKeyOrder(const T& anEntry) const;
  47. inline TInt FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const;
  48. inline TInt FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  49. inline TInt FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  50. inline TInt FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  51. template <class K>
  52. inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const
  53. { return RArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T> *)&apfnCompare); }
  54. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const;
  55. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const;
  56. inline TInt SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  57. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  58. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  59. inline TInt SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  60. inline TInt InsertInSignedKeyOrder(const T& anEntry);
  61. inline TInt InsertInUnsignedKeyOrder(const T& anEntry);
  62. inline TInt InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder);
  63. inline TInt InsertInSignedKeyOrderAllowRepeats(const T& anEntry);
  64. inline TInt InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry);
  65. inline TInt InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder);
  67. inline void AppendL(const T& anEntry);
  68. inline void InsertL(const T& anEntry, TInt aPos);
  69. inline TInt FindL(const T& anEntry) const;
  70. inline TInt FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
  71. inline TInt FindInSignedKeyOrderL(const T& anEntry) const;
  72. inline TInt FindInUnsignedKeyOrderL(const T& anEntry) const;
  73. inline TInt FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const;
  74. inline void FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  75. inline void FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  76. inline void FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  77. inline TInt SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const;
  78. inline TInt SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const;
  79. inline TInt SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  80. inline void SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  81. inline void SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  82. inline void SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  83. inline void InsertInSignedKeyOrderL(const T& anEntry);
  84. inline void InsertInUnsignedKeyOrderL(const T& anEntry);
  85. inline void InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder);
  86. inline void InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry);
  87. inline void InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry);
  88. inline void InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder);
  90. inline RArray(TInt aEntrySize,T* aEntries, TInt aCount);
  91. inline void GranularCompress();
  92. inline TInt Reserve(TInt aCount);
  93. inline void ReserveL(TInt aCount);
  94. inline void SortSigned();
  95. inline void SortUnsigned();
  96. inline void Sort(TLinearOrder<T> anOrder);
  97. inline TArray<T> Array() const;
  99. };
  100. #line 5331
  101. template<> class RArray<TInt> : private RPointerArrayBase
  102. {
  103. public:
  104. inline RArray();
  105. inline explicit RArray(TInt aGranularity);
  106. inline RArray(TInt aMinGrowBy, TInt aFactor);
  107. inline void Close();
  108. inline TInt Count() const;
  109. inline const TInt& operator[](TInt anIndex) const;
  110. inline TInt& operator[](TInt anIndex);
  111. inline TInt Append(TInt anEntry);
  112. inline TInt Insert(TInt anEntry, TInt aPos);
  113. inline void Remove(TInt anIndex);
  114. inline void Compress();
  115. inline void Reset();
  116. inline TInt Find(TInt anEntry) const;
  117. inline TInt FindInOrder(TInt anEntry) const;
  118. inline TInt FindInOrder(TInt anEntry, TInt& anIndex) const;
  119. inline TInt SpecificFindInOrder(TInt anEntry, TInt aMode) const;
  120. inline TInt SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const;
  121. inline TInt InsertInOrder(TInt anEntry);
  122. inline TInt InsertInOrderAllowRepeats(TInt anEntry);
  124. inline void AppendL(TInt anEntry);
  125. inline void InsertL(TInt anEntry, TInt aPos);
  126. inline TInt FindL(TInt anEntry) const;
  127. inline TInt FindInOrderL(TInt anEntry) const;
  128. inline void FindInOrderL(TInt anEntry, TInt& anIndex) const;
  129. inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const;
  130. inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const;
  131. inline void InsertInOrderL(TInt anEntry);
  132. inline void InsertInOrderAllowRepeatsL(TInt anEntry);
  134. inline RArray(TInt* aEntries, TInt aCount);
  135. inline void GranularCompress();
  136. inline TInt Reserve(TInt aCount);
  137. inline void ReserveL(TInt aCount);
  138. inline void Sort();
  139. inline TArray<TInt> Array() const;
  141. };
  142. #line 5387
  143. template<> class RArray<TUint> : private RPointerArrayBase
  144. {
  145. public:
  146. inline RArray();
  147. inline explicit RArray(TInt aGranularity);
  148. inline RArray(TInt aMinGrowBy, TInt aFactor);
  149. inline void Close();
  150. inline TInt Count() const;
  151. inline const TUint& operator[](TInt anIndex) const;
  152. inline TUint& operator[](TInt anIndex);
  153. inline TInt Append(TUint anEntry);
  154. inline TInt Insert(TUint anEntry, TInt aPos);
  155. inline void Remove(TInt anIndex);
  156. inline void Compress();
  157. inline void Reset();
  158. inline TInt Find(TUint anEntry) const;
  159. inline TInt FindInOrder(TUint anEntry) const;
  160. inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const;
  161. inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const;
  162. inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const;
  163. inline TInt InsertInOrder(TUint anEntry);
  164. inline TInt InsertInOrderAllowRepeats(TUint anEntry);
  166. inline void AppendL(TUint anEntry);
  167. inline void InsertL(TUint anEntry, TInt aPos);
  168. inline TInt FindL(TUint anEntry) const;
  169. inline TInt FindInOrderL(TUint anEntry) const;
  170. inline void FindInOrderL(TUint anEntry, TInt& anIndex) const;
  171. inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const;
  172. inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const;
  173. inline void InsertInOrderL(TUint anEntry);
  174. inline void InsertInOrderAllowRepeatsL(TUint anEntry);
  176. inline RArray(TUint* aEntries, TInt aCount);
  177. inline void GranularCompress();
  178. inline TInt Reserve(TInt aCount);
  179. inline void ReserveL(TInt aCount);
  180. inline void Sort();
  181. inline TArray<TUint> Array() const;
  183. };
  184. #line 5822
  185. extern TAny* operator new(TUint aSize) throw() ;
  191. extern TAny* operator new(TUint aSize,TUint anExtraSize) throw() ;
  197. extern void operator delete(TAny* aPtr) throw() ;
  204. extern TAny* operator new[](TUint aSize) throw() ;
  210. extern void operator delete[](TAny* aPtr) throw() ;
  217. inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
  224. inline TAny* operator new[](TUint aSize, TAny* aBase) throw() ;
  232. inline void operator delete(TAny* aPtr, TAny* aBase) throw() ;
  239. inline void operator delete[](TAny* aPtr, TAny* aBase) throw() ;
  240. #line 5886
  241. TBool operator==(TTrue,volatile const TBool);
  247. TBool operator==(volatile const TBool,TTrue);
  253. TBool operator!=(TTrue,volatile const TBool);
  259. TBool operator!=(volatile const TBool,TTrue);
  260. #line 5928
  261. class TIpcArgs
  262. {
  263. public:
  270. enum TArgType
  271. {
  272. EUnspecified = 0,
  273. EHandle = 1,
  274. EFlagDes = 4,
  275. EFlagConst = 2,
  276. EFlag16Bit = 1,
  277. EDes8 = EFlagDes,
  278. EDes16 = EFlagDes|EFlag16Bit,
  279. EDesC8 = EFlagDes|EFlagConst,
  280. EDesC16 = EFlagDes|EFlagConst|EFlag16Bit,
  281. };
  289. enum {
  290.      KBitsPerType=3
  291.      };
  297. enum TNothing {
  298. #line 5976
  299.               ENothing
  300.               };
  301. public:
  309. inline TIpcArgs()
  310. :iFlags(0)
  311. {}
  312. #line 5998
  313. template <class T0>
  314. inline explicit TIpcArgs(T0 a0)
  315. {
  316. Assign(iArgs[0],a0);
  317. iFlags=(Type(a0)<<(0*KBitsPerType));
  318. }
  319. #line 6015
  320. template <class T0,class T1>
  321. inline TIpcArgs(T0 a0,T1 a1)
  322. {
  323. Assign(iArgs[0],a0);
  324. Assign(iArgs[1],a1);
  325. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType));
  326. }
  327. #line 6035
  328. template <class T0,class T1,class T2>
  329. inline TIpcArgs(T0 a0,T1 a1,T2 a2)
  330. {
  331. Assign(iArgs[0],a0);
  332. Assign(iArgs[1],a1);
  333. Assign(iArgs[2],a2);
  334. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType));
  335. }
  336. #line 6058
  337. template <class T0,class T1,class T2,class T3>
  338. inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3)
  339. {
  340. Assign(iArgs[0],a0);
  341. Assign(iArgs[1],a1);
  342. Assign(iArgs[2],a2);
  343. Assign(iArgs[3],a3);
  344. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType))|(Type(a3)<<(3*KBitsPerType));
  345. }
  347. inline void Set(TInt aIndex,TNothing);
  348. inline void Set(TInt aIndex,TInt aValue);
  349. inline void Set(TInt aIndex,const TAny* aValue);
  350. inline void Set(TInt aIndex,RHandleBase aValue);
  351. inline void Set(TInt aIndex,const TDesC8* aValue);
  353. inline void Set(TInt aIndex,const TDesC16* aValue);
  355. inline void Set(TInt aIndex,TDes8* aValue);
  357. inline void Set(TInt aIndex,TDes16* aValue);
  359. private:
  360. inline static TArgType Type(TNothing);
  361. inline static TArgType Type(TInt);
  362. inline static TArgType Type(const TAny*);
  363. inline static TArgType Type(RHandleBase aValue);
  364. inline static TArgType Type(const TDesC8*);
  366. inline static TArgType Type(const TDesC16*);
  368. inline static TArgType Type(TDes8*);
  370. inline static TArgType Type(TDes16*);
  373. inline static void Assign(TInt&,TNothing);
  374. inline static void Assign(TInt& aArg,TInt aValue);
  375. inline static void Assign(TInt& aArg,const TAny* aValue);
  376. inline static void Assign(TInt& aArg,RHandleBase aValue);
  377. inline static void Assign(TInt& aArg,const TDesC8* aValue);
  379. inline static void Assign(TInt& aArg,const TDesC16* aValue);
  381. inline static void Assign(TInt& aArg,TDes8* aValue);
  383. inline static void Assign(TInt& aArg,TDes16* aValue);
  385. public:
  393. TInt iArgs[KMaxMessageArguments];
  394. #line 6123
  395. TInt iFlags;
  396. };
  403. struct SInt64
  404. {
  405. public:
  406. inline SInt64();
  407. inline SInt64(Int64 a);
  408. inline SInt64& operator=(Int64 a);
  409. inline operator Int64() const;
  410. public:
  411. TUint32 iData[2];
  412. };
  417. struct SUint64
  418. {
  419. public:
  420. inline SUint64();
  421. inline SUint64(Uint64 a);
  422. inline SUint64& operator=(Uint64 a);
  423. inline operator Uint64() const;
  424. public:
  425. TUint32 iData[2];
  426. };
  431. struct SDouble
  432. {
  433. public:
  434. inline SDouble();
  435. inline SDouble(TReal a);
  436. inline SDouble& operator=(TReal a);
  437. inline operator TReal() const;
  438. public:
  439. TUint32 iData[2];
  440. };
  441. #line 6181
  442. class TThreadStackInfo
  443. {
  444. public:
  448. TLinAddr iBase;
  454. TLinAddr iLimit;
  461. TLinAddr iExpandLimit;
  462. };
  463. #line 6214
  464. class XLeaveException
  465. {
  466. public:
  467. inline XLeaveException() {}
  468. inline XLeaveException(TInt aReason) {iR = aReason;}
  469. inline TInt Reason() const {return iR;}
  470. __declspec(dllexport) TInt GetReason() const;
  471. private:
  472. #line 6230
  473. private:
  475. TAny* iVtable;
  477. TInt iR;
  478. };
  485. namespace std {
  486.   bool uncaught_exception(void);
  487.   void terminate(void);
  488.   void unexpected(void);
  489.   typedef void (*terminate_handler)();
  490.   terminate_handler set_terminate(terminate_handler h) throw();
  491.   typedef void (*unexpected_handler)();
  492.   unexpected_handler set_unexpected(unexpected_handler h) throw();
  493. }
  501. class __UnknownWindowsType1;
  502. class __UnknownWindowsType2;
  505. class TWin32SEHTrap;
  511. typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  516. class TWin32SEHTrap
  517. {
  518. private:
  520.     TWin32SEHTrap(TWin32SEHTrap const &);
  521.     TWin32SEHTrap& operator=(TWin32SEHTrap const &);
  522. #line 6297
  523. public:
  524. __declspec(dllexport) TWin32SEHTrap();
  526. public:
  528. __declspec(dllexport) void Trap();
  531. __declspec(dllexport) void UnTrap();
  534. private:
  537. static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  544.     TWin32SEHTrap* iPrevExceptionRegistrationRecord;
  545. TWin32SEHExceptionHandler* iExceptionHandler;
  547. private:
  548. TUint32 iPadding[254];
  549. };
  550. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.inl" /* stack depth 5 */
  551. #line 9
  552. inline TAny* operator new(TUint , TAny* aBase) throw()
  553. {return aBase;}
  556. inline void operator delete(TAny* , TAny* ) throw()
  557. {}
  563. inline TAny* operator new[](TUint , TAny* aBase) throw()
  564. {return aBase;}
  567. inline void operator delete[](TAny* , TAny* ) throw()
  568. {}
  573. inline RAllocator::RAllocator()
  574. {
  575. iAccessCount=1;
  576. iHandleCount=0;
  577. iHandles=0;
  578. iFlags=0;
  579. iCellCount=0;
  580. iTotalAllocSize=0;
  581. }
  582. inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)
  583. {__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}
  586. inline RHeap::RHeap()
  587. {}
  592. inline TInt RHeap::MaxLength() const
  596. {return iMaxLength;}
  599. inline void RHeap::operator delete(TAny*, TAny*)
  604. {}
  607. inline TUint8* RHeap::Base() const
  608. #line 73
  609. {return iBase;}
  614. inline TInt RHeap::Size() const
  615. #line 89
  616. {return iTop-iBase;}
  621. inline TInt RHeap::Align(TInt a) const
  625. {return (((a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  630. inline const TAny* RHeap::Align(const TAny* a) const
  634. {return (const TAny*)((((TLinAddr)a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  639. inline TBool RHeap::IsLastCell(const SCell* aCell) const
  643. {return (((TUint8*)aCell) + aCell->len) == iTop;}
  649. inline void RHeap::Lock() const
  653. {((RFastLock&)iLock).Wait();}
  658. inline void RHeap::Unlock() const
  662. {((RFastLock&)iLock).Signal();}
  669. template <class T>
  670. inline TRefByValue<T>::TRefByValue(T &aRef)
  671. : iRef(aRef)
  677. {}
  682. template <class T>
  683. inline TRefByValue<T>::operator T &()
  687. {return(iRef);}
  688. #line 201
  689. inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)
  690. { return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }
  696. inline TChar::TChar()
  702. {}
  707. inline TChar::TChar(TUint aChar)
  708. : iChar(aChar)
  714. {}
  719. inline TChar& TChar::operator-=(TUint aChar)
  720. #line 241
  721. {iChar-=aChar;return(*this);}
  726. inline TChar& TChar::operator+=(TUint aChar)
  727. #line 256
  728. {iChar+=aChar;return(*this);}
  733. inline TChar TChar::operator-(TUint aChar)
  734. #line 273
  735. {return(iChar-aChar);}
  740. inline TChar TChar::operator+(TUint aChar)
  741. #line 288
  742. {return(iChar+aChar);}
  747. inline TChar::operator TUint() const
  754. {return(iChar);}
  760. inline TBool TDesC8::operator<(const TDesC8 &aDes) const
  761. #line 320
  762. {return(Compare(aDes)<0);}
  767. inline TBool TDesC8::operator<=(const TDesC8 &aDes) const
  768. #line 339
  769. {return(Compare(aDes)<=0);}
  774. inline TBool TDesC8::operator>(const TDesC8 &aDes) const
  775. #line 358
  776. {return(Compare(aDes)>0);}
  781. inline TBool TDesC8::operator>=(const TDesC8 &aDes) const
  782. #line 377
  783. {return(Compare(aDes)>=0);}
  788. inline TBool TDesC8::operator==(const TDesC8 &aDes) const
  789. #line 396
  790. {return(Compare(aDes)==0);}
  795. inline TBool TDesC8::operator!=(const TDesC8 &aDes) const
  796. #line 415
  797. {return(Compare(aDes)!=0);}
  802. inline const TUint8 &TDesC8::operator[](TInt anIndex) const
  803. #line 433
  804. {return(AtC(anIndex));}
  809. inline TInt TDesC8::Length() const
  817. {return(iLength&KMaskDesLength8);}
  822. inline TInt TDesC8::Size() const
  830. {return(Length());}
  835. inline void TDesC8::DoSetLength(TInt aLength)
  836. {iLength=(iLength&(~KMaskDesLength8))|aLength;}
  842. inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)
  843. #line 483
  844. {new(this) TPtrC8(aBuf,aLength);}
  849. inline void TPtrC8::Set(const TDesC8 &aDes)
  857. {new(this) TPtrC8(aDes);}
  862. inline void TPtrC8::Set(const TPtrC8& aPtr)
  863. #line 510
  864. {new(this) TPtrC8(aPtr);}
  871. inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)
  872. {return TPtr8(*this,aMaxLength);}
  878. template <TInt S>
  879. inline TBufC8<S>::TBufC8()
  880. : TBufCBase8()
  881. #line 540
  882. {}
  887. template <TInt S>
  888. inline TBufC8<S>::TBufC8(const TUint8 *aString)
  889. : TBufCBase8(aString,S)
  890. #line 564
  891. {}
  896. template <TInt S>
  897. inline TBufC8<S>::TBufC8(const TDesC8 &aDes)
  898. : TBufCBase8(aDes,S)
  899. #line 588
  900. {}
  905. template <TInt S>
  906. inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)
  907. #line 607
  908. {Copy(aString,S);return(*this);}
  913. template <TInt S>
  914. inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)
  915. #line 626
  916. {Copy(aDes,S);return(*this);}
  921. template <TInt S>
  922. inline TPtr8 TBufC8<S>::Des()
  923. #line 656
  924. {return DoDes(S);}
  931. inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)
  932. #line 681
  933. {return *this=static_cast<const TDesC8&>(aLcb);}
  934. #line 710
  935. inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)
  936. {
  937. Assign(HBufC8::NewL(aStream,aMaxLength));
  938. }
  945. inline TDes8 &TDes8::operator=(const TUint8 *aString)
  946. #line 733
  947.     {Copy(aString);return(*this);}
  952. inline TDes8 &TDes8::operator=(const TDesC8 &aDes)
  953. #line 751
  954.     {Copy(aDes);return(*this);}
  959. inline TDes8 &TDes8::operator=(const TDes8 &aDes)
  960. #line 769
  961.     {Copy(aDes);return(*this);}
  966. inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)
  967. #line 788
  968. {Append(aDes);return(*this);}
  973. inline const TUint8 &TDes8::operator[](TInt anIndex) const
  974. #line 806
  975. {return(AtC(anIndex));}
  980. inline TUint8 &TDes8::operator[](TInt anIndex)
  981. #line 825
  982. {return((TUint8 &)AtC(anIndex));}
  987. inline TInt TDes8::MaxLength() const
  988. #line 839
  989. {return(iMaxLength);}
  994. inline TInt TDes8::MaxSize() const
  995. #line 853
  996. {return(iMaxLength);}
  1001. inline TUint8 * TDes8::WPtr() const
  1002. {return((TUint8 *)Ptr());}
  1008. inline TPtr8 &TPtr8::operator=(const TUint8 *aString)
  1009. #line 879
  1010. {Copy(aString);return(*this);}
  1015. inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)
  1016. #line 899
  1017. {Copy(aDes);return(*this);}
  1022. inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)
  1023. #line 919
  1024. {Copy(aDes);return(*this);}
  1029. inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)
  1030. #line 940
  1031. {new(this) TPtr8(aBuf,aLength,aMaxLength);}
  1036. inline void TPtr8::Set(const TPtr8 &aPtr)
  1037. #line 955
  1038. {new(this) TPtr8(aPtr);}
  1044. template <TInt S>
  1045. inline TBuf8<S>::TBuf8()
  1046. : TBufBase8(S)
  1047. #line 972
  1048. {}
  1053. template <TInt S>
  1054. inline TBuf8<S>::TBuf8(TInt aLength)
  1055. : TBufBase8(aLength,S)
  1056. #line 994
  1057. {}
  1062. template <TInt S>
  1063. inline TBuf8<S>::TBuf8(const TUint8 *aString)
  1064. : TBufBase8(aString,S)
  1065. #line 1018
  1066. {}
  1071. template <TInt S>
  1072. inline TBuf8<S>::TBuf8(const TDesC8 &aDes)
  1073. : TBufBase8(aDes,S)
  1074. #line 1042
  1075. {}
  1080. template <TInt S>
  1081. inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)
  1082. #line 1062
  1083. {Copy(aString);return(*this);}
  1088. template <TInt S>
  1089. inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)
  1090. #line 1082
  1091. {Copy(aDes);return(*this);}
  1096. template <TInt S>
  1097. inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)
  1098. #line 1100
  1099. {Copy(aBuf);return *this;}
  1105. template <TInt S>
  1106. inline TAlignedBuf8<S>::TAlignedBuf8()
  1107. : TBufBase8(S)
  1108. #line 1117
  1109. {}
  1114. template <TInt S>
  1115. inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)
  1116. : TBufBase8(aLength,S)
  1117. #line 1139
  1118. {}
  1123. template <TInt S>
  1124. inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)
  1125. : TBufBase8(aString,S)
  1126. #line 1163
  1127. {}
  1132. template <TInt S>
  1133. inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)
  1134. : TBufBase8(aDes,S)
  1135. #line 1187
  1136. {}
  1141. template <TInt S>
  1142. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)
  1143. #line 1207
  1144. {Copy(aString);return(*this);}
  1149. template <TInt S>
  1150. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)
  1151. #line 1227
  1152. {Copy(aDes);return(*this);}
  1157. template <TInt S>
  1158. inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)
  1159. #line 1245
  1160. {Copy(aBuf);return *this;}
  1166. template <TInt S>
  1167. inline const TDesC8* TLitC8<S>::operator&() const
  1173. {return (reinterpret_cast<const TDesC8*>(this)) ;}
  1178. template <TInt S>
  1179. inline const TDesC8& TLitC8<S>::operator()() const
  1185. {return *operator&();}
  1190. template <TInt S>
  1191. inline TLitC8<S>::operator const TDesC8&() const
  1196. {return *operator&();}
  1200. template <TInt S>
  1201. inline TLitC8<S>::operator const __TRefDesC8() const
  1208. {return *operator&();}
  1215. inline TBool TDesC16::operator<(const TDesC16 &aDes) const
  1216. #line 1314
  1217. {return(Compare(aDes)<0);}
  1222. inline TBool TDesC16::operator<=(const TDesC16 &aDes) const
  1223. #line 1333
  1224. {return(Compare(aDes)<=0);}
  1229. inline TBool TDesC16::operator>(const TDesC16 &aDes) const
  1230. #line 1352
  1231. {return(Compare(aDes)>0);}
  1236. inline TBool TDesC16::operator>=(const TDesC16 &aDes) const
  1237. #line 1371
  1238. {return(Compare(aDes)>=0);}
  1243. inline TBool TDesC16::operator==(const TDesC16 &aDes) const
  1244. #line 1390
  1245. {return(Compare(aDes)==0);}
  1250. inline TBool TDesC16::operator!=(const TDesC16 &aDes) const
  1251. #line 1409
  1252. {return(Compare(aDes)!=0);}
  1257. inline const TUint16 &TDesC16::operator[](TInt anIndex) const
  1258. #line 1427
  1259. {return(AtC(anIndex));}
  1264. inline TInt TDesC16::Length() const
  1272. {return(iLength&KMaskDesLength16);}
  1277. inline TInt TDesC16::Size() const
  1278. #line 1454
  1279. {return(Length()<<1);}
  1284. inline void TDesC16::DoSetLength(TInt aLength)
  1285. {iLength=(iLength&(~KMaskDesLength16))|aLength;}
  1291. inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)
  1292. #line 1478
  1293. {new(this) TPtrC16(aBuf,aLength);}
  1298. inline void TPtrC16::Set(const TDesC16 &aDes)
  1306. {new(this) TPtrC16(aDes);}
  1311. inline void TPtrC16::Set(const TPtrC16& aPtr)
  1312. {new(this) TPtrC16(aPtr);}
  1318. inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)
  1319. {return TPtr16(*this,aMaxLength);}
  1325. template <TInt S>
  1326. inline TBufC16<S>::TBufC16()
  1327. : TBufCBase16()
  1328. #line 1526
  1329. {}
  1334. template <TInt S>
  1335. inline TBufC16<S>::TBufC16(const TUint16 *aString)
  1336. : TBufCBase16(aString,S)
  1337. #line 1550
  1338. {}
  1343. template <TInt S>
  1344. inline TBufC16<S>::TBufC16(const TDesC16 &aDes)
  1345. : TBufCBase16(aDes,S)
  1346. #line 1574
  1347. {}
  1352. template <TInt S>
  1353. inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)
  1354. #line 1593
  1355. {Copy(aString,S);return(*this);}
  1360. template <TInt S>
  1361. inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)
  1362. #line 1612
  1363. {Copy(aDes,S);return(*this);}
  1368. template <TInt S>
  1369. inline TPtr16 TBufC16<S>::Des()
  1370. #line 1642
  1371. {return(DoDes(S));}
  1378. inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)
  1379. #line 1667
  1380. {return *this=static_cast<const TDesC16&>(aLcb);}
  1387. inline TDes16 &TDes16::operator=(const TUint16 *aString)
  1388. #line 1687
  1389.     {Copy(aString);return(*this);}
  1394. inline TDes16 &TDes16::operator=(const TDesC16 &aDes)
  1395. #line 1705
  1396.     {Copy(aDes);return(*this);}
  1401. inline TDes16 &TDes16::operator=(const TDes16 &aDes)
  1402. #line 1723
  1403.     {Copy(aDes);return(*this);}
  1408. inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)
  1409. #line 1742
  1410. {Append(aDes);return(*this);}
  1415. inline const TUint16 &TDes16::operator[](TInt anIndex) const
  1416. #line 1759
  1417. {return(AtC(anIndex));}
  1422. inline TUint16 &TDes16::operator[](TInt anIndex)
  1423. #line 1778
  1424. {return((TUint16 &)AtC(anIndex));}
  1429. inline TInt TDes16::MaxLength() const
  1430. #line 1792
  1431. {return(iMaxLength);}
  1436. inline TInt TDes16::MaxSize() const
  1437. #line 1806
  1438. {return(iMaxLength<<1);}
  1443. inline TUint16 * TDes16::WPtr() const
  1444. {return((TUint16 *)Ptr());}
  1450. inline TPtr16 &TPtr16::operator=(const TUint16 *aString)
  1451. #line 1832
  1452. {Copy(aString);return(*this);}
  1457. inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)
  1458. #line 1852
  1459. {Copy(aDes);return(*this);}
  1464. inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)
  1465. #line 1872
  1466. {Copy(aDes);return(*this);}
  1471. inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)
  1472. #line 1893
  1473. {new(this) TPtr16(aBuf,aLength,aMaxLength);}
  1478. inline void TPtr16::Set(const TPtr16 &aPtr)
  1479. #line 1908
  1480. {new(this) TPtr16(aPtr);}
  1486. template <TInt S>
  1487. inline TBuf16<S>::TBuf16()
  1488. : TBufBase16(S)
  1489. #line 1925
  1490. {}
  1495. template <TInt S>
  1496. inline TBuf16<S>::TBuf16(TInt aLength)
  1497. : TBufBase16(aLength,S)
  1498. #line 1947
  1499. {}
  1504. template <TInt S>
  1505. inline TBuf16<S>::TBuf16(const TUint16 *aString)
  1506. : TBufBase16(aString,S)
  1507. #line 1971
  1508. {}
  1513. template <TInt S>
  1514. inline TBuf16<S>::TBuf16(const TDesC16 &aDes)
  1515. : TBufBase16(aDes,S)
  1516. #line 1995
  1517. {}
  1522. template <TInt S>
  1523. inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)
  1524. #line 2015
  1525. {Copy(aString);return(*this);}
  1530. template <TInt S>
  1531. inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)
  1532. #line 2035
  1533. {Copy(aDes);return(*this);}
  1538. template <TInt S>
  1539. inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)
  1540. #line 2056
  1541. {Copy(aBuf);return *this;}
  1542. #line 2083
  1543. inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)
  1544. {
  1545. Assign(HBufC16::NewL(aStream,aMaxLength));
  1546. }
  1550. template <TInt S>
  1551. inline const TDesC16* TLitC16<S>::operator&() const
  1557. {return (reinterpret_cast<const TDesC16*>(this)) ;}
  1562. template <TInt S>
  1563. inline const TDesC16& TLitC16<S>::operator()() const
  1569. {return *operator&();}
  1574. template <TInt S>
  1575. inline TLitC16<S>::operator const TDesC16&() const
  1580. {return *operator&();}
  1585. template <TInt S>
  1586. inline TLitC16<S>::operator const __TRefDesC16() const
  1593. {return *operator&();}
  1601. template <TInt S>
  1602. inline TBufC<S>::TBufC()
  1603. : TBufCBase16()
  1604. #line 2157
  1605. {}
  1610. template <TInt S>
  1611. inline TBufC<S>::TBufC(const TText *aString)
  1612. : TBufCBase16(aString,S)
  1613. #line 2186
  1614. {}
  1619. template <TInt S>
  1620. inline TBufC<S>::TBufC(const TDesC &aDes)
  1621. : TBufCBase16(aDes,S)
  1622. #line 2219
  1623. {}
  1624. #line 2234
  1625. template <TInt S>
  1626. inline TBufC<S> &TBufC<S>::operator=(const TText *aString)
  1627. #line 2253
  1628. {Copy(aString,S);return(*this);}
  1633. template <TInt S>
  1634. inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)
  1635. #line 2277
  1636. {Copy(aDes,S);return(*this);}
  1641. template <TInt S>
  1642. inline TPtr TBufC<S>::Des()
  1643. #line 2308
  1644. {return(DoDes(S));}
  1651. template <TInt S>
  1652. inline TBuf<S>::TBuf()
  1653. : TBufBase16(S)
  1661. {}
  1666. template <TInt S>
  1667. inline TBuf<S>::TBuf(TInt aLength)
  1668. : TBufBase16(aLength,S)
  1669. #line 2350
  1670. {}
  1675. template <TInt S>
  1676. inline TBuf<S>::TBuf(const TText *aString)
  1677. : TBufBase16(aString,S)
  1678. #line 2378
  1679. {}
  1684. template <TInt S>
  1685. inline TBuf<S>::TBuf(const TDesC &aDes)
  1686. : TBufBase16(aDes,S)
  1687. #line 2407
  1688. {}
  1689. #line 2426
  1690. template <TInt S>
  1691. inline TBuf<S> &TBuf<S>::operator=(const TText *aString)
  1692. {Copy(aString);return(*this);}
  1693. template <TInt S>
  1694. inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)
  1695. {Copy(aDes);return(*this);}
  1696. template <TInt S>
  1697. inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)
  1698. {Copy(aBuf);return(*this);}
  1704. template <TInt S>
  1705. inline const TDesC* TLitC<S>::operator&() const
  1711. {return (reinterpret_cast<const TDesC*>(this)) ;}
  1716. template <TInt S>
  1717. inline const TDesC& TLitC<S>::operator()() const
  1723. {return *operator&();}
  1728. template <TInt S>
  1729. inline TLitC<S>::operator const TDesC&() const
  1734. {return *operator&();}
  1739. template <TInt S>
  1740. inline TLitC<S>::operator const __TRefDesC() const
  1747. {return *operator&();}
  1753. template <class T>
  1754. inline TPckgC<T>::TPckgC(const T &aRef)
  1755. : TPtrC8((const TUint8 *)&aRef,sizeof(T))
  1763. {}
  1768. template <class T>
  1769. inline const T &TPckgC<T>::operator()() const
  1776. {return(*((const T *)iPtr));}
  1782. template <class T>
  1783. inline TPckg<T>::TPckg(const T &aRef)
  1784. : TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T))
  1792. {}
  1797. template <class T>
  1798. inline T &TPckg<T>::operator()()
  1805. {return(*((T *)iPtr));}
  1811. template <class T>
  1812. inline TPckgBuf<T>::TPckgBuf()
  1813. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1821. {new(&this->iBuf[0]) T;}
  1826. template <class T>
  1827. inline TPckgBuf<T>::TPckgBuf(const T &aRef)
  1828. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1829. #line 2576
  1830. {new(&this->iBuf[0]) T(aRef);}
  1835. template <class T>
  1836. inline TPckgBuf<T> &TPckgBuf<T>::operator=(const TPckgBuf<T> &aRef)
  1844. {this->Copy(aRef);return(*this);}
  1849. template <class T>
  1850. inline T &TPckgBuf<T>::operator=(const T &aRef)
  1851. #line 2605
  1852. {this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));}
  1857. template <class T>
  1858. inline T &TPckgBuf<T>::operator()()
  1865. {return(*((T *)&this->iBuf[0]));}
  1870. template <class T>
  1871. inline const T &TPckgBuf<T>::operator()() const
  1878. {return(*((T *)&this->iBuf[0]));}
  1884. inline TRequestStatus::TRequestStatus()
  1888. : iFlags(0)
  1889. {}
  1894. inline TRequestStatus::TRequestStatus(TInt aVal)
  1902. : iStatus(aVal),
  1903. iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0)
  1905. {}
  1910. inline TInt TRequestStatus::operator=(TInt aVal)
  1918. {
  1919. if(aVal==KRequestPending)
  1920. iFlags|=TRequestStatus::ERequestPending;
  1921. else
  1922. iFlags&=~TRequestStatus::ERequestPending;
  1923. return (iStatus=aVal);
  1924. }
  1929. inline TBool TRequestStatus::operator==(TInt aVal) const
  1930. #line 2691
  1931. {return(iStatus==aVal);}
  1936. inline TBool TRequestStatus::operator!=(TInt aVal) const
  1937. #line 2705
  1938. {return(iStatus!=aVal);}
  1943. inline TBool TRequestStatus::operator>=(TInt aVal) const
  1944. #line 2720
  1945. {return(iStatus>=aVal);}
  1950. inline TBool TRequestStatus::operator<=(TInt aVal) const
  1951. #line 2735
  1952. {return(iStatus<=aVal);}
  1957. inline TBool TRequestStatus::operator>(TInt aVal) const
  1958. #line 2750
  1959. {return(iStatus>aVal);}
  1964. inline TBool TRequestStatus::operator<(TInt aVal) const
  1965. #line 2765
  1966. {return(iStatus<aVal);}
  1971. inline TInt TRequestStatus::Int() const
  1977. {return(iStatus);}
  1984. inline TPoint::TPoint()
  1985. : iX(0),iY(0)
  1989. {}
  1994. inline TPoint::TPoint(TInt aX,TInt aY)
  1995. : iX(aX),iY(aY)
  2002. {}
  2008. inline TSize::TSize()
  2009. : iWidth(0),iHeight(0)
  2013. {}
  2018. inline TSize::TSize(TInt aWidth,TInt aHeight)
  2019. : iWidth(aWidth),iHeight(aHeight)
  2026. {}
  2033. inline RHandleBase::RHandleBase()
  2034. : iHandle(0)
  2038. {}
  2044. inline RHandleBase::RHandleBase(TInt aHandle)
  2045. : iHandle(aHandle)
  2046. #line 2853
  2047. {}
  2053. inline void RHandleBase::SetHandle(TInt aHandle)
  2060. { iHandle=aHandle; }
  2065. inline TInt RHandleBase::Handle() const
  2071. {return(iHandle);}
  2076. inline TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError)
  2077. #line 2899
  2078. {
  2079. if(aHandleOrError>=0)
  2080. {
  2081. iHandle = aHandleOrError;
  2082. return KErrNone;
  2083. }
  2084. iHandle = 0;
  2085. return aHandleOrError;
  2086. }
  2093. inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType)
  2094. #line 2935
  2095. {return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));}
  2096. #line 2947
  2097. inline RFastLock::RFastLock()
  2098. : iCount(0)
  2099. {}
  2100. #line 2960
  2101. inline RMessagePtr2::RMessagePtr2()
  2102. : iHandle(0)
  2103. {}
  2104. #line 2972
  2105. inline TBool RMessagePtr2::IsNull() const
  2106. {return iHandle==0;}
  2107. #line 2983
  2108. inline TInt RMessagePtr2::Handle() const
  2109. {return iHandle;}
  2110. inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2111. {return aLeft.Handle()==aRight.Handle();}
  2112. inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2113. {return aLeft.Handle()!=aRight.Handle();}
  2114. #line 3000
  2115. inline RMessage2::RMessage2()
  2116. {}
  2117. #line 3011
  2118. inline TInt RMessage2::Function() const
  2119. {return(iFunction);}
  2120. #line 3022
  2121. inline TInt RMessage2::Int0() const
  2122. {return(iArgs[0]);}
  2123. #line 3033
  2124. inline TInt RMessage2::Int1() const
  2125. {return(iArgs[1]);}
  2126. #line 3044
  2127. inline TInt RMessage2::Int2() const
  2128. {return(iArgs[2]);}
  2129. #line 3054
  2130. inline TInt RMessage2::Int3() const
  2131. {return(iArgs[3]);}
  2132. #line 3064
  2133. inline const TAny *RMessage2::Ptr0() const
  2134. {return((const TAny *)iArgs[0]);}
  2135. #line 3075
  2136. inline const TAny *RMessage2::Ptr1() const
  2137. {return((const TAny *)iArgs[1]);}
  2138. #line 3086
  2139. inline const TAny *RMessage2::Ptr2() const
  2140. {return((const TAny *)iArgs[2]);}
  2141. #line 3097
  2142. inline const TAny *RMessage2::Ptr3() const
  2143. {return((const TAny *)iArgs[3]);}
  2144. #line 3107
  2145. inline CSession2* RMessage2::Session() const
  2146. {return (CSession2*)iSessionPtr; }
  2152. inline TUid TUid::Uid(TInt aUid)
  2153. #line 3123
  2154. {TUid uid={aUid};return uid;}
  2159. inline TUid TUid::Null()
  2165. {TUid uid={KNullUidValue};return uid;}
  2172. template <class T>
  2173. inline TArray<T>::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr)
  2174. : iPtr(aPtr),iCount(aCount),iAt(anAt)
  2175. #line 3195
  2176. {}
  2181. template <class T>
  2182. inline TInt TArray<T>::Count() const
  2189. {return((*iCount)(iPtr));}
  2194. template <class T>
  2195. inline const T &TArray<T>::operator[](TInt anIndex) const
  2196. #line 3232
  2197. {return(*((const T *)(*iAt)(iPtr,anIndex)));}
  2204. template <class T>
  2205. inline TIdentityRelation<T>::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) )
  2206. #line 3254
  2207. { iIdentity=(TGeneralIdentityRelation)anIdentity; }
  2212. template <class T>
  2213. inline TIdentityRelation<T>::operator TGeneralIdentityRelation() const
  2218. { return iIdentity; }
  2224. template <class T>
  2225. inline TLinearOrder<T>::TLinearOrder( TInt(*anOrder)(const T&, const T&) )
  2226. #line 3288
  2227. { iOrder=(TGeneralLinearOrder)anOrder; }
  2232. template <class T>
  2233. inline TLinearOrder<T>::operator TGeneralLinearOrder() const
  2238. { return iOrder; }
  2239. #line 3312
  2240. template <class T>
  2241. inline RPointerArray<T>::RPointerArray()
  2242. : RPointerArrayBase()
  2243. {}
  2244. #line 3331
  2245. template <class T>
  2246. inline RPointerArray<T>::RPointerArray(TInt aGranularity)
  2247. : RPointerArrayBase(aGranularity)
  2248. {}
  2249. #line 3354
  2250. template <class T>
  2251. inline RPointerArray<T>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2252. : RPointerArrayBase(aMinGrowBy, aFactor)
  2253. {}
  2258. template <class T>
  2259. inline void RPointerArray<T>::Close()
  2260. #line 3372
  2261. {RPointerArrayBase::Close();}
  2266. template <class T>
  2267. inline TInt RPointerArray<T>::Count() const
  2273. { return RPointerArrayBase::Count(); }
  2278. template <class T>
  2279. inline T* const& RPointerArray<T>::operator[](TInt anIndex) const
  2280. #line 3408
  2281. {return (T* const&)At(anIndex);}
  2286. template <class T>
  2287. inline T*& RPointerArray<T>::operator[](TInt anIndex)
  2288. #line 3432
  2289. {return (T*&)At(anIndex);}
  2294. template <class T>
  2295. inline TInt RPointerArray<T>::Append(const T* anEntry)
  2296. #line 3447
  2297. { return RPointerArrayBase::Append(anEntry); }
  2302. template <class T>
  2303. inline TInt RPointerArray<T>::Insert(const T* anEntry, TInt aPos)
  2304. #line 3468
  2305. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2310. template <class T>
  2311. inline void RPointerArray<T>::Remove(TInt anIndex)
  2312. #line 3488
  2313. {RPointerArrayBase::Remove(anIndex);}
  2318. template <class T>
  2319. inline void RPointerArray<T>::Compress()
  2320. #line 3503
  2321. {RPointerArrayBase::Compress();}
  2326. template <class T>
  2327. inline void RPointerArray<T>::Reset()
  2328. #line 3522
  2329. {RPointerArrayBase::Reset();}
  2334. template <class T>
  2335. inline TInt RPointerArray<T>::Find(const T* anEntry) const
  2336. #line 3542
  2337. { return RPointerArrayBase::Find(anEntry); }
  2342. template <class T>
  2343. inline TInt RPointerArray<T>::Find(const T* anEntry, TIdentityRelation<T> anIdentity) const
  2344. #line 3566
  2345. { return RPointerArrayBase::Find(anEntry,anIdentity); }
  2350. template <class T>
  2351. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry) const
  2352. #line 3584
  2353. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2358. template <class T>
  2359. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const
  2360. #line 3606
  2361. { return RPointerArrayBase::FindIsq(anEntry,anOrder); }
  2366. template <class T>
  2367. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry, TInt& anIndex) const
  2368. #line 3631
  2369. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2374. template <class T>
  2375. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2376. #line 3660
  2377. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); }
  2382. template <class T>
  2383. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const
  2384. #line 3691
  2385. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2390. template <class T>
  2391. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2392. #line 3726
  2393. { return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); }
  2398. template <class T>
  2399. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const
  2400. #line 3766
  2401. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2406. template <class T>
  2407. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2408. #line 3810
  2409. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); }
  2414. template <class T>
  2415. inline TInt RPointerArray<T>::InsertInAddressOrder(const T* anEntry)
  2416. #line 3833
  2417. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2422. template <class T>
  2423. inline TInt RPointerArray<T>::InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder)
  2424. #line 3862
  2425. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); }
  2430. template <class T>
  2431. inline TInt RPointerArray<T>::InsertInAddressOrderAllowRepeats(const T* anEntry)
  2432. #line 3885
  2433. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2438. template <class T>
  2439. inline TInt RPointerArray<T>::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder)
  2440. #line 3911
  2441. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); }
  2447. template <class T>
  2448. inline RPointerArray<T>::RPointerArray(T** aEntries, TInt aCount)
  2449. : RPointerArrayBase((TAny **)aEntries, aCount)
  2450. #line 3935
  2451. {}
  2456. template <class T>
  2457. inline void RPointerArray<T>::GranularCompress()
  2458. #line 3950
  2459. {RPointerArrayBase::GranularCompress();}
  2464. template <class T>
  2465. inline TInt RPointerArray<T>::Reserve(TInt aCount)
  2466. #line 3969
  2467. { return RPointerArrayBase::DoReserve(aCount); }
  2472. template <class T>
  2473. inline void RPointerArray<T>::SortIntoAddressOrder()
  2477. { HeapSortUnsigned(); }
  2482. template <class T>
  2483. inline void RPointerArray<T>::Sort(TLinearOrder<T> anOrder)
  2484. #line 3996
  2485. { HeapSort(anOrder); }
  2490. template <class T>
  2491. inline TArray<T*> RPointerArray<T>::Array() const
  2499. { return TArray<T*>(GetCount,GetElementPtr,(const CBase*)this); }
  2504. template <class T>
  2505. void RPointerArray<T>::ResetAndDestroy()
  2506. #line 4026
  2507. {
  2508. TInt c=Count();
  2509. T** pE=(T**)Entries();
  2510. ZeroCount();
  2511. TInt i;
  2512. for (i=0; i<c; i++)
  2513. {
  2514. delete *pE;
  2515. pE++;
  2516. }
  2517. Reset();
  2518. }
  2519. #line 4049
  2520. inline RPointerArray<TAny>::RPointerArray()
  2521. : RPointerArrayBase()
  2522. {}
  2523. #line 4067
  2524. inline RPointerArray<TAny>::RPointerArray(TInt aGranularity)
  2525. : RPointerArrayBase(aGranularity)
  2526. {}
  2527. #line 4089
  2528. inline RPointerArray<TAny>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2529. : RPointerArrayBase(aMinGrowBy, aFactor)
  2530. {}
  2535. inline void RPointerArray<TAny>::Close()
  2536. #line 4105
  2537. {RPointerArrayBase::Close();}
  2542. inline TInt RPointerArray<TAny>::Count() const
  2548. { return RPointerArrayBase::Count(); }
  2553. inline TAny* const& RPointerArray<TAny>::operator[](TInt anIndex) const
  2554. #line 4139
  2555. {return At(anIndex);}
  2560. inline TAny*& RPointerArray<TAny>::operator[](TInt anIndex)
  2561. #line 4162
  2562. {return At(anIndex);}
  2567. inline TInt RPointerArray<TAny>::Append(const TAny* anEntry)
  2568. #line 4176
  2569. { return RPointerArrayBase::Append(anEntry); }
  2574. inline TInt RPointerArray<TAny>::Insert(const TAny* anEntry, TInt aPos)
  2575. #line 4196
  2576. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2581. inline void RPointerArray<TAny>::Remove(TInt anIndex)
  2582. #line 4215
  2583. {RPointerArrayBase::Remove(anIndex);}
  2588. inline void RPointerArray<TAny>::Compress()
  2589. #line 4229
  2590. {RPointerArrayBase::Compress();}
  2595. inline void RPointerArray<TAny>::Reset()
  2596. #line 4247
  2597. {RPointerArrayBase::Reset();}
  2602. inline TInt RPointerArray<TAny>::Find(const TAny* anEntry) const
  2603. #line 4266
  2604. { return RPointerArrayBase::Find(anEntry); }
  2609. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry) const
  2610. #line 4283
  2611. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2616. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const
  2617. #line 4307
  2618. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2623. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const
  2624. #line 4337
  2625. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2630. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const
  2631. #line 4376
  2632. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2637. inline TInt RPointerArray<TAny>::InsertInAddressOrder(const TAny* anEntry)
  2638. #line 4398
  2639. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2644. inline TInt RPointerArray<TAny>::InsertInAddressOrderAllowRepeats(const TAny* anEntry)
  2645. #line 4420
  2646. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2652. inline RPointerArray<TAny>::RPointerArray(TAny** aEntries, TInt aCount)
  2653. : RPointerArrayBase((TAny **)aEntries, aCount)
  2654. #line 4443
  2655. {}
  2660. inline void RPointerArray<TAny>::GranularCompress()
  2661. #line 4457
  2662. {RPointerArrayBase::GranularCompress();}
  2667. inline void RPointerArray<TAny>::SortIntoAddressOrder()
  2671. { HeapSortUnsigned(); }
  2676. inline TArray<TAny*> RPointerArray<TAny>::Array() const
  2684. { return TArray<TAny*>(GetCount,GetElementPtr,(const CBase*)this); }
  2689. template <class T>
  2690. inline RArray<T>::RArray()
  2691. : RArrayBase(sizeof(T))
  2692. #line 4497
  2693. {}
  2698. template <class T>
  2699. inline RArray<T>::RArray(TInt aGranularity)
  2700. : RArrayBase(sizeof(T),aGranularity)
  2701. #line 4519
  2702. {}
  2707. template <class T>
  2708. inline RArray<T>::RArray(TInt aGranularity, TInt aKeyOffset)
  2709. : RArrayBase(sizeof(T),aGranularity,aKeyOffset)
  2710. #line 4543
  2711. {}
  2712. #line 4567
  2713. template <class T>
  2714. inline RArray<T>::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
  2715. : RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor)
  2716. {}
  2721. template <class T>
  2722. inline void RArray<T>::Close()
  2728. {RArrayBase::Close();}
  2733. template <class T>
  2734. inline TInt RArray<T>::Count() const
  2740. {return RArrayBase::Count();}
  2745. template <class T>
  2746. inline const T& RArray<T>::operator[](TInt anIndex) const
  2747. #line 4616
  2748. {return *(const T*)At(anIndex); }
  2753. template <class T>
  2754. inline T& RArray<T>::operator[](TInt anIndex)
  2755. #line 4638
  2756. {return *(T*)At(anIndex); }
  2761. template <class T>
  2762. inline TInt RArray<T>::Append(const T& anEntry)
  2763. #line 4653
  2764. {return RArrayBase::Append(&anEntry);}
  2769. template <class T>
  2770. inline TInt RArray<T>::Insert(const T& anEntry, TInt aPos)
  2771. #line 4675
  2772. {return RArrayBase::Insert(&anEntry,aPos);}
  2777. template <class T>
  2778. inline void RArray<T>::Remove(TInt anIndex)
  2779. #line 4692
  2780. {RArrayBase::Remove(anIndex);}
  2785. template <class T>
  2786. inline void RArray<T>::Compress()
  2794. {RArrayBase::Compress();}
  2799. template <class T>
  2800. inline void RArray<T>::Reset()
  2801. #line 4721
  2802. {RArrayBase::Reset();}
  2807. template <class T>
  2808. inline TInt RArray<T>::Find(const T& anEntry) const
  2809. #line 4743
  2810. {return RArrayBase::Find(&anEntry);}
  2815. template <class T>
  2816. inline TInt RArray<T>::Find(const T& anEntry, TIdentityRelation<T> anIdentity) const
  2817. #line 4768
  2818. {return RArrayBase::Find(&anEntry,anIdentity);}
  2823. template <class T>
  2824. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry) const
  2825. #line 4787
  2826. {return RArrayBase::FindIsqSigned(&anEntry);}
  2831. template <class T>
  2832. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry) const
  2833. #line 4806
  2834. {return RArrayBase::FindIsqUnsigned(&anEntry);}
  2839. template <class T>
  2840. inline TInt RArray<T>::FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const
  2841. #line 4828
  2842. {return RArrayBase::FindIsq(&anEntry,anOrder);}
  2847. template <class T>
  2848. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2849. #line 4851
  2850. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex);}
  2855. template <class T>
  2856. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2857. #line 4875
  2858. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);}
  2863. template <class T>
  2864. inline TInt RArray<T>::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2865. #line 4902
  2866. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);}
  2871. template <class T>
  2872. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const
  2873. #line 4936
  2874. {return RArrayBase::FindIsqSigned(&anEntry,aMode);}
  2879. template <class T>
  2880. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const
  2881. #line 4970
  2882. {return RArrayBase::FindIsqUnsigned(&anEntry,aMode);}
  2887. template <class T>
  2888. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2889. #line 5003
  2890. {return RArrayBase::FindIsq(&anEntry,anOrder,aMode);}
  2895. template <class T>
  2896. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2897. #line 5042
  2898. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);}
  2903. template <class T>
  2904. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2905. #line 5081
  2906. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);}
  2911. template <class T>
  2912. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2913. #line 5123
  2914. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);}
  2919. template <class T>
  2920. inline TInt RArray<T>::InsertInSignedKeyOrder(const T& anEntry)
  2921. #line 5146
  2922. {return RArrayBase::InsertIsqSigned(&anEntry,EFalse);}
  2927. template <class T>
  2928. inline TInt RArray<T>::InsertInUnsignedKeyOrder(const T& anEntry)
  2929. #line 5169
  2930. {return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);}
  2935. template <class T>
  2936. inline TInt RArray<T>::InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder)
  2937. #line 5197
  2938. {return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);}
  2943. template <class T>
  2944. inline TInt RArray<T>::InsertInSignedKeyOrderAllowRepeats(const T& anEntry)
  2945. #line 5221
  2946. {return RArrayBase::InsertIsqSigned(&anEntry,ETrue);}
  2951. template <class T>
  2952. inline TInt RArray<T>::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry)
  2953. #line 5245
  2954. {return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);}
  2959. template <class T>
  2960. inline TInt RArray<T>::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder)
  2961. #line 5272
  2962. {return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);}
  2968. template <class T>
  2969. inline RArray<T>::RArray(TInt aEntrySize,T* aEntries, TInt aCount)
  2970. : RArrayBase(aEntrySize,aEntries,aCount)
  2971. #line 5303
  2972. {}
  2977. template <class T>
  2978. inline void RArray<T>::GranularCompress()
  2979. #line 5318
  2980. {RArrayBase::GranularCompress();}
  2985. template <class T>
  2986. inline TInt RArray<T>::Reserve(TInt aCount)
  2987. #line 5337
  2988. { return RArrayBase::DoReserve(aCount); }
  2993. template <class T>
  2994. inline void RArray<T>::SortSigned()
  2999. {HeapSortSigned();}
  3004. template <class T>
  3005. inline void RArray<T>::SortUnsigned()
  3010. {HeapSortUnsigned();}
  3015. template <class T>
  3016. inline void RArray<T>::Sort(TLinearOrder<T> anOrder)
  3017. #line 5375
  3018. {HeapSort(anOrder);}
  3023. template <class T>
  3024. inline TArray<T> RArray<T>::Array() const
  3030. { return TArray<T>(GetCount,GetElementPtr,(const CBase*)this); }
  3036. inline RArray<TInt>::RArray()
  3037. : RPointerArrayBase()
  3044. {}
  3049. inline RArray<TInt>::RArray(TInt aGranularity)
  3050. : RPointerArrayBase(aGranularity)
  3051. #line 5417
  3052. {}
  3053. #line 5437
  3054. inline RArray<TInt>::RArray(TInt aMinGrowBy, TInt aFactor)
  3055. : RPointerArrayBase(aMinGrowBy, aFactor)
  3056. {}
  3061. inline void RArray<TInt>::Close()
  3067. {RPointerArrayBase::Close();}
  3072. inline TInt RArray<TInt>::Count() const
  3078. { return RPointerArrayBase::Count(); }
  3083. inline const TInt& RArray<TInt>::operator[](TInt anIndex) const
  3084. #line 5484
  3085. {return (const TInt&)At(anIndex);}
  3090. inline TInt& RArray<TInt>::operator[](TInt anIndex)
  3091. #line 5507
  3092. {return (TInt&)At(anIndex);}
  3097. inline TInt RArray<TInt>::Append(TInt anEntry)
  3098. #line 5521
  3099. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3104. inline TInt RArray<TInt>::Insert(TInt anEntry, TInt aPos)
  3105. #line 5541
  3106. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3111. inline void RArray<TInt>::Remove(TInt anIndex)
  3112. #line 5558
  3113. {RPointerArrayBase::Remove(anIndex);}
  3118. inline void RArray<TInt>::Compress()
  3126. {RPointerArrayBase::Compress();}
  3131. inline void RArray<TInt>::Reset()
  3132. #line 5586
  3133. {RPointerArrayBase::Reset();}
  3138. inline TInt RArray<TInt>::Find(TInt anEntry) const
  3139. #line 5604
  3140. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3145. inline TInt RArray<TInt>::FindInOrder(TInt anEntry) const
  3146. #line 5621
  3147. { return RPointerArrayBase::FindIsqSigned(anEntry); }
  3152. inline TInt RArray<TInt>::FindInOrder(TInt anEntry, TInt& anIndex) const
  3153. #line 5644
  3154. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); }
  3159. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt aMode) const
  3160. #line 5675
  3161. { return RPointerArrayBase::FindIsqSigned(anEntry,aMode); }
  3166. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const
  3167. #line 5713
  3168. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); }
  3173. inline TInt RArray<TInt>::InsertInOrder(TInt anEntry)
  3174. #line 5735
  3175. { return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); }
  3180. inline TInt RArray<TInt>::InsertInOrderAllowRepeats(TInt anEntry)
  3181. #line 5758
  3182. { return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); }
  3188. inline RArray<TInt>::RArray(TInt* aEntries, TInt aCount)
  3189. : RPointerArrayBase((TAny**)aEntries, aCount)
  3190. #line 5781
  3191. {}
  3193. inline void RArray<TInt>::GranularCompress()
  3194. #line 5792
  3195. {RPointerArrayBase::GranularCompress();}
  3200. inline TInt RArray<TInt>::Reserve(TInt aCount)
  3201. #line 5810
  3202. { return RPointerArrayBase::DoReserve(aCount); }
  3207. inline void RArray<TInt>::Sort()
  3211. { HeapSortSigned(); }
  3216. inline TArray<TInt> RArray<TInt>::Array() const
  3224. { return TArray<TInt>(GetCount,GetElementPtr,(const CBase*)this); }
  3229. inline RArray<TUint>::RArray()
  3230. : RPointerArrayBase()
  3231. #line 5847
  3232. {}
  3237. inline RArray<TUint>::RArray(TInt aGranularity)
  3238. : RPointerArrayBase(aGranularity)
  3239. #line 5863
  3240. {}
  3241. #line 5883
  3242. inline RArray<TUint>::RArray(TInt aMinGrowBy, TInt aFactor)
  3243. : RPointerArrayBase(aMinGrowBy, aFactor)
  3244. {}
  3249. inline void RArray<TUint>::Close()
  3255. {RPointerArrayBase::Close();}
  3260. inline TInt RArray<TUint>::Count() const
  3266. {return RPointerArrayBase::Count(); }
  3271. inline const TUint& RArray<TUint>::operator[](TInt anIndex) const
  3272. #line 5930
  3273. {return (const TUint&)At(anIndex);}
  3278. inline TUint& RArray<TUint>::operator[](TInt anIndex)
  3279. #line 5953
  3280. {return (TUint&)At(anIndex);}
  3285. inline TInt RArray<TUint>::Append(TUint anEntry)
  3293. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3298. inline TInt RArray<TUint>::Insert(TUint anEntry, TInt aPos)
  3299. #line 5987
  3300. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3305. inline void RArray<TUint>::Remove(TInt anIndex)
  3306. #line 6005
  3307. {RPointerArrayBase::Remove(anIndex);}
  3312. inline void RArray<TUint>::Compress()
  3320. {RPointerArrayBase::Compress();}
  3325. inline void RArray<TUint>::Reset()
  3326. #line 6033
  3327. {RPointerArrayBase::Reset();}
  3332. inline TInt RArray<TUint>::Find(TUint anEntry) const
  3333. #line 6051
  3334. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3339. inline TInt RArray<TUint>::FindInOrder(TUint anEntry) const
  3340. #line 6070
  3341. { return RPointerArrayBase::FindIsqUnsigned(anEntry); }
  3346. inline TInt RArray<TUint>::FindInOrder(TUint anEntry, TInt& anIndex) const
  3347. #line 6098
  3348. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); }
  3353. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt aMode) const
  3354. #line 6128
  3355. { return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); }
  3360. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const
  3361. #line 6163
  3362. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); }
  3367. inline TInt RArray<TUint>::InsertInOrder(TUint anEntry)
  3368. #line 6185
  3369. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); }
  3374. inline TInt RArray<TUint>::InsertInOrderAllowRepeats(TUint anEntry)
  3375. #line 6208
  3376. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); }
  3382. inline RArray<TUint>::RArray(TUint* aEntries, TInt aCount)
  3383. : RPointerArrayBase((TAny**)aEntries, aCount)
  3384. #line 6231
  3385. {}
  3389. inline void RArray<TUint>::GranularCompress()
  3390. #line 6244
  3391. {RPointerArrayBase::GranularCompress();}
  3396. inline TInt RArray<TUint>::Reserve(TInt aCount)
  3397. #line 6262
  3398. { return RPointerArrayBase::DoReserve(aCount); }
  3403. inline void RArray<TUint>::Sort()
  3407. { HeapSortUnsigned(); }
  3412. inline TArray<TUint> RArray<TUint>::Array() const
  3420. { return TArray<TUint>(GetCount,GetElementPtr,(const CBase*)this); }
  3421. #line 6293
  3422. inline void TIpcArgs::Set(TInt,TNothing)
  3423. {}
  3424. #line 6307
  3425. inline void TIpcArgs::Set(TInt aIndex,TInt aValue)
  3426. {
  3427. iArgs[aIndex] = aValue;
  3428. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3429. }
  3430. #line 6324
  3431. inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue)
  3432. {
  3433. iArgs[aIndex] = (TInt)aValue;
  3434. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3435. }
  3436. #line 6341
  3437. inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue)
  3438. {
  3439. iArgs[aIndex] = (TInt)aValue.Handle();
  3440. iFlags |= EHandle<<(aIndex*KBitsPerType);
  3441. }
  3442. #line 6358
  3443. inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue)
  3444. {
  3445. iArgs[aIndex] = (TInt)aValue;
  3446. iFlags |= EDesC8<<(aIndex*KBitsPerType);
  3447. }
  3448. #line 6377
  3449. inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue)
  3450. {
  3451. iArgs[aIndex] = (TInt)aValue;
  3452. iFlags |= EDesC16<<(aIndex*KBitsPerType);
  3453. }
  3454. #line 6396
  3455. inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue)
  3456. {
  3457. iArgs[aIndex] = (TInt)aValue;
  3458. iFlags |= EDes8<<(aIndex*KBitsPerType);
  3459. }
  3460. #line 6415
  3461. inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue)
  3462. {
  3463. iArgs[aIndex] = (TInt)aValue;
  3464. iFlags |= EDes16<<(aIndex*KBitsPerType);
  3465. }
  3472. inline TIpcArgs::TArgType TIpcArgs::Type(TNothing)
  3473. { return EUnspecified; }
  3474. inline TIpcArgs::TArgType TIpcArgs::Type(TInt)
  3475. { return EUnspecified; }
  3476. inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*)
  3477. { return EUnspecified; }
  3478. inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase)
  3479. { return EHandle; }
  3480. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*)
  3481. { return EDesC8; }
  3483. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*)
  3484. { return EDesC16; }
  3486. inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*)
  3487. { return EDes8; }
  3489. inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*)
  3490. { return EDes16; }
  3492. inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing)
  3493. {}
  3494. inline void TIpcArgs::Assign(TInt& aArg,TInt aValue)
  3495. { aArg = aValue; }
  3496. inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue)
  3497. { aArg = (TInt)aValue; }
  3498. inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue)
  3499. { aArg = (TInt)aValue.Handle(); }
  3500. inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue)
  3501. { aArg = (TInt)aValue; }
  3503. inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue)
  3504. { aArg = (TInt)aValue; }
  3506. inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue)
  3507. { aArg = (TInt)aValue; }
  3509. inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue)
  3510. { aArg = (TInt)aValue; }
  3517. inline SInt64::SInt64()
  3518. {}
  3520. inline SInt64::SInt64(Int64 a)
  3521. {
  3522. iData[0] = (TUint32)((Uint64)a);
  3523. iData[1] = (TUint32)(((Uint64)a)>>32);
  3524. }
  3526. inline SInt64& SInt64::operator=(Int64 a)
  3527. {
  3528. iData[0] = (TUint32)((Uint64)a);
  3529. iData[1] = (TUint32)(((Uint64)a)>>32);
  3530. return *this;
  3531. }
  3533. inline SInt64::operator Int64() const
  3534. {
  3535. Int64 x;
  3536. TUint32* px = (TUint32*)&x;
  3537. px[0] = iData[0];
  3538. px[1] = iData[1];
  3539. return x;
  3540. }
  3542. inline SUint64::SUint64()
  3543. {}
  3545. inline SUint64::SUint64(Uint64 a)
  3546. {
  3547. iData[0] = (TUint32)a;
  3548. iData[1] = (TUint32)(a>>32);
  3549. }
  3551. inline SUint64& SUint64::operator=(Uint64 a)
  3552. {
  3553. iData[0] = (TUint32)a;
  3554. iData[1] = (TUint32)(a>>32);
  3555. return *this;
  3556. }
  3558. inline SUint64::operator Uint64() const
  3559. {
  3560. Uint64 x;
  3561. TUint32* px = (TUint32*)&x;
  3562. px[0] = iData[0];
  3563. px[1] = iData[1];
  3564. return x;
  3565. }
  3567. inline SDouble::SDouble()
  3568. {}
  3570. inline SDouble::SDouble(TReal a)
  3571. {
  3572. const TUint32* pa = (const TUint32*)&a;
  3577. iData[0] = pa[0];
  3578. iData[1] = pa[1];
  3580. }
  3582. inline SDouble& SDouble::operator=(TReal a)
  3583. {
  3584. new (this) SDouble(a);
  3585. return *this;
  3586. }
  3588. inline SDouble::operator TReal() const
  3589. {
  3590. TReal x;
  3591. TUint32* px = (TUint32*)&x;
  3596. px[0] = iData[0];
  3597. px[1] = iData[1];
  3599. return x;
  3600. }
  3607. inline TSecureId::TSecureId()
  3608. {}
  3612. inline TSecureId::TSecureId(TUint32 aId)
  3613. : iId(aId) {}
  3617. inline TSecureId::operator TUint32() const
  3618. { return iId; }
  3622. inline TSecureId::TSecureId(TUid aId)
  3623. : iId(aId.iUid) {}
  3627. inline TSecureId::operator TUid() const
  3628. { return (TUid&)iId; }
  3633. inline const TSecureId* SSecureId::operator&() const
  3634. { return (const TSecureId*)this; }
  3635. inline SSecureId::operator const TSecureId&() const
  3636. { return (const TSecureId&)iId; }
  3637. inline SSecureId::operator TUint32() const
  3638. { return iId; }
  3639. inline SSecureId::operator TUid() const
  3640. { return (TUid&)iId; }
  3647. inline TVendorId::TVendorId()
  3648. {}
  3652. inline TVendorId::TVendorId(TUint32 aId)
  3653. : iId(aId) {}
  3657. inline TVendorId::operator TUint32() const
  3658. { return iId; }
  3662. inline TVendorId::TVendorId(TUid aId)
  3663. : iId(aId.iUid) {}
  3667. inline TVendorId::operator TUid() const
  3668. { return (TUid&)iId; }
  3673. inline const TVendorId* SVendorId::operator&() const
  3674. { return (const TVendorId*)this; }
  3675. inline SVendorId::operator const TVendorId&() const
  3676. { return (const TVendorId&)iId; }
  3677. inline SVendorId::operator TUint32() const
  3678. { return iId; }
  3679. inline SVendorId::operator TUid() const
  3680. { return (TUid&)iId; }
  3686. inline TCapabilitySet::TCapabilitySet()
  3687. {}
  3693. inline TCapabilitySet::TCapabilitySet(TCapability aCapability)
  3694. { new (this) TCapabilitySet(aCapability, aCapability); }
  3700. inline void TCapabilitySet::Set(TCapability aCapability)
  3701. { new (this) TCapabilitySet(aCapability, aCapability); }
  3708. inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2)
  3709. { new (this) TCapabilitySet(aCapability1, aCapability2); }
  3715. inline TSecurityInfo::TSecurityInfo()
  3716. {}
  3721. inline TSecurityPolicy::TSecurityPolicy()
  3722. { new (this) TSecurityPolicy(EAlwaysFail); }
  3728. inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const
  3729. { return (const TSecurityPolicy*)this; }
  3735. inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const
  3736. { return *(const TSecurityPolicy*)this; }
  3742. inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const
  3743. { return *(const TSecurityPolicy*)this; }
  3744. #line 6341 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.h" /* stack depth 4 */
  3745. #line 13 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 3 */
  3752. class TFunctor
  3753. {
  3754. public:
  3755. __declspec(dllexport) virtual void operator()() =0;
  3756. };
  3757. #line 53
  3758. class TCallBack
  3759. {
  3760. public:
  3761. inline TCallBack();
  3762. inline TCallBack(TInt (*aFunction)(TAny* aPtr));
  3763. inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
  3764. inline TInt CallBack() const;
  3765. public:
  3770. TInt (*iFunction)(TAny* aPtr);
  3777. TAny* iPtr;
  3778. };
  3779. #line 89
  3780. class TSglQueLink
  3781. {
  3783. public:
  3784. inline TSglQueLink() : iNext(0 )
  3792. {}
  3794. private:
  3795. __declspec(dllexport) void Enque(TSglQueLink* aLink);
  3796. public:
  3800. TSglQueLink* iNext;
  3801. friend class TSglQueBase;
  3802. };
  3803. #line 130
  3804. class TDblQueLinkBase
  3805. {
  3806. public:
  3807. inline TDblQueLinkBase() : iNext(0 )
  3815. {}
  3816. __declspec(dllexport) void Enque(TDblQueLinkBase* aLink);
  3817. __declspec(dllexport) void AddBefore(TDblQueLinkBase* aLink);
  3818. public:
  3822. TDblQueLinkBase* iNext;
  3827. TDblQueLinkBase* iPrev;
  3828. };
  3829. #line 166
  3830. class TDblQueLink : public TDblQueLinkBase
  3831. {
  3832. public:
  3833. __declspec(dllexport) void Deque();
  3834. };
  3835. #line 184
  3836. class TPriQueLink : public TDblQueLink
  3837. {
  3838. public:
  3844. TInt iPriority;
  3845. };
  3846. #line 205
  3847. class TDeltaQueLink : public TDblQueLinkBase
  3848. {
  3849. public:
  3853. TInt iDelta;
  3854. };
  3855. #line 224
  3856. class TTickCountQueLink : public TDblQueLink
  3857. {
  3858. public:
  3862. TUint iTickCount;
  3863. };
  3864. #line 248
  3865. class TSglQueBase
  3866. {
  3867. public:
  3868. __declspec(dllexport) TBool IsEmpty() const;
  3869. __declspec(dllexport) void SetOffset(TInt aOffset);
  3870. __declspec(dllexport) void Reset();
  3871. protected:
  3872. __declspec(dllexport) TSglQueBase();
  3873. __declspec(dllexport) TSglQueBase(TInt aOffset);
  3874. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3875. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3876. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3877. protected:
  3881. TSglQueLink* iHead;
  3886. TSglQueLink* iLast;
  3891. TInt iOffset;
  3892. private:
  3893. TSglQueBase(const TSglQueBase& aQue);
  3894. TSglQueBase &operator=(const TSglQueBase& aQue);
  3895. friend class TSglQueIterBase;
  3896. };
  3897. #line 296
  3898. class TDblQueBase
  3899. {
  3900. public:
  3901. __declspec(dllexport) TBool IsEmpty() const;
  3902. __declspec(dllexport) void SetOffset(TInt aOffset);
  3903. __declspec(dllexport) void Reset();
  3904. protected:
  3905. __declspec(dllexport) TDblQueBase();
  3906. __declspec(dllexport) TDblQueBase(TInt aOffset);
  3907. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3908. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3909. __declspec(dllexport) void DoAddPriority(TAny* aPtr);
  3910. __declspec(dllexport) void __DbgTestEmpty() const;
  3911. protected:
  3915. TDblQueLink iHead;
  3920. TInt iOffset;
  3921. private:
  3922. TDblQueBase(const TDblQueBase& aQue);
  3923. TDblQueBase& operator=(const TDblQueBase& aQue);
  3924. friend class TDblQueIterBase;
  3925. };
  3926. #line 338
  3927. class TDeltaQueBase : public TDblQueBase
  3928. {
  3929. public:
  3930. __declspec(dllexport) TBool CountDown();
  3931. __declspec(dllexport) TBool CountDown(TInt aValue);
  3932. __declspec(dllexport) TBool FirstDelta(TInt& aValue);
  3933. __declspec(dllexport) void Reset();
  3934. protected:
  3935. __declspec(dllexport) TDeltaQueBase();
  3936. __declspec(dllexport) TDeltaQueBase(TInt aOffset);
  3937. __declspec(dllexport) void DoAddDelta(TAny* aPtr,TInt aDelta);
  3938. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3939. __declspec(dllexport) TAny* DoRemoveFirst();
  3940. protected:
  3944. TInt* iFirstDelta;
  3945. };
  3946. #line 375
  3947. template <class T>
  3948. class TSglQue : public TSglQueBase
  3949. {
  3950. public:
  3951. inline TSglQue();
  3952. inline explicit TSglQue(TInt aOffset);
  3953. inline void AddFirst(T& aRef);
  3954. inline void AddLast(T& aRef);
  3955. inline TBool IsFirst(const T* aPtr) const;
  3956. inline TBool IsLast(const T* aPtr) const;
  3957. inline T* First() const;
  3958. inline T* Last() const;
  3959. inline void Remove(T& aRef);
  3960. };
  3961. #line 407
  3962. template <class T>
  3963. class TDblQue : public TDblQueBase
  3964. {
  3965. public:
  3966. inline TDblQue();
  3967. inline explicit TDblQue(TInt aOffset);
  3968. inline void AddFirst(T& aRef);
  3969. inline void AddLast(T& aRef);
  3970. inline TBool IsHead(const T* aPtr) const;
  3971. inline TBool IsFirst(const T* aPtr) const;
  3972. inline TBool IsLast(const T* aPtr) const;
  3973. inline T* First() const;
  3974. inline T* Last() const;
  3975. };
  3976. #line 441
  3977. template <class T>
  3978. class TPriQue : public TDblQueBase
  3979. {
  3980. public:
  3981. inline TPriQue();
  3982. inline explicit TPriQue(TInt aOffset);
  3983. inline void Add(T& aRef);
  3984. inline TBool IsHead(const T* aPtr) const;
  3985. inline TBool IsFirst(const T* aPtr) const;
  3986. inline TBool IsLast(const T* aPtr) const;
  3987. inline T* First() const;
  3988. inline T* Last() const;
  3989. };
  3990. #line 487
  3991. template <class T>
  3992. class TDeltaQue : public TDeltaQueBase
  3993. {
  3994. public:
  3995. inline TDeltaQue();
  3996. inline explicit TDeltaQue(TInt aOffset);
  3997. inline void Add(T& aRef,TInt aDelta);
  3998. inline void Remove(T& aRef);
  3999. inline T* RemoveFirst();
  4000. };
  4006. class TTickCountQueLink;
  4007. #line 520
  4008. class TTickCountQue : public TDblQueBase
  4009. {
  4010. public:
  4011. TTickCountQue();
  4012. void Add(TTickCountQueLink& aRef);
  4013. TTickCountQueLink* First() const;
  4014. TTickCountQueLink* RemoveFirst();
  4015. TTickCountQueLink* RemoveFirst(TUint aTickCount);
  4016. };
  4017. #line 543
  4018. class TSglQueIterBase
  4019. {
  4020. public:
  4021. __declspec(dllexport) void SetToFirst();
  4022. protected:
  4023. __declspec(dllexport) TSglQueIterBase(TSglQueBase& aQue);
  4024. __declspec(dllexport) TAny* DoPostInc();
  4025. __declspec(dllexport) TAny* DoCurrent();
  4026. __declspec(dllexport) void DoSet(TAny* aLink);
  4027. protected:
  4028. TInt iOffset;
  4029. TSglQueLink* iHead;
  4030. TSglQueLink* iNext;
  4031. };
  4032. #line 571
  4033. template <class T>
  4034. class TSglQueIter : public TSglQueIterBase
  4035. {
  4036. public:
  4037. inline TSglQueIter(TSglQueBase& aQue);
  4038. inline void Set(T& aLink);
  4039. inline operator T*();
  4040. inline T* operator++(TInt);
  4041. };
  4042. #line 594
  4043. class TDblQueIterBase
  4044. {
  4045. public:
  4046. __declspec(dllexport) void SetToFirst();
  4047. __declspec(dllexport) void SetToLast();
  4048. protected:
  4049. __declspec(dllexport) TDblQueIterBase(TDblQueBase& aQue);
  4050. __declspec(dllexport) TAny* DoPostInc();
  4051. __declspec(dllexport) TAny* DoPostDec();
  4052. __declspec(dllexport) TAny* DoCurrent();
  4053. __declspec(dllexport) void DoSet(TAny* aLink);
  4054. protected:
  4058. TInt iOffset;
  4063. TDblQueLinkBase* iHead;
  4068. TDblQueLinkBase* iNext;
  4069. };
  4070. #line 635
  4071. template <class T>
  4072. class TDblQueIter : public TDblQueIterBase
  4073. {
  4074. public:
  4075. inline TDblQueIter(TDblQueBase& aQue);
  4076. inline void Set(T& aLink);
  4077. inline operator T*();
  4078. inline T* operator++(TInt);
  4079. inline T* operator--(TInt);
  4080. };
  4081. #line 660
  4082. enum TKeyCmpText
  4083. {
  4091. ECmpNormal,
  4092. #line 682
  4093. ECmpNormal8,
  4094. #line 696
  4095. ECmpNormal16,
  4096. #line 706
  4097. ECmpFolded,
  4098. #line 717
  4099. ECmpFolded8,
  4100. #line 728
  4101. ECmpFolded16,
  4102. #line 738
  4103. ECmpCollated,
  4104. #line 749
  4105. ECmpCollated8,
  4106. #line 761
  4107. ECmpCollated16
  4108. };
  4109. #line 777
  4110. enum TKeyCmpNumeric
  4111. {
  4115. ECmpTInt8=((ECmpCollated16+1)<<1),
  4121. ECmpTInt16,
  4127. ECmpTInt32,
  4133. ECmpTInt,
  4139. ECmpTUint8,
  4145. ECmpTUint16,
  4151. ECmpTUint32,
  4157. ECmpTUint,
  4163. ECmpTInt64
  4164. };
  4165. #line 856
  4166. class TKey
  4167. {
  4168. public:
  4169. inline void SetPtr(const TAny* aPtr);
  4170. __declspec(dllexport) virtual TInt Compare(TInt aLeft,TInt aRight) const;
  4171. __declspec(dllexport) virtual TAny* At(TInt anIndex) const;
  4172. protected:
  4173. __declspec(dllexport) TKey();
  4174. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType);
  4175. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
  4176. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpNumeric aType);
  4177. protected:
  4178. TInt iKeyOffset;
  4179. TInt iKeyLength;
  4180. TInt iCmpType;
  4181. const TAny* iPtr;
  4182. };
  4183. #line 890
  4184. class TSwap
  4185. {
  4186. public:
  4187. __declspec(dllexport) TSwap();
  4188. __declspec(dllexport) virtual void Swap(TInt aLeft,TInt aRight) const;
  4189. };
  4190. #line 918
  4191. class TCharF : public TChar
  4192. {
  4193. public:
  4194. inline TCharF(TUint aChar);
  4195. inline TCharF(const TChar& aChar);
  4196. inline TCharF& operator=(TUint aChar);
  4197. inline TCharF& operator=(const TChar& aChar);
  4198. };
  4199. #line 937
  4200. class TCharLC : public TChar
  4201. {
  4202. public:
  4203. inline TCharLC(TUint aChar);
  4204. inline TCharLC(const TChar& aChar);
  4205. inline TCharLC& operator=(TUint aChar);
  4206. inline TCharLC& operator=(const TChar& aChar);
  4207. };
  4208. #line 956
  4209. class TCharUC : public TChar
  4210. {
  4211. public:
  4212. inline TCharUC(TUint aChar);
  4213. inline TCharUC(const TChar& aChar);
  4214. inline TCharUC& operator=(TUint aChar);
  4215. inline TCharUC& operator=(const TChar& aChar);
  4216. };
  4217. #line 982
  4218. class TRealFormat
  4219. {
  4220. public:
  4221. __declspec(dllexport) TRealFormat();
  4222. __declspec(dllexport) TRealFormat(TInt aWidth);
  4223. __declspec(dllexport) TRealFormat(TInt aWidth,TInt aDecimalPlaces);
  4224. public:
  4225. #line 1007
  4226. TInt iType;
  4232. TInt iWidth;
  4233. #line 1025
  4234. TInt iPlaces;
  4235. #line 1038
  4236. TChar iPoint;
  4237. #line 1051
  4238. TChar iTriad;
  4239. #line 1071
  4240. TInt iTriLen;
  4241. };
  4242. #line 1089
  4243. class TLexMark8
  4244. {
  4245. public:
  4246. inline TLexMark8();
  4247. private:
  4248. inline TLexMark8(const TUint8* aString);
  4249. const TUint8* iPtr;
  4250. friend class TLex8;
  4251. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4252. };
  4257. class TRealX;
  4258. #line 1123
  4259. class TLex8
  4260. {
  4261. public:
  4262. __declspec(dllexport) TLex8();
  4263. inline TLex8(const TUint8* aString);
  4264. inline TLex8(const TDesC8& aDes);
  4265. inline TLex8& operator=(const TUint8* aString);
  4266. inline TLex8& operator=(const TDesC8& aDes);
  4267. inline TBool Eos() const;
  4268. inline void Mark(TLexMark8& aMark) const;
  4269. inline void Mark();
  4270. __declspec(dllexport) void Inc();
  4271. __declspec(dllexport) void Inc(TInt aNumber);
  4272. __declspec(dllexport) TChar Get();
  4273. __declspec(dllexport) TChar Peek() const;
  4274. __declspec(dllexport) void UnGet();
  4275. inline void UnGetToMark();
  4276. __declspec(dllexport) void UnGetToMark(const TLexMark8 aMark);
  4277. __declspec(dllexport) void SkipSpace();
  4278. inline void SkipAndMark(TInt aNumber);
  4279. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark8& aMark);
  4280. inline void SkipSpaceAndMark();
  4281. __declspec(dllexport) void SkipSpaceAndMark(TLexMark8& aMark);
  4282. __declspec(dllexport) void SkipCharacters();
  4283. inline TInt TokenLength() const;
  4284. __declspec(dllexport) TInt TokenLength(const TLexMark8 aMark) const;
  4285. __declspec(dllexport) TPtrC8 MarkedToken() const;
  4286. __declspec(dllexport) TPtrC8 MarkedToken(const TLexMark8 aMark) const;
  4287. __declspec(dllexport) TPtrC8 NextToken();
  4288. __declspec(dllexport) TPtrC8 Remainder() const;
  4289. __declspec(dllexport) TPtrC8 RemainderFromMark() const;
  4290. __declspec(dllexport) TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
  4291. __declspec(dllexport) TInt Offset() const;
  4292. inline TInt MarkedOffset() const;
  4293. __declspec(dllexport) TInt MarkedOffset(const TLexMark8 aMark) const;
  4294. __declspec(dllexport) TInt Val(TInt8& aVal);
  4295. __declspec(dllexport) TInt Val(TInt16& aVal);
  4296. __declspec(dllexport) TInt Val(TInt32& aVal);
  4297. __declspec(dllexport) TInt Val(TInt64& aVal);
  4298. inline TInt Val(TInt& aVal);
  4299. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4300. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4301. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4302. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4303. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4304. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4305. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4306. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4307. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4308. __declspec(dllexport) TInt Val(TReal32& aVal);
  4309. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4310. __declspec(dllexport) TInt Val(TReal64& aVal);
  4311. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4312. inline void Assign(const TLex8& aLex);
  4313. __declspec(dllexport) void Assign(const TUint8* aString);
  4314. __declspec(dllexport) void Assign(const TDesC8& aDes);
  4315. TInt Val(TRealX& aVal);
  4316. TInt Val(TRealX& aVal, TChar aPoint);
  4319. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4322. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4325. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4328. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4329. private:
  4330. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4331. void ScndigAfterPoint(TInt& aSig,TInt64& aDl);
  4332. void ValidateMark(const TLexMark8 aMark) const;
  4333. private:
  4334. const TUint8* iNext;
  4335. const TUint8* iBuf;
  4336. const TUint8* iEnd;
  4337. TLexMark8 iMark;
  4338. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4339. };
  4340. #line 1220
  4341. class TLexMark16
  4342. {
  4343. public:
  4344. inline TLexMark16();
  4345. private:
  4346. inline TLexMark16(const TUint16* aString);
  4347. const TUint16* iPtr;
  4348. friend class TLex16;
  4349. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4350. };
  4351. #line 1253
  4352. class TLex16
  4353. {
  4354. public:
  4355. __declspec(dllexport) TLex16();
  4356. inline TLex16(const TUint16* aString);
  4357. inline TLex16(const TDesC16& aDes);
  4358. inline TLex16& operator=(const TUint16* aString);
  4359. inline TLex16& operator=(const TDesC16& aDes);
  4360. inline TBool Eos() const;
  4361. inline void Mark();
  4362. inline void Mark(TLexMark16& aMark) const;
  4363. __declspec(dllexport) void Inc();
  4364. __declspec(dllexport) void Inc(TInt aNumber);
  4365. __declspec(dllexport) TChar Get();
  4366. __declspec(dllexport) TChar Peek() const;
  4367. __declspec(dllexport) void UnGet();
  4368. inline void UnGetToMark();
  4369. __declspec(dllexport) void UnGetToMark(const TLexMark16 aMark);
  4370. __declspec(dllexport) void SkipSpace();
  4371. inline void SkipAndMark(TInt aNumber);
  4372. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark16& aMark);
  4373. __declspec(dllexport) void SkipSpaceAndMark(TLexMark16& aMark);
  4374. inline void SkipSpaceAndMark();
  4375. __declspec(dllexport) void SkipCharacters();
  4376. inline TInt TokenLength() const;
  4377. __declspec(dllexport) TInt TokenLength(const TLexMark16 aMark) const;
  4378. __declspec(dllexport) TPtrC16 MarkedToken() const;
  4379. __declspec(dllexport) TPtrC16 MarkedToken(const TLexMark16 aMark) const;
  4380. __declspec(dllexport) TPtrC16 NextToken();
  4381. __declspec(dllexport) TPtrC16 Remainder() const;
  4382. __declspec(dllexport) TPtrC16 RemainderFromMark() const;
  4383. __declspec(dllexport) TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
  4384. __declspec(dllexport) TInt Offset() const;
  4385. inline TInt MarkedOffset() const;
  4386. __declspec(dllexport) TInt MarkedOffset(const TLexMark16 aMark) const;
  4387. __declspec(dllexport) TInt Val(TInt8& aVal);
  4388. __declspec(dllexport) TInt Val(TInt16& aVal);
  4389. __declspec(dllexport) TInt Val(TInt32& aVal);
  4390. __declspec(dllexport) TInt Val(TInt64& aVal);
  4391. inline TInt Val(TInt& aVal);
  4392. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4393. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4394. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4395. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4397. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4398. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4399. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4400. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4401. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4402. __declspec(dllexport) TInt Val(TReal32& aVal);
  4403. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4404. __declspec(dllexport) TInt Val(TReal64& aVal);
  4405. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4406. inline void Assign(const TLex16& aLex);
  4407. __declspec(dllexport) void Assign(const TUint16* aString);
  4408. __declspec(dllexport) void Assign(const TDesC16& aDes);
  4409. TInt Val(TRealX& aVal);
  4410. TInt Val(TRealX& aVal, TChar aPoint);
  4413. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4416. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4419. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4422. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4423. private:
  4424. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4425. void ValidateMark(const TLexMark16 aMark) const;
  4426. private:
  4427. const TUint16* iNext;
  4428. const TUint16* iBuf;
  4429. const TUint16* iEnd;
  4430. TLexMark16 iMark;
  4431. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4432. };
  4433. #line 1355
  4434. typedef TLex16 TLex;
  4435. #line 1373
  4436. typedef TLexMark16 TLexMark;
  4437. #line 1430
  4438. class TCheckedUid
  4439. {
  4440. public:
  4441. __declspec(dllexport) TCheckedUid();
  4442. __declspec(dllexport) TCheckedUid(const TUidType& aUidType);
  4443. __declspec(dllexport) TCheckedUid(const TDesC8& aPtr);
  4444. __declspec(dllexport) void Set(const TUidType& aUidType);
  4445. __declspec(dllexport) void Set(const TDesC8& aPtr);
  4446. __declspec(dllexport) TPtrC8 Des() const;
  4447. inline const TUidType& UidType() const;
  4448. protected:
  4449. __declspec(dllexport) TUint Check() const;
  4450. private:
  4451. TUidType iType;
  4452. TUint iCheck;
  4453. };
  4454. #line 1469
  4455. class TDateTime
  4456. {
  4457. public:
  4458. inline TDateTime();
  4459. __declspec(dllexport) TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4460. __declspec(dllexport) TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4461. __declspec(dllexport) TInt SetYear(TInt aYear);
  4462. __declspec(dllexport) TInt SetYearLeapCheck(TInt aYear);
  4463. __declspec(dllexport) TInt SetMonth(TMonth aMonth);
  4464. __declspec(dllexport) TInt SetDay(TInt aDay);
  4465. __declspec(dllexport) TInt SetHour(TInt aHour);
  4466. __declspec(dllexport) TInt SetMinute(TInt aMinute);
  4467. __declspec(dllexport) TInt SetSecond(TInt aSecond);
  4468. __declspec(dllexport) TInt SetMicroSecond(TInt aMicroSecond);
  4469. inline TInt Year() const;
  4470. inline TMonth Month() const;
  4471. inline TInt Day() const;
  4472. inline TInt Hour() const;
  4473. inline TInt Minute() const;
  4474. inline TInt Second() const;
  4475. inline TInt MicroSecond() const;
  4476. private:
  4477. TInt iYear;
  4478. TMonth iMonth;
  4479. TInt iDay;
  4480. TInt iHour;
  4481. TInt iMinute;
  4482. TInt iSecond;
  4483. TInt iMicroSecond;
  4484. };
  4485. #line 1516
  4486. class TTimeIntervalMicroSeconds
  4487. {
  4488. public:
  4489. inline TTimeIntervalMicroSeconds();
  4490. inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
  4491. inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
  4492. inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
  4493. inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
  4494. inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
  4495. inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
  4496. inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
  4497. inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
  4498. inline const TInt64& Int64() const;
  4499. private:
  4500. TInt64 iInterval;
  4501. };
  4502. #line 1554
  4503. class TTimeIntervalBase
  4504. {
  4505. public:
  4506. inline TBool operator==(TTimeIntervalBase aInterval) const;
  4507. inline TBool operator!=(TTimeIntervalBase aInterval) const;
  4508. inline TBool operator>=(TTimeIntervalBase aInterval) const;
  4509. inline TBool operator<=(TTimeIntervalBase aInterval) const;
  4510. inline TBool operator>(TTimeIntervalBase aInterval) const;
  4511. inline TBool operator<(TTimeIntervalBase aInterval) const;
  4512. inline TInt Int() const;
  4513. protected:
  4514. inline TTimeIntervalBase();
  4515. inline TTimeIntervalBase(TInt aInterval);
  4516. protected:
  4517. TInt iInterval;
  4518. };
  4519. #line 1583
  4520. class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
  4521. {
  4522. public:
  4523. inline TTimeIntervalMicroSeconds32();
  4524. inline TTimeIntervalMicroSeconds32(TInt aInterval);
  4525. inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
  4526. };
  4527. #line 1606
  4528. class TTimeIntervalSeconds : public TTimeIntervalBase
  4529. {
  4530. public:
  4531. inline TTimeIntervalSeconds();
  4532. inline TTimeIntervalSeconds(TInt aInterval);
  4533. inline TTimeIntervalSeconds& operator=(TInt aInterval);
  4534. };
  4535. #line 1626
  4536. class TTimeIntervalMinutes : public TTimeIntervalBase
  4537. {
  4538. public:
  4539. inline TTimeIntervalMinutes();
  4540. inline TTimeIntervalMinutes(TInt aInterval);
  4541. inline TTimeIntervalMinutes& operator=(TInt aInterval);
  4542. };
  4543. #line 1646
  4544. class TTimeIntervalHours : public TTimeIntervalBase
  4545. {
  4546. public:
  4547. inline TTimeIntervalHours();
  4548. inline TTimeIntervalHours(TInt aInterval);
  4549. inline TTimeIntervalHours& operator=(TInt aInterval);
  4550. };
  4551. #line 1666
  4552. class TTimeIntervalDays : public TTimeIntervalBase
  4553. {
  4554. public:
  4555. inline TTimeIntervalDays();
  4556. inline TTimeIntervalDays(TInt aInterval);
  4557. inline TTimeIntervalDays& operator=(TInt aInterval);
  4558. };
  4559. #line 1686
  4560. class TTimeIntervalMonths : public TTimeIntervalBase
  4561. {
  4562. public:
  4563. inline TTimeIntervalMonths();
  4564. inline TTimeIntervalMonths(TInt aInterval);
  4565. inline TTimeIntervalMonths& operator=(TInt aInterval);
  4566. };
  4567. #line 1706
  4568. class TTimeIntervalYears : public TTimeIntervalBase
  4569. {
  4570. public:
  4571. inline TTimeIntervalYears();