Updated flatbuffers.

Author: akb825

Shared/external/flatbuffers/array.h

@@ -39,10 +39,11 @@ class Array {
   typedef VectorConstIterator<T, return_type, uoffset_t> const_iterator;
   typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
 
-  // If T is a LE-scalar or a struct (!scalar_tag::value).
+  // If T is a non-pointer and a LE-scalar or a struct (!scalar_tag::value).
   static FLATBUFFERS_CONSTEXPR bool is_span_observable =
-      (scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1)) ||
-      !scalar_tag::value;
+      !std::is_pointer<T>::value &&
+      ((scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1)) ||
+       !scalar_tag::value);
 
   FLATBUFFERS_CONSTEXPR uint16_t size() const { return length; }
 

Shared/external/flatbuffers/base.h

@@ -140,8 +140,8 @@
 #endif // !defined(FLATBUFFERS_LITTLEENDIAN)
 
 #define FLATBUFFERS_VERSION_MAJOR 25
-#define FLATBUFFERS_VERSION_MINOR 9
-#define FLATBUFFERS_VERSION_REVISION 23
+#define FLATBUFFERS_VERSION_MINOR 12
+#define FLATBUFFERS_VERSION_REVISION 19
 #define FLATBUFFERS_STRING_EXPAND(X) #X
 #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
 namespace flatbuffers {
@@ -267,11 +267,11 @@ namespace flatbuffers {
 
 #ifndef FLATBUFFERS_LOCALE_INDEPENDENT
   // Enable locale independent functions {strtof_l, strtod_l,strtoll_l,
-  // strtoull_l}.
+  // strtoull_l} on platforms that support them.
   #if (defined(_MSC_VER) && _MSC_VER >= 1800) || \
-      (defined(__ANDROID_API__) && __ANDROID_API__>= 21) || \
+      (defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__>= 26) || \
       (defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 700)) && \
-        (!defined(__Fuchsia__) && !defined(__ANDROID_API__))
+      !defined(__Fuchsia__)
     #define FLATBUFFERS_LOCALE_INDEPENDENT 1
   #else
     #define FLATBUFFERS_LOCALE_INDEPENDENT 0

Shared/external/flatbuffers/flatbuffer_builder.h

@@ -470,7 +470,8 @@ class FlatBufferBuilderImpl {
       for (auto it = buf_.scratch_data(); it < buf_.scratch_end();
            it += sizeof(uoffset_t)) {
         auto vt_offset_ptr = reinterpret_cast<uoffset_t*>(it);
-        auto vt2 = reinterpret_cast<voffset_t*>(buf_.data_at(*vt_offset_ptr));
+        auto vt2 = reinterpret_cast<voffset_t*>(
+            buf_.data_at(*vt_offset_ptr + length_of_64_bit_region_));
         auto vt2_size = ReadScalar<voffset_t>(vt2);
         if (vt1_size != vt2_size || 0 != memcmp(vt2, vt1, vt1_size)) continue;
         vt_use = *vt_offset_ptr;
@@ -834,6 +835,16 @@ class FlatBufferBuilderImpl {
     return Offset<Vector<uint8_t>>(EndVector(v.size()));
   }
 
+  Offset64<Vector64<uint8_t>> CreateVector64(const std::vector<bool>& v) {
+    StartVector<uint8_t, Offset64, Vector64<uint8_t>::size_type>(v.size());
+    for (auto i = v.size(); i > 0;) {
+      PushElement(static_cast<uint8_t>(v[--i]));
+    }
+    return Offset64<Vector64<uint8_t>>(
+        EndVector<Vector64<uint8_t>::size_type,
+                  Offset64<Vector64<uint8_t>>::offset_type>(v.size()));
+  }
+
   /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
   /// This is a convenience function that takes care of iteration for you.
   /// @tparam T The data type of the `std::vector` elements.

Shared/external/flatbuffers/stl_emulation.h

@@ -47,7 +47,9 @@
   // See: https://en.cppreference.com/w/cpp/utility/feature_test
   #if defined(__cplusplus) && __cplusplus >= 202002L \
       || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
-    #define FLATBUFFERS_USE_STD_SPAN 1
+    #if __has_include(<span>)
+      #define FLATBUFFERS_USE_STD_SPAN 1
+    #endif
   #endif
 #endif // FLATBUFFERS_USE_STD_SPAN
 
@@ -321,7 +323,7 @@ namespace internal {
     SpanIterator(pointer ptr) : ptr_(ptr) {}
     reference operator*() const { return *ptr_; }
     pointer operator->() { return ptr_; }
-    SpanIterator& operator++() { ptr_++; return *this; }  
+    SpanIterator& operator++() { ptr_++; return *this; }
     SpanIterator  operator++(int) { auto tmp = *this; ++(*this); return tmp; }
 
     friend bool operator== (const SpanIterator& lhs, const SpanIterator& rhs) { return lhs.ptr_ == rhs.ptr_; }

Shared/external/flatbuffers/table.h

@@ -18,6 +18,7 @@
 #define FLATBUFFERS_TABLE_H_
 
 #include "flatbuffers/base.h"
+#include "flatbuffers/vector.h"
 #include "flatbuffers/verifier.h"
 
 namespace flatbuffers {
@@ -70,6 +71,32 @@ class Table {
     return GetPointer<P, uoffset64_t>(field);
   }
 
+  template <typename P, typename SizeT = uoffset_t,
+            typename OffsetSize = uoffset_t>
+  const Vector<P, SizeT>* GetVectorPointerOrEmpty(voffset_t field) const {
+    auto* ptr = GetPointer<const Vector<P, SizeT>*, OffsetSize>(field);
+    return ptr ? ptr : EmptyVector<P, SizeT>();
+  }
+
+  template <typename P, typename SizeT = uoffset_t>
+  const Vector<P, SizeT>* GetVectorPointer64OrEmpty(voffset_t field) const {
+    return GetVectorPointerOrEmpty<P, SizeT, uoffset64_t>(field);
+  }
+
+  template <typename P, typename SizeT = uoffset_t,
+            typename OffsetSize = uoffset_t>
+  Vector<P, SizeT>* GetMutableVectorPointerOrEmpty(voffset_t field) {
+    auto* ptr = GetPointer<Vector<P, SizeT>*, OffsetSize>(field);
+    // This is a const_cast, but safe, since all mutable operations on an
+    // empty vector are NOPs.
+    return ptr ? ptr : const_cast<Vector<P, SizeT>*>(EmptyVector<P, SizeT>());
+  }
+
+  template <typename P, typename SizeT = uoffset_t>
+  Vector<P, SizeT>* GetMutableVectorPointer64OrEmpty(voffset_t field) {
+    return GetMutableVectorPointerOrEmpty<P, SizeT, uoffset64_t>(field);
+  }
+
   template <typename P>
   P GetStruct(voffset_t field) const {
     auto field_offset = GetOptionalFieldOffset(field);
@@ -122,52 +149,94 @@ class Table {
 
   // Verify the vtable of this table.
   // Call this once per table, followed by VerifyField once per field.
-  bool VerifyTableStart(Verifier& verifier) const {
+  template <bool B>
+  bool VerifyTableStart(VerifierTemplate<B>& verifier) const {
     return verifier.VerifyTableStart(data_);
   }
 
   // Verify a particular field.
-  template <typename T>
-  bool VerifyField(const Verifier& verifier, voffset_t field,
+  template <typename T, bool B>
+  bool VerifyField(const VerifierTemplate<B>& verifier, voffset_t field,
                    size_t align) const {
     // Calling GetOptionalFieldOffset should be safe now thanks to
     // VerifyTable().
     auto field_offset = GetOptionalFieldOffset(field);
     // Check the actual field.
-    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
+    return !field_offset ||
+           verifier.template VerifyField<T>(data_, field_offset, align);
   }
 
   // VerifyField for required fields.
-  template <typename T>
-  bool VerifyFieldRequired(const Verifier& verifier, voffset_t field,
+  template <typename T, bool B>
+  bool VerifyFieldRequired(const VerifierTemplate<B>& verifier, voffset_t field,
                            size_t align) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return verifier.Check(field_offset != 0) &&
-           verifier.VerifyField<T>(data_, field_offset, align);
+           verifier.template VerifyField<T>(data_, field_offset, align);
   }
 
   // Versions for offsets.
-  template <typename OffsetT = uoffset_t>
-  bool VerifyOffset(const Verifier& verifier, voffset_t field) const {
+  template <typename OffsetT = uoffset_t, bool B = false>
+  bool VerifyOffset(const VerifierTemplate<B>& verifier,
+                    voffset_t field) const {
     auto field_offset = GetOptionalFieldOffset(field);
-    return !field_offset || verifier.VerifyOffset<OffsetT>(data_, field_offset);
+    return !field_offset ||
+           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
   }
 
-  template <typename OffsetT = uoffset_t>
-  bool VerifyOffsetRequired(const Verifier& verifier, voffset_t field) const {
+  template <typename OffsetT = uoffset_t, bool B = false>
+  bool VerifyOffsetRequired(const VerifierTemplate<B>& verifier,
+                            voffset_t field) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return verifier.Check(field_offset != 0) &&
-           verifier.VerifyOffset<OffsetT>(data_, field_offset);
+           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
   }
 
-  bool VerifyOffset64(const Verifier& verifier, voffset_t field) const {
+  template <bool B>
+  bool VerifyOffset64(const VerifierTemplate<B>& verifier,
+                      voffset_t field) const {
     return VerifyOffset<uoffset64_t>(verifier, field);
   }
 
-  bool VerifyOffset64Required(const Verifier& verifier, voffset_t field) const {
+  template <bool B>
+  bool VerifyOffset64Required(const VerifierTemplate<B>& verifier,
+                              voffset_t field) const {
     return VerifyOffsetRequired<uoffset64_t>(verifier, field);
   }
 
+  // Verify a string that may have a default value.
+  template <typename OffsetT = uoffset_t>
+  bool VerifyStringWithDefault(const Verifier& verifier,
+                               voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset == 0 ||
+           verifier.VerifyString(GetPointer<const String*, OffsetT>(field));
+  }
+
+  // Verify a vector that has a default empty value.
+  template <typename P, typename SizeT = uoffset_t,
+            typename OffsetSize = uoffset_t>
+  bool VerifyVectorWithDefault(const Verifier& verifier,
+                               voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset == 0 ||
+           verifier.VerifyVector(
+               GetPointer<const Vector<P, SizeT>*, OffsetSize>(field));
+  }
+
+  template <typename P, typename SizeT = uoffset_t>
+  bool VerifyVector64WithDefault(const Verifier& verifier,
+                                 voffset_t field) const {
+    return VerifyVectorWithDefault<P, SizeT, uoffset64_t>(verifier, field);
+  }
+
+ protected:
+  template <typename T, typename SizeT = uoffset_t>
+  static const Vector<T, SizeT>* EmptyVector() {
+    static const SizeT empty_vector_length = 0;
+    return reinterpret_cast<const Vector<T, SizeT>*>(&empty_vector_length);
+  }
+
  private:
   // private constructor & copy constructor: you obtain instances of this
   // class by pointing to existing data only

Shared/external/flatbuffers/vector.h

@@ -172,7 +172,8 @@ class Vector {
       scalar_tag;
 
   static FLATBUFFERS_CONSTEXPR bool is_span_observable =
-      scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1);
+      scalar_tag::value && !std::is_pointer<T>::value &&
+      (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1);
 
   SizeT size() const { return EndianScalar(length_); }
 
@@ -359,6 +360,22 @@ FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t> make_bytes_span(
   return span<const uint8_t>(vec.Data(), vec.size() * sizeof(U));
 }
 
+#if FLATBUFFERS_LITTLEENDIAN
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_structs_span(
+    Vector<const U*>& vec) FLATBUFFERS_NOEXCEPT {
+  return span<U>(reinterpret_cast<U*>(vec.data()), vec.size());
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_structs_span(
+    const Vector<const U*>& vec) FLATBUFFERS_NOEXCEPT {
+  return span<const U>(reinterpret_cast<const U*>(vec.data()), vec.size());
+}
+
+#endif
+
 // Convenient helper functions to get a span of any vector, regardless
 // of whether it is null or not (the field is not set).
 template <class U>
@@ -377,6 +394,22 @@ FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
   return ptr ? make_span(*ptr) : span<const U>();
 }
 
+#if FLATBUFFERS_LITTLEENDIAN
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_structs_span(
+    Vector<const U*>* ptr) FLATBUFFERS_NOEXCEPT {
+  return ptr ? make_span(*ptr) : span<U>();
+}
+
+template <class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_structs_span(
+    const Vector<const U*>* ptr) FLATBUFFERS_NOEXCEPT {
+  return ptr ? make_span(*ptr) : span<const U>();
+}
+
+#endif
+
 // Represent a vector much like the template above, but in this case we
 // don't know what the element types are (used with reflection.h).
 class VectorOfAny {