HLH_RoundU32.h

   1 /*******************************************************************************
   2  *         File : ..\utils\HLH_RoundU32.h
   3  *
   4  *       Author : Henry He
   5  *      Created : 2009-10-14 14:26:15
   6  *  Description :
   7  ******************************************************************************/
   8
   9 #ifndef __HLH_ROUNDU32_INC_20091014_142615_HENRY__
  10 #define __HLH_ROUNDU32_INC_20091014_142615_HENRY__
  11
  12
  13 /*******************************************************************************
  14  * Desc : Includes Files
  15  ******************************************************************************/
  16 #include "HLH_utils/typedef.h"
  17
  18
  19 /*******************************************************************************
  20  * Desc : Macro Definations
  21  ******************************************************************************/
  22 #define HLH_ROUNDU32_RANGE            (  ~ ( (UINT32) 0 )  )
  23 #define HLH_ROUNDU32_HALF             ( HLH_ROUNDU32_RANGE / 2 )
  24
  25
  26 /*******************************************************************************
  27  * Desc : Type Definations
  28  ******************************************************************************/
  29
  30
  31 /*******************************************************************************
  32  * Desc : Global Variables
  33  ******************************************************************************/
  34
  35
  36 /*******************************************************************************
  37  * Desc : Classes
  38  ******************************************************************************/
  39
  40 ////////////////////////////////////////////////////////////////////////////////
  41 // Class to handle round up counter
  42
  43 class HLH_RoundU32
  44 {
  45   public:
  46     /******************************************************************************
  47      * Desc : Constructor / Deconstructor
  48      ******************************************************************************/
  49     HLH_RoundU32 (UINT32 unVal = 0) { m_unVal = unVal; }
  50
  51     ~HLH_RoundU32 () {}
  52
  53   public:
  54     /******************************************************************************
  55      * Desc : Convertions
  56      ******************************************************************************/
  57                 UINT32  GetUINT32 ();
  58     operator UINT32 () const      { return m_unVal; }
  59     operator float  () const      { return (float) m_unVal; }
  60     operator double () const      { return (double) m_unVal; }
  61
  62   public:
  63     /******************************************************************************
  64      * Desc : Operators
  65      ******************************************************************************/
  66     // Preposed add
  67     HLH_RoundU32 &operator ++ ()  { ++m_unVal; return *this; }
  68
  69     // Preposed sub
  70     HLH_RoundU32 &operator -- ()  { --m_unVal; return *this; }
  71
  72     // Postpositioned add
  73     HLH_RoundU32  operator ++ (int)  { return HLH_RoundU32 (m_unVal++); }
  74
  75     // Postpositioned sub
  76     HLH_RoundU32  operator -- (int)  { return HLH_RoundU32 (m_unVal--); }
  77
  78     HLH_RoundU32  operator +  (const HLH_RoundU32 &zhrVal) const { return HLH_RoundU32 (m_unVal + zhrVal.m_unVal); }
  79     HLH_RoundU32  operator -  (const HLH_RoundU32 &zhrVal) const { return HLH_RoundU32 (m_unVal - zhrVal.m_unVal); }
  80     HLH_RoundU32  operator *  (const HLH_RoundU32 &zhrVal) const { return HLH_RoundU32 (m_unVal * zhrVal.m_unVal); }
  81     HLH_RoundU32  operator /  (const HLH_RoundU32 &zhrVal) const { return HLH_RoundU32 (m_unVal / zhrVal.m_unVal); }
  82     HLH_RoundU32  operator %  (const HLH_RoundU32 &zhrVal) const { return HLH_RoundU32 (m_unVal % zhrVal.m_unVal); }
  83
  84     HLH_RoundU32 &operator =  (UINT32 unVal) { m_unVal = unVal; return *this; }
  85
  86     HLH_RoundU32 &operator += (const HLH_RoundU32 &zhrVal) { m_unVal += zhrVal.m_unVal; return *this; }
  87     HLH_RoundU32 &operator -= (const HLH_RoundU32 &zhrVal) { m_unVal -= zhrVal.m_unVal; return *this; }
  88     HLH_RoundU32 &operator *= (const HLH_RoundU32 &zhrVal) { m_unVal *= zhrVal.m_unVal; return *this; }
  89     HLH_RoundU32 &operator /= (const HLH_RoundU32 &zhrVal) { m_unVal /= zhrVal.m_unVal; return *this; }
  90     HLH_RoundU32 &operator %= (const HLH_RoundU32 &zhrVal) { m_unVal %= zhrVal.m_unVal; return *this; }
  91
  92     bool operator <  (const HLH_RoundU32 &zhrVal) const;
  93     bool operator >  (const HLH_RoundU32 &zhrVal) const;
  94     bool operator <= (const HLH_RoundU32 &zhrVal) const;
  95     bool operator >= (const HLH_RoundU32 &zhrVal) const;
  96
  97     bool operator == (const HLH_RoundU32 &zhrVal) const { return ( m_unVal == zhrVal.m_unVal ); }
  98     bool operator != (const HLH_RoundU32 &zhrVal) const { return ( m_unVal != zhrVal.m_unVal ); }
  99
 100   public:
 101     UINT32      m_unVal;
 102 };
 103
 104
 105
 106
 107 /******************************************************************************
 108  * Desc : Operators
 109  ******************************************************************************/
 110
 111
 112 inline bool HLH_RoundU32::operator <  (const HLH_RoundU32 &zhrVal) const
 113 {
 114
 115   UINT32  unDivide;
 116   UINT32  unVal;
 117
 118   unVal    = zhrVal.m_unVal;
 119   unDivide = unVal + HLH_ROUNDU32_HALF;
 120
 121   if (unVal < unDivide) {
 122     return (  (m_unVal < unVal) || (m_unVal > unDivide)  );
 123   } else {
 124     return (m_unVal > unDivide && m_unVal < unVal);
 125   }
 126
 127 }
 128
 129 inline bool HLH_RoundU32::operator >  (const HLH_RoundU32 &zhrVal) const
 130 {
 131
 132   UINT32  unDivide;
 133   UINT32  unVal;
 134
 135   unVal    = zhrVal.m_unVal;
 136   unDivide = unVal + HLH_ROUNDU32_HALF;
 137
 138   if (unVal < unDivide) {
 139     return ( m_unVal > unVal && m_unVal <= unDivide );
 140   } else {
 141     return ( m_unVal <= unDivide || m_unVal > unVal );
 142   }
 143
 144 }
 145
 146 inline bool HLH_RoundU32::operator <= (const HLH_RoundU32 &zhrVal) const
 147 {
 148
 149   UINT32  unDivide;
 150   UINT32  unVal;
 151
 152   unVal    = zhrVal.m_unVal;
 153   unDivide = unVal + HLH_ROUNDU32_HALF;
 154
 155   if (unVal < unDivide) {
 156     return (  (m_unVal <= unVal) || (m_unVal > unDivide)  );
 157   } else {
 158     return (m_unVal > unDivide && m_unVal <= unVal);
 159   }
 160
 161 }
 162
 163 inline bool HLH_RoundU32::operator >= (const HLH_RoundU32 &zhrVal) const
 164 {
 165
 166   UINT32  unDivide;
 167   UINT32  unVal;
 168
 169   unVal    = zhrVal.m_unVal;
 170   unDivide = unVal + HLH_ROUNDU32_HALF;
 171
 172   if (unVal < unDivide) {
 173     return ( m_unVal >= unVal && m_unVal <= unDivide );
 174   } else {
 175     return ( m_unVal <= unDivide || m_unVal >= unVal);
 176   }
 177
 178 }
 179
 180
 181
 182
 183
 184 #endif /* __HLH_ROUNDU32_INC_20091014_142615_HENRY__ */