mfbt/Saturate.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* Provides saturation arithmetics for scalar types. */
   8
   9 #ifndef mozilla_Saturate_h
  10 #define mozilla_Saturate_h
  11
  12 #include "mozilla/Attributes.h"
  13 #include "mozilla/Move.h"
  14 #include "mozilla/TypeTraits.h"
  15
  16 #include <limits>
  17
  18 namespace mozilla {
  19 namespace detail {
  20
  21 /**
  22  * |SaturateOp<T>| wraps scalar values for saturation arithmetics. Usage:
  23  *
  24  *    uint32_t value = 1;
  25  *
  26  *    ++SaturateOp<uint32_t>(value); // value is 2
  27  *    --SaturateOp<uint32_t>(value); // value is 1
  28  *    --SaturateOp<uint32_t>(value); // value is 0
  29  *    --SaturateOp<uint32_t>(value); // value is still 0
  30  *
  31  * Please add new operators when required.
  32  *
  33  * |SaturateOp<T>| will saturate at the minimum and maximum values of
  34  * type T. If you need other bounds, implement a clamped-type class and
  35  * specialize the type traits accordingly.
  36  */
  37 template <typename T>
  38 class SaturateOp
  39 {
  40 public:
  41   explicit SaturateOp(T& aValue)
  42     : mValue(aValue)
  43   {
  44     // We should actually check for |std::is_scalar<T>::value| to be
  45     // true, but this type trait is not available everywhere. Relax
  46     // this assertion if you want to use floating point values as well.
  47     static_assert(IsIntegral<T>::value,
  48                   "Integral type required in instantiation");
  49   }
  50
  51   // Add and subtract operators
  52
  53   T operator+(const T& aRhs) const
  54   {
  55     return T(mValue) += aRhs;
  56   }
  57
  58   T operator-(const T& aRhs) const
  59   {
  60     return T(mValue) -= aRhs;
  61   }
  62
  63   // Compound operators
  64
  65   const T& operator+=(const T& aRhs) const
  66   {
  67     const T min = std::numeric_limits<T>::min();
  68     const T max = std::numeric_limits<T>::max();
  69
  70     if (aRhs > static_cast<T>(0)) {
  71       mValue = (max - aRhs) < mValue ? max : mValue + aRhs;
  72     } else {
  73       mValue = (min - aRhs) > mValue ? min : mValue + aRhs;
  74     }
  75     return mValue;
  76   }
  77
  78   const T& operator-=(const T& aRhs) const
  79   {
  80     const T min = std::numeric_limits<T>::min();
  81     const T max = std::numeric_limits<T>::max();
  82
  83     if (aRhs > static_cast<T>(0)) {
  84       mValue = (min + aRhs) > mValue ? min : mValue - aRhs;
  85     } else {
  86       mValue = (max + aRhs) < mValue ? max : mValue - aRhs;
  87     }
  88     return mValue;
  89   }
  90
  91   // Increment and decrement operators
  92
  93   const T& operator++() const // prefix
  94   {
  95     return operator+=(static_cast<T>(1));
  96   }
  97
  98   T operator++(int) const // postfix
  99   {
 100     const T value(mValue);
 101     operator++();
 102     return value;
 103   }
 104
 105   const T& operator--() const // prefix
 106   {
 107     return operator-=(static_cast<T>(1));
 108   }
 109
 110   T operator--(int) const // postfix
 111   {
 112     const T value(mValue);
 113     operator--();
 114     return value;
 115   }
 116
 117 private:
 118   SaturateOp(const SaturateOp<T>&) = delete;
 119   SaturateOp(SaturateOp<T>&&) = delete;
 120   SaturateOp& operator=(const SaturateOp<T>&) = delete;
 121   SaturateOp& operator=(SaturateOp<T>&&) = delete;
 122
 123   T& mValue;
 124 };
 125
 126 /**
 127  * |Saturate<T>| is a value type for saturation arithmetics. It's
 128  * build on top of |SaturateOp<T>|.
 129  */
 130 template <typename T>
 131 class Saturate
 132 {
 133 public:
 134   Saturate() = default;
 135   MOZ_IMPLICIT Saturate(const Saturate<T>&) = default;
 136
 137   MOZ_IMPLICIT Saturate(Saturate<T>&& aValue)
 138   {
 139     mValue = std::move(aValue.mValue);
 140   }
 141
 142   explicit Saturate(const T& aValue)
 143     : mValue(aValue)
 144   { }
 145
 146   const T& value() const
 147   {
 148     return mValue;
 149   }
 150
 151   // Compare operators
 152
 153   bool operator==(const Saturate<T>& aRhs) const
 154   {
 155     return mValue == aRhs.mValue;
 156   }
 157
 158   bool operator!=(const Saturate<T>& aRhs) const
 159   {
 160     return !operator==(aRhs);
 161   }
 162
 163   bool operator==(const T& aRhs) const
 164   {
 165     return mValue == aRhs;
 166   }
 167
 168   bool operator!=(const T& aRhs) const
 169   {
 170     return !operator==(aRhs);
 171   }
 172
 173   // Assignment operators
 174
 175   Saturate<T>& operator=(const Saturate<T>&) = default;
 176
 177   Saturate<T>& operator=(Saturate<T>&& aRhs)
 178   {
 179     mValue = std::move(aRhs.mValue);
 180     return *this;
 181   }
 182
 183   // Add and subtract operators
 184
 185   Saturate<T> operator+(const Saturate<T>& aRhs) const
 186   {
 187     Saturate<T> lhs(mValue);
 188     return lhs += aRhs.mValue;
 189   }
 190
 191   Saturate<T> operator+(const T& aRhs) const
 192   {
 193     Saturate<T> lhs(mValue);
 194     return lhs += aRhs;
 195   }
 196
 197   Saturate<T> operator-(const Saturate<T>& aRhs) const
 198   {
 199     Saturate<T> lhs(mValue);
 200     return lhs -= aRhs.mValue;
 201   }
 202
 203   Saturate<T> operator-(const T& aRhs) const
 204   {
 205     Saturate<T> lhs(mValue);
 206     return lhs -= aRhs;
 207   }
 208
 209   // Compound operators
 210
 211   Saturate<T>& operator+=(const Saturate<T>& aRhs)
 212   {
 213     SaturateOp<T>(mValue) += aRhs.mValue;
 214     return *this;
 215   }
 216
 217   Saturate<T>& operator+=(const T& aRhs)
 218   {
 219     SaturateOp<T>(mValue) += aRhs;
 220     return *this;
 221   }
 222
 223   Saturate<T>& operator-=(const Saturate<T>& aRhs)
 224   {
 225     SaturateOp<T>(mValue) -= aRhs.mValue;
 226     return *this;
 227   }
 228
 229   Saturate<T>& operator-=(const T& aRhs)
 230   {
 231     SaturateOp<T>(mValue) -= aRhs;
 232     return *this;
 233   }
 234
 235   // Increment and decrement operators
 236
 237   Saturate<T>& operator++() // prefix
 238   {
 239     ++SaturateOp<T>(mValue);
 240     return *this;
 241   }
 242
 243   Saturate<T> operator++(int) // postfix
 244   {
 245     return Saturate<T>(SaturateOp<T>(mValue)++);
 246   }
 247
 248   Saturate<T>& operator--() // prefix
 249   {
 250     --SaturateOp<T>(mValue);
 251     return *this;
 252   }
 253
 254   Saturate<T> operator--(int) // postfix
 255   {
 256     return Saturate<T>(SaturateOp<T>(mValue)--);
 257   }
 258
 259 private:
 260   T mValue;
 261 };
 262
 263 } // namespace detail
 264
 265 typedef detail::Saturate<int8_t> SaturateInt8;
 266 typedef detail::Saturate<int16_t> SaturateInt16;
 267 typedef detail::Saturate<int32_t> SaturateInt32;
 268 typedef detail::Saturate<uint8_t> SaturateUint8;
 269 typedef detail::Saturate<uint16_t> SaturateUint16;
 270 typedef detail::Saturate<uint32_t> SaturateUint32;
 271
 272 } // namespace mozilla
 273
 274 template<typename LhsT, typename RhsT>
 275 bool
 276 operator==(LhsT aLhs, const mozilla::detail::Saturate<RhsT>& aRhs)
 277 {
 278   return aRhs.operator==(static_cast<RhsT>(aLhs));
 279 }
 280
 281 template<typename LhsT, typename RhsT>
 282 bool
 283 operator!=(LhsT aLhs, const mozilla::detail::Saturate<RhsT>& aRhs)
 284 {
 285   return !(aLhs == aRhs);
 286 }
 287
 288 #endif // mozilla_Saturate_h