Updated flatbuffers to the latest version.

Author: akb825

Shared/external/flatbuffers/allocator.h

@@ -28,21 +28,21 @@ class Allocator {
   virtual ~Allocator() {}
 
   // Allocate `size` bytes of memory.
-  virtual uint8_t *allocate(size_t size) = 0;
+  virtual uint8_t* allocate(size_t size) = 0;
 
   // Deallocate `size` bytes of memory at `p` allocated by this allocator.
-  virtual void deallocate(uint8_t *p, size_t size) = 0;
+  virtual void deallocate(uint8_t* p, size_t size) = 0;
 
   // Reallocate `new_size` bytes of memory, replacing the old region of size
   // `old_size` at `p`. In contrast to a normal realloc, this grows downwards,
   // and is intended specifcally for `vector_downward` use.
   // `in_use_back` and `in_use_front` indicate how much of `old_size` is
   // actually in use at each end, and needs to be copied.
-  virtual uint8_t *reallocate_downward(uint8_t *old_p, size_t old_size,
+  virtual uint8_t* reallocate_downward(uint8_t* old_p, size_t old_size,
                                        size_t new_size, size_t in_use_back,
                                        size_t in_use_front) {
     FLATBUFFERS_ASSERT(new_size > old_size);  // vector_downward only grows
-    uint8_t *new_p = allocate(new_size);
+    uint8_t* new_p = allocate(new_size);
     memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
                     in_use_front);
     deallocate(old_p, old_size);
@@ -54,7 +54,7 @@ class Allocator {
   // to `new_p` of `new_size`. Only memory of size `in_use_front` and
   // `in_use_back` will be copied from the front and back of the old memory
   // allocation.
-  void memcpy_downward(uint8_t *old_p, size_t old_size, uint8_t *new_p,
+  void memcpy_downward(uint8_t* old_p, size_t old_size, uint8_t* new_p,
                        size_t new_size, size_t in_use_back,
                        size_t in_use_front) {
     memcpy(new_p + new_size - in_use_back, old_p + old_size - in_use_back,

Shared/external/flatbuffers/array.h

@@ -27,17 +27,15 @@
 namespace flatbuffers {
 
 // This is used as a helper type for accessing arrays.
-template<typename T, uint16_t length> class Array {
+template <typename T, uint16_t length>
+class Array {
   // Array<T> can carry only POD data types (scalars or structs).
   typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
       scalar_tag;
-  typedef
-      typename flatbuffers::conditional<scalar_tag::value, T, const T *>::type
-          IndirectHelperType;
 
  public:
   typedef uint16_t size_type;
-  typedef typename IndirectHelper<IndirectHelperType>::return_type return_type;
+  typedef typename IndirectHelper<T>::return_type return_type;
   typedef VectorConstIterator<T, return_type, uoffset_t> const_iterator;
   typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
 
@@ -50,15 +48,16 @@ template<typename T, uint16_t length> class Array {
 
   return_type Get(uoffset_t i) const {
     FLATBUFFERS_ASSERT(i < size());
-    return IndirectHelper<IndirectHelperType>::Read(Data(), i);
+    return IndirectHelper<T>::Read(Data(), i);
   }
 
   return_type operator[](uoffset_t i) const { return Get(i); }
 
   // If this is a Vector of enums, T will be its storage type, not the enum
   // type. This function makes it convenient to retrieve value with enum
   // type E.
-  template<typename E> E GetEnum(uoffset_t i) const {
+  template <typename E>
+  E GetEnum(uoffset_t i) const {
     return static_cast<E>(Get(i));
   }
 
@@ -83,28 +82,28 @@ template<typename T, uint16_t length> class Array {
   // operation. For primitive types use @p Mutate directly.
   // @warning Assignments and reads to/from the dereferenced pointer are not
   //  automatically converted to the correct endianness.
-  typename flatbuffers::conditional<scalar_tag::value, void, T *>::type
+  typename flatbuffers::conditional<scalar_tag::value, void, T*>::type
   GetMutablePointer(uoffset_t i) const {
     FLATBUFFERS_ASSERT(i < size());
-    return const_cast<T *>(&data()[i]);
+    return const_cast<T*>(&data()[i]);
   }
 
   // Change elements if you have a non-const pointer to this object.
-  void Mutate(uoffset_t i, const T &val) { MutateImpl(scalar_tag(), i, val); }
+  void Mutate(uoffset_t i, const T& val) { MutateImpl(scalar_tag(), i, val); }
 
   // The raw data in little endian format. Use with care.
-  const uint8_t *Data() const { return data_; }
+  const uint8_t* Data() const { return data_; }
 
-  uint8_t *Data() { return data_; }
+  uint8_t* Data() { return data_; }
 
   // Similarly, but typed, much like std::vector::data
-  const T *data() const { return reinterpret_cast<const T *>(Data()); }
-  T *data() { return reinterpret_cast<T *>(Data()); }
+  const T* data() const { return reinterpret_cast<const T*>(Data()); }
+  T* data() { return reinterpret_cast<T*>(Data()); }
 
   // Copy data from a span with endian conversion.
   // If this Array and the span overlap, the behavior is undefined.
   void CopyFromSpan(flatbuffers::span<const T, length> src) {
-    const auto p1 = reinterpret_cast<const uint8_t *>(src.data());
+    const auto p1 = reinterpret_cast<const uint8_t*>(src.data());
     const auto p2 = Data();
     FLATBUFFERS_ASSERT(!(p1 >= p2 && p1 < (p2 + length)) &&
                        !(p2 >= p1 && p2 < (p1 + length)));
@@ -114,12 +113,12 @@ template<typename T, uint16_t length> class Array {
   }
 
  protected:
-  void MutateImpl(flatbuffers::true_type, uoffset_t i, const T &val) {
+  void MutateImpl(flatbuffers::true_type, uoffset_t i, const T& val) {
     FLATBUFFERS_ASSERT(i < size());
     WriteScalar(data() + i, val);
   }
 
-  void MutateImpl(flatbuffers::false_type, uoffset_t i, const T &val) {
+  void MutateImpl(flatbuffers::false_type, uoffset_t i, const T& val) {
     *(GetMutablePointer(i)) = val;
   }
 
@@ -134,7 +133,9 @@ template<typename T, uint16_t length> class Array {
   // Copy data from flatbuffers::span with endian conversion.
   void CopyFromSpanImpl(flatbuffers::false_type,
                         flatbuffers::span<const T, length> src) {
-    for (size_type k = 0; k < length; k++) { Mutate(k, src[k]); }
+    for (size_type k = 0; k < length; k++) {
+      Mutate(k, src[k]);
+    }
   }
 
   // This class is only used to access pre-existing data. Don't ever
@@ -153,21 +154,21 @@ template<typename T, uint16_t length> class Array {
  private:
   // This class is a pointer. Copying will therefore create an invalid object.
   // Private and unimplemented copy constructor.
-  Array(const Array &);
-  Array &operator=(const Array &);
+  Array(const Array&);
+  Array& operator=(const Array&);
 };
 
 // Specialization for Array[struct] with access using Offset<void> pointer.
 // This specialization used by idl_gen_text.cpp.
-template<typename T, uint16_t length, template<typename> class OffsetT>
+template <typename T, uint16_t length, template <typename> class OffsetT>
 class Array<OffsetT<T>, length> {
   static_assert(flatbuffers::is_same<T, void>::value, "unexpected type T");
 
  public:
-  typedef const void *return_type;
+  typedef const void* return_type;
   typedef uint16_t size_type;
 
-  const uint8_t *Data() const { return data_; }
+  const uint8_t* Data() const { return data_; }
 
   // Make idl_gen_text.cpp::PrintContainer happy.
   return_type operator[](uoffset_t) const {
@@ -178,41 +179,41 @@ class Array<OffsetT<T>, length> {
  private:
   // This class is only used to access pre-existing data.
   Array();
-  Array(const Array &);
-  Array &operator=(const Array &);
+  Array(const Array&);
+  Array& operator=(const Array&);
 
   uint8_t data_[1];
 };
 
-template<class U, uint16_t N>
-FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U, N> make_span(Array<U, N> &arr)
+template <class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U, N> make_span(Array<U, N>& arr)
     FLATBUFFERS_NOEXCEPT {
   static_assert(
       Array<U, N>::is_span_observable,
       "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
   return span<U, N>(arr.data(), N);
 }
 
-template<class U, uint16_t N>
+template <class U, uint16_t N>
 FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U, N> make_span(
-    const Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+    const Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
   static_assert(
       Array<U, N>::is_span_observable,
       "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
   return span<const U, N>(arr.data(), N);
 }
 
-template<class U, uint16_t N>
+template <class U, uint16_t N>
 FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t, sizeof(U) * N>
-make_bytes_span(Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+make_bytes_span(Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
   static_assert(Array<U, N>::is_span_observable,
                 "internal error, Array<T> might hold only scalars or structs");
   return span<uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
 }
 
-template<class U, uint16_t N>
+template <class U, uint16_t N>
 FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t, sizeof(U) * N>
-make_bytes_span(const Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+make_bytes_span(const Array<U, N>& arr) FLATBUFFERS_NOEXCEPT {
   static_assert(Array<U, N>::is_span_observable,
                 "internal error, Array<T> might hold only scalars or structs");
   return span<const uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
@@ -221,31 +222,31 @@ make_bytes_span(const Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
 // Cast a raw T[length] to a raw flatbuffers::Array<T, length>
 // without endian conversion. Use with care.
 // TODO: move these Cast-methods to `internal` namespace.
-template<typename T, uint16_t length>
-Array<T, length> &CastToArray(T (&arr)[length]) {
-  return *reinterpret_cast<Array<T, length> *>(arr);
+template <typename T, uint16_t length>
+Array<T, length>& CastToArray(T (&arr)[length]) {
+  return *reinterpret_cast<Array<T, length>*>(arr);
 }
 
-template<typename T, uint16_t length>
-const Array<T, length> &CastToArray(const T (&arr)[length]) {
-  return *reinterpret_cast<const Array<T, length> *>(arr);
+template <typename T, uint16_t length>
+const Array<T, length>& CastToArray(const T (&arr)[length]) {
+  return *reinterpret_cast<const Array<T, length>*>(arr);
 }
 
-template<typename E, typename T, uint16_t length>
-Array<E, length> &CastToArrayOfEnum(T (&arr)[length]) {
+template <typename E, typename T, uint16_t length>
+Array<E, length>& CastToArrayOfEnum(T (&arr)[length]) {
   static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
-  return *reinterpret_cast<Array<E, length> *>(arr);
+  return *reinterpret_cast<Array<E, length>*>(arr);
 }
 
-template<typename E, typename T, uint16_t length>
-const Array<E, length> &CastToArrayOfEnum(const T (&arr)[length]) {
+template <typename E, typename T, uint16_t length>
+const Array<E, length>& CastToArrayOfEnum(const T (&arr)[length]) {
   static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
-  return *reinterpret_cast<const Array<E, length> *>(arr);
+  return *reinterpret_cast<const Array<E, length>*>(arr);
 }
 
-template<typename T, uint16_t length>
-bool operator==(const Array<T, length> &lhs,
-                const Array<T, length> &rhs) noexcept {
+template <typename T, uint16_t length>
+bool operator==(const Array<T, length>& lhs,
+                const Array<T, length>& rhs) noexcept {
   return std::addressof(lhs) == std::addressof(rhs) ||
          (lhs.size() == rhs.size() &&
           std::memcmp(lhs.Data(), rhs.Data(), rhs.size() * sizeof(T)) == 0);

Shared/external/flatbuffers/base.h

@@ -139,9 +139,9 @@
   #endif
 #endif // !defined(FLATBUFFERS_LITTLEENDIAN)
 
-#define FLATBUFFERS_VERSION_MAJOR 24
-#define FLATBUFFERS_VERSION_MINOR 3
-#define FLATBUFFERS_VERSION_REVISION 25
+#define FLATBUFFERS_VERSION_MAJOR 25
+#define FLATBUFFERS_VERSION_MINOR 9
+#define FLATBUFFERS_VERSION_REVISION 23
 #define FLATBUFFERS_STRING_EXPAND(X) #X
 #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
 namespace flatbuffers {
@@ -339,15 +339,15 @@ typedef uint16_t voffset_t;
 typedef uintmax_t largest_scalar_t;
 
 // In 32bits, this evaluates to 2GB - 1
-#define FLATBUFFERS_MAX_BUFFER_SIZE std::numeric_limits<::flatbuffers::soffset_t>::max()
-#define FLATBUFFERS_MAX_64_BUFFER_SIZE std::numeric_limits<::flatbuffers::soffset64_t>::max()
+#define FLATBUFFERS_MAX_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset_t>::max)()
+#define FLATBUFFERS_MAX_64_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset64_t>::max)()
 
 // The minimum size buffer that can be a valid flatbuffer.
 // Includes the offset to the root table (uoffset_t), the offset to the vtable
 // of the root table (soffset_t), the size of the vtable (uint16_t), and the
 // size of the referring table (uint16_t).
-#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(uoffset_t) + sizeof(soffset_t) + \
-   sizeof(uint16_t) + sizeof(uint16_t)
+#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(::flatbuffers::uoffset_t) + \
+  sizeof(::flatbuffers::soffset_t) + sizeof(uint16_t) + sizeof(uint16_t)
 
 // We support aligning the contents of buffers up to this size.
 #ifndef FLATBUFFERS_MAX_ALIGNMENT
@@ -459,10 +459,17 @@ inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {
   return ((~buf_size) + 1) & (scalar_size - 1);
 }
 
+#if !defined(_MSC_VER)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
 // Generic 'operator==' with conditional specialisations.
 // T e - new value of a scalar field.
 // T def - default of scalar (is known at compile-time).
 template<typename T> inline bool IsTheSameAs(T e, T def) { return e == def; }
+#if !defined(_MSC_VER)
+  #pragma GCC diagnostic pop
+#endif
 
 #if defined(FLATBUFFERS_NAN_DEFAULTS) && \
     defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)