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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
symbiantypes.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：12k
源码类别：

Symbian

开发平台：

C/C++

symbiantypes.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _SYMBIANTYPES_H_
  36. #define _SYMBIANTYPES_H_
  38. #ifndef _SYMBIAN
  39. #error This is the symbian types include. Only use on a Symbian platform.
  40. #endif
  42. #include <e32std.h>
  43. #include <e32def.h>
  45. inline
  46. double SymbianUINT32toDouble(TInt32 a)
  47. {
  48.     double ret;
  50.     if (a >= 0x80000000)
  51.     {
  52. ret = (double)(a & 0x7fffffff);
  53. ret += 2147483648.0;
  54.     }
  55.     else
  56.     {
  57. ret = (double)a;
  58.     }
  60.     return ret;
  61. }
  63. class SymInt64 : private TInt64
  64. {
  65.   public:
  66.     //Ctors
  67.     inline SymInt64(const SymInt64& it);
  68.     inline SymInt64();
  69.     inline SymInt64(const TInt64& it);    
  70.     inline SymInt64(const TInt32& it);
  71.     inline SymInt64(const TUint32& it);
  72.     inline SymInt64(const TInt& aVal);
  73.     inline SymInt64(const TUint& aVal);
  74.     inline SymInt64(const TUint& aHigh, const TUint& aLow);
  75.     inline SymInt64(const TReal& aVal);
  77.     //Assignment opers
  78.     inline SymInt64& operator=(const TInt&     aVal);
  79.     inline SymInt64& operator=(const TUint&    aVal);
  80.     inline SymInt64& operator=(const TInt32&   aVal);
  81.     inline SymInt64& operator=(const TUint32&  aVal);
  82.     inline SymInt64& operator=(const TReal&    aVal);
  83.     inline SymInt64& operator=(const TInt64&   aVal);
  84.     inline SymInt64& operator=(const SymInt64& aVal);
  85.     
  86.     //operators
  87.     inline SymInt64& operator>>=(TInt aShift);
  88.     inline SymInt64& operator<<=(TInt aShift);
  89.     inline SymInt64  operator+() const;
  90.     inline SymInt64  operator-() const;
  91.     inline SymInt64& operator++();
  92.     inline SymInt64  operator++(TInt);
  93.     inline SymInt64& operator--();
  94.     inline SymInt64  operator--(TInt);
  95.     inline SymInt64  operator>>(TInt aShift) const;
  96.     inline SymInt64  operator<<(TInt aShift) const;
  98.     inline SymInt64& operator+=(const SymInt64 &aVal);
  99.     inline SymInt64& operator-=(const SymInt64 &aVal);
  100.     inline SymInt64& operator*=(const SymInt64 &aVal);
  101.     inline SymInt64& operator/=(const SymInt64 &aVal);
  102.     inline SymInt64& operator%=(const SymInt64 &aVal);
  103.     inline SymInt64& operator|=(const SymInt64 &aVal);
  105.     inline SymInt64& operator+=(const int &aVal);
  106.     inline SymInt64& operator-=(const int &aVal);
  107.     inline SymInt64& operator*=(const int &aVal);
  108.     inline SymInt64& operator/=(const int &aVal);
  109.     inline SymInt64& operator%=(const int &aVal);
  110.     inline SymInt64& operator|=(const int &aVal);
  112.  
  113.     //SymInt64 math ops....
  114.     inline SymInt64  operator+(const SymInt64 &aVal) const;
  115.     inline SymInt64  operator-(const SymInt64 &aVal) const;
  116.     inline SymInt64  operator*(const SymInt64 &aVal) const;
  117.     inline SymInt64  operator/(const SymInt64 &aVal) const;
  118.     inline SymInt64  operator%(const SymInt64 &aVal) const;
  119.     inline SymInt64  operator|(const SymInt64 &aVal) const;
  120.     inline SymInt64  operator&(const SymInt64 &aVal) const;
  122.     inline SymInt64  operator+(const int &aVal) const;
  123.     inline SymInt64  operator-(const int &aVal) const;
  124.     inline SymInt64  operator*(const int &aVal) const;
  125.     inline SymInt64  operator/(const int &aVal) const;
  126.     inline SymInt64  operator%(const int &aVal) const;
  127.     inline SymInt64  operator|(const int &aVal) const;
  128.     inline SymInt64  operator&(const int &aVal) const;
  130.     //Compares....
  131.     inline TInt operator==(const SymInt64& aVal) const;
  132.     inline TInt operator!=(const SymInt64& aVal) const;
  133.     inline TInt operator>=(const SymInt64& aVal) const;
  134.     inline TInt operator<=(const SymInt64& aVal) const;
  135.     inline TInt operator>(const SymInt64& aVal) const;
  136.     inline TInt operator<(const SymInt64& aVal) const;
  137.     inline TInt operator!() const { return *this == 0; }
  138.  
  139.     //Assorted....
  140.     inline TUint   Low() const;
  141.     inline TUint   High() const;
  142.     inline TReal   GetTReal() const;
  143.     
  144.   private:
  145. };
  147. inline SymInt64::SymInt64(const SymInt64& it)
  148. {
  149.     iLow  = it.iLow;
  150.     iHigh = it.iHigh;
  151. }
  153. inline SymInt64::SymInt64()
  154. {
  155.     iLow = 0;
  156.     iHigh = 0;
  157. }
  158. inline SymInt64::SymInt64(const TInt64& it )
  159. {
  160.     iLow  = it.Low();
  161.     iHigh = it.High();
  162. }
  164. inline SymInt64::SymInt64(const TInt32& it)
  165.     : TInt64((TInt)it)
  166. {
  167. }
  168. inline SymInt64::SymInt64(const TUint32& it)
  169. {
  170.     iHigh = 0;
  171.     iLow  = it;
  172. }
  173. inline SymInt64::SymInt64(const TInt& it)
  174.     : TInt64(it)
  175. {
  176. }
  178. inline SymInt64::SymInt64(const TUint& it)
  179.     : TInt64(it)
  180. {
  181. }
  183. inline SymInt64::SymInt64(const TUint& aHigh, const TUint& aLow)
  184.     : TInt64(aHigh, aLow)
  185. {
  186. }
  188. inline SymInt64::SymInt64(const TReal& it)
  189.     : TInt64(it)
  190. {
  191. }
  196. inline SymInt64& SymInt64::operator=(const TInt& aVal)
  197. {
  198.     TInt64::operator=(aVal);
  199.     return *this;
  200. }
  201. inline SymInt64& SymInt64::operator=(const TUint& aVal)
  202. {
  203.     TInt64::operator=(aVal);
  204.     return *this;
  205. }
  206. inline SymInt64& SymInt64::operator=(const TInt32& aVal)
  207. {
  208.     iHigh = 0;
  209.     iLow  = aVal;    
  210.     return *this;
  211. }
  213. inline SymInt64& SymInt64::operator=(const TUint32& aVal)
  214. {
  215.     iHigh = 0;
  216.     iLow  = aVal;
  217.     return *this;
  218. }
  219. inline SymInt64& SymInt64::operator=(const TReal& aVal)
  220. {
  221.     TInt64::operator=(aVal);
  222.     return *this;
  223. }
  224. inline SymInt64& SymInt64::operator=(const TInt64& aVal)
  225. {
  226.     iLow  = aVal.Low();
  227.     iHigh = aVal.High();
  228.     
  229.     return *this;
  230. }
  231. inline SymInt64& SymInt64::operator=(const SymInt64& aVal)
  232. {
  233.     TInt64::operator=(aVal);
  234.     return *this;
  235. }
  239. inline SymInt64& SymInt64::operator+=(const SymInt64 &aVal)
  240. {
  241.     TInt64::operator+=(aVal);
  242.     return *this;
  243. }
  244. inline SymInt64& SymInt64::operator-=(const SymInt64 &aVal)
  245. {
  246.     TInt64::operator-=(aVal);
  247.     return *this;
  248. }
  249. inline SymInt64& SymInt64::operator*=(const SymInt64 &aVal)
  250. {
  251.     TInt64::operator*=(aVal);
  252.     return *this;
  253. }
  254. inline SymInt64& SymInt64::operator/=(const SymInt64 &aVal)
  255. {
  256.     TInt64::operator/=(aVal);
  257.     return *this;
  258. }
  260. inline SymInt64& SymInt64::operator%=(const SymInt64 &aVal)
  261. {
  262.     TInt64::operator%=(aVal);
  263.     return *this;
  264. }
  266. inline SymInt64& SymInt64::operator|=(const SymInt64 &aVal)
  267. {
  268.     iHigh |= aVal.iHigh;
  269.     iLow |= aVal.iLow;
  270.     return *this;
  271. }
  277. inline SymInt64& SymInt64::operator+=(const int &aVal)
  278. {
  279.     TInt64::operator+=(aVal);
  280.     return *this;
  281. }
  282. inline SymInt64& SymInt64::operator-=(const int &aVal)
  283. {
  284.     TInt64::operator-=(aVal);
  285.     return *this;
  286. }
  287. inline SymInt64& SymInt64::operator*=(const int &aVal)
  288. {
  289.     TInt64::operator*=(aVal);
  290.     return *this;
  291. }
  292. inline SymInt64& SymInt64::operator/=(const int &aVal)
  293. {
  294.     TInt64::operator/=(aVal);
  295.     return *this;
  296. }
  298. inline SymInt64& SymInt64::operator%=(const int &aVal)
  299. {
  300.     TInt64::operator%=(aVal);
  301.     return *this;
  302. }
  304. inline SymInt64& SymInt64::operator|=(const int &aVal)
  305. {
  306.     iLow |= aVal;
  307.     return *this;
  308. }
  314. inline SymInt64& SymInt64::operator>>=(TInt aShift)
  315. {
  316.     TInt64::operator>>=(aShift);
  317.     return *this;
  318. }
  319. inline SymInt64& SymInt64::operator<<=(TInt aShift)
  320. {
  321.     TInt64::operator<<=(aShift);
  322.     return *this;
  323. }
  326. inline SymInt64 SymInt64::operator+() const
  327. {
  328.     return TInt64::operator+();
  329. }
  330. inline SymInt64 SymInt64::operator-() const
  331. {
  332.     return TInt64::operator-();
  333. }
  334. inline SymInt64& SymInt64::operator++()
  335. {
  336.     TInt64::operator++();
  337.     return *this;
  338. }
  339. inline SymInt64 SymInt64::operator++(TInt a)
  340. {
  341.     return TInt64::operator++(a);
  342. }
  343. inline SymInt64& SymInt64::operator--()
  344. {
  345.     TInt64::operator--();
  346.     return *this;
  347. }
  348. inline SymInt64 SymInt64::operator--(TInt a)
  349. {
  350.     return TInt64::operator--(a);
  351. }
  356. inline SymInt64 SymInt64::operator+(const SymInt64 &aVal) const
  357. {
  358.     return TInt64::operator+(aVal);
  359. }
  360. inline SymInt64 SymInt64::operator-(const SymInt64 &aVal) const
  361. {
  362.     return TInt64::operator-(aVal);
  363. }
  364. inline SymInt64 SymInt64::operator*(const SymInt64 &aVal) const
  365. {
  366.     return TInt64::operator*(aVal);
  367. }
  368. inline SymInt64 SymInt64::operator/(const SymInt64 &aVal) const
  369. {
  370.     return TInt64::operator/(aVal);
  371. }
  372. inline SymInt64 SymInt64::operator%(const SymInt64 &aVal) const
  373. {
  374.     return TInt64::operator%(aVal);
  375. }
  376. inline SymInt64 SymInt64::operator|(const SymInt64 &it) const
  377. {
  378.     return SymInt64( iHigh|it.iHigh, iLow|it.iLow );
  379. }
  380. inline SymInt64 SymInt64::operator&(const SymInt64 &it) const
  381. {
  382.     return SymInt64( iHigh&it.iHigh, iLow&it.iLow );
  383. }
  388. inline SymInt64 SymInt64::operator+(const int &aVal) const
  389. {
  390.     return TInt64::operator+(aVal);
  391. }
  392. inline SymInt64 SymInt64::operator-(const int &aVal) const
  393. {
  394.     return TInt64::operator-(aVal);
  395. }
  396. inline SymInt64 SymInt64::operator*(const int &aVal) const
  397. {
  398.     return TInt64::operator*(aVal);
  399. }
  400. inline SymInt64 SymInt64::operator/(const int &aVal) const
  401. {
  402.     return TInt64::operator/(aVal);
  403. }
  404. inline SymInt64 SymInt64::operator%(const int &aVal) const
  405. {
  406.     return TInt64::operator%(aVal);
  407. }
  408. inline SymInt64 SymInt64::operator|(const int &it) const
  409. {
  410.     return SymInt64( iHigh, iLow|it );
  411. }
  412. inline SymInt64 SymInt64::operator&(const int &it) const
  413. {
  414.     return SymInt64( 0, iLow&it );
  415. }
  421. inline SymInt64 SymInt64::operator>>(TInt aShift) const
  422. {
  423.     return TInt64::operator>>(aShift);
  424. }
  425. inline SymInt64 SymInt64::operator<<(TInt aShift) const
  426. {
  427.     return TInt64::operator<<(aShift);
  428. }
  432. inline TInt SymInt64::operator==(const SymInt64 &aVal) const
  433. {
  434.     return TInt64::operator==(aVal);
  435. }
  436. inline TInt SymInt64::operator!=(const SymInt64 &aVal) const
  437. {
  438.     return TInt64::operator!=(aVal);
  439. }
  440. inline TInt SymInt64::operator>=(const SymInt64 &aVal) const
  441. {
  442.     return TInt64::operator>=(aVal);
  443. }
  444. inline TInt SymInt64::operator<=(const SymInt64 &aVal) const
  445. {
  446.     return TInt64::operator<=(aVal);
  447. }
  448. inline TInt SymInt64::operator>(const SymInt64 &aVal) const
  449. {
  450.     return TInt64::operator>(aVal);
  451. }
  452. inline TInt SymInt64::operator<(const SymInt64 &aVal) const
  453. {
  454.     return TInt64::operator<(aVal);
  455. }
  458. inline TUint SymInt64::Low() const
  459. {
  460.     return iLow;
  461. }
  463. inline TUint SymInt64::High() const
  464. {
  465.     return iHigh;
  466. }
  468. inline TReal SymInt64::GetTReal() const
  469. {
  470.     return TInt64::GetTReal();
  471. }
  474. // operators for SymInt64 and smaller precision types
  475. inline TInt operator==(const int& aVal, const SymInt64& bVal)
  476. {
  477.     return bVal == aVal;
  478. }
  480. inline TInt operator!=(const int& aVal, const SymInt64& bVal)
  481. {
  482.     return bVal != aVal;
  483. }
  485. inline TInt operator>=(const int& aVal, const SymInt64& bVal)
  486. {
  487.     return bVal <= aVal;
  488. }
  490. inline TInt operator<=(const int& aVal, const SymInt64& bVal)
  491. {
  492.     return bVal >= aVal;
  493. }
  495. inline TInt operator>(const  int& aVal, const SymInt64& bVal)
  496. {
  497.     return bVal < aVal;
  498. }
  500. inline TInt operator<(const  int& aVal, const SymInt64& bVal)
  501. {
  502.     return bVal > aVal;
  503. }
  510. #endif /* _SYMBIANTYPES_H_ */  /* Nothing past here */