Implemented more general version of ForwardDiff/RevereseDiff.

webrtc/base/mod_ops.h

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_BASE_MOD_OPS_H_
 #define WEBRTC_BASE_MOD_OPS_H_
 
 #include <limits>
 #include <type_traits>
 
 #include "webrtc/base/checks.h"
 
-#define MOD_OPS_ASSERT_TYPE_IS_UNSIGNED(T)              \
-  static_assert(std::numeric_limits<T>::is_integer &&   \
-                    !std::numeric_limits<T>::is_signed, \
-                "Type must be of unsigned integer.")
-
 namespace webrtc {
 
 template <unsigned long M>                                    // NOLINT
 inline unsigned long Add(unsigned long a, unsigned long b) {  // NOLINT
   RTC_DCHECK_LT(a, M);
   unsigned long t = M - b % M;  // NOLINT
   unsigned long res = a - t;    // NOLINT
   if (t > a)
     return res + M;
   return res;
 }
 
 template <unsigned long M>                                         // NOLINT
 inline unsigned long Subtract(unsigned long a, unsigned long b) {  // NOLINT
   RTC_DCHECK_LT(a, M);
   unsigned long sub = b % M;  // NOLINT
   if (a < sub)
     return M - (sub - a);
   return a - sub;
 }
 
-// Calculates the forward difference between two numbers.
+// Calculates the forward difference between two wrapping numbers.
 //
 // Example:
 // uint8_t x = 253;
 // uint8_t y = 2;
 //
 // ForwardDiff(x, y) == 4
 //
 //   252   253   254   255    0     1     2     3
 // #################################################
 // |     |  x  |     |     |     |     |  y  |     |
 // #################################################
 //          |----->----->----->----->----->
 //
 // ForwardDiff(y, x) == 251
 //
 //   252   253   254   255    0     1     2     3
 // #################################################
 // |     |  x  |     |     |     |     |  y  |     |
 // #################################################
 // -->----->                              |----->---
 //
+template <typename T, T M>

[torbjorng (webrtc), 2016/03/11 14:54:22]

Do we want these functions to work for e.g., T=uint8_t and M=256? The problem is
that M cannot be represented as T.

Either M needs to be stored in T' which in such corner cases needs to be made
larger, or perhaps more neatly we could truncate modulo as per the implicit
modulus of the type and make sure the core works for that (without upsetting
picky compilers).

I assume the intended use here is for compile-time constants M, so we could wrap
things conditions on M without cost.

[philipel, 2016/03/11 16:04:38]

The other version is still available so you can do both:
ForwardDiff<uint8_t>(x, y)
ForwardDiff<uint8_t, 13>(x, y)

See line 71.

+inline T ForwardDiff(T a, T b) {
+  static_assert(std::is_unsigned<T>::value,
+                "Type must be of unsigned integer.");

[torbjorng (webrtc), 2016/03/11 14:54:22]

Please make more idiomatic, e.g., "Type must be an unsigned integer" or "Type
must of unsigned".

[philipel, 2016/03/11 16:04:38]

Done.

+  RTC_DCHECK_LT(a, M);
+  RTC_DCHECK_LT(b, M);
+  return a <= b ? b - a : M - (a - b);
+}
+
 template <typename T>
 inline T ForwardDiff(T a, T b) {
-  MOD_OPS_ASSERT_TYPE_IS_UNSIGNED(T);
+  static_assert(std::is_unsigned<T>::value,
+                "Type must be of unsigned integer.");
   return b - a;
 }
 
-// Calculates the reverse difference between two numbers.
+// Calculates the reverse difference between two wrapping numbers.
 //
 // Example:
 // uint8_t x = 253;
 // uint8_t y = 2;
 //
 // ReverseDiff(y, x) == 5
 //
 //   252   253   254   255    0     1     2     3
 // #################################################
 // |     |  x  |     |     |     |     |  y  |     |
 // #################################################
 //          <-----<-----<-----<-----<-----|
 //
 // ReverseDiff(x, y) == 251
 //
 //   252   253   254   255    0     1     2     3
 // #################################################
 // |     |  x  |     |     |     |     |  y  |     |
 // #################################################
 // ---<-----|                             |<-----<--
 //
+template <typename T, T M>
+inline T ReverseDiff(T a, T b) {
+  static_assert(std::is_unsigned<T>::value,
+                "Type must be of unsigned integer.");
+  RTC_DCHECK_LT(a, M);
+  RTC_DCHECK_LT(b, M);
+  return b <= a ? a - b : M - (b - a);
+}
+
 template <typename T>
 inline T ReverseDiff(T a, T b) {
-  MOD_OPS_ASSERT_TYPE_IS_UNSIGNED(T);
+  static_assert(std::is_unsigned<T>::value,
+                "Type must be of unsigned integer.");
   return a - b;
 }
 
 // Test if the sequence number a is ahead or at sequence number b.
 // If the two sequence numbers are at max distance from each other
 // then the sequence number with highest value is considered to
 // be ahead.
 template <typename T>
 inline bool AheadOrAt(T a, T b) {
-  MOD_OPS_ASSERT_TYPE_IS_UNSIGNED(T);
+  static_assert(std::is_unsigned<T>::value,
+                "Type must be of unsigned integer.");
   const T maxDist = std::numeric_limits<T>::max() / 2 + T(1);
   if (a - b == maxDist)
     return b < a;
   return ForwardDiff(b, a) < maxDist;
 }
 
 // Test if sequence number a is ahead of sequence number b.
 template <typename T>
 inline bool AheadOf(T a, T b) {
-  MOD_OPS_ASSERT_TYPE_IS_UNSIGNED(T);
+  static_assert(std::is_unsigned<T>::value,
+                "Type must be of unsigned integer.");
   return a != b && AheadOrAt(a, b);
 }
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_BASE_MOD_OPS_H_