From 1cfbf16e320ca9bdadd9c24eb1d2d68b25369ba6 Mon Sep 17 00:00:00 2001 From: Pimyn Girgis Date: Tue, 2 Dec 2025 12:28:10 +0000 Subject: executor: update flatbuffers Update flatbuffers to v23.5.26, which matches the compiler version in the new env container. --- executor/_include/flatbuffers/vector.h | 78 +++++++++++++++++++--------------- 1 file changed, 43 insertions(+), 35 deletions(-) (limited to 'executor/_include/flatbuffers/vector.h') diff --git a/executor/_include/flatbuffers/vector.h b/executor/_include/flatbuffers/vector.h index 6bcdfe263..ae52b9382 100644 --- a/executor/_include/flatbuffers/vector.h +++ b/executor/_include/flatbuffers/vector.h @@ -27,15 +27,18 @@ struct String; // An STL compatible iterator implementation for Vector below, effectively // calling Get() for every element. -template struct VectorIterator { +template +struct VectorIterator { typedef std::random_access_iterator_tag iterator_category; typedef IT value_type; typedef ptrdiff_t difference_type; typedef IT *pointer; typedef IT &reference; - VectorIterator(const uint8_t *data, uoffset_t i) - : data_(data + IndirectHelper::element_stride * i) {} + static const SizeT element_stride = IndirectHelper::element_stride; + + VectorIterator(Data data, SizeT i) : data_(data + element_stride * i) {} VectorIterator(const VectorIterator &other) : data_(other.data_) {} VectorIterator() : data_(nullptr) {} @@ -62,7 +65,7 @@ template struct VectorIterator { } difference_type operator-(const VectorIterator &other) const { - return (data_ - other.data_) / IndirectHelper::element_stride; + return (data_ - other.data_) / element_stride; } // Note: return type is incompatible with the standard @@ -74,51 +77,52 @@ template struct VectorIterator { IT operator->() const { return IndirectHelper::Read(data_, 0); } VectorIterator &operator++() { - data_ += IndirectHelper::element_stride; + data_ += element_stride; return *this; } VectorIterator operator++(int) { VectorIterator temp(data_, 0); - data_ += IndirectHelper::element_stride; + data_ += element_stride; return temp; } - VectorIterator operator+(const uoffset_t &offset) const { - return VectorIterator(data_ + offset * IndirectHelper::element_stride, - 0); + VectorIterator operator+(const SizeT &offset) const { + return VectorIterator(data_ + offset * element_stride, 0); } - VectorIterator &operator+=(const uoffset_t &offset) { - data_ += offset * IndirectHelper::element_stride; + VectorIterator &operator+=(const SizeT &offset) { + data_ += offset * element_stride; return *this; } VectorIterator &operator--() { - data_ -= IndirectHelper::element_stride; + data_ -= element_stride; return *this; } VectorIterator operator--(int) { VectorIterator temp(data_, 0); - data_ -= IndirectHelper::element_stride; + data_ -= element_stride; return temp; } - VectorIterator operator-(const uoffset_t &offset) const { - return VectorIterator(data_ - offset * IndirectHelper::element_stride, - 0); + VectorIterator operator-(const SizeT &offset) const { + return VectorIterator(data_ - offset * element_stride, 0); } - VectorIterator &operator-=(const uoffset_t &offset) { - data_ -= offset * IndirectHelper::element_stride; + VectorIterator &operator-=(const SizeT &offset) { + data_ -= offset * element_stride; return *this; } private: - const uint8_t *data_; + Data data_; }; +template +using VectorConstIterator = VectorIterator; + template struct VectorReverseIterator : public std::reverse_iterator { explicit VectorReverseIterator(Iterator iter) @@ -141,11 +145,12 @@ struct VectorReverseIterator : public std::reverse_iterator { // This is used as a helper type for accessing vectors. // Vector::data() assumes the vector elements start after the length field. -template class Vector { +template class Vector { public: - typedef VectorIterator::mutable_return_type> + typedef VectorIterator::mutable_return_type, + uint8_t *, SizeT> iterator; - typedef VectorIterator::return_type> + typedef VectorConstIterator::return_type, SizeT> const_iterator; typedef VectorReverseIterator reverse_iterator; typedef VectorReverseIterator const_reverse_iterator; @@ -156,39 +161,40 @@ template class Vector { static FLATBUFFERS_CONSTEXPR bool is_span_observable = scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1); - uoffset_t size() const { return EndianScalar(length_); } + SizeT size() const { return EndianScalar(length_); } // Deprecated: use size(). Here for backwards compatibility. FLATBUFFERS_ATTRIBUTE([[deprecated("use size() instead")]]) - uoffset_t Length() const { return size(); } + SizeT Length() const { return size(); } + typedef SizeT size_type; typedef typename IndirectHelper::return_type return_type; typedef typename IndirectHelper::mutable_return_type mutable_return_type; typedef return_type value_type; - return_type Get(uoffset_t i) const { + return_type Get(SizeT i) const { FLATBUFFERS_ASSERT(i < size()); return IndirectHelper::Read(Data(), i); } - return_type operator[](uoffset_t i) const { return Get(i); } + return_type operator[](SizeT 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 E GetEnum(uoffset_t i) const { + template E GetEnum(SizeT i) const { return static_cast(Get(i)); } // If this a vector of unions, this does the cast for you. There's no check // to make sure this is the right type! - template const U *GetAs(uoffset_t i) const { + template const U *GetAs(SizeT i) const { return reinterpret_cast(Get(i)); } // If this a vector of unions, this does the cast for you. There's no check // to make sure this is actually a string! - const String *GetAsString(uoffset_t i) const { + const String *GetAsString(SizeT i) const { return reinterpret_cast(Get(i)); } @@ -222,7 +228,7 @@ template class Vector { // Change elements if you have a non-const pointer to this object. // Scalars only. See reflection.h, and the documentation. - void Mutate(uoffset_t i, const T &val) { + void Mutate(SizeT i, const T &val) { FLATBUFFERS_ASSERT(i < size()); WriteScalar(data() + i, val); } @@ -230,15 +236,15 @@ template class Vector { // Change an element of a vector of tables (or strings). // "val" points to the new table/string, as you can obtain from // e.g. reflection::AddFlatBuffer(). - void MutateOffset(uoffset_t i, const uint8_t *val) { + void MutateOffset(SizeT i, const uint8_t *val) { FLATBUFFERS_ASSERT(i < size()); - static_assert(sizeof(T) == sizeof(uoffset_t), "Unrelated types"); + static_assert(sizeof(T) == sizeof(SizeT), "Unrelated types"); WriteScalar(data() + i, - static_cast(val - (Data() + i * sizeof(uoffset_t)))); + static_cast(val - (Data() + i * sizeof(SizeT)))); } // Get a mutable pointer to tables/strings inside this vector. - mutable_return_type GetMutableObject(uoffset_t i) const { + mutable_return_type GetMutableObject(SizeT i) const { FLATBUFFERS_ASSERT(i < size()); return const_cast(IndirectHelper::Read(Data(), i)); } @@ -276,7 +282,7 @@ template class Vector { // try to construct these manually. Vector(); - uoffset_t length_; + SizeT length_; private: // This class is a pointer. Copying will therefore create an invalid object. @@ -295,6 +301,8 @@ template class Vector { } }; +template using Vector64 = Vector; + template FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span make_span(Vector &vec) FLATBUFFERS_NOEXCEPT { -- cgit mrf-deployment