test/uae-tmpl/be_val

   1 // #include <map>
   2 #include <netinet/in.h>
   3 #include "be_conv"
   4
   5 // using namespace std;
   6
   7 template<class T> // big endian value
   8 class be_val
   9 {
  10   public:
  11     typedef T value_type;
  12     typedef be_val<value_type> my_type;
  13
  14 #ifdef DEBUG
  15     /* Debugging */
  16     inline void print ()
  17     {
  18       unsigned long *lp = (unsigned long *)((void *) &data);
  19       printf ("%08lx", *lp);
  20     }
  21 #endif
  22
  23     be_val () {}
  24
  25     // explicit: this constructor is not used
  26     //           for automatic type promotion
  27     explicit be_val (value_type d) : data (ne2be (d)) {}
  28
  29     be_val (const my_type& other)
  30     {
  31       data = other.data;
  32     }
  33
  34     operator value_type () const
  35     {
  36       return static_cast<value_type> (be2ne (data));
  37     }
  38     const my_type& operator= (const value_type d)
  39     {
  40       *this = my_type (d);
  41       return *this;
  42     }
  43     const my_type& operator++ () // pre increment operator
  44     {
  45       value_type tmp = static_cast<value_type> (*this);
  46       return *this = my_type (++tmp);
  47     }
  48     const my_type operator++ (int) // post increment operator
  49     {
  50       my_type tmp = *this;
  51       (*this)++;
  52       return tmp;
  53     }
  54     const my_type& operator-- () // pre increment operator
  55     {
  56       value_type tmp = static_cast<value_type> (*this);
  57       return *this = my_type (--tmp);
  58     }
  59     const my_type operator-- (int) // post increment operator
  60     {
  61       my_type tmp = *this;
  62       (*this)--;
  63       return tmp;
  64     }
  65     const my_type& operator+= (const my_type& other)
  66     {
  67       *this = *this + other;
  68     }
  69     const my_type& operator-= (const my_type& other)
  70     {
  71       *this = *this - other;
  72     }
  73     const my_type& operator*= (const my_type& other)
  74     {
  75       *this = *this * other;
  76     }
  77     const my_type& operator/= (const my_type& other)
  78     {
  79       *this = *this / other;
  80     }
  81     const my_type& operator&= (const my_type& other)
  82     {
  83       *this = *this & other;
  84     }
  85     const my_type& operator|= (const my_type& other)
  86     {
  87       *this = *this | other;
  88     }
  89     const my_type& operator%= (const my_type& other)
  90     {
  91       *this = *this % other;
  92     }
  93     const my_type& operator^= (const my_type& other)
  94     {
  95       *this = *this ^ other;
  96     }
  97     const my_type& operator<<= (const my_type& other)
  98     {
  99       *this = *this << other;
 100     }
 101     const my_type& operator>>= (const my_type& other)
 102     {
 103       *this = *this >> other;
 104     }
 105
 106   protected:
 107     value_type data;
 108 };
 109
 110 template<class C>
 111 inline const be_val<C> operator+ (const be_val<C>& a, const be_val<C>& b)
 112 {
 113   return be_val<C>(static_cast<C> (a) + static_cast<C> (b));
 114 }
 115
 116 template<class C>
 117 inline const be_val<C> operator- (const be_val<C>& a, const be_val<C>& b)
 118 {
 119   return be_val<C>(static_cast<C> (a) - static_cast<C> (b));
 120 }
 121
 122 template<class C>
 123 inline const be_val<C> operator* (const be_val<C>& a, const be_val<C>& b)
 124 {
 125   return be_val<C>(static_cast<C> (a) * static_cast<C> (b));
 126 }
 127
 128 template<class C>
 129 inline const be_val<C> operator/ (const be_val<C>& a, const be_val<C>& b)
 130 {
 131   return be_val<C>(static_cast<C> (a) / static_cast<C> (b));
 132 }
 133
 134 template<class C>
 135 inline const be_val<C> operator% (const be_val<C>& a, const be_val<C>& b)
 136 {
 137   return be_val<C>(static_cast<C> (a) % static_cast<C> (b));
 138 }
 139
 140 template<class C>
 141 inline const be_val<C> operator^ (const be_val<C>& a, const be_val<C>& b)
 142 {
 143   return be_val<C>(static_cast<C> (a) ^ static_cast<C> (b));
 144 }
 145
 146 template<class C>
 147 inline const be_val<C> operator& (const be_val<C>& a, const be_val<C>& b)
 148 {
 149   return be_val<C>(static_cast<C> (a) & static_cast<C> (b));
 150 }
 151
 152 template<class C>
 153 inline const be_val<C> operator| (const be_val<C>& a, const be_val<C>& b)
 154 {
 155   return be_val<C>(static_cast<C> (a) | static_cast<C> (b));
 156 }
 157
 158 template<class C>
 159 inline const be_val<C> operator<< (const be_val<C>& a, const be_val<C>& b)
 160 {
 161   return be_val<C>(static_cast<C> (a) << static_cast<C> (b));
 162 }
 163
 164 template<class C>
 165 inline const be_val<C> operator>> (const be_val<C>& a, const be_val<C>& b)
 166 {
 167   return be_val<C>(static_cast<C> (a) >> static_cast<C> (b));
 168 }
 169
 170 template<class C>
 171 inline bool operator< (const be_val<C>& a, const be_val<C>& b)
 172 {
 173   return static_cast<C> (a) < static_cast<C> (b);
 174 }
 175
 176 template<class C>
 177 inline bool operator> (const be_val<C>& a, const be_val<C>& b)
 178 {
 179   return static_cast<C> (a) > static_cast<C> (b);
 180 }
 181
 182 template<class C>
 183 inline bool operator<= (const be_val<C>& a, const be_val<C>& b)
 184 {
 185   return static_cast<C> (a) <= static_cast<C> (b);
 186 }
 187
 188 template<class C>
 189 inline bool operator>= (const be_val<C>& a, const be_val<C>& b)
 190 {
 191   return static_cast<C> (a) >= static_cast<C> (b);
 192 }
 193
 194 template<class C>
 195 inline bool operator== (const be_val<C>& a, const be_val<C>& b)
 196 {
 197   return static_cast<C> (a) == static_cast<C> (b);
 198 }
 199
 200 template<class C>
 201 inline bool operator!= (const be_val<C>& a, const be_val<C>& b)
 202 {
 203   return static_cast<C> (a) != static_cast<C> (b);
 204 }