Use a single function, FieldValue::Increment, for both integer and double arguments.

See go/firestore-cpp-field-value-increment for more background and rationale.

This requires some template metaprogramming but results in a more convenient and safer API. In particular, `static_assert` allows preventing truncation with a readable error message (e.g. if a user passes `unsigned long long` as an argument).

While working on this, I discovered that STLPort actually does contain `<type_traits>` header, so the STLPort implementation is pretty straightforward (the only extra complication is accounting for the nested `tr1` namespace). I checked the code from this CL manually in Android Studio using STLPort on NDK r17, and it compiled successfully.

PiperOrigin-RevId: 308336176

Author: var-const

app/meta/type_traits.h

@@ -18,6 +18,7 @@
 #define FIREBASE_APP_CLIENT_CPP_META_TYPE_TRAITS_H_
 
 #include <cstdlib>
+#include <type_traits>
 
 #if !defined(FIREBASE_NAMESPACE)
 #define FIREBASE_NAMESPACE firebase
@@ -65,6 +66,57 @@ struct is_lvalue_reference<T&> {
   static constexpr bool value = true;
 };
 
+// STLPort does include <type_traits> header, but its contents are in `std::tr1`
+// namespace. To work around this, use aliases.
+// TODO(varconst): all of the reimplementations of traits above can be replaced
+// with appropriate aliases.
+// TODO(varconst): the traits in this file would be more conformant if they
+// inherited from `std::integral_constant`.
+#ifdef STLPORT
+#define FIREBASE_TYPE_TRAITS_NS std::tr1
+#else
+#define FIREBASE_TYPE_TRAITS_NS std
+#endif
+
+template <bool value, typename T = void>
+using enable_if = FIREBASE_TYPE_TRAITS_NS::enable_if<value, T>;
+
+template <typename T>
+using is_floating_point = FIREBASE_TYPE_TRAITS_NS::is_floating_point<T>;
+
+template <typename T>
+using is_integral = FIREBASE_TYPE_TRAITS_NS::is_integral<T>;
+
+template <typename T, typename U>
+using is_same = FIREBASE_TYPE_TRAITS_NS::is_same<T, U>;
+
+template <typename T, T value>
+using integral_constant = FIREBASE_TYPE_TRAITS_NS::integral_constant<T, value>;
+
+#undef FIREBASE_TYPE_TRAITS_NS
+
+// `is_char<T>::value` is true iff `T` is a character type (including `wchar_t`
+// and C++11 fixed-width character types).
+template <typename T>
+struct is_char {
+  static constexpr bool value =
+#if __cplusplus >= 202002L
+      is_same<T, char8_t>::value ||
+#endif
+#if __cplusplus >= 201103L
+      is_same<T, char16_t>::value || is_same<T, char32_t>::value ||
+#endif
+      is_same<T, char>::value || is_same<T, signed char>::value ||
+      is_same<T, unsigned char>::value || is_same<T, wchar_t>::value;
+};
+
+// A subset of `std::is_integral`: excludes `bool` and character types.
+template <typename T>
+struct is_integer {
+  static constexpr bool value =
+      is_integral<T>::value && !is_same<T, bool>::value && !is_char<T>::value;
+};
+
 // NOLINTNEXTLINE - allow namespace overridden
 }  // namespace FIREBASE_NAMESPACE
 

firestore/src/common/field_value.cc

@@ -256,19 +256,15 @@ FieldValue FieldValue::ArrayRemove(std::vector<FieldValue> elements) {
   return FieldValueInternal::ArrayRemove(firebase::Move(elements));
 }
 
-#if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
 /* static */
 FieldValue FieldValue::IntegerIncrement(int64_t by_value) {
   return FieldValueInternal::IntegerIncrement(by_value);
 }
-#endif  // if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
 
-#if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
 /* static */
 FieldValue FieldValue::DoubleIncrement(double by_value) {
   return FieldValueInternal::DoubleIncrement(by_value);
 }
-#endif  // if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
 
 // TODO(varconst): consider reversing the role of the two output functions, so
 // that `ToString` delegates to `operator<<`, not the other way round.
@@ -322,10 +318,8 @@ std::string FieldValue::ToString() const {
       return "FieldValue::ArrayRemove()";
 
     case Type::kIncrementInteger:
-      return "FieldValue::IntegerIncrement()";
-
     case Type::kIncrementDouble:
-      return "FieldValue::DoubleIncrement()";
+      return "FieldValue::Increment()";
   }
 
   FIREBASE_ASSERT_MESSAGE_RETURN("<invalid>", false,

firestore/src/include/firebase/firestore/field_value.h

@@ -19,9 +19,11 @@
 
 #include <cstdint>
 #include <iosfwd>
+#include <limits>
 #include <string>
 #include <vector>
 
+#include "app/meta/type_traits.h"
 #include "firebase/firestore/map_field_value.h"
 
 namespace firebase {
@@ -50,6 +52,17 @@ class GeoPoint;
  * foo_value() will fail (and cause a crash).
  */
 class FieldValue final {
+  // Helper aliases for `Increment` member functions.
+  // Qualifying `is_integer` is to prevent ambiguity with the
+  // `FieldValue::is_integer` member function.
+  // Note: normally, `enable_if::type` would be included in the alias, but such
+  // a declaration breaks SWIG (presumably, SWIG cannot handle `typename` within
+  // an alias template).
+  template <typename T>
+  using EnableIfIntegral = enable_if<::firebase::is_integer<T>::value, int>;
+  template <typename T>
+  using EnableIfFloatingPoint = enable_if<is_floating_point<T>::value, int>;
+
  public:
   /**
    * The enumeration of all valid runtime types of FieldValue.
@@ -315,7 +328,8 @@ class FieldValue final {
 #if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
   /**
    * Returns a special value that can be used with `Set()` or `Update()` that
-   * tells the server to increment the field's current value by the given value.
+   * tells the server to increment the field's current value by the given
+   * integer value.
    *
    * If the current field value is an integer, possible integer overflows are
    * resolved to `LONG_MAX` or `LONG_MIN`. If the current field value is a
@@ -325,16 +339,29 @@ class FieldValue final {
    * If field is not an integer or a double, or if the field does not yet exist,
    * the transformation will set the field to the given value.
    *
-   * @param by_value The integer value to increment by.
+   * @param by_value The integer value to increment by. Should be an integer
+   * type not larger than `int64_t`.
    * @return The FieldValue sentinel for use in a call to `Set()` or `Update().`
    */
-  static FieldValue IntegerIncrement(int64_t by_value);
+  template <typename T, typename EnableIfIntegral<T>::type = 0>
+  static FieldValue Increment(T by_value) {
+    // Note: Doxygen will run into trouble if this function's definition is
+    // moved outside the class body.
+    static_assert(
+        std::numeric_limits<T>::max() <= std::numeric_limits<int64_t>::max(),
+        "The integer type you provided is larger than can fit in an int64_t. "
+        "If you are sure the value will not be truncated, please explicitly "
+        "cast to int64_t before passing it to FieldValue::Increment().");
+    return IntegerIncrement(static_cast<int64_t>(by_value));
+  }
+
 #endif  // if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
 
 #if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
   /**
    * Returns a special value that can be used with `Set()` or `Update()` that
-   * tells the server to increment the field's current value by the given value.
+   * tells the server to increment the field's current value by the given
+   * floating point value.
    *
    * If the current field value is an integer, possible integer overflows are
    * resolved to `LONG_MAX` or `LONG_MIN`. If the current field value is a
@@ -344,10 +371,23 @@ class FieldValue final {
    * If field is not an integer or a double, or if the field does not yet exist,
    * the transformation will set the field to the given value.
    *
-   * @param by_value The double value to increment by.
+   * @param by_value The double value to increment by. Should be a floating
+   * point type no larger than `double`.
    * @return The FieldValue sentinel for use in a call to `Set()` or `Update().`
    */
-  static FieldValue DoubleIncrement(double by_value);
+  template <typename T, typename EnableIfFloatingPoint<T>::type = 0>
+  static FieldValue Increment(T by_value) {
+    // Note: Doxygen will run into trouble if this function's definition is
+    // moved outside the class body.
+    static_assert(
+        std::numeric_limits<T>::max() <= std::numeric_limits<double>::max(),
+        "The floating point type you provided is larger than can fit in a "
+        "double. If you are sure the value will not be truncated, please "
+        "explicitly cast to double before passing it to "
+        "FieldValue::Increment().");
+    return DoubleIncrement(static_cast<double>(by_value));
+  }
+
 #endif  // if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
 
   /**
@@ -380,6 +420,9 @@ class FieldValue final {
 
   explicit FieldValue(FieldValueInternal* internal);
 
+  static FieldValue IntegerIncrement(int64_t by_value);
+  static FieldValue DoubleIncrement(double by_value);
+
   FieldValueInternal* internal_ = nullptr;
 };
 

firestore/src/ios/field_value_ios.cc

@@ -236,9 +236,8 @@ std::string Describe(Type type) {
     case Type::kArrayRemove:
       return "FieldValue::ArrayRemove()";
     case Type::kIncrementInteger:
-      return "FieldValue::IntegerIncrement()";
     case Type::kIncrementDouble:
-      return "FieldValue::DoubleIncrement()";
+      return "FieldValue::Increment()";
     default: {
       // TODO(b/147444199): use string formatting.
       // HARD_FAIL("Unexpected type '%s'", type);