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

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

Symbian

开发平台：

C/C++

S60UIExamplePlayView.inc：源码内容
  1. inline void AppendL(TInt anEntry);
  2. inline void InsertL(TInt anEntry, TInt aPos);
  3. inline TInt FindL(TInt anEntry) const;
  4. inline TInt FindInOrderL(TInt anEntry) const;
  5. inline void FindInOrderL(TInt anEntry, TInt& anIndex) const;
  6. inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const;
  7. inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const;
  8. inline void InsertInOrderL(TInt anEntry);
  9. inline void InsertInOrderAllowRepeatsL(TInt anEntry);
  11. inline RArray(TInt* aEntries, TInt aCount);
  12. inline void GranularCompress();
  13. inline TInt Reserve(TInt aCount);
  14. inline void ReserveL(TInt aCount);
  15. inline void Sort();
  16. inline TArray<TInt> Array() const;
  18. };
  19. #line 5387
  20. template<> class RArray<TUint> : private RPointerArrayBase
  21. {
  22. public:
  23. inline RArray();
  24. inline explicit RArray(TInt aGranularity);
  25. inline RArray(TInt aMinGrowBy, TInt aFactor);
  26. inline void Close();
  27. inline TInt Count() const;
  28. inline const TUint& operator[](TInt anIndex) const;
  29. inline TUint& operator[](TInt anIndex);
  30. inline TInt Append(TUint anEntry);
  31. inline TInt Insert(TUint anEntry, TInt aPos);
  32. inline void Remove(TInt anIndex);
  33. inline void Compress();
  34. inline void Reset();
  35. inline TInt Find(TUint anEntry) const;
  36. inline TInt FindInOrder(TUint anEntry) const;
  37. inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const;
  38. inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const;
  39. inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const;
  40. inline TInt InsertInOrder(TUint anEntry);
  41. inline TInt InsertInOrderAllowRepeats(TUint anEntry);
  43. inline void AppendL(TUint anEntry);
  44. inline void InsertL(TUint anEntry, TInt aPos);
  45. inline TInt FindL(TUint anEntry) const;
  46. inline TInt FindInOrderL(TUint anEntry) const;
  47. inline void FindInOrderL(TUint anEntry, TInt& anIndex) const;
  48. inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const;
  49. inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const;
  50. inline void InsertInOrderL(TUint anEntry);
  51. inline void InsertInOrderAllowRepeatsL(TUint anEntry);
  53. inline RArray(TUint* aEntries, TInt aCount);
  54. inline void GranularCompress();
  55. inline TInt Reserve(TInt aCount);
  56. inline void ReserveL(TInt aCount);
  57. inline void Sort();
  58. inline TArray<TUint> Array() const;
  60. };
  61. #line 5822
  62. extern TAny* operator new(TUint aSize) throw() ;
  68. extern TAny* operator new(TUint aSize,TUint anExtraSize) throw() ;
  74. extern void operator delete(TAny* aPtr) throw() ;
  81. extern TAny* operator new[](TUint aSize) throw() ;
  87. extern void operator delete[](TAny* aPtr) throw() ;
  94. inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
  101. inline TAny* operator new[](TUint aSize, TAny* aBase) throw() ;
  109. inline void operator delete(TAny* aPtr, TAny* aBase) throw() ;
  116. inline void operator delete[](TAny* aPtr, TAny* aBase) throw() ;
  117. #line 5886
  118. TBool operator==(TTrue,volatile const TBool);
  124. TBool operator==(volatile const TBool,TTrue);
  130. TBool operator!=(TTrue,volatile const TBool);
  136. TBool operator!=(volatile const TBool,TTrue);
  137. #line 5928
  138. class TIpcArgs
  139. {
  140. public:
  147. enum TArgType
  148. {
  149. EUnspecified = 0,
  150. EHandle = 1,
  151. EFlagDes = 4,
  152. EFlagConst = 2,
  153. EFlag16Bit = 1,
  154. EDes8 = EFlagDes,
  155. EDes16 = EFlagDes|EFlag16Bit,
  156. EDesC8 = EFlagDes|EFlagConst,
  157. EDesC16 = EFlagDes|EFlagConst|EFlag16Bit,
  158. };
  166. enum {
  167.      KBitsPerType=3
  168.      };
  174. enum TNothing {
  175. #line 5976
  176.               ENothing
  177.               };
  178. public:
  186. inline TIpcArgs()
  187. :iFlags(0)
  188. {}
  189. #line 5998
  190. template <class T0>
  191. inline explicit TIpcArgs(T0 a0)
  192. {
  193. Assign(iArgs[0],a0);
  194. iFlags=(Type(a0)<<(0*KBitsPerType));
  195. }
  196. #line 6015
  197. template <class T0,class T1>
  198. inline TIpcArgs(T0 a0,T1 a1)
  199. {
  200. Assign(iArgs[0],a0);
  201. Assign(iArgs[1],a1);
  202. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType));
  203. }
  204. #line 6035
  205. template <class T0,class T1,class T2>
  206. inline TIpcArgs(T0 a0,T1 a1,T2 a2)
  207. {
  208. Assign(iArgs[0],a0);
  209. Assign(iArgs[1],a1);
  210. Assign(iArgs[2],a2);
  211. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType));
  212. }
  213. #line 6058
  214. template <class T0,class T1,class T2,class T3>
  215. inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3)
  216. {
  217. Assign(iArgs[0],a0);
  218. Assign(iArgs[1],a1);
  219. Assign(iArgs[2],a2);
  220. Assign(iArgs[3],a3);
  221. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType))|(Type(a3)<<(3*KBitsPerType));
  222. }
  224. inline void Set(TInt aIndex,TNothing);
  225. inline void Set(TInt aIndex,TInt aValue);
  226. inline void Set(TInt aIndex,const TAny* aValue);
  227. inline void Set(TInt aIndex,RHandleBase aValue);
  228. inline void Set(TInt aIndex,const TDesC8* aValue);
  230. inline void Set(TInt aIndex,const TDesC16* aValue);
  232. inline void Set(TInt aIndex,TDes8* aValue);
  234. inline void Set(TInt aIndex,TDes16* aValue);
  236. private:
  237. inline static TArgType Type(TNothing);
  238. inline static TArgType Type(TInt);
  239. inline static TArgType Type(const TAny*);
  240. inline static TArgType Type(RHandleBase aValue);
  241. inline static TArgType Type(const TDesC8*);
  243. inline static TArgType Type(const TDesC16*);
  245. inline static TArgType Type(TDes8*);
  247. inline static TArgType Type(TDes16*);
  250. inline static void Assign(TInt&,TNothing);
  251. inline static void Assign(TInt& aArg,TInt aValue);
  252. inline static void Assign(TInt& aArg,const TAny* aValue);
  253. inline static void Assign(TInt& aArg,RHandleBase aValue);
  254. inline static void Assign(TInt& aArg,const TDesC8* aValue);
  256. inline static void Assign(TInt& aArg,const TDesC16* aValue);
  258. inline static void Assign(TInt& aArg,TDes8* aValue);
  260. inline static void Assign(TInt& aArg,TDes16* aValue);
  262. public:
  270. TInt iArgs[KMaxMessageArguments];
  271. #line 6123
  272. TInt iFlags;
  273. };
  280. struct SInt64
  281. {
  282. public:
  283. inline SInt64();
  284. inline SInt64(Int64 a);
  285. inline SInt64& operator=(Int64 a);
  286. inline operator Int64() const;
  287. public:
  288. TUint32 iData[2];
  289. };
  294. struct SUint64
  295. {
  296. public:
  297. inline SUint64();
  298. inline SUint64(Uint64 a);
  299. inline SUint64& operator=(Uint64 a);
  300. inline operator Uint64() const;
  301. public:
  302. TUint32 iData[2];
  303. };
  308. struct SDouble
  309. {
  310. public:
  311. inline SDouble();
  312. inline SDouble(TReal a);
  313. inline SDouble& operator=(TReal a);
  314. inline operator TReal() const;
  315. public:
  316. TUint32 iData[2];
  317. };
  318. #line 6181
  319. class TThreadStackInfo
  320. {
  321. public:
  325. TLinAddr iBase;
  331. TLinAddr iLimit;
  338. TLinAddr iExpandLimit;
  339. };
  340. #line 6214
  341. class XLeaveException
  342. {
  343. public:
  344. inline XLeaveException() {}
  345. inline XLeaveException(TInt aReason) {iR = aReason;}
  346. inline TInt Reason() const {return iR;}
  347. __declspec(dllexport) TInt GetReason() const;
  348. private:
  349. #line 6230
  350. private:
  352. TAny* iVtable;
  354. TInt iR;
  355. };
  362. namespace std {
  363.   bool uncaught_exception(void);
  364.   void terminate(void);
  365.   void unexpected(void);
  366.   typedef void (*terminate_handler)();
  367.   terminate_handler set_terminate(terminate_handler h) throw();
  368.   typedef void (*unexpected_handler)();
  369.   unexpected_handler set_unexpected(unexpected_handler h) throw();
  370. }
  378. class __UnknownWindowsType1;
  379. class __UnknownWindowsType2;
  382. class TWin32SEHTrap;
  388. typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  393. class TWin32SEHTrap
  394. {
  395. private:
  397.     TWin32SEHTrap(TWin32SEHTrap const &);
  398.     TWin32SEHTrap& operator=(TWin32SEHTrap const &);
  399. #line 6297
  400. public:
  401. __declspec(dllexport) TWin32SEHTrap();
  403. public:
  405. __declspec(dllexport) void Trap();
  408. __declspec(dllexport) void UnTrap();
  411. private:
  414. static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  421.     TWin32SEHTrap* iPrevExceptionRegistrationRecord;
  422. TWin32SEHExceptionHandler* iExceptionHandler;
  424. private:
  425. TUint32 iPadding[254];
  426. };
  427. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.inl" /* stack depth 6 */
  428. #line 9
  429. inline TAny* operator new(TUint , TAny* aBase) throw()
  430. {return aBase;}
  433. inline void operator delete(TAny* , TAny* ) throw()
  434. {}
  440. inline TAny* operator new[](TUint , TAny* aBase) throw()
  441. {return aBase;}
  444. inline void operator delete[](TAny* , TAny* ) throw()
  445. {}
  450. inline RAllocator::RAllocator()
  451. {
  452. iAccessCount=1;
  453. iHandleCount=0;
  454. iHandles=0;
  455. iFlags=0;
  456. iCellCount=0;
  457. iTotalAllocSize=0;
  458. }
  459. inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)
  460. {__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}
  463. inline RHeap::RHeap()
  464. {}
  469. inline TInt RHeap::MaxLength() const
  473. {return iMaxLength;}
  476. inline void RHeap::operator delete(TAny*, TAny*)
  481. {}
  484. inline TUint8* RHeap::Base() const
  485. #line 73
  486. {return iBase;}
  491. inline TInt RHeap::Size() const
  492. #line 89
  493. {return iTop-iBase;}
  498. inline TInt RHeap::Align(TInt a) const
  502. {return (((a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  507. inline const TAny* RHeap::Align(const TAny* a) const
  511. {return (const TAny*)((((TLinAddr)a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  516. inline TBool RHeap::IsLastCell(const SCell* aCell) const
  520. {return (((TUint8*)aCell) + aCell->len) == iTop;}
  526. inline void RHeap::Lock() const
  530. {((RFastLock&)iLock).Wait();}
  535. inline void RHeap::Unlock() const
  539. {((RFastLock&)iLock).Signal();}
  546. template <class T>
  547. inline TRefByValue<T>::TRefByValue(T &aRef)
  548. : iRef(aRef)
  554. {}
  559. template <class T>
  560. inline TRefByValue<T>::operator T &()
  564. {return(iRef);}
  565. #line 201
  566. inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)
  567. { return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }
  573. inline TChar::TChar()
  579. {}
  584. inline TChar::TChar(TUint aChar)
  585. : iChar(aChar)
  591. {}
  596. inline TChar& TChar::operator-=(TUint aChar)
  597. #line 241
  598. {iChar-=aChar;return(*this);}
  603. inline TChar& TChar::operator+=(TUint aChar)
  604. #line 256
  605. {iChar+=aChar;return(*this);}
  610. inline TChar TChar::operator-(TUint aChar)
  611. #line 273
  612. {return(iChar-aChar);}
  617. inline TChar TChar::operator+(TUint aChar)
  618. #line 288
  619. {return(iChar+aChar);}
  624. inline TChar::operator TUint() const
  631. {return(iChar);}
  637. inline TBool TDesC8::operator<(const TDesC8 &aDes) const
  638. #line 320
  639. {return(Compare(aDes)<0);}
  644. inline TBool TDesC8::operator<=(const TDesC8 &aDes) const
  645. #line 339
  646. {return(Compare(aDes)<=0);}
  651. inline TBool TDesC8::operator>(const TDesC8 &aDes) const
  652. #line 358
  653. {return(Compare(aDes)>0);}
  658. inline TBool TDesC8::operator>=(const TDesC8 &aDes) const
  659. #line 377
  660. {return(Compare(aDes)>=0);}
  665. inline TBool TDesC8::operator==(const TDesC8 &aDes) const
  666. #line 396
  667. {return(Compare(aDes)==0);}
  672. inline TBool TDesC8::operator!=(const TDesC8 &aDes) const
  673. #line 415
  674. {return(Compare(aDes)!=0);}
  679. inline const TUint8 &TDesC8::operator[](TInt anIndex) const
  680. #line 433
  681. {return(AtC(anIndex));}
  686. inline TInt TDesC8::Length() const
  694. {return(iLength&KMaskDesLength8);}
  699. inline TInt TDesC8::Size() const
  707. {return(Length());}
  712. inline void TDesC8::DoSetLength(TInt aLength)
  713. {iLength=(iLength&(~KMaskDesLength8))|aLength;}
  719. inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)
  720. #line 483
  721. {new(this) TPtrC8(aBuf,aLength);}
  726. inline void TPtrC8::Set(const TDesC8 &aDes)
  734. {new(this) TPtrC8(aDes);}
  739. inline void TPtrC8::Set(const TPtrC8& aPtr)
  740. #line 510
  741. {new(this) TPtrC8(aPtr);}
  748. inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)
  749. {return TPtr8(*this,aMaxLength);}
  755. template <TInt S>
  756. inline TBufC8<S>::TBufC8()
  757. : TBufCBase8()
  758. #line 540
  759. {}
  764. template <TInt S>
  765. inline TBufC8<S>::TBufC8(const TUint8 *aString)
  766. : TBufCBase8(aString,S)
  767. #line 564
  768. {}
  773. template <TInt S>
  774. inline TBufC8<S>::TBufC8(const TDesC8 &aDes)
  775. : TBufCBase8(aDes,S)
  776. #line 588
  777. {}
  782. template <TInt S>
  783. inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)
  784. #line 607
  785. {Copy(aString,S);return(*this);}
  790. template <TInt S>
  791. inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)
  792. #line 626
  793. {Copy(aDes,S);return(*this);}
  798. template <TInt S>
  799. inline TPtr8 TBufC8<S>::Des()
  800. #line 656
  801. {return DoDes(S);}
  808. inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)
  809. #line 681
  810. {return *this=static_cast<const TDesC8&>(aLcb);}
  811. #line 710
  812. inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)
  813. {
  814. Assign(HBufC8::NewL(aStream,aMaxLength));
  815. }
  822. inline TDes8 &TDes8::operator=(const TUint8 *aString)
  823. #line 733
  824.     {Copy(aString);return(*this);}
  829. inline TDes8 &TDes8::operator=(const TDesC8 &aDes)
  830. #line 751
  831.     {Copy(aDes);return(*this);}
  836. inline TDes8 &TDes8::operator=(const TDes8 &aDes)
  837. #line 769
  838.     {Copy(aDes);return(*this);}
  843. inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)
  844. #line 788
  845. {Append(aDes);return(*this);}
  850. inline const TUint8 &TDes8::operator[](TInt anIndex) const
  851. #line 806
  852. {return(AtC(anIndex));}
  857. inline TUint8 &TDes8::operator[](TInt anIndex)
  858. #line 825
  859. {return((TUint8 &)AtC(anIndex));}
  864. inline TInt TDes8::MaxLength() const
  865. #line 839
  866. {return(iMaxLength);}
  871. inline TInt TDes8::MaxSize() const
  872. #line 853
  873. {return(iMaxLength);}
  878. inline TUint8 * TDes8::WPtr() const
  879. {return((TUint8 *)Ptr());}
  885. inline TPtr8 &TPtr8::operator=(const TUint8 *aString)
  886. #line 879
  887. {Copy(aString);return(*this);}
  892. inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)
  893. #line 899
  894. {Copy(aDes);return(*this);}
  899. inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)
  900. #line 919
  901. {Copy(aDes);return(*this);}
  906. inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)
  907. #line 940
  908. {new(this) TPtr8(aBuf,aLength,aMaxLength);}
  913. inline void TPtr8::Set(const TPtr8 &aPtr)
  914. #line 955
  915. {new(this) TPtr8(aPtr);}
  921. template <TInt S>
  922. inline TBuf8<S>::TBuf8()
  923. : TBufBase8(S)
  924. #line 972
  925. {}
  930. template <TInt S>
  931. inline TBuf8<S>::TBuf8(TInt aLength)
  932. : TBufBase8(aLength,S)
  933. #line 994
  934. {}
  939. template <TInt S>
  940. inline TBuf8<S>::TBuf8(const TUint8 *aString)
  941. : TBufBase8(aString,S)
  942. #line 1018
  943. {}
  948. template <TInt S>
  949. inline TBuf8<S>::TBuf8(const TDesC8 &aDes)
  950. : TBufBase8(aDes,S)
  951. #line 1042
  952. {}
  957. template <TInt S>
  958. inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)
  959. #line 1062
  960. {Copy(aString);return(*this);}
  965. template <TInt S>
  966. inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)
  967. #line 1082
  968. {Copy(aDes);return(*this);}
  973. template <TInt S>
  974. inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)
  975. #line 1100
  976. {Copy(aBuf);return *this;}
  982. template <TInt S>
  983. inline TAlignedBuf8<S>::TAlignedBuf8()
  984. : TBufBase8(S)
  985. #line 1117
  986. {}
  991. template <TInt S>
  992. inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)
  993. : TBufBase8(aLength,S)
  994. #line 1139
  995. {}
  1000. template <TInt S>
  1001. inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)
  1002. : TBufBase8(aString,S)
  1003. #line 1163
  1004. {}
  1009. template <TInt S>
  1010. inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)
  1011. : TBufBase8(aDes,S)
  1012. #line 1187
  1013. {}
  1018. template <TInt S>
  1019. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)
  1020. #line 1207
  1021. {Copy(aString);return(*this);}
  1026. template <TInt S>
  1027. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)
  1028. #line 1227
  1029. {Copy(aDes);return(*this);}
  1034. template <TInt S>
  1035. inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)
  1036. #line 1245
  1037. {Copy(aBuf);return *this;}
  1043. template <TInt S>
  1044. inline const TDesC8* TLitC8<S>::operator&() const
  1050. {return (reinterpret_cast<const TDesC8*>(this)) ;}
  1055. template <TInt S>
  1056. inline const TDesC8& TLitC8<S>::operator()() const
  1062. {return *operator&();}
  1067. template <TInt S>
  1068. inline TLitC8<S>::operator const TDesC8&() const
  1073. {return *operator&();}
  1077. template <TInt S>
  1078. inline TLitC8<S>::operator const __TRefDesC8() const
  1085. {return *operator&();}
  1092. inline TBool TDesC16::operator<(const TDesC16 &aDes) const
  1093. #line 1314
  1094. {return(Compare(aDes)<0);}
  1099. inline TBool TDesC16::operator<=(const TDesC16 &aDes) const
  1100. #line 1333
  1101. {return(Compare(aDes)<=0);}
  1106. inline TBool TDesC16::operator>(const TDesC16 &aDes) const
  1107. #line 1352
  1108. {return(Compare(aDes)>0);}
  1113. inline TBool TDesC16::operator>=(const TDesC16 &aDes) const
  1114. #line 1371
  1115. {return(Compare(aDes)>=0);}
  1120. inline TBool TDesC16::operator==(const TDesC16 &aDes) const
  1121. #line 1390
  1122. {return(Compare(aDes)==0);}
  1127. inline TBool TDesC16::operator!=(const TDesC16 &aDes) const
  1128. #line 1409
  1129. {return(Compare(aDes)!=0);}
  1134. inline const TUint16 &TDesC16::operator[](TInt anIndex) const
  1135. #line 1427
  1136. {return(AtC(anIndex));}
  1141. inline TInt TDesC16::Length() const
  1149. {return(iLength&KMaskDesLength16);}
  1154. inline TInt TDesC16::Size() const
  1155. #line 1454
  1156. {return(Length()<<1);}
  1161. inline void TDesC16::DoSetLength(TInt aLength)
  1162. {iLength=(iLength&(~KMaskDesLength16))|aLength;}
  1168. inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)
  1169. #line 1478
  1170. {new(this) TPtrC16(aBuf,aLength);}
  1175. inline void TPtrC16::Set(const TDesC16 &aDes)
  1183. {new(this) TPtrC16(aDes);}
  1188. inline void TPtrC16::Set(const TPtrC16& aPtr)
  1189. {new(this) TPtrC16(aPtr);}
  1195. inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)
  1196. {return TPtr16(*this,aMaxLength);}
  1202. template <TInt S>
  1203. inline TBufC16<S>::TBufC16()
  1204. : TBufCBase16()
  1205. #line 1526
  1206. {}
  1211. template <TInt S>
  1212. inline TBufC16<S>::TBufC16(const TUint16 *aString)
  1213. : TBufCBase16(aString,S)
  1214. #line 1550
  1215. {}
  1220. template <TInt S>
  1221. inline TBufC16<S>::TBufC16(const TDesC16 &aDes)
  1222. : TBufCBase16(aDes,S)
  1223. #line 1574
  1224. {}
  1229. template <TInt S>
  1230. inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)
  1231. #line 1593
  1232. {Copy(aString,S);return(*this);}
  1237. template <TInt S>
  1238. inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)
  1239. #line 1612
  1240. {Copy(aDes,S);return(*this);}
  1245. template <TInt S>
  1246. inline TPtr16 TBufC16<S>::Des()
  1247. #line 1642
  1248. {return(DoDes(S));}
  1255. inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)
  1256. #line 1667
  1257. {return *this=static_cast<const TDesC16&>(aLcb);}
  1264. inline TDes16 &TDes16::operator=(const TUint16 *aString)
  1265. #line 1687
  1266.     {Copy(aString);return(*this);}
  1271. inline TDes16 &TDes16::operator=(const TDesC16 &aDes)
  1272. #line 1705
  1273.     {Copy(aDes);return(*this);}
  1278. inline TDes16 &TDes16::operator=(const TDes16 &aDes)
  1279. #line 1723
  1280.     {Copy(aDes);return(*this);}
  1285. inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)
  1286. #line 1742
  1287. {Append(aDes);return(*this);}
  1292. inline const TUint16 &TDes16::operator[](TInt anIndex) const
  1293. #line 1759
  1294. {return(AtC(anIndex));}
  1299. inline TUint16 &TDes16::operator[](TInt anIndex)
  1300. #line 1778
  1301. {return((TUint16 &)AtC(anIndex));}
  1306. inline TInt TDes16::MaxLength() const
  1307. #line 1792
  1308. {return(iMaxLength);}
  1313. inline TInt TDes16::MaxSize() const
  1314. #line 1806
  1315. {return(iMaxLength<<1);}
  1320. inline TUint16 * TDes16::WPtr() const
  1321. {return((TUint16 *)Ptr());}
  1327. inline TPtr16 &TPtr16::operator=(const TUint16 *aString)
  1328. #line 1832
  1329. {Copy(aString);return(*this);}
  1334. inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)
  1335. #line 1852
  1336. {Copy(aDes);return(*this);}
  1341. inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)
  1342. #line 1872
  1343. {Copy(aDes);return(*this);}
  1348. inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)
  1349. #line 1893
  1350. {new(this) TPtr16(aBuf,aLength,aMaxLength);}
  1355. inline void TPtr16::Set(const TPtr16 &aPtr)
  1356. #line 1908
  1357. {new(this) TPtr16(aPtr);}
  1363. template <TInt S>
  1364. inline TBuf16<S>::TBuf16()
  1365. : TBufBase16(S)
  1366. #line 1925
  1367. {}
  1372. template <TInt S>
  1373. inline TBuf16<S>::TBuf16(TInt aLength)
  1374. : TBufBase16(aLength,S)
  1375. #line 1947
  1376. {}
  1381. template <TInt S>
  1382. inline TBuf16<S>::TBuf16(const TUint16 *aString)
  1383. : TBufBase16(aString,S)
  1384. #line 1971
  1385. {}
  1390. template <TInt S>
  1391. inline TBuf16<S>::TBuf16(const TDesC16 &aDes)
  1392. : TBufBase16(aDes,S)
  1393. #line 1995
  1394. {}
  1399. template <TInt S>
  1400. inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)
  1401. #line 2015
  1402. {Copy(aString);return(*this);}
  1407. template <TInt S>
  1408. inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)
  1409. #line 2035
  1410. {Copy(aDes);return(*this);}
  1415. template <TInt S>
  1416. inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)
  1417. #line 2056
  1418. {Copy(aBuf);return *this;}
  1419. #line 2083
  1420. inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)
  1421. {
  1422. Assign(HBufC16::NewL(aStream,aMaxLength));
  1423. }
  1427. template <TInt S>
  1428. inline const TDesC16* TLitC16<S>::operator&() const
  1434. {return (reinterpret_cast<const TDesC16*>(this)) ;}
  1439. template <TInt S>
  1440. inline const TDesC16& TLitC16<S>::operator()() const
  1446. {return *operator&();}
  1451. template <TInt S>
  1452. inline TLitC16<S>::operator const TDesC16&() const
  1457. {return *operator&();}
  1462. template <TInt S>
  1463. inline TLitC16<S>::operator const __TRefDesC16() const
  1470. {return *operator&();}
  1478. template <TInt S>
  1479. inline TBufC<S>::TBufC()
  1480. : TBufCBase16()
  1481. #line 2157
  1482. {}
  1487. template <TInt S>
  1488. inline TBufC<S>::TBufC(const TText *aString)
  1489. : TBufCBase16(aString,S)
  1490. #line 2186
  1491. {}
  1496. template <TInt S>
  1497. inline TBufC<S>::TBufC(const TDesC &aDes)
  1498. : TBufCBase16(aDes,S)
  1499. #line 2219
  1500. {}
  1501. #line 2234
  1502. template <TInt S>
  1503. inline TBufC<S> &TBufC<S>::operator=(const TText *aString)
  1504. #line 2253
  1505. {Copy(aString,S);return(*this);}
  1510. template <TInt S>
  1511. inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)
  1512. #line 2277
  1513. {Copy(aDes,S);return(*this);}
  1518. template <TInt S>
  1519. inline TPtr TBufC<S>::Des()
  1520. #line 2308
  1521. {return(DoDes(S));}
  1528. template <TInt S>
  1529. inline TBuf<S>::TBuf()
  1530. : TBufBase16(S)
  1538. {}
  1543. template <TInt S>
  1544. inline TBuf<S>::TBuf(TInt aLength)
  1545. : TBufBase16(aLength,S)
  1546. #line 2350
  1547. {}
  1552. template <TInt S>
  1553. inline TBuf<S>::TBuf(const TText *aString)
  1554. : TBufBase16(aString,S)
  1555. #line 2378
  1556. {}
  1561. template <TInt S>
  1562. inline TBuf<S>::TBuf(const TDesC &aDes)
  1563. : TBufBase16(aDes,S)
  1564. #line 2407
  1565. {}
  1566. #line 2426
  1567. template <TInt S>
  1568. inline TBuf<S> &TBuf<S>::operator=(const TText *aString)
  1569. {Copy(aString);return(*this);}
  1570. template <TInt S>
  1571. inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)
  1572. {Copy(aDes);return(*this);}
  1573. template <TInt S>
  1574. inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)
  1575. {Copy(aBuf);return(*this);}
  1581. template <TInt S>
  1582. inline const TDesC* TLitC<S>::operator&() const
  1588. {return (reinterpret_cast<const TDesC*>(this)) ;}
  1593. template <TInt S>
  1594. inline const TDesC& TLitC<S>::operator()() const
  1600. {return *operator&();}
  1605. template <TInt S>
  1606. inline TLitC<S>::operator const TDesC&() const
  1611. {return *operator&();}
  1616. template <TInt S>
  1617. inline TLitC<S>::operator const __TRefDesC() const
  1624. {return *operator&();}
  1630. template <class T>
  1631. inline TPckgC<T>::TPckgC(const T &aRef)
  1632. : TPtrC8((const TUint8 *)&aRef,sizeof(T))
  1640. {}
  1645. template <class T>
  1646. inline const T &TPckgC<T>::operator()() const
  1653. {return(*((const T *)iPtr));}
  1659. template <class T>
  1660. inline TPckg<T>::TPckg(const T &aRef)
  1661. : TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T))
  1669. {}
  1674. template <class T>
  1675. inline T &TPckg<T>::operator()()
  1682. {return(*((T *)iPtr));}
  1688. template <class T>
  1689. inline TPckgBuf<T>::TPckgBuf()
  1690. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1698. {new(&this->iBuf[0]) T;}
  1703. template <class T>
  1704. inline TPckgBuf<T>::TPckgBuf(const T &aRef)
  1705. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  1706. #line 2576
  1707. {new(&this->iBuf[0]) T(aRef);}
  1712. template <class T>
  1713. inline TPckgBuf<T> &TPckgBuf<T>::operator=(const TPckgBuf<T> &aRef)
  1721. {this->Copy(aRef);return(*this);}
  1726. template <class T>
  1727. inline T &TPckgBuf<T>::operator=(const T &aRef)
  1728. #line 2605
  1729. {this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));}
  1734. template <class T>
  1735. inline T &TPckgBuf<T>::operator()()
  1742. {return(*((T *)&this->iBuf[0]));}
  1747. template <class T>
  1748. inline const T &TPckgBuf<T>::operator()() const
  1755. {return(*((T *)&this->iBuf[0]));}
  1761. inline TRequestStatus::TRequestStatus()
  1765. : iFlags(0)
  1766. {}
  1771. inline TRequestStatus::TRequestStatus(TInt aVal)
  1779. : iStatus(aVal),
  1780. iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0)
  1782. {}
  1787. inline TInt TRequestStatus::operator=(TInt aVal)
  1795. {
  1796. if(aVal==KRequestPending)
  1797. iFlags|=TRequestStatus::ERequestPending;
  1798. else
  1799. iFlags&=~TRequestStatus::ERequestPending;
  1800. return (iStatus=aVal);
  1801. }
  1806. inline TBool TRequestStatus::operator==(TInt aVal) const
  1807. #line 2691
  1808. {return(iStatus==aVal);}
  1813. inline TBool TRequestStatus::operator!=(TInt aVal) const
  1814. #line 2705
  1815. {return(iStatus!=aVal);}
  1820. inline TBool TRequestStatus::operator>=(TInt aVal) const
  1821. #line 2720
  1822. {return(iStatus>=aVal);}
  1827. inline TBool TRequestStatus::operator<=(TInt aVal) const
  1828. #line 2735
  1829. {return(iStatus<=aVal);}
  1834. inline TBool TRequestStatus::operator>(TInt aVal) const
  1835. #line 2750
  1836. {return(iStatus>aVal);}
  1841. inline TBool TRequestStatus::operator<(TInt aVal) const
  1842. #line 2765
  1843. {return(iStatus<aVal);}
  1848. inline TInt TRequestStatus::Int() const
  1854. {return(iStatus);}
  1861. inline TPoint::TPoint()
  1862. : iX(0),iY(0)
  1866. {}
  1871. inline TPoint::TPoint(TInt aX,TInt aY)
  1872. : iX(aX),iY(aY)
  1879. {}
  1885. inline TSize::TSize()
  1886. : iWidth(0),iHeight(0)
  1890. {}
  1895. inline TSize::TSize(TInt aWidth,TInt aHeight)
  1896. : iWidth(aWidth),iHeight(aHeight)
  1903. {}
  1910. inline RHandleBase::RHandleBase()
  1911. : iHandle(0)
  1915. {}
  1921. inline RHandleBase::RHandleBase(TInt aHandle)
  1922. : iHandle(aHandle)
  1923. #line 2853
  1924. {}
  1930. inline void RHandleBase::SetHandle(TInt aHandle)
  1937. { iHandle=aHandle; }
  1942. inline TInt RHandleBase::Handle() const
  1948. {return(iHandle);}
  1953. inline TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError)
  1954. #line 2899
  1955. {
  1956. if(aHandleOrError>=0)
  1957. {
  1958. iHandle = aHandleOrError;
  1959. return KErrNone;
  1960. }
  1961. iHandle = 0;
  1962. return aHandleOrError;
  1963. }
  1970. inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType)
  1971. #line 2935
  1972. {return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));}
  1973. #line 2947
  1974. inline RFastLock::RFastLock()
  1975. : iCount(0)
  1976. {}
  1977. #line 2960
  1978. inline RMessagePtr2::RMessagePtr2()
  1979. : iHandle(0)
  1980. {}
  1981. #line 2972
  1982. inline TBool RMessagePtr2::IsNull() const
  1983. {return iHandle==0;}
  1984. #line 2983
  1985. inline TInt RMessagePtr2::Handle() const
  1986. {return iHandle;}
  1987. inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  1988. {return aLeft.Handle()==aRight.Handle();}
  1989. inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  1990. {return aLeft.Handle()!=aRight.Handle();}
  1991. #line 3000
  1992. inline RMessage2::RMessage2()
  1993. {}
  1994. #line 3011
  1995. inline TInt RMessage2::Function() const
  1996. {return(iFunction);}
  1997. #line 3022
  1998. inline TInt RMessage2::Int0() const
  1999. {return(iArgs[0]);}
  2000. #line 3033
  2001. inline TInt RMessage2::Int1() const
  2002. {return(iArgs[1]);}
  2003. #line 3044
  2004. inline TInt RMessage2::Int2() const
  2005. {return(iArgs[2]);}
  2006. #line 3054
  2007. inline TInt RMessage2::Int3() const
  2008. {return(iArgs[3]);}
  2009. #line 3064
  2010. inline const TAny *RMessage2::Ptr0() const
  2011. {return((const TAny *)iArgs[0]);}
  2012. #line 3075
  2013. inline const TAny *RMessage2::Ptr1() const
  2014. {return((const TAny *)iArgs[1]);}
  2015. #line 3086
  2016. inline const TAny *RMessage2::Ptr2() const
  2017. {return((const TAny *)iArgs[2]);}
  2018. #line 3097
  2019. inline const TAny *RMessage2::Ptr3() const
  2020. {return((const TAny *)iArgs[3]);}
  2021. #line 3107
  2022. inline CSession2* RMessage2::Session() const
  2023. {return (CSession2*)iSessionPtr; }
  2029. inline TUid TUid::Uid(TInt aUid)
  2030. #line 3123
  2031. {TUid uid={aUid};return uid;}
  2036. inline TUid TUid::Null()
  2042. {TUid uid={KNullUidValue};return uid;}
  2049. template <class T>
  2050. inline TArray<T>::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr)
  2051. : iPtr(aPtr),iCount(aCount),iAt(anAt)
  2052. #line 3195
  2053. {}
  2058. template <class T>
  2059. inline TInt TArray<T>::Count() const
  2066. {return((*iCount)(iPtr));}
  2071. template <class T>
  2072. inline const T &TArray<T>::operator[](TInt anIndex) const
  2073. #line 3232
  2074. {return(*((const T *)(*iAt)(iPtr,anIndex)));}
  2081. template <class T>
  2082. inline TIdentityRelation<T>::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) )
  2083. #line 3254
  2084. { iIdentity=(TGeneralIdentityRelation)anIdentity; }
  2089. template <class T>
  2090. inline TIdentityRelation<T>::operator TGeneralIdentityRelation() const
  2095. { return iIdentity; }
  2101. template <class T>
  2102. inline TLinearOrder<T>::TLinearOrder( TInt(*anOrder)(const T&, const T&) )
  2103. #line 3288
  2104. { iOrder=(TGeneralLinearOrder)anOrder; }
  2109. template <class T>
  2110. inline TLinearOrder<T>::operator TGeneralLinearOrder() const
  2115. { return iOrder; }
  2116. #line 3312
  2117. template <class T>
  2118. inline RPointerArray<T>::RPointerArray()
  2119. : RPointerArrayBase()
  2120. {}
  2121. #line 3331
  2122. template <class T>
  2123. inline RPointerArray<T>::RPointerArray(TInt aGranularity)
  2124. : RPointerArrayBase(aGranularity)
  2125. {}
  2126. #line 3354
  2127. template <class T>
  2128. inline RPointerArray<T>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2129. : RPointerArrayBase(aMinGrowBy, aFactor)
  2130. {}
  2135. template <class T>
  2136. inline void RPointerArray<T>::Close()
  2137. #line 3372
  2138. {RPointerArrayBase::Close();}
  2143. template <class T>
  2144. inline TInt RPointerArray<T>::Count() const
  2150. { return RPointerArrayBase::Count(); }
  2155. template <class T>
  2156. inline T* const& RPointerArray<T>::operator[](TInt anIndex) const
  2157. #line 3408
  2158. {return (T* const&)At(anIndex);}
  2163. template <class T>
  2164. inline T*& RPointerArray<T>::operator[](TInt anIndex)
  2165. #line 3432
  2166. {return (T*&)At(anIndex);}
  2171. template <class T>
  2172. inline TInt RPointerArray<T>::Append(const T* anEntry)
  2173. #line 3447
  2174. { return RPointerArrayBase::Append(anEntry); }
  2179. template <class T>
  2180. inline TInt RPointerArray<T>::Insert(const T* anEntry, TInt aPos)
  2181. #line 3468
  2182. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2187. template <class T>
  2188. inline void RPointerArray<T>::Remove(TInt anIndex)
  2189. #line 3488
  2190. {RPointerArrayBase::Remove(anIndex);}
  2195. template <class T>
  2196. inline void RPointerArray<T>::Compress()
  2197. #line 3503
  2198. {RPointerArrayBase::Compress();}
  2203. template <class T>
  2204. inline void RPointerArray<T>::Reset()
  2205. #line 3522
  2206. {RPointerArrayBase::Reset();}
  2211. template <class T>
  2212. inline TInt RPointerArray<T>::Find(const T* anEntry) const
  2213. #line 3542
  2214. { return RPointerArrayBase::Find(anEntry); }
  2219. template <class T>
  2220. inline TInt RPointerArray<T>::Find(const T* anEntry, TIdentityRelation<T> anIdentity) const
  2221. #line 3566
  2222. { return RPointerArrayBase::Find(anEntry,anIdentity); }
  2227. template <class T>
  2228. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry) const
  2229. #line 3584
  2230. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2235. template <class T>
  2236. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const
  2237. #line 3606
  2238. { return RPointerArrayBase::FindIsq(anEntry,anOrder); }
  2243. template <class T>
  2244. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry, TInt& anIndex) const
  2245. #line 3631
  2246. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2251. template <class T>
  2252. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2253. #line 3660
  2254. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); }
  2259. template <class T>
  2260. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const
  2261. #line 3691
  2262. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2267. template <class T>
  2268. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2269. #line 3726
  2270. { return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); }
  2275. template <class T>
  2276. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const
  2277. #line 3766
  2278. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2283. template <class T>
  2284. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2285. #line 3810
  2286. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); }
  2291. template <class T>
  2292. inline TInt RPointerArray<T>::InsertInAddressOrder(const T* anEntry)
  2293. #line 3833
  2294. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2299. template <class T>
  2300. inline TInt RPointerArray<T>::InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder)
  2301. #line 3862
  2302. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); }
  2307. template <class T>
  2308. inline TInt RPointerArray<T>::InsertInAddressOrderAllowRepeats(const T* anEntry)
  2309. #line 3885
  2310. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2315. template <class T>
  2316. inline TInt RPointerArray<T>::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder)
  2317. #line 3911
  2318. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); }
  2324. template <class T>
  2325. inline RPointerArray<T>::RPointerArray(T** aEntries, TInt aCount)
  2326. : RPointerArrayBase((TAny **)aEntries, aCount)
  2327. #line 3935
  2328. {}
  2333. template <class T>
  2334. inline void RPointerArray<T>::GranularCompress()
  2335. #line 3950
  2336. {RPointerArrayBase::GranularCompress();}
  2341. template <class T>
  2342. inline TInt RPointerArray<T>::Reserve(TInt aCount)
  2343. #line 3969
  2344. { return RPointerArrayBase::DoReserve(aCount); }
  2349. template <class T>
  2350. inline void RPointerArray<T>::SortIntoAddressOrder()
  2354. { HeapSortUnsigned(); }
  2359. template <class T>
  2360. inline void RPointerArray<T>::Sort(TLinearOrder<T> anOrder)
  2361. #line 3996
  2362. { HeapSort(anOrder); }
  2367. template <class T>
  2368. inline TArray<T*> RPointerArray<T>::Array() const
  2376. { return TArray<T*>(GetCount,GetElementPtr,(const CBase*)this); }
  2381. template <class T>
  2382. void RPointerArray<T>::ResetAndDestroy()
  2383. #line 4026
  2384. {
  2385. TInt c=Count();
  2386. T** pE=(T**)Entries();
  2387. ZeroCount();
  2388. TInt i;
  2389. for (i=0; i<c; i++)
  2390. {
  2391. delete *pE;
  2392. pE++;
  2393. }
  2394. Reset();
  2395. }
  2396. #line 4049
  2397. inline RPointerArray<TAny>::RPointerArray()
  2398. : RPointerArrayBase()
  2399. {}
  2400. #line 4067
  2401. inline RPointerArray<TAny>::RPointerArray(TInt aGranularity)
  2402. : RPointerArrayBase(aGranularity)
  2403. {}
  2404. #line 4089
  2405. inline RPointerArray<TAny>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2406. : RPointerArrayBase(aMinGrowBy, aFactor)
  2407. {}
  2412. inline void RPointerArray<TAny>::Close()
  2413. #line 4105
  2414. {RPointerArrayBase::Close();}
  2419. inline TInt RPointerArray<TAny>::Count() const
  2425. { return RPointerArrayBase::Count(); }
  2430. inline TAny* const& RPointerArray<TAny>::operator[](TInt anIndex) const
  2431. #line 4139
  2432. {return At(anIndex);}
  2437. inline TAny*& RPointerArray<TAny>::operator[](TInt anIndex)
  2438. #line 4162
  2439. {return At(anIndex);}
  2444. inline TInt RPointerArray<TAny>::Append(const TAny* anEntry)
  2445. #line 4176
  2446. { return RPointerArrayBase::Append(anEntry); }
  2451. inline TInt RPointerArray<TAny>::Insert(const TAny* anEntry, TInt aPos)
  2452. #line 4196
  2453. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2458. inline void RPointerArray<TAny>::Remove(TInt anIndex)
  2459. #line 4215
  2460. {RPointerArrayBase::Remove(anIndex);}
  2465. inline void RPointerArray<TAny>::Compress()
  2466. #line 4229
  2467. {RPointerArrayBase::Compress();}
  2472. inline void RPointerArray<TAny>::Reset()
  2473. #line 4247
  2474. {RPointerArrayBase::Reset();}
  2479. inline TInt RPointerArray<TAny>::Find(const TAny* anEntry) const
  2480. #line 4266
  2481. { return RPointerArrayBase::Find(anEntry); }
  2486. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry) const
  2487. #line 4283
  2488. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2493. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const
  2494. #line 4307
  2495. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2500. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const
  2501. #line 4337
  2502. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2507. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const
  2508. #line 4376
  2509. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2514. inline TInt RPointerArray<TAny>::InsertInAddressOrder(const TAny* anEntry)
  2515. #line 4398
  2516. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2521. inline TInt RPointerArray<TAny>::InsertInAddressOrderAllowRepeats(const TAny* anEntry)
  2522. #line 4420
  2523. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2529. inline RPointerArray<TAny>::RPointerArray(TAny** aEntries, TInt aCount)
  2530. : RPointerArrayBase((TAny **)aEntries, aCount)
  2531. #line 4443
  2532. {}
  2537. inline void RPointerArray<TAny>::GranularCompress()
  2538. #line 4457
  2539. {RPointerArrayBase::GranularCompress();}
  2544. inline void RPointerArray<TAny>::SortIntoAddressOrder()
  2548. { HeapSortUnsigned(); }
  2553. inline TArray<TAny*> RPointerArray<TAny>::Array() const
  2561. { return TArray<TAny*>(GetCount,GetElementPtr,(const CBase*)this); }
  2566. template <class T>
  2567. inline RArray<T>::RArray()
  2568. : RArrayBase(sizeof(T))
  2569. #line 4497
  2570. {}
  2575. template <class T>
  2576. inline RArray<T>::RArray(TInt aGranularity)
  2577. : RArrayBase(sizeof(T),aGranularity)
  2578. #line 4519
  2579. {}
  2584. template <class T>
  2585. inline RArray<T>::RArray(TInt aGranularity, TInt aKeyOffset)
  2586. : RArrayBase(sizeof(T),aGranularity,aKeyOffset)
  2587. #line 4543
  2588. {}
  2589. #line 4567
  2590. template <class T>
  2591. inline RArray<T>::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
  2592. : RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor)
  2593. {}
  2598. template <class T>
  2599. inline void RArray<T>::Close()
  2605. {RArrayBase::Close();}
  2610. template <class T>
  2611. inline TInt RArray<T>::Count() const
  2617. {return RArrayBase::Count();}
  2622. template <class T>
  2623. inline const T& RArray<T>::operator[](TInt anIndex) const
  2624. #line 4616
  2625. {return *(const T*)At(anIndex); }
  2630. template <class T>
  2631. inline T& RArray<T>::operator[](TInt anIndex)
  2632. #line 4638
  2633. {return *(T*)At(anIndex); }
  2638. template <class T>
  2639. inline TInt RArray<T>::Append(const T& anEntry)
  2640. #line 4653
  2641. {return RArrayBase::Append(&anEntry);}
  2646. template <class T>
  2647. inline TInt RArray<T>::Insert(const T& anEntry, TInt aPos)
  2648. #line 4675
  2649. {return RArrayBase::Insert(&anEntry,aPos);}
  2654. template <class T>
  2655. inline void RArray<T>::Remove(TInt anIndex)
  2656. #line 4692
  2657. {RArrayBase::Remove(anIndex);}
  2662. template <class T>
  2663. inline void RArray<T>::Compress()
  2671. {RArrayBase::Compress();}
  2676. template <class T>
  2677. inline void RArray<T>::Reset()
  2678. #line 4721
  2679. {RArrayBase::Reset();}
  2684. template <class T>
  2685. inline TInt RArray<T>::Find(const T& anEntry) const
  2686. #line 4743
  2687. {return RArrayBase::Find(&anEntry);}
  2692. template <class T>
  2693. inline TInt RArray<T>::Find(const T& anEntry, TIdentityRelation<T> anIdentity) const
  2694. #line 4768
  2695. {return RArrayBase::Find(&anEntry,anIdentity);}
  2700. template <class T>
  2701. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry) const
  2702. #line 4787
  2703. {return RArrayBase::FindIsqSigned(&anEntry);}
  2708. template <class T>
  2709. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry) const
  2710. #line 4806
  2711. {return RArrayBase::FindIsqUnsigned(&anEntry);}
  2716. template <class T>
  2717. inline TInt RArray<T>::FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const
  2718. #line 4828
  2719. {return RArrayBase::FindIsq(&anEntry,anOrder);}
  2724. template <class T>
  2725. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2726. #line 4851
  2727. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex);}
  2732. template <class T>
  2733. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const
  2734. #line 4875
  2735. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);}
  2740. template <class T>
  2741. inline TInt RArray<T>::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2742. #line 4902
  2743. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);}
  2748. template <class T>
  2749. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const
  2750. #line 4936
  2751. {return RArrayBase::FindIsqSigned(&anEntry,aMode);}
  2756. template <class T>
  2757. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const
  2758. #line 4970
  2759. {return RArrayBase::FindIsqUnsigned(&anEntry,aMode);}
  2764. template <class T>
  2765. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2766. #line 5003
  2767. {return RArrayBase::FindIsq(&anEntry,anOrder,aMode);}
  2772. template <class T>
  2773. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2774. #line 5042
  2775. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);}
  2780. template <class T>
  2781. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  2782. #line 5081
  2783. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);}
  2788. template <class T>
  2789. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2790. #line 5123
  2791. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);}
  2796. template <class T>
  2797. inline TInt RArray<T>::InsertInSignedKeyOrder(const T& anEntry)
  2798. #line 5146
  2799. {return RArrayBase::InsertIsqSigned(&anEntry,EFalse);}
  2804. template <class T>
  2805. inline TInt RArray<T>::InsertInUnsignedKeyOrder(const T& anEntry)
  2806. #line 5169
  2807. {return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);}
  2812. template <class T>
  2813. inline TInt RArray<T>::InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder)
  2814. #line 5197
  2815. {return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);}
  2820. template <class T>
  2821. inline TInt RArray<T>::InsertInSignedKeyOrderAllowRepeats(const T& anEntry)
  2822. #line 5221
  2823. {return RArrayBase::InsertIsqSigned(&anEntry,ETrue);}
  2828. template <class T>
  2829. inline TInt RArray<T>::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry)
  2830. #line 5245
  2831. {return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);}
  2836. template <class T>
  2837. inline TInt RArray<T>::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder)
  2838. #line 5272
  2839. {return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);}
  2845. template <class T>
  2846. inline RArray<T>::RArray(TInt aEntrySize,T* aEntries, TInt aCount)
  2847. : RArrayBase(aEntrySize,aEntries,aCount)
  2848. #line 5303
  2849. {}
  2854. template <class T>
  2855. inline void RArray<T>::GranularCompress()
  2856. #line 5318
  2857. {RArrayBase::GranularCompress();}
  2862. template <class T>
  2863. inline TInt RArray<T>::Reserve(TInt aCount)
  2864. #line 5337
  2865. { return RArrayBase::DoReserve(aCount); }
  2870. template <class T>
  2871. inline void RArray<T>::SortSigned()
  2876. {HeapSortSigned();}
  2881. template <class T>
  2882. inline void RArray<T>::SortUnsigned()
  2887. {HeapSortUnsigned();}
  2892. template <class T>
  2893. inline void RArray<T>::Sort(TLinearOrder<T> anOrder)
  2894. #line 5375
  2895. {HeapSort(anOrder);}
  2900. template <class T>
  2901. inline TArray<T> RArray<T>::Array() const
  2907. { return TArray<T>(GetCount,GetElementPtr,(const CBase*)this); }
  2913. inline RArray<TInt>::RArray()
  2914. : RPointerArrayBase()
  2921. {}
  2926. inline RArray<TInt>::RArray(TInt aGranularity)
  2927. : RPointerArrayBase(aGranularity)
  2928. #line 5417
  2929. {}
  2930. #line 5437
  2931. inline RArray<TInt>::RArray(TInt aMinGrowBy, TInt aFactor)
  2932. : RPointerArrayBase(aMinGrowBy, aFactor)
  2933. {}
  2938. inline void RArray<TInt>::Close()
  2944. {RPointerArrayBase::Close();}
  2949. inline TInt RArray<TInt>::Count() const
  2955. { return RPointerArrayBase::Count(); }
  2960. inline const TInt& RArray<TInt>::operator[](TInt anIndex) const
  2961. #line 5484
  2962. {return (const TInt&)At(anIndex);}
  2967. inline TInt& RArray<TInt>::operator[](TInt anIndex)
  2968. #line 5507
  2969. {return (TInt&)At(anIndex);}
  2974. inline TInt RArray<TInt>::Append(TInt anEntry)
  2975. #line 5521
  2976. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  2981. inline TInt RArray<TInt>::Insert(TInt anEntry, TInt aPos)
  2982. #line 5541
  2983. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  2988. inline void RArray<TInt>::Remove(TInt anIndex)
  2989. #line 5558
  2990. {RPointerArrayBase::Remove(anIndex);}
  2995. inline void RArray<TInt>::Compress()
  3003. {RPointerArrayBase::Compress();}
  3008. inline void RArray<TInt>::Reset()
  3009. #line 5586
  3010. {RPointerArrayBase::Reset();}
  3015. inline TInt RArray<TInt>::Find(TInt anEntry) const
  3016. #line 5604
  3017. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3022. inline TInt RArray<TInt>::FindInOrder(TInt anEntry) const
  3023. #line 5621
  3024. { return RPointerArrayBase::FindIsqSigned(anEntry); }
  3029. inline TInt RArray<TInt>::FindInOrder(TInt anEntry, TInt& anIndex) const
  3030. #line 5644
  3031. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); }
  3036. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt aMode) const
  3037. #line 5675
  3038. { return RPointerArrayBase::FindIsqSigned(anEntry,aMode); }
  3043. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const
  3044. #line 5713
  3045. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); }
  3050. inline TInt RArray<TInt>::InsertInOrder(TInt anEntry)
  3051. #line 5735
  3052. { return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); }
  3057. inline TInt RArray<TInt>::InsertInOrderAllowRepeats(TInt anEntry)
  3058. #line 5758
  3059. { return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); }
  3065. inline RArray<TInt>::RArray(TInt* aEntries, TInt aCount)
  3066. : RPointerArrayBase((TAny**)aEntries, aCount)
  3067. #line 5781
  3068. {}
  3070. inline void RArray<TInt>::GranularCompress()
  3071. #line 5792
  3072. {RPointerArrayBase::GranularCompress();}
  3077. inline TInt RArray<TInt>::Reserve(TInt aCount)
  3078. #line 5810
  3079. { return RPointerArrayBase::DoReserve(aCount); }
  3084. inline void RArray<TInt>::Sort()
  3088. { HeapSortSigned(); }
  3093. inline TArray<TInt> RArray<TInt>::Array() const
  3101. { return TArray<TInt>(GetCount,GetElementPtr,(const CBase*)this); }
  3106. inline RArray<TUint>::RArray()
  3107. : RPointerArrayBase()
  3108. #line 5847
  3109. {}
  3114. inline RArray<TUint>::RArray(TInt aGranularity)
  3115. : RPointerArrayBase(aGranularity)
  3116. #line 5863
  3117. {}
  3118. #line 5883
  3119. inline RArray<TUint>::RArray(TInt aMinGrowBy, TInt aFactor)
  3120. : RPointerArrayBase(aMinGrowBy, aFactor)
  3121. {}
  3126. inline void RArray<TUint>::Close()
  3132. {RPointerArrayBase::Close();}
  3137. inline TInt RArray<TUint>::Count() const
  3143. {return RPointerArrayBase::Count(); }
  3148. inline const TUint& RArray<TUint>::operator[](TInt anIndex) const
  3149. #line 5930
  3150. {return (const TUint&)At(anIndex);}
  3155. inline TUint& RArray<TUint>::operator[](TInt anIndex)
  3156. #line 5953
  3157. {return (TUint&)At(anIndex);}
  3162. inline TInt RArray<TUint>::Append(TUint anEntry)
  3170. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3175. inline TInt RArray<TUint>::Insert(TUint anEntry, TInt aPos)
  3176. #line 5987
  3177. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3182. inline void RArray<TUint>::Remove(TInt anIndex)
  3183. #line 6005
  3184. {RPointerArrayBase::Remove(anIndex);}
  3189. inline void RArray<TUint>::Compress()
  3197. {RPointerArrayBase::Compress();}
  3202. inline void RArray<TUint>::Reset()
  3203. #line 6033
  3204. {RPointerArrayBase::Reset();}
  3209. inline TInt RArray<TUint>::Find(TUint anEntry) const
  3210. #line 6051
  3211. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3216. inline TInt RArray<TUint>::FindInOrder(TUint anEntry) const
  3217. #line 6070
  3218. { return RPointerArrayBase::FindIsqUnsigned(anEntry); }
  3223. inline TInt RArray<TUint>::FindInOrder(TUint anEntry, TInt& anIndex) const
  3224. #line 6098
  3225. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); }
  3230. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt aMode) const
  3231. #line 6128
  3232. { return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); }
  3237. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const
  3238. #line 6163
  3239. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); }
  3244. inline TInt RArray<TUint>::InsertInOrder(TUint anEntry)
  3245. #line 6185
  3246. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); }
  3251. inline TInt RArray<TUint>::InsertInOrderAllowRepeats(TUint anEntry)
  3252. #line 6208
  3253. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); }
  3259. inline RArray<TUint>::RArray(TUint* aEntries, TInt aCount)
  3260. : RPointerArrayBase((TAny**)aEntries, aCount)
  3261. #line 6231
  3262. {}
  3266. inline void RArray<TUint>::GranularCompress()
  3267. #line 6244
  3268. {RPointerArrayBase::GranularCompress();}
  3273. inline TInt RArray<TUint>::Reserve(TInt aCount)
  3274. #line 6262
  3275. { return RPointerArrayBase::DoReserve(aCount); }
  3280. inline void RArray<TUint>::Sort()
  3284. { HeapSortUnsigned(); }
  3289. inline TArray<TUint> RArray<TUint>::Array() const
  3297. { return TArray<TUint>(GetCount,GetElementPtr,(const CBase*)this); }
  3298. #line 6293
  3299. inline void TIpcArgs::Set(TInt,TNothing)
  3300. {}
  3301. #line 6307
  3302. inline void TIpcArgs::Set(TInt aIndex,TInt aValue)
  3303. {
  3304. iArgs[aIndex] = aValue;
  3305. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3306. }
  3307. #line 6324
  3308. inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue)
  3309. {
  3310. iArgs[aIndex] = (TInt)aValue;
  3311. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3312. }
  3313. #line 6341
  3314. inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue)
  3315. {
  3316. iArgs[aIndex] = (TInt)aValue.Handle();
  3317. iFlags |= EHandle<<(aIndex*KBitsPerType);
  3318. }
  3319. #line 6358
  3320. inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue)
  3321. {
  3322. iArgs[aIndex] = (TInt)aValue;
  3323. iFlags |= EDesC8<<(aIndex*KBitsPerType);
  3324. }
  3325. #line 6377
  3326. inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue)
  3327. {
  3328. iArgs[aIndex] = (TInt)aValue;
  3329. iFlags |= EDesC16<<(aIndex*KBitsPerType);
  3330. }
  3331. #line 6396
  3332. inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue)
  3333. {
  3334. iArgs[aIndex] = (TInt)aValue;
  3335. iFlags |= EDes8<<(aIndex*KBitsPerType);
  3336. }
  3337. #line 6415
  3338. inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue)
  3339. {
  3340. iArgs[aIndex] = (TInt)aValue;
  3341. iFlags |= EDes16<<(aIndex*KBitsPerType);
  3342. }
  3349. inline TIpcArgs::TArgType TIpcArgs::Type(TNothing)
  3350. { return EUnspecified; }
  3351. inline TIpcArgs::TArgType TIpcArgs::Type(TInt)
  3352. { return EUnspecified; }
  3353. inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*)
  3354. { return EUnspecified; }
  3355. inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase)
  3356. { return EHandle; }
  3357. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*)
  3358. { return EDesC8; }
  3360. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*)
  3361. { return EDesC16; }
  3363. inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*)
  3364. { return EDes8; }
  3366. inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*)
  3367. { return EDes16; }
  3369. inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing)
  3370. {}
  3371. inline void TIpcArgs::Assign(TInt& aArg,TInt aValue)
  3372. { aArg = aValue; }
  3373. inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue)
  3374. { aArg = (TInt)aValue; }
  3375. inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue)
  3376. { aArg = (TInt)aValue.Handle(); }
  3377. inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue)
  3378. { aArg = (TInt)aValue; }
  3380. inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue)
  3381. { aArg = (TInt)aValue; }
  3383. inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue)
  3384. { aArg = (TInt)aValue; }
  3386. inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue)
  3387. { aArg = (TInt)aValue; }
  3394. inline SInt64::SInt64()
  3395. {}
  3397. inline SInt64::SInt64(Int64 a)
  3398. {
  3399. iData[0] = (TUint32)((Uint64)a);
  3400. iData[1] = (TUint32)(((Uint64)a)>>32);
  3401. }
  3403. inline SInt64& SInt64::operator=(Int64 a)
  3404. {
  3405. iData[0] = (TUint32)((Uint64)a);
  3406. iData[1] = (TUint32)(((Uint64)a)>>32);
  3407. return *this;
  3408. }
  3410. inline SInt64::operator Int64() const
  3411. {
  3412. Int64 x;
  3413. TUint32* px = (TUint32*)&x;
  3414. px[0] = iData[0];
  3415. px[1] = iData[1];
  3416. return x;
  3417. }
  3419. inline SUint64::SUint64()
  3420. {}
  3422. inline SUint64::SUint64(Uint64 a)
  3423. {
  3424. iData[0] = (TUint32)a;
  3425. iData[1] = (TUint32)(a>>32);
  3426. }
  3428. inline SUint64& SUint64::operator=(Uint64 a)
  3429. {
  3430. iData[0] = (TUint32)a;
  3431. iData[1] = (TUint32)(a>>32);
  3432. return *this;
  3433. }
  3435. inline SUint64::operator Uint64() const
  3436. {
  3437. Uint64 x;
  3438. TUint32* px = (TUint32*)&x;
  3439. px[0] = iData[0];
  3440. px[1] = iData[1];
  3441. return x;
  3442. }
  3444. inline SDouble::SDouble()
  3445. {}
  3447. inline SDouble::SDouble(TReal a)
  3448. {
  3449. const TUint32* pa = (const TUint32*)&a;
  3454. iData[0] = pa[0];
  3455. iData[1] = pa[1];
  3457. }
  3459. inline SDouble& SDouble::operator=(TReal a)
  3460. {
  3461. new (this) SDouble(a);
  3462. return *this;
  3463. }
  3465. inline SDouble::operator TReal() const
  3466. {
  3467. TReal x;
  3468. TUint32* px = (TUint32*)&x;
  3473. px[0] = iData[0];
  3474. px[1] = iData[1];
  3476. return x;
  3477. }
  3484. inline TSecureId::TSecureId()
  3485. {}
  3489. inline TSecureId::TSecureId(TUint32 aId)
  3490. : iId(aId) {}
  3494. inline TSecureId::operator TUint32() const
  3495. { return iId; }
  3499. inline TSecureId::TSecureId(TUid aId)
  3500. : iId(aId.iUid) {}
  3504. inline TSecureId::operator TUid() const
  3505. { return (TUid&)iId; }
  3510. inline const TSecureId* SSecureId::operator&() const
  3511. { return (const TSecureId*)this; }
  3512. inline SSecureId::operator const TSecureId&() const
  3513. { return (const TSecureId&)iId; }
  3514. inline SSecureId::operator TUint32() const
  3515. { return iId; }
  3516. inline SSecureId::operator TUid() const
  3517. { return (TUid&)iId; }
  3524. inline TVendorId::TVendorId()
  3525. {}
  3529. inline TVendorId::TVendorId(TUint32 aId)
  3530. : iId(aId) {}
  3534. inline TVendorId::operator TUint32() const
  3535. { return iId; }
  3539. inline TVendorId::TVendorId(TUid aId)
  3540. : iId(aId.iUid) {}
  3544. inline TVendorId::operator TUid() const
  3545. { return (TUid&)iId; }
  3550. inline const TVendorId* SVendorId::operator&() const
  3551. { return (const TVendorId*)this; }
  3552. inline SVendorId::operator const TVendorId&() const
  3553. { return (const TVendorId&)iId; }
  3554. inline SVendorId::operator TUint32() const
  3555. { return iId; }
  3556. inline SVendorId::operator TUid() const
  3557. { return (TUid&)iId; }
  3563. inline TCapabilitySet::TCapabilitySet()
  3564. {}
  3570. inline TCapabilitySet::TCapabilitySet(TCapability aCapability)
  3571. { new (this) TCapabilitySet(aCapability, aCapability); }
  3577. inline void TCapabilitySet::Set(TCapability aCapability)
  3578. { new (this) TCapabilitySet(aCapability, aCapability); }
  3585. inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2)
  3586. { new (this) TCapabilitySet(aCapability1, aCapability2); }
  3592. inline TSecurityInfo::TSecurityInfo()
  3593. {}
  3598. inline TSecurityPolicy::TSecurityPolicy()
  3599. { new (this) TSecurityPolicy(EAlwaysFail); }
  3605. inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const
  3606. { return (const TSecurityPolicy*)this; }
  3612. inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const
  3613. { return *(const TSecurityPolicy*)this; }
  3619. inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const
  3620. { return *(const TSecurityPolicy*)this; }
  3621. #line 6341 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.h" /* stack depth 5 */
  3622. #line 13 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 4 */
  3629. class TFunctor
  3630. {
  3631. public:
  3632. __declspec(dllexport) virtual void operator()() =0;
  3633. };
  3634. #line 53
  3635. class TCallBack
  3636. {
  3637. public:
  3638. inline TCallBack();
  3639. inline TCallBack(TInt (*aFunction)(TAny* aPtr));
  3640. inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
  3641. inline TInt CallBack() const;
  3642. public:
  3647. TInt (*iFunction)(TAny* aPtr);
  3654. TAny* iPtr;
  3655. };
  3656. #line 89
  3657. class TSglQueLink
  3658. {
  3660. public:
  3661. inline TSglQueLink() : iNext(0 )
  3669. {}
  3671. private:
  3672. __declspec(dllexport) void Enque(TSglQueLink* aLink);
  3673. public:
  3677. TSglQueLink* iNext;
  3678. friend class TSglQueBase;
  3679. };
  3680. #line 130
  3681. class TDblQueLinkBase
  3682. {
  3683. public:
  3684. inline TDblQueLinkBase() : iNext(0 )
  3692. {}
  3693. __declspec(dllexport) void Enque(TDblQueLinkBase* aLink);
  3694. __declspec(dllexport) void AddBefore(TDblQueLinkBase* aLink);
  3695. public:
  3699. TDblQueLinkBase* iNext;
  3704. TDblQueLinkBase* iPrev;
  3705. };
  3706. #line 166
  3707. class TDblQueLink : public TDblQueLinkBase
  3708. {
  3709. public:
  3710. __declspec(dllexport) void Deque();
  3711. };
  3712. #line 184
  3713. class TPriQueLink : public TDblQueLink
  3714. {
  3715. public:
  3721. TInt iPriority;
  3722. };
  3723. #line 205
  3724. class TDeltaQueLink : public TDblQueLinkBase
  3725. {
  3726. public:
  3730. TInt iDelta;
  3731. };
  3732. #line 224
  3733. class TTickCountQueLink : public TDblQueLink
  3734. {
  3735. public:
  3739. TUint iTickCount;
  3740. };
  3741. #line 248
  3742. class TSglQueBase
  3743. {
  3744. public:
  3745. __declspec(dllexport) TBool IsEmpty() const;
  3746. __declspec(dllexport) void SetOffset(TInt aOffset);
  3747. __declspec(dllexport) void Reset();
  3748. protected:
  3749. __declspec(dllexport) TSglQueBase();
  3750. __declspec(dllexport) TSglQueBase(TInt aOffset);
  3751. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3752. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3753. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3754. protected:
  3758. TSglQueLink* iHead;
  3763. TSglQueLink* iLast;
  3768. TInt iOffset;
  3769. private:
  3770. TSglQueBase(const TSglQueBase& aQue);
  3771. TSglQueBase &operator=(const TSglQueBase& aQue);
  3772. friend class TSglQueIterBase;
  3773. };
  3774. #line 296
  3775. class TDblQueBase
  3776. {
  3777. public:
  3778. __declspec(dllexport) TBool IsEmpty() const;
  3779. __declspec(dllexport) void SetOffset(TInt aOffset);
  3780. __declspec(dllexport) void Reset();
  3781. protected:
  3782. __declspec(dllexport) TDblQueBase();
  3783. __declspec(dllexport) TDblQueBase(TInt aOffset);
  3784. __declspec(dllexport) void DoAddFirst(TAny* aPtr);
  3785. __declspec(dllexport) void DoAddLast(TAny* aPtr);
  3786. __declspec(dllexport) void DoAddPriority(TAny* aPtr);
  3787. __declspec(dllexport) void __DbgTestEmpty() const;
  3788. protected:
  3792. TDblQueLink iHead;
  3797. TInt iOffset;
  3798. private:
  3799. TDblQueBase(const TDblQueBase& aQue);
  3800. TDblQueBase& operator=(const TDblQueBase& aQue);
  3801. friend class TDblQueIterBase;
  3802. };
  3803. #line 338
  3804. class TDeltaQueBase : public TDblQueBase
  3805. {
  3806. public:
  3807. __declspec(dllexport) TBool CountDown();
  3808. __declspec(dllexport) TBool CountDown(TInt aValue);
  3809. __declspec(dllexport) TBool FirstDelta(TInt& aValue);
  3810. __declspec(dllexport) void Reset();
  3811. protected:
  3812. __declspec(dllexport) TDeltaQueBase();
  3813. __declspec(dllexport) TDeltaQueBase(TInt aOffset);
  3814. __declspec(dllexport) void DoAddDelta(TAny* aPtr,TInt aDelta);
  3815. __declspec(dllexport) void DoRemove(TAny* aPtr);
  3816. __declspec(dllexport) TAny* DoRemoveFirst();
  3817. protected:
  3821. TInt* iFirstDelta;
  3822. };
  3823. #line 375
  3824. template <class T>
  3825. class TSglQue : public TSglQueBase
  3826. {
  3827. public:
  3828. inline TSglQue();
  3829. inline explicit TSglQue(TInt aOffset);
  3830. inline void AddFirst(T& aRef);
  3831. inline void AddLast(T& aRef);
  3832. inline TBool IsFirst(const T* aPtr) const;
  3833. inline TBool IsLast(const T* aPtr) const;
  3834. inline T* First() const;
  3835. inline T* Last() const;
  3836. inline void Remove(T& aRef);
  3837. };
  3838. #line 407
  3839. template <class T>
  3840. class TDblQue : public TDblQueBase
  3841. {
  3842. public:
  3843. inline TDblQue();
  3844. inline explicit TDblQue(TInt aOffset);
  3845. inline void AddFirst(T& aRef);
  3846. inline void AddLast(T& aRef);
  3847. inline TBool IsHead(const T* aPtr) const;
  3848. inline TBool IsFirst(const T* aPtr) const;
  3849. inline TBool IsLast(const T* aPtr) const;
  3850. inline T* First() const;
  3851. inline T* Last() const;
  3852. };
  3853. #line 441
  3854. template <class T>
  3855. class TPriQue : public TDblQueBase
  3856. {
  3857. public:
  3858. inline TPriQue();
  3859. inline explicit TPriQue(TInt aOffset);
  3860. inline void Add(T& aRef);
  3861. inline TBool IsHead(const T* aPtr) const;
  3862. inline TBool IsFirst(const T* aPtr) const;
  3863. inline TBool IsLast(const T* aPtr) const;
  3864. inline T* First() const;
  3865. inline T* Last() const;
  3866. };
  3867. #line 487
  3868. template <class T>
  3869. class TDeltaQue : public TDeltaQueBase
  3870. {
  3871. public:
  3872. inline TDeltaQue();
  3873. inline explicit TDeltaQue(TInt aOffset);
  3874. inline void Add(T& aRef,TInt aDelta);
  3875. inline void Remove(T& aRef);
  3876. inline T* RemoveFirst();
  3877. };
  3883. class TTickCountQueLink;
  3884. #line 520
  3885. class TTickCountQue : public TDblQueBase
  3886. {
  3887. public:
  3888. TTickCountQue();
  3889. void Add(TTickCountQueLink& aRef);
  3890. TTickCountQueLink* First() const;
  3891. TTickCountQueLink* RemoveFirst();
  3892. TTickCountQueLink* RemoveFirst(TUint aTickCount);
  3893. };
  3894. #line 543
  3895. class TSglQueIterBase
  3896. {
  3897. public:
  3898. __declspec(dllexport) void SetToFirst();
  3899. protected:
  3900. __declspec(dllexport) TSglQueIterBase(TSglQueBase& aQue);
  3901. __declspec(dllexport) TAny* DoPostInc();
  3902. __declspec(dllexport) TAny* DoCurrent();
  3903. __declspec(dllexport) void DoSet(TAny* aLink);
  3904. protected:
  3905. TInt iOffset;
  3906. TSglQueLink* iHead;
  3907. TSglQueLink* iNext;
  3908. };
  3909. #line 571
  3910. template <class T>
  3911. class TSglQueIter : public TSglQueIterBase
  3912. {
  3913. public:
  3914. inline TSglQueIter(TSglQueBase& aQue);
  3915. inline void Set(T& aLink);
  3916. inline operator T*();
  3917. inline T* operator++(TInt);
  3918. };
  3919. #line 594
  3920. class TDblQueIterBase
  3921. {
  3922. public:
  3923. __declspec(dllexport) void SetToFirst();
  3924. __declspec(dllexport) void SetToLast();
  3925. protected:
  3926. __declspec(dllexport) TDblQueIterBase(TDblQueBase& aQue);
  3927. __declspec(dllexport) TAny* DoPostInc();
  3928. __declspec(dllexport) TAny* DoPostDec();
  3929. __declspec(dllexport) TAny* DoCurrent();
  3930. __declspec(dllexport) void DoSet(TAny* aLink);
  3931. protected:
  3935. TInt iOffset;
  3940. TDblQueLinkBase* iHead;
  3945. TDblQueLinkBase* iNext;
  3946. };
  3947. #line 635
  3948. template <class T>
  3949. class TDblQueIter : public TDblQueIterBase
  3950. {
  3951. public:
  3952. inline TDblQueIter(TDblQueBase& aQue);
  3953. inline void Set(T& aLink);
  3954. inline operator T*();
  3955. inline T* operator++(TInt);
  3956. inline T* operator--(TInt);
  3957. };
  3958. #line 660
  3959. enum TKeyCmpText
  3960. {
  3968. ECmpNormal,
  3969. #line 682
  3970. ECmpNormal8,
  3971. #line 696
  3972. ECmpNormal16,
  3973. #line 706
  3974. ECmpFolded,
  3975. #line 717
  3976. ECmpFolded8,
  3977. #line 728
  3978. ECmpFolded16,
  3979. #line 738
  3980. ECmpCollated,
  3981. #line 749
  3982. ECmpCollated8,
  3983. #line 761
  3984. ECmpCollated16
  3985. };
  3986. #line 777
  3987. enum TKeyCmpNumeric
  3988. {
  3992. ECmpTInt8=((ECmpCollated16+1)<<1),
  3998. ECmpTInt16,
  4004. ECmpTInt32,
  4010. ECmpTInt,
  4016. ECmpTUint8,
  4022. ECmpTUint16,
  4028. ECmpTUint32,
  4034. ECmpTUint,
  4040. ECmpTInt64
  4041. };
  4042. #line 856
  4043. class TKey
  4044. {
  4045. public:
  4046. inline void SetPtr(const TAny* aPtr);
  4047. __declspec(dllexport) virtual TInt Compare(TInt aLeft,TInt aRight) const;
  4048. __declspec(dllexport) virtual TAny* At(TInt anIndex) const;
  4049. protected:
  4050. __declspec(dllexport) TKey();
  4051. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType);
  4052. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
  4053. __declspec(dllexport) TKey(TInt aOffset,TKeyCmpNumeric aType);
  4054. protected:
  4055. TInt iKeyOffset;
  4056. TInt iKeyLength;
  4057. TInt iCmpType;
  4058. const TAny* iPtr;
  4059. };
  4060. #line 890
  4061. class TSwap
  4062. {
  4063. public:
  4064. __declspec(dllexport) TSwap();
  4065. __declspec(dllexport) virtual void Swap(TInt aLeft,TInt aRight) const;
  4066. };
  4067. #line 918
  4068. class TCharF : public TChar
  4069. {
  4070. public:
  4071. inline TCharF(TUint aChar);
  4072. inline TCharF(const TChar& aChar);
  4073. inline TCharF& operator=(TUint aChar);
  4074. inline TCharF& operator=(const TChar& aChar);
  4075. };
  4076. #line 937
  4077. class TCharLC : public TChar
  4078. {
  4079. public:
  4080. inline TCharLC(TUint aChar);
  4081. inline TCharLC(const TChar& aChar);
  4082. inline TCharLC& operator=(TUint aChar);
  4083. inline TCharLC& operator=(const TChar& aChar);
  4084. };
  4085. #line 956
  4086. class TCharUC : public TChar
  4087. {
  4088. public:
  4089. inline TCharUC(TUint aChar);
  4090. inline TCharUC(const TChar& aChar);
  4091. inline TCharUC& operator=(TUint aChar);
  4092. inline TCharUC& operator=(const TChar& aChar);
  4093. };
  4094. #line 982
  4095. class TRealFormat
  4096. {
  4097. public:
  4098. __declspec(dllexport) TRealFormat();
  4099. __declspec(dllexport) TRealFormat(TInt aWidth);
  4100. __declspec(dllexport) TRealFormat(TInt aWidth,TInt aDecimalPlaces);
  4101. public:
  4102. #line 1007
  4103. TInt iType;
  4109. TInt iWidth;
  4110. #line 1025
  4111. TInt iPlaces;
  4112. #line 1038
  4113. TChar iPoint;
  4114. #line 1051
  4115. TChar iTriad;
  4116. #line 1071
  4117. TInt iTriLen;
  4118. };
  4119. #line 1089
  4120. class TLexMark8
  4121. {
  4122. public:
  4123. inline TLexMark8();
  4124. private:
  4125. inline TLexMark8(const TUint8* aString);
  4126. const TUint8* iPtr;
  4127. friend class TLex8;
  4128. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4129. };
  4134. class TRealX;
  4135. #line 1123
  4136. class TLex8
  4137. {
  4138. public:
  4139. __declspec(dllexport) TLex8();
  4140. inline TLex8(const TUint8* aString);
  4141. inline TLex8(const TDesC8& aDes);
  4142. inline TLex8& operator=(const TUint8* aString);
  4143. inline TLex8& operator=(const TDesC8& aDes);
  4144. inline TBool Eos() const;
  4145. inline void Mark(TLexMark8& aMark) const;
  4146. inline void Mark();
  4147. __declspec(dllexport) void Inc();
  4148. __declspec(dllexport) void Inc(TInt aNumber);
  4149. __declspec(dllexport) TChar Get();
  4150. __declspec(dllexport) TChar Peek() const;
  4151. __declspec(dllexport) void UnGet();
  4152. inline void UnGetToMark();
  4153. __declspec(dllexport) void UnGetToMark(const TLexMark8 aMark);
  4154. __declspec(dllexport) void SkipSpace();
  4155. inline void SkipAndMark(TInt aNumber);
  4156. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark8& aMark);
  4157. inline void SkipSpaceAndMark();
  4158. __declspec(dllexport) void SkipSpaceAndMark(TLexMark8& aMark);
  4159. __declspec(dllexport) void SkipCharacters();
  4160. inline TInt TokenLength() const;
  4161. __declspec(dllexport) TInt TokenLength(const TLexMark8 aMark) const;
  4162. __declspec(dllexport) TPtrC8 MarkedToken() const;
  4163. __declspec(dllexport) TPtrC8 MarkedToken(const TLexMark8 aMark) const;
  4164. __declspec(dllexport) TPtrC8 NextToken();
  4165. __declspec(dllexport) TPtrC8 Remainder() const;
  4166. __declspec(dllexport) TPtrC8 RemainderFromMark() const;
  4167. __declspec(dllexport) TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
  4168. __declspec(dllexport) TInt Offset() const;
  4169. inline TInt MarkedOffset() const;
  4170. __declspec(dllexport) TInt MarkedOffset(const TLexMark8 aMark) const;
  4171. __declspec(dllexport) TInt Val(TInt8& aVal);
  4172. __declspec(dllexport) TInt Val(TInt16& aVal);
  4173. __declspec(dllexport) TInt Val(TInt32& aVal);
  4174. __declspec(dllexport) TInt Val(TInt64& aVal);
  4175. inline TInt Val(TInt& aVal);
  4176. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4177. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4178. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4179. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4180. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4181. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4182. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4183. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4184. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4185. __declspec(dllexport) TInt Val(TReal32& aVal);
  4186. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4187. __declspec(dllexport) TInt Val(TReal64& aVal);
  4188. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4189. inline void Assign(const TLex8& aLex);
  4190. __declspec(dllexport) void Assign(const TUint8* aString);
  4191. __declspec(dllexport) void Assign(const TDesC8& aDes);
  4192. TInt Val(TRealX& aVal);
  4193. TInt Val(TRealX& aVal, TChar aPoint);
  4196. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4199. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4202. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4205. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4206. private:
  4207. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4208. void ScndigAfterPoint(TInt& aSig,TInt64& aDl);
  4209. void ValidateMark(const TLexMark8 aMark) const;
  4210. private:
  4211. const TUint8* iNext;
  4212. const TUint8* iBuf;
  4213. const TUint8* iEnd;
  4214. TLexMark8 iMark;
  4215. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4216. };
  4217. #line 1220
  4218. class TLexMark16
  4219. {
  4220. public:
  4221. inline TLexMark16();
  4222. private:
  4223. inline TLexMark16(const TUint16* aString);
  4224. const TUint16* iPtr;
  4225. friend class TLex16;
  4226. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4227. };
  4228. #line 1253
  4229. class TLex16
  4230. {
  4231. public:
  4232. __declspec(dllexport) TLex16();
  4233. inline TLex16(const TUint16* aString);
  4234. inline TLex16(const TDesC16& aDes);
  4235. inline TLex16& operator=(const TUint16* aString);
  4236. inline TLex16& operator=(const TDesC16& aDes);
  4237. inline TBool Eos() const;
  4238. inline void Mark();
  4239. inline void Mark(TLexMark16& aMark) const;
  4240. __declspec(dllexport) void Inc();
  4241. __declspec(dllexport) void Inc(TInt aNumber);
  4242. __declspec(dllexport) TChar Get();
  4243. __declspec(dllexport) TChar Peek() const;
  4244. __declspec(dllexport) void UnGet();
  4245. inline void UnGetToMark();
  4246. __declspec(dllexport) void UnGetToMark(const TLexMark16 aMark);
  4247. __declspec(dllexport) void SkipSpace();
  4248. inline void SkipAndMark(TInt aNumber);
  4249. __declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark16& aMark);
  4250. __declspec(dllexport) void SkipSpaceAndMark(TLexMark16& aMark);
  4251. inline void SkipSpaceAndMark();
  4252. __declspec(dllexport) void SkipCharacters();
  4253. inline TInt TokenLength() const;
  4254. __declspec(dllexport) TInt TokenLength(const TLexMark16 aMark) const;
  4255. __declspec(dllexport) TPtrC16 MarkedToken() const;
  4256. __declspec(dllexport) TPtrC16 MarkedToken(const TLexMark16 aMark) const;
  4257. __declspec(dllexport) TPtrC16 NextToken();
  4258. __declspec(dllexport) TPtrC16 Remainder() const;
  4259. __declspec(dllexport) TPtrC16 RemainderFromMark() const;
  4260. __declspec(dllexport) TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
  4261. __declspec(dllexport) TInt Offset() const;
  4262. inline TInt MarkedOffset() const;
  4263. __declspec(dllexport) TInt MarkedOffset(const TLexMark16 aMark) const;
  4264. __declspec(dllexport) TInt Val(TInt8& aVal);
  4265. __declspec(dllexport) TInt Val(TInt16& aVal);
  4266. __declspec(dllexport) TInt Val(TInt32& aVal);
  4267. __declspec(dllexport) TInt Val(TInt64& aVal);
  4268. inline TInt Val(TInt& aVal);
  4269. __declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
  4270. __declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
  4271. __declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
  4272. __declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
  4274. inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
  4275. __declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
  4276. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
  4277. __declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
  4278. __declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
  4279. __declspec(dllexport) TInt Val(TReal32& aVal);
  4280. __declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
  4281. __declspec(dllexport) TInt Val(TReal64& aVal);
  4282. __declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
  4283. inline void Assign(const TLex16& aLex);
  4284. __declspec(dllexport) void Assign(const TUint16* aString);
  4285. __declspec(dllexport) void Assign(const TDesC16& aDes);
  4286. TInt Val(TRealX& aVal);
  4287. TInt Val(TRealX& aVal, TChar aPoint);
  4290. inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
  4293. inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
  4296. inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4299. inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
  4300. private:
  4301. void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
  4302. void ValidateMark(const TLexMark16 aMark) const;
  4303. private:
  4304. const TUint16* iNext;
  4305. const TUint16* iBuf;
  4306. const TUint16* iEnd;
  4307. TLexMark16 iMark;
  4308. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4309. };
  4310. #line 1355
  4311. typedef TLex16 TLex;
  4312. #line 1373
  4313. typedef TLexMark16 TLexMark;
  4314. #line 1430
  4315. class TCheckedUid
  4316. {
  4317. public:
  4318. __declspec(dllexport) TCheckedUid();
  4319. __declspec(dllexport) TCheckedUid(const TUidType& aUidType);
  4320. __declspec(dllexport) TCheckedUid(const TDesC8& aPtr);
  4321. __declspec(dllexport) void Set(const TUidType& aUidType);
  4322. __declspec(dllexport) void Set(const TDesC8& aPtr);
  4323. __declspec(dllexport) TPtrC8 Des() const;
  4324. inline const TUidType& UidType() const;
  4325. protected:
  4326. __declspec(dllexport) TUint Check() const;
  4327. private:
  4328. TUidType iType;
  4329. TUint iCheck;
  4330. };
  4331. #line 1469
  4332. class TDateTime
  4333. {
  4334. public:
  4335. inline TDateTime();
  4336. __declspec(dllexport) TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4337. __declspec(dllexport) TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
  4338. __declspec(dllexport) TInt SetYear(TInt aYear);
  4339. __declspec(dllexport) TInt SetYearLeapCheck(TInt aYear);
  4340. __declspec(dllexport) TInt SetMonth(TMonth aMonth);
  4341. __declspec(dllexport) TInt SetDay(TInt aDay);
  4342. __declspec(dllexport) TInt SetHour(TInt aHour);
  4343. __declspec(dllexport) TInt SetMinute(TInt aMinute);
  4344. __declspec(dllexport) TInt SetSecond(TInt aSecond);
  4345. __declspec(dllexport) TInt SetMicroSecond(TInt aMicroSecond);
  4346. inline TInt Year() const;
  4347. inline TMonth Month() const;
  4348. inline TInt Day() const;
  4349. inline TInt Hour() const;
  4350. inline TInt Minute() const;
  4351. inline TInt Second() const;
  4352. inline TInt MicroSecond() const;
  4353. private:
  4354. TInt iYear;
  4355. TMonth iMonth;
  4356. TInt iDay;
  4357. TInt iHour;
  4358. TInt iMinute;
  4359. TInt iSecond;
  4360. TInt iMicroSecond;
  4361. };
  4362. #line 1516
  4363. class TTimeIntervalMicroSeconds
  4364. {
  4365. public:
  4366. inline TTimeIntervalMicroSeconds();
  4367. inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
  4368. inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
  4369. inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
  4370. inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
  4371. inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
  4372. inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
  4373. inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
  4374. inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
  4375. inline const TInt64& Int64() const;
  4376. private:
  4377. TInt64 iInterval;
  4378. };
  4379. #line 1554
  4380. class TTimeIntervalBase
  4381. {
  4382. public:
  4383. inline TBool operator==(TTimeIntervalBase aInterval) const;
  4384. inline TBool operator!=(TTimeIntervalBase aInterval) const;
  4385. inline TBool operator>=(TTimeIntervalBase aInterval) const;
  4386. inline TBool operator<=(TTimeIntervalBase aInterval) const;
  4387. inline TBool operator>(TTimeIntervalBase aInterval) const;
  4388. inline TBool operator<(TTimeIntervalBase aInterval) const;
  4389. inline TInt Int() const;
  4390. protected:
  4391. inline TTimeIntervalBase();
  4392. inline TTimeIntervalBase(TInt aInterval);
  4393. protected:
  4394. TInt iInterval;
  4395. };
  4396. #line 1583
  4397. class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
  4398. {
  4399. public:
  4400. inline TTimeIntervalMicroSeconds32();
  4401. inline TTimeIntervalMicroSeconds32(TInt aInterval);
  4402. inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
  4403. };
  4404. #line 1606
  4405. class TTimeIntervalSeconds : public TTimeIntervalBase
  4406. {
  4407. public:
  4408. inline TTimeIntervalSeconds();
  4409. inline TTimeIntervalSeconds(TInt aInterval);
  4410. inline TTimeIntervalSeconds& operator=(TInt aInterval);
  4411. };
  4412. #line 1626
  4413. class TTimeIntervalMinutes : public TTimeIntervalBase
  4414. {
  4415. public:
  4416. inline TTimeIntervalMinutes();
  4417. inline TTimeIntervalMinutes(TInt aInterval);
  4418. inline TTimeIntervalMinutes& operator=(TInt aInterval);
  4419. };
  4420. #line 1646
  4421. class TTimeIntervalHours : public TTimeIntervalBase
  4422. {
  4423. public:
  4424. inline TTimeIntervalHours();
  4425. inline TTimeIntervalHours(TInt aInterval);
  4426. inline TTimeIntervalHours& operator=(TInt aInterval);
  4427. };
  4428. #line 1666
  4429. class TTimeIntervalDays : public TTimeIntervalBase
  4430. {
  4431. public:
  4432. inline TTimeIntervalDays();
  4433. inline TTimeIntervalDays(TInt aInterval);
  4434. inline TTimeIntervalDays& operator=(TInt aInterval);
  4435. };
  4436. #line 1686
  4437. class TTimeIntervalMonths : public TTimeIntervalBase
  4438. {
  4439. public:
  4440. inline TTimeIntervalMonths();
  4441. inline TTimeIntervalMonths(TInt aInterval);
  4442. inline TTimeIntervalMonths& operator=(TInt aInterval);
  4443. };
  4444. #line 1706
  4445. class TTimeIntervalYears : public TTimeIntervalBase
  4446. {
  4447. public:
  4448. inline TTimeIntervalYears();
  4449. inline TTimeIntervalYears(TInt aInterval);
  4450. inline TTimeIntervalYears& operator=(TInt aInterval);
  4451. };
  4452. #line 1725
  4453. enum {
  4459.      EParseTimePresent=0x1,
  4465.      EParseDatePresent=0x2
  4466.      };
  4467. #line 1770
  4468. class TTime
  4469. {
  4470. public:
  4471. inline TTime();
  4472. inline TTime(const TInt64& aTime);
  4473. __declspec(dllexport) TTime(const TDesC& aString);
  4474. __declspec(dllexport) TTime(const TDateTime& aDateTime);
  4475. inline TTime& operator=(const TInt64& aTime);
  4476. __declspec(dllexport) TTime& operator=(const TDateTime& aDateTime);
  4477. __declspec(dllexport) void HomeTime();
  4478. __declspec(dllexport) void UniversalTime();
  4479. __declspec(dllexport) TInt Set(const TDesC& aString);
  4481. __declspec(dllexport) TDateTime DateTime() const;
  4482. __declspec(dllexport) TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;
  4483. __declspec(dllexport) TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;
  4484. __declspec(dllexport) TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;
  4485. __declspec(dllexport) TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;
  4486. __declspec(dllexport) TTimeIntervalDays DaysFrom(TTime aTime) const;
  4487. __declspec(dllexport) TTimeIntervalMonths MonthsFrom(TTime aTime) const;
  4488. __declspec(dllexport) TTimeIntervalYears YearsFrom(TTime aTime) const;
  4490. __declspec(dllexport) TInt DaysInMonth() const;
  4491. __declspec(dllexport) TDay DayNoInWeek() const;
  4492. __declspec(dllexport) TInt DayNoInMonth() const;
  4493. __declspec(dllexport) TInt DayNoInYear() const;
  4494. __declspec(dllexport) TInt DayNoInYear(TTime aStartDate) const;
  4495. __declspec(dllexport) TInt WeekNoInYear() const;
  4496. __declspec(dllexport) TInt WeekNoInYear(TTime aStartDate) const;
  4497. __declspec(dllexport) TInt WeekNoInYear(TFirstWeekRule aRule) const;
  4498. __declspec(dllexport) TInt WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const;
  4499. __declspec(dllexport) void FormatL(TDes& aDes,const TDesC& aFormat) const;
  4500. __declspec(dllexport) void RoundUpToNextMinute();
  4501. __declspec(dllexport) TInt Parse(const TDesC& aDes,TInt aCenturyOffset=0);
  4503. __declspec(dllexport) TTime operator+(TTimeIntervalYears aYear) const;
  4504. __declspec(dllexport) TTime operator+(TTimeIntervalMonths aMonth) const;
  4505. __declspec(dllexport) TTime operator+(TTimeIntervalDays aDay) const;
  4506. __declspec(dllexport) TTime operator+(TTimeIntervalHours aHour) const;
  4507. __declspec(dllexport) TTime operator+(TTimeIntervalMinutes aMinute) const;
  4508. __declspec(dllexport) TTime operator+(TTimeIntervalSeconds aSecond) const;
  4509. __declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds aMicroSecond) const;
  4510. __declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const;
  4511. __declspec(dllexport) TTime operator-(TTimeIntervalYears aYear) const;
  4512. __declspec(dllexport) TTime operator-(TTimeIntervalMonths aMonth) const;
  4513. __declspec(dllexport) TTime operator-(TTimeIntervalDays aDay) const;
  4514. __declspec(dllexport) TTime operator-(TTimeIntervalHours aHour) const;
  4515. __declspec(dllexport) TTime operator-(TTimeIntervalMinutes aMinute) const;
  4516. __declspec(dllexport) TTime operator-(TTimeIntervalSeconds aSecond) const;
  4517. __declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds aMicroSecond) const;
  4518. __declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const;
  4519. __declspec(dllexport) TTime& operator+=(TTimeIntervalYears aYear);
  4520. __declspec(dllexport) TTime& operator+=(TTimeIntervalMonths aMonth);
  4521. __declspec(dllexport) TTime& operator+=(TTimeIntervalDays aDay);
  4522. __declspec(dllexport) TTime& operator+=(TTimeIntervalHours aHour);
  4523. __declspec(dllexport) TTime& operator+=(TTimeIntervalMinutes aMinute);
  4524. __declspec(dllexport) TTime& operator+=(TTimeIntervalSeconds aSecond);
  4525. __declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds aMicroSecond);
  4526. __declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds32 aMicroSecond);
  4527. __declspec(dllexport) TTime& operator-=(TTimeIntervalYears aYear);
  4528. __declspec(dllexport) TTime& operator-=(TTimeIntervalMonths aMonth);
  4529. __declspec(dllexport) TTime& operator-=(TTimeIntervalDays aDay);
  4530. __declspec(dllexport) TTime& operator-=(TTimeIntervalHours aHour);
  4531. __declspec(dllexport) TTime& operator-=(TTimeIntervalMinutes aMinute);
  4532. __declspec(dllexport) TTime& operator-=(TTimeIntervalSeconds aSecond);
  4533. __declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds aMicroSecond);
  4534. __declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds32 aMicroSecond);
  4535. inline TBool operator==(TTime aTime) const;
  4536. inline TBool operator!=(TTime aTime) const;
  4537. inline TBool operator>=(TTime aTime) const;
  4538. inline TBool operator<=(TTime aTime) const;
  4539. inline TBool operator>(TTime aTime) const;
  4540. inline TBool operator<(TTime aTime) const;
  4541. inline const TInt64& Int64() const;
  4542. private:
  4543. static TTime Convert(const TDateTime& aDateTime);
  4544. private:
  4545. TInt64 iTime;
  4546. public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
  4547. };
  4548. #line 1861
  4549. class Time
  4550. {
  4551. public:
  4552. __declspec(dllexport) static TTime NullTTime();
  4553. __declspec(dllexport) static TTime MaxTTime();
  4554. __declspec(dllexport) static TTime MinTTime();
  4555. __declspec(dllexport) static TInt DaysInMonth(TInt aYear, TMonth aMonth);
  4556. __declspec(dllexport) static TBool IsLeapYear(TInt aYear);
  4557. __declspec(dllexport) static TInt LeapYearsUpTo(TInt aYear);
  4558. };
  4559. #line 1887
  4560. class TDayName : public TBuf<KMaxDayName>
  4561. {
  4562. public:
  4563. __declspec(dllexport) TDayName();
  4564. __declspec(dllexport) TDayName(TDay aDay);
  4565. __declspec(dllexport) void Set(TDay aDay);
  4566. };
  4567. #line 1915
  4568. class TDayNameAbb : public TBuf<KMaxDayNameAbb>
  4569. {
  4570. public:
  4571. __declspec(dllexport) TDayNameAbb();
  4572. __declspec(dllexport) TDayNameAbb(TDay aDay);
  4573. __declspec(dllexport) void Set(TDay aDay);
  4574. };
  4575. #line 1938
  4576. class TMonthName : public TBuf<KMaxMonthName>
  4577. {
  4578. public:
  4579. __declspec(dllexport) TMonthName();
  4580. __declspec(dllexport) TMonthName(TMonth aMonth);
  4581. __declspec(dllexport) void Set(TMonth aMonth);
  4582. };
  4583. #line 1961
  4584. class TMonthNameAbb : public TBuf<KMaxMonthNameAbb>
  4585. {
  4586. public:
  4587. __declspec(dllexport) TMonthNameAbb();
  4588. __declspec(dllexport) TMonthNameAbb(TMonth aMonth);
  4589. __declspec(dllexport) void Set(TMonth aMonth);
  4590. };
  4591. #line 1986
  4592. class TDateSuffix : public TBuf<KMaxSuffix>
  4593. {
  4594. public:
  4595. __declspec(dllexport) TDateSuffix();
  4596. __declspec(dllexport) TDateSuffix(TInt aDateSuffix);
  4597. __declspec(dllexport) void Set(TInt aDateSuffix);
  4598. };
  4599. #line 2010
  4600. class TAmPmName : public TBuf<KMaxAmPmName>
  4601. {
  4602. public:
  4603. __declspec(dllexport) TAmPmName();
  4604. __declspec(dllexport) TAmPmName(TAmPm aSelector);
  4605. __declspec(dllexport) void Set(TAmPm aSelector);
  4606. };
  4607. #line 2031
  4608. class TCurrencySymbol : public TBuf<KMaxCurrencySymbol>
  4609. {
  4610. public:
  4611. __declspec(dllexport) TCurrencySymbol();
  4612. __declspec(dllexport) void Set();
  4613. };
  4614. #line 2067
  4615. class TShortDateFormatSpec : public TBuf<KMaxShortDateFormatSpec>
  4616. {
  4617. public:
  4618. __declspec(dllexport) TShortDateFormatSpec();
  4619. __declspec(dllexport) void Set();
  4620. };
  4621. #line 2103
  4622. class TLongDateFormatSpec : public TBuf<KMaxLongDateFormatSpec>
  4623. {
  4624. public:
  4625. __declspec(dllexport) TLongDateFormatSpec();
  4626. __declspec(dllexport) void Set();
  4627. };
  4628. #line 2136
  4629. class TTimeFormatSpec : public TBuf<KMaxTimeFormatSpec>
  4630. {
  4631. public:
  4632. __declspec(dllexport) TTimeFormatSpec();
  4633. __declspec(dllexport) void Set();
  4634. };
  4635. #line 2156
  4636. class TLocale
  4637. {
  4638. public:
  4643. enum TNegativeCurrencyFormat
  4644. {
  4648. ELeadingMinusSign,
  4654. EInBrackets,
  4659. ETrailingMinusSign,
  4664. EInterveningMinusSign
  4665. };
  4670. enum
  4671. {
  4677. EFlagNegativeLoseSpace = 0x00000001,
  4684. EFlagNegativeCurrencySymbolOpposite=0x00000002
  4685. };
  4687. enum TDeviceTimeState
  4688. {
  4691. EDeviceUserTime,
  4695. ENITZNetworkTimeSync