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

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

Symbian

开发平台：

C/C++

winscw_uid.inc：源码内容
  1. class PlatSec
  2. {
  4. public:
  5. #line 4509
  6. __declspec(dllexport) static TBool IsCapabilityEnforced(TCapability aCapability);
  14. enum TConfigSetting
  15. {
  16. EPlatSecEnforcement,
  17. EPlatSecDiagnotics,
  18. EPlatSecProcessIsolation,
  19. EPlatSecEnforceSysBin,
  20. };
  21. #line 4535
  22. __declspec(dllexport) static TInt ConfigSetting(TConfigSetting aSetting);
  23. #line 4544
  24. public:
  26. static inline TInt LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
  27. #line 4564
  28. static inline TInt LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps);
  30. static inline TInt CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText);
  32. static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText);
  34. static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText);
  36. static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText);
  38. static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing, const char* aContextText);
  40. static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText);
  42. static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText);
  44. static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps, const char* aContextText);
  46. static inline TInt PolicyCheckFail(RSessionBase aSession, const SSecurityInfo& aMissingCaps, const char* aContextText);
  48. static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps, const char* aContextText);
  50. static inline TInt CreatorCapabilityCheckFail(TCapability aCapability);
  52. static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps);
  54. static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability);
  56. static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps);
  58. static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing);
  60. static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability);
  62. static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps);
  64. static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps);
  66. static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps);
  69. private:
  71. __declspec(dllexport) static TInt EmitDiagnostic(TPlatSecDiagnostic& aDiagnostic, const char* aContextText);
  72. #line 4616
  73. public:
  75. __declspec(dllexport) static TInt EmitDiagnostic();
  76. };
  83. struct TEmulatorImageHeader
  84. {
  85. TUid iUids[KMaxCheckedUid];
  86. TProcessPriority iPriority;
  87. SSecurityInfo iS;
  88. TUint32 iSpare1;
  89. TUint32 iSpare2;
  90. TUint32 iModuleVersion;
  91. TUint32 iFlags;
  92. };
  93. #line 4648
  94. class TProcessMemoryInfo
  95. {
  96. public:
  100. TUint32 iCodeBase;
  106. TUint32 iCodeSize;
  112. TUint32 iConstDataBase;
  119. TUint32 iConstDataSize;
  125. TUint32 iInitialisedDataBase;
  131. TUint32 iInitialisedDataSize;
  137. TUint32 iUninitialisedDataBase;
  143. TUint32 iUninitialisedDataSize;
  144. };
  145. #line 4709
  146. typedef TProcessMemoryInfo TModuleMemoryInfo;
  152. class CBase;
  153. #line 4768
  154. template <class T>
  155. class TArray
  156. {
  157. public:
  158. inline TArray(TInt (*aCount)(const CBase* aPtr),const TAny*(*anAt)(const CBase* aPtr,TInt anIndex),const CBase* aPtr);
  159. inline TInt Count() const;
  160. inline const T& operator[](TInt anIndex) const;
  161. private:
  162. const CBase* iPtr;
  163. TInt (*iCount)(const CBase* aPtr);
  164. const TAny*(*iAt)(const CBase* aPtr,TInt anIndex);
  165. };
  166. #line 4796
  167. typedef TBool (*TGeneralIdentityRelation)(const TAny*, const TAny*);
  168. #line 4812
  169. typedef TInt (*TGeneralLinearOrder)(const TAny*, const TAny*);
  170. #line 4832
  171. template <class T>
  172. class TIdentityRelation
  173. {
  174. public:
  175. inline TIdentityRelation( TBool (*anIdentity)(const T&, const T&) );
  176. inline operator TGeneralIdentityRelation() const;
  177. private:
  178. TGeneralIdentityRelation iIdentity;
  179. };
  180. #line 4857
  181. class DefaultIdentity
  182. {
  183. public:
  184. __declspec(dllexport) static TBool Integer(const TInt&, const TInt&);
  185. __declspec(dllexport) static TBool Des8(const TDesC8&, const TDesC8&);
  186. __declspec(dllexport) static TBool Des16(const TDesC16&, const TDesC16&);
  187. };
  188. #line 4883
  189. template <class T>
  190. class TLinearOrder
  191. {
  192. public:
  193. inline TLinearOrder( TInt(*anOrder)(const T&, const T&) );
  194. inline operator TGeneralLinearOrder() const;
  195. private:
  196. TGeneralLinearOrder iOrder;
  197. };
  198. #line 4913
  199. enum TArrayFindMode
  200. {
  201. #line 4923
  202. EArrayFindMode_Any = 0,
  208. EArrayFindMode_First = 1,
  214. EArrayFindMode_Last = 2,
  219. EArrayFindMode_Limit = 3
  220. };
  221. #line 4954
  222. class RPointerArrayBase
  223. {
  224. protected:
  225. __declspec(dllexport) RPointerArrayBase();
  226. __declspec(dllexport) RPointerArrayBase(TInt aGranularity);
  227. __declspec(dllexport) RPointerArrayBase(TInt aMinGrowBy, TInt aFactor);
  228. __declspec(dllexport) void Close();
  229. __declspec(dllexport) TInt Count() const;
  230. inline void ZeroCount() {iCount=0;}
  231. inline TAny** Entries() {return iEntries;}
  232. __declspec(dllexport) TAny*& At(TInt anIndex) const;
  233. __declspec(dllexport) TInt Append(const TAny* anEntry);
  234. __declspec(dllexport) TInt Insert(const TAny* anEntry, TInt aPos);
  235. __declspec(dllexport) void Remove(TInt anIndex);
  236. __declspec(dllexport) void Compress();
  237. __declspec(dllexport) void Reset();
  238. __declspec(dllexport) TInt Find(const TAny* anEntry) const;
  239. __declspec(dllexport) TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const;
  240. __declspec(dllexport) TInt FindIsqSigned(TInt anEntry) const;
  241. __declspec(dllexport) TInt FindIsqUnsigned(TUint anEntry) const;
  242. __declspec(dllexport) TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const;
  243. __declspec(dllexport) TInt FindIsqSigned(TInt anEntry, TInt aMode) const;
  244. __declspec(dllexport) TInt FindIsqUnsigned(TUint anEntry, TInt aMode) const;
  245. __declspec(dllexport) TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const;
  246. __declspec(dllexport) TInt InsertIsqSigned(TInt anEntry, TBool aAllowRepeats);
  247. __declspec(dllexport) TInt InsertIsqUnsigned(TUint anEntry, TBool aAllowRepeats);
  248. __declspec(dllexport) TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats);
  249. __declspec(dllexport) TInt BinarySearchSigned(TInt anEntry, TInt& anIndex) const;
  250. __declspec(dllexport) TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex) const;
  251. __declspec(dllexport) TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const;
  252. __declspec(dllexport) TInt BinarySearchSigned(TInt anEntry, TInt& anIndex, TInt aMode) const;
  253. __declspec(dllexport) TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex, TInt aMode) const;
  254. __declspec(dllexport) TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const;
  256. __declspec(dllexport) RPointerArrayBase(TAny** aEntries, TInt aCount);
  257. __declspec(dllexport) void GranularCompress();
  258. __declspec(dllexport) TInt DoReserve(TInt aCount);
  259. __declspec(dllexport) void HeapSortSigned();
  260. __declspec(dllexport) void HeapSortUnsigned();
  261. __declspec(dllexport) void HeapSort(TGeneralLinearOrder anOrder);
  262. __declspec(dllexport) static TInt GetCount(const CBase* aPtr);
  263. __declspec(dllexport) static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex);
  265. private:
  266. TInt Grow();
  267. private:
  268. TInt iCount;
  269. TAny** iEntries;
  270. TInt iAllocated;
  271. TInt iGranularity;
  272. TInt iSpare1;
  273. TInt iSpare2;
  274. };
  275. #line 5024
  276. template <class T>
  277. class RPointerArray : private RPointerArrayBase
  278. {
  279. public:
  280. inline RPointerArray();
  281. inline explicit RPointerArray(TInt aGranularity);
  282. inline RPointerArray(TInt aMinGrowBy, TInt aFactor);
  283. inline void Close();
  284. inline TInt Count() const;
  285. inline T* const& operator[](TInt anIndex) const;
  286. inline T*& operator[](TInt anIndex);
  287. inline TInt Append(const T* anEntry);
  288. inline TInt Insert(const T* anEntry, TInt aPos);
  289. inline void Remove(TInt anIndex);
  290. inline void Compress();
  291. inline void Reset();
  292. void ResetAndDestroy();
  293. inline TInt Find(const T* anEntry) const;
  294. inline TInt Find(const T* anEntry, TIdentityRelation<T> anIdentity) const;
  295. inline TInt FindInAddressOrder(const T* anEntry) const;
  296. inline TInt FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const;
  297. inline TInt FindInAddressOrder(const T* anEntry, TInt& anIndex) const;
  298. inline TInt FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  299. template <class K>
  300. inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const
  301. { return RPointerArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T> *)&apfnCompare); }
  302. inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const;
  303. inline TInt SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  304. inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const;
  305. inline TInt SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  306. inline TInt InsertInAddressOrder(const T* anEntry);
  307. inline TInt InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder);
  308. inline TInt InsertInAddressOrderAllowRepeats(const T* anEntry);
  309. inline TInt InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder);
  311. inline void AppendL(const T* anEntry);
  312. inline void InsertL(const T* anEntry, TInt aPos);
  313. inline TInt FindL(const T* anEntry) const;
  314. inline TInt FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const;
  315. inline TInt FindInAddressOrderL(const T* anEntry) const;
  316. inline TInt FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const;
  317. inline void FindInAddressOrderL(const T* anEntry, TInt& anIndex) const;
  318. inline void FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  319. inline TInt SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const;
  320. inline TInt SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  321. inline void SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const;
  322. inline void SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  323. inline void InsertInAddressOrderL(const T* anEntry);
  324. inline void InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder);
  325. inline void InsertInAddressOrderAllowRepeatsL(const T* anEntry);
  326. inline void InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder);
  328. inline RPointerArray(T** aEntries, TInt aCount);
  329. inline void GranularCompress();
  330. inline TInt Reserve(TInt aCount);
  331. inline void ReserveL(TInt aCount);
  332. inline void SortIntoAddressOrder();
  333. inline void Sort(TLinearOrder<T> anOrder);
  334. inline TArray<T*> Array() const;
  336. };
  337. #line 5099
  338. template<> class RPointerArray<TAny> : private RPointerArrayBase
  339. {
  340. public:
  341. inline RPointerArray();
  342. inline explicit RPointerArray(TInt aGranularity);
  343. inline RPointerArray(TInt aMinGrowBy, TInt aFactor);
  344. inline void Close();
  345. inline TInt Count() const;
  346. inline TAny* const& operator[](TInt anIndex) const;
  347. inline TAny*& operator[](TInt anIndex);
  348. inline TInt Append(const TAny* anEntry);
  349. inline TInt Insert(const TAny* anEntry, TInt aPos);
  350. inline void Remove(TInt anIndex);
  351. inline void Compress();
  352. inline void Reset();
  353. inline TInt Find(const TAny* anEntry) const;
  354. inline TInt FindInAddressOrder(const TAny* anEntry) const;
  355. inline TInt FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const;
  356. inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const;
  357. inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
  358. inline TInt InsertInAddressOrder(const TAny* anEntry);
  359. inline TInt InsertInAddressOrderAllowRepeats(const TAny* anEntry);
  361. inline void AppendL(const TAny* anEntry);
  362. inline void InsertL(const TAny* anEntry, TInt aPos);
  363. inline TInt FindL(const TAny* anEntry) const;
  364. inline TInt FindInAddressOrderL(const TAny* anEntry) const;
  365. inline void FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const;
  366. inline TInt SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const;
  367. inline void SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
  368. inline void InsertInAddressOrderL(const TAny* anEntry);
  369. inline void InsertInAddressOrderAllowRepeatsL(const TAny* anEntry);
  371. inline RPointerArray(TAny** aEntries, TInt aCount);
  372. inline void GranularCompress();
  373. inline void SortIntoAddressOrder();
  374. inline TArray<TAny*> Array() const;
  376. };
  377. #line 5150
  378. class RArrayBase
  379. {
  380. protected:
  381. __declspec(dllexport) RArrayBase(TInt anEntrySize);
  382. __declspec(dllexport) RArrayBase(TInt anEntrySize, TInt aGranularity);
  383. __declspec(dllexport) RArrayBase(TInt anEntrySize, TInt aGranularity, TInt aKeyOffset);
  384. __declspec(dllexport) RArrayBase(TInt anEntrySize, TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
  385. __declspec(dllexport) void Close();
  386. __declspec(dllexport) TInt Count() const;
  387. __declspec(dllexport) TAny* At(TInt anIndex) const;
  388. __declspec(dllexport) TInt Append(const TAny* anEntry);
  389. __declspec(dllexport) TInt Insert(const TAny* anEntry, TInt aPos);
  390. __declspec(dllexport) void Remove(TInt anIndex);
  391. __declspec(dllexport) void Compress();
  392. __declspec(dllexport) void Reset();
  393. __declspec(dllexport) TInt Find(const TAny* anEntry) const;
  394. __declspec(dllexport) TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const;
  395. __declspec(dllexport) TInt FindIsqSigned(const TAny* anEntry) const;
  396. __declspec(dllexport) TInt FindIsqUnsigned(const TAny* anEntry) const;
  397. __declspec(dllexport) TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const;
  398. __declspec(dllexport) TInt FindIsqSigned(const TAny* anEntry, TInt aMode) const;
  399. __declspec(dllexport) TInt FindIsqUnsigned(const TAny* anEntry, TInt aMode) const;
  400. __declspec(dllexport) TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const;
  401. __declspec(dllexport) TInt InsertIsqSigned(const TAny* anEntry, TBool aAllowRepeats);
  402. __declspec(dllexport) TInt InsertIsqUnsigned(const TAny* anEntry, TBool aAllowRepeats);
  403. __declspec(dllexport) TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats);
  404. __declspec(dllexport) TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex) const;
  405. __declspec(dllexport) TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex) const;
  406. __declspec(dllexport) TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const;
  407. __declspec(dllexport) TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
  408. __declspec(dllexport) TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const;
  409. __declspec(dllexport) TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const;
  411. __declspec(dllexport) RArrayBase(TInt aEntrySize,TAny* aEntries, TInt aCount);
  412. __declspec(dllexport) void GranularCompress();
  413. __declspec(dllexport) TInt DoReserve(TInt aCount);
  414. __declspec(dllexport) void HeapSortSigned();
  415. __declspec(dllexport) void HeapSortUnsigned();
  416. __declspec(dllexport) void HeapSort(TGeneralLinearOrder anOrder);
  417. __declspec(dllexport) static TInt GetCount(const CBase* aPtr);
  418. __declspec(dllexport) static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex);
  420. private:
  421. TInt Grow();
  422. private:
  423. TInt iCount;
  424. TAny* iEntries;
  425. TInt iEntrySize;
  426. TInt iKeyOffset;
  427. TInt iAllocated;
  428. TInt iGranularity;
  429. TInt iSpare1;
  430. TInt iSpare2;
  431. };
  432. #line 5244
  433. template <class T>
  434. class RArray : private RArrayBase
  435. {
  436. public:
  437. inline RArray();
  438. inline explicit RArray(TInt aGranularity);
  439. inline RArray(TInt aGranularity, TInt aKeyOffset);
  440. inline RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor);
  441. inline void Close();
  442. inline TInt Count() const;
  443. inline const T& operator[](TInt anIndex) const;
  444. inline T& operator[](TInt anIndex);
  445. inline TInt Append(const T& anEntry);
  446. inline TInt Insert(const T& anEntry, TInt aPos);
  447. inline void Remove(TInt anIndex);
  448. inline void Compress();
  449. inline void Reset();
  450. inline TInt Find(const T& anEntry) const;
  451. inline TInt Find(const T& anEntry, TIdentityRelation<T> anIdentity) const;
  452. inline TInt FindInSignedKeyOrder(const T& anEntry) const;
  453. inline TInt FindInUnsignedKeyOrder(const T& anEntry) const;
  454. inline TInt FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const;
  455. inline TInt FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  456. inline TInt FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const;
  457. inline TInt FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  458. template <class K>
  459. inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const
  460. { return RArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T> *)&apfnCompare); }
  461. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const;
  462. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const;
  463. inline TInt SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  464. inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  465. inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const;
  466. inline TInt SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  467. inline TInt InsertInSignedKeyOrder(const T& anEntry);
  468. inline TInt InsertInUnsignedKeyOrder(const T& anEntry);
  469. inline TInt InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder);
  470. inline TInt InsertInSignedKeyOrderAllowRepeats(const T& anEntry);
  471. inline TInt InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry);
  472. inline TInt InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder);
  474. inline void AppendL(const T& anEntry);
  475. inline void InsertL(const T& anEntry, TInt aPos);
  476. inline TInt FindL(const T& anEntry) const;
  477. inline TInt FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const;
  478. inline TInt FindInSignedKeyOrderL(const T& anEntry) const;
  479. inline TInt FindInUnsignedKeyOrderL(const T& anEntry) const;
  480. inline TInt FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const;
  481. inline void FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  482. inline void FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const;
  483. inline void FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const;
  484. inline TInt SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const;
  485. inline TInt SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const;
  486. inline TInt SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const;
  487. inline void SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  488. inline void SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const;
  489. inline void SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const;
  490. inline void InsertInSignedKeyOrderL(const T& anEntry);
  491. inline void InsertInUnsignedKeyOrderL(const T& anEntry);
  492. inline void InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder);
  493. inline void InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry);
  494. inline void InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry);
  495. inline void InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder);
  497. inline RArray(TInt aEntrySize,T* aEntries, TInt aCount);
  498. inline void GranularCompress();
  499. inline TInt Reserve(TInt aCount);
  500. inline void ReserveL(TInt aCount);
  501. inline void SortSigned();
  502. inline void SortUnsigned();
  503. inline void Sort(TLinearOrder<T> anOrder);
  504. inline TArray<T> Array() const;
  506. };
  507. #line 5331
  508. template<> class RArray<TInt> : private RPointerArrayBase
  509. {
  510. public:
  511. inline RArray();
  512. inline explicit RArray(TInt aGranularity);
  513. inline RArray(TInt aMinGrowBy, TInt aFactor);
  514. inline void Close();
  515. inline TInt Count() const;
  516. inline const TInt& operator[](TInt anIndex) const;
  517. inline TInt& operator[](TInt anIndex);
  518. inline TInt Append(TInt anEntry);
  519. inline TInt Insert(TInt anEntry, TInt aPos);
  520. inline void Remove(TInt anIndex);
  521. inline void Compress();
  522. inline void Reset();
  523. inline TInt Find(TInt anEntry) const;
  524. inline TInt FindInOrder(TInt anEntry) const;
  525. inline TInt FindInOrder(TInt anEntry, TInt& anIndex) const;
  526. inline TInt SpecificFindInOrder(TInt anEntry, TInt aMode) const;
  527. inline TInt SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const;
  528. inline TInt InsertInOrder(TInt anEntry);
  529. inline TInt InsertInOrderAllowRepeats(TInt anEntry);
  531. inline void AppendL(TInt anEntry);
  532. inline void InsertL(TInt anEntry, TInt aPos);
  533. inline TInt FindL(TInt anEntry) const;
  534. inline TInt FindInOrderL(TInt anEntry) const;
  535. inline void FindInOrderL(TInt anEntry, TInt& anIndex) const;
  536. inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const;
  537. inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const;
  538. inline void InsertInOrderL(TInt anEntry);
  539. inline void InsertInOrderAllowRepeatsL(TInt anEntry);
  541. inline RArray(TInt* aEntries, TInt aCount);
  542. inline void GranularCompress();
  543. inline TInt Reserve(TInt aCount);
  544. inline void ReserveL(TInt aCount);
  545. inline void Sort();
  546. inline TArray<TInt> Array() const;
  548. };
  549. #line 5387
  550. template<> class RArray<TUint> : private RPointerArrayBase
  551. {
  552. public:
  553. inline RArray();
  554. inline explicit RArray(TInt aGranularity);
  555. inline RArray(TInt aMinGrowBy, TInt aFactor);
  556. inline void Close();
  557. inline TInt Count() const;
  558. inline const TUint& operator[](TInt anIndex) const;
  559. inline TUint& operator[](TInt anIndex);
  560. inline TInt Append(TUint anEntry);
  561. inline TInt Insert(TUint anEntry, TInt aPos);
  562. inline void Remove(TInt anIndex);
  563. inline void Compress();
  564. inline void Reset();
  565. inline TInt Find(TUint anEntry) const;
  566. inline TInt FindInOrder(TUint anEntry) const;
  567. inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const;
  568. inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const;
  569. inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const;
  570. inline TInt InsertInOrder(TUint anEntry);
  571. inline TInt InsertInOrderAllowRepeats(TUint anEntry);
  573. inline void AppendL(TUint anEntry);
  574. inline void InsertL(TUint anEntry, TInt aPos);
  575. inline TInt FindL(TUint anEntry) const;
  576. inline TInt FindInOrderL(TUint anEntry) const;
  577. inline void FindInOrderL(TUint anEntry, TInt& anIndex) const;
  578. inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const;
  579. inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const;
  580. inline void InsertInOrderL(TUint anEntry);
  581. inline void InsertInOrderAllowRepeatsL(TUint anEntry);
  583. inline RArray(TUint* aEntries, TInt aCount);
  584. inline void GranularCompress();
  585. inline TInt Reserve(TInt aCount);
  586. inline void ReserveL(TInt aCount);
  587. inline void Sort();
  588. inline TArray<TUint> Array() const;
  590. };
  591. #line 5822
  592. extern TAny* operator new(TUint aSize) throw() ;
  598. extern TAny* operator new(TUint aSize,TUint anExtraSize) throw() ;
  604. extern void operator delete(TAny* aPtr) throw() ;
  611. extern TAny* operator new[](TUint aSize) throw() ;
  617. extern void operator delete[](TAny* aPtr) throw() ;
  624. inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
  631. inline TAny* operator new[](TUint aSize, TAny* aBase) throw() ;
  639. inline void operator delete(TAny* aPtr, TAny* aBase) throw() ;
  646. inline void operator delete[](TAny* aPtr, TAny* aBase) throw() ;
  647. #line 5886
  648. TBool operator==(TTrue,volatile const TBool);
  654. TBool operator==(volatile const TBool,TTrue);
  660. TBool operator!=(TTrue,volatile const TBool);
  666. TBool operator!=(volatile const TBool,TTrue);
  667. #line 5928
  668. class TIpcArgs
  669. {
  670. public:
  677. enum TArgType
  678. {
  679. EUnspecified = 0,
  680. EHandle = 1,
  681. EFlagDes = 4,
  682. EFlagConst = 2,
  683. EFlag16Bit = 1,
  684. EDes8 = EFlagDes,
  685. EDes16 = EFlagDes|EFlag16Bit,
  686. EDesC8 = EFlagDes|EFlagConst,
  687. EDesC16 = EFlagDes|EFlagConst|EFlag16Bit,
  688. };
  696. enum {
  697.      KBitsPerType=3
  698.      };
  704. enum TNothing {
  705. #line 5976
  706.               ENothing
  707.               };
  708. public:
  716. inline TIpcArgs()
  717. :iFlags(0)
  718. {}
  719. #line 5998
  720. template <class T0>
  721. inline explicit TIpcArgs(T0 a0)
  722. {
  723. Assign(iArgs[0],a0);
  724. iFlags=(Type(a0)<<(0*KBitsPerType));
  725. }
  726. #line 6015
  727. template <class T0,class T1>
  728. inline TIpcArgs(T0 a0,T1 a1)
  729. {
  730. Assign(iArgs[0],a0);
  731. Assign(iArgs[1],a1);
  732. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType));
  733. }
  734. #line 6035
  735. template <class T0,class T1,class T2>
  736. inline TIpcArgs(T0 a0,T1 a1,T2 a2)
  737. {
  738. Assign(iArgs[0],a0);
  739. Assign(iArgs[1],a1);
  740. Assign(iArgs[2],a2);
  741. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType));
  742. }
  743. #line 6058
  744. template <class T0,class T1,class T2,class T3>
  745. inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3)
  746. {
  747. Assign(iArgs[0],a0);
  748. Assign(iArgs[1],a1);
  749. Assign(iArgs[2],a2);
  750. Assign(iArgs[3],a3);
  751. iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType))|(Type(a3)<<(3*KBitsPerType));
  752. }
  754. inline void Set(TInt aIndex,TNothing);
  755. inline void Set(TInt aIndex,TInt aValue);
  756. inline void Set(TInt aIndex,const TAny* aValue);
  757. inline void Set(TInt aIndex,RHandleBase aValue);
  758. inline void Set(TInt aIndex,const TDesC8* aValue);
  760. inline void Set(TInt aIndex,const TDesC16* aValue);
  762. inline void Set(TInt aIndex,TDes8* aValue);
  764. inline void Set(TInt aIndex,TDes16* aValue);
  766. private:
  767. inline static TArgType Type(TNothing);
  768. inline static TArgType Type(TInt);
  769. inline static TArgType Type(const TAny*);
  770. inline static TArgType Type(RHandleBase aValue);
  771. inline static TArgType Type(const TDesC8*);
  773. inline static TArgType Type(const TDesC16*);
  775. inline static TArgType Type(TDes8*);
  777. inline static TArgType Type(TDes16*);
  780. inline static void Assign(TInt&,TNothing);
  781. inline static void Assign(TInt& aArg,TInt aValue);
  782. inline static void Assign(TInt& aArg,const TAny* aValue);
  783. inline static void Assign(TInt& aArg,RHandleBase aValue);
  784. inline static void Assign(TInt& aArg,const TDesC8* aValue);
  786. inline static void Assign(TInt& aArg,const TDesC16* aValue);
  788. inline static void Assign(TInt& aArg,TDes8* aValue);
  790. inline static void Assign(TInt& aArg,TDes16* aValue);
  792. public:
  800. TInt iArgs[KMaxMessageArguments];
  801. #line 6123
  802. TInt iFlags;
  803. };
  810. struct SInt64
  811. {
  812. public:
  813. inline SInt64();
  814. inline SInt64(Int64 a);
  815. inline SInt64& operator=(Int64 a);
  816. inline operator Int64() const;
  817. public:
  818. TUint32 iData[2];
  819. };
  824. struct SUint64
  825. {
  826. public:
  827. inline SUint64();
  828. inline SUint64(Uint64 a);
  829. inline SUint64& operator=(Uint64 a);
  830. inline operator Uint64() const;
  831. public:
  832. TUint32 iData[2];
  833. };
  838. struct SDouble
  839. {
  840. public:
  841. inline SDouble();
  842. inline SDouble(TReal a);
  843. inline SDouble& operator=(TReal a);
  844. inline operator TReal() const;
  845. public:
  846. TUint32 iData[2];
  847. };
  848. #line 6181
  849. class TThreadStackInfo
  850. {
  851. public:
  855. TLinAddr iBase;
  861. TLinAddr iLimit;
  868. TLinAddr iExpandLimit;
  869. };
  870. #line 6214
  871. class XLeaveException
  872. {
  873. public:
  874. inline XLeaveException() {}
  875. inline XLeaveException(TInt aReason) {iR = aReason;}
  876. inline TInt Reason() const {return iR;}
  877. __declspec(dllexport) TInt GetReason() const;
  878. private:
  879. #line 6230
  880. private:
  882. TAny* iVtable;
  884. TInt iR;
  885. };
  892. namespace std {
  893.   bool uncaught_exception(void);
  894.   void terminate(void);
  895.   void unexpected(void);
  896.   typedef void (*terminate_handler)();
  897.   terminate_handler set_terminate(terminate_handler h) throw();
  898.   typedef void (*unexpected_handler)();
  899.   unexpected_handler set_unexpected(unexpected_handler h) throw();
  900. }
  908. class __UnknownWindowsType1;
  909. class __UnknownWindowsType2;
  912. class TWin32SEHTrap;
  918. typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  923. class TWin32SEHTrap
  924. {
  925. private:
  927.     TWin32SEHTrap(TWin32SEHTrap const &);
  928.     TWin32SEHTrap& operator=(TWin32SEHTrap const &);
  929. #line 6297
  930. public:
  931. __declspec(dllexport) TWin32SEHTrap();
  933. public:
  935. __declspec(dllexport) void Trap();
  938. __declspec(dllexport) void UnTrap();
  941. private:
  944. static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
  951.     TWin32SEHTrap* iPrevExceptionRegistrationRecord;
  952. TWin32SEHExceptionHandler* iExceptionHandler;
  954. private:
  955. TUint32 iPadding[254];
  956. };
  957. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.inl" /* stack depth 2 */
  958. #line 9
  959. inline TAny* operator new(TUint , TAny* aBase) throw()
  960. {return aBase;}
  963. inline void operator delete(TAny* , TAny* ) throw()
  964. {}
  970. inline TAny* operator new[](TUint , TAny* aBase) throw()
  971. {return aBase;}
  974. inline void operator delete[](TAny* , TAny* ) throw()
  975. {}
  980. inline RAllocator::RAllocator()
  981. {
  982. iAccessCount=1;
  983. iHandleCount=0;
  984. iHandles=0;
  985. iFlags=0;
  986. iCellCount=0;
  987. iTotalAllocSize=0;
  988. }
  989. inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)
  990. {__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}
  993. inline RHeap::RHeap()
  994. {}
  999. inline TInt RHeap::MaxLength() const
  1003. {return iMaxLength;}
  1006. inline void RHeap::operator delete(TAny*, TAny*)
  1011. {}
  1014. inline TUint8* RHeap::Base() const
  1015. #line 73
  1016. {return iBase;}
  1021. inline TInt RHeap::Size() const
  1022. #line 89
  1023. {return iTop-iBase;}
  1028. inline TInt RHeap::Align(TInt a) const
  1032. {return (((a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  1037. inline const TAny* RHeap::Align(const TAny* a) const
  1041. {return (const TAny*)((((TLinAddr)a)+( iAlign)-1)&~(( iAlign)-1)) ;}
  1046. inline TBool RHeap::IsLastCell(const SCell* aCell) const
  1050. {return (((TUint8*)aCell) + aCell->len) == iTop;}
  1056. inline void RHeap::Lock() const
  1060. {((RFastLock&)iLock).Wait();}
  1065. inline void RHeap::Unlock() const
  1069. {((RFastLock&)iLock).Signal();}
  1076. template <class T>
  1077. inline TRefByValue<T>::TRefByValue(T &aRef)
  1078. : iRef(aRef)
  1084. {}
  1089. template <class T>
  1090. inline TRefByValue<T>::operator T &()
  1094. {return(iRef);}
  1095. #line 201
  1096. inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)
  1097. { return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }
  1103. inline TChar::TChar()
  1109. {}
  1114. inline TChar::TChar(TUint aChar)
  1115. : iChar(aChar)
  1121. {}
  1126. inline TChar& TChar::operator-=(TUint aChar)
  1127. #line 241
  1128. {iChar-=aChar;return(*this);}
  1133. inline TChar& TChar::operator+=(TUint aChar)
  1134. #line 256
  1135. {iChar+=aChar;return(*this);}
  1140. inline TChar TChar::operator-(TUint aChar)
  1141. #line 273
  1142. {return(iChar-aChar);}
  1147. inline TChar TChar::operator+(TUint aChar)
  1148. #line 288
  1149. {return(iChar+aChar);}
  1154. inline TChar::operator TUint() const
  1161. {return(iChar);}
  1167. inline TBool TDesC8::operator<(const TDesC8 &aDes) const
  1168. #line 320
  1169. {return(Compare(aDes)<0);}
  1174. inline TBool TDesC8::operator<=(const TDesC8 &aDes) const
  1175. #line 339
  1176. {return(Compare(aDes)<=0);}
  1181. inline TBool TDesC8::operator>(const TDesC8 &aDes) const
  1182. #line 358
  1183. {return(Compare(aDes)>0);}
  1188. inline TBool TDesC8::operator>=(const TDesC8 &aDes) const
  1189. #line 377
  1190. {return(Compare(aDes)>=0);}
  1195. inline TBool TDesC8::operator==(const TDesC8 &aDes) const
  1196. #line 396
  1197. {return(Compare(aDes)==0);}
  1202. inline TBool TDesC8::operator!=(const TDesC8 &aDes) const
  1203. #line 415
  1204. {return(Compare(aDes)!=0);}
  1209. inline const TUint8 &TDesC8::operator[](TInt anIndex) const
  1210. #line 433
  1211. {return(AtC(anIndex));}
  1216. inline TInt TDesC8::Length() const
  1224. {return(iLength&KMaskDesLength8);}
  1229. inline TInt TDesC8::Size() const
  1237. {return(Length());}
  1242. inline void TDesC8::DoSetLength(TInt aLength)
  1243. {iLength=(iLength&(~KMaskDesLength8))|aLength;}
  1249. inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)
  1250. #line 483
  1251. {new(this) TPtrC8(aBuf,aLength);}
  1256. inline void TPtrC8::Set(const TDesC8 &aDes)
  1264. {new(this) TPtrC8(aDes);}
  1269. inline void TPtrC8::Set(const TPtrC8& aPtr)
  1270. #line 510
  1271. {new(this) TPtrC8(aPtr);}
  1278. inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)
  1279. {return TPtr8(*this,aMaxLength);}
  1285. template <TInt S>
  1286. inline TBufC8<S>::TBufC8()
  1287. : TBufCBase8()
  1288. #line 540
  1289. {}
  1294. template <TInt S>
  1295. inline TBufC8<S>::TBufC8(const TUint8 *aString)
  1296. : TBufCBase8(aString,S)
  1297. #line 564
  1298. {}
  1303. template <TInt S>
  1304. inline TBufC8<S>::TBufC8(const TDesC8 &aDes)
  1305. : TBufCBase8(aDes,S)
  1306. #line 588
  1307. {}
  1312. template <TInt S>
  1313. inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)
  1314. #line 607
  1315. {Copy(aString,S);return(*this);}
  1320. template <TInt S>
  1321. inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)
  1322. #line 626
  1323. {Copy(aDes,S);return(*this);}
  1328. template <TInt S>
  1329. inline TPtr8 TBufC8<S>::Des()
  1330. #line 656
  1331. {return DoDes(S);}
  1338. inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)
  1339. #line 681
  1340. {return *this=static_cast<const TDesC8&>(aLcb);}
  1341. #line 710
  1342. inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)
  1343. {
  1344. Assign(HBufC8::NewL(aStream,aMaxLength));
  1345. }
  1352. inline TDes8 &TDes8::operator=(const TUint8 *aString)
  1353. #line 733
  1354.     {Copy(aString);return(*this);}
  1359. inline TDes8 &TDes8::operator=(const TDesC8 &aDes)
  1360. #line 751
  1361.     {Copy(aDes);return(*this);}
  1366. inline TDes8 &TDes8::operator=(const TDes8 &aDes)
  1367. #line 769
  1368.     {Copy(aDes);return(*this);}
  1373. inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)
  1374. #line 788
  1375. {Append(aDes);return(*this);}
  1380. inline const TUint8 &TDes8::operator[](TInt anIndex) const
  1381. #line 806
  1382. {return(AtC(anIndex));}
  1387. inline TUint8 &TDes8::operator[](TInt anIndex)
  1388. #line 825
  1389. {return((TUint8 &)AtC(anIndex));}
  1394. inline TInt TDes8::MaxLength() const
  1395. #line 839
  1396. {return(iMaxLength);}
  1401. inline TInt TDes8::MaxSize() const
  1402. #line 853
  1403. {return(iMaxLength);}
  1408. inline TUint8 * TDes8::WPtr() const
  1409. {return((TUint8 *)Ptr());}
  1415. inline TPtr8 &TPtr8::operator=(const TUint8 *aString)
  1416. #line 879
  1417. {Copy(aString);return(*this);}
  1422. inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)
  1423. #line 899
  1424. {Copy(aDes);return(*this);}
  1429. inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)
  1430. #line 919
  1431. {Copy(aDes);return(*this);}
  1436. inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)
  1437. #line 940
  1438. {new(this) TPtr8(aBuf,aLength,aMaxLength);}
  1443. inline void TPtr8::Set(const TPtr8 &aPtr)
  1444. #line 955
  1445. {new(this) TPtr8(aPtr);}
  1451. template <TInt S>
  1452. inline TBuf8<S>::TBuf8()
  1453. : TBufBase8(S)
  1454. #line 972
  1455. {}
  1460. template <TInt S>
  1461. inline TBuf8<S>::TBuf8(TInt aLength)
  1462. : TBufBase8(aLength,S)
  1463. #line 994
  1464. {}
  1469. template <TInt S>
  1470. inline TBuf8<S>::TBuf8(const TUint8 *aString)
  1471. : TBufBase8(aString,S)
  1472. #line 1018
  1473. {}
  1478. template <TInt S>
  1479. inline TBuf8<S>::TBuf8(const TDesC8 &aDes)
  1480. : TBufBase8(aDes,S)
  1481. #line 1042
  1482. {}
  1487. template <TInt S>
  1488. inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)
  1489. #line 1062
  1490. {Copy(aString);return(*this);}
  1495. template <TInt S>
  1496. inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)
  1497. #line 1082
  1498. {Copy(aDes);return(*this);}
  1503. template <TInt S>
  1504. inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)
  1505. #line 1100
  1506. {Copy(aBuf);return *this;}
  1512. template <TInt S>
  1513. inline TAlignedBuf8<S>::TAlignedBuf8()
  1514. : TBufBase8(S)
  1515. #line 1117
  1516. {}
  1521. template <TInt S>
  1522. inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)
  1523. : TBufBase8(aLength,S)
  1524. #line 1139
  1525. {}
  1530. template <TInt S>
  1531. inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)
  1532. : TBufBase8(aString,S)
  1533. #line 1163
  1534. {}
  1539. template <TInt S>
  1540. inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)
  1541. : TBufBase8(aDes,S)
  1542. #line 1187
  1543. {}
  1548. template <TInt S>
  1549. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)
  1550. #line 1207
  1551. {Copy(aString);return(*this);}
  1556. template <TInt S>
  1557. inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)
  1558. #line 1227
  1559. {Copy(aDes);return(*this);}
  1564. template <TInt S>
  1565. inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)
  1566. #line 1245
  1567. {Copy(aBuf);return *this;}
  1573. template <TInt S>
  1574. inline const TDesC8* TLitC8<S>::operator&() const
  1580. {return (reinterpret_cast<const TDesC8*>(this)) ;}
  1585. template <TInt S>
  1586. inline const TDesC8& TLitC8<S>::operator()() const
  1592. {return *operator&();}
  1597. template <TInt S>
  1598. inline TLitC8<S>::operator const TDesC8&() const
  1603. {return *operator&();}
  1607. template <TInt S>
  1608. inline TLitC8<S>::operator const __TRefDesC8() const
  1615. {return *operator&();}
  1622. inline TBool TDesC16::operator<(const TDesC16 &aDes) const
  1623. #line 1314
  1624. {return(Compare(aDes)<0);}
  1629. inline TBool TDesC16::operator<=(const TDesC16 &aDes) const
  1630. #line 1333
  1631. {return(Compare(aDes)<=0);}
  1636. inline TBool TDesC16::operator>(const TDesC16 &aDes) const
  1637. #line 1352
  1638. {return(Compare(aDes)>0);}
  1643. inline TBool TDesC16::operator>=(const TDesC16 &aDes) const
  1644. #line 1371
  1645. {return(Compare(aDes)>=0);}
  1650. inline TBool TDesC16::operator==(const TDesC16 &aDes) const
  1651. #line 1390
  1652. {return(Compare(aDes)==0);}
  1657. inline TBool TDesC16::operator!=(const TDesC16 &aDes) const
  1658. #line 1409
  1659. {return(Compare(aDes)!=0);}
  1664. inline const TUint16 &TDesC16::operator[](TInt anIndex) const
  1665. #line 1427
  1666. {return(AtC(anIndex));}
  1671. inline TInt TDesC16::Length() const
  1679. {return(iLength&KMaskDesLength16);}
  1684. inline TInt TDesC16::Size() const
  1685. #line 1454
  1686. {return(Length()<<1);}
  1691. inline void TDesC16::DoSetLength(TInt aLength)
  1692. {iLength=(iLength&(~KMaskDesLength16))|aLength;}
  1698. inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)
  1699. #line 1478
  1700. {new(this) TPtrC16(aBuf,aLength);}
  1705. inline void TPtrC16::Set(const TDesC16 &aDes)
  1713. {new(this) TPtrC16(aDes);}
  1718. inline void TPtrC16::Set(const TPtrC16& aPtr)
  1719. {new(this) TPtrC16(aPtr);}
  1725. inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)
  1726. {return TPtr16(*this,aMaxLength);}
  1732. template <TInt S>
  1733. inline TBufC16<S>::TBufC16()
  1734. : TBufCBase16()
  1735. #line 1526
  1736. {}
  1741. template <TInt S>
  1742. inline TBufC16<S>::TBufC16(const TUint16 *aString)
  1743. : TBufCBase16(aString,S)
  1744. #line 1550
  1745. {}
  1750. template <TInt S>
  1751. inline TBufC16<S>::TBufC16(const TDesC16 &aDes)
  1752. : TBufCBase16(aDes,S)
  1753. #line 1574
  1754. {}
  1759. template <TInt S>
  1760. inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)
  1761. #line 1593
  1762. {Copy(aString,S);return(*this);}
  1767. template <TInt S>
  1768. inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)
  1769. #line 1612
  1770. {Copy(aDes,S);return(*this);}
  1775. template <TInt S>
  1776. inline TPtr16 TBufC16<S>::Des()
  1777. #line 1642
  1778. {return(DoDes(S));}
  1785. inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)
  1786. #line 1667
  1787. {return *this=static_cast<const TDesC16&>(aLcb);}
  1794. inline TDes16 &TDes16::operator=(const TUint16 *aString)
  1795. #line 1687
  1796.     {Copy(aString);return(*this);}
  1801. inline TDes16 &TDes16::operator=(const TDesC16 &aDes)
  1802. #line 1705
  1803.     {Copy(aDes);return(*this);}
  1808. inline TDes16 &TDes16::operator=(const TDes16 &aDes)
  1809. #line 1723
  1810.     {Copy(aDes);return(*this);}
  1815. inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)
  1816. #line 1742
  1817. {Append(aDes);return(*this);}
  1822. inline const TUint16 &TDes16::operator[](TInt anIndex) const
  1823. #line 1759
  1824. {return(AtC(anIndex));}
  1829. inline TUint16 &TDes16::operator[](TInt anIndex)
  1830. #line 1778
  1831. {return((TUint16 &)AtC(anIndex));}
  1836. inline TInt TDes16::MaxLength() const
  1837. #line 1792
  1838. {return(iMaxLength);}
  1843. inline TInt TDes16::MaxSize() const
  1844. #line 1806
  1845. {return(iMaxLength<<1);}
  1850. inline TUint16 * TDes16::WPtr() const
  1851. {return((TUint16 *)Ptr());}
  1857. inline TPtr16 &TPtr16::operator=(const TUint16 *aString)
  1858. #line 1832
  1859. {Copy(aString);return(*this);}
  1864. inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)
  1865. #line 1852
  1866. {Copy(aDes);return(*this);}
  1871. inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)
  1872. #line 1872
  1873. {Copy(aDes);return(*this);}
  1878. inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)
  1879. #line 1893
  1880. {new(this) TPtr16(aBuf,aLength,aMaxLength);}
  1885. inline void TPtr16::Set(const TPtr16 &aPtr)
  1886. #line 1908
  1887. {new(this) TPtr16(aPtr);}
  1893. template <TInt S>
  1894. inline TBuf16<S>::TBuf16()
  1895. : TBufBase16(S)
  1896. #line 1925
  1897. {}
  1902. template <TInt S>
  1903. inline TBuf16<S>::TBuf16(TInt aLength)
  1904. : TBufBase16(aLength,S)
  1905. #line 1947
  1906. {}
  1911. template <TInt S>
  1912. inline TBuf16<S>::TBuf16(const TUint16 *aString)
  1913. : TBufBase16(aString,S)
  1914. #line 1971
  1915. {}
  1920. template <TInt S>
  1921. inline TBuf16<S>::TBuf16(const TDesC16 &aDes)
  1922. : TBufBase16(aDes,S)
  1923. #line 1995
  1924. {}
  1929. template <TInt S>
  1930. inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)
  1931. #line 2015
  1932. {Copy(aString);return(*this);}
  1937. template <TInt S>
  1938. inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)
  1939. #line 2035
  1940. {Copy(aDes);return(*this);}
  1945. template <TInt S>
  1946. inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)
  1947. #line 2056
  1948. {Copy(aBuf);return *this;}
  1949. #line 2083
  1950. inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)
  1951. {
  1952. Assign(HBufC16::NewL(aStream,aMaxLength));
  1953. }
  1957. template <TInt S>
  1958. inline const TDesC16* TLitC16<S>::operator&() const
  1964. {return (reinterpret_cast<const TDesC16*>(this)) ;}
  1969. template <TInt S>
  1970. inline const TDesC16& TLitC16<S>::operator()() const
  1976. {return *operator&();}
  1981. template <TInt S>
  1982. inline TLitC16<S>::operator const TDesC16&() const
  1987. {return *operator&();}
  1992. template <TInt S>
  1993. inline TLitC16<S>::operator const __TRefDesC16() const
  2000. {return *operator&();}
  2008. template <TInt S>
  2009. inline TBufC<S>::TBufC()
  2010. : TBufCBase16()
  2011. #line 2157
  2012. {}
  2017. template <TInt S>
  2018. inline TBufC<S>::TBufC(const TText *aString)
  2019. : TBufCBase16(aString,S)
  2020. #line 2186
  2021. {}
  2026. template <TInt S>
  2027. inline TBufC<S>::TBufC(const TDesC &aDes)
  2028. : TBufCBase16(aDes,S)
  2029. #line 2219
  2030. {}
  2031. #line 2234
  2032. template <TInt S>
  2033. inline TBufC<S> &TBufC<S>::operator=(const TText *aString)
  2034. #line 2253
  2035. {Copy(aString,S);return(*this);}
  2040. template <TInt S>
  2041. inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)
  2042. #line 2277
  2043. {Copy(aDes,S);return(*this);}
  2048. template <TInt S>
  2049. inline TPtr TBufC<S>::Des()
  2050. #line 2308
  2051. {return(DoDes(S));}
  2058. template <TInt S>
  2059. inline TBuf<S>::TBuf()
  2060. : TBufBase16(S)
  2068. {}
  2073. template <TInt S>
  2074. inline TBuf<S>::TBuf(TInt aLength)
  2075. : TBufBase16(aLength,S)
  2076. #line 2350
  2077. {}
  2082. template <TInt S>
  2083. inline TBuf<S>::TBuf(const TText *aString)
  2084. : TBufBase16(aString,S)
  2085. #line 2378
  2086. {}
  2091. template <TInt S>
  2092. inline TBuf<S>::TBuf(const TDesC &aDes)
  2093. : TBufBase16(aDes,S)
  2094. #line 2407
  2095. {}
  2096. #line 2426
  2097. template <TInt S>
  2098. inline TBuf<S> &TBuf<S>::operator=(const TText *aString)
  2099. {Copy(aString);return(*this);}
  2100. template <TInt S>
  2101. inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)
  2102. {Copy(aDes);return(*this);}
  2103. template <TInt S>
  2104. inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)
  2105. {Copy(aBuf);return(*this);}
  2111. template <TInt S>
  2112. inline const TDesC* TLitC<S>::operator&() const
  2118. {return (reinterpret_cast<const TDesC*>(this)) ;}
  2123. template <TInt S>
  2124. inline const TDesC& TLitC<S>::operator()() const
  2130. {return *operator&();}
  2135. template <TInt S>
  2136. inline TLitC<S>::operator const TDesC&() const
  2141. {return *operator&();}
  2146. template <TInt S>
  2147. inline TLitC<S>::operator const __TRefDesC() const
  2154. {return *operator&();}
  2160. template <class T>
  2161. inline TPckgC<T>::TPckgC(const T &aRef)
  2162. : TPtrC8((const TUint8 *)&aRef,sizeof(T))
  2170. {}
  2175. template <class T>
  2176. inline const T &TPckgC<T>::operator()() const
  2183. {return(*((const T *)iPtr));}
  2189. template <class T>
  2190. inline TPckg<T>::TPckg(const T &aRef)
  2191. : TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T))
  2199. {}
  2204. template <class T>
  2205. inline T &TPckg<T>::operator()()
  2212. {return(*((T *)iPtr));}
  2218. template <class T>
  2219. inline TPckgBuf<T>::TPckgBuf()
  2220. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  2228. {new(&this->iBuf[0]) T;}
  2233. template <class T>
  2234. inline TPckgBuf<T>::TPckgBuf(const T &aRef)
  2235. : TAlignedBuf8<sizeof(T)>(sizeof(T))
  2236. #line 2576
  2237. {new(&this->iBuf[0]) T(aRef);}
  2242. template <class T>
  2243. inline TPckgBuf<T> &TPckgBuf<T>::operator=(const TPckgBuf<T> &aRef)
  2251. {this->Copy(aRef);return(*this);}
  2256. template <class T>
  2257. inline T &TPckgBuf<T>::operator=(const T &aRef)
  2258. #line 2605
  2259. {this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));}
  2264. template <class T>
  2265. inline T &TPckgBuf<T>::operator()()
  2272. {return(*((T *)&this->iBuf[0]));}
  2277. template <class T>
  2278. inline const T &TPckgBuf<T>::operator()() const
  2285. {return(*((T *)&this->iBuf[0]));}
  2291. inline TRequestStatus::TRequestStatus()
  2295. : iFlags(0)
  2296. {}
  2301. inline TRequestStatus::TRequestStatus(TInt aVal)
  2309. : iStatus(aVal),
  2310. iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0)
  2312. {}
  2317. inline TInt TRequestStatus::operator=(TInt aVal)
  2325. {
  2326. if(aVal==KRequestPending)
  2327. iFlags|=TRequestStatus::ERequestPending;
  2328. else
  2329. iFlags&=~TRequestStatus::ERequestPending;
  2330. return (iStatus=aVal);
  2331. }
  2336. inline TBool TRequestStatus::operator==(TInt aVal) const
  2337. #line 2691
  2338. {return(iStatus==aVal);}
  2343. inline TBool TRequestStatus::operator!=(TInt aVal) const
  2344. #line 2705
  2345. {return(iStatus!=aVal);}
  2350. inline TBool TRequestStatus::operator>=(TInt aVal) const
  2351. #line 2720
  2352. {return(iStatus>=aVal);}
  2357. inline TBool TRequestStatus::operator<=(TInt aVal) const
  2358. #line 2735
  2359. {return(iStatus<=aVal);}
  2364. inline TBool TRequestStatus::operator>(TInt aVal) const
  2365. #line 2750
  2366. {return(iStatus>aVal);}
  2371. inline TBool TRequestStatus::operator<(TInt aVal) const
  2372. #line 2765
  2373. {return(iStatus<aVal);}
  2378. inline TInt TRequestStatus::Int() const
  2384. {return(iStatus);}
  2391. inline TPoint::TPoint()
  2392. : iX(0),iY(0)
  2396. {}
  2401. inline TPoint::TPoint(TInt aX,TInt aY)
  2402. : iX(aX),iY(aY)
  2409. {}
  2415. inline TSize::TSize()
  2416. : iWidth(0),iHeight(0)
  2420. {}
  2425. inline TSize::TSize(TInt aWidth,TInt aHeight)
  2426. : iWidth(aWidth),iHeight(aHeight)
  2433. {}
  2440. inline RHandleBase::RHandleBase()
  2441. : iHandle(0)
  2445. {}
  2451. inline RHandleBase::RHandleBase(TInt aHandle)
  2452. : iHandle(aHandle)
  2453. #line 2853
  2454. {}
  2460. inline void RHandleBase::SetHandle(TInt aHandle)
  2467. { iHandle=aHandle; }
  2472. inline TInt RHandleBase::Handle() const
  2478. {return(iHandle);}
  2483. inline TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError)
  2484. #line 2899
  2485. {
  2486. if(aHandleOrError>=0)
  2487. {
  2488. iHandle = aHandleOrError;
  2489. return KErrNone;
  2490. }
  2491. iHandle = 0;
  2492. return aHandleOrError;
  2493. }
  2500. inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType)
  2501. #line 2935
  2502. {return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));}
  2503. #line 2947
  2504. inline RFastLock::RFastLock()
  2505. : iCount(0)
  2506. {}
  2507. #line 2960
  2508. inline RMessagePtr2::RMessagePtr2()
  2509. : iHandle(0)
  2510. {}
  2511. #line 2972
  2512. inline TBool RMessagePtr2::IsNull() const
  2513. {return iHandle==0;}
  2514. #line 2983
  2515. inline TInt RMessagePtr2::Handle() const
  2516. {return iHandle;}
  2517. inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2518. {return aLeft.Handle()==aRight.Handle();}
  2519. inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight)
  2520. {return aLeft.Handle()!=aRight.Handle();}
  2521. #line 3000
  2522. inline RMessage2::RMessage2()
  2523. {}
  2524. #line 3011
  2525. inline TInt RMessage2::Function() const
  2526. {return(iFunction);}
  2527. #line 3022
  2528. inline TInt RMessage2::Int0() const
  2529. {return(iArgs[0]);}
  2530. #line 3033
  2531. inline TInt RMessage2::Int1() const
  2532. {return(iArgs[1]);}
  2533. #line 3044
  2534. inline TInt RMessage2::Int2() const
  2535. {return(iArgs[2]);}
  2536. #line 3054
  2537. inline TInt RMessage2::Int3() const
  2538. {return(iArgs[3]);}
  2539. #line 3064
  2540. inline const TAny *RMessage2::Ptr0() const
  2541. {return((const TAny *)iArgs[0]);}
  2542. #line 3075
  2543. inline const TAny *RMessage2::Ptr1() const
  2544. {return((const TAny *)iArgs[1]);}
  2545. #line 3086
  2546. inline const TAny *RMessage2::Ptr2() const
  2547. {return((const TAny *)iArgs[2]);}
  2548. #line 3097
  2549. inline const TAny *RMessage2::Ptr3() const
  2550. {return((const TAny *)iArgs[3]);}
  2551. #line 3107
  2552. inline CSession2* RMessage2::Session() const
  2553. {return (CSession2*)iSessionPtr; }
  2559. inline TUid TUid::Uid(TInt aUid)
  2560. #line 3123
  2561. {TUid uid={aUid};return uid;}
  2566. inline TUid TUid::Null()
  2572. {TUid uid={KNullUidValue};return uid;}
  2579. template <class T>
  2580. inline TArray<T>::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr)
  2581. : iPtr(aPtr),iCount(aCount),iAt(anAt)
  2582. #line 3195
  2583. {}
  2588. template <class T>
  2589. inline TInt TArray<T>::Count() const
  2596. {return((*iCount)(iPtr));}
  2601. template <class T>
  2602. inline const T &TArray<T>::operator[](TInt anIndex) const
  2603. #line 3232
  2604. {return(*((const T *)(*iAt)(iPtr,anIndex)));}
  2611. template <class T>
  2612. inline TIdentityRelation<T>::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) )
  2613. #line 3254
  2614. { iIdentity=(TGeneralIdentityRelation)anIdentity; }
  2619. template <class T>
  2620. inline TIdentityRelation<T>::operator TGeneralIdentityRelation() const
  2625. { return iIdentity; }
  2631. template <class T>
  2632. inline TLinearOrder<T>::TLinearOrder( TInt(*anOrder)(const T&, const T&) )
  2633. #line 3288
  2634. { iOrder=(TGeneralLinearOrder)anOrder; }
  2639. template <class T>
  2640. inline TLinearOrder<T>::operator TGeneralLinearOrder() const
  2645. { return iOrder; }
  2646. #line 3312
  2647. template <class T>
  2648. inline RPointerArray<T>::RPointerArray()
  2649. : RPointerArrayBase()
  2650. {}
  2651. #line 3331
  2652. template <class T>
  2653. inline RPointerArray<T>::RPointerArray(TInt aGranularity)
  2654. : RPointerArrayBase(aGranularity)
  2655. {}
  2656. #line 3354
  2657. template <class T>
  2658. inline RPointerArray<T>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2659. : RPointerArrayBase(aMinGrowBy, aFactor)
  2660. {}
  2665. template <class T>
  2666. inline void RPointerArray<T>::Close()
  2667. #line 3372
  2668. {RPointerArrayBase::Close();}
  2673. template <class T>
  2674. inline TInt RPointerArray<T>::Count() const
  2680. { return RPointerArrayBase::Count(); }
  2685. template <class T>
  2686. inline T* const& RPointerArray<T>::operator[](TInt anIndex) const
  2687. #line 3408
  2688. {return (T* const&)At(anIndex);}
  2693. template <class T>
  2694. inline T*& RPointerArray<T>::operator[](TInt anIndex)
  2695. #line 3432
  2696. {return (T*&)At(anIndex);}
  2701. template <class T>
  2702. inline TInt RPointerArray<T>::Append(const T* anEntry)
  2703. #line 3447
  2704. { return RPointerArrayBase::Append(anEntry); }
  2709. template <class T>
  2710. inline TInt RPointerArray<T>::Insert(const T* anEntry, TInt aPos)
  2711. #line 3468
  2712. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2717. template <class T>
  2718. inline void RPointerArray<T>::Remove(TInt anIndex)
  2719. #line 3488
  2720. {RPointerArrayBase::Remove(anIndex);}
  2725. template <class T>
  2726. inline void RPointerArray<T>::Compress()
  2727. #line 3503
  2728. {RPointerArrayBase::Compress();}
  2733. template <class T>
  2734. inline void RPointerArray<T>::Reset()
  2735. #line 3522
  2736. {RPointerArrayBase::Reset();}
  2741. template <class T>
  2742. inline TInt RPointerArray<T>::Find(const T* anEntry) const
  2743. #line 3542
  2744. { return RPointerArrayBase::Find(anEntry); }
  2749. template <class T>
  2750. inline TInt RPointerArray<T>::Find(const T* anEntry, TIdentityRelation<T> anIdentity) const
  2751. #line 3566
  2752. { return RPointerArrayBase::Find(anEntry,anIdentity); }
  2757. template <class T>
  2758. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry) const
  2759. #line 3584
  2760. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  2765. template <class T>
  2766. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const
  2767. #line 3606
  2768. { return RPointerArrayBase::FindIsq(anEntry,anOrder); }
  2773. template <class T>
  2774. inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry, TInt& anIndex) const
  2775. #line 3631
  2776. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  2781. template <class T>
  2782. inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  2783. #line 3660
  2784. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); }
  2789. template <class T>
  2790. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const
  2791. #line 3691
  2792. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  2797. template <class T>
  2798. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  2799. #line 3726
  2800. { return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); }
  2805. template <class T>
  2806. inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const
  2807. #line 3766
  2808. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  2813. template <class T>
  2814. inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  2815. #line 3810
  2816. { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); }
  2821. template <class T>
  2822. inline TInt RPointerArray<T>::InsertInAddressOrder(const T* anEntry)
  2823. #line 3833
  2824. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  2829. template <class T>
  2830. inline TInt RPointerArray<T>::InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder)
  2831. #line 3862
  2832. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); }
  2837. template <class T>
  2838. inline TInt RPointerArray<T>::InsertInAddressOrderAllowRepeats(const T* anEntry)
  2839. #line 3885
  2840. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  2845. template <class T>
  2846. inline TInt RPointerArray<T>::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder)
  2847. #line 3911
  2848. { return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); }
  2854. template <class T>
  2855. inline RPointerArray<T>::RPointerArray(T** aEntries, TInt aCount)
  2856. : RPointerArrayBase((TAny **)aEntries, aCount)
  2857. #line 3935
  2858. {}
  2863. template <class T>
  2864. inline void RPointerArray<T>::GranularCompress()
  2865. #line 3950
  2866. {RPointerArrayBase::GranularCompress();}
  2871. template <class T>
  2872. inline TInt RPointerArray<T>::Reserve(TInt aCount)
  2873. #line 3969
  2874. { return RPointerArrayBase::DoReserve(aCount); }
  2879. template <class T>
  2880. inline void RPointerArray<T>::SortIntoAddressOrder()
  2884. { HeapSortUnsigned(); }
  2889. template <class T>
  2890. inline void RPointerArray<T>::Sort(TLinearOrder<T> anOrder)
  2891. #line 3996
  2892. { HeapSort(anOrder); }
  2897. template <class T>
  2898. inline TArray<T*> RPointerArray<T>::Array() const
  2906. { return TArray<T*>(GetCount,GetElementPtr,(const CBase*)this); }
  2911. template <class T>
  2912. void RPointerArray<T>::ResetAndDestroy()
  2913. #line 4026
  2914. {
  2915. TInt c=Count();
  2916. T** pE=(T**)Entries();
  2917. ZeroCount();
  2918. TInt i;
  2919. for (i=0; i<c; i++)
  2920. {
  2921. delete *pE;
  2922. pE++;
  2923. }
  2924. Reset();
  2925. }
  2926. #line 4049
  2927. inline RPointerArray<TAny>::RPointerArray()
  2928. : RPointerArrayBase()
  2929. {}
  2930. #line 4067
  2931. inline RPointerArray<TAny>::RPointerArray(TInt aGranularity)
  2932. : RPointerArrayBase(aGranularity)
  2933. {}
  2934. #line 4089
  2935. inline RPointerArray<TAny>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
  2936. : RPointerArrayBase(aMinGrowBy, aFactor)
  2937. {}
  2942. inline void RPointerArray<TAny>::Close()
  2943. #line 4105
  2944. {RPointerArrayBase::Close();}
  2949. inline TInt RPointerArray<TAny>::Count() const
  2955. { return RPointerArrayBase::Count(); }
  2960. inline TAny* const& RPointerArray<TAny>::operator[](TInt anIndex) const
  2961. #line 4139
  2962. {return At(anIndex);}
  2967. inline TAny*& RPointerArray<TAny>::operator[](TInt anIndex)
  2968. #line 4162
  2969. {return At(anIndex);}
  2974. inline TInt RPointerArray<TAny>::Append(const TAny* anEntry)
  2975. #line 4176
  2976. { return RPointerArrayBase::Append(anEntry); }
  2981. inline TInt RPointerArray<TAny>::Insert(const TAny* anEntry, TInt aPos)
  2982. #line 4196
  2983. { return RPointerArrayBase::Insert(anEntry,aPos); }
  2988. inline void RPointerArray<TAny>::Remove(TInt anIndex)
  2989. #line 4215
  2990. {RPointerArrayBase::Remove(anIndex);}
  2995. inline void RPointerArray<TAny>::Compress()
  2996. #line 4229
  2997. {RPointerArrayBase::Compress();}
  3002. inline void RPointerArray<TAny>::Reset()
  3003. #line 4247
  3004. {RPointerArrayBase::Reset();}
  3009. inline TInt RPointerArray<TAny>::Find(const TAny* anEntry) const
  3010. #line 4266
  3011. { return RPointerArrayBase::Find(anEntry); }
  3016. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry) const
  3017. #line 4283
  3018. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
  3023. inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const
  3024. #line 4307
  3025. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
  3030. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const
  3031. #line 4337
  3032. { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
  3037. inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const
  3038. #line 4376
  3039. { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
  3044. inline TInt RPointerArray<TAny>::InsertInAddressOrder(const TAny* anEntry)
  3045. #line 4398
  3046. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
  3051. inline TInt RPointerArray<TAny>::InsertInAddressOrderAllowRepeats(const TAny* anEntry)
  3052. #line 4420
  3053. { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
  3059. inline RPointerArray<TAny>::RPointerArray(TAny** aEntries, TInt aCount)
  3060. : RPointerArrayBase((TAny **)aEntries, aCount)
  3061. #line 4443
  3062. {}
  3067. inline void RPointerArray<TAny>::GranularCompress()
  3068. #line 4457
  3069. {RPointerArrayBase::GranularCompress();}
  3074. inline void RPointerArray<TAny>::SortIntoAddressOrder()
  3078. { HeapSortUnsigned(); }
  3083. inline TArray<TAny*> RPointerArray<TAny>::Array() const
  3091. { return TArray<TAny*>(GetCount,GetElementPtr,(const CBase*)this); }
  3096. template <class T>
  3097. inline RArray<T>::RArray()
  3098. : RArrayBase(sizeof(T))
  3099. #line 4497
  3100. {}
  3105. template <class T>
  3106. inline RArray<T>::RArray(TInt aGranularity)
  3107. : RArrayBase(sizeof(T),aGranularity)
  3108. #line 4519
  3109. {}
  3114. template <class T>
  3115. inline RArray<T>::RArray(TInt aGranularity, TInt aKeyOffset)
  3116. : RArrayBase(sizeof(T),aGranularity,aKeyOffset)
  3117. #line 4543
  3118. {}
  3119. #line 4567
  3120. template <class T>
  3121. inline RArray<T>::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
  3122. : RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor)
  3123. {}
  3128. template <class T>
  3129. inline void RArray<T>::Close()
  3135. {RArrayBase::Close();}
  3140. template <class T>
  3141. inline TInt RArray<T>::Count() const
  3147. {return RArrayBase::Count();}
  3152. template <class T>
  3153. inline const T& RArray<T>::operator[](TInt anIndex) const
  3154. #line 4616
  3155. {return *(const T*)At(anIndex); }
  3160. template <class T>
  3161. inline T& RArray<T>::operator[](TInt anIndex)
  3162. #line 4638
  3163. {return *(T*)At(anIndex); }
  3168. template <class T>
  3169. inline TInt RArray<T>::Append(const T& anEntry)
  3170. #line 4653
  3171. {return RArrayBase::Append(&anEntry);}
  3176. template <class T>
  3177. inline TInt RArray<T>::Insert(const T& anEntry, TInt aPos)
  3178. #line 4675
  3179. {return RArrayBase::Insert(&anEntry,aPos);}
  3184. template <class T>
  3185. inline void RArray<T>::Remove(TInt anIndex)
  3186. #line 4692
  3187. {RArrayBase::Remove(anIndex);}
  3192. template <class T>
  3193. inline void RArray<T>::Compress()
  3201. {RArrayBase::Compress();}
  3206. template <class T>
  3207. inline void RArray<T>::Reset()
  3208. #line 4721
  3209. {RArrayBase::Reset();}
  3214. template <class T>
  3215. inline TInt RArray<T>::Find(const T& anEntry) const
  3216. #line 4743
  3217. {return RArrayBase::Find(&anEntry);}
  3222. template <class T>
  3223. inline TInt RArray<T>::Find(const T& anEntry, TIdentityRelation<T> anIdentity) const
  3224. #line 4768
  3225. {return RArrayBase::Find(&anEntry,anIdentity);}
  3230. template <class T>
  3231. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry) const
  3232. #line 4787
  3233. {return RArrayBase::FindIsqSigned(&anEntry);}
  3238. template <class T>
  3239. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry) const
  3240. #line 4806
  3241. {return RArrayBase::FindIsqUnsigned(&anEntry);}
  3246. template <class T>
  3247. inline TInt RArray<T>::FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const
  3248. #line 4828
  3249. {return RArrayBase::FindIsq(&anEntry,anOrder);}
  3254. template <class T>
  3255. inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const
  3256. #line 4851
  3257. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex);}
  3262. template <class T>
  3263. inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const
  3264. #line 4875
  3265. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);}
  3270. template <class T>
  3271. inline TInt RArray<T>::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
  3272. #line 4902
  3273. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);}
  3278. template <class T>
  3279. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const
  3280. #line 4936
  3281. {return RArrayBase::FindIsqSigned(&anEntry,aMode);}
  3286. template <class T>
  3287. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const
  3288. #line 4970
  3289. {return RArrayBase::FindIsqUnsigned(&anEntry,aMode);}
  3294. template <class T>
  3295. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
  3296. #line 5003
  3297. {return RArrayBase::FindIsq(&anEntry,anOrder,aMode);}
  3302. template <class T>
  3303. inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  3304. #line 5042
  3305. {return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);}
  3310. template <class T>
  3311. inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
  3312. #line 5081
  3313. {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);}
  3318. template <class T>
  3319. inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
  3320. #line 5123
  3321. {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);}
  3326. template <class T>
  3327. inline TInt RArray<T>::InsertInSignedKeyOrder(const T& anEntry)
  3328. #line 5146
  3329. {return RArrayBase::InsertIsqSigned(&anEntry,EFalse);}
  3334. template <class T>
  3335. inline TInt RArray<T>::InsertInUnsignedKeyOrder(const T& anEntry)
  3336. #line 5169
  3337. {return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);}
  3342. template <class T>
  3343. inline TInt RArray<T>::InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder)
  3344. #line 5197
  3345. {return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);}
  3350. template <class T>
  3351. inline TInt RArray<T>::InsertInSignedKeyOrderAllowRepeats(const T& anEntry)
  3352. #line 5221
  3353. {return RArrayBase::InsertIsqSigned(&anEntry,ETrue);}
  3358. template <class T>
  3359. inline TInt RArray<T>::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry)
  3360. #line 5245
  3361. {return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);}
  3366. template <class T>
  3367. inline TInt RArray<T>::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder)
  3368. #line 5272
  3369. {return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);}
  3375. template <class T>
  3376. inline RArray<T>::RArray(TInt aEntrySize,T* aEntries, TInt aCount)
  3377. : RArrayBase(aEntrySize,aEntries,aCount)
  3378. #line 5303
  3379. {}
  3384. template <class T>
  3385. inline void RArray<T>::GranularCompress()
  3386. #line 5318
  3387. {RArrayBase::GranularCompress();}
  3392. template <class T>
  3393. inline TInt RArray<T>::Reserve(TInt aCount)
  3394. #line 5337
  3395. { return RArrayBase::DoReserve(aCount); }
  3400. template <class T>
  3401. inline void RArray<T>::SortSigned()
  3406. {HeapSortSigned();}
  3411. template <class T>
  3412. inline void RArray<T>::SortUnsigned()
  3417. {HeapSortUnsigned();}
  3422. template <class T>
  3423. inline void RArray<T>::Sort(TLinearOrder<T> anOrder)
  3424. #line 5375
  3425. {HeapSort(anOrder);}
  3430. template <class T>
  3431. inline TArray<T> RArray<T>::Array() const
  3437. { return TArray<T>(GetCount,GetElementPtr,(const CBase*)this); }
  3443. inline RArray<TInt>::RArray()
  3444. : RPointerArrayBase()
  3451. {}
  3456. inline RArray<TInt>::RArray(TInt aGranularity)
  3457. : RPointerArrayBase(aGranularity)
  3458. #line 5417
  3459. {}
  3460. #line 5437
  3461. inline RArray<TInt>::RArray(TInt aMinGrowBy, TInt aFactor)
  3462. : RPointerArrayBase(aMinGrowBy, aFactor)
  3463. {}
  3468. inline void RArray<TInt>::Close()
  3474. {RPointerArrayBase::Close();}
  3479. inline TInt RArray<TInt>::Count() const
  3485. { return RPointerArrayBase::Count(); }
  3490. inline const TInt& RArray<TInt>::operator[](TInt anIndex) const
  3491. #line 5484
  3492. {return (const TInt&)At(anIndex);}
  3497. inline TInt& RArray<TInt>::operator[](TInt anIndex)
  3498. #line 5507
  3499. {return (TInt&)At(anIndex);}
  3504. inline TInt RArray<TInt>::Append(TInt anEntry)
  3505. #line 5521
  3506. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3511. inline TInt RArray<TInt>::Insert(TInt anEntry, TInt aPos)
  3512. #line 5541
  3513. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3518. inline void RArray<TInt>::Remove(TInt anIndex)
  3519. #line 5558
  3520. {RPointerArrayBase::Remove(anIndex);}
  3525. inline void RArray<TInt>::Compress()
  3533. {RPointerArrayBase::Compress();}
  3538. inline void RArray<TInt>::Reset()
  3539. #line 5586
  3540. {RPointerArrayBase::Reset();}
  3545. inline TInt RArray<TInt>::Find(TInt anEntry) const
  3546. #line 5604
  3547. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3552. inline TInt RArray<TInt>::FindInOrder(TInt anEntry) const
  3553. #line 5621
  3554. { return RPointerArrayBase::FindIsqSigned(anEntry); }
  3559. inline TInt RArray<TInt>::FindInOrder(TInt anEntry, TInt& anIndex) const
  3560. #line 5644
  3561. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); }
  3566. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt aMode) const
  3567. #line 5675
  3568. { return RPointerArrayBase::FindIsqSigned(anEntry,aMode); }
  3573. inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const
  3574. #line 5713
  3575. { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); }
  3580. inline TInt RArray<TInt>::InsertInOrder(TInt anEntry)
  3581. #line 5735
  3582. { return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); }
  3587. inline TInt RArray<TInt>::InsertInOrderAllowRepeats(TInt anEntry)
  3588. #line 5758
  3589. { return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); }
  3595. inline RArray<TInt>::RArray(TInt* aEntries, TInt aCount)
  3596. : RPointerArrayBase((TAny**)aEntries, aCount)
  3597. #line 5781
  3598. {}
  3600. inline void RArray<TInt>::GranularCompress()
  3601. #line 5792
  3602. {RPointerArrayBase::GranularCompress();}
  3607. inline TInt RArray<TInt>::Reserve(TInt aCount)
  3608. #line 5810
  3609. { return RPointerArrayBase::DoReserve(aCount); }
  3614. inline void RArray<TInt>::Sort()
  3618. { HeapSortSigned(); }
  3623. inline TArray<TInt> RArray<TInt>::Array() const
  3631. { return TArray<TInt>(GetCount,GetElementPtr,(const CBase*)this); }
  3636. inline RArray<TUint>::RArray()
  3637. : RPointerArrayBase()
  3638. #line 5847
  3639. {}
  3644. inline RArray<TUint>::RArray(TInt aGranularity)
  3645. : RPointerArrayBase(aGranularity)
  3646. #line 5863
  3647. {}
  3648. #line 5883
  3649. inline RArray<TUint>::RArray(TInt aMinGrowBy, TInt aFactor)
  3650. : RPointerArrayBase(aMinGrowBy, aFactor)
  3651. {}
  3656. inline void RArray<TUint>::Close()
  3662. {RPointerArrayBase::Close();}
  3667. inline TInt RArray<TUint>::Count() const
  3673. {return RPointerArrayBase::Count(); }
  3678. inline const TUint& RArray<TUint>::operator[](TInt anIndex) const
  3679. #line 5930
  3680. {return (const TUint&)At(anIndex);}
  3685. inline TUint& RArray<TUint>::operator[](TInt anIndex)
  3686. #line 5953
  3687. {return (TUint&)At(anIndex);}
  3692. inline TInt RArray<TUint>::Append(TUint anEntry)
  3700. { return RPointerArrayBase::Append((const TAny*)anEntry); }
  3705. inline TInt RArray<TUint>::Insert(TUint anEntry, TInt aPos)
  3706. #line 5987
  3707. { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
  3712. inline void RArray<TUint>::Remove(TInt anIndex)
  3713. #line 6005
  3714. {RPointerArrayBase::Remove(anIndex);}
  3719. inline void RArray<TUint>::Compress()
  3727. {RPointerArrayBase::Compress();}
  3732. inline void RArray<TUint>::Reset()
  3733. #line 6033
  3734. {RPointerArrayBase::Reset();}
  3739. inline TInt RArray<TUint>::Find(TUint anEntry) const
  3740. #line 6051
  3741. { return RPointerArrayBase::Find((const TAny*)anEntry); }
  3746. inline TInt RArray<TUint>::FindInOrder(TUint anEntry) const
  3747. #line 6070
  3748. { return RPointerArrayBase::FindIsqUnsigned(anEntry); }
  3753. inline TInt RArray<TUint>::FindInOrder(TUint anEntry, TInt& anIndex) const
  3754. #line 6098
  3755. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); }
  3760. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt aMode) const
  3761. #line 6128
  3762. { return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); }
  3767. inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const
  3768. #line 6163
  3769. { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); }
  3774. inline TInt RArray<TUint>::InsertInOrder(TUint anEntry)
  3775. #line 6185
  3776. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); }
  3781. inline TInt RArray<TUint>::InsertInOrderAllowRepeats(TUint anEntry)
  3782. #line 6208
  3783. { return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); }
  3789. inline RArray<TUint>::RArray(TUint* aEntries, TInt aCount)
  3790. : RPointerArrayBase((TAny**)aEntries, aCount)
  3791. #line 6231
  3792. {}
  3796. inline void RArray<TUint>::GranularCompress()
  3797. #line 6244
  3798. {RPointerArrayBase::GranularCompress();}
  3803. inline TInt RArray<TUint>::Reserve(TInt aCount)
  3804. #line 6262
  3805. { return RPointerArrayBase::DoReserve(aCount); }
  3810. inline void RArray<TUint>::Sort()
  3814. { HeapSortUnsigned(); }
  3819. inline TArray<TUint> RArray<TUint>::Array() const
  3827. { return TArray<TUint>(GetCount,GetElementPtr,(const CBase*)this); }
  3828. #line 6293
  3829. inline void TIpcArgs::Set(TInt,TNothing)
  3830. {}
  3831. #line 6307
  3832. inline void TIpcArgs::Set(TInt aIndex,TInt aValue)
  3833. {
  3834. iArgs[aIndex] = aValue;
  3835. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3836. }
  3837. #line 6324
  3838. inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue)
  3839. {
  3840. iArgs[aIndex] = (TInt)aValue;
  3841. iFlags |= EUnspecified<<(aIndex*KBitsPerType);
  3842. }
  3843. #line 6341
  3844. inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue)
  3845. {
  3846. iArgs[aIndex] = (TInt)aValue.Handle();
  3847. iFlags |= EHandle<<(aIndex*KBitsPerType);
  3848. }
  3849. #line 6358
  3850. inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue)
  3851. {
  3852. iArgs[aIndex] = (TInt)aValue;
  3853. iFlags |= EDesC8<<(aIndex*KBitsPerType);
  3854. }
  3855. #line 6377
  3856. inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue)
  3857. {
  3858. iArgs[aIndex] = (TInt)aValue;
  3859. iFlags |= EDesC16<<(aIndex*KBitsPerType);
  3860. }
  3861. #line 6396
  3862. inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue)
  3863. {
  3864. iArgs[aIndex] = (TInt)aValue;
  3865. iFlags |= EDes8<<(aIndex*KBitsPerType);
  3866. }
  3867. #line 6415
  3868. inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue)
  3869. {
  3870. iArgs[aIndex] = (TInt)aValue;
  3871. iFlags |= EDes16<<(aIndex*KBitsPerType);
  3872. }
  3879. inline TIpcArgs::TArgType TIpcArgs::Type(TNothing)
  3880. { return EUnspecified; }
  3881. inline TIpcArgs::TArgType TIpcArgs::Type(TInt)
  3882. { return EUnspecified; }
  3883. inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*)
  3884. { return EUnspecified; }
  3885. inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase)
  3886. { return EHandle; }
  3887. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*)
  3888. { return EDesC8; }
  3890. inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*)
  3891. { return EDesC16; }
  3893. inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*)
  3894. { return EDes8; }
  3896. inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*)
  3897. { return EDes16; }
  3899. inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing)
  3900. {}
  3901. inline void TIpcArgs::Assign(TInt& aArg,TInt aValue)
  3902. { aArg = aValue; }
  3903. inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue)
  3904. { aArg = (TInt)aValue; }
  3905. inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue)
  3906. { aArg = (TInt)aValue.Handle(); }
  3907. inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue)
  3908. { aArg = (TInt)aValue; }
  3910. inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue)
  3911. { aArg = (TInt)aValue; }
  3913. inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue)
  3914. { aArg = (TInt)aValue; }
  3916. inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue)
  3917. { aArg = (TInt)aValue; }
  3924. inline SInt64::SInt64()
  3925. {}
  3927. inline SInt64::SInt64(Int64 a)
  3928. {
  3929. iData[0] = (TUint32)((Uint64)a);
  3930. iData[1] = (TUint32)(((Uint64)a)>>32);
  3931. }
  3933. inline SInt64& SInt64::operator=(Int64 a)
  3934. {
  3935. iData[0] = (TUint32)((Uint64)a);
  3936. iData[1] = (TUint32)(((Uint64)a)>>32);
  3937. return *this;
  3938. }
  3940. inline SInt64::operator Int64() const
  3941. {
  3942. Int64 x;
  3943. TUint32* px = (TUint32*)&x;
  3944. px[0] = iData[0];
  3945. px[1] = iData[1];
  3946. return x;
  3947. }
  3949. inline SUint64::SUint64()
  3950. {}
  3952. inline SUint64::SUint64(Uint64 a)
  3953. {
  3954. iData[0] = (TUint32)a;
  3955. iData[1] = (TUint32)(a>>32);
  3956. }
  3958. inline SUint64& SUint64::operator=(Uint64 a)
  3959. {
  3960. iData[0] = (TUint32)a;
  3961. iData[1] = (TUint32)(a>>32);
  3962. return *this;
  3963. }
  3965. inline SUint64::operator Uint64() const
  3966. {
  3967. Uint64 x;
  3968. TUint32* px = (TUint32*)&x;
  3969. px[0] = iData[0];
  3970. px[1] = iData[1];
  3971. return x;
  3972. }
  3974. inline SDouble::SDouble()
  3975. {}
  3977. inline SDouble::SDouble(TReal a)
  3978. {
  3979. const TUint32* pa = (const TUint32*)&a;
  3984. iData[0] = pa[0];
  3985. iData[1] = pa[1];
  3987. }
  3989. inline SDouble& SDouble::operator=(TReal a)
  3990. {
  3991. new (this) SDouble(a);
  3992. return *this;
  3993. }
  3995. inline SDouble::operator TReal() const
  3996. {
  3997. TReal x;
  3998. TUint32* px = (TUint32*)&x;
  4003. px[0] = iData[0];
  4004. px[1] = iData[1];
  4006. return x;
  4007. }
  4014. inline TSecureId::TSecureId()
  4015. {}
  4019. inline TSecureId::TSecureId(TUint32 aId)
  4020. : iId(aId) {}
  4024. inline TSecureId::operator TUint32() const
  4025. { return iId; }
  4029. inline TSecureId::TSecureId(TUid aId)
  4030. : iId(aId.iUid) {}
  4034. inline TSecureId::operator TUid() const
  4035. { return (TUid&)iId; }
  4040. inline const TSecureId* SSecureId::operator&() const
  4041. { return (const TSecureId*)this; }
  4042. inline SSecureId::operator const TSecureId&() const
  4043. { return (const TSecureId&)iId; }
  4044. inline SSecureId::operator TUint32() const
  4045. { return iId; }
  4046. inline SSecureId::operator TUid() const
  4047. { return (TUid&)iId; }
  4054. inline TVendorId::TVendorId()
  4055. {}
  4059. inline TVendorId::TVendorId(TUint32 aId)
  4060. : iId(aId) {}
  4064. inline TVendorId::operator TUint32() const
  4065. { return iId; }
  4069. inline TVendorId::TVendorId(TUid aId)
  4070. : iId(aId.iUid) {}
  4074. inline TVendorId::operator TUid() const
  4075. { return (TUid&)iId; }
  4080. inline const TVendorId* SVendorId::operator&() const
  4081. { return (const TVendorId*)this; }
  4082. inline SVendorId::operator const TVendorId&() const
  4083. { return (const TVendorId&)iId; }
  4084. inline SVendorId::operator TUint32() const
  4085. { return iId; }
  4086. inline SVendorId::operator TUid() const
  4087. { return (TUid&)iId; }
  4093. inline TCapabilitySet::TCapabilitySet()
  4094. {}
  4100. inline TCapabilitySet::TCapabilitySet(TCapability aCapability)
  4101. { new (this) TCapabilitySet(aCapability, aCapability); }
  4107. inline void TCapabilitySet::Set(TCapability aCapability)
  4108. { new (this) TCapabilitySet(aCapability, aCapability); }
  4115. inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2)
  4116. { new (this) TCapabilitySet(aCapability1, aCapability2); }
  4122. inline TSecurityInfo::TSecurityInfo()
  4123. {}
  4128. inline TSecurityPolicy::TSecurityPolicy()
  4129. { new (this) TSecurityPolicy(EAlwaysFail); }
  4135. inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const
  4136. { return (const TSecurityPolicy*)this; }
  4142. inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const
  4143. { return *(const TSecurityPolicy*)this; }
  4149. inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const
  4150. { return *(const TSecurityPolicy*)this; }
  4151. #line 6341 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.h" /* stack depth 1 */
  4152. #line 2 "C:\gbtukmanpf01\NOK124\Courses\S60\05300-S60_C++_Introduction\Working\LabCode\Lab_05304-s2.cb1\starter\.generated\winscw_uid.cpp" /* stack depth 0 */
  4155. #pragma data_seg(".SYMBIAN")
  4156. #line 4
  4157. TEmulatorImageHeader uid={{0x1000007a,0x100039CE,0x08B9993D},EPriorityForeground,{0x08B9993D,0x00000000,{0x00000000u,0x00000000u}},0,0,0x00000000,0};
  4159. #pragma data_seg()