diff --git a/include/flatbuffers/base.h b/include/flatbuffers/base.h index 912ed0aec..b955cbdaf 100644 --- a/include/flatbuffers/base.h +++ b/include/flatbuffers/base.h @@ -9,6 +9,10 @@ #include +#if !defined(FLATBUFFERS_ASSERT) +#define FLATBUFFERS_ASSERT assert +#endif + #ifndef ARDUINO #include #endif @@ -209,7 +213,7 @@ template T EndianSwap(T t) { u.i = FLATBUFFERS_BYTESWAP64(u.i); return u.t; } else { - assert(0); + FLATBUFFERS_ASSERT(0); } } diff --git a/include/flatbuffers/flatbuffers.h b/include/flatbuffers/flatbuffers.h index 89098c80f..cc9936409 100644 --- a/include/flatbuffers/flatbuffers.h +++ b/include/flatbuffers/flatbuffers.h @@ -33,7 +33,8 @@ template struct Offset { inline void EndianCheck() { int endiantest = 1; // If this fails, see FLATBUFFERS_LITTLEENDIAN above. - assert(*reinterpret_cast(&endiantest) == FLATBUFFERS_LITTLEENDIAN); + FLATBUFFERS_ASSERT(*reinterpret_cast(&endiantest) == + FLATBUFFERS_LITTLEENDIAN); (void)endiantest; } @@ -194,7 +195,7 @@ template class Vector { typedef typename IndirectHelper::mutable_return_type mutable_return_type; return_type Get(uoffset_t i) const { - assert(i < size()); + FLATBUFFERS_ASSERT(i < size()); return IndirectHelper::Read(Data(), i); } @@ -232,7 +233,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) { - assert(i < size()); + FLATBUFFERS_ASSERT(i < size()); WriteScalar(data() + i, val); } @@ -240,15 +241,15 @@ template class Vector { // "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) { - assert(i < size()); - assert(sizeof(T) == sizeof(uoffset_t)); + FLATBUFFERS_ASSERT(i < size()); + static_assert(sizeof(T) == sizeof(uoffset_t), "Unrelated types"); WriteScalar(data() + i, static_cast(val - (Data() + i * sizeof(uoffset_t)))); } // Get a mutable pointer to tables/strings inside this vector. mutable_return_type GetMutableObject(uoffset_t i) const { - assert(i < size()); + FLATBUFFERS_ASSERT(i < size()); return const_cast(IndirectHelper::Read(Data(), i)); } @@ -368,7 +369,7 @@ class Allocator { 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) { - assert(new_size > old_size); // vector_downward only grows + FLATBUFFERS_ASSERT(new_size > old_size); // vector_downward only grows uint8_t *new_p = allocate(new_size); memcpy_downward(old_p, old_size, new_p, new_size, in_use_back, in_use_front); @@ -428,7 +429,7 @@ class DetachedBuffer { reserved_(reserved), cur_(cur), size_(sz) { - assert(allocator_); + FLATBUFFERS_ASSERT(allocator_); } DetachedBuffer(DetachedBuffer &&other) @@ -499,7 +500,7 @@ class DetachedBuffer { inline void destroy() { if (buf_) { - assert(allocator_); + FLATBUFFERS_ASSERT(allocator_); allocator_->deallocate(buf_, reserved_); } if (own_allocator_ && allocator_) { delete allocator_; } @@ -537,12 +538,12 @@ class vector_downward { buf_(nullptr), cur_(nullptr), scratch_(nullptr) { - assert(allocator_); + FLATBUFFERS_ASSERT(allocator_); } ~vector_downward() { if (buf_) { - assert(allocator_); + FLATBUFFERS_ASSERT(allocator_); allocator_->deallocate(buf_, reserved_); } if (own_allocator_ && allocator_) { delete allocator_; } @@ -550,7 +551,7 @@ class vector_downward { void reset() { if (buf_) { - assert(allocator_); + FLATBUFFERS_ASSERT(allocator_); allocator_->deallocate(buf_, reserved_); buf_ = nullptr; } @@ -583,11 +584,11 @@ class vector_downward { } size_t ensure_space(size_t len) { - assert(cur_ >= scratch_ && scratch_ >= buf_); + FLATBUFFERS_ASSERT(cur_ >= scratch_ && scratch_ >= buf_); if (len > static_cast(cur_ - scratch_)) { reallocate(len); } // Beyond this, signed offsets may not have enough range: // (FlatBuffers > 2GB not supported). - assert(size() < FLATBUFFERS_MAX_BUFFER_SIZE); + FLATBUFFERS_ASSERT(size() < FLATBUFFERS_MAX_BUFFER_SIZE); return len; } @@ -609,17 +610,17 @@ class vector_downward { size_t capacity() const { return reserved_; } uint8_t *data() const { - assert(cur_); + FLATBUFFERS_ASSERT(cur_); return cur_; } uint8_t *scratch_data() const { - assert(buf_); + FLATBUFFERS_ASSERT(buf_); return buf_; } uint8_t *scratch_end() const { - assert(scratch_); + FLATBUFFERS_ASSERT(scratch_); return scratch_; } @@ -671,7 +672,7 @@ class vector_downward { uint8_t *scratch_; // Points to the end of the scratchpad in use. void reallocate(size_t len) { - assert(allocator_); + FLATBUFFERS_ASSERT(allocator_); auto old_reserved = reserved_; auto old_size = size(); auto old_scratch_size = scratch_size(); @@ -815,7 +816,7 @@ class FlatBufferBuilder { // FlatBufferBuilder::Finish with your root table. // If you really need to access an unfinished buffer, call // GetCurrentBufferPointer instead. - assert(finished); + FLATBUFFERS_ASSERT(finished); } /// @endcond @@ -908,7 +909,7 @@ class FlatBufferBuilder { // Align to ensure GetSize() below is correct. Align(sizeof(uoffset_t)); // Offset must refer to something already in buffer. - assert(off && off <= GetSize()); + FLATBUFFERS_ASSERT(off && off <= GetSize()); return GetSize() - off + static_cast(sizeof(uoffset_t)); } @@ -921,9 +922,9 @@ class FlatBufferBuilder { // Ignoring this assert may appear to work in simple cases, but the reason // it is here is that storing objects in-line may cause vtable offsets // to not fit anymore. It also leads to vtable duplication. - assert(!nested); + FLATBUFFERS_ASSERT(!nested); // If you hit this, fields were added outside the scope of a table. - assert(!num_field_loc); + FLATBUFFERS_ASSERT(!num_field_loc); } // From generated code (or from the parser), we call StartTable/EndTable @@ -939,7 +940,7 @@ class FlatBufferBuilder { // resulting vtable offset. uoffset_t EndTable(uoffset_t start) { // If you get this assert, a corresponding StartTable wasn't called. - assert(nested); + FLATBUFFERS_ASSERT(nested); // Write the vtable offset, which is the start of any Table. // We fill it's value later. auto vtableoffsetloc = PushElement(0); @@ -953,7 +954,8 @@ class FlatBufferBuilder { FieldIndexToOffset(0)); buf_.fill_big(max_voffset_); auto table_object_size = vtableoffsetloc - start; - assert(table_object_size < 0x10000); // Vtable use 16bit offsets. + // Vtable use 16bit offsets. + FLATBUFFERS_ASSERT(table_object_size < 0x10000); WriteScalar(buf_.data() + sizeof(voffset_t), static_cast(table_object_size)); WriteScalar(buf_.data(), max_voffset_); @@ -963,7 +965,8 @@ class FlatBufferBuilder { auto field_location = reinterpret_cast(it); auto pos = static_cast(vtableoffsetloc - field_location->off); // If this asserts, it means you've set a field twice. - assert(!ReadScalar(buf_.data() + field_location->id)); + FLATBUFFERS_ASSERT( + !ReadScalar(buf_.data() + field_location->id)); WriteScalar(buf_.data() + field_location->id, pos); } ClearOffsets(); @@ -1011,7 +1014,7 @@ class FlatBufferBuilder { auto vtable_ptr = table_ptr - ReadScalar(table_ptr); bool ok = ReadScalar(vtable_ptr + field) != 0; // If this fails, the caller will show what field needs to be set. - assert(ok); + FLATBUFFERS_ASSERT(ok); (void)ok; } @@ -1143,7 +1146,7 @@ class FlatBufferBuilder { /// @cond FLATBUFFERS_INTERNAL uoffset_t EndVector(size_t len) { - assert(nested); // Hit if no corresponding StartVector. + FLATBUFFERS_ASSERT(nested); // Hit if no corresponding StartVector. nested = false; return PushElement(static_cast(len)); } @@ -1559,7 +1562,7 @@ class FlatBufferBuilder { (file_identifier ? kFileIdentifierLength : 0), minalign_); if (file_identifier) { - assert(strlen(file_identifier) == kFileIdentifierLength); + FLATBUFFERS_ASSERT(strlen(file_identifier) == kFileIdentifierLength); PushBytes(reinterpret_cast(file_identifier), kFileIdentifierLength); } @@ -1698,7 +1701,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS { bool Check(bool ok) const { // clang-format off #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE - assert(ok); + FLATBUFFERS_ASSERT(ok); #endif #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE if (!ok) @@ -2066,7 +2069,7 @@ inline const uint8_t *GetBufferStartFromRootPointer(const void *root) { // or the buffer is corrupt. // Assert, because calling this function with bad data may cause reads // outside of buffer boundaries. - assert(false); + FLATBUFFERS_ASSERT(false); return nullptr; } diff --git a/include/flatbuffers/flexbuffers.h b/include/flatbuffers/flexbuffers.h index 1e6e47699..023654a60 100644 --- a/include/flatbuffers/flexbuffers.h +++ b/include/flatbuffers/flexbuffers.h @@ -97,23 +97,23 @@ inline bool IsFixedTypedVector(Type t) { } inline Type ToTypedVector(Type t, size_t fixed_len = 0) { - assert(IsTypedVectorElementType(t)); + FLATBUFFERS_ASSERT(IsTypedVectorElementType(t)); switch (fixed_len) { case 0: return static_cast(t - TYPE_INT + TYPE_VECTOR_INT); case 2: return static_cast(t - TYPE_INT + TYPE_VECTOR_INT2); case 3: return static_cast(t - TYPE_INT + TYPE_VECTOR_INT3); case 4: return static_cast(t - TYPE_INT + TYPE_VECTOR_INT4); - default: assert(0); return TYPE_NULL; + default: FLATBUFFERS_ASSERT(0); return TYPE_NULL; } } inline Type ToTypedVectorElementType(Type t) { - assert(IsTypedVector(t)); + FLATBUFFERS_ASSERT(IsTypedVector(t)); return static_cast(t - TYPE_VECTOR_INT + TYPE_INT); } inline Type ToFixedTypedVectorElementType(Type t, uint8_t *len) { - assert(IsFixedTypedVector(t)); + FLATBUFFERS_ASSERT(IsFixedTypedVector(t)); auto fixed_type = t - TYPE_VECTOR_INT2; *len = static_cast(fixed_type / 3 + 2); // 3 types each, starting from length 2. @@ -690,7 +690,7 @@ class Reference { return Mutate(dest, static_cast(t), byte_width, value_width); if (byte_width == sizeof(float)) return Mutate(dest, static_cast(t), byte_width, value_width); - assert(false); + FLATBUFFERS_ASSERT(false); return false; } @@ -1026,11 +1026,11 @@ class Builder FLATBUFFERS_FINAL_CLASS { // We should have interleaved keys and values on the stack. // Make sure it is an even number: auto len = stack_.size() - start; - assert(!(len & 1)); + FLATBUFFERS_ASSERT(!(len & 1)); len /= 2; // Make sure keys are all strings: for (auto key = start; key < stack_.size(); key += 2) { - assert(stack_[key].type_ == TYPE_KEY); + FLATBUFFERS_ASSERT(stack_[key].type_ == TYPE_KEY); } // Now sort values, so later we can do a binary seach lookup. // We want to sort 2 array elements at a time. @@ -1061,7 +1061,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { // TODO: Have to check for pointer equality, as some sort // implementation apparently call this function with the same // element?? Why? - assert(comp || &a == &b); + FLATBUFFERS_ASSERT(comp || &a == &b); return comp < 0; }); // First create a vector out of all keys. @@ -1141,9 +1141,9 @@ class Builder FLATBUFFERS_FINAL_CLASS { template size_t FixedTypedVector(const T *elems, size_t len) { // We only support a few fixed vector lengths. Anything bigger use a // regular typed vector. - assert(len >= 2 && len <= 4); + FLATBUFFERS_ASSERT(len >= 2 && len <= 4); // And only scalar values. - assert(flatbuffers::is_scalar::value); + static_assert(flatbuffers::is_scalar::value, "Unrelated types"); return ScalarVector(elems, len, true); } @@ -1222,7 +1222,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { // in a parent. You need to have exactly one root to finish a buffer. // Check your Start/End calls are matched, and all objects are inside // some other object. - assert(stack_.size() == 1); + FLATBUFFERS_ASSERT(stack_.size() == 1); // Write root value. auto byte_width = Align(stack_[0].ElemWidth(buf_.size(), 0)); @@ -1240,7 +1240,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { // If you get this assert, you're attempting to get access a buffer // which hasn't been finished yet. Be sure to call // Builder::Finish with your root object. - assert(finished_); + FLATBUFFERS_ASSERT(finished_); } // Align to prepare for writing a scalar with a certain size. @@ -1257,7 +1257,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { } template void Write(T val, size_t byte_width) { - assert(sizeof(T) >= byte_width); + FLATBUFFERS_ASSERT(sizeof(T) >= byte_width); val = flatbuffers::EndianScalar(val); WriteBytes(&val, byte_width); } @@ -1268,13 +1268,13 @@ class Builder FLATBUFFERS_FINAL_CLASS { case 4: Write(static_cast(f), byte_width); break; // case 2: Write(static_cast(f), byte_width); break; // case 1: Write(static_cast(f), byte_width); break; - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } } void WriteOffset(uint64_t o, uint8_t byte_width) { auto reloff = buf_.size() - o; - assert(byte_width == 8 || reloff < 1ULL << (byte_width * 8)); + FLATBUFFERS_ASSERT(byte_width == 8 || reloff < 1ULL << (byte_width * 8)); Write(reloff, byte_width); } @@ -1291,12 +1291,12 @@ class Builder FLATBUFFERS_FINAL_CLASS { case 2: return BIT_WIDTH_16; case 4: return BIT_WIDTH_32; case 8: return BIT_WIDTH_64; - default: assert(false); return BIT_WIDTH_64; + default: FLATBUFFERS_ASSERT(false); return BIT_WIDTH_64; } } template static Type GetScalarType() { - assert(flatbuffers::is_scalar::value); + static_assert(flatbuffers::is_scalar::value, "Unrelated types"); return flatbuffers::is_floating_point::value ? TYPE_FLOAT : flatbuffers::is_same::value @@ -1360,7 +1360,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { byte_width) return bit_width; } - assert(false); // Must match one of the sizes above. + FLATBUFFERS_ASSERT(false); // Must match one of the sizes above. return BIT_WIDTH_64; } } @@ -1405,7 +1405,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { // byte vector > 255 elements). For such types, write a "blob" instead. // TODO: instead of asserting, could write vector with larger elements // instead, though that would be wasteful. - assert(WidthU(len) <= bit_width); + FLATBUFFERS_ASSERT(WidthU(len) <= bit_width); if (!fixed) Write(len, byte_width); auto vloc = buf_.size(); for (size_t i = 0; i < len; i++) Write(elems[i], byte_width); @@ -1437,13 +1437,13 @@ class Builder FLATBUFFERS_FINAL_CLASS { } else { // If you get this assert, you are writing a typed vector with // elements that are not all the same type. - assert(vector_type == stack_[i].type_); + FLATBUFFERS_ASSERT(vector_type == stack_[i].type_); } } } // If you get this assert, your fixed types are not one of: // Int / UInt / Float / Key. - assert(IsTypedVectorElementType(vector_type)); + FLATBUFFERS_ASSERT(IsTypedVectorElementType(vector_type)); auto byte_width = Align(bit_width); // Write vector. First the keys width/offset if available, and size. if (keys) { diff --git a/include/flatbuffers/grpc.h b/include/flatbuffers/grpc.h index e40ab7645..2c71c7da1 100644 --- a/include/flatbuffers/grpc.h +++ b/include/flatbuffers/grpc.h @@ -91,14 +91,14 @@ class SliceAllocator : public Allocator { virtual ~SliceAllocator() { grpc_slice_unref(slice_); } virtual uint8_t *allocate(size_t size) override { - assert(GRPC_SLICE_IS_EMPTY(slice_)); + FLATBUFFERS_ASSERT(GRPC_SLICE_IS_EMPTY(slice_)); slice_ = grpc_slice_malloc(size); return GRPC_SLICE_START_PTR(slice_); } virtual void deallocate(uint8_t *p, size_t size) override { - assert(p == GRPC_SLICE_START_PTR(slice_)); - assert(size == GRPC_SLICE_LENGTH(slice_)); + FLATBUFFERS_ASSERT(p == GRPC_SLICE_START_PTR(slice_)); + FLATBUFFERS_ASSERT(size == GRPC_SLICE_LENGTH(slice_)); grpc_slice_unref(slice_); slice_ = grpc_empty_slice(); } @@ -106,9 +106,9 @@ class SliceAllocator : public Allocator { 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) override { - assert(old_p == GRPC_SLICE_START_PTR(slice_)); - assert(old_size == GRPC_SLICE_LENGTH(slice_)); - assert(new_size > old_size); + FLATBUFFERS_ASSERT(old_p == GRPC_SLICE_START_PTR(slice_)); + FLATBUFFERS_ASSERT(old_size == GRPC_SLICE_LENGTH(slice_)); + FLATBUFFERS_ASSERT(new_size > old_size); grpc_slice old_slice = slice_; grpc_slice new_slice = grpc_slice_malloc(new_size); uint8_t *new_p = GRPC_SLICE_START_PTR(new_slice); @@ -121,8 +121,8 @@ class SliceAllocator : public Allocator { private: grpc_slice &get_slice(uint8_t *p, size_t size) { - assert(p == GRPC_SLICE_START_PTR(slice_)); - assert(size == GRPC_SLICE_LENGTH(slice_)); + FLATBUFFERS_ASSERT(p == GRPC_SLICE_START_PTR(slice_)); + FLATBUFFERS_ASSERT(size == GRPC_SLICE_LENGTH(slice_)); return slice_; } @@ -162,10 +162,10 @@ class MessageBuilder : private detail::SliceAllocatorMember, auto msg_data = buf_.data(); // pointer to msg auto msg_size = buf_.size(); // size of msg // Do some sanity checks on data/size - assert(msg_data); - assert(msg_size); - assert(msg_data >= buf_data); - assert(msg_data + msg_size <= buf_data + buf_size); + FLATBUFFERS_ASSERT(msg_data); + FLATBUFFERS_ASSERT(msg_size); + FLATBUFFERS_ASSERT(msg_data >= buf_data); + FLATBUFFERS_ASSERT(msg_data + msg_size <= buf_data + buf_size); // Calculate offsets from the buffer start auto begin = msg_data - buf_data; auto end = begin + msg_size; diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index a811fcb74..4c4bcc3b4 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -181,7 +181,7 @@ template class SymbolTable { dict.erase(it); dict[newname] = obj; } else { - assert(false); + FLATBUFFERS_ASSERT(false); } } @@ -485,7 +485,7 @@ class CheckedError { *this = other; // Use assignment operator. } - ~CheckedError() { assert(has_been_checked_); } + ~CheckedError() { FLATBUFFERS_ASSERT(has_been_checked_); } bool Check() { has_been_checked_ = true; diff --git a/include/flatbuffers/minireflect.h b/include/flatbuffers/minireflect.h index 1f351c056..4fb536e7c 100644 --- a/include/flatbuffers/minireflect.h +++ b/include/flatbuffers/minireflect.h @@ -89,9 +89,9 @@ inline size_t InlineSize(ElementaryType type, const TypeTable *type_table) { case ST_TABLE: case ST_UNION: return 4; case ST_STRUCT: return type_table->values[type_table->num_elems]; - default: assert(false); return 1; + default: FLATBUFFERS_ASSERT(false); return 1; } - default: assert(false); return 1; + default: FLATBUFFERS_ASSERT(false); return 1; } } @@ -190,7 +190,7 @@ inline void IterateValue(ElementaryType type, const uint8_t *val, case ST_STRUCT: IterateObject(val, type_table, visitor); break; case ST_UNION: { val += ReadScalar(val); - assert(prev_val); + FLATBUFFERS_ASSERT(prev_val); auto union_type = *prev_val; // Always a uint8_t. if (vector_index >= 0) { auto type_vec = reinterpret_cast *>(prev_val); @@ -217,7 +217,7 @@ inline void IterateValue(ElementaryType type, const uint8_t *val, } break; } - case ST_ENUM: assert(false); break; + case ST_ENUM: FLATBUFFERS_ASSERT(false); break; } break; } diff --git a/include/flatbuffers/reflection.h b/include/flatbuffers/reflection.h index 6e2fafda5..5010e0002 100644 --- a/include/flatbuffers/reflection.h +++ b/include/flatbuffers/reflection.h @@ -72,20 +72,20 @@ inline const Table *GetAnyRoot(const uint8_t *flatbuf) { // Get a field's default, if you know it's an integer, and its exact type. template T GetFieldDefaultI(const reflection::Field &field) { - assert(sizeof(T) == GetTypeSize(field.type()->base_type())); + FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return static_cast(field.default_integer()); } // Get a field's default, if you know it's floating point and its exact type. template T GetFieldDefaultF(const reflection::Field &field) { - assert(sizeof(T) == GetTypeSize(field.type()->base_type())); + FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return static_cast(field.default_real()); } // Get a field, if you know it's an integer, and its exact type. template T GetFieldI(const Table &table, const reflection::Field &field) { - assert(sizeof(T) == GetTypeSize(field.type()->base_type())); + FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return table.GetField(field.offset(), static_cast(field.default_integer())); } @@ -93,7 +93,7 @@ T GetFieldI(const Table &table, const reflection::Field &field) { // Get a field, if you know it's floating point and its exact type. template T GetFieldF(const Table &table, const reflection::Field &field) { - assert(sizeof(T) == GetTypeSize(field.type()->base_type())); + FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return table.GetField(field.offset(), static_cast(field.default_real())); } @@ -101,15 +101,15 @@ T GetFieldF(const Table &table, const reflection::Field &field) { // Get a field, if you know it's a string. inline const String *GetFieldS(const Table &table, const reflection::Field &field) { - assert(field.type()->base_type() == reflection::String); + FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::String); return table.GetPointer(field.offset()); } // Get a field, if you know it's a vector. template Vector *GetFieldV(const Table &table, const reflection::Field &field) { - assert(field.type()->base_type() == reflection::Vector && - sizeof(T) == GetTypeSize(field.type()->element())); + FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Vector && + sizeof(T) == GetTypeSize(field.type()->element())); return table.GetPointer *>(field.offset()); } @@ -123,8 +123,8 @@ inline VectorOfAny *GetFieldAnyV(const Table &table, // Get a field, if you know it's a table. inline Table *GetFieldT(const Table &table, const reflection::Field &field) { - assert(field.type()->base_type() == reflection::Obj || - field.type()->base_type() == reflection::Union); + FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj || + field.type()->base_type() == reflection::Union); return table.GetPointer(field.offset()); } @@ -133,14 +133,14 @@ inline const Struct *GetFieldStruct(const Table &table, const reflection::Field &field) { // TODO: This does NOT check if the field is a table or struct, but we'd need // access to the schema to check the is_struct flag. - assert(field.type()->base_type() == reflection::Obj); + FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj); return table.GetStruct(field.offset()); } // Get a structure's field, if you know it's a struct. inline const Struct *GetFieldStruct(const Struct &structure, const reflection::Field &field) { - assert(field.type()->base_type() == reflection::Obj); + FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj); return structure.GetStruct(field.offset()); } @@ -262,12 +262,12 @@ template bool SetField(Table *table, const reflection::Field &field, T val) { reflection::BaseType type = field.type()->base_type(); if (!IsScalar(type)) { return false; } - assert(sizeof(T) == GetTypeSize(type)); + FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(type)); T def; if (IsInteger(type)) { def = GetFieldDefaultI(field); } else { - assert(IsFloat(type)); + FLATBUFFERS_ASSERT(IsFloat(type)); def = GetFieldDefaultF(field); } return table->SetField(field.offset(), val, def); @@ -386,7 +386,7 @@ inline const reflection::Object &GetUnionType( // TODO: this is clumsy and slow, but no other way to find it? auto type_field = parent.fields()->LookupByKey( (unionfield.name()->str() + UnionTypeFieldSuffix()).c_str()); - assert(type_field); + FLATBUFFERS_ASSERT(type_field); auto union_type = GetFieldI(table, *type_field); auto enumval = enumdef->values()->LookupByKey(union_type); return *enumval->object(); @@ -444,7 +444,8 @@ const uint8_t *AddFlatBuffer(std::vector &flatbuf, inline bool SetFieldT(Table *table, const reflection::Field &field, const uint8_t *val) { - assert(sizeof(uoffset_t) == GetTypeSize(field.type()->base_type())); + FLATBUFFERS_ASSERT(sizeof(uoffset_t) == + GetTypeSize(field.type()->base_type())); return table->SetPointer(field.offset(), val); } diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h index 7cadd0b5f..51f83cb22 100644 --- a/include/flatbuffers/util.h +++ b/include/flatbuffers/util.h @@ -284,7 +284,7 @@ inline std::string AbsolutePath(const std::string &filepath) { // Convert a unicode code point into a UTF-8 representation by appending it // to a string. Returns the number of bytes generated. inline int ToUTF8(uint32_t ucc, std::string *out) { - assert(!(ucc & 0x80000000)); // Top bit can't be set. + FLATBUFFERS_ASSERT(!(ucc & 0x80000000)); // Top bit can't be set. // 6 possible encodings: http://en.wikipedia.org/wiki/UTF-8 for (int i = 0; i < 6; i++) { // Max bits this encoding can represent. @@ -302,7 +302,7 @@ inline int ToUTF8(uint32_t ucc, std::string *out) { return i + 1; // Return the number of bytes added. } } - assert(0); // Impossible to arrive here. + FLATBUFFERS_ASSERT(0); // Impossible to arrive here. return -1; } diff --git a/src/code_generators.cpp b/src/code_generators.cpp index c6bf91c2b..2ecd5e3a7 100644 --- a/src/code_generators.cpp +++ b/src/code_generators.cpp @@ -47,7 +47,7 @@ void CodeWriter::operator+=(std::string text) { const std::string &value = iter->second; stream_ << value; } else { - assert(false && "could not find key"); + FLATBUFFERS_ASSERT(false && "could not find key"); stream_ << key; } diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp index 917e41d3c..75c86c091 100644 --- a/src/idl_gen_cpp.cpp +++ b/src/idl_gen_cpp.cpp @@ -216,7 +216,7 @@ class CppGenerator : public BaseGenerator { if (parser_.opts.include_dependence_headers) { GenIncludeDependencies(); } - assert(!cur_name_space_); + FLATBUFFERS_ASSERT(!cur_name_space_); // Generate forward declarations for all structs/tables, since they may // have circular references. @@ -667,7 +667,7 @@ class CppGenerator : public BaseGenerator { return actual_type ? (native_type ? "std::string" : "flatbuffers::String") : Name(ev); } else { - assert(false); + FLATBUFFERS_ASSERT(false); return Name(ev); } } @@ -897,7 +897,7 @@ class CppGenerator : public BaseGenerator { } if (parser_.opts.scoped_enums || parser_.opts.prefixed_enums) { - assert(minv && maxv); + FLATBUFFERS_ASSERT(minv && maxv); code_.SetValue("SEP", ",\n"); if (enum_def.attributes.Lookup("bit_flags")) { @@ -1118,7 +1118,7 @@ class CppGenerator : public BaseGenerator { code_ += getptr; code_ += " return verifier.Verify(ptr);"; } else { - assert(false); + FLATBUFFERS_ASSERT(false); } code_ += " }"; } else { @@ -1169,7 +1169,7 @@ class CppGenerator : public BaseGenerator { } else if (ev.union_type.base_type == BASE_TYPE_STRING) { code_ += " return new std::string(ptr->c_str(), ptr->size());"; } else { - assert(false); + FLATBUFFERS_ASSERT(false); } code_ += " }"; } @@ -1202,7 +1202,7 @@ class CppGenerator : public BaseGenerator { } else if (ev.union_type.base_type == BASE_TYPE_STRING) { code_ += " return _fbb.CreateString(*ptr).Union();"; } else { - assert(false); + FLATBUFFERS_ASSERT(false); } code_ += " }"; } @@ -1244,7 +1244,7 @@ class CppGenerator : public BaseGenerator { " value = new {{TYPE}}(*reinterpret_cast<{{TYPE}} *>" "(u.value));"; } else { - code_ += " assert(false); // {{TYPE}} not copyable."; + code_ += " FLATBUFFERS_ASSERT(false); // {{TYPE}} not copyable."; } code_ += " break;"; code_ += " }"; @@ -1697,7 +1697,7 @@ class CppGenerator : public BaseGenerator { nested->constant); nested_root = parser_.LookupStruct(qualified_name); } - assert(nested_root); // Guaranteed to exist by parser. + FLATBUFFERS_ASSERT(nested_root); // Guaranteed to exist by parser. (void)nested_root; code_.SetValue("CPP_NAME", TranslateNameSpace(qualified_name)); @@ -2092,7 +2092,7 @@ class CppGenerator : public BaseGenerator { break; } case BASE_TYPE_UTYPE: { - assert(union_field->value.type.base_type == BASE_TYPE_UNION); + FLATBUFFERS_ASSERT(union_field->value.type.base_type == BASE_TYPE_UNION); // Generate code that sets the union type, of the form: // _o->field.type = _e; code += "_o->" + union_field->name + ".type = _e;"; @@ -2403,7 +2403,7 @@ class CppGenerator : public BaseGenerator { f((1 << i) * 8, code_ptr, id); } } - assert(!(field.padding & ~0xF)); + FLATBUFFERS_ASSERT(!(field.padding & ~0xF)); } } diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp index 358169bed..788da83d7 100644 --- a/src/idl_gen_general.cpp +++ b/src/idl_gen_general.cpp @@ -131,7 +131,7 @@ const LanguageParameters &GetLangParams(IDLOptions::Language lang) { if (lang == IDLOptions::kJava) { return language_parameters[0]; } else { - assert(lang == IDLOptions::kCSharp); + FLATBUFFERS_ASSERT(lang == IDLOptions::kCSharp); return language_parameters[1]; } } @@ -274,7 +274,7 @@ class GeneralGenerator : public BaseGenerator { if (lang_.language == IDLOptions::kJava) { return java_typename[type.base_type]; } else { - assert(lang_.language == IDLOptions::kCSharp); + FLATBUFFERS_ASSERT(lang_.language == IDLOptions::kCSharp); return csharp_typename[type.base_type]; } } @@ -999,7 +999,7 @@ class GeneralGenerator : public BaseGenerator { code += "(obj, o) : null"; } break; - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } } code += member_suffix; @@ -1427,7 +1427,7 @@ bool GenerateGeneral(const Parser &parser, const std::string &path, std::string GeneralMakeRule(const Parser &parser, const std::string &path, const std::string &file_name) { - assert(parser.opts.lang <= IDLOptions::kMAX); + FLATBUFFERS_ASSERT(parser.opts.lang <= IDLOptions::kMAX); const auto &lang = GetLangParams(parser.opts.lang); std::string make_rule; diff --git a/src/idl_gen_go.cpp b/src/idl_gen_go.cpp index 810751e4e..8c95e711e 100644 --- a/src/idl_gen_go.cpp +++ b/src/idl_gen_go.cpp @@ -522,7 +522,7 @@ static void GenStructAccessor(const StructDef &struct_def, break; } case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break; - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } } if (field.value.type.base_type == BASE_TYPE_VECTOR) { diff --git a/src/idl_gen_grpc.cpp b/src/idl_gen_grpc.cpp index 89cf4300e..02994bda0 100644 --- a/src/idl_gen_grpc.cpp +++ b/src/idl_gen_grpc.cpp @@ -160,7 +160,7 @@ class FlatBufPrinter : public grpc_generator::Printer { void Indent() { indent_++; } void Outdent() { indent_--; - assert(indent_ >= 0); + FLATBUFFERS_ASSERT(indent_ >= 0); } private: diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index c0844d4ea..3e3730acc 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -54,7 +54,7 @@ const JsLanguageParameters &GetJsLangParams(IDLOptions::Language lang) { if (lang == IDLOptions::kJs) { return js_language_parameters[0]; } else { - assert(lang == IDLOptions::kTs); + FLATBUFFERS_ASSERT(lang == IDLOptions::kTs); return js_language_parameters[1]; } } @@ -870,7 +870,7 @@ class JsGenerator : public BaseGenerator { " : null;\n"; break; - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } } code += "};\n\n"; @@ -1181,7 +1181,7 @@ bool GenerateJS(const Parser &parser, const std::string &path, std::string JSMakeRule(const Parser &parser, const std::string &path, const std::string &file_name) { - assert(parser.opts.lang <= IDLOptions::kMAX); + FLATBUFFERS_ASSERT(parser.opts.lang <= IDLOptions::kMAX); const auto &lang = GetJsLangParams(parser.opts.lang); std::string filebase = diff --git a/src/idl_gen_php.cpp b/src/idl_gen_php.cpp index 56429cec3..7d98e00de 100644 --- a/src/idl_gen_php.cpp +++ b/src/idl_gen_php.cpp @@ -702,7 +702,7 @@ class PhpGenerator : public BaseGenerator { break; } case BASE_TYPE_UNION: GetUnionField(field, code_ptr); break; - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } } if (field.value.type.base_type == BASE_TYPE_VECTOR) { diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp index 76dd29ac2..7695155c8 100644 --- a/src/idl_gen_python.cpp +++ b/src/idl_gen_python.cpp @@ -459,7 +459,7 @@ static void GenStructAccessor(const StructDef &struct_def, break; } case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break; - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } } if (field.value.type.base_type == BASE_TYPE_VECTOR) { diff --git a/src/idl_gen_text.cpp b/src/idl_gen_text.cpp index 6ef7f0967..cb2525bf8 100644 --- a/src/idl_gen_text.cpp +++ b/src/idl_gen_text.cpp @@ -108,7 +108,7 @@ bool Print(const void *val, Type type, int indent, case BASE_TYPE_UNION: // If this assert hits, you have an corrupt buffer, a union type field // was not present or was out of range. - assert(union_type); + FLATBUFFERS_ASSERT(union_type); return Print(val, *union_type, indent, nullptr, opts, _text); case BASE_TYPE_STRUCT: @@ -143,7 +143,7 @@ bool Print(const void *val, Type type, int indent, // clang-format on } break; - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } return true; } @@ -173,7 +173,7 @@ static bool GenFieldOffset(const FieldDef &fd, const Table *table, bool fixed, const void *val = nullptr; if (fixed) { // The only non-scalar fields in structs are structs. - assert(IsStruct(fd.value.type)); + FLATBUFFERS_ASSERT(IsStruct(fd.value.type)); val = reinterpret_cast(table)->GetStruct( fd.value.offset); } else if (fd.flexbuffer) { @@ -261,7 +261,7 @@ static bool GenStruct(const StructDef &struct_def, const Table *table, bool GenerateText(const Parser &parser, const void *flatbuffer, std::string *_text) { std::string &text = *_text; - assert(parser.root_struct_def_); // call SetRootType() + FLATBUFFERS_ASSERT(parser.root_struct_def_); // call SetRootType() text.reserve(1024); // Reduce amount of inevitable reallocs. auto root = parser.opts.size_prefixed ? GetSizePrefixedRoot
(flatbuffer) : GetRoot
(flatbuffer); diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index 3a1d7b9f0..c0fe5335f 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -826,7 +826,7 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, const StructDef *parent_struct_def) { switch (val.type.base_type) { case BASE_TYPE_UNION: { - assert(field); + FLATBUFFERS_ASSERT(field); std::string constant; // Find corresponding type field we may have already parsed. for (auto elem = field_stack_.rbegin(); @@ -843,9 +843,9 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, // output these in alphabetical order, meaning it comes after this // value. So we scan past the value to find it, then come back here. auto type_name = field->name + UnionTypeFieldSuffix(); - assert(parent_struct_def); + FLATBUFFERS_ASSERT(parent_struct_def); auto type_field = parent_struct_def->fields.Lookup(type_name); - assert(type_field); // Guaranteed by ParseField(). + FLATBUFFERS_ASSERT(type_field); // Guaranteed by ParseField(). // Remember where we are in the source file, so we can come back here. auto backup = *static_cast(this); ECHECK(SkipAnyJsonValue()); // The table. @@ -882,7 +882,7 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, } else if (enum_val->union_type.base_type == BASE_TYPE_STRING) { ECHECK(ParseString(val)); } else { - assert(false); + FLATBUFFERS_ASSERT(false); } break; } @@ -917,7 +917,7 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, } void Parser::SerializeStruct(const StructDef &struct_def, const Value &val) { - assert(val.constant.length() == struct_def.bytesize); + FLATBUFFERS_ASSERT(val.constant.length() == struct_def.bytesize); builder_.Align(struct_def.minalign); builder_.PushBytes(reinterpret_cast(val.constant.c_str()), struct_def.bytesize); @@ -1105,14 +1105,14 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, if (struct_def.fixed) { builder_.ClearOffsets(); builder_.EndStruct(); - assert(value); + FLATBUFFERS_ASSERT(value); // Temporarily store this struct in the value string, since it is to // be serialized in-place elsewhere. value->assign( reinterpret_cast(builder_.GetCurrentBufferPointer()), struct_def.bytesize); builder_.PopBytes(struct_def.bytesize); - assert(!ovalue); + FLATBUFFERS_ASSERT(!ovalue); } else { auto val = builder_.EndTable(start); if (ovalue) *ovalue = val; @@ -1195,7 +1195,7 @@ CheckedError Parser::ParseNestedFlatbuffer(Value &val, FieldDef *field, // Create and initialize new parser Parser nested_parser; - assert(field->nested_flatbuffer); + FLATBUFFERS_ASSERT(field->nested_flatbuffer); nested_parser.root_struct_def_ = field->nested_flatbuffer; nested_parser.enums_ = enums_; nested_parser.opts = opts; @@ -1307,7 +1307,7 @@ CheckedError Parser::ParseEnumFromString(Type &type, int64_t *result) { } CheckedError Parser::ParseHash(Value &e, FieldDef *field) { - assert(field); + FLATBUFFERS_ASSERT(field); Value *hash_name = field->attributes.Lookup("hash"); switch (e.type.base_type) { case BASE_TYPE_SHORT: { @@ -1346,7 +1346,7 @@ CheckedError Parser::ParseHash(Value &e, FieldDef *field) { e.constant = NumToString(hashed_value); break; } - default: assert(0); + default: FLATBUFFERS_ASSERT(0); } NEXT(); return NoError(); @@ -1401,7 +1401,7 @@ CheckedError Parser::ParseSingleValue(const std::string *name, Value &e) { e.constant = NumToString(strtod(attribute_.c_str(), &end)); if (*end) return Error("invalid float: " + attribute_); } else { - assert(0); // Shouldn't happen, we covered all types. + FLATBUFFERS_ASSERT(0); // Shouldn't happen, we covered all types. e.constant = "0"; } NEXT(); @@ -2279,7 +2279,7 @@ CheckedError Parser::ParseRoot(const char *source, const char **include_paths, auto &bt = field.value.type.base_type == BASE_TYPE_VECTOR ? field.value.type.element : field.value.type.base_type; - assert(bt == BASE_TYPE_STRUCT); + FLATBUFFERS_ASSERT(bt == BASE_TYPE_STRUCT); bt = enum_def->underlying_type.base_type; struct_def.refcount--; enum_def->refcount++; @@ -2613,7 +2613,7 @@ Definition::SerializeAttributes(FlatBufferBuilder *builder, std::vector> attrs; for (auto kv = attributes.dict.begin(); kv != attributes.dict.end(); ++kv) { auto it = parser.known_attributes_.find(kv->first); - assert(it != parser.known_attributes_.end()); + FLATBUFFERS_ASSERT(it != parser.known_attributes_.end()); if (!it->second) { // Custom attribute. attrs.push_back(reflection::CreateKeyValue( *builder, builder->CreateString(kv->first), diff --git a/src/reflection.cpp b/src/reflection.cpp index 7ffefe7a5..4a6c64aef 100644 --- a/src/reflection.cpp +++ b/src/reflection.cpp @@ -275,7 +275,7 @@ class ResizeContext { break; } case reflection::String: break; - default: assert(false); + default: FLATBUFFERS_ASSERT(false); } } // Check if the vtable offset points beyond the insertion point. @@ -478,7 +478,7 @@ Offset CopyTable(FlatBufferBuilder &fbb, } } } - assert(offset_idx == offsets.size()); + FLATBUFFERS_ASSERT(offset_idx == offsets.size()); if (objectdef.is_struct()) { fbb.ClearOffsets(); return fbb.EndStruct(); @@ -518,11 +518,11 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema, bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema, const flatbuffers::Table &table, const reflection::Field &vec_field) { - assert(vec_field.type()->base_type() == reflection::Vector); + FLATBUFFERS_ASSERT(vec_field.type()->base_type() == reflection::Vector); if (!table.VerifyField(v, vec_field.offset())) return false; switch (vec_field.type()->element()) { - case reflection::None: assert(false); break; + case reflection::None: FLATBUFFERS_ASSERT(false); break; case reflection::UType: return v.Verify(flatbuffers::GetFieldV(table, vec_field)); case reflection::Bool: @@ -552,7 +552,7 @@ bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema, return false; } } - case reflection::Vector: assert(false); break; + case reflection::Vector: FLATBUFFERS_ASSERT(false); break; case reflection::Obj: { auto obj = schema.objects()->Get(vec_field.type()->index()); if (obj->is_struct()) { @@ -575,8 +575,8 @@ bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema, } return true; } - case reflection::Union: assert(false); break; - default: assert(false); break; + case reflection::Union: FLATBUFFERS_ASSERT(false); break; + default: FLATBUFFERS_ASSERT(false); break; } return false; @@ -597,7 +597,7 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema, for (uoffset_t i = 0; i < obj.fields()->size(); i++) { auto field_def = obj.fields()->Get(i); switch (field_def->type()->base_type()) { - case reflection::None: assert(false); break; + case reflection::None: FLATBUFFERS_ASSERT(false); break; case reflection::UType: if (!table->VerifyField(v, field_def->offset())) return false; break; @@ -665,7 +665,7 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema, } break; } - default: assert(false); break; + default: FLATBUFFERS_ASSERT(false); break; } } diff --git a/src/util.cpp b/src/util.cpp index 2c8f2d045..15a2f53e2 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -47,12 +47,12 @@ static LoadFileFunction g_load_file_function = LoadFileRaw; static FileExistsFunction g_file_exists_function = FileExistsRaw; bool LoadFile(const char *name, bool binary, std::string *buf) { - assert(g_load_file_function); + FLATBUFFERS_ASSERT(g_load_file_function); return g_load_file_function(name, binary, buf); } bool FileExists(const char *name) { - assert(g_file_exists_function); + FLATBUFFERS_ASSERT(g_file_exists_function); return g_file_exists_function(name); } diff --git a/tests/MyGame/Example/MonsterStorageGrpc.java b/tests/MyGame/Example/MonsterStorageGrpc.java index 4627db8d4..535bba7d2 100644 --- a/tests/MyGame/Example/MonsterStorageGrpc.java +++ b/tests/MyGame/Example/MonsterStorageGrpc.java @@ -1,4 +1,4 @@ -//Generated by flatc compiler (version 1.8.0) +//Generated by flatc compiler (version 1.9.0) //If you make any local changes, they will be lost //source: monster_test.fbs diff --git a/tests/monster_test_generated.h b/tests/monster_test_generated.h index 7bc9496fe..34d74a13c 100644 --- a/tests/monster_test_generated.h +++ b/tests/monster_test_generated.h @@ -2168,7 +2168,7 @@ inline flatbuffers::Offset AnyUnion::Pack(flatbuffers::FlatBufferBuilder & inline AnyUnion::AnyUnion(const AnyUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) { switch (type) { case Any_Monster: { - assert(false); // MonsterT not copyable. + FLATBUFFERS_ASSERT(false); // MonsterT not copyable. break; } case Any_TestSimpleTableWithEnum: { diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index 18f1d6e87..1034ef2bc 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -import * as NS9459827973991502386 from "./namespace_test1_generated"; +import * as NS11563891686210618450 from "./namespace_test1_generated"; /** * @constructor */ @@ -39,24 +39,24 @@ static getRootAsTableInFirstNS(bb:flatbuffers.ByteBuffer, obj?:TableInFirstNS):T * @param {NamespaceA.NamespaceB.TableInNestedNS=} obj * @returns {NamespaceA.NamespaceB.TableInNestedNS|null} */ -fooTable(obj?:NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS|null { +fooTable(obj?:NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS):NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS|null { var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? (obj || new NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; }; /** * @returns {NamespaceA.NamespaceB.EnumInNestedNS} */ -fooEnum():NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS { +fooEnum():NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS { var offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb!.readInt8(this.bb_pos + offset)) : NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A; + return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb!.readInt8(this.bb_pos + offset)) : NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS.A; }; /** * @param {NamespaceA.NamespaceB.EnumInNestedNS} value * @returns {boolean} */ -mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS):boolean { +mutate_foo_enum(value:NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS):boolean { var offset = this.bb!.__offset(this.bb_pos, 6); if (offset === 0) { @@ -71,9 +71,9 @@ mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS * @param {NamespaceA.NamespaceB.StructInNestedNS=} obj * @returns {NamespaceA.NamespaceB.StructInNestedNS|null} */ -fooStruct(obj?:NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS|null { +fooStruct(obj?:NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS):NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS|null { var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb!) : null; + return offset ? (obj || new NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb!) : null; }; /** @@ -95,8 +95,8 @@ static addFooTable(builder:flatbuffers.Builder, fooTableOffset:flatbuffers.Offse * @param {flatbuffers.Builder} builder * @param {NamespaceA.NamespaceB.EnumInNestedNS} fooEnum */ -static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS) { - builder.addFieldInt8(1, fooEnum, NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A); +static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS) { + builder.addFieldInt8(1, fooEnum, NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS.A); }; /**