diff --git a/.clang-format b/.clang-format index e27ba59f7..7da2b4389 100644 --- a/.clang-format +++ b/.clang-format @@ -1,7 +1,13 @@ --- -Language: Cpp -BasedOnStyle: Google +Language: Cpp +BasedOnStyle: Google DerivePointerAlignment: false PointerAlignment: Right +IndentPPDirectives: AfterHash +Cpp11BracedListStyle: false +AlwaysBreakTemplateDeclarations: false +AllowShortCaseLabelsOnASingleLine: true +SpaceAfterTemplateKeyword: false +AllowShortBlocksOnASingleLine: true ... diff --git a/grpc/src/compiler/schema_interface.h b/grpc/src/compiler/schema_interface.h index 25bbdb514..2be2ed738 100644 --- a/grpc/src/compiler/schema_interface.h +++ b/grpc/src/compiler/schema_interface.h @@ -40,8 +40,8 @@ #include #ifndef GRPC_CUSTOM_STRING -#include -#define GRPC_CUSTOM_STRING std::string +# include +# define GRPC_CUSTOM_STRING std::string #endif namespace grpc { diff --git a/grpc/tests/grpctest.cpp b/grpc/tests/grpctest.cpp index 83b288a1c..cbb9bac1b 100644 --- a/grpc/tests/grpctest.cpp +++ b/grpc/tests/grpctest.cpp @@ -18,46 +18,48 @@ #include -#include "monster_test_generated.h" #include "monster_test.grpc.fb.h" +#include "monster_test_generated.h" using namespace MyGame::Example; // The callback implementation of our server, that derives from the generated // code. It implements all rpcs specified in the FlatBuffers schema. class ServiceImpl final : public MyGame::Example::MonsterStorage::Service { - virtual ::grpc::Status Store(::grpc::ServerContext* context, - const flatbuffers::grpc::Message *request, - flatbuffers::grpc::Message *response) - override { + virtual ::grpc::Status Store( + ::grpc::ServerContext *context, + const flatbuffers::grpc::Message *request, + flatbuffers::grpc::Message *response) override { // Create a response from the incoming request name. fbb_.Clear(); - auto stat_offset = CreateStat(fbb_, fbb_.CreateString("Hello, " + - request->GetRoot()->name()->str())); + auto stat_offset = CreateStat( + fbb_, fbb_.CreateString("Hello, " + request->GetRoot()->name()->str())); fbb_.Finish(stat_offset); // Transfer ownership of the message to gRPC *response = fbb_.ReleaseMessage(); return grpc::Status::OK; } - virtual ::grpc::Status Retrieve(::grpc::ServerContext *context, - const flatbuffers::grpc::Message *request, - ::grpc::ServerWriter< flatbuffers::grpc::Message>* writer) - override { + virtual ::grpc::Status Retrieve( + ::grpc::ServerContext *context, + const flatbuffers::grpc::Message *request, + ::grpc::ServerWriter> *writer) + override { + for (int i = 0; i < 10; i++) { + fbb_.Clear(); + // Create 10 monsters for resposne. + auto monster_offset = + CreateMonster(fbb_, 0, 0, 0, + fbb_.CreateString(request->GetRoot()->id()->str() + + " No." + std::to_string(i))); + fbb_.Finish(monster_offset); - for (int i=0; i<10; i++) { - fbb_.Clear(); - // Create 10 monsters for resposne. - auto monster_offset = - CreateMonster(fbb_, 0, 0, 0, fbb_.CreateString( - request->GetRoot()->id()->str() + " No." + std::to_string(i))); - fbb_.Finish(monster_offset); + flatbuffers::grpc::Message monster = + fbb_.ReleaseMessage(); - flatbuffers::grpc::Message monster = fbb_.ReleaseMessage(); - - // Send monster to client using streaming. - writer->Write(monster); - } - return grpc::Status::OK; + // Send monster to client using streaming. + writer->Write(monster); + } + return grpc::Status::OK; } private: @@ -90,7 +92,7 @@ void RunServer() { server_instance->Wait(); } -int main(int /*argc*/, const char * /*argv*/[]) { +int main(int /*argc*/, const char * /*argv*/ []) { // Launch server. std::thread server_thread(RunServer); @@ -103,7 +105,6 @@ int main(int /*argc*/, const char * /*argv*/[]) { grpc::InsecureChannelCredentials()); auto stub = MyGame::Example::MonsterStorage::NewStub(channel); - flatbuffers::grpc::MessageBuilder fbb; { grpc::ClientContext context; @@ -138,7 +139,7 @@ int main(int /*argc*/, const char * /*argv*/[]) { } } - #if !FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION +#if !FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION { // Test that an invalid request errors out correctly grpc::ClientContext context; @@ -149,9 +150,10 @@ int main(int /*argc*/, const char * /*argv*/[]) { // matches the protobuf gRPC status code for an unparseable message. assert(!status.ok()); assert(status.error_code() == ::grpc::StatusCode::INTERNAL); - assert(strcmp(status.error_message().c_str(), "Message verification failed") == 0); + assert(strcmp(status.error_message().c_str(), + "Message verification failed") == 0); } - #endif +#endif server_instance->Shutdown(); diff --git a/include/flatbuffers/base.h b/include/flatbuffers/base.h index 2f03e420e..784a7d078 100644 --- a/include/flatbuffers/base.h +++ b/include/flatbuffers/base.h @@ -1,6 +1,7 @@ #ifndef FLATBUFFERS_BASE_H_ #define FLATBUFFERS_BASE_H_ +// clang-format off #if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING) && \ defined(_MSC_VER) && defined(_DEBUG) #define _CRTDBG_MAP_ALLOC diff --git a/include/flatbuffers/code_generators.h b/include/flatbuffers/code_generators.h index fad0afe2a..d19002e69 100644 --- a/include/flatbuffers/code_generators.h +++ b/include/flatbuffers/code_generators.h @@ -49,7 +49,7 @@ class CodeWriter { // Associates a key with a value. All subsequent calls to operator+=, where // the specified key is contained in {{ and }} delimiters will be replaced by // the given value. - void SetValue(const std::string& key, const std::string& value) { + void SetValue(const std::string &key, const std::string &value) { value_map_[key] = value; } @@ -71,8 +71,7 @@ class BaseGenerator { public: virtual bool generate() = 0; - static std::string NamespaceDir(const Parser &parser, - const std::string &path, + static std::string NamespaceDir(const Parser &parser, const std::string &path, const Namespace &ns); protected: @@ -128,8 +127,7 @@ struct CommentConfig { }; extern void GenComment(const std::vector &dc, - std::string *code_ptr, - const CommentConfig *config, + std::string *code_ptr, const CommentConfig *config, const char *prefix = ""); } // namespace flatbuffers diff --git a/include/flatbuffers/flatbuffers.h b/include/flatbuffers/flatbuffers.h index df616f8a4..ef694f749 100644 --- a/include/flatbuffers/flatbuffers.h +++ b/include/flatbuffers/flatbuffers.h @@ -38,6 +38,7 @@ inline void EndianCheck() { } template FLATBUFFERS_CONSTEXPR size_t AlignOf() { + // clang-format off #ifdef _MSC_VER return __alignof(T); #else @@ -47,6 +48,7 @@ template FLATBUFFERS_CONSTEXPR size_t AlignOf() { return alignof(T); #endif #endif + // clang-format on } // When we read serialized data from memory, in the case of most scalars, @@ -85,16 +87,15 @@ template struct IndirectHelper { // 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 uoffset_t difference_type; typedef IT *pointer; typedef IT &reference; - VectorIterator(const uint8_t *data, uoffset_t i) : - data_(data + IndirectHelper::element_stride * i) {} + VectorIterator(const uint8_t *data, uoffset_t i) + : data_(data + IndirectHelper::element_stride * i) {} VectorIterator(const VectorIterator &other) : data_(other.data_) {} VectorIterator &operator=(const VectorIterator &other) { @@ -123,13 +124,9 @@ struct VectorIterator { return (data_ - other.data_) / IndirectHelper::element_stride; } - IT operator *() const { - return IndirectHelper::Read(data_, 0); - } + IT operator*() const { return IndirectHelper::Read(data_, 0); } - IT operator->() const { - return IndirectHelper::Read(data_, 0); - } + IT operator->() const { return IndirectHelper::Read(data_, 0); } VectorIterator &operator++() { data_ += IndirectHelper::element_stride; @@ -143,10 +140,11 @@ struct VectorIterator { } VectorIterator operator+(const uoffset_t &offset) const { - return VectorIterator(data_ + offset * IndirectHelper::element_stride, 0); + return VectorIterator(data_ + offset * IndirectHelper::element_stride, + 0); } - VectorIterator& operator+=(const uoffset_t &offset) { + VectorIterator &operator+=(const uoffset_t &offset) { data_ += offset * IndirectHelper::element_stride; return *this; } @@ -163,15 +161,16 @@ struct VectorIterator { } VectorIterator operator-(const uoffset_t &offset) { - return VectorIterator(data_ - offset * IndirectHelper::element_stride, 0); + return VectorIterator(data_ - offset * IndirectHelper::element_stride, + 0); } - VectorIterator& operator-=(const uoffset_t &offset) { + VectorIterator &operator-=(const uoffset_t &offset) { data_ -= offset * IndirectHelper::element_stride; return *this; } -private: + private: const uint8_t *data_; }; @@ -180,11 +179,11 @@ struct String; // This is used as a helper type for accessing vectors. // Vector::data() assumes the vector elements start after the length field. template class Vector { -public: + public: typedef VectorIterator::mutable_return_type> - iterator; + iterator; typedef VectorIterator::return_type> - const_iterator; + const_iterator; uoffset_t size() const { return EndianScalar(length_); } @@ -232,7 +231,7 @@ public: // 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(uoffset_t i, const T &val) { assert(i < size()); WriteScalar(data() + i, val); } @@ -258,17 +257,15 @@ public: return reinterpret_cast(&length_ + 1); } - uint8_t *Data() { - return reinterpret_cast(&length_ + 1); - } + uint8_t *Data() { return reinterpret_cast(&length_ + 1); } // Similarly, but typed, much like std::vector::data const T *data() const { return reinterpret_cast(Data()); } T *data() { return reinterpret_cast(Data()); } template return_type LookupByKey(K key) const { - void *search_result = std::bsearch(&key, Data(), size(), - IndirectHelper::element_stride, KeyCompare); + void *search_result = std::bsearch( + &key, Data(), size(), IndirectHelper::element_stride, KeyCompare); if (!search_result) { return nullptr; // Key not found. @@ -279,17 +276,17 @@ public: return IndirectHelper::Read(element, 0); } -protected: + protected: // This class is only used to access pre-existing data. Don't ever // try to construct these manually. Vector(); uoffset_t length_; -private: + private: // This class is a pointer. Copying will therefore create an invalid object. // Private and unimplemented copy constructor. - Vector(const Vector&); + Vector(const Vector &); template static int KeyCompare(const void *ap, const void *bp) { const K *key = reinterpret_cast(ap); @@ -305,22 +302,21 @@ private: // 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 { -public: + public: uoffset_t size() const { return EndianScalar(length_); } const uint8_t *Data() const { return reinterpret_cast(&length_ + 1); } - uint8_t *Data() { - return reinterpret_cast(&length_ + 1); - } -protected: + uint8_t *Data() { return reinterpret_cast(&length_ + 1); } + + protected: VectorOfAny(); uoffset_t length_; -private: - VectorOfAny(const VectorOfAny&); + private: + VectorOfAny(const VectorOfAny &); }; #ifndef FLATBUFFERS_CPP98_STL @@ -347,7 +343,7 @@ struct String : public Vector { const char *c_str() const { return reinterpret_cast(Data()); } std::string str() const { return std::string(c_str(), Length()); } - bool operator <(const String &o) const { + bool operator<(const String &o) const { return strcmp(c_str(), o.c_str()) < 0; } }; @@ -399,20 +395,32 @@ class DefaultAllocator : public Allocator { // the DetachedBuffer can manage the memory lifetime. class DetachedBuffer { public: - DetachedBuffer() : allocator_(nullptr), own_allocator_(false), buf_(nullptr), - reserved_(0), cur_(nullptr), size_(0) {} + DetachedBuffer() + : allocator_(nullptr), + own_allocator_(false), + buf_(nullptr), + reserved_(0), + cur_(nullptr), + size_(0) {} DetachedBuffer(Allocator *allocator, bool own_allocator, uint8_t *buf, size_t reserved, uint8_t *cur, size_t sz) - : allocator_(allocator), own_allocator_(own_allocator), buf_(buf), - reserved_(reserved), cur_(cur), size_(sz) { + : allocator_(allocator), + own_allocator_(own_allocator), + buf_(buf), + reserved_(reserved), + cur_(cur), + size_(sz) { assert(allocator_); } DetachedBuffer(DetachedBuffer &&other) - : allocator_(other.allocator_), own_allocator_(other.own_allocator_), - buf_(other.buf_), reserved_(other.reserved_), cur_(other.cur_), - size_(other.size_) { + : allocator_(other.allocator_), + own_allocator_(other.own_allocator_), + buf_(other.buf_), + reserved_(other.reserved_), + cur_(other.cur_), + size_(other.size_) { other.reset(); } @@ -431,23 +439,16 @@ class DetachedBuffer { return *this; } - ~DetachedBuffer() { - destroy(); - } + ~DetachedBuffer() { destroy(); } - const uint8_t *data() const { - return cur_; - } + const uint8_t *data() const { return cur_; } - uint8_t *data() { - return cur_; - } + uint8_t *data() { return cur_; } - size_t size() const { - return size_; - } + size_t size() const { return size_; } -#if 0 // disabled for now due to the ordering of classes in this header + // clang-format off + #if 0 // disabled for now due to the ordering of classes in this header template bool Verify() const { Verifier verifier(data(), size()); @@ -463,7 +464,8 @@ class DetachedBuffer { T* GetRoot() { return flatbuffers::GetRoot(data()); } -#endif + #endif + // clang-format on // These may change access mode, leave these at end of public section FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer &other)) @@ -483,9 +485,7 @@ class DetachedBuffer { assert(allocator_); allocator_->deallocate(buf_, reserved_); } - if (own_allocator_ && allocator_) { - delete allocator_; - } + if (own_allocator_ && allocator_) { delete allocator_; } reset(); } @@ -508,9 +508,12 @@ class vector_downward { explicit vector_downward(size_t initial_size = 1024, Allocator *allocator = nullptr, bool own_allocator = false) - : allocator_(allocator ? allocator : &DefaultAllocator::instance()), - own_allocator_(own_allocator), initial_size_(initial_size), reserved_(0), - buf_(nullptr), cur_(nullptr) { + : allocator_(allocator ? allocator : &DefaultAllocator::instance()), + own_allocator_(own_allocator), + initial_size_(initial_size), + reserved_(0), + buf_(nullptr), + cur_(nullptr) { assert(allocator_); } @@ -519,9 +522,7 @@ class vector_downward { assert(allocator_); allocator_->deallocate(buf_, reserved_); } - if (own_allocator_ && allocator_) { - delete allocator_; - } + if (own_allocator_ && allocator_) { delete allocator_; } } void reset() { @@ -563,9 +564,7 @@ class vector_downward { uint8_t *make_space(size_t len) { assert(cur_ >= buf_); - if (len > static_cast(cur_ - buf_)) { - reallocate(len); - } + if (len > static_cast(cur_ - buf_)) { reallocate(len); } cur_ -= len; // Beyond this, signed offsets may not have enough range: // (FlatBuffers > 2GB not supported). @@ -579,9 +578,7 @@ class vector_downward { return static_cast(reserved_ - (cur_ - buf_)); } - size_t capacity() const { - return reserved_; - } + size_t capacity() const { return reserved_; } uint8_t *buf() const { assert(buf_); @@ -601,7 +598,7 @@ class vector_downward { } // Specialized version of push() that avoids memcpy call for small data. - template void push_small(const T& little_endian_t) { + template void push_small(const T &little_endian_t) { auto dest = make_space(sizeof(T)); *reinterpret_cast(dest) = little_endian_t; } @@ -656,10 +653,11 @@ inline voffset_t FieldIndexToOffset(voffset_t field_id) { return static_cast((field_id + fixed_fields) * sizeof(voffset_t)); } -template const T* data(const std::vector &v) { +template +const T *data(const std::vector &v) { return v.empty() ? nullptr : &v.front(); } -template T* data(std::vector &v) { +template T *data(std::vector &v) { return v.empty() ? nullptr : &v.front(); } @@ -674,8 +672,7 @@ template T* data(std::vector &v) { /// `PushElement`/`AddElement`/`EndTable`, or the builtin `CreateString`/ /// `CreateVector` functions. Do this is depth-first order to build up a tree to /// the root. `Finish()` wraps up the buffer ready for transport. -class FlatBufferBuilder -{ +class FlatBufferBuilder { public: /// @brief Default constructor for FlatBufferBuilder. /// @param[in] initial_size The initial size of the buffer, in bytes. Defaults @@ -687,9 +684,14 @@ class FlatBufferBuilder explicit FlatBufferBuilder(size_t initial_size = 1024, Allocator *allocator = nullptr, bool own_allocator = false) - : buf_(initial_size, allocator, own_allocator), max_voffset_(0), - nested(false), finished(false), minalign_(1), force_defaults_(false), - dedup_vtables_(true), string_pool(nullptr) { + : buf_(initial_size, allocator, own_allocator), + max_voffset_(0), + nested(false), + finished(false), + minalign_(1), + force_defaults_(false), + dedup_vtables_(true), + string_pool(nullptr) { offsetbuf_.reserve(16); // Avoid first few reallocs. vtables_.reserve(16); EndianCheck(); @@ -700,7 +702,7 @@ class FlatBufferBuilder } void Reset() { - Clear(); // clear builder state + Clear(); // clear builder state buf_.reset(); // deallocate buffer } @@ -792,9 +794,7 @@ class FlatBufferBuilder finished = true; } - void PushBytes(const uint8_t *bytes, size_t size) { - buf_.push(bytes, size); - } + void PushBytes(const uint8_t *bytes, size_t size) { buf_.push(bytes, size); } void PopBytes(size_t amount) { buf_.pop(amount); } @@ -894,9 +894,9 @@ class FlatBufferBuilder // by the offsets themselves. In reverse: // Include space for the last offset and ensure empty tables have a // minimum size. - max_voffset_ = (std::max)(static_cast(max_voffset_ + - sizeof(voffset_t)), - FieldIndexToOffset(0)); + max_voffset_ = + (std::max)(static_cast(max_voffset_ + sizeof(voffset_t)), + FieldIndexToOffset(0)); buf_.fill_big(max_voffset_); auto table_object_size = vtableoffsetloc - start; assert(table_object_size < 0x10000); // Vtable use 16bit offsets. @@ -905,8 +905,7 @@ class FlatBufferBuilder WriteScalar(buf_.data(), max_voffset_); // Write the offsets into the table for (auto field_location = offsetbuf_.begin(); - field_location != offsetbuf_.end(); - ++field_location) { + field_location != offsetbuf_.end(); ++field_location) { 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)); @@ -929,9 +928,7 @@ class FlatBufferBuilder } } // If this is a new vtable, remember it. - if (vt_use == GetSize()) { - vtables_.push_back(vt_use); - } + if (vt_use == GetSize()) { vtables_.push_back(vt_use); } // Fill the vtable offset we created above. // The offset points from the beginning of the object to where the // vtable is stored. @@ -939,7 +936,7 @@ class FlatBufferBuilder // flexibility (storing all vtables at the start of the file). WriteScalar(buf_.data_at(vtableoffsetloc), static_cast(vt_use) - - static_cast(vtableoffsetloc)); + static_cast(vtableoffsetloc)); nested = false; return vtableoffsetloc; @@ -1022,8 +1019,7 @@ class FlatBufferBuilder /// @param[in] str A const reference to a std::string like type with support /// of T::c_str() and T::length() to store in the buffer. /// @return Returns the offset in the buffer where the string starts. - template - Offset CreateString(const T &str) { + template Offset CreateString(const T &str) { return CreateString(str.c_str(), str.length()); } @@ -1119,6 +1115,7 @@ class FlatBufferBuilder // causing the wrong overload to be selected, remove it. AssertScalarT(); StartVector(len, sizeof(T)); + // clang-format off #if FLATBUFFERS_LITTLEENDIAN PushBytes(reinterpret_cast(v), len * sizeof(T)); #else @@ -1130,14 +1127,14 @@ class FlatBufferBuilder } } #endif + // clang-format on return Offset>(EndVector(len)); } - template Offset>> CreateVector(const Offset *v, size_t len) { + template + Offset>> CreateVector(const Offset *v, size_t len) { StartVector(len, sizeof(Offset)); - for (auto i = len; i > 0; ) { - PushElement(v[--i]); - } + for (auto i = len; i > 0;) { PushElement(v[--i]); } return Offset>>(EndVector(len)); } @@ -1156,12 +1153,13 @@ class FlatBufferBuilder // Background: https://isocpp.org/blog/2012/11/on-vectorbool Offset> CreateVector(const std::vector &v) { StartVector(v.size(), sizeof(uint8_t)); - for (auto i = v.size(); i > 0; ) { + for (auto i = v.size(); i > 0;) { PushElement(static_cast(v[--i])); } return Offset>(EndVector(v.size())); } + // clang-format off #ifndef FLATBUFFERS_CPP98_STL /// @brief Serialize values returned by a function into a FlatBuffer `vector`. /// This is a convenience function that takes care of iteration for you. @@ -1177,6 +1175,7 @@ class FlatBufferBuilder return CreateVector(elems); } #endif + // clang-format on /// @brief Serialize values returned by a function into a FlatBuffer `vector`. /// This is a convenience function that takes care of iteration for you. @@ -1187,8 +1186,8 @@ class FlatBufferBuilder /// @param state State passed to f. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVector( - size_t vector_size, F f, S *state) { + template + Offset> CreateVector(size_t vector_size, F f, S *state) { std::vector elems(vector_size); for (size_t i = 0; i < vector_size; i++) elems[i] = f(i, state); return CreateVector(elems); @@ -1214,8 +1213,8 @@ class FlatBufferBuilder /// @param[in] len The number of elements to serialize. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfStructs( - const T *v, size_t len) { + template + Offset> CreateVectorOfStructs(const T *v, size_t len) { StartVector(len * sizeof(T) / AlignOf(), AlignOf()); PushBytes(reinterpret_cast(v), sizeof(T) * len); return Offset>(EndVector(len)); @@ -1229,15 +1228,17 @@ class FlatBufferBuilder /// @param[in] len The number of elements to serialize. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfNativeStructs( - const S *v, size_t len) { - extern T Pack(const S&); - typedef T (*Pack_t)(const S&); + template + Offset> CreateVectorOfNativeStructs(const S *v, + size_t len) { + extern T Pack(const S &); + typedef T (*Pack_t)(const S &); std::vector vv(len); - std::transform(v, v+len, vv.begin(), *(Pack_t)&Pack); + std::transform(v, v + len, vv.begin(), *(Pack_t)&Pack); return CreateVectorOfStructs(vv.data(), vv.size()); } + // clang-format off #ifndef FLATBUFFERS_CPP98_STL /// @brief Serialize an array of structs into a FlatBuffer `vector`. /// @tparam T The data type of the struct array elements. @@ -1257,6 +1258,7 @@ class FlatBufferBuilder return EndVectorOfStructs(vector_size); } #endif + // clang-format on /// @brief Serialize an array of structs into a FlatBuffer `vector`. /// @tparam T The data type of the struct array elements. @@ -1267,9 +1269,10 @@ class FlatBufferBuilder /// where the vector is stored. /// This is mostly useful when flatbuffers are generated with mutation /// accessors. - template Offset> - CreateVectorOfStructs(size_t vector_size, F f, S *state) { - T* structs = StartVectorOfStructs(vector_size); + template + Offset> CreateVectorOfStructs(size_t vector_size, F f, + S *state) { + T *structs = StartVectorOfStructs(vector_size); for (size_t i = 0; i < vector_size; i++) { f(i, structs, state); structs++; @@ -1283,33 +1286,34 @@ class FlatBufferBuilder /// serialize into the buffer as a `vector`. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfStructs( + template + Offset> CreateVectorOfStructs( const std::vector &v) { return CreateVectorOfStructs(data(v), v.size()); } - /// @brief Serialize a `std::vector` of native structs into a FlatBuffer `vector`. + /// @brief Serialize a `std::vector` of native structs into a FlatBuffer + /// `vector`. /// @tparam T The data type of the `std::vector` struct elements. /// @tparam S The data type of the `std::vector` native struct elements. /// @param[in]] v A const reference to the `std::vector` of structs to /// serialize into the buffer as a `vector`. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfNativeStructs( + template + Offset> CreateVectorOfNativeStructs( const std::vector &v) { return CreateVectorOfNativeStructs(data(v), v.size()); } - /// @cond FLATBUFFERS_INTERNAL - template - struct StructKeyComparator { + template struct StructKeyComparator { bool operator()(const T &a, const T &b) const { return a.KeyCompareLessThan(&b); } - private: - StructKeyComparator& operator= (const StructKeyComparator&); + private: + StructKeyComparator &operator=(const StructKeyComparator &); }; /// @endcond @@ -1320,20 +1324,21 @@ class FlatBufferBuilder /// serialize into the buffer as a `vector`. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfSortedStructs( - std::vector *v) { + template + Offset> CreateVectorOfSortedStructs(std::vector *v) { return CreateVectorOfSortedStructs(data(*v), v->size()); } - /// @brief Serialize a `std::vector` of native structs into a FlatBuffer `vector` - /// in sorted order. + /// @brief Serialize a `std::vector` of native structs into a FlatBuffer + /// `vector` in sorted order. /// @tparam T The data type of the `std::vector` struct elements. /// @tparam S The data type of the `std::vector` native struct elements. /// @param[in]] v A const reference to the `std::vector` of structs to /// serialize into the buffer as a `vector`. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfSortedNativeStructs( + template + Offset> CreateVectorOfSortedNativeStructs( std::vector *v) { return CreateVectorOfSortedNativeStructs(data(*v), v->size()); } @@ -1346,14 +1351,14 @@ class FlatBufferBuilder /// @param[in] len The number of elements to serialize. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfSortedStructs( - T *v, size_t len) { + template + Offset> CreateVectorOfSortedStructs(T *v, size_t len) { std::sort(v, v + len, StructKeyComparator()); return CreateVectorOfStructs(v, len); } - /// @brief Serialize an array of native structs into a FlatBuffer `vector` in sorted - /// order. + /// @brief Serialize an array of native structs into a FlatBuffer `vector` in + /// sorted order. /// @tparam T The data type of the struct array elements. /// @tparam S The data type of the native struct array elements. /// @param[in] v A pointer to the array of type `S` to serialize into the @@ -1361,28 +1366,28 @@ class FlatBufferBuilder /// @param[in] len The number of elements to serialize. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset> CreateVectorOfSortedNativeStructs( - S *v, size_t len) { - extern T Pack(const S&); - typedef T (*Pack_t)(const S&); + template + Offset> CreateVectorOfSortedNativeStructs(S *v, + size_t len) { + extern T Pack(const S &); + typedef T (*Pack_t)(const S &); std::vector vv(len); - std::transform(v, v+len, vv.begin(), *(Pack_t)&Pack); + std::transform(v, v + len, vv.begin(), *(Pack_t)&Pack); return CreateVectorOfSortedStructs(vv, len); } /// @cond FLATBUFFERS_INTERNAL - template - struct TableKeyComparator { - TableKeyComparator(vector_downward& buf) : buf_(buf) {} + template struct TableKeyComparator { + TableKeyComparator(vector_downward &buf) : buf_(buf) {} bool operator()(const Offset &a, const Offset &b) const { auto table_a = reinterpret_cast(buf_.data_at(a.o)); auto table_b = reinterpret_cast(buf_.data_at(b.o)); return table_a->KeyCompareLessThan(table_b); } - vector_downward& buf_; + vector_downward &buf_; - private: - TableKeyComparator& operator= (const TableKeyComparator&); + private: + TableKeyComparator &operator=(const TableKeyComparator &); }; /// @endcond @@ -1394,8 +1399,9 @@ class FlatBufferBuilder /// @param[in] len The number of elements to store in the `vector`. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset>> CreateVectorOfSortedTables( - Offset *v, size_t len) { + template + Offset>> CreateVectorOfSortedTables(Offset *v, + size_t len) { std::sort(v, v + len, TableKeyComparator(buf_)); return CreateVector(v, len); } @@ -1407,7 +1413,8 @@ class FlatBufferBuilder /// offsets to store in the buffer in sorted order. /// @return Returns a typed `Offset` into the serialized data indicating /// where the vector is stored. - template Offset>> CreateVectorOfSortedTables( + template + Offset>> CreateVectorOfSortedTables( std::vector> *v) { return CreateVectorOfSortedTables(data(*v), v->size()); } @@ -1438,8 +1445,8 @@ class FlatBufferBuilder /// @param[out] buf A pointer to a pointer of type `T` that can be /// written to at a later time to serialize the data into a `vector` /// in the buffer. - template Offset> CreateUninitializedVector( - size_t len, T **buf) { + template + Offset> CreateUninitializedVector(size_t len, T **buf) { return CreateUninitializedVector(len, sizeof(T), reinterpret_cast(buf)); } @@ -1458,9 +1465,8 @@ class FlatBufferBuilder /// @brief Finish serializing a buffer by writing the root offset. /// @param[in] file_identifier If a `file_identifier` is given, the buffer /// will be prefixed with a standard FlatBuffers file header. - template void Finish(Offset root, - const char *file_identifier = nullptr) { - + template + void Finish(Offset root, const char *file_identifier = nullptr) { Finish(root.o, file_identifier, false); } @@ -1471,8 +1477,9 @@ class FlatBufferBuilder /// All >32 bit quantities in this buffer will be aligned when the whole /// size pre-fixed buffer is aligned. /// These kinds of buffers are useful for creating a stream of FlatBuffers. - template void FinishSizePrefixed(Offset root, - const char *file_identifier = nullptr) { + template + void FinishSizePrefixed(Offset root, + const char *file_identifier = nullptr) { Finish(root.o, file_identifier, true); } @@ -1484,9 +1491,8 @@ class FlatBufferBuilder void Finish(uoffset_t root, const char *file_identifier, bool size_prefix) { NotNested(); // This will cause the whole buffer to be aligned. - PreAlign((size_prefix ? sizeof(uoffset_t) : 0) + - sizeof(uoffset_t) + - (file_identifier ? kFileIdentifierLength : 0), + PreAlign((size_prefix ? sizeof(uoffset_t) : 0) + sizeof(uoffset_t) + + (file_identifier ? kFileIdentifierLength : 0), minalign_); if (file_identifier) { assert(strlen(file_identifier) == kFileIdentifierLength); @@ -1494,9 +1500,7 @@ class FlatBufferBuilder kFileIdentifierLength); } PushElement(ReferTo(root)); // Location of root. - if (size_prefix) { - PushElement(GetSize()); - } + if (size_prefix) { PushElement(GetSize()); } finished = true; } @@ -1529,7 +1533,7 @@ class FlatBufferBuilder struct StringOffsetCompare { StringOffsetCompare(const vector_downward &buf) : buf_(&buf) {} - bool operator() (const Offset &a, const Offset &b) const { + bool operator()(const Offset &a, const Offset &b) const { auto stra = reinterpret_cast(buf_->data_at(a.o)); auto strb = reinterpret_cast(buf_->data_at(b.o)); return strncmp(stra->c_str(), strb->c_str(), @@ -1545,15 +1549,15 @@ class FlatBufferBuilder private: // Allocates space for a vector of structures. // Must be completed with EndVectorOfStructs(). - template T* StartVectorOfStructs(size_t vector_size) { + template T *StartVectorOfStructs(size_t vector_size) { StartVector(vector_size * sizeof(T) / AlignOf(), AlignOf()); return reinterpret_cast(buf_.make_space(vector_size * sizeof(T))); } // End the vector of structues in the flatbuffers. // Vector should have previously be started with StartVectorOfStructs(). - template Offset> EndVectorOfStructs( - size_t vector_size) { + template + Offset> EndVectorOfStructs(size_t vector_size) { return Offset>(EndVector(vector_size)); } }; @@ -1563,8 +1567,9 @@ class FlatBufferBuilder // Helpers to get a typed pointer to the root object contained in the buffer. template T *GetMutableRoot(void *buf) { EndianCheck(); - return reinterpret_cast(reinterpret_cast(buf) + - EndianScalar(*reinterpret_cast(buf))); + return reinterpret_cast( + reinterpret_cast(buf) + + EndianScalar(*reinterpret_cast(buf))); } template const T *GetRoot(const void *buf) { @@ -1578,18 +1583,17 @@ template const T *GetSizePrefixedRoot(const void *buf) { /// Helpers to get a typed pointer to objects that are currently being built. /// @warning Creating new objects will lead to reallocations and invalidates /// the pointer! -template T *GetMutableTemporaryPointer(FlatBufferBuilder &fbb, - Offset offset) { - return reinterpret_cast(fbb.GetCurrentBufferPointer() + - fbb.GetSize() - offset.o); +template +T *GetMutableTemporaryPointer(FlatBufferBuilder &fbb, Offset offset) { + return reinterpret_cast(fbb.GetCurrentBufferPointer() + fbb.GetSize() - + offset.o); } -template const T *GetTemporaryPointer(FlatBufferBuilder &fbb, - Offset offset) { +template +const T *GetTemporaryPointer(FlatBufferBuilder &fbb, Offset offset) { return GetMutableTemporaryPointer(fbb, offset); } - /// @brief Get a pointer to the the file_identifier section of the buffer. /// @return Returns a const char pointer to the start of the file_identifier /// characters in the buffer. The returned char * has length @@ -1603,8 +1607,8 @@ inline const char *GetBufferIdentifier(const void *buf) { // Helper to see if the identifier in a buffer has the expected value. inline bool BufferHasIdentifier(const void *buf, const char *identifier) { - return strncmp(GetBufferIdentifier(buf), - identifier, FlatBufferBuilder::kFileIdentifierLength) == 0; + return strncmp(GetBufferIdentifier(buf), identifier, + FlatBufferBuilder::kFileIdentifierLength) == 0; } // Helper class to verify the integrity of a FlatBuffer @@ -1612,15 +1616,23 @@ class Verifier FLATBUFFERS_FINAL_CLASS { public: Verifier(const uint8_t *buf, size_t buf_len, uoffset_t _max_depth = 64, uoffset_t _max_tables = 1000000) - : buf_(buf), end_(buf + buf_len), depth_(0), max_depth_(_max_depth), - num_tables_(0), max_tables_(_max_tables) + : buf_(buf), + end_(buf + buf_len), + depth_(0), + max_depth_(_max_depth), + num_tables_(0), + max_tables_(_max_tables) + // clang-format off #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE , upper_bound_(buf) #endif - {} + // clang-format on + { + } // Central location where any verification failures register. bool Check(bool ok) const { + // clang-format off #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE assert(ok); #endif @@ -1628,18 +1640,20 @@ class Verifier FLATBUFFERS_FINAL_CLASS { if (!ok) upper_bound_ = buf_; #endif + // clang-format on return ok; } // Verify any range within the buffer. bool Verify(const void *elem, size_t elem_len) const { + // clang-format off #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE auto upper_bound = reinterpret_cast(elem) + elem_len; if (upper_bound_ < upper_bound) upper_bound_ = upper_bound; #endif - return Check(elem_len <= (size_t) (end_ - buf_) && - elem >= buf_ && + // clang-format on + return Check(elem_len <= (size_t)(end_ - buf_) && elem >= buf_ && elem <= end_ - elem_len); } @@ -1656,9 +1670,8 @@ class Verifier FLATBUFFERS_FINAL_CLASS { // Verify a pointer (may be NULL) of any vector type. template bool Verify(const Vector *vec) const { const uint8_t *end; - return !vec || - VerifyVector(reinterpret_cast(vec), sizeof(T), - &end); + return !vec || VerifyVector(reinterpret_cast(vec), + sizeof(T), &end); } // Verify a pointer (may be NULL) of a vector to struct. @@ -1693,12 +1706,12 @@ class Verifier FLATBUFFERS_FINAL_CLASS { // Special case for string contents, after the above has been called. bool VerifyVectorOfStrings(const Vector> *vec) const { - if (vec) { - for (uoffset_t i = 0; i < vec->size(); i++) { - if (!Verify(vec->Get(i))) return false; - } + if (vec) { + for (uoffset_t i = 0; i < vec->size(); i++) { + if (!Verify(vec->Get(i))) return false; } - return true; + } + return true; } // Special case for table contents, after the above has been called. @@ -1711,8 +1724,8 @@ class Verifier FLATBUFFERS_FINAL_CLASS { return true; } - template bool VerifyBufferFromStart(const char *identifier, - const uint8_t *start) { + template + bool VerifyBufferFromStart(const char *identifier, const uint8_t *start) { if (identifier && (size_t(end_ - start) < 2 * sizeof(flatbuffers::uoffset_t) || !BufferHasIdentifier(start, identifier))) { @@ -1721,19 +1734,15 @@ class Verifier FLATBUFFERS_FINAL_CLASS { // Call T::Verify, which must be in the generated code for this type. auto o = VerifyOffset(start); - return o && - reinterpret_cast(start + o)-> - Verify(*this) - #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE - && GetComputedSize() - #endif - ; + return o && reinterpret_cast(start + o)->Verify(*this) +#ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE + && GetComputedSize() +#endif + ; } // Verify this whole buffer, starting with root type T. - template bool VerifyBuffer() { - return VerifyBuffer(nullptr); - } + template bool VerifyBuffer() { return VerifyBuffer(nullptr); } template bool VerifyBuffer(const char *identifier) { return VerifyBufferFromStart(identifier, buf_); @@ -1768,6 +1777,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS { return true; } + // clang-format off #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE // Returns the message size in bytes size_t GetComputedSize() const { @@ -1777,6 +1787,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS { return (buf_ + size > end_) ? 0 : size; } #endif + // clang-format on private: const uint8_t *buf_; @@ -1785,9 +1796,11 @@ class Verifier FLATBUFFERS_FINAL_CLASS { uoffset_t max_depth_; uoffset_t num_tables_; uoffset_t max_tables_; -#ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE - mutable const uint8_t *upper_bound_; -#endif + // clang-format off + #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE + mutable const uint8_t *upper_bound_; + #endif + // clang-format on }; // Convenient way to bundle a buffer and its length, to pass it around @@ -1797,9 +1810,11 @@ struct BufferRefBase {}; // for std::is_base_of template struct BufferRef : BufferRefBase { BufferRef() : buf(nullptr), len(0), must_free(false) {} BufferRef(uint8_t *_buf, uoffset_t _len) - : buf(_buf), len(_len), must_free(false) {} + : buf(_buf), len(_len), must_free(false) {} - ~BufferRef() { if (must_free) free(buf); } + ~BufferRef() { + if (must_free) free(buf); + } const T *GetRoot() const { return flatbuffers::GetRoot(buf); } @@ -1862,9 +1877,8 @@ class Table { template P GetPointer(voffset_t field) { auto field_offset = GetOptionalFieldOffset(field); auto p = data_ + field_offset; - return field_offset - ? reinterpret_cast

(p + ReadScalar(p)) - : nullptr; + return field_offset ? reinterpret_cast

(p + ReadScalar(p)) + : nullptr; } template P GetPointer(voffset_t field) const { return const_cast(this)->GetPointer

(field); @@ -1910,15 +1924,14 @@ class Table { if (!verifier.Verify(data_)) return false; auto vtable = GetVTable(); // Check the vtable size field, then check vtable fits in its entirety. - return verifier.VerifyComplexity() && - verifier.Verify(vtable) && + return verifier.VerifyComplexity() && verifier.Verify(vtable) && (ReadScalar(vtable) & (sizeof(voffset_t) - 1)) == 0 && verifier.Verify(vtable, ReadScalar(vtable)); } // Verify a particular field. - template bool VerifyField(const Verifier &verifier, - voffset_t field) const { + template + bool VerifyField(const Verifier &verifier, voffset_t field) const { // Calling GetOptionalFieldOffset should be safe now thanks to // VerifyTable(). auto field_offset = GetOptionalFieldOffset(field); @@ -1927,8 +1940,8 @@ class Table { } // VerifyField for required fields. - template bool VerifyFieldRequired(const Verifier &verifier, - voffset_t field) const { + template + bool VerifyFieldRequired(const Verifier &verifier, voffset_t field) const { auto field_offset = GetOptionalFieldOffset(field); return verifier.Check(field_offset != 0) && verifier.Verify(data_ + field_offset); @@ -1965,8 +1978,8 @@ inline const uint8_t *GetBufferStartFromRootPointer(const void *root) { // Either the vtable is before the root or after the root. auto start = (std::min)(vtable, reinterpret_cast(root)); // Align to at least sizeof(uoffset_t). - start = reinterpret_cast( - reinterpret_cast(start) & ~(sizeof(uoffset_t) - 1)); + start = reinterpret_cast(reinterpret_cast(start) & + ~(sizeof(uoffset_t) - 1)); // Additionally, there may be a file_identifier in the buffer, and the root // offset. The buffer may have been aligned to any size between // sizeof(uoffset_t) and FLATBUFFERS_MAX_ALIGNMENT (see "force_align"). @@ -1979,11 +1992,11 @@ inline const uint8_t *GetBufferStartFromRootPointer(const void *root) { static_assert(FlatBufferBuilder::kFileIdentifierLength == sizeof(uoffset_t), "file_identifier is assumed to be the same size as uoffset_t"); for (auto possible_roots = FLATBUFFERS_MAX_ALIGNMENT / sizeof(uoffset_t) + 1; - possible_roots; - possible_roots--) { - start -= sizeof(uoffset_t); - if (ReadScalar(start) + start == - reinterpret_cast(root)) return start; + possible_roots; possible_roots--) { + start -= sizeof(uoffset_t); + if (ReadScalar(start) + start == + reinterpret_cast(root)) + return start; } // We didn't find the root, either the "root" passed isn't really a root, // or the buffer is corrupt. @@ -1996,8 +2009,7 @@ inline const uint8_t *GetBufferStartFromRootPointer(const void *root) { // Base class for native objects (FlatBuffer data de-serialized into native // C++ data structures). // Contains no functionality, purely documentative. -struct NativeTable { -}; +struct NativeTable {}; /// @brief Function types to be used with resolving hashes into objects and /// back again. The resolver gets a pointer to a field inside an object API @@ -2008,6 +2020,7 @@ struct NativeTable { /// if you wish. The resolver does the opposite lookup, for when the object /// is being serialized again. typedef uint64_t hash_value_t; +// clang-format off #ifdef FLATBUFFERS_CPP98_STL typedef void (*resolver_function_t)(void **pointer_adr, hash_value_t hash); typedef hash_value_t (*rehasher_function_t)(void *pointer); @@ -2016,6 +2029,7 @@ typedef uint64_t hash_value_t; resolver_function_t; typedef std::function rehasher_function_t; #endif +// clang-format on // Helper function to test if a field is present, using any of the field // enums in the generated code. @@ -2034,8 +2048,7 @@ template bool IsFieldPresent(const T *table, voffset_t field) { // names must be NULL terminated. inline int LookupEnum(const char **names, const char *name) { for (const char **p = names; *p; p++) - if (!strcmp(*p, name)) - return static_cast(p - names); + if (!strcmp(*p, name)) return static_cast(p - names); return -1; } @@ -2049,6 +2062,7 @@ inline int LookupEnum(const char **names, const char *name) { // by the force_align attribute. // These are used in the generated code only. +// clang-format off #if defined(_MSC_VER) #define MANUALLY_ALIGNED_STRUCT(alignment) \ __pragma(pack(1)); \ @@ -2066,6 +2080,7 @@ inline int LookupEnum(const char **names, const char *name) { #else #error Unknown compiler, please define structure alignment macros #endif +// clang-format on // Minimal reflection via code generation. // Besides full-fat reflection (see reflection.h) and parsing/printing by @@ -2080,6 +2095,7 @@ inline int LookupEnum(const char **names, const char *name) { enum SequenceType { ST_TABLE, ST_STRUCT, ST_UNION, ST_ENUM }; // Scalars have the same order as in idl.h +// clang-format off #define FLATBUFFERS_GEN_ELEMENTARY_TYPES(ET) \ ET(ET_UTYPE) \ ET(ET_BOOL) \ @@ -2110,12 +2126,13 @@ inline const char **ElementaryTypeNames() { }; return names; } +// clang-format on // Basic type info cost just 16bits per field! struct TypeCode { - uint16_t base_type : 4; // ElementaryType + uint16_t base_type : 4; // ElementaryType uint16_t is_vector : 1; - int16_t sequence_ref : 11; // Index into type_refs below, or -1 for none. + int16_t sequence_ref : 11; // Index into type_refs below, or -1 for none. }; static_assert(sizeof(TypeCode) == 2, "TypeCode"); @@ -2131,7 +2148,7 @@ struct TypeTable { const TypeCode *type_codes; const TypeFunction *type_refs; const int32_t *values; // Only set for non-consecutive enum/union or structs. - const char **names; // Only set if compiled with --reflect-names. + const char **names; // Only set if compiled with --reflect-names. }; // String which identifies the current version of FlatBuffers. @@ -2144,6 +2161,7 @@ struct TypeTable { // appreciate if you left it in. // Weak linkage is culled by VS & doesn't work on cygwin. +// clang-format off #if !defined(_WIN32) && !defined(__CYGWIN__) extern volatile __attribute__((weak)) const char *flatbuffer_version_string; @@ -2188,7 +2206,8 @@ volatile __attribute__((weak)) const char *flatbuffer_version_string = } // namespace flatbuffers #if defined(_MSC_VER) -#pragma warning(pop) + #pragma warning(pop) #endif +// clang-format on #endif // FLATBUFFERS_H_ diff --git a/include/flatbuffers/flatc.h b/include/flatbuffers/flatc.h index 00d1a61a0..c7b60febc 100644 --- a/include/flatbuffers/flatc.h +++ b/include/flatbuffers/flatc.h @@ -14,15 +14,15 @@ * limitations under the License. */ -#include "flatbuffers/flatbuffers.h" -#include "flatbuffers/idl.h" -#include "flatbuffers/util.h" #include #include #include +#include "flatbuffers/flatbuffers.h" +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" #ifndef FLATC_H_ -#define FLATC_H_ +# define FLATC_H_ namespace flatbuffers { @@ -49,12 +49,10 @@ class FlatCompiler { MakeRuleFn make_rule; }; - typedef void (*WarnFn)(const FlatCompiler *flatc, - const std::string &warn, + typedef void (*WarnFn)(const FlatCompiler *flatc, const std::string &warn, bool show_exe_name); - typedef void (*ErrorFn)(const FlatCompiler *flatc, - const std::string &err, + typedef void (*ErrorFn)(const FlatCompiler *flatc, const std::string &err, bool usage, bool show_exe_name); // Parameters required to initialize the FlatCompiler. @@ -65,21 +63,20 @@ class FlatCompiler { warn_fn(nullptr), error_fn(nullptr) {} - const Generator* generators; + const Generator *generators; size_t num_generators; WarnFn warn_fn; ErrorFn error_fn; }; - explicit FlatCompiler(const InitParams& params) : params_(params) {} + explicit FlatCompiler(const InitParams ¶ms) : params_(params) {} - int Compile(int argc, const char** argv); + int Compile(int argc, const char **argv); - std::string GetUsageString(const char* program_name) const; + std::string GetUsageString(const char *program_name) const; private: - void ParseFile(flatbuffers::Parser &parser, - const std::string &filename, + void ParseFile(flatbuffers::Parser &parser, const std::string &filename, const std::string &contents, std::vector &include_directories) const; @@ -91,7 +88,6 @@ class FlatCompiler { InitParams params_; }; - } // namespace flatbuffers #endif // FLATC_H_ diff --git a/include/flatbuffers/flexbuffers.h b/include/flatbuffers/flexbuffers.h index 3050c2ff3..a25213fdd 100644 --- a/include/flatbuffers/flexbuffers.h +++ b/include/flatbuffers/flexbuffers.h @@ -24,12 +24,12 @@ #include "flatbuffers/util.h" #ifdef _MSC_VER -#include +# include #endif #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable: 4127) // C4127: conditional expression is constant +# pragma warning(push) +# pragma warning(disable : 4127) // C4127: conditional expression is constant #endif namespace flexbuffers { @@ -60,24 +60,25 @@ enum Type { TYPE_INDIRECT_UINT = 7, TYPE_INDIRECT_FLOAT = 8, TYPE_MAP = 9, - TYPE_VECTOR = 10, // Untyped. - TYPE_VECTOR_INT = 11, // Typed any size (stores no type table). + TYPE_VECTOR = 10, // Untyped. + TYPE_VECTOR_INT = 11, // Typed any size (stores no type table). TYPE_VECTOR_UINT = 12, TYPE_VECTOR_FLOAT = 13, TYPE_VECTOR_KEY = 14, TYPE_VECTOR_STRING = 15, - TYPE_VECTOR_INT2 = 16, // Typed tuple (no type table, no size field). + TYPE_VECTOR_INT2 = 16, // Typed tuple (no type table, no size field). TYPE_VECTOR_UINT2 = 17, TYPE_VECTOR_FLOAT2 = 18, - TYPE_VECTOR_INT3 = 19, // Typed triple (no type table, no size field). + TYPE_VECTOR_INT3 = 19, // Typed triple (no type table, no size field). TYPE_VECTOR_UINT3 = 20, TYPE_VECTOR_FLOAT3 = 21, - TYPE_VECTOR_INT4 = 22, // Typed quad (no type table, no size field). + TYPE_VECTOR_INT4 = 22, // Typed quad (no type table, no size field). TYPE_VECTOR_UINT4 = 23, TYPE_VECTOR_FLOAT4 = 24, TYPE_BLOB = 25, TYPE_BOOL = 26, - TYPE_VECTOR_BOOL = 36, // To Allow the same type of conversion of type to vector type + TYPE_VECTOR_BOOL = + 36, // To Allow the same type of conversion of type to vector type }; inline bool IsInline(Type t) { return t <= TYPE_FLOAT || t == TYPE_BOOL; } @@ -87,7 +88,8 @@ inline bool IsTypedVectorElementType(Type t) { } inline bool IsTypedVector(Type t) { - return (t >= TYPE_VECTOR_INT && t <= TYPE_VECTOR_STRING) || t == TYPE_VECTOR_BOOL; + return (t >= TYPE_VECTOR_INT && t <= TYPE_VECTOR_STRING) || + t == TYPE_VECTOR_BOOL; } inline bool IsFixedTypedVector(Type t) { @@ -113,7 +115,8 @@ inline Type ToTypedVectorElementType(Type t) { inline Type ToFixedTypedVectorElementType(Type t, uint8_t *len) { assert(IsFixedTypedVector(t)); auto fixed_type = t - TYPE_VECTOR_INT2; - *len = static_cast(fixed_type / 3 + 2); // 3 types each, starting from length 2. + *len = static_cast(fixed_type / 3 + + 2); // 3 types each, starting from length 2. return static_cast(fixed_type % 3 + TYPE_INT); } @@ -127,19 +130,20 @@ typedef int8_t quarter; // decently quick, but it is the most frequently executed function. // We could do an (unaligned) 64-bit read if we ifdef out the platforms for // which that doesn't work (or where we'd read into un-owned memory). -template +template R ReadSizedScalar(const uint8_t *data, uint8_t byte_width) { return byte_width < 4 - ? (byte_width < 2 ? static_cast(flatbuffers::ReadScalar(data)) - : static_cast(flatbuffers::ReadScalar(data))) - : (byte_width < 8 ? static_cast(flatbuffers::ReadScalar(data)) - : static_cast(flatbuffers::ReadScalar(data))); + ? (byte_width < 2 + ? static_cast(flatbuffers::ReadScalar(data)) + : static_cast(flatbuffers::ReadScalar(data))) + : (byte_width < 8 + ? static_cast(flatbuffers::ReadScalar(data)) + : static_cast(flatbuffers::ReadScalar(data))); } - inline int64_t ReadInt64(const uint8_t *data, uint8_t byte_width) { - return ReadSizedScalar(data, - byte_width); + return ReadSizedScalar( + data, byte_width); } inline uint64_t ReadUInt64(const uint8_t *data, uint8_t byte_width) { @@ -148,6 +152,7 @@ inline uint64_t ReadUInt64(const uint8_t *data, uint8_t byte_width) { // TODO: GCC apparently replaces memcpy by a rep movsb, but only if count is a // constant, which here it isn't. Test if memcpy is still faster than // the conditionals in ReadSizedScalar. Can also use inline asm. + // clang-format off #ifdef _MSC_VER uint64_t u = 0; __movsb(reinterpret_cast(&u), @@ -157,11 +162,12 @@ inline uint64_t ReadUInt64(const uint8_t *data, uint8_t byte_width) { return ReadSizedScalar( data, byte_width); #endif + // clang-format on } inline double ReadDouble(const uint8_t *data, uint8_t byte_width) { return ReadSizedScalar(data, - byte_width); + byte_width); } inline const uint8_t *Indirect(const uint8_t *offset, uint8_t byte_width) { @@ -173,13 +179,14 @@ template const uint8_t *Indirect(const uint8_t *offset) { } inline BitWidth WidthU(uint64_t u) { - #define FLATBUFFERS_GET_FIELD_BIT_WIDTH(value, width) { \ +#define FLATBUFFERS_GET_FIELD_BIT_WIDTH(value, width) \ + { \ if (!((u) & ~((1ULL << (width)) - 1ULL))) return BIT_WIDTH_##width; \ } FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 8); FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 16); FLATBUFFERS_GET_FIELD_BIT_WIDTH(u, 32); - #undef FLATBUFFERS_GET_FIELD_BIT_WIDTH +#undef FLATBUFFERS_GET_FIELD_BIT_WIDTH return BIT_WIDTH_64; } @@ -198,7 +205,7 @@ inline BitWidth WidthF(double f) { class Object { public: Object(const uint8_t *data, uint8_t byte_width) - : data_(data), byte_width_(byte_width) {} + : data_(data), byte_width_(byte_width) {} protected: const uint8_t *data_; @@ -216,15 +223,14 @@ class Sized : public Object { class String : public Sized { public: - String(const uint8_t *data, uint8_t byte_width) - : Sized(data, byte_width) {} + String(const uint8_t *data, uint8_t byte_width) : Sized(data, byte_width) {} size_t length() const { return size(); } const char *c_str() const { return reinterpret_cast(data_); } std::string str() const { return std::string(c_str(), length()); } static String EmptyString() { - static const uint8_t empty_string[] = { 0/*len*/, 0/*terminator*/ }; + static const uint8_t empty_string[] = { 0 /*len*/, 0 /*terminator*/ }; return String(empty_string + 1, 1); } bool IsTheEmptyString() const { return data_ == EmptyString().data_; } @@ -233,10 +239,10 @@ class String : public Sized { class Blob : public Sized { public: Blob(const uint8_t *data_buf, uint8_t byte_width) - : Sized(data_buf, byte_width) {} + : Sized(data_buf, byte_width) {} static Blob EmptyBlob() { - static const uint8_t empty_blob[] = { 0/*len*/ }; + static const uint8_t empty_blob[] = { 0 /*len*/ }; return Blob(empty_blob + 1, 1); } bool IsTheEmptyBlob() const { return data_ == EmptyBlob().data_; } @@ -245,13 +251,12 @@ class Blob : public Sized { class Vector : public Sized { public: - Vector(const uint8_t *data, uint8_t byte_width) - : Sized(data, byte_width) {} + Vector(const uint8_t *data, uint8_t byte_width) : Sized(data, byte_width) {} Reference operator[](size_t i) const; static Vector EmptyVector() { - static const uint8_t empty_vector[] = { 0/*len*/ }; + static const uint8_t empty_vector[] = { 0 /*len*/ }; return Vector(empty_vector + 1, 1); } bool IsTheEmptyVector() const { return data_ == EmptyVector().data_; } @@ -260,12 +265,12 @@ class Vector : public Sized { class TypedVector : public Sized { public: TypedVector(const uint8_t *data, uint8_t byte_width, Type element_type) - : Sized(data, byte_width), type_(element_type) {} + : Sized(data, byte_width), type_(element_type) {} Reference operator[](size_t i) const; static TypedVector EmptyTypedVector() { - static const uint8_t empty_typed_vector[] = { 0/*len*/ }; + static const uint8_t empty_typed_vector[] = { 0 /*len*/ }; return TypedVector(empty_typed_vector + 1, 1, TYPE_INT); } bool IsTheEmptyVector() const { @@ -284,12 +289,12 @@ class FixedTypedVector : public Object { public: FixedTypedVector(const uint8_t *data, uint8_t byte_width, Type element_type, uint8_t len) - : Object(data, byte_width), type_(element_type), len_(len) {} + : Object(data, byte_width), type_(element_type), len_(len) {} Reference operator[](size_t i) const; static FixedTypedVector EmptyFixedTypedVector() { - static const uint8_t fixed_empty_vector[] = { 0/* unused */ }; + static const uint8_t fixed_empty_vector[] = { 0 /* unused */ }; return FixedTypedVector(fixed_empty_vector, 1, TYPE_INT, 0); } bool IsTheEmptyFixedTypedVector() const { @@ -306,8 +311,7 @@ class FixedTypedVector : public Object { class Map : public Vector { public: - Map(const uint8_t *data, uint8_t byte_width) - : Vector(data, byte_width) {} + Map(const uint8_t *data, uint8_t byte_width) : Vector(data, byte_width) {} Reference operator[](const char *key) const; Reference operator[](const std::string &key) const; @@ -319,31 +323,31 @@ class Map : public Vector { auto keys_offset = data_ - byte_width_ * num_prefixed_fields; return TypedVector(Indirect(keys_offset, byte_width_), static_cast( - ReadUInt64(keys_offset + byte_width_, byte_width_)), + ReadUInt64(keys_offset + byte_width_, byte_width_)), TYPE_KEY); } static Map EmptyMap() { static const uint8_t empty_map[] = { - 0/*keys_len*/, 0/*keys_offset*/, 1/*keys_width*/, 0/*len*/ + 0 /*keys_len*/, 0 /*keys_offset*/, 1 /*keys_width*/, 0 /*len*/ }; return Map(empty_map + 4, 1); } - bool IsTheEmptyMap() const { - return data_ == EmptyMap().data_; - } + bool IsTheEmptyMap() const { return data_ == EmptyMap().data_; } }; class Reference { public: Reference(const uint8_t *data, uint8_t parent_width, uint8_t byte_width, Type type) - : data_(data), parent_width_(parent_width), byte_width_(byte_width), - type_(type) {} + : data_(data), + parent_width_(parent_width), + byte_width_(byte_width), + type_(type) {} Reference(const uint8_t *data, uint8_t parent_width, uint8_t packed_type) - : data_(data), parent_width_(parent_width) { + : data_(data), parent_width_(parent_width) { byte_width_ = 1U << static_cast(packed_type & 3); type_ = static_cast(packed_type >> 2); } @@ -352,13 +356,14 @@ class Reference { bool IsNull() const { return type_ == TYPE_NULL; } bool IsBool() const { return type_ == TYPE_BOOL; } - bool IsInt() const { return type_ == TYPE_INT || - type_ == TYPE_INDIRECT_INT; } - bool IsUInt() const { return type_ == TYPE_UINT|| - type_ == TYPE_INDIRECT_UINT;; } + bool IsInt() const { return type_ == TYPE_INT || type_ == TYPE_INDIRECT_INT; } + bool IsUInt() const { + return type_ == TYPE_UINT || type_ == TYPE_INDIRECT_UINT; + } bool IsIntOrUint() const { return IsInt() || IsUInt(); } - bool IsFloat() const { return type_ == TYPE_FLOAT || - type_ == TYPE_INDIRECT_FLOAT; } + bool IsFloat() const { + return type_ == TYPE_FLOAT || type_ == TYPE_INDIRECT_FLOAT; + } bool IsNumeric() const { return IsIntOrUint() || IsFloat(); } bool IsString() const { return type_ == TYPE_STRING; } bool IsKey() const { return type_ == TYPE_KEY; } @@ -367,7 +372,8 @@ class Reference { bool IsBlob() const { return type_ == TYPE_BLOB; } bool AsBool() const { - return (type_ == TYPE_BOOL ? ReadUInt64(data_, parent_width_) : AsUInt64()) != 0; + return (type_ == TYPE_BOOL ? ReadUInt64(data_, parent_width_) + : AsUInt64()) != 0; } // Reads any type as a int64_t. Never fails, does most sensible conversion. @@ -377,79 +383,82 @@ class Reference { if (type_ == TYPE_INT) { // A fast path for the common case. return ReadInt64(data_, parent_width_); - } else switch (type_) { - case TYPE_INDIRECT_INT: return ReadInt64(Indirect(), byte_width_); - case TYPE_UINT: return ReadUInt64(data_, parent_width_); - case TYPE_INDIRECT_UINT: return ReadUInt64(Indirect(), byte_width_); - case TYPE_FLOAT: return static_cast( - ReadDouble(data_, parent_width_)); - case TYPE_INDIRECT_FLOAT: return static_cast( - ReadDouble(Indirect(), byte_width_)); - case TYPE_NULL: return 0; - case TYPE_STRING: return flatbuffers::StringToInt(AsString().c_str()); - case TYPE_VECTOR: return static_cast(AsVector().size()); - case TYPE_BOOL: return ReadInt64(data_, parent_width_); - default: - // Convert other things to int. - return 0; - } + } else + switch (type_) { + case TYPE_INDIRECT_INT: return ReadInt64(Indirect(), byte_width_); + case TYPE_UINT: return ReadUInt64(data_, parent_width_); + case TYPE_INDIRECT_UINT: return ReadUInt64(Indirect(), byte_width_); + case TYPE_FLOAT: + return static_cast(ReadDouble(data_, parent_width_)); + case TYPE_INDIRECT_FLOAT: + return static_cast(ReadDouble(Indirect(), byte_width_)); + case TYPE_NULL: return 0; + case TYPE_STRING: return flatbuffers::StringToInt(AsString().c_str()); + case TYPE_VECTOR: return static_cast(AsVector().size()); + case TYPE_BOOL: return ReadInt64(data_, parent_width_); + default: + // Convert other things to int. + return 0; + } } // TODO: could specialize these to not use AsInt64() if that saves // extension ops in generated code, and use a faster op than ReadInt64. int32_t AsInt32() const { return static_cast(AsInt64()); } int16_t AsInt16() const { return static_cast(AsInt64()); } - int8_t AsInt8() const { return static_cast (AsInt64()); } + int8_t AsInt8() const { return static_cast(AsInt64()); } uint64_t AsUInt64() const { if (type_ == TYPE_UINT) { // A fast path for the common case. return ReadUInt64(data_, parent_width_); - } else switch (type_) { - case TYPE_INDIRECT_UINT: return ReadUInt64(Indirect(), byte_width_); - case TYPE_INT: return ReadInt64(data_, parent_width_); - case TYPE_INDIRECT_INT: return ReadInt64(Indirect(), byte_width_); - case TYPE_FLOAT: return static_cast( - ReadDouble(data_, parent_width_)); - case TYPE_INDIRECT_FLOAT: return static_cast( - ReadDouble(Indirect(), byte_width_)); - case TYPE_NULL: return 0; - case TYPE_STRING: return flatbuffers::StringToUInt(AsString().c_str()); - case TYPE_VECTOR: return static_cast(AsVector().size()); - case TYPE_BOOL: return ReadUInt64(data_, parent_width_); - default: - // Convert other things to uint. - return 0; - } + } else + switch (type_) { + case TYPE_INDIRECT_UINT: return ReadUInt64(Indirect(), byte_width_); + case TYPE_INT: return ReadInt64(data_, parent_width_); + case TYPE_INDIRECT_INT: return ReadInt64(Indirect(), byte_width_); + case TYPE_FLOAT: + return static_cast(ReadDouble(data_, parent_width_)); + case TYPE_INDIRECT_FLOAT: + return static_cast(ReadDouble(Indirect(), byte_width_)); + case TYPE_NULL: return 0; + case TYPE_STRING: return flatbuffers::StringToUInt(AsString().c_str()); + case TYPE_VECTOR: return static_cast(AsVector().size()); + case TYPE_BOOL: return ReadUInt64(data_, parent_width_); + default: + // Convert other things to uint. + return 0; + } } uint32_t AsUInt32() const { return static_cast(AsUInt64()); } uint16_t AsUInt16() const { return static_cast(AsUInt64()); } - uint8_t AsUInt8() const { return static_cast (AsUInt64()); } + uint8_t AsUInt8() const { return static_cast(AsUInt64()); } double AsDouble() const { if (type_ == TYPE_FLOAT) { // A fast path for the common case. return ReadDouble(data_, parent_width_); - } else switch (type_) { - case TYPE_INDIRECT_FLOAT: return ReadDouble(Indirect(), byte_width_); - case TYPE_INT: return static_cast( - ReadInt64(data_, parent_width_)); - case TYPE_UINT: return static_cast( - ReadUInt64(data_, parent_width_)); - case TYPE_INDIRECT_INT: return static_cast( - ReadInt64(Indirect(), byte_width_)); - case TYPE_INDIRECT_UINT: return static_cast( - ReadUInt64(Indirect(), byte_width_)); - case TYPE_NULL: return 0.0; - case TYPE_STRING: return strtod(AsString().c_str(), nullptr); - case TYPE_VECTOR: return static_cast(AsVector().size()); - case TYPE_BOOL: return static_cast( - ReadUInt64(data_, parent_width_)); - default: - // Convert strings and other things to float. - return 0; - } + } else + switch (type_) { + case TYPE_INDIRECT_FLOAT: return ReadDouble(Indirect(), byte_width_); + case TYPE_INT: + return static_cast(ReadInt64(data_, parent_width_)); + case TYPE_UINT: + return static_cast(ReadUInt64(data_, parent_width_)); + case TYPE_INDIRECT_INT: + return static_cast(ReadInt64(Indirect(), byte_width_)); + case TYPE_INDIRECT_UINT: + return static_cast(ReadUInt64(Indirect(), byte_width_)); + case TYPE_NULL: return 0.0; + case TYPE_STRING: return strtod(AsString().c_str(), nullptr); + case TYPE_VECTOR: return static_cast(AsVector().size()); + case TYPE_BOOL: + return static_cast(ReadUInt64(data_, parent_width_)); + default: + // Convert strings and other things to float. + return 0; + } } float AsFloat() const { return static_cast(AsDouble()); } @@ -652,9 +661,7 @@ class Reference { memcpy(const_cast(s.c_str()), str, len); return true; } - bool MutateString(const char *str) { - return MutateString(str, strlen(str)); - } + bool MutateString(const char *str) { return MutateString(str, strlen(str)); } bool MutateString(const std::string &str) { return MutateString(str.data(), str.length()); } @@ -664,9 +671,11 @@ class Reference { return flexbuffers::Indirect(data_, parent_width_); } - template bool Mutate(const uint8_t *dest, T t, size_t byte_width, - BitWidth value_width) { - auto fits = static_cast(static_cast(1U) << value_width) <= byte_width; + template + bool Mutate(const uint8_t *dest, T t, size_t byte_width, + BitWidth value_width) { + auto fits = static_cast(static_cast(1U) << value_width) <= + byte_width; if (fits) { t = flatbuffers::EndianScalar(t); memcpy(const_cast(dest), &t, byte_width); @@ -674,8 +683,9 @@ class Reference { return fits; } - template bool MutateF(const uint8_t *dest, T t, size_t byte_width, - BitWidth value_width) { + template + bool MutateF(const uint8_t *dest, T t, size_t byte_width, + BitWidth value_width) { if (byte_width == sizeof(double)) return Mutate(dest, static_cast(t), byte_width, value_width); if (byte_width == sizeof(float)) @@ -707,21 +717,25 @@ template<> inline double Reference::As() { return AsDouble(); } template<> inline float Reference::As() { return AsFloat(); } template<> inline String Reference::As() { return AsString(); } -template<> inline std::string Reference::As() { return AsString().str(); } +template<> inline std::string Reference::As() { + return AsString().str(); +} template<> inline Blob Reference::As() { return AsBlob(); } template<> inline Vector Reference::As() { return AsVector(); } -template<> inline TypedVector Reference::As() { return AsTypedVector(); } -template<> inline FixedTypedVector Reference::As() { return AsFixedTypedVector(); } +template<> inline TypedVector Reference::As() { + return AsTypedVector(); +} +template<> inline FixedTypedVector Reference::As() { + return AsFixedTypedVector(); +} template<> inline Map Reference::As() { return AsMap(); } inline uint8_t PackedType(BitWidth bit_width, Type type) { return static_cast(bit_width | (type << 2)); } -inline uint8_t NullPackedType() { - return PackedType(BIT_WIDTH_8, TYPE_NULL); -} +inline uint8_t NullPackedType() { return PackedType(BIT_WIDTH_8, TYPE_NULL); } // Vector accessors. // Note: if you try to access outside of bounds, you get a Null value back @@ -730,7 +744,7 @@ inline uint8_t NullPackedType() { // wanted 3d). // The Null converts seamlessly into a default value for any other type. // TODO(wvo): Could introduce an #ifdef that makes this into an assert? -inline Reference Vector::operator[](size_t i) const { +inline Reference Vector::operator[](size_t i) const { auto len = size(); if (i >= len) return Reference(nullptr, 1, NullPackedType()); auto packed_type = (data_ + len * byte_width_)[i]; @@ -738,14 +752,14 @@ inline Reference Vector::operator[](size_t i) const { return Reference(elem, byte_width_, packed_type); } -inline Reference TypedVector::operator[](size_t i) const { +inline Reference TypedVector::operator[](size_t i) const { auto len = size(); if (i >= len) return Reference(nullptr, 1, NullPackedType()); auto elem = data_ + i * byte_width_; return Reference(elem, byte_width_, 1, type_); } -inline Reference FixedTypedVector::operator[](size_t i) const { +inline Reference FixedTypedVector::operator[](size_t i) const { if (i >= len_) return Reference(nullptr, 1, NullPackedType()); auto elem = data_ + i * byte_width_; return Reference(elem, byte_width_, 1, type_); @@ -753,7 +767,7 @@ inline Reference FixedTypedVector::operator[](size_t i) const { template int KeyCompare(const void *key, const void *elem) { auto str_elem = reinterpret_cast( - Indirect(reinterpret_cast(elem))); + Indirect(reinterpret_cast(elem))); auto skey = reinterpret_cast(key); return strcmp(skey, str_elem); } @@ -770,8 +784,7 @@ inline Reference Map::operator[](const char *key) const { case 8: comp = KeyCompare; break; } auto res = std::bsearch(key, keys.data_, keys.size(), keys.byte_width_, comp); - if (!res) - return Reference(nullptr, 1, NullPackedType()); + if (!res) return Reference(nullptr, 1, NullPackedType()); auto i = (reinterpret_cast(res) - keys.data_) / keys.byte_width_; return (*static_cast(this))[i]; } @@ -817,8 +830,11 @@ class Builder FLATBUFFERS_FINAL_CLASS { public: Builder(size_t initial_size = 256, BuilderFlag flags = BUILDER_FLAG_SHARE_KEYS) - : buf_(initial_size), finished_(false), flags_(flags), - force_min_bit_width_(BIT_WIDTH_8), key_pool(KeyOffsetCompare(buf_)), + : buf_(initial_size), + finished_(false), + flags_(flags), + force_min_bit_width_(BIT_WIDTH_8), + key_pool(KeyOffsetCompare(buf_)), string_pool(StringOffsetCompare(buf_)) { buf_.clear(); } @@ -831,9 +847,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { } // Size of the buffer. Does not include unfinished values. - size_t GetSize() const { - return buf_.size(); - } + size_t GetSize() const { return buf_.size(); } // Reset all state so we can re-use the buffer. void Clear() { @@ -851,26 +865,42 @@ class Builder FLATBUFFERS_FINAL_CLASS { // vectors and elsewhere). void Null() { stack_.push_back(Value()); } - void Null(const char *key) { Key(key); Null(); } + void Null(const char *key) { + Key(key); + Null(); + } void Int(int64_t i) { stack_.push_back(Value(i, TYPE_INT, WidthI(i))); } - void Int(const char *key, int64_t i) { Key(key); Int(i); } + void Int(const char *key, int64_t i) { + Key(key); + Int(i); + } void UInt(uint64_t u) { stack_.push_back(Value(u, TYPE_UINT, WidthU(u))); } - void UInt(const char *key, uint64_t u) { Key(key); Int(u); } + void UInt(const char *key, uint64_t u) { + Key(key); + Int(u); + } void Float(float f) { stack_.push_back(Value(f)); } - void Float(const char *key, float f) { Key(key); Float(f); } + void Float(const char *key, float f) { + Key(key); + Float(f); + } void Double(double f) { stack_.push_back(Value(f)); } - void Double(const char *key, double d) { Key(key); Double(d); } + void Double(const char *key, double d) { + Key(key); + Double(d); + } void Bool(bool b) { stack_.push_back(Value(b)); } - void Bool(const char *key, bool b) { Key(key); Bool(b); } - - void IndirectInt(int64_t i) { - PushIndirect(i, TYPE_INDIRECT_INT, WidthI(i)); + void Bool(const char *key, bool b) { + Key(key); + Bool(b); } + + void IndirectInt(int64_t i) { PushIndirect(i, TYPE_INDIRECT_INT, WidthI(i)); } void IndirectInt(const char *key, int64_t i) { Key(key); IndirectInt(i); @@ -939,9 +969,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { } return sloc; } - size_t String(const char *str) { - return String(str, strlen(str)); - } + size_t String(const char *str) { return String(str, strlen(str)); } size_t String(const std::string &str) { return String(str.c_str(), str.size()); } @@ -974,9 +1002,15 @@ class Builder FLATBUFFERS_FINAL_CLASS { // Also some FlatBuffers types? size_t StartVector() { return stack_.size(); } - size_t StartVector(const char *key) { Key(key); return stack_.size(); } + size_t StartVector(const char *key) { + Key(key); + return stack_.size(); + } size_t StartMap() { return stack_.size(); } - size_t StartMap(const char *key) { Key(key); return stack_.size(); } + size_t StartMap(const char *key) { + Key(key); + return stack_.size(); + } // TODO(wvo): allow this to specify an aligment greater than the natural // alignment. @@ -1000,7 +1034,10 @@ class Builder FLATBUFFERS_FINAL_CLASS { } // Now sort values, so later we can do a binary seach lookup. // We want to sort 2 array elements at a time. - struct TwoValue { Value key; Value val; }; + struct TwoValue { + Value key; + Value val; + }; // TODO(wvo): strict aliasing? // TODO(wvo): allow the caller to indicate the data is already sorted // for maximum efficiency? With an assert to check sortedness to make sure @@ -1011,22 +1048,22 @@ class Builder FLATBUFFERS_FINAL_CLASS { // sorted fashion. // std::sort is typically already a lot faster on sorted data though. auto dict = - reinterpret_cast(flatbuffers::vector_data(stack_) + - start); + reinterpret_cast(flatbuffers::vector_data(stack_) + start); std::sort(dict, dict + len, [&](const TwoValue &a, const TwoValue &b) -> bool { - auto as = reinterpret_cast( - flatbuffers::vector_data(buf_) + a.key.u_); - auto bs = reinterpret_cast( - flatbuffers::vector_data(buf_) + b.key.u_); - auto comp = strcmp(as, bs); - // If this assertion hits, you've added two keys with the same value to - // this map. - // TODO: Have to check for pointer equality, as some sort implementation - // apparently call this function with the same element?? Why? - assert(comp || &a == &b); - return comp < 0; - }); + auto as = reinterpret_cast( + flatbuffers::vector_data(buf_) + a.key.u_); + auto bs = reinterpret_cast( + flatbuffers::vector_data(buf_) + b.key.u_); + auto comp = strcmp(as, bs); + // If this assertion hits, you've added two keys with the same + // value to this map. + // TODO: Have to check for pointer equality, as some sort + // implementation apparently call this function with the same + // element?? Why? + assert(comp || &a == &b); + return comp < 0; + }); // First create a vector out of all keys. // TODO(wvo): if kBuilderFlagShareKeyVectors is true, see if we can share // the first vector. @@ -1043,7 +1080,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { f(); return EndVector(start, false, false); } - template size_t Vector(F f, T &state) { + template size_t Vector(F f, T &state) { auto start = StartVector(); f(state); return EndVector(start, false, false); @@ -1053,8 +1090,8 @@ class Builder FLATBUFFERS_FINAL_CLASS { f(); return EndVector(start, false, false); } - template size_t Vector(const char *key, F f, - T &state) { + template + size_t Vector(const char *key, F f, T &state) { auto start = StartVector(key); f(state); return EndVector(start, false, false); @@ -1070,8 +1107,8 @@ class Builder FLATBUFFERS_FINAL_CLASS { EndVector(start, false, false); } } - template void Vector(const char *key, const T *elems, - size_t len) { + template + void Vector(const char *key, const T *elems, size_t len) { Key(key); Vector(elems, len); } @@ -1084,7 +1121,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { f(); return EndVector(start, true, false); } - template size_t TypedVector(F f, T &state) { + template size_t TypedVector(F f, T &state) { auto start = StartVector(); f(state); return EndVector(start, true, false); @@ -1094,8 +1131,8 @@ class Builder FLATBUFFERS_FINAL_CLASS { f(); return EndVector(start, true, false); } - template size_t TypedVector(const char *key, F f, - T &state) { + template + size_t TypedVector(const char *key, F f, T &state) { auto start = StartVector(key); f(state); return EndVector(start, true, false); @@ -1110,8 +1147,8 @@ class Builder FLATBUFFERS_FINAL_CLASS { return ScalarVector(elems, len, true); } - template size_t FixedTypedVector(const char *key, const T *elems, - size_t len) { + template + size_t FixedTypedVector(const char *key, const T *elems, size_t len) { Key(key); return FixedTypedVector(elems, len); } @@ -1121,7 +1158,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { f(); return EndMap(start); } - template size_t Map(F f, T &state) { + template size_t Map(F f, T &state) { auto start = StartMap(); f(state); return EndMap(start); @@ -1131,8 +1168,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { f(); return EndMap(start); } - template size_t Map(const char *key, F f, - T &state) { + template size_t Map(const char *key, F f, T &state) { auto start = StartMap(key); f(state); return EndMap(start); @@ -1160,9 +1196,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { void Add(const std::string &str) { String(str); } void Add(const flexbuffers::String &str) { String(str); } - template void Add(const std::vector &vec) { - Vector(vec); - } + template void Add(const std::vector &vec) { Vector(vec); } template void Add(const char *key, const T &t) { Key(key); @@ -1173,9 +1207,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { Map(map); } - template void operator+=(const T &t) { - Add(t); - } + template void operator+=(const T &t) { Add(t); } // This function is useful in combination with the Mutate* functions above. // It forces elements of vectors and maps to have a minimum size, such that @@ -1220,8 +1252,7 @@ class Builder FLATBUFFERS_FINAL_CLASS { } void WriteBytes(const void *val, size_t size) { - buf_.insert(buf_.end(), - reinterpret_cast(val), + buf_.insert(buf_.end(), reinterpret_cast(val), reinterpret_cast(val) + size); } @@ -1235,8 +1266,8 @@ class Builder FLATBUFFERS_FINAL_CLASS { switch (byte_width) { case 8: Write(f, byte_width); break; 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; + // case 2: Write(static_cast(f), byte_width); break; + // case 1: Write(static_cast(f), byte_width); break; default: assert(0); } } @@ -1267,9 +1298,11 @@ class Builder FLATBUFFERS_FINAL_CLASS { template static Type GetScalarType() { assert(flatbuffers::is_scalar::value); return flatbuffers::is_floating_point::value - ? TYPE_FLOAT - : flatbuffers::is_same::value ? TYPE_BOOL - : (flatbuffers::is_unsigned::value ? TYPE_UINT : TYPE_INT); + ? TYPE_FLOAT + : flatbuffers::is_same::value + ? TYPE_BOOL + : (flatbuffers::is_unsigned::value ? TYPE_UINT + : TYPE_INT); } struct Value { @@ -1286,19 +1319,20 @@ class Builder FLATBUFFERS_FINAL_CLASS { Value() : i_(0), type_(TYPE_NULL), min_bit_width_(BIT_WIDTH_8) {} - Value(bool b) : u_(static_cast(b)), type_(TYPE_BOOL), min_bit_width_(BIT_WIDTH_8) {} + Value(bool b) + : u_(static_cast(b)), + type_(TYPE_BOOL), + min_bit_width_(BIT_WIDTH_8) {} Value(int64_t i, Type t, BitWidth bw) - : i_(i), type_(t), min_bit_width_(bw) {} + : i_(i), type_(t), min_bit_width_(bw) {} Value(uint64_t u, Type t, BitWidth bw) - : u_(u), type_(t), min_bit_width_(bw) {} + : u_(u), type_(t), min_bit_width_(bw) {} - Value(float f) - : f_(f), type_(TYPE_FLOAT), min_bit_width_(BIT_WIDTH_32) {} - Value(double f) - : f_(f), type_(TYPE_FLOAT), min_bit_width_(WidthF(f)) {} + Value(float f) : f_(f), type_(TYPE_FLOAT), min_bit_width_(BIT_WIDTH_32) {} + Value(double f) : f_(f), type_(TYPE_FLOAT), min_bit_width_(WidthF(f)) {} - uint8_t StoredPackedType(BitWidth parent_bit_width_= BIT_WIDTH_8) const { + uint8_t StoredPackedType(BitWidth parent_bit_width_ = BIT_WIDTH_8) const { return PackedType(StoredWidth(parent_bit_width_), type_); } @@ -1315,15 +1349,15 @@ class Builder FLATBUFFERS_FINAL_CLASS { byte_width <= sizeof(flatbuffers::largest_scalar_t); byte_width *= 2) { // Where are we going to write this offset? - auto offset_loc = - buf_size + - flatbuffers::PaddingBytes(buf_size, byte_width) + - elem_index * byte_width; + auto offset_loc = buf_size + + flatbuffers::PaddingBytes(buf_size, byte_width) + + elem_index * byte_width; // Compute relative offset. auto offset = offset_loc - u_; // Does it fit? auto bit_width = WidthU(offset); - if (static_cast(static_cast(1U) << bit_width) == byte_width) + if (static_cast(static_cast(1U) << bit_width) == + byte_width) return bit_width; } assert(false); // Must match one of the sizes above. @@ -1333,9 +1367,9 @@ class Builder FLATBUFFERS_FINAL_CLASS { BitWidth StoredWidth(BitWidth parent_bit_width_ = BIT_WIDTH_8) const { if (IsInline(type_)) { - return (std::max)(min_bit_width_, parent_bit_width_); + return (std::max)(min_bit_width_, parent_bit_width_); } else { - return min_bit_width_; + return min_bit_width_; } } }; @@ -1343,19 +1377,11 @@ class Builder FLATBUFFERS_FINAL_CLASS { void WriteAny(const Value &val, uint8_t byte_width) { switch (val.type_) { case TYPE_NULL: - case TYPE_INT: - Write(val.i_, byte_width); - break; + case TYPE_INT: Write(val.i_, byte_width); break; case TYPE_BOOL: - case TYPE_UINT: - Write(val.u_, byte_width); - break; - case TYPE_FLOAT: - WriteDouble(val.f_, byte_width); - break; - default: - WriteOffset(val.u_, byte_width); - break; + case TYPE_UINT: Write(val.u_, byte_width); break; + case TYPE_FLOAT: WriteDouble(val.f_, byte_width); break; + default: WriteOffset(val.u_, byte_width); break; } } @@ -1369,8 +1395,8 @@ class Builder FLATBUFFERS_FINAL_CLASS { return sloc; } - template size_t ScalarVector(const T *elems, size_t len, - bool fixed) { + template + size_t ScalarVector(const T *elems, size_t len, bool fixed) { auto vector_type = GetScalarType(); auto byte_width = sizeof(T); auto bit_width = WidthB(byte_width); @@ -1436,12 +1462,11 @@ class Builder FLATBUFFERS_FINAL_CLASS { buf_.push_back(stack_[i].StoredPackedType(bit_width)); } } - return Value(static_cast(vloc), keys - ? TYPE_MAP - : (typed - ? ToTypedVector(vector_type, fixed ? vec_len : 0) - : TYPE_VECTOR), - bit_width); + return Value(static_cast(vloc), + keys ? TYPE_MAP + : (typed ? ToTypedVector(vector_type, fixed ? vec_len : 0) + : TYPE_VECTOR), + bit_width); } // You shouldn't really be copying instances of this class. @@ -1473,10 +1498,10 @@ class Builder FLATBUFFERS_FINAL_CLASS { struct StringOffsetCompare { StringOffsetCompare(const std::vector &buf) : buf_(&buf) {} bool operator()(const StringOffset &a, const StringOffset &b) const { - auto stra = reinterpret_cast(flatbuffers::vector_data(*buf_) + - a.first); - auto strb = reinterpret_cast(flatbuffers::vector_data(*buf_) + - b.first); + auto stra = reinterpret_cast( + flatbuffers::vector_data(*buf_) + a.first); + auto strb = reinterpret_cast( + flatbuffers::vector_data(*buf_) + b.first); return strncmp(stra, strb, (std::min)(a.second, b.second) + 1) < 0; } const std::vector *buf_; @@ -1491,8 +1516,8 @@ class Builder FLATBUFFERS_FINAL_CLASS { } // namespace flexbuffers -#if defined(_MSC_VER) -#pragma warning(pop) -#endif +# if defined(_MSC_VER) +# pragma warning(pop) +# endif #endif // FLATBUFFERS_FLEXBUFFERS_H_ diff --git a/include/flatbuffers/grpc.h b/include/flatbuffers/grpc.h index a5730f661..ac55efd59 100644 --- a/include/flatbuffers/grpc.h +++ b/include/flatbuffers/grpc.h @@ -30,13 +30,12 @@ namespace grpc { // `grpc_slice` and also provides flatbuffers-specific helpers such as `Verify` // and `GetRoot`. Since it is backed by a `grpc_slice`, the underlying buffer // is refcounted and ownership is be managed automatically. -template -class Message { +template class Message { public: Message() : slice_(grpc_empty_slice()) {} Message(grpc_slice slice, bool add_ref) - : slice_(add_ref ? grpc_slice_ref(slice) : slice) {} + : slice_(add_ref ? grpc_slice_ref(slice) : slice) {} Message &operator=(const Message &other) = delete; @@ -137,7 +136,7 @@ namespace detail { struct SliceAllocatorMember { SliceAllocator slice_allocator_; }; -} +} // namespace detail // MessageBuilder is a gRPC-specific FlatBufferBuilder that uses SliceAllocator // to allocate gRPC buffers. @@ -145,7 +144,7 @@ class MessageBuilder : private detail::SliceAllocatorMember, public FlatBufferBuilder { public: explicit MessageBuilder(uoffset_t initial_size = 1024) - : FlatBufferBuilder(initial_size, &slice_allocator_, false) {} + : FlatBufferBuilder(initial_size, &slice_allocator_, false) {} MessageBuilder(const MessageBuilder &other) = delete; MessageBuilder &operator=(const MessageBuilder &other) = delete; @@ -155,8 +154,7 @@ class MessageBuilder : private detail::SliceAllocatorMember, // GetMessage extracts the subslice of the buffer corresponding to the // flatbuffers-encoded region and wraps it in a `Message` to handle buffer // ownership. - template - Message GetMessage() { + template Message GetMessage() { auto buf_data = buf_.buf(); // pointer to memory auto buf_size = buf_.capacity(); // size of memory auto msg_data = buf_.data(); // pointer to msg @@ -178,8 +176,7 @@ class MessageBuilder : private detail::SliceAllocatorMember, return msg; } - template - Message ReleaseMessage() { + template Message ReleaseMessage() { Message msg = GetMessage(); Reset(); return msg; @@ -194,8 +191,7 @@ class MessageBuilder : private detail::SliceAllocatorMember, namespace grpc { -template -class SerializationTraits> { +template class SerializationTraits> { public: static grpc::Status Serialize(const flatbuffers::grpc::Message &msg, grpc_byte_buffer **buffer, bool *own_buffer) { @@ -237,19 +233,19 @@ class SerializationTraits> { *msg = flatbuffers::grpc::Message(slice, false); } grpc_byte_buffer_destroy(buffer); - #if FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION +#if FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION return ::grpc::Status::OK; - #else +#else if (msg->Verify()) { return ::grpc::Status::OK; } else { return ::grpc::Status(::grpc::StatusCode::INTERNAL, "Message verification failed"); } - #endif +#endif } }; -} // namespace grpc; +} // namespace grpc #endif // FLATBUFFERS_GRPC_H_ diff --git a/include/flatbuffers/hash.h b/include/flatbuffers/hash.h index 9ae37e5c0..855e92d9e 100644 --- a/include/flatbuffers/hash.h +++ b/include/flatbuffers/hash.h @@ -24,26 +24,22 @@ namespace flatbuffers { -template -struct FnvTraits { +template struct FnvTraits { static const T kFnvPrime; static const T kOffsetBasis; }; -template <> -struct FnvTraits { +template<> struct FnvTraits { static const uint32_t kFnvPrime = 0x01000193; static const uint32_t kOffsetBasis = 0x811C9DC5; }; -template <> -struct FnvTraits { +template<> struct FnvTraits { static const uint64_t kFnvPrime = 0x00000100000001b3ULL; static const uint64_t kOffsetBasis = 0xcbf29ce484222645ULL; }; -template -T HashFnv1(const char *input) { +template T HashFnv1(const char *input) { T hash = FnvTraits::kOffsetBasis; for (const char *c = input; *c; ++c) { hash *= FnvTraits::kFnvPrime; @@ -52,8 +48,7 @@ T HashFnv1(const char *input) { return hash; } -template -T HashFnv1a(const char *input) { +template T HashFnv1a(const char *input) { T hash = FnvTraits::kOffsetBasis; for (const char *c = input; *c; ++c) { hash ^= static_cast(*c); @@ -62,21 +57,20 @@ T HashFnv1a(const char *input) { return hash; } -template -struct NamedHashFunction { +template struct NamedHashFunction { const char *name; - typedef T (*HashFunction)(const char*); + typedef T (*HashFunction)(const char *); HashFunction function; }; const NamedHashFunction kHashFunctions32[] = { - { "fnv1_32", HashFnv1 }, + { "fnv1_32", HashFnv1 }, { "fnv1a_32", HashFnv1a }, }; const NamedHashFunction kHashFunctions64[] = { - { "fnv1_64", HashFnv1 }, + { "fnv1_64", HashFnv1 }, { "fnv1a_64", HashFnv1a }, }; diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index f145d0b22..b51ebf338 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -18,17 +18,17 @@ #define FLATBUFFERS_IDL_H_ #include -#include #include +#include #include "flatbuffers/base.h" #include "flatbuffers/flatbuffers.h" +#include "flatbuffers/flexbuffers.h" #include "flatbuffers/hash.h" #include "flatbuffers/reflection.h" -#include "flatbuffers/flexbuffers.h" #if !defined(FLATBUFFERS_CPP98_STL) - #include +# include #endif // !defined(FLATBUFFERS_CPP98_STL) // This file defines the data types representing a parsed IDL (Interface @@ -39,6 +39,7 @@ namespace flatbuffers { // The order of these matters for Is*() functions below. // Additionally, Parser::ParseType assumes bool..string is a contiguous range // of type tokens. +// clang-format off #define FLATBUFFERS_GEN_TYPES_SCALAR(TD) \ TD(NONE, "", uint8_t, byte, byte, byte, uint8) \ TD(UTYPE, "", uint8_t, byte, byte, byte, uint8) /* begin scalar/int */ \ @@ -110,13 +111,12 @@ inline bool IsFloat (BaseType t) { return t == BASE_TYPE_FLOAT || inline bool IsLong (BaseType t) { return t == BASE_TYPE_LONG || t == BASE_TYPE_ULONG; } inline bool IsBool (BaseType t) { return t == BASE_TYPE_BOOL; } +// clang-format on extern const char *const kTypeNames[]; extern const char kTypeSizes[]; -inline size_t SizeOf(BaseType t) { - return kTypeSizes[t]; -} +inline size_t SizeOf(BaseType t) { return kTypeSizes[t]; } struct StructDef; struct EnumDef; @@ -125,13 +125,12 @@ class Parser; // Represents any type in the IDL, which is a combination of the BaseType // and additional information for vectors/structs_. struct Type { - explicit Type(BaseType _base_type = BASE_TYPE_NONE, - StructDef *_sd = nullptr, EnumDef *_ed = nullptr) - : base_type(_base_type), - element(BASE_TYPE_NONE), - struct_def(_sd), - enum_def(_ed) - {} + explicit Type(BaseType _base_type = BASE_TYPE_NONE, StructDef *_sd = nullptr, + EnumDef *_ed = nullptr) + : base_type(_base_type), + element(BASE_TYPE_NONE), + struct_def(_sd), + enum_def(_ed) {} bool operator==(const Type &o) { return base_type == o.base_type && element == o.element && @@ -151,8 +150,9 @@ struct Type { // Represents a parsed scalar value, it's type, and field offset. struct Value { - Value() : constant("0"), offset(static_cast( - ~(static_cast(0U)))) {} + Value() + : constant("0"), + offset(static_cast(~(static_cast(0U)))) {} Type type; std::string constant; voffset_t offset; @@ -163,9 +163,7 @@ struct Value { template class SymbolTable { public: ~SymbolTable() { - for (auto it = vec.begin(); it != vec.end(); ++it) { - delete *it; - } + for (auto it = vec.begin(); it != vec.end(); ++it) { delete *it; } } bool Add(const std::string &name, T *e) { @@ -193,15 +191,14 @@ template class SymbolTable { } public: - std::map dict; // quick lookup - std::vector vec; // Used to iterate in order of insertion + std::map dict; // quick lookup + std::vector vec; // Used to iterate in order of insertion }; // A name space, as set in the schema. struct Namespace { Namespace() : from_table(0) {} - // Given a (potentally unqualified) name, return the "fully qualified" name // which has a full namespaced descriptor. // With max_components you can request less than the number of components @@ -215,13 +212,16 @@ struct Namespace { // Base class for all definition types (fields, structs_, enums_). struct Definition { - Definition() : generated(false), defined_namespace(nullptr), - serialized_location(0), index(-1), refcount(1) {} + Definition() + : generated(false), + defined_namespace(nullptr), + serialized_location(0), + index(-1), + refcount(1) {} - flatbuffers::Offset>> - SerializeAttributes(FlatBufferBuilder *builder, - const Parser &parser) const; + flatbuffers::Offset< + flatbuffers::Vector>> + SerializeAttributes(FlatBufferBuilder *builder, const Parser &parser) const; std::string name; std::string file; @@ -237,34 +237,38 @@ struct Definition { }; struct FieldDef : public Definition { - FieldDef() : deprecated(false), required(false), key(false), - native_inline(false), flexbuffer(false), nested_flatbuffer(NULL), - padding(0) {} + FieldDef() + : deprecated(false), + required(false), + key(false), + native_inline(false), + flexbuffer(false), + nested_flatbuffer(NULL), + padding(0) {} Offset Serialize(FlatBufferBuilder *builder, uint16_t id, const Parser &parser) const; Value value; - bool deprecated; // Field is allowed to be present in old data, but can't be. - // written in new data nor accessed in new code. - bool required; // Field must always be present. - bool key; // Field functions as a key for creating sorted vectors. + bool deprecated; // Field is allowed to be present in old data, but can't be. + // written in new data nor accessed in new code. + bool required; // Field must always be present. + bool key; // Field functions as a key for creating sorted vectors. bool native_inline; // Field will be defined inline (instead of as a pointer) // for native tables if field is a struct. - bool flexbuffer; // This field contains FlexBuffer data. - StructDef *nested_flatbuffer; // This field contains nested FlatBuffer data. - size_t padding; // Bytes to always pad after this field. + bool flexbuffer; // This field contains FlexBuffer data. + StructDef *nested_flatbuffer; // This field contains nested FlatBuffer data. + size_t padding; // Bytes to always pad after this field. }; struct StructDef : public Definition { StructDef() - : fixed(false), - predecl(true), - sortbysize(true), - has_key(false), - minalign(1), - bytesize(0) - {} + : fixed(false), + predecl(true), + sortbysize(true), + has_key(false), + minalign(1), + bytesize(0) {} void PadLastField(size_t min_align) { auto padding = PaddingBytes(bytesize, min_align); @@ -300,8 +304,7 @@ inline size_t InlineAlignment(const Type &type) { } struct EnumVal { - EnumVal(const std::string &_name, int64_t _val) - : name(_name), value(_val) {} + EnumVal(const std::string &_name, int64_t _val) : name(_name), value(_val) {} Offset Serialize(FlatBufferBuilder *builder) const; @@ -315,12 +318,10 @@ struct EnumDef : public Definition { EnumDef() : is_union(false), uses_type_aliases(false) {} EnumVal *ReverseLookup(int enum_idx, bool skip_union_default = true) { - for (auto it = vals.vec.begin() + static_cast(is_union && - skip_union_default); - it != vals.vec.end(); ++it) { - if ((*it)->value == enum_idx) { - return *it; - } + for (auto it = vals.vec.begin() + + static_cast(is_union && skip_union_default); + it != vals.vec.end(); ++it) { + if ((*it)->value == enum_idx) { return *it; } } return nullptr; } @@ -338,8 +339,7 @@ inline bool EqualByName(const Type &a, const Type &b) { return a.base_type == b.base_type && a.element == b.element && (a.struct_def == b.struct_def || a.struct_def->name == b.struct_def->name) && - (a.enum_def == b.enum_def || - a.enum_def->name == b.enum_def->name); + (a.enum_def == b.enum_def || a.enum_def->name == b.enum_def->name); } struct RPCCall { @@ -389,16 +389,16 @@ struct IDLOptions { // Possible options for the more general generator below. enum Language { - kJava = 1 << 0, + kJava = 1 << 0, kCSharp = 1 << 1, - kGo = 1 << 2, - kCpp = 1 << 3, - kJs = 1 << 4, + kGo = 1 << 2, + kCpp = 1 << 3, + kJs = 1 << 4, kPython = 1 << 5, - kPhp = 1 << 6, - kJson = 1 << 7, + kPhp = 1 << 6, + kJson = 1 << 7, kBinary = 1 << 8, - kTs = 1 << 9, + kTs = 1 << 9, kJsonSchema = 1 << 10, kMAX }; @@ -414,33 +414,35 @@ struct IDLOptions { unsigned long lang_to_generate; IDLOptions() - : strict_json(false), - skip_js_exports(false), - use_goog_js_export_format(false), - output_default_scalars_in_json(false), - indent_step(2), - output_enum_identifiers(true), prefixed_enums(true), scoped_enums(false), - include_dependence_headers(true), - mutable_buffer(false), - one_file(false), - proto_mode(false), - generate_all(false), - skip_unexpected_fields_in_json(false), - generate_name_strings(false), - generate_object_based_api(false), - cpp_object_api_pointer_type("std::unique_ptr"), - gen_nullable(false), - object_suffix("T"), - union_value_namespacing(true), - allow_non_utf8(false), - keep_include_path(false), - binary_schema_comments(false), - skip_flatbuffers_import(false), - reexport_ts_modules(true), - protobuf_ascii_alike(false), - lang(IDLOptions::kJava), - mini_reflect(IDLOptions::kNone), - lang_to_generate(0) {} + : strict_json(false), + skip_js_exports(false), + use_goog_js_export_format(false), + output_default_scalars_in_json(false), + indent_step(2), + output_enum_identifiers(true), + prefixed_enums(true), + scoped_enums(false), + include_dependence_headers(true), + mutable_buffer(false), + one_file(false), + proto_mode(false), + generate_all(false), + skip_unexpected_fields_in_json(false), + generate_name_strings(false), + generate_object_based_api(false), + cpp_object_api_pointer_type("std::unique_ptr"), + gen_nullable(false), + object_suffix("T"), + union_value_namespacing(true), + allow_non_utf8(false), + keep_include_path(false), + binary_schema_comments(false), + skip_flatbuffers_import(false), + reexport_ts_modules(true), + protobuf_ascii_alike(false), + lang(IDLOptions::kJava), + mini_reflect(IDLOptions::kNone), + lang_to_generate(0) {} }; // This encapsulates where the parser is in the current source file. @@ -466,7 +468,7 @@ struct ParserState { class CheckedError { public: explicit CheckedError(bool error) - : is_error_(error), has_been_checked_(false) {} + : is_error_(error), has_been_checked_(false) {} CheckedError &operator=(const CheckedError &other) { is_error_ = other.is_error_; @@ -481,7 +483,10 @@ class CheckedError { ~CheckedError() { assert(has_been_checked_); } - bool Check() { has_been_checked_ = true; return is_error_; } + bool Check() { + has_been_checked_ = true; + return is_error_; + } private: bool is_error_; @@ -490,23 +495,25 @@ class CheckedError { // Additionally, in GCC we can get these errors statically, for additional // assurance: +// clang-format off #ifdef __GNUC__ #define FLATBUFFERS_CHECKED_ERROR CheckedError \ __attribute__((warn_unused_result)) #else #define FLATBUFFERS_CHECKED_ERROR CheckedError #endif +// clang-format on class Parser : public ParserState { public: explicit Parser(const IDLOptions &options = IDLOptions()) - : current_namespace_(nullptr), - empty_namespace_(nullptr), - root_struct_def_(nullptr), - opts(options), - uses_flexbuffers_(false), - source_(nullptr), - anonymous_counter(0) { + : current_namespace_(nullptr), + empty_namespace_(nullptr), + root_struct_def_(nullptr), + opts(options), + uses_flexbuffers_(false), + source_(nullptr), + anonymous_counter(0) { // Start out with the empty namespace being current. empty_namespace_ = new Namespace(); namespaces_.push_back(empty_namespace_); @@ -581,7 +588,7 @@ class Parser : public ParserState { StructDef *LookupStruct(const std::string &id) const; -private: + private: void Message(const std::string &msg); void Warning(const std::string &msg); FLATBUFFERS_CHECKED_ERROR Error(const std::string &msg); @@ -606,6 +613,7 @@ private: FLATBUFFERS_CHECKED_ERROR ParseAnyValue(Value &val, FieldDef *field, size_t parent_fieldn, const StructDef *parent_struct_def); + // clang-format off #if defined(FLATBUFFERS_CPP98_STL) typedef CheckedError (*ParseTableDelimitersBody)( const std::string &name, size_t &fieldn, const StructDef *struct_def, @@ -615,6 +623,7 @@ private: const StructDef*, void*)> ParseTableDelimitersBody; #endif // defined(FLATBUFFERS_CPP98_STL) + // clang-format on FLATBUFFERS_CHECKED_ERROR ParseTableDelimiters(size_t &fieldn, const StructDef *struct_def, ParseTableDelimitersBody body, @@ -623,6 +632,7 @@ private: std::string *value, uoffset_t *ovalue); void SerializeStruct(const StructDef &struct_def, const Value &val); void AddVector(bool sortbysize, int count); + // clang-format off #if defined(FLATBUFFERS_CPP98_STL) typedef CheckedError (*ParseVectorDelimitersBody)(size_t &count, void *state); @@ -630,6 +640,7 @@ private: typedef std::function ParseVectorDelimitersBody; #endif // defined(FLATBUFFERS_CPP98_STL) + // clang-format on FLATBUFFERS_CHECKED_ERROR ParseVectorDelimiters( size_t &count, ParseVectorDelimitersBody body, void *state); FLATBUFFERS_CHECKED_ERROR ParseVector(const Type &type, uoffset_t *ovalue); @@ -844,7 +855,7 @@ bool GenerateCppGRPC(const Parser &parser, bool GenerateGoGRPC(const Parser &parser, const std::string &path, const std::string &file_name); - + // Generate GRPC Java classes. // See idl_gen_grpc.cpp bool GenerateJavaGRPC(const Parser &parser, diff --git a/include/flatbuffers/minireflect.h b/include/flatbuffers/minireflect.h index cb3f40387..1f351c056 100644 --- a/include/flatbuffers/minireflect.h +++ b/include/flatbuffers/minireflect.h @@ -65,8 +65,7 @@ struct IterationVisitor { virtual void EndVector() {} virtual void Element(size_t /*i*/, ElementaryType /*type*/, const TypeTable * /*type_table*/, - const uint8_t * /*val*/) - {} + const uint8_t * /*val*/) {} virtual ~IterationVisitor() {} }; @@ -75,34 +74,24 @@ inline size_t InlineSize(ElementaryType type, const TypeTable *type_table) { case ET_UTYPE: case ET_BOOL: case ET_CHAR: - case ET_UCHAR: - return 1; + case ET_UCHAR: return 1; case ET_SHORT: - case ET_USHORT: - return 2; + case ET_USHORT: return 2; case ET_INT: case ET_UINT: case ET_FLOAT: - case ET_STRING: - return 4; + case ET_STRING: return 4; case ET_LONG: case ET_ULONG: - case ET_DOUBLE: - return 8; + case ET_DOUBLE: return 8; case ET_SEQUENCE: switch (type_table->st) { case ST_TABLE: - case ST_UNION: - return 4; - case ST_STRUCT: - return type_table->values[type_table->num_elems]; - default: - assert(false); - return 1; + case ST_UNION: return 4; + case ST_STRUCT: return type_table->values[type_table->num_elems]; + default: assert(false); return 1; } - default: - assert(false); - return 1; + default: assert(false); return 1; } } @@ -118,7 +107,7 @@ inline int32_t LookupEnum(int32_t enum_val, const int32_t *values, template const char *EnumName(T tval, const TypeTable *type_table) { if (!type_table || !type_table->names) return nullptr; auto i = LookupEnum(static_cast(tval), type_table->values, - type_table->num_elems); + type_table->num_elems); if (i >= 0 && i < static_cast(type_table->num_elems)) { return type_table->names[i]; } @@ -126,13 +115,11 @@ template const char *EnumName(T tval, const TypeTable *type_table) { } void IterateObject(const uint8_t *obj, const TypeTable *type_table, - IterationVisitor *visitor); + IterationVisitor *visitor); inline void IterateValue(ElementaryType type, const uint8_t *val, - const TypeTable *type_table, - const uint8_t *prev_val, - soffset_t vector_index, - IterationVisitor *visitor) { + const TypeTable *type_table, const uint8_t *prev_val, + soffset_t vector_index, IterationVisitor *visitor) { switch (type) { case ET_UTYPE: { auto tval = *reinterpret_cast(val); @@ -200,9 +187,7 @@ inline void IterateValue(ElementaryType type, const uint8_t *val, val += ReadScalar(val); IterateObject(val, type_table, visitor); break; - case ST_STRUCT: - IterateObject(val, type_table, visitor); - break; + case ST_STRUCT: IterateObject(val, type_table, visitor); break; case ST_UNION: { val += ReadScalar(val); assert(prev_val); @@ -211,10 +196,10 @@ inline void IterateValue(ElementaryType type, const uint8_t *val, auto type_vec = reinterpret_cast *>(prev_val); union_type = type_vec->Get(static_cast(vector_index)); } - auto type_code_idx = LookupEnum(union_type, type_table->values, - type_table->num_elems); - if (type_code_idx >= 0 && type_code_idx < - static_cast(type_table->num_elems)) { + auto type_code_idx = + LookupEnum(union_type, type_table->values, type_table->num_elems); + if (type_code_idx >= 0 && + type_code_idx < static_cast(type_table->num_elems)) { auto type_code = type_table->type_codes[type_code_idx]; switch (type_code.base_type) { case ET_SEQUENCE: { @@ -225,17 +210,14 @@ inline void IterateValue(ElementaryType type, const uint8_t *val, case ET_STRING: visitor->String(reinterpret_cast(val)); break; - default: - visitor->Unknown(val); + default: visitor->Unknown(val); } } else { visitor->Unknown(val); } break; } - case ST_ENUM: - assert(false); - break; + case ST_ENUM: assert(false); break; } break; } @@ -257,14 +239,12 @@ inline void IterateObject(const uint8_t *obj, const TypeTable *type_table, auto is_vector = type_code.is_vector != 0; auto ref_idx = type_code.sequence_ref; const TypeTable *ref = nullptr; - if (ref_idx >= 0) { - ref = type_table->type_refs[ref_idx](); - } + if (ref_idx >= 0) { ref = type_table->type_refs[ref_idx](); } auto name = type_table->names ? type_table->names[i] : nullptr; const uint8_t *val = nullptr; if (type_table->st == ST_TABLE) { val = reinterpret_cast(obj)->GetAddressOf( - FieldIndexToOffset(static_cast(i))); + FieldIndexToOffset(static_cast(i))); } else { val = obj + type_table->values[i]; } @@ -310,24 +290,29 @@ struct ToStringVisitor : public IterationVisitor { const char *name, const uint8_t *val) { if (!val) return; if (set_idx) s += ", "; - if (name) { s += name; s += ": "; } + if (name) { + s += name; + s += ": "; + } } template void Named(T x, const char *name) { - if (name) s+= name; - else s+= NumToString(x); + if (name) + s += name; + else + s += NumToString(x); } void UType(uint8_t x, const char *name) { Named(x, name); } - void Bool(bool x) { s+= x ? "true" : "false"; } + void Bool(bool x) { s += x ? "true" : "false"; } void Char(int8_t x, const char *name) { Named(x, name); } void UChar(uint8_t x, const char *name) { Named(x, name); } void Short(int16_t x, const char *name) { Named(x, name); } void UShort(uint16_t x, const char *name) { Named(x, name); } void Int(int32_t x, const char *name) { Named(x, name); } void UInt(uint32_t x, const char *name) { Named(x, name); } - void Long(int64_t x) { s+= NumToString(x); } - void ULong(uint64_t x) { s+= NumToString(x); } - void Float(float x) { s+= NumToString(x); } - void Double(double x) { s+= NumToString(x); } + void Long(int64_t x) { s += NumToString(x); } + void ULong(uint64_t x) { s += NumToString(x); } + void Float(float x) { s += NumToString(x); } + void Double(double x) { s += NumToString(x); } void String(const struct String *str) { EscapeString(str->c_str(), str->size(), &s, true); } diff --git a/include/flatbuffers/reflection.h b/include/flatbuffers/reflection.h index ad5c45627..6e2fafda5 100644 --- a/include/flatbuffers/reflection.h +++ b/include/flatbuffers/reflection.h @@ -30,14 +30,18 @@ namespace flatbuffers { // ------------------------- GETTERS ------------------------- -inline bool IsScalar (reflection::BaseType t) { return t >= reflection::UType && - t <= reflection::Double; } -inline bool IsInteger(reflection::BaseType t) { return t >= reflection::UType && - t <= reflection::ULong; } -inline bool IsFloat (reflection::BaseType t) { return t == reflection::Float || - t == reflection::Double; } -inline bool IsLong (reflection::BaseType t) { return t == reflection::Long || - t == reflection::ULong; } +inline bool IsScalar(reflection::BaseType t) { + return t >= reflection::UType && t <= reflection::Double; +} +inline bool IsInteger(reflection::BaseType t) { + return t >= reflection::UType && t <= reflection::ULong; +} +inline bool IsFloat(reflection::BaseType t) { + return t == reflection::Float || t == reflection::Double; +} +inline bool IsLong(reflection::BaseType t) { + return t == reflection::Long || t == reflection::ULong; +} // Size of a basic type, don't use with structs. inline size_t GetTypeSize(reflection::BaseType base_type) { @@ -48,8 +52,7 @@ inline size_t GetTypeSize(reflection::BaseType base_type) { // Same as above, but now correctly returns the size of a struct if // the field (or vector element) is a struct. -inline size_t GetTypeSizeInline(reflection::BaseType base_type, - int type_index, +inline size_t GetTypeSizeInline(reflection::BaseType base_type, int type_index, const reflection::Schema &schema) { if (base_type == reflection::Obj && schema.objects()->Get(type_index)->is_struct()) { @@ -80,16 +83,16 @@ template T GetFieldDefaultF(const reflection::Field &field) { } // Get a field, if you know it's an integer, and its exact type. -template T GetFieldI(const Table &table, - const reflection::Field &field) { +template +T GetFieldI(const Table &table, const reflection::Field &field) { assert(sizeof(T) == GetTypeSize(field.type()->base_type())); return table.GetField(field.offset(), static_cast(field.default_integer())); } // Get a field, if you know it's floating point and its exact type. -template T GetFieldF(const Table &table, - const reflection::Field &field) { +template +T GetFieldF(const Table &table, const reflection::Field &field) { assert(sizeof(T) == GetTypeSize(field.type()->base_type())); return table.GetField(field.offset(), static_cast(field.default_real())); @@ -103,8 +106,8 @@ inline const String *GetFieldS(const Table &table, } // Get a field, if you know it's a vector. -template Vector *GetFieldV(const Table &table, - const reflection::Field &field) { +template +Vector *GetFieldV(const Table &table, const reflection::Field &field) { assert(field.type()->base_type() == reflection::Vector && sizeof(T) == GetTypeSize(field.type()->element())); return table.GetPointer *>(field.offset()); @@ -119,8 +122,7 @@ 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) { +inline Table *GetFieldT(const Table &table, const reflection::Field &field) { assert(field.type()->base_type() == reflection::Obj || field.type()->base_type() == reflection::Union); return table.GetPointer

(field.offset()); @@ -153,8 +155,7 @@ double GetAnyValueF(reflection::BaseType type, const uint8_t *data); // All scalars converted using stringstream, strings as-is, and all other // data types provide some level of debug-pretty-printing. std::string GetAnyValueS(reflection::BaseType type, const uint8_t *data, - const reflection::Schema *schema, - int type_index); + const reflection::Schema *schema, int type_index); // Get any table field as a 64bit int, regardless of what type it is. inline int64_t GetAnyFieldI(const Table &table, @@ -165,14 +166,12 @@ inline int64_t GetAnyFieldI(const Table &table, } // Get any table field as a double, regardless of what type it is. -inline double GetAnyFieldF(const Table &table, - const reflection::Field &field) { +inline double GetAnyFieldF(const Table &table, const reflection::Field &field) { auto field_ptr = table.GetAddressOf(field.offset()); return field_ptr ? GetAnyValueF(field.type()->base_type(), field_ptr) : field.default_real(); } - // Get any table field as a string, regardless of what type it is. // You may pass nullptr for the schema if you don't care to have fields that // are of table type pretty-printed. @@ -186,15 +185,13 @@ inline std::string GetAnyFieldS(const Table &table, } // Get any struct field as a 64bit int, regardless of what type it is. -inline int64_t GetAnyFieldI(const Struct &st, - const reflection::Field &field) { +inline int64_t GetAnyFieldI(const Struct &st, const reflection::Field &field) { return GetAnyValueI(field.type()->base_type(), st.GetAddressOf(field.offset())); } // Get any struct field as a double, regardless of what type it is. -inline double GetAnyFieldF(const Struct &st, - const reflection::Field &field) { +inline double GetAnyFieldF(const Struct &st, const reflection::Field &field) { return GetAnyValueF(field.type()->base_type(), st.GetAddressOf(field.offset())); } @@ -228,8 +225,8 @@ inline std::string GetAnyVectorElemS(const VectorOfAny *vec, // Get a vector element that's a table/string/vector from a generic vector. // Pass Table/String/VectorOfAny as template parameter. // Warning: does no typechecking. -template T *GetAnyVectorElemPointer(const VectorOfAny *vec, - size_t i) { +template +T *GetAnyVectorElemPointer(const VectorOfAny *vec, size_t i) { auto elem_ptr = vec->Data() + sizeof(uoffset_t) * i; return (T *)(elem_ptr + ReadScalar(elem_ptr)); } @@ -239,34 +236,32 @@ template T *GetAnyVectorElemPointer(const VectorOfAny *vec, // Get elem_size from GetTypeSizeInline(). // Note: little-endian data on all platforms, use EndianScalar() instead of // raw pointer access with scalars). -template T *GetAnyVectorElemAddressOf(const VectorOfAny *vec, - size_t i, - size_t elem_size) { +template +T *GetAnyVectorElemAddressOf(const VectorOfAny *vec, size_t i, + size_t elem_size) { // C-cast to allow const conversion. return (T *)(vec->Data() + elem_size * i); } // Similarly, for elements of tables. -template T *GetAnyFieldAddressOf(const Table &table, - const reflection::Field &field) { +template +T *GetAnyFieldAddressOf(const Table &table, const reflection::Field &field) { return (T *)table.GetAddressOf(field.offset()); } // Similarly, for elements of structs. -template T *GetAnyFieldAddressOf(const Struct &st, - const reflection::Field &field) { +template +T *GetAnyFieldAddressOf(const Struct &st, const reflection::Field &field) { return (T *)st.GetAddressOf(field.offset()); } // ------------------------- SETTERS ------------------------- // Set any scalar field, if you know its exact type. -template bool SetField(Table *table, const reflection::Field &field, - T val) { +template +bool SetField(Table *table, const reflection::Field &field, T val) { reflection::BaseType type = field.type()->base_type(); - if (!IsScalar(type)) { - return false; - } + if (!IsScalar(type)) { return false; } assert(sizeof(T) == GetTypeSize(type)); T def; if (IsInteger(type)) { @@ -306,7 +301,7 @@ inline bool SetAnyFieldF(Table *table, const reflection::Field &field, // Set any table field as a string, regardless of what type it is. inline bool SetAnyFieldS(Table *table, const reflection::Field &field, - const char *val) { + const char *val) { auto field_ptr = table->GetAddressOf(field.offset()); if (!field_ptr) return false; SetAnyValueS(field.type()->base_type(), field_ptr, val); @@ -352,7 +347,6 @@ inline void SetAnyVectorElemS(VectorOfAny *vec, reflection::BaseType elem_type, SetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val); } - // ------------------------- RESIZING SETTERS ------------------------- // "smart" pointer for use with resizing vectors: turns a pointer inside @@ -360,27 +354,25 @@ inline void SetAnyVectorElemS(VectorOfAny *vec, reflection::BaseType elem_type, template class pointer_inside_vector { public: pointer_inside_vector(T *ptr, std::vector &vec) - : offset_(reinterpret_cast(ptr) - - reinterpret_cast(flatbuffers::vector_data(vec))), - vec_(vec) {} + : offset_(reinterpret_cast(ptr) - + reinterpret_cast(flatbuffers::vector_data(vec))), + vec_(vec) {} T *operator*() const { return reinterpret_cast( - reinterpret_cast( - flatbuffers::vector_data(vec_)) + offset_); - } - T *operator->() const { - return operator*(); + reinterpret_cast(flatbuffers::vector_data(vec_)) + offset_); } + T *operator->() const { return operator*(); } void operator=(const pointer_inside_vector &piv); + private: size_t offset_; std::vector &vec_; }; // Helper to create the above easily without specifying template args. -template pointer_inside_vector piv(T *ptr, - std::vector &vec) { +template +pointer_inside_vector piv(T *ptr, std::vector &vec) { return pointer_inside_vector(ptr, vec); } @@ -393,7 +385,7 @@ inline const reflection::Object &GetUnionType( auto enumdef = schema.enums()->Get(unionfield.type()->index()); // 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()); + (unionfield.name()->str() + UnionTypeFieldSuffix()).c_str()); assert(type_field); auto union_type = GetFieldI(table, *type_field); auto enumval = enumdef->values()->LookupByKey(union_type); @@ -419,16 +411,14 @@ uint8_t *ResizeAnyVector(const reflection::Schema &schema, uoffset_t newsize, uoffset_t elem_size, std::vector *flatbuf, const reflection::Object *root_table = nullptr); -template +template void ResizeVector(const reflection::Schema &schema, uoffset_t newsize, T val, const Vector *vec, std::vector *flatbuf, const reflection::Object *root_table = nullptr) { auto delta_elem = static_cast(newsize) - static_cast(vec->size()); - auto newelems = ResizeAnyVector(schema, newsize, - reinterpret_cast(vec), - vec->size(), - static_cast(sizeof(T)), flatbuf, - root_table); + auto newelems = ResizeAnyVector( + schema, newsize, reinterpret_cast(vec), vec->size(), + static_cast(sizeof(T)), flatbuf, root_table); // Set new elements to "val". for (int i = 0; i < delta_elem; i++) { auto loc = newelems + i * sizeof(T); @@ -479,10 +469,8 @@ Offset CopyTable(FlatBufferBuilder &fbb, // root should point to the root type for this flatbuffer. // buf should point to the start of flatbuffer data. // length specifies the size of the flatbuffer data. -bool Verify(const reflection::Schema &schema, - const reflection::Object &root, - const uint8_t *buf, - size_t length); +bool Verify(const reflection::Schema &schema, const reflection::Object &root, + const uint8_t *buf, size_t length); } // namespace flatbuffers diff --git a/include/flatbuffers/registry.h b/include/flatbuffers/registry.h index 35771c182..f90fc8d29 100644 --- a/include/flatbuffers/registry.h +++ b/include/flatbuffers/registry.h @@ -37,18 +37,16 @@ class Registry { // Generate text from an arbitrary FlatBuffer by looking up its // file_identifier in the registry. - bool FlatBufferToText(const uint8_t *flatbuf, size_t len, - std::string *dest) { + bool FlatBufferToText(const uint8_t *flatbuf, size_t len, std::string *dest) { // Get the identifier out of the buffer. // If the buffer is truncated, exit. - if (len < sizeof(uoffset_t) + - FlatBufferBuilder::kFileIdentifierLength) { + if (len < sizeof(uoffset_t) + FlatBufferBuilder::kFileIdentifierLength) { lasterror_ = "buffer truncated"; return false; } - std::string ident(reinterpret_cast(flatbuf) + - sizeof(uoffset_t), - FlatBufferBuilder::kFileIdentifierLength); + std::string ident( + reinterpret_cast(flatbuf) + sizeof(uoffset_t), + FlatBufferBuilder::kFileIdentifierLength); // Load and parse the schema. Parser parser; if (!LoadSchema(ident, &parser)) return false; @@ -82,38 +80,36 @@ class Registry { // If schemas used contain include statements, call this function for every // directory the parser should search them for. - void AddIncludeDirectory(const char *path) { - include_paths_.push_back(path); - } + void AddIncludeDirectory(const char *path) { include_paths_.push_back(path); } // Returns a human readable error if any of the above functions fail. const std::string &GetLastError() { return lasterror_; } private: - bool LoadSchema(const std::string &ident, Parser *parser) { - // Find the schema, if not, exit. - auto it = schemas_.find(ident); - if (it == schemas_.end()) { - // Don't attach the identifier, since it may not be human readable. - lasterror_ = "identifier for this buffer not in the registry"; - return false; - } - auto &schema = it->second; - // Load the schema from disk. If not, exit. - std::string schematext; - if (!LoadFile(schema.path_.c_str(), false, &schematext)) { - lasterror_ = "could not load schema: " + schema.path_; - return false; - } - // Parse schema. - parser->opts = opts_; - if (!parser->Parse(schematext.c_str(), vector_data(include_paths_), - schema.path_.c_str())) { - lasterror_ = parser->error_; - return false; - } - return true; - } + bool LoadSchema(const std::string &ident, Parser *parser) { + // Find the schema, if not, exit. + auto it = schemas_.find(ident); + if (it == schemas_.end()) { + // Don't attach the identifier, since it may not be human readable. + lasterror_ = "identifier for this buffer not in the registry"; + return false; + } + auto &schema = it->second; + // Load the schema from disk. If not, exit. + std::string schematext; + if (!LoadFile(schema.path_.c_str(), false, &schematext)) { + lasterror_ = "could not load schema: " + schema.path_; + return false; + } + // Parse schema. + parser->opts = opts_; + if (!parser->Parse(schematext.c_str(), vector_data(include_paths_), + schema.path_.c_str())) { + lasterror_ = parser->error_; + return false; + } + return true; + } struct Schema { std::string path_; diff --git a/include/flatbuffers/stl_emulation.h b/include/flatbuffers/stl_emulation.h index bacb2244b..4ec7bc18f 100644 --- a/include/flatbuffers/stl_emulation.h +++ b/include/flatbuffers/stl_emulation.h @@ -17,6 +17,8 @@ #ifndef FLATBUFFERS_STL_EMULATION_H_ #define FLATBUFFERS_STL_EMULATION_H_ +// clang-format off + #include #include #include diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h index 6b7b7bc3e..245ba1175 100644 --- a/include/flatbuffers/util.h +++ b/include/flatbuffers/util.h @@ -17,32 +17,31 @@ #ifndef FLATBUFFERS_UTIL_H_ #define FLATBUFFERS_UTIL_H_ -#include -#include -#include -#include +#include #include #include -#include +#include +#include +#include +#include #ifdef _WIN32 -#ifndef WIN32_LEAN_AND_MEAN - #define WIN32_LEAN_AND_MEAN -#endif -#ifndef NOMINMAX - #define NOMINMAX -#endif -#include -#include -#include +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +# include #else -#include +# include #endif -#include #include +#include #include "flatbuffers/base.h" - namespace flatbuffers { // Convert an integer or floating point value to a string. @@ -61,18 +60,18 @@ template<> inline std::string NumToString(unsigned char t) { return NumToString(static_cast(t)); } #if defined(FLATBUFFERS_CPP98_STL) - template <> inline std::string NumToString(long long t) { - char buf[21]; // (log((1 << 63) - 1) / log(10)) + 2 - snprintf(buf, sizeof(buf), "%lld", t); - return std::string(buf); - } +template<> inline std::string NumToString(long long t) { + char buf[21]; // (log((1 << 63) - 1) / log(10)) + 2 + snprintf(buf, sizeof(buf), "%lld", t); + return std::string(buf); +} - template <> inline std::string NumToString( - unsigned long long t) { - char buf[22]; // (log((1 << 63) - 1) / log(10)) + 1 - snprintf(buf, sizeof(buf), "%llu", t); - return std::string(buf); - } +template<> +inline std::string NumToString(unsigned long long t) { + char buf[22]; // (log((1 << 63) - 1) / log(10)) + 1 + snprintf(buf, sizeof(buf), "%llu", t); + return std::string(buf); +} #endif // defined(FLATBUFFERS_CPP98_STL) // Special versions for floats/doubles. @@ -100,10 +99,7 @@ template<> inline std::string NumToString(float t) { // For example, IntToStringHex(0x23, 8) returns the string "00000023". inline std::string IntToStringHex(int i, int xdigits) { std::stringstream ss; - ss << std::setw(xdigits) - << std::setfill('0') - << std::hex - << std::uppercase + ss << std::setw(xdigits) << std::setfill('0') << std::hex << std::uppercase << i; return ss.str(); } @@ -111,21 +107,25 @@ inline std::string IntToStringHex(int i, int xdigits) { // Portable implementation of strtoll(). inline int64_t StringToInt(const char *str, char **endptr = nullptr, int base = 10) { + // clang-format off #ifdef _MSC_VER return _strtoi64(str, endptr, base); #else return strtoll(str, endptr, base); #endif + // clang-format on } // Portable implementation of strtoull(). inline uint64_t StringToUInt(const char *str, char **endptr = nullptr, int base = 10) { + // clang-format off #ifdef _MSC_VER return _strtoui64(str, endptr, base); #else return strtoull(str, endptr, base); #endif + // clang-format on } typedef bool (*LoadFileFunction)(const char *filename, bool binary, @@ -134,9 +134,8 @@ typedef bool (*FileExistsFunction)(const char *filename); LoadFileFunction SetLoadFileFunction(LoadFileFunction load_file_function); -FileExistsFunction SetFileExistsFunction(FileExistsFunction - file_exists_function); - +FileExistsFunction SetFileExistsFunction( + FileExistsFunction file_exists_function); // Check if file "name" exists. bool FileExists(const char *name); @@ -239,16 +238,19 @@ inline std::string PosixPath(const char *path) { inline void EnsureDirExists(const std::string &filepath) { auto parent = StripFileName(filepath); if (parent.length()) EnsureDirExists(parent); + // clang-format off #ifdef _WIN32 (void)_mkdir(filepath.c_str()); #else mkdir(filepath.c_str(), S_IRWXU|S_IRGRP|S_IXGRP); #endif + // clang-format on } // Obtains the absolute path from any other path. // Returns the input path if the absolute path couldn't be resolved. inline std::string AbsolutePath(const std::string &filepath) { + // clang-format off #ifdef FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION return filepath; #else @@ -262,6 +264,7 @@ inline std::string AbsolutePath(const std::string &filepath) { ? abs_path : filepath; #endif // FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION + // clang-format on } // To and from UTF-8 unicode conversion functions @@ -279,7 +282,7 @@ inline int ToUTF8(uint32_t ucc, std::string *out) { uint32_t remain_bits = i * 6; // Store first byte: (*out) += static_cast((0xFE << (max_bits - remain_bits)) | - (ucc >> remain_bits)); + (ucc >> remain_bits)); // Store remaining bytes: for (int j = i - 1; j >= 0; j--) { (*out) += static_cast(((ucc >> (j * 6)) & 0x3F) | 0x80); @@ -309,9 +312,7 @@ inline int FromUTF8(const char **in) { if ((**in << len) & 0x80) return -1; // Bit after leading 1's must be 0. if (!len) return *(*in)++; // UTF-8 encoded values with a length are between 2 and 4 bytes. - if (len < 2 || len > 4) { - return -1; - } + if (len < 2 || len > 4) { return -1; } // Grab initial bits of the code. int ucc = *(*in)++ & ((1 << (7 - len)) - 1); for (int i = 0; i < len - 1; i++) { @@ -321,28 +322,20 @@ inline int FromUTF8(const char **in) { } // UTF-8 cannot encode values between 0xD800 and 0xDFFF (reserved for // UTF-16 surrogate pairs). - if (ucc >= 0xD800 && ucc <= 0xDFFF) { - return -1; - } + if (ucc >= 0xD800 && ucc <= 0xDFFF) { return -1; } // UTF-8 must represent code points in their shortest possible encoding. switch (len) { case 2: // Two bytes of UTF-8 can represent code points from U+0080 to U+07FF. - if (ucc < 0x0080 || ucc > 0x07FF) { - return -1; - } + if (ucc < 0x0080 || ucc > 0x07FF) { return -1; } break; case 3: // Three bytes of UTF-8 can represent code points from U+0800 to U+FFFF. - if (ucc < 0x0800 || ucc > 0xFFFF) { - return -1; - } + if (ucc < 0x0800 || ucc > 0xFFFF) { return -1; } break; case 4: // Four bytes of UTF-8 can represent code points from U+10000 to U+10FFFF. - if (ucc < 0x10000 || ucc > 0x10FFFF) { - return -1; - } + if (ucc < 0x10000 || ucc > 0x10FFFF) { return -1; } break; } return ucc; @@ -421,7 +414,8 @@ inline bool EscapeString(const char *s, size_t length, std::string *_text, text += "\\u"; text += IntToStringHex(ucc, 4); } else if (ucc <= 0x10FFFF) { - // Encode Unicode SMP values to a surrogate pair using two \u escapes. + // Encode Unicode SMP values to a surrogate pair using two \u + // escapes. uint32_t base = ucc - 0x10000; auto high_surrogate = (base >> 10) + 0xD800; auto low_surrogate = (base & 0x03FF) + 0xDC00; diff --git a/samples/sample_binary.cpp b/samples/sample_binary.cpp index 4c5f01709..46f08bb17 100644 --- a/samples/sample_binary.cpp +++ b/samples/sample_binary.cpp @@ -14,13 +14,13 @@ * limitations under the License. */ -#include "monster_generated.h" // Already includes "flatbuffers/flatbuffers.h". +#include "monster_generated.h" // Already includes "flatbuffers/flatbuffers.h". using namespace MyGame::Sample; // Example how to use FlatBuffers to create and read binary buffers. -int main(int /*argc*/, const char * /*argv*/[]) { +int main(int /*argc*/, const char * /*argv*/ []) { // Build up a serialized buffer algorithmically: flatbuffers::FlatBufferBuilder builder; @@ -53,7 +53,7 @@ int main(int /*argc*/, const char * /*argv*/[]) { auto orc = CreateMonster(builder, &position, 150, 80, name, inventory, Color_Red, weapons, Equipment_Weapon, axe.Union()); - builder.Finish(orc); // Serialize the root of the object. + builder.Finish(orc); // Serialize the root of the object. // We now have a FlatBuffer we can store on disk or send over a network. @@ -83,8 +83,8 @@ int main(int /*argc*/, const char * /*argv*/[]) { (void)inv; // Get and test the `weapons` FlatBuffers's `vector`. - std::string expected_weapon_names[] = {"Sword", "Axe"}; - short expected_weapon_damages[] = {3, 5}; + std::string expected_weapon_names[] = { "Sword", "Axe" }; + short expected_weapon_damages[] = { 3, 5 }; auto weps = monster->weapons(); for (unsigned int i = 0; i < weps->size(); i++) { assert(weps->Get(i)->name()->str() == expected_weapon_names[i]); @@ -95,11 +95,10 @@ int main(int /*argc*/, const char * /*argv*/[]) { // Get and test the `Equipment` union (`equipped` field). assert(monster->equipped_type() == Equipment_Weapon); - auto equipped = static_cast(monster->equipped()); + auto equipped = static_cast(monster->equipped()); assert(equipped->name()->str() == "Axe"); assert(equipped->damage() == 5); (void)equipped; printf("The FlatBuffer was successfully created and verified!\n"); } - diff --git a/samples/sample_text.cpp b/samples/sample_text.cpp index d851120d1..aca0189c6 100644 --- a/samples/sample_text.cpp +++ b/samples/sample_text.cpp @@ -17,13 +17,13 @@ #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "monster_generated.h" // Already includes "flatbuffers/flatbuffers.h". +#include "monster_generated.h" // Already includes "flatbuffers/flatbuffers.h". using namespace MyGame::Sample; // This is an example of parsing text straight into a buffer and then // generating flatbuffer (JSON) text from the buffer. -int main(int /*argc*/, const char * /*argv*/[]) { +int main(int /*argc*/, const char * /*argv*/ []) { // load FlatBuffer schema (.fbs) and JSON from disk std::string schemafile; std::string jsonfile; diff --git a/src/clang-format.sh b/src/clang-format.sh new file mode 100644 index 000000000..fbce6b9e4 --- /dev/null +++ b/src/clang-format.sh @@ -0,0 +1,2 @@ +clang-format -i -style=file include/flatbuffers/* src/*.cpp tests/test.cpp samples/*.cpp grpc/src/compiler/schema_interface.h grpc/tests/*.cpp +git checkout include/flatbuffers/reflection_generated.h diff --git a/src/code_generators.cpp b/src/code_generators.cpp index e0bee8ba1..c6bf91c2b 100644 --- a/src/code_generators.cpp +++ b/src/code_generators.cpp @@ -20,24 +20,19 @@ #include "flatbuffers/util.h" #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable: 4127) // C4127: conditional expression is constant +# pragma warning(push) +# pragma warning(disable : 4127) // C4127: conditional expression is constant #endif namespace flatbuffers { void CodeWriter::operator+=(std::string text) { - while (true) { auto begin = text.find("{{"); - if (begin == std::string::npos) { - break; - } + if (begin == std::string::npos) { break; } auto end = text.find("}}"); - if (end == std::string::npos || end < begin) { - break; - } + if (end == std::string::npos || end < begin) { break; } // Write all the text before the first {{ into the stream. stream_.write(text.c_str(), begin); @@ -119,7 +114,6 @@ std::string BaseGenerator::WrapInNameSpace(const Namespace *ns, return qualified_name + name; } - std::string BaseGenerator::WrapInNameSpace(const Definition &def) const { return WrapInNameSpace(def.defined_namespace, def.name); } @@ -150,12 +144,12 @@ void GenComment(const std::vector &dc, std::string *code_ptr, if (config != nullptr && config->first_line != nullptr) { code += std::string(prefix) + std::string(config->first_line) + "\n"; } - std::string line_prefix = std::string(prefix) + - ((config != nullptr && config->content_line_prefix != nullptr) ? - config->content_line_prefix : "///"); - for (auto it = dc.begin(); - it != dc.end(); - ++it) { + std::string line_prefix = + std::string(prefix) + + ((config != nullptr && config->content_line_prefix != nullptr) + ? config->content_line_prefix + : "///"); + for (auto it = dc.begin(); it != dc.end(); ++it) { code += line_prefix + *it + "\n"; } if (config != nullptr && config->last_line != nullptr) { @@ -166,5 +160,5 @@ void GenComment(const std::vector &dc, std::string *code_ptr, } // namespace flatbuffers #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/src/flatc.cpp b/src/flatc.cpp index 4f5e76591..def85b400 100644 --- a/src/flatc.cpp +++ b/src/flatc.cpp @@ -20,12 +20,10 @@ #define FLATC_VERSION "1.8.0 (" __DATE__ " " __TIME__ ")" - namespace flatbuffers { void FlatCompiler::ParseFile( - flatbuffers::Parser &parser, - const std::string &filename, + flatbuffers::Parser &parser, const std::string &filename, const std::string &contents, std::vector &include_directories) const { auto local_include_directory = flatbuffers::StripFileName(filename); @@ -47,11 +45,11 @@ void FlatCompiler::Error(const std::string &err, bool usage, params_.error_fn(this, err, usage, show_exe_name); } -std::string FlatCompiler::GetUsageString(const char* program_name) const { +std::string FlatCompiler::GetUsageString(const char *program_name) const { std::stringstream ss; ss << "Usage: " << program_name << " [OPTION]... FILE... [-- FILE...]\n"; for (size_t i = 0; i < params_.num_generators; ++i) { - const Generator& g = params_.generators[i]; + const Generator &g = params_.generators[i]; std::stringstream full_name; full_name << std::setw(12) << std::left << g.generator_opt_long; @@ -60,71 +58,73 @@ std::string FlatCompiler::GetUsageString(const char* program_name) const { ss << " " << full_name.str() << " " << name << " " << help << ".\n"; } + // clang-format off ss << - " -o PATH Prefix PATH to all generated files.\n" - " -I PATH Search for includes in the specified path.\n" - " -M Print make rules for generated files.\n" - " --version Print the version number of flatc and exit.\n" - " --strict-json Strict JSON: field names must be / will be quoted,\n" - " no trailing commas in tables/vectors.\n" - " --allow-non-utf8 Pass non-UTF-8 input through parser and emit nonstandard\n" - " \\x escapes in JSON. (Default is to raise parse error on\n" - " non-UTF-8 input.)\n" - " --defaults-json Output fields whose value is the default when\n" - " writing JSON\n" - " --unknown-json Allow fields in JSON that are not defined in the\n" - " schema. These fields will be discared when generating\n" - " binaries.\n" - " --no-prefix Don\'t prefix enum values with the enum type in C++.\n" - " --scoped-enums Use C++11 style scoped and strongly typed enums.\n" - " also implies --no-prefix.\n" - " --gen-includes (deprecated), this is the default behavior.\n" - " If the original behavior is required (no include\n" - " statements) use --no-includes.\n" - " --no-includes Don\'t generate include statements for included\n" - " schemas the generated file depends on (C++).\n" - " --gen-mutable Generate accessors that can mutate buffers in-place.\n" - " --gen-onefile Generate single output file for C# and Go.\n" - " --gen-name-strings Generate type name functions for C++.\n" - " --gen-object-api Generate an additional object-based API.\n" - " --cpp-ptr-type T Set object API pointer type (default std::unique_ptr)\n" - " --cpp-str-type T Set object API string type (default std::string)\n" - " T::c_str() and T::length() must be supported\n" - " --gen-nullable Add Clang _Nullable for C++ pointer. or @Nullable for Java\n" - " --object-prefix Customise class prefix for C++ object-based API.\n" - " --object-suffix Customise class suffix for C++ object-based API.\n" - " Default value is \"T\"\n" - " --no-js-exports Removes Node.js style export lines in JS.\n" - " --goog-js-export Uses goog.exports* for closure compiler exporting in JS.\n" - " --go-namespace Generate the overrided namespace in Golang.\n" - " --go-import Generate the overrided import for flatbuffers in Golang.\n" - " (default is \"github.com/google/flatbuffers/go\")\n" - " --raw-binary Allow binaries without file_indentifier to be read.\n" - " This may crash flatc given a mismatched schema.\n" - " --proto Input is a .proto, translate to .fbs.\n" - " --grpc Generate GRPC interfaces for the specified languages\n" - " --schema Serialize schemas instead of JSON (use with -b)\n" - " --bfbs-comments Add doc comments to the binary schema files.\n" - " --conform FILE Specify a schema the following schemas should be\n" - " an evolution of. Gives errors if not.\n" - " --conform-includes Include path for the schema given with --conform\n" - " PATH \n" - " --include-prefix Prefix this path to any generated include statements.\n" - " PATH\n" - " --keep-prefix Keep original prefix of schema include statement.\n" - " --no-fb-import Don't include flatbuffers import statement for TypeScript.\n" - " --no-ts-reexport Don't re-export imported dependencies for TypeScript.\n" - " --reflect-types Add minimal type reflection to code generation.\n" - " --reflect-names Add minimal type/name reflection.\n" - "FILEs may be schemas (must end in .fbs), or JSON files (conforming to preceding\n" - "schema). FILEs after the -- must be binary flatbuffer format files.\n" - "Output files are named using the base file name of the input,\n" - "and written to the current directory or the path given by -o.\n" - "example: " << program_name << " -c -b schema1.fbs schema2.fbs data.json\n"; + " -o PATH Prefix PATH to all generated files.\n" + " -I PATH Search for includes in the specified path.\n" + " -M Print make rules for generated files.\n" + " --version Print the version number of flatc and exit.\n" + " --strict-json Strict JSON: field names must be / will be quoted,\n" + " no trailing commas in tables/vectors.\n" + " --allow-non-utf8 Pass non-UTF-8 input through parser and emit nonstandard\n" + " \\x escapes in JSON. (Default is to raise parse error on\n" + " non-UTF-8 input.)\n" + " --defaults-json Output fields whose value is the default when\n" + " writing JSON\n" + " --unknown-json Allow fields in JSON that are not defined in the\n" + " schema. These fields will be discared when generating\n" + " binaries.\n" + " --no-prefix Don\'t prefix enum values with the enum type in C++.\n" + " --scoped-enums Use C++11 style scoped and strongly typed enums.\n" + " also implies --no-prefix.\n" + " --gen-includes (deprecated), this is the default behavior.\n" + " If the original behavior is required (no include\n" + " statements) use --no-includes.\n" + " --no-includes Don\'t generate include statements for included\n" + " schemas the generated file depends on (C++).\n" + " --gen-mutable Generate accessors that can mutate buffers in-place.\n" + " --gen-onefile Generate single output file for C# and Go.\n" + " --gen-name-strings Generate type name functions for C++.\n" + " --gen-object-api Generate an additional object-based API.\n" + " --cpp-ptr-type T Set object API pointer type (default std::unique_ptr)\n" + " --cpp-str-type T Set object API string type (default std::string)\n" + " T::c_str() and T::length() must be supported\n" + " --gen-nullable Add Clang _Nullable for C++ pointer. or @Nullable for Java\n" + " --object-prefix Customise class prefix for C++ object-based API.\n" + " --object-suffix Customise class suffix for C++ object-based API.\n" + " Default value is \"T\"\n" + " --no-js-exports Removes Node.js style export lines in JS.\n" + " --goog-js-export Uses goog.exports* for closure compiler exporting in JS.\n" + " --go-namespace Generate the overrided namespace in Golang.\n" + " --go-import Generate the overrided import for flatbuffers in Golang.\n" + " (default is \"github.com/google/flatbuffers/go\")\n" + " --raw-binary Allow binaries without file_indentifier to be read.\n" + " This may crash flatc given a mismatched schema.\n" + " --proto Input is a .proto, translate to .fbs.\n" + " --grpc Generate GRPC interfaces for the specified languages\n" + " --schema Serialize schemas instead of JSON (use with -b)\n" + " --bfbs-comments Add doc comments to the binary schema files.\n" + " --conform FILE Specify a schema the following schemas should be\n" + " an evolution of. Gives errors if not.\n" + " --conform-includes Include path for the schema given with --conform\n" + " PATH \n" + " --include-prefix Prefix this path to any generated include statements.\n" + " PATH\n" + " --keep-prefix Keep original prefix of schema include statement.\n" + " --no-fb-import Don't include flatbuffers import statement for TypeScript.\n" + " --no-ts-reexport Don't re-export imported dependencies for TypeScript.\n" + " --reflect-types Add minimal type reflection to code generation.\n" + " --reflect-names Add minimal type/name reflection.\n" + "FILEs may be schemas (must end in .fbs), or JSON files (conforming to preceding\n" + "schema). FILEs after the -- must be binary flatbuffer format files.\n" + "Output files are named using the base file name of the input,\n" + "and written to the current directory or the path given by -o.\n" + "example: " << program_name << " -c -b schema1.fbs schema2.fbs data.json\n"; + // clang-format on return ss.str(); } -int FlatCompiler::Compile(int argc, const char** argv) { +int FlatCompiler::Compile(int argc, const char **argv) { if (params_.generators == nullptr || params_.num_generators == 0) { return 0; } @@ -153,58 +153,58 @@ int FlatCompiler::Compile(int argc, const char** argv) { if (arg == "-o") { if (++argi >= argc) Error("missing path following: " + arg, true); output_path = flatbuffers::ConCatPathFileName( - flatbuffers::PosixPath(argv[argi]), ""); - } else if(arg == "-I") { + flatbuffers::PosixPath(argv[argi]), ""); + } else if (arg == "-I") { if (++argi >= argc) Error("missing path following" + arg, true); include_directories_storage.push_back( - flatbuffers::PosixPath(argv[argi])); + flatbuffers::PosixPath(argv[argi])); include_directories.push_back( - include_directories_storage.back().c_str()); - } else if(arg == "--conform") { + include_directories_storage.back().c_str()); + } else if (arg == "--conform") { if (++argi >= argc) Error("missing path following" + arg, true); conform_to_schema = flatbuffers::PosixPath(argv[argi]); } else if (arg == "--conform-includes") { if (++argi >= argc) Error("missing path following" + arg, true); include_directories_storage.push_back( - flatbuffers::PosixPath(argv[argi])); + flatbuffers::PosixPath(argv[argi])); conform_include_directories.push_back( - include_directories_storage.back().c_str()); + include_directories_storage.back().c_str()); } else if (arg == "--include-prefix") { if (++argi >= argc) Error("missing path following" + arg, true); opts.include_prefix = flatbuffers::ConCatPathFileName( - flatbuffers::PosixPath(argv[argi]), ""); - } else if(arg == "--keep-prefix") { + flatbuffers::PosixPath(argv[argi]), ""); + } else if (arg == "--keep-prefix") { opts.keep_include_path = true; - } else if(arg == "--strict-json") { + } else if (arg == "--strict-json") { opts.strict_json = true; - } else if(arg == "--allow-non-utf8") { + } else if (arg == "--allow-non-utf8") { opts.allow_non_utf8 = true; - } else if(arg == "--no-js-exports") { + } else if (arg == "--no-js-exports") { opts.skip_js_exports = true; - } else if(arg == "--goog-js-export") { + } else if (arg == "--goog-js-export") { opts.use_goog_js_export_format = true; - } else if(arg == "--go-namespace") { + } else if (arg == "--go-namespace") { if (++argi >= argc) Error("missing golang namespace" + arg, true); opts.go_namespace = argv[argi]; - } else if(arg == "--go-import") { + } else if (arg == "--go-import") { if (++argi >= argc) Error("missing golang import" + arg, true); opts.go_import = argv[argi]; - } else if(arg == "--defaults-json") { + } else if (arg == "--defaults-json") { opts.output_default_scalars_in_json = true; } else if (arg == "--unknown-json") { opts.skip_unexpected_fields_in_json = true; - } else if(arg == "--no-prefix") { + } else if (arg == "--no-prefix") { opts.prefixed_enums = false; - } else if(arg == "--scoped-enums") { + } else if (arg == "--scoped-enums") { opts.prefixed_enums = false; opts.scoped_enums = true; } else if (arg == "--no-union-value-namespacing") { opts.union_value_namespacing = false; - } else if(arg == "--gen-mutable") { + } else if (arg == "--gen-mutable") { opts.mutable_buffer = true; - } else if(arg == "--gen-name-strings") { + } else if (arg == "--gen-name-strings") { opts.generate_name_strings = true; - } else if(arg == "--gen-object-api") { + } else if (arg == "--gen-object-api") { opts.generate_object_based_api = true; } else if (arg == "--cpp-ptr-type") { if (++argi >= argc) Error("missing type following" + arg, true); @@ -220,40 +220,40 @@ int FlatCompiler::Compile(int argc, const char** argv) { } else if (arg == "--object-suffix") { if (++argi >= argc) Error("missing suffix following" + arg, true); opts.object_suffix = argv[argi]; - } else if(arg == "--gen-all") { + } else if (arg == "--gen-all") { opts.generate_all = true; opts.include_dependence_headers = false; - } else if(arg == "--gen-includes") { + } else if (arg == "--gen-includes") { // Deprecated, remove this option some time in the future. printf("warning: --gen-includes is deprecated (it is now default)\n"); - } else if(arg == "--no-includes") { + } else if (arg == "--no-includes") { opts.include_dependence_headers = false; } else if (arg == "--gen-onefile") { opts.one_file = true; } else if (arg == "--raw-binary") { raw_binary = true; - } else if(arg == "--") { // Separator between text and binary inputs. + } else if (arg == "--") { // Separator between text and binary inputs. binary_files_from = filenames.size(); - } else if(arg == "--proto") { + } else if (arg == "--proto") { opts.proto_mode = true; - } else if(arg == "--schema") { + } else if (arg == "--schema") { schema_binary = true; - } else if(arg == "-M") { + } else if (arg == "-M") { print_make_rules = true; - } else if(arg == "--version") { + } else if (arg == "--version") { printf("flatc version %s\n", FLATC_VERSION); exit(0); - } else if(arg == "--grpc") { + } else if (arg == "--grpc") { grpc_enabled = true; - } else if(arg == "--bfbs-comments") { + } else if (arg == "--bfbs-comments") { opts.binary_schema_comments = true; - } else if(arg == "--no-fb-import") { + } else if (arg == "--no-fb-import") { opts.skip_flatbuffers_import = true; - } else if(arg == "--no-ts-reexport") { + } else if (arg == "--no-ts-reexport") { opts.reexport_ts_modules = false; - } else if(arg == "--reflect-types") { + } else if (arg == "--reflect-types") { opts.mini_reflect = IDLOptions::kTypes; - } else if(arg == "--reflect-names") { + } else if (arg == "--reflect-names") { opts.mini_reflect = IDLOptions::kTypesAndNames; } else { for (size_t i = 0; i < params_.num_generators; ++i) { @@ -267,7 +267,7 @@ int FlatCompiler::Compile(int argc, const char** argv) { } } Error("unknown commandline argument: " + arg, true); - found:; + found:; } } else { filenames.push_back(flatbuffers::PosixPath(argv[argi])); @@ -294,23 +294,22 @@ int FlatCompiler::Compile(int argc, const char** argv) { std::unique_ptr parser(new flatbuffers::Parser(opts)); - for (auto file_it = filenames.begin(); - file_it != filenames.end(); - ++file_it) { + for (auto file_it = filenames.begin(); file_it != filenames.end(); + ++file_it) { auto &filename = *file_it; std::string contents; if (!flatbuffers::LoadFile(filename.c_str(), true, &contents)) Error("unable to load file: " + filename); - bool is_binary = static_cast(file_it - filenames.begin()) >= - binary_files_from; + bool is_binary = + static_cast(file_it - filenames.begin()) >= binary_files_from; auto ext = flatbuffers::GetExtension(filename); auto is_schema = ext == "fbs" || ext == "proto"; if (is_binary) { parser->builder_.Clear(); parser->builder_.PushFlatBuffer( - reinterpret_cast(contents.c_str()), - contents.length()); + reinterpret_cast(contents.c_str()), + contents.length()); if (!raw_binary) { // Generally reading binaries that do not correspond to the schema // will crash, and sadly there's no way around that when the binary @@ -319,16 +318,15 @@ int FlatCompiler::Compile(int argc, const char** argv) { // such an identifier, so by default we require them to match. if (!parser->file_identifier_.length()) { Error("current schema has no file_identifier: cannot test if \"" + - filename + - "\" matches the schema, use --raw-binary to read this file" - " anyway."); - } else if (!flatbuffers::BufferHasIdentifier(contents.c_str(), - parser->file_identifier_.c_str())) { - Error("binary \"" + - filename + - "\" does not have expected file_identifier \"" + - parser->file_identifier_ + - "\", use --raw-binary to read this file anyway."); + filename + + "\" matches the schema, use --raw-binary to read this file" + " anyway."); + } else if (!flatbuffers::BufferHasIdentifier( + contents.c_str(), parser->file_identifier_.c_str())) { + Error("binary \"" + filename + + "\" does not have expected file_identifier \"" + + parser->file_identifier_ + + "\", use --raw-binary to read this file anyway."); } } } else { @@ -346,8 +344,9 @@ int FlatCompiler::Compile(int argc, const char** argv) { if (!is_schema && !parser->builder_.GetSize()) { // If a file doesn't end in .fbs, it must be json/binary. Ensure we // didn't just parse a schema with a different extension. - Error("input file is neither json nor a .fbs (schema) file: " + - filename, true); + Error( + "input file is neither json nor a .fbs (schema) file: " + filename, + true); } if (is_schema && !conform_to_schema.empty()) { auto err = parser->ConformTo(conform_parser); @@ -359,8 +358,8 @@ int FlatCompiler::Compile(int argc, const char** argv) { } } - std::string filebase = flatbuffers::StripPath( - flatbuffers::StripExtension(filename)); + std::string filebase = + flatbuffers::StripPath(flatbuffers::StripExtension(filename)); for (size_t i = 0; i < params_.num_generators; ++i) { parser->opts.lang = params_.generators[i].lang; @@ -368,29 +367,28 @@ int FlatCompiler::Compile(int argc, const char** argv) { if (!print_make_rules) { flatbuffers::EnsureDirExists(output_path); if ((!params_.generators[i].schema_only || is_schema) && - !params_.generators[i].generate(*parser.get(), output_path, filebase)) { + !params_.generators[i].generate(*parser.get(), output_path, + filebase)) { Error(std::string("Unable to generate ") + - params_.generators[i].lang_name + - " for " + - filebase); + params_.generators[i].lang_name + " for " + filebase); } } else { std::string make_rule = params_.generators[i].make_rule( *parser.get(), output_path, filename); if (!make_rule.empty()) - printf("%s\n", flatbuffers::WordWrap( - make_rule, 80, " ", " \\").c_str()); + printf("%s\n", + flatbuffers::WordWrap(make_rule, 80, " ", " \\").c_str()); } if (grpc_enabled) { if (params_.generators[i].generateGRPC != nullptr) { if (!params_.generators[i].generateGRPC(*parser.get(), output_path, - filebase)) { + filebase)) { Error(std::string("Unable to generate GRPC interface for") + params_.generators[i].lang_name); } } else { - Warn(std::string("GRPC interface generator not implemented for ") - + params_.generators[i].lang_name); + Warn(std::string("GRPC interface generator not implemented for ") + + params_.generators[i].lang_name); } } } diff --git a/src/flatc_main.cpp b/src/flatc_main.cpp index e4702c651..d093020e3 100644 --- a/src/flatc_main.cpp +++ b/src/flatc_main.cpp @@ -19,26 +19,17 @@ static const char *g_program_name = nullptr; static void Warn(const flatbuffers::FlatCompiler *flatc, - const std::string &warn, - bool show_exe_name) { + const std::string &warn, bool show_exe_name) { (void)flatc; - if (show_exe_name) { - printf("%s: ", g_program_name); - } + if (show_exe_name) { printf("%s: ", g_program_name); } printf("warning: %s\n", warn.c_str()); } static void Error(const flatbuffers::FlatCompiler *flatc, - const std::string &err, - bool usage, - bool show_exe_name) { - if (show_exe_name) { - printf("%s: ", g_program_name); - } + const std::string &err, bool usage, bool show_exe_name) { + if (show_exe_name) { printf("%s: ", g_program_name); } printf("error: %s\n", err.c_str()); - if (usage) { - printf("%s", flatc->GetUsageString(g_program_name).c_str()); - } + if (usage) { printf("%s", flatc->GetUsageString(g_program_name).c_str()); } exit(1); } @@ -46,61 +37,43 @@ int main(int argc, const char *argv[]) { g_program_name = argv[0]; const flatbuffers::FlatCompiler::Generator generators[] = { - { flatbuffers::GenerateBinary, "-b", "--binary", "binary", false, - nullptr, + { flatbuffers::GenerateBinary, "-b", "--binary", "binary", false, nullptr, flatbuffers::IDLOptions::kBinary, "Generate wire format binaries for any data definitions", flatbuffers::BinaryMakeRule }, - { flatbuffers::GenerateTextFile, "-t", "--json", "text", false, - nullptr, + { flatbuffers::GenerateTextFile, "-t", "--json", "text", false, nullptr, flatbuffers::IDLOptions::kJson, "Generate text output for any data definitions", flatbuffers::TextMakeRule }, - { flatbuffers::GenerateCPP, "-c", "--cpp", "C++", true, - flatbuffers::GenerateCppGRPC, - flatbuffers::IDLOptions::kCpp, - "Generate C++ headers for tables/structs", - flatbuffers::CPPMakeRule }, - { flatbuffers::GenerateGo, "-g", "--go", "Go", true, - flatbuffers::GenerateGoGRPC, - flatbuffers::IDLOptions::kGo, - "Generate Go files for tables/structs", - flatbuffers::GeneralMakeRule }, - { flatbuffers::GenerateGeneral, "-j", "--java", "Java", true, - flatbuffers::GenerateJavaGRPC, - flatbuffers::IDLOptions::kJava, + { flatbuffers::GenerateCPP, "-c", "--cpp", "C++", true, + flatbuffers::GenerateCppGRPC, flatbuffers::IDLOptions::kCpp, + "Generate C++ headers for tables/structs", flatbuffers::CPPMakeRule }, + { flatbuffers::GenerateGo, "-g", "--go", "Go", true, + flatbuffers::GenerateGoGRPC, flatbuffers::IDLOptions::kGo, + "Generate Go files for tables/structs", flatbuffers::GeneralMakeRule }, + { flatbuffers::GenerateGeneral, "-j", "--java", "Java", true, + flatbuffers::GenerateJavaGRPC, flatbuffers::IDLOptions::kJava, "Generate Java classes for tables/structs", flatbuffers::GeneralMakeRule }, - { flatbuffers::GenerateJS, "-s", "--js", "JavaScript", true, - nullptr, + { flatbuffers::GenerateJS, "-s", "--js", "JavaScript", true, nullptr, flatbuffers::IDLOptions::kJs, - "Generate JavaScript code for tables/structs", - flatbuffers::JSMakeRule }, - { flatbuffers::GenerateJS, "-T", "--ts", "TypeScript", true, - nullptr, + "Generate JavaScript code for tables/structs", flatbuffers::JSMakeRule }, + { flatbuffers::GenerateJS, "-T", "--ts", "TypeScript", true, nullptr, flatbuffers::IDLOptions::kTs, - "Generate TypeScript code for tables/structs", - flatbuffers::JSMakeRule }, - { flatbuffers::GenerateGeneral, "-n", "--csharp", "C#", true, - nullptr, + "Generate TypeScript code for tables/structs", flatbuffers::JSMakeRule }, + { flatbuffers::GenerateGeneral, "-n", "--csharp", "C#", true, nullptr, flatbuffers::IDLOptions::kCSharp, - "Generate C# classes for tables/structs", - flatbuffers::GeneralMakeRule }, - { flatbuffers::GeneratePython, "-p", "--python", "Python", true, - nullptr, + "Generate C# classes for tables/structs", flatbuffers::GeneralMakeRule }, + { flatbuffers::GeneratePython, "-p", "--python", "Python", true, nullptr, flatbuffers::IDLOptions::kPython, "Generate Python files for tables/structs", flatbuffers::GeneralMakeRule }, - { flatbuffers::GeneratePhp, nullptr, "--php", "PHP", true, - nullptr, - flatbuffers::IDLOptions::kPhp, - "Generate PHP files for tables/structs", - flatbuffers::GeneralMakeRule }, - { flatbuffers::GenerateJsonSchema, nullptr, "--jsonschema", "JsonSchema", true, - nullptr, - flatbuffers::IDLOptions::kJsonSchema, - "Generate Json schema", + { flatbuffers::GeneratePhp, nullptr, "--php", "PHP", true, nullptr, + flatbuffers::IDLOptions::kPhp, "Generate PHP files for tables/structs", flatbuffers::GeneralMakeRule }, + { flatbuffers::GenerateJsonSchema, nullptr, "--jsonschema", "JsonSchema", + true, nullptr, flatbuffers::IDLOptions::kJsonSchema, + "Generate Json schema", flatbuffers::GeneralMakeRule }, }; flatbuffers::FlatCompiler::InitParams params; diff --git a/src/flathash.cpp b/src/flathash.cpp index 1a033f8ee..64e3f35bf 100644 --- a/src/flathash.cpp +++ b/src/flathash.cpp @@ -14,20 +14,16 @@ * limitations under the License. */ +#include #include #include #include #include "flatbuffers/hash.h" -#include -enum OutputFormat { - kDecimal, - kHexadecimal, - kHexadecimal0x -}; +enum OutputFormat { kDecimal, kHexadecimal, kHexadecimal0x }; -int main(int argc, char* argv[]) { - const char* name = argv[0]; +int main(int argc, char *argv[]) { + const char *name = argv[0]; if (argc <= 1) { printf("%s HASH [OPTION]... STRING... [-- STRING...]\n", name); printf("Available hashing algorithms:\n 32 bit:\n"); @@ -50,7 +46,7 @@ int main(int argc, char* argv[]) { return 0; } - const char* hash_algorithm = argv[1]; + const char *hash_algorithm = argv[1]; flatbuffers::NamedHashFunction::HashFunction hash_function32 = flatbuffers::FindHashFunction32(hash_algorithm); @@ -66,15 +62,21 @@ int main(int argc, char* argv[]) { bool annotate = false; bool escape_dash = false; for (int i = 2; i < argc; i++) { - const char* arg = argv[i]; + const char *arg = argv[i]; if (!escape_dash && arg[0] == '-') { std::string opt = arg; - if (opt == "-d") output_format = kDecimal; - else if (opt == "-x") output_format = kHexadecimal; - else if (opt == "-0x") output_format = kHexadecimal0x; - else if (opt == "-c") annotate = true; - else if (opt == "--") escape_dash = true; - else printf("Unrecognized argument: \"%s\"\n", arg); + if (opt == "-d") + output_format = kDecimal; + else if (opt == "-x") + output_format = kHexadecimal; + else if (opt == "-0x") + output_format = kHexadecimal0x; + else if (opt == "-c") + annotate = true; + else if (opt == "--") + escape_dash = true; + else + printf("Unrecognized argument: \"%s\"\n", arg); } else { std::stringstream ss; if (output_format == kDecimal) { @@ -90,8 +92,7 @@ int main(int argc, char* argv[]) { else if (hash_function64) ss << hash_function64(arg); - if (annotate) - ss << " /* \"" << arg << "\" */"; + if (annotate) ss << " /* \"" << arg << "\" */"; ss << "\n"; @@ -100,4 +101,3 @@ int main(int argc, char* argv[]) { } return 0; } - diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp index 8b2837953..6420ba722 100644 --- a/src/idl_gen_cpp.cpp +++ b/src/idl_gen_cpp.cpp @@ -16,17 +16,15 @@ // independent from idl_parser, since this code is not needed for most clients +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" namespace flatbuffers { // Pedantic warning free version of toupper(). -inline char ToUpper(char c) { - return static_cast(::toupper(c)); -} +inline char ToUpper(char c) { return static_cast(::toupper(c)); } static std::string GeneratedFileName(const std::string &path, const std::string &file_name) { @@ -40,23 +38,102 @@ class CppGenerator : public BaseGenerator { const std::string &file_name) : BaseGenerator(parser, path, file_name, "", "::"), cur_name_space_(nullptr) { - const char *keywords[] = { - "alignas", "alignof", "and", "and_eq", "asm", "atomic_cancel", - "atomic_commit", "atomic_noexcept", "auto", "bitand", "bitor", "bool", - "break", "case", "catch", "char", "char16_t", "char32_t", "class", - "compl", "concept", "const", "constexpr", "const_cast", "continue", - "co_await", "co_return", "co_yield", "decltype", "default", "delete", - "do", "double", "dynamic_cast", "else", "enum", "explicit", "export", - "extern", "false", "float", "for", "friend", "goto", "if", "import", - "inline", "int", "long", "module", "mutable", "namespace", "new", - "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", - "private", "protected", "public", "register", "reinterpret_cast", - "requires", "return", "short", "signed", "sizeof", "static", - "static_assert", "static_cast", "struct", "switch", "synchronized", - "template", "this", "thread_local", "throw", "true", "try", "typedef", - "typeid", "typename", "union", "unsigned", "using", "virtual", "void", - "volatile", "wchar_t", "while", "xor", "xor_eq", nullptr - }; + const char *keywords[] = { "alignas", + "alignof", + "and", + "and_eq", + "asm", + "atomic_cancel", + "atomic_commit", + "atomic_noexcept", + "auto", + "bitand", + "bitor", + "bool", + "break", + "case", + "catch", + "char", + "char16_t", + "char32_t", + "class", + "compl", + "concept", + "const", + "constexpr", + "const_cast", + "continue", + "co_await", + "co_return", + "co_yield", + "decltype", + "default", + "delete", + "do", + "double", + "dynamic_cast", + "else", + "enum", + "explicit", + "export", + "extern", + "false", + "float", + "for", + "friend", + "goto", + "if", + "import", + "inline", + "int", + "long", + "module", + "mutable", + "namespace", + "new", + "noexcept", + "not", + "not_eq", + "nullptr", + "operator", + "or", + "or_eq", + "private", + "protected", + "public", + "register", + "reinterpret_cast", + "requires", + "return", + "short", + "signed", + "sizeof", + "static", + "static_assert", + "static_cast", + "struct", + "switch", + "synchronized", + "template", + "this", + "thread_local", + "throw", + "true", + "try", + "typedef", + "typeid", + "typename", + "union", + "unsigned", + "using", + "virtual", + "void", + "volatile", + "wchar_t", + "while", + "xor", + "xor_eq", + nullptr }; for (auto kw = keywords; *kw; kw++) keywords_.insert(*kw); } @@ -91,8 +168,7 @@ class CppGenerator : public BaseGenerator { } for (auto it = parser_.included_files_.begin(); it != parser_.included_files_.end(); ++it) { - if (it->second.empty()) - continue; + if (it->second.empty()) continue; auto noext = flatbuffers::StripExtension(it->second); auto basename = flatbuffers::StripPath(noext); @@ -112,9 +188,7 @@ class CppGenerator : public BaseGenerator { return EscapeKeyword(def.name); } - std::string Name(const EnumVal &ev) const { - return EscapeKeyword(ev.name); - } + std::string Name(const EnumVal &ev) const { return EscapeKeyword(ev.name); } // Iterate through all definitions we haven't generate code for (enums, // structs, and tables) and output them to a single file. @@ -137,9 +211,7 @@ class CppGenerator : public BaseGenerator { } code_ += ""; - if (parser_.opts.include_dependence_headers) { - GenIncludeDependencies(); - } + if (parser_.opts.include_dependence_headers) { GenIncludeDependencies(); } assert(!cur_name_space_); @@ -242,8 +314,7 @@ class CppGenerator : public BaseGenerator { auto &struct_def = *parser_.root_struct_def_; SetNameSpace(struct_def.defined_namespace); auto name = Name(struct_def); - auto qualified_name = - cur_name_space_->GetFullyQualifiedName(name); + auto qualified_name = cur_name_space_->GetFullyQualifiedName(name); auto cpp_name = TranslateNameSpace(qualified_name); code_.SetValue("STRUCT_NAME", name); @@ -252,7 +323,9 @@ class CppGenerator : public BaseGenerator { // The root datatype accessor: code_ += "inline \\"; - code_ += "const {{CPP_NAME}} *{{NULLABLE_EXT}}Get{{STRUCT_NAME}}(const void *buf) {"; + code_ += + "const {{CPP_NAME}} *{{NULLABLE_EXT}}Get{{STRUCT_NAME}}(const void " + "*buf) {"; code_ += " return flatbuffers::GetRoot<{{CPP_NAME}}>(buf);"; code_ += "}"; code_ += ""; @@ -373,10 +446,12 @@ class CppGenerator : public BaseGenerator { // Return a C++ type from the table in idl.h std::string GenTypeBasic(const Type &type, bool user_facing_type) const { static const char *ctypename[] = { + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #CTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD + // clang-format on }; if (user_facing_type) { if (type.enum_def) return WrapInNameSpace(*type.enum_def); @@ -401,9 +476,7 @@ class CppGenerator : public BaseGenerator { } case BASE_TYPE_UNION: // fall through - default: { - return "void"; - } + default: { return "void"; } } } @@ -436,8 +509,10 @@ class CppGenerator : public BaseGenerator { return parser_.opts.gen_nullable ? " _Nullable " : ""; } - static std::string NativeName(const std::string &name, const StructDef *sd, const IDLOptions & opts) { - return sd && !sd->fixed ? opts.object_prefix + name + opts.object_suffix : name; + static std::string NativeName(const std::string &name, const StructDef *sd, + const IDLOptions &opts) { + return sd && !sd->fixed ? opts.object_prefix + name + opts.object_suffix + : name; } const std::string &PtrType(const FieldDef *field) { @@ -448,9 +523,7 @@ class CppGenerator : public BaseGenerator { const std::string NativeString(const FieldDef *field) { auto attr = field ? field->attributes.Lookup("cpp_str_type") : nullptr; auto &ret = attr ? attr->constant : parser_.opts.cpp_object_api_string_type; - if (ret.empty()) { - return "std::string"; - } + if (ret.empty()) { return "std::string"; } return ret; } @@ -479,35 +552,35 @@ class CppGenerator : public BaseGenerator { } case BASE_TYPE_VECTOR: { const auto type_name = GenTypeNative(type.VectorType(), true, field); - if (type.struct_def && type.struct_def->attributes.Lookup("native_custom_alloc")) { - auto native_custom_alloc = type.struct_def->attributes.Lookup("native_custom_alloc"); - return "std::vector<" + type_name + "," + native_custom_alloc->constant + "<" + type_name + ">>"; - } else + if (type.struct_def && + type.struct_def->attributes.Lookup("native_custom_alloc")) { + auto native_custom_alloc = + type.struct_def->attributes.Lookup("native_custom_alloc"); + return "std::vector<" + type_name + "," + + native_custom_alloc->constant + "<" + type_name + ">>"; + } else return "std::vector<" + type_name + ">"; } case BASE_TYPE_STRUCT: { auto type_name = WrapInNameSpace(*type.struct_def); if (IsStruct(type)) { auto native_type = type.struct_def->attributes.Lookup("native_type"); - if (native_type) { - type_name = native_type->constant; - } + if (native_type) { type_name = native_type->constant; } if (invector || field.native_inline) { return type_name; } else { return GenTypeNativePtr(type_name, &field, false); } } else { - return GenTypeNativePtr(NativeName(type_name, type.struct_def, parser_.opts), - &field, false); + return GenTypeNativePtr( + NativeName(type_name, type.struct_def, parser_.opts), &field, + false); } } case BASE_TYPE_UNION: { return type.enum_def->name + "Union"; } - default: { - return GenTypeBasic(type, true); - } + default: { return GenTypeBasic(type, true); } } } @@ -554,13 +627,12 @@ class CppGenerator : public BaseGenerator { bool native_type = false) { if (ev.union_type.base_type == BASE_TYPE_STRUCT) { auto name = actual_type ? ev.union_type.struct_def->name : Name(ev); - return wrap - ? WrapInNameSpace(ev.union_type.struct_def->defined_namespace, name) - : name; + return wrap ? WrapInNameSpace(ev.union_type.struct_def->defined_namespace, + name) + : name; } else if (ev.union_type.base_type == BASE_TYPE_STRING) { - return actual_type - ? (native_type ? "std::string" : "flatbuffers::String") - : Name(ev); + return actual_type ? (native_type ? "std::string" : "flatbuffers::String") + : Name(ev); } else { assert(false); return Name(ev); @@ -580,10 +652,8 @@ class CppGenerator : public BaseGenerator { "const flatbuffers::Vector *types)"; } - std::string UnionUnPackSignature(const EnumDef &enum_def, - bool inclass) { - return (inclass ? "static " : "") + - std::string("void *") + + std::string UnionUnPackSignature(const EnumDef &enum_def, bool inclass) { + return (inclass ? "static " : "") + std::string("void *") + (inclass ? "" : Name(enum_def) + "Union::") + "UnPack(const void *obj, " + Name(enum_def) + " type, const flatbuffers::resolver_function_t *resolver)"; @@ -597,43 +667,37 @@ class CppGenerator : public BaseGenerator { (inclass ? " = nullptr" : "") + ") const"; } - std::string TableCreateSignature(const StructDef &struct_def, - bool predecl, - const IDLOptions & opts) { + std::string TableCreateSignature(const StructDef &struct_def, bool predecl, + const IDLOptions &opts) { return "flatbuffers::Offset<" + Name(struct_def) + "> Create" + - Name(struct_def) + - "(flatbuffers::FlatBufferBuilder &_fbb, const " + + Name(struct_def) + "(flatbuffers::FlatBufferBuilder &_fbb, const " + NativeName(Name(struct_def), &struct_def, opts) + " *_o, const flatbuffers::rehasher_function_t *_rehasher" + (predecl ? " = nullptr" : "") + ")"; } - std::string TablePackSignature(const StructDef &struct_def, - bool inclass, - const IDLOptions & opts) { - return std::string(inclass ? "static " : "") + - "flatbuffers::Offset<" + Name(struct_def) + "> " + - (inclass ? "" : Name(struct_def) + "::") + - "Pack(flatbuffers::FlatBufferBuilder &_fbb, " + - "const " + NativeName(Name(struct_def), &struct_def, opts) + "* _o, " + + std::string TablePackSignature(const StructDef &struct_def, bool inclass, + const IDLOptions &opts) { + return std::string(inclass ? "static " : "") + "flatbuffers::Offset<" + + Name(struct_def) + "> " + (inclass ? "" : Name(struct_def) + "::") + + "Pack(flatbuffers::FlatBufferBuilder &_fbb, " + "const " + + NativeName(Name(struct_def), &struct_def, opts) + "* _o, " + "const flatbuffers::rehasher_function_t *_rehasher" + (inclass ? " = nullptr" : "") + ")"; } - std::string TableUnPackSignature(const StructDef &struct_def, - bool inclass, - const IDLOptions & opts) { + std::string TableUnPackSignature(const StructDef &struct_def, bool inclass, + const IDLOptions &opts) { return NativeName(Name(struct_def), &struct_def, opts) + " *" + (inclass ? "" : Name(struct_def) + "::") + "UnPack(const flatbuffers::resolver_function_t *_resolver" + (inclass ? " = nullptr" : "") + ") const"; } - std::string TableUnPackToSignature(const StructDef &struct_def, - bool inclass, - const IDLOptions & opts) { - return "void " + (inclass ? "" : Name(struct_def) + "::") + - "UnPackTo(" + NativeName(Name(struct_def), &struct_def, opts) + " *" + + std::string TableUnPackToSignature(const StructDef &struct_def, bool inclass, + const IDLOptions &opts) { + return "void " + (inclass ? "" : Name(struct_def) + "::") + "UnPackTo(" + + NativeName(Name(struct_def), &struct_def, opts) + " *" + "_o, const flatbuffers::resolver_function_t *_resolver" + (inclass ? " = nullptr" : "") + ") const"; } @@ -644,15 +708,13 @@ class CppGenerator : public BaseGenerator { code_ += ""; } - void GenMiniReflect(const StructDef *struct_def, - const EnumDef *enum_def) { + void GenMiniReflect(const StructDef *struct_def, const EnumDef *enum_def) { code_.SetValue("NAME", struct_def ? struct_def->name : enum_def->name); - code_.SetValue("SEQ_TYPE", struct_def - ? (struct_def->fixed ? "ST_STRUCT" : "ST_TABLE") - : (enum_def->is_union ? "ST_UNION" : "ST_ENUM")); - auto num_fields = struct_def - ? struct_def->fields.vec.size() - : enum_def->vals.vec.size(); + code_.SetValue("SEQ_TYPE", + struct_def ? (struct_def->fixed ? "ST_STRUCT" : "ST_TABLE") + : (enum_def->is_union ? "ST_UNION" : "ST_ENUM")); + auto num_fields = + struct_def ? struct_def->fields.vec.size() : enum_def->vals.vec.size(); code_.SetValue("NUM_FIELDS", NumToString(num_fields)); std::vector names; std::vector types; @@ -684,14 +746,13 @@ class CppGenerator : public BaseGenerator { auto is_vector = type.base_type == BASE_TYPE_VECTOR; auto bt = is_vector ? type.element : type.base_type; auto et = IsScalar(bt) || bt == BASE_TYPE_STRING - ? bt - BASE_TYPE_UTYPE + ET_UTYPE - : ET_SEQUENCE; + ? bt - BASE_TYPE_UTYPE + ET_UTYPE + : ET_SEQUENCE; int ref_idx = -1; - std::string ref_name = type.struct_def - ? WrapInNameSpace(*type.struct_def) - : type.enum_def - ? WrapInNameSpace(*type.enum_def) - : ""; + std::string ref_name = + type.struct_def + ? WrapInNameSpace(*type.struct_def) + : type.enum_def ? WrapInNameSpace(*type.enum_def) : ""; if (!ref_name.empty()) { auto rit = type_refs.begin(); for (; rit != type_refs.end(); ++rit) { @@ -753,8 +814,8 @@ class CppGenerator : public BaseGenerator { if (!vs.empty()) { code_ += " static const int32_t values[] = { {{VALUES}} };"; } - auto has_names = num_fields && - parser_.opts.mini_reflect == IDLOptions::kTypesAndNames; + auto has_names = + num_fields && parser_.opts.mini_reflect == IDLOptions::kTypesAndNames; if (has_names) { code_ += " static const char *names[] = {"; code_ += " {{NAMES}}"; @@ -763,7 +824,7 @@ class CppGenerator : public BaseGenerator { code_ += " static flatbuffers::TypeTable tt = {"; code_ += std::string(" flatbuffers::{{SEQ_TYPE}}, {{NUM_FIELDS}}, ") + (num_fields ? "type_codes, " : "nullptr, ") + - (!type_refs.empty() ? "type_refs, ": "nullptr, " ) + + (!type_refs.empty() ? "type_refs, " : "nullptr, ") + (!vs.empty() ? "values, " : "nullptr, ") + (has_names ? "names" : "nullptr"); code_ += " };"; @@ -782,8 +843,7 @@ class CppGenerator : public BaseGenerator { GenComment(enum_def.doc_comment); code_ += GenEnumDecl(enum_def) + "\\"; - if (parser_.opts.scoped_enums) - code_ += " : {{BASE_TYPE}}\\"; + if (parser_.opts.scoped_enums) code_ += " : {{BASE_TYPE}}\\"; code_ += " {"; int64_t anyv = 0; @@ -816,11 +876,11 @@ class CppGenerator : public BaseGenerator { code_.SetValue("VALUE", NumToString(anyv)); code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; } else { // MIN & MAX are useless for bit_flags - code_.SetValue("KEY",GenEnumValDecl(enum_def, "MIN")); + code_.SetValue("KEY", GenEnumValDecl(enum_def, "MIN")); code_.SetValue("VALUE", GenEnumValDecl(enum_def, minv->name)); code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; - code_.SetValue("KEY",GenEnumValDecl(enum_def, "MAX")); + code_.SetValue("KEY", GenEnumValDecl(enum_def, "MAX")); code_.SetValue("VALUE", GenEnumValDecl(enum_def, maxv->name)); code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\"; } @@ -835,14 +895,15 @@ class CppGenerator : public BaseGenerator { // Generate an array of all enumeration values auto num_fields = NumToString(enum_def.vals.vec.size()); - code_ += "inline {{ENUM_NAME}} (&EnumValues{{ENUM_NAME}}())[" + num_fields + "] {"; + code_ += "inline {{ENUM_NAME}} (&EnumValues{{ENUM_NAME}}())[" + num_fields + + "] {"; code_ += " static {{ENUM_NAME}} values[] = {"; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; auto value = GetEnumValUse(enum_def, ev); auto suffix = *it != enum_def.vals.vec.back() ? "," : ""; - code_ += " " + value + suffix; + code_ += " " + value + suffix; } code_ += " };"; code_ += " return values;"; @@ -867,9 +928,7 @@ class CppGenerator : public BaseGenerator { for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - while (val++ != ev.value) { - code_ += " \"\","; - } + while (val++ != ev.value) { code_ += " \"\","; } code_ += " \"" + Name(ev) + "\","; } code_ += " nullptr"; @@ -896,13 +955,12 @@ class CppGenerator : public BaseGenerator { // Generate type traits for unions to map from a type to union enum value. if (enum_def.is_union && !enum_def.uses_type_aliases) { for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); - ++it) { + ++it) { const auto &ev = **it; if (it == enum_def.vals.vec.begin()) { code_ += "template struct {{ENUM_NAME}}Traits {"; - } - else { + } else { auto name = GetUnionElement(ev, true, true); code_ += "template<> struct {{ENUM_NAME}}Traits<" + name + "> {"; } @@ -918,7 +976,7 @@ class CppGenerator : public BaseGenerator { // Generate a union type code_.SetValue("NAME", Name(enum_def)); code_.SetValue("NONE", - GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"))); + GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"))); code_ += "struct {{NAME}}Union {"; code_ += " {{NAME}} type;"; @@ -929,10 +987,17 @@ class CppGenerator : public BaseGenerator { code_ += " type({{NONE}}), value(nullptr)"; code_ += " { std::swap(type, u.type); std::swap(value, u.value); }"; code_ += " {{NAME}}Union(const {{NAME}}Union &) FLATBUFFERS_NOEXCEPT;"; - code_ += " {{NAME}}Union &operator=(const {{NAME}}Union &u) FLATBUFFERS_NOEXCEPT"; - code_ += " { {{NAME}}Union t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }"; - code_ += " {{NAME}}Union &operator=({{NAME}}Union &&u) FLATBUFFERS_NOEXCEPT"; - code_ += " { std::swap(type, u.type); std::swap(value, u.value); return *this; }"; + code_ += + " {{NAME}}Union &operator=(const {{NAME}}Union &u) " + "FLATBUFFERS_NOEXCEPT"; + code_ += + " { {{NAME}}Union t(u); std::swap(type, t.type); std::swap(value, " + "t.value); return *this; }"; + code_ += + " {{NAME}}Union &operator=({{NAME}}Union &&u) FLATBUFFERS_NOEXCEPT"; + code_ += + " { std::swap(type, u.type); std::swap(value, u.value); return " + "*this; }"; code_ += " ~{{NAME}}Union() { Reset(); }"; code_ += ""; code_ += " void Reset();"; @@ -942,7 +1007,8 @@ class CppGenerator : public BaseGenerator { code_ += " template "; code_ += " void Set(T&& val) {"; code_ += " Reset();"; - code_ += " type = {{NAME}}Traits::enum_value;"; + code_ += + " type = {{NAME}}Traits::enum_value;"; code_ += " if (type != {{NONE}}) {"; code_ += " value = new T(std::forward(val));"; code_ += " }"; @@ -957,9 +1023,7 @@ class CppGenerator : public BaseGenerator { for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - if (!ev.value) { - continue; - } + if (!ev.value) { continue; } const auto native_type = NativeName(GetUnionElement(ev, true, true, true), @@ -975,7 +1039,8 @@ class CppGenerator : public BaseGenerator { code_ += " const {{NATIVE_TYPE}} *As{{NATIVE_NAME}}() const {"; code_ += " return type == {{NATIVE_ID}} ?"; - code_ += " reinterpret_cast(value) : nullptr;"; + code_ += + " reinterpret_cast(value) : nullptr;"; code_ += " }"; } code_ += "};"; @@ -1038,7 +1103,8 @@ class CppGenerator : public BaseGenerator { code_ += " if (values->size() != types->size()) return false;"; code_ += " for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {"; code_ += " if (!Verify" + Name(enum_def) + "("; - code_ += " verifier, values->Get(i), types->GetEnum<" + Name(enum_def) + ">(i))) {"; + code_ += " verifier, values->Get(i), types->GetEnum<" + + Name(enum_def) + ">(i))) {"; code_ += " return false;"; code_ += " }"; code_ += " }"; @@ -1053,9 +1119,7 @@ class CppGenerator : public BaseGenerator { for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - if (!ev.value) { - continue; - } + if (!ev.value) { continue; } code_.SetValue("LABEL", GetEnumValUse(enum_def, ev)); code_.SetValue("TYPE", GetUnionElement(ev, true, true)); @@ -1085,13 +1149,12 @@ class CppGenerator : public BaseGenerator { for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { auto &ev = **it; - if (!ev.value) { - continue; - } + if (!ev.value) { continue; } code_.SetValue("LABEL", GetEnumValUse(enum_def, ev)); - code_.SetValue("TYPE", NativeName(GetUnionElement(ev, true, true, true), - ev.union_type.struct_def, parser_.opts)); + code_.SetValue("TYPE", + NativeName(GetUnionElement(ev, true, true, true), + ev.union_type.struct_def, parser_.opts)); code_.SetValue("NAME", GetUnionElement(ev, false, true)); code_ += " case {{LABEL}}: {"; code_ += " auto ptr = reinterpret_cast(value);"; @@ -1115,19 +1178,19 @@ class CppGenerator : public BaseGenerator { code_ += ""; // Union copy constructor - code_ += "inline {{ENUM_NAME}}Union::{{ENUM_NAME}}Union(const " - "{{ENUM_NAME}}Union &u) FLATBUFFERS_NOEXCEPT : type(u.type), " - "value(nullptr) {"; + code_ += + "inline {{ENUM_NAME}}Union::{{ENUM_NAME}}Union(const " + "{{ENUM_NAME}}Union &u) FLATBUFFERS_NOEXCEPT : type(u.type), " + "value(nullptr) {"; code_ += " switch (type) {"; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - if (!ev.value) { - continue; - } + if (!ev.value) { continue; } code_.SetValue("LABEL", GetEnumValUse(enum_def, ev)); - code_.SetValue("TYPE", NativeName(GetUnionElement(ev, true, true, true), - ev.union_type.struct_def, parser_.opts)); + code_.SetValue("TYPE", + NativeName(GetUnionElement(ev, true, true, true), + ev.union_type.struct_def, parser_.opts)); code_ += " case {{LABEL}}: {"; bool copyable = true; if (ev.union_type.base_type == BASE_TYPE_STRUCT) { @@ -1143,8 +1206,9 @@ class CppGenerator : public BaseGenerator { } } if (copyable) { - code_ += " value = new {{TYPE}}(*reinterpret_cast<{{TYPE}} *>" - "(u.value));"; + code_ += + " value = new {{TYPE}}(*reinterpret_cast<{{TYPE}} *>" + "(u.value));"; } else { code_ += " assert(false); // {{TYPE}} not copyable."; } @@ -1159,19 +1223,18 @@ class CppGenerator : public BaseGenerator { // Union Reset() function. code_.SetValue("NONE", - GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"))); + GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"))); code_ += "inline void {{ENUM_NAME}}Union::Reset() {"; code_ += " switch (type) {"; for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { const auto &ev = **it; - if (!ev.value) { - continue; - } + if (!ev.value) { continue; } code_.SetValue("LABEL", GetEnumValUse(enum_def, ev)); - code_.SetValue("TYPE", NativeName(GetUnionElement(ev, true, true, true), - ev.union_type.struct_def, parser_.opts)); + code_.SetValue("TYPE", + NativeName(GetUnionElement(ev, true, true, true), + ev.union_type.struct_def, parser_.opts)); code_ += " case {{LABEL}}: {"; code_ += " auto ptr = reinterpret_cast<{{TYPE}} *>(value);"; code_ += " delete ptr;"; @@ -1213,9 +1276,7 @@ class CppGenerator : public BaseGenerator { void GenFullyQualifiedNameGetter(const StructDef &struct_def, const std::string &name) { - if (!parser_.opts.generate_name_strings) { - return; - } + if (!parser_.opts.generate_name_strings) { return; } auto fullname = struct_def.defined_namespace->GetFullyQualifiedName(name); code_.SetValue("NAME", fullname); code_.SetValue("CONSTEXPR", "FLATBUFFERS_CONSTEXPR"); @@ -1235,9 +1296,8 @@ class CppGenerator : public BaseGenerator { auto ev = field.value.type.enum_def->ReverseLookup( static_cast(StringToInt(field.value.constant.c_str())), false); if (ev) { - return WrapInNameSpace( - field.value.type.enum_def->defined_namespace, - GetEnumValUse(*field.value.type.enum_def, *ev)); + return WrapInNameSpace(field.value.type.enum_def->defined_namespace, + GetEnumValUse(*field.value.type.enum_def, *ev)); } else { return GenUnderlyingCast(field, true, field.value.constant); } @@ -1282,7 +1342,7 @@ class CppGenerator : public BaseGenerator { // Generate the default constructor for this struct. Properly initialize all // scalar members with default values. - void GenDefaultConstructor(const StructDef& struct_def) { + void GenDefaultConstructor(const StructDef &struct_def) { std::string initializer_list; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { @@ -1292,9 +1352,7 @@ class CppGenerator : public BaseGenerator { auto cpp_type = field.attributes.Lookup("cpp_type"); // Scalar types get parsed defaults, raw pointers get nullptrs. if (IsScalar(field.value.type.base_type)) { - if (!initializer_list.empty()) { - initializer_list += ",\n "; - } + if (!initializer_list.empty()) { initializer_list += ",\n "; } initializer_list += Name(field); initializer_list += "(" + GetDefaultScalarValue(field) + ")"; } else if (field.value.type.base_type == BASE_TYPE_STRUCT) { @@ -1309,9 +1367,7 @@ class CppGenerator : public BaseGenerator { } } } else if (cpp_type) { - if (!initializer_list.empty()) { - initializer_list += ",\n "; - } + if (!initializer_list.empty()) { initializer_list += ",\n "; } initializer_list += Name(field) + "(0)"; } } @@ -1320,26 +1376,32 @@ class CppGenerator : public BaseGenerator { initializer_list = "\n : " + initializer_list; } - code_.SetValue("NATIVE_NAME", NativeName(Name(struct_def), &struct_def, parser_.opts)); + code_.SetValue("NATIVE_NAME", + NativeName(Name(struct_def), &struct_def, parser_.opts)); code_.SetValue("INIT_LIST", initializer_list); code_ += " {{NATIVE_NAME}}(){{INIT_LIST}} {"; code_ += " }"; } - void GenOperatorNewDelete(const StructDef & struct_def) { - if (auto native_custom_alloc = struct_def.attributes.Lookup("native_custom_alloc")) { + void GenOperatorNewDelete(const StructDef &struct_def) { + if (auto native_custom_alloc = + struct_def.attributes.Lookup("native_custom_alloc")) { code_ += " inline void *operator new (std::size_t count) {"; - code_ += " return " + native_custom_alloc->constant + "<{{NATIVE_NAME}}>().allocate(count / sizeof({{NATIVE_NAME}}));"; + code_ += " return " + native_custom_alloc->constant + + "<{{NATIVE_NAME}}>().allocate(count / sizeof({{NATIVE_NAME}}));"; code_ += " }"; code_ += " inline void operator delete (void *ptr) {"; - code_ += " return " + native_custom_alloc->constant + "<{{NATIVE_NAME}}>().deallocate(static_cast<{{NATIVE_NAME}}*>(ptr),1);"; + code_ += " return " + native_custom_alloc->constant + + "<{{NATIVE_NAME}}>().deallocate(static_cast<{{NATIVE_NAME}}*>(" + "ptr),1);"; code_ += " }"; } } void GenNativeTable(const StructDef &struct_def) { - const auto native_name = NativeName(Name(struct_def), &struct_def, parser_.opts); + const auto native_name = + NativeName(Name(struct_def), &struct_def, parser_.opts); code_.SetValue("STRUCT_NAME", Name(struct_def)); code_.SetValue("NATIVE_NAME", native_name); @@ -1358,7 +1420,7 @@ class CppGenerator : public BaseGenerator { } // Generate the code to call the appropriate Verify function(s) for a field. - void GenVerifyCall(const FieldDef &field, const char* prefix) { + void GenVerifyCall(const FieldDef &field, const char *prefix) { code_.SetValue("PRE", prefix); code_.SetValue("NAME", Name(field)); code_.SetValue("REQUIRED", field.required ? "Required" : ""); @@ -1375,8 +1437,9 @@ class CppGenerator : public BaseGenerator { case BASE_TYPE_UNION: { code_.SetValue("ENUM_NAME", field.value.type.enum_def->name); code_.SetValue("SUFFIX", UnionTypeFieldSuffix()); - code_ += "{{PRE}}Verify{{ENUM_NAME}}(verifier, {{NAME}}(), " - "{{NAME}}{{SUFFIX}}())\\"; + code_ += + "{{PRE}}Verify{{ENUM_NAME}}(verifier, {{NAME}}(), " + "{{NAME}}{{SUFFIX}}())\\"; break; } case BASE_TYPE_STRUCT: { @@ -1405,33 +1468,31 @@ class CppGenerator : public BaseGenerator { } case BASE_TYPE_UNION: { code_.SetValue("ENUM_NAME", field.value.type.enum_def->name); - code_ += "{{PRE}}Verify{{ENUM_NAME}}Vector(verifier, {{NAME}}(), {{NAME}}_type())\\"; + code_ += + "{{PRE}}Verify{{ENUM_NAME}}Vector(verifier, {{NAME}}(), " + "{{NAME}}_type())\\"; break; } - default: - break; + default: break; } break; } - default: { - break; - } + default: { break; } } } // Generate an accessor struct, builder structs & function for a table. void GenTable(const StructDef &struct_def) { - if (parser_.opts.generate_object_based_api) { - GenNativeTable(struct_def); - } + if (parser_.opts.generate_object_based_api) { GenNativeTable(struct_def); } // Generate an accessor struct, with methods of the form: // type name() const { return GetField(offset, defaultval); } GenComment(struct_def.doc_comment); code_.SetValue("STRUCT_NAME", Name(struct_def)); - code_ += "struct {{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS" - " : private flatbuffers::Table {"; + code_ += + "struct {{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS" + " : private flatbuffers::Table {"; if (parser_.opts.generate_object_based_api) { code_ += " typedef {{NATIVE_NAME}} NativeTableType;"; } @@ -1489,15 +1550,13 @@ class CppGenerator : public BaseGenerator { auto call = accessor + offset_type + ">(" + offset_str; // Default value as second arg for non-pointer types. - if (is_scalar) { - call += ", " + GenDefaultConstant(field); - } + if (is_scalar) { call += ", " + GenDefaultConstant(field); } call += ")"; std::string afterptr = " *" + NullableExtension(); GenComment(field.doc_comment, " "); - code_.SetValue("FIELD_TYPE", - GenTypeGet(field.value.type, " ", "const ", afterptr.c_str(), true)); + code_.SetValue("FIELD_TYPE", GenTypeGet(field.value.type, " ", "const ", + afterptr.c_str(), true)); code_.SetValue("FIELD_VALUE", GenUnderlyingCast(field, true, call)); code_.SetValue("NULLABLE_EXT", NullableExtension()); @@ -1508,31 +1567,31 @@ class CppGenerator : public BaseGenerator { if (field.value.type.base_type == BASE_TYPE_UNION) { auto u = field.value.type.enum_def; - code_ += " template " - "const T *{{NULLABLE_EXT}}{{FIELD_NAME}}_as() const;"; + code_ += + " template " + "const T *{{NULLABLE_EXT}}{{FIELD_NAME}}_as() const;"; - for (auto u_it = u->vals.vec.begin(); - u_it != u->vals.vec.end(); ++u_it) { + for (auto u_it = u->vals.vec.begin(); u_it != u->vals.vec.end(); + ++u_it) { auto &ev = **u_it; - if (ev.union_type.base_type == BASE_TYPE_NONE) { - continue; - } + if (ev.union_type.base_type == BASE_TYPE_NONE) { continue; } auto full_struct_name = GetUnionElement(ev, true, true); // @TODO: Mby make this decisions more universal? How? code_.SetValue("U_GET_TYPE", Name(field) + UnionTypeFieldSuffix()); - code_.SetValue("U_ELEMENT_TYPE", WrapInNameSpace( - u->defined_namespace, GetEnumValUse(*u, ev))); + code_.SetValue( + "U_ELEMENT_TYPE", + WrapInNameSpace(u->defined_namespace, GetEnumValUse(*u, ev))); code_.SetValue("U_FIELD_TYPE", "const " + full_struct_name + " *"); - code_.SetValue("U_FIELD_NAME", - Name(field) + "_as_" + Name(ev)); + code_.SetValue("U_FIELD_NAME", Name(field) + "_as_" + Name(ev)); code_.SetValue("U_NULLABLE", NullableExtension()); // `const Type *union_name_asType() const` accessor. code_ += " {{U_FIELD_TYPE}}{{U_NULLABLE}}{{U_FIELD_NAME}}() const {"; - code_ += " return {{U_GET_TYPE}}() == {{U_ELEMENT_TYPE}} ? " - "static_cast<{{U_FIELD_TYPE}}>({{FIELD_NAME}}()) " - ": nullptr;"; + code_ += + " return {{U_GET_TYPE}}() == {{U_ELEMENT_TYPE}} ? " + "static_cast<{{U_FIELD_TYPE}}>({{FIELD_NAME}}()) " + ": nullptr;"; code_ += " }"; } } @@ -1544,20 +1603,24 @@ class CppGenerator : public BaseGenerator { code_.SetValue("OFFSET_NAME", offset_str); code_.SetValue("FIELD_TYPE", GenTypeBasic(field.value.type, true)); code_.SetValue("FIELD_VALUE", - GenUnderlyingCast(field, false, "_" + Name(field))); + GenUnderlyingCast(field, false, "_" + Name(field))); code_.SetValue("DEFAULT_VALUE", GenDefaultConstant(field)); - code_ += " bool mutate_{{FIELD_NAME}}({{FIELD_TYPE}} " - "_{{FIELD_NAME}}) {"; - code_ += " return {{SET_FN}}({{OFFSET_NAME}}, {{FIELD_VALUE}}, {{DEFAULT_VALUE}});"; + code_ += + " bool mutate_{{FIELD_NAME}}({{FIELD_TYPE}} " + "_{{FIELD_NAME}}) {"; + code_ += + " return {{SET_FN}}({{OFFSET_NAME}}, {{FIELD_VALUE}}, " + "{{DEFAULT_VALUE}});"; code_ += " }"; } else { auto postptr = " *" + NullableExtension(); - auto type = GenTypeGet(field.value.type, " ", "", postptr.c_str(), true); + auto type = + GenTypeGet(field.value.type, " ", "", postptr.c_str(), true); auto underlying = accessor + type + ">(" + offset_str + ")"; code_.SetValue("FIELD_TYPE", type); code_.SetValue("FIELD_VALUE", - GenUnderlyingCast(field, true, underlying)); + GenUnderlyingCast(field, true, underlying)); code_ += " {{FIELD_TYPE}}mutable_{{FIELD_NAME}}() {"; code_ += " return {{FIELD_VALUE}};"; @@ -1568,8 +1631,7 @@ class CppGenerator : public BaseGenerator { auto nested = field.attributes.Lookup("nested_flatbuffer"); if (nested) { std::string qualified_name = - parser_.current_namespace_->GetFullyQualifiedName( - nested->constant); + parser_.current_namespace_->GetFullyQualifiedName(nested->constant); auto nested_root = parser_.LookupStruct(qualified_name); assert(nested_root); // Guaranteed to exist by parser. (void)nested_root; @@ -1582,8 +1644,9 @@ class CppGenerator : public BaseGenerator { } if (field.flexbuffer) { - code_ += " flexbuffers::Reference {{FIELD_NAME}}_flexbuffer_root()" - " const {"; + code_ += + " flexbuffers::Reference {{FIELD_NAME}}_flexbuffer_root()" + " const {"; code_ += " auto v = {{FIELD_NAME}}();"; code_ += " return flexbuffers::GetRoot(v->Data(), v->size());"; code_ += " }"; @@ -1634,9 +1697,7 @@ class CppGenerator : public BaseGenerator { for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (field.deprecated) { - continue; - } + if (field.deprecated) { continue; } GenVerifyCall(field, " &&\n "); } @@ -1645,8 +1706,10 @@ class CppGenerator : public BaseGenerator { if (parser_.opts.generate_object_based_api) { // Generate the UnPack() pre declaration. - code_ += " " + TableUnPackSignature(struct_def, true, parser_.opts) + ";"; - code_ += " " + TableUnPackToSignature(struct_def, true, parser_.opts) + ";"; + code_ += + " " + TableUnPackSignature(struct_def, true, parser_.opts) + ";"; + code_ += + " " + TableUnPackToSignature(struct_def, true, parser_.opts) + ";"; code_ += " " + TablePackSignature(struct_def, true, parser_.opts) + ";"; } @@ -1657,8 +1720,7 @@ class CppGenerator : public BaseGenerator { for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (field.deprecated || - field.value.type.base_type != BASE_TYPE_UNION) { + if (field.deprecated || field.value.type.base_type != BASE_TYPE_UNION) { continue; } @@ -1667,26 +1729,24 @@ class CppGenerator : public BaseGenerator { code_.SetValue("FIELD_NAME", Name(field)); - for (auto u_it = u->vals.vec.begin(); - u_it != u->vals.vec.end(); ++u_it) { + for (auto u_it = u->vals.vec.begin(); u_it != u->vals.vec.end(); ++u_it) { auto &ev = **u_it; - if (ev.union_type.base_type == BASE_TYPE_NONE) { - continue; - } + if (ev.union_type.base_type == BASE_TYPE_NONE) { continue; } auto full_struct_name = GetUnionElement(ev, true, true); - code_.SetValue("U_ELEMENT_TYPE", WrapInNameSpace( - u->defined_namespace, GetEnumValUse(*u, ev))); + code_.SetValue( + "U_ELEMENT_TYPE", + WrapInNameSpace(u->defined_namespace, GetEnumValUse(*u, ev))); code_.SetValue("U_FIELD_TYPE", "const " + full_struct_name + " *"); code_.SetValue("U_ELEMENT_NAME", full_struct_name); - code_.SetValue("U_FIELD_NAME", - Name(field) + "_as_" + Name(ev)); + code_.SetValue("U_FIELD_NAME", Name(field) + "_as_" + Name(ev)); // `template<> const T *union_name_as() const` accessor. - code_ += "template<> " - "inline {{U_FIELD_TYPE}}{{STRUCT_NAME}}::{{FIELD_NAME}}_as" - "<{{U_ELEMENT_NAME}}>() const {"; + code_ += + "template<> " + "inline {{U_FIELD_TYPE}}{{STRUCT_NAME}}::{{FIELD_NAME}}_as" + "<{{U_ELEMENT_NAME}}>() const {"; code_ += " return {{U_FIELD_NAME}}();"; code_ += "}"; code_ += ""; @@ -1719,9 +1779,7 @@ class CppGenerator : public BaseGenerator { const bool is_scalar = IsScalar(field.value.type.base_type); const bool is_string = field.value.type.base_type == BASE_TYPE_STRING; const bool is_vector = field.value.type.base_type == BASE_TYPE_VECTOR; - if (is_string || is_vector) { - has_string_or_vector_fields = true; - } + if (is_string || is_vector) { has_string_or_vector_fields = true; } std::string offset = GenFieldOffsetName(field); std::string name = GenUnderlyingCast(field, false, Name(field)); @@ -1746,7 +1804,7 @@ class CppGenerator : public BaseGenerator { } code_ += " void add_{{FIELD_NAME}}({{FIELD_TYPE}}{{FIELD_NAME}}) {"; - code_ += " fbb_.{{ADD_FN}}(\\"; + code_ += " fbb_.{{ADD_FN}}(\\"; if (is_scalar) { code_ += "{{ADD_OFFSET}}, {{ADD_NAME}}, {{ADD_VALUE}});"; } else { @@ -1757,14 +1815,17 @@ class CppGenerator : public BaseGenerator { } // Builder constructor - code_ += " explicit {{STRUCT_NAME}}Builder(flatbuffers::FlatBufferBuilder &_fbb)"; + code_ += + " explicit {{STRUCT_NAME}}Builder(flatbuffers::FlatBufferBuilder " + "&_fbb)"; code_ += " : fbb_(_fbb) {"; code_ += " start_ = fbb_.StartTable();"; code_ += " }"; // Assignment operator; - code_ += " {{STRUCT_NAME}}Builder &operator=" - "(const {{STRUCT_NAME}}Builder &);"; + code_ += + " {{STRUCT_NAME}}Builder &operator=" + "(const {{STRUCT_NAME}}Builder &);"; // Finish() function. code_ += " flatbuffers::Offset<{{STRUCT_NAME}}> Finish() {"; @@ -1787,15 +1848,14 @@ class CppGenerator : public BaseGenerator { // Generate a convenient CreateX function that uses the above builder // to create a table in one go. - code_ += "inline flatbuffers::Offset<{{STRUCT_NAME}}> " - "Create{{STRUCT_NAME}}("; + code_ += + "inline flatbuffers::Offset<{{STRUCT_NAME}}> " + "Create{{STRUCT_NAME}}("; code_ += " flatbuffers::FlatBufferBuilder &_fbb\\"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (!field.deprecated) { - GenParam(field, false, ",\n "); - } + if (!field.deprecated) { GenParam(field, false, ",\n "); } } code_ += ") {"; @@ -1818,19 +1878,19 @@ class CppGenerator : public BaseGenerator { // Generate a CreateXDirect function with vector types as parameters if (has_string_or_vector_fields) { - code_ += "inline flatbuffers::Offset<{{STRUCT_NAME}}> " - "Create{{STRUCT_NAME}}Direct("; + code_ += + "inline flatbuffers::Offset<{{STRUCT_NAME}}> " + "Create{{STRUCT_NAME}}Direct("; code_ += " flatbuffers::FlatBufferBuilder &_fbb\\"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (!field.deprecated) { - GenParam(field, true, ",\n "); - } + if (!field.deprecated) { GenParam(field, true, ",\n "); } } // Need to call "Create" with the struct namespace. - const auto qualified_create_name = struct_def.defined_namespace->GetFullyQualifiedName("Create"); + const auto qualified_create_name = + struct_def.defined_namespace->GetFullyQualifiedName("Create"); code_.SetValue("CREATE_NAME", TranslateNameSpace(qualified_create_name)); code_ += ") {"; @@ -1843,12 +1903,15 @@ class CppGenerator : public BaseGenerator { code_.SetValue("FIELD_NAME", Name(field)); if (field.value.type.base_type == BASE_TYPE_STRING) { - code_ += ",\n {{FIELD_NAME}} ? " - "_fbb.CreateString({{FIELD_NAME}}) : 0\\"; + code_ += + ",\n {{FIELD_NAME}} ? " + "_fbb.CreateString({{FIELD_NAME}}) : 0\\"; } else if (field.value.type.base_type == BASE_TYPE_VECTOR) { auto type = GenTypeWire(field.value.type.VectorType(), "", false); - code_ += ",\n {{FIELD_NAME}} ? " - "_fbb.CreateVector<" + type + ">(*{{FIELD_NAME}}) : 0\\"; + code_ += + ",\n {{FIELD_NAME}} ? " + "_fbb.CreateVector<" + + type + ">(*{{FIELD_NAME}}) : 0\\"; } else { code_ += ",\n {{FIELD_NAME}}\\"; } @@ -1887,17 +1950,16 @@ class CppGenerator : public BaseGenerator { return ptype + "(new " + name + "(*" + val + "))"; } } else { - const auto ptype = GenTypeNativePtr(NativeName(name, type.struct_def, parser_.opts), - &afield, true); + const auto ptype = GenTypeNativePtr( + NativeName(name, type.struct_def, parser_.opts), &afield, true); return ptype + "(" + val + "->UnPack(_resolver))"; } } case BASE_TYPE_UNION: { - return GenUnionUnpackVal(afield, - invector ? "->Get(_i)" : "", - invector ? ("->GetEnum<" + - type.enum_def->name + - ">(_i)").c_str() : ""); + return GenUnionUnpackVal( + afield, invector ? "->Get(_i)" : "", + invector ? ("->GetEnum<" + type.enum_def->name + ">(_i)").c_str() + : ""); } default: { return val; @@ -1916,9 +1978,7 @@ class CppGenerator : public BaseGenerator { indexing += "(" + field.value.type.enum_def->name + ")"; } indexing += "_e->Get(_i)"; - if (field.value.type.element == BASE_TYPE_BOOL) { - indexing += " != 0"; - } + if (field.value.type.element == BASE_TYPE_BOOL) { indexing += " != 0"; } // Generate code that pushes data from _e to _o in the form: // for (uoffset_t i = 0; i < _e->size(); ++i) { @@ -1928,17 +1988,16 @@ class CppGenerator : public BaseGenerator { if (field.value.type.element == BASE_TYPE_UTYPE) { name = StripUnionType(Name(field)); } - auto access = field.value.type.element == BASE_TYPE_UTYPE - ? ".type" - : (field.value.type.element == BASE_TYPE_UNION - ? ".value" - : ""); + auto access = + field.value.type.element == BASE_TYPE_UTYPE + ? ".type" + : (field.value.type.element == BASE_TYPE_UNION ? ".value" : ""); code += "{ _o->" + name + ".resize(_e->size()); "; code += "for (flatbuffers::uoffset_t _i = 0;"; code += " _i < _e->size(); _i++) { "; code += "_o->" + name + "[_i]" + access + " = "; - code += GenUnpackVal(field.value.type.VectorType(), - indexing, true, field); + code += + GenUnpackVal(field.value.type.VectorType(), indexing, true, field); code += "; } }"; break; } @@ -1993,8 +2052,10 @@ class CppGenerator : public BaseGenerator { } if (field.attributes.Lookup("cpp_type")) { auto type = GenTypeBasic(field.value.type, false); - value = "_rehasher ? " - "static_cast<" + type + ">((*_rehasher)(" + value + ")) : 0"; + value = + "_rehasher ? " + "static_cast<" + + type + ">((*_rehasher)(" + value + ")) : 0"; } std::string code; @@ -2006,9 +2067,7 @@ class CppGenerator : public BaseGenerator { // For optional fields, check to see if there actually is any data // in _o->field before attempting to access it. - if (!field.required) { - code = value + ".empty() ? 0 : " + code; - } + if (!field.required) { code = value + ".empty() ? 0 : " + code; } break; } // Vector fields come in several flavours, of the forms: @@ -2029,7 +2088,7 @@ class CppGenerator : public BaseGenerator { case BASE_TYPE_STRUCT: { if (IsStruct(vector_type)) { auto native_type = - field.value.type.struct_def->attributes.Lookup("native_type"); + field.value.type.struct_def->attributes.Lookup("native_type"); if (native_type) { code += "_fbb.CreateVectorOfNativeStructs<"; code += WrapInNameSpace(*vector_type.struct_def) + ">"; @@ -2054,19 +2113,21 @@ class CppGenerator : public BaseGenerator { break; } case BASE_TYPE_UNION: { - code += "_fbb.CreateVector>(" + value + - ".size(), [](size_t i, _VectorArgs *__va) { " - "return __va->_" + value + - "[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va)"; + code += + "_fbb.CreateVector>(" + + value + + ".size(), [](size_t i, _VectorArgs *__va) { " + "return __va->_" + + value + "[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va)"; break; } case BASE_TYPE_UTYPE: { value = StripUnionType(value); code += "_fbb.CreateVector(" + value + ".size(), [](size_t i, _VectorArgs *__va) { " - "return static_cast(__va->_" + value + - "[i].type); }, &_va)"; + "return static_cast(__va->_" + + value + "[i].type); }, &_va)"; break; } default: { @@ -2086,9 +2147,7 @@ class CppGenerator : public BaseGenerator { // For optional fields, check to see if there actually is any data // in _o->field before attempting to access it. - if (!field.required) { - code = value + ".size() ? " + code + " : 0"; - } + if (!field.required) { code = value + ".size() ? " + code + " : 0"; } break; } case BASE_TYPE_UNION: { @@ -2127,27 +2186,28 @@ class CppGenerator : public BaseGenerator { // Generate code for tables that needs to come after the regular definition. void GenTablePost(const StructDef &struct_def) { code_.SetValue("STRUCT_NAME", Name(struct_def)); - code_.SetValue("NATIVE_NAME", NativeName(Name(struct_def), &struct_def, parser_.opts)); + code_.SetValue("NATIVE_NAME", + NativeName(Name(struct_def), &struct_def, parser_.opts)); if (parser_.opts.generate_object_based_api) { // Generate the X::UnPack() method. - code_ += "inline " + TableUnPackSignature(struct_def, false, parser_.opts) + " {"; + code_ += "inline " + + TableUnPackSignature(struct_def, false, parser_.opts) + " {"; code_ += " auto _o = new {{NATIVE_NAME}}();"; code_ += " UnPackTo(_o, _resolver);"; code_ += " return _o;"; code_ += "}"; code_ += ""; - code_ += "inline " + TableUnPackToSignature(struct_def, false, parser_.opts) + " {"; + code_ += "inline " + + TableUnPackToSignature(struct_def, false, parser_.opts) + " {"; code_ += " (void)_o;"; code_ += " (void)_resolver;"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; - if (field.deprecated) { - continue; - } + if (field.deprecated) { continue; } // Assign a value from |this| to |_o|. Values from |this| are stored // in a variable |_e| by calling this->field_type(). The value is then @@ -2167,13 +2227,15 @@ class CppGenerator : public BaseGenerator { // Generate the X::Pack member function that simply calls the global // CreateX function. - code_ += "inline " + TablePackSignature(struct_def, false, parser_.opts) + " {"; + code_ += "inline " + TablePackSignature(struct_def, false, parser_.opts) + + " {"; code_ += " return Create{{STRUCT_NAME}}(_fbb, _o, _rehasher);"; code_ += "}"; code_ += ""; // Generate a CreateX method that works with an unpacked C++ object. - code_ += "inline " + TableCreateSignature(struct_def, false, parser_.opts) + " {"; + code_ += "inline " + + TableCreateSignature(struct_def, false, parser_.opts) + " {"; code_ += " (void)_rehasher;"; code_ += " (void)_o;"; @@ -2189,13 +2251,12 @@ class CppGenerator : public BaseGenerator { for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; - if (field.deprecated) { - continue; - } + if (field.deprecated) { continue; } code_ += " auto _" + Name(field) + " = " + GenCreateParam(field) + ";"; } // Need to call "Create" with the struct namespace. - const auto qualified_create_name = struct_def.defined_namespace->GetFullyQualifiedName("Create"); + const auto qualified_create_name = + struct_def.defined_namespace->GetFullyQualifiedName("Create"); code_.SetValue("CREATE_NAME", TranslateNameSpace(qualified_create_name)); code_ += " return {{CREATE_NAME}}{{STRUCT_NAME}}("; @@ -2203,18 +2264,14 @@ class CppGenerator : public BaseGenerator { for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; - if (field.deprecated) { - continue; - } + if (field.deprecated) { continue; } bool pass_by_address = false; if (field.value.type.base_type == BASE_TYPE_STRUCT) { if (IsStruct(field.value.type)) { auto native_type = field.value.type.struct_def->attributes.Lookup("native_type"); - if (native_type) { - pass_by_address = true; - } + if (native_type) { pass_by_address = true; } } } @@ -2246,7 +2303,7 @@ class CppGenerator : public BaseGenerator { static void PaddingDefinition(int bits, std::string *code_ptr, int *id) { *code_ptr += " int" + NumToString(bits) + "_t padding" + - NumToString((*id)++) + "__;"; + NumToString((*id)++) + "__;"; } static void PaddingInitializer(int bits, std::string *code_ptr, int *id) { @@ -2270,8 +2327,9 @@ class CppGenerator : public BaseGenerator { code_.SetValue("ALIGN", NumToString(struct_def.minalign)); code_.SetValue("STRUCT_NAME", Name(struct_def)); - code_ += "MANUALLY_ALIGNED_STRUCT({{ALIGN}}) " - "{{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS {"; + code_ += + "MANUALLY_ALIGNED_STRUCT({{ALIGN}}) " + "{{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS {"; code_ += " private:"; int padding_id = 0; @@ -2279,7 +2337,7 @@ class CppGenerator : public BaseGenerator { it != struct_def.fields.vec.end(); ++it) { const auto &field = **it; code_.SetValue("FIELD_TYPE", - GenTypeGet(field.value.type, " ", "", " ", false)); + GenTypeGet(field.value.type, " ", "", " ", false)); code_.SetValue("FIELD_NAME", Name(field)); code_ += " {{FIELD_TYPE}}{{FIELD_NAME}}_;"; @@ -2355,8 +2413,8 @@ class CppGenerator : public BaseGenerator { auto field_type = GenTypeGet(field.value.type, " ", "const ", " &", true); auto is_scalar = IsScalar(field.value.type.base_type); auto member = Name(field) + "_"; - auto value = is_scalar ? "flatbuffers::EndianScalar(" + member + ")" - : member; + auto value = + is_scalar ? "flatbuffers::EndianScalar(" + member + ")" : member; code_.SetValue("FIELD_NAME", Name(field)); code_.SetValue("FIELD_TYPE", field_type); @@ -2373,11 +2431,12 @@ class CppGenerator : public BaseGenerator { if (is_scalar) { code_.SetValue("ARG", GenTypeBasic(field.value.type, true)); code_.SetValue("FIELD_VALUE", - GenUnderlyingCast(field, false, "_" + Name(field))); + GenUnderlyingCast(field, false, "_" + Name(field))); code_ += " void mutate_{{FIELD_NAME}}({{ARG}} _{{FIELD_NAME}}) {"; - code_ += " flatbuffers::WriteScalar(&{{FIELD_NAME}}_, " - "{{FIELD_VALUE}});"; + code_ += + " flatbuffers::WriteScalar(&{{FIELD_NAME}}_, " + "{{FIELD_VALUE}});"; code_ += " }"; } else { code_ += " {{FIELD_TYPE}}mutable_{{FIELD_NAME}}() {"; @@ -2400,7 +2459,9 @@ class CppGenerator : public BaseGenerator { code_.SetValue("KEY_TYPE", type); code_ += " int KeyCompareWithValue({{KEY_TYPE}} val) const {"; code_ += " const auto key = {{FIELD_NAME}}();"; - code_ += " return static_cast(key > val) - static_cast(key < val);"; + code_ += + " return static_cast(key > val) - static_cast(key < " + "val);"; code_ += " }"; } } @@ -2419,9 +2480,7 @@ class CppGenerator : public BaseGenerator { // The file must start and end with an empty (or null) namespace so that // namespaces are properly opened and closed. void SetNameSpace(const Namespace *ns) { - if (cur_name_space_ == ns) { - return; - } + if (cur_name_space_ == ns) { return; } // Compute the size of the longest common namespace prefix. // If cur_name_space is A::B::C::D and ns is A::B::E::F::G, @@ -2442,18 +2501,14 @@ class CppGenerator : public BaseGenerator { for (size_t j = old_size; j > common_prefix_size; --j) { code_ += "} // namespace " + cur_name_space_->components[j - 1]; } - if (old_size != common_prefix_size) { - code_ += ""; - } + if (old_size != common_prefix_size) { code_ += ""; } // open namespace parts to reach the ns namespace // in the previous example, E, then F, then G are opened for (auto j = common_prefix_size; j != new_size; ++j) { code_ += "namespace " + ns->components[j] + " {"; } - if (new_size != common_prefix_size) { - code_ += ""; - } + if (new_size != common_prefix_size) { code_ += ""; } cur_name_space_ = ns; } diff --git a/src/idl_gen_fbs.cpp b/src/idl_gen_fbs.cpp index 2ef70dab4..80b943bd3 100644 --- a/src/idl_gen_fbs.cpp +++ b/src/idl_gen_fbs.cpp @@ -16,10 +16,10 @@ // independent from idl_parser, since this code is not needed for most clients +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" namespace flatbuffers { @@ -27,16 +27,15 @@ static std::string GenType(const Type &type, bool underlying = false) { switch (type.base_type) { case BASE_TYPE_STRUCT: return type.struct_def->defined_namespace->GetFullyQualifiedName( - type.struct_def->name); - case BASE_TYPE_VECTOR: - return "[" + GenType(type.VectorType()) + "]"; + type.struct_def->name); + case BASE_TYPE_VECTOR: return "[" + GenType(type.VectorType()) + "]"; default: - if (type.enum_def && !underlying) { - return type.enum_def->defined_namespace->GetFullyQualifiedName( - type.enum_def->name); - } else { - return kTypeNames[type.base_type]; - } + if (type.enum_def && !underlying) { + return type.enum_def->defined_namespace->GetFullyQualifiedName( + type.enum_def->name); + } else { + return kTypeNames[type.base_type]; + } } } @@ -47,7 +46,7 @@ static void GenNameSpace(const Namespace &name_space, std::string *_schema, auto &schema = *_schema; schema += "namespace "; for (auto it = name_space.components.begin(); - it != name_space.components.end(); ++it) { + it != name_space.components.end(); ++it) { if (it != name_space.components.begin()) schema += "."; schema += *it; } @@ -69,6 +68,7 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) { std::string schema; schema += "// Generated from " + file_name + ".proto\n\n"; if (parser.opts.include_dependence_headers) { + // clang-format off #ifdef FBS_GEN_INCLUDES // TODO: currently all in one file. int num_includes = 0; for (auto it = parser.included_files_.begin(); @@ -82,18 +82,19 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) { } if (num_includes) schema += "\n"; #endif + // clang-format on } // Generate code for all the enum declarations. const Namespace *last_namespace = nullptr; for (auto enum_def_it = parser.enums_.vec.begin(); - enum_def_it != parser.enums_.vec.end(); ++enum_def_it) { + enum_def_it != parser.enums_.vec.end(); ++enum_def_it) { EnumDef &enum_def = **enum_def_it; GenNameSpace(*enum_def.defined_namespace, &schema, &last_namespace); GenComment(enum_def.doc_comment, &schema, nullptr); schema += "enum " + enum_def.name + " : "; schema += GenType(enum_def.underlying_type, true) + " {\n"; - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); ++it) { + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); + ++it) { auto &ev = **it; GenComment(ev.doc_comment, &schema, nullptr, " "); schema += " " + ev.name + " = " + NumToString(ev.value) + ",\n"; @@ -101,14 +102,14 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) { schema += "}\n\n"; } // Generate code for all structs/tables. - for (auto it = parser.structs_.vec.begin(); - it != parser.structs_.vec.end(); ++it) { + for (auto it = parser.structs_.vec.begin(); it != parser.structs_.vec.end(); + ++it) { StructDef &struct_def = **it; GenNameSpace(*struct_def.defined_namespace, &schema, &last_namespace); GenComment(struct_def.doc_comment, &schema, nullptr); schema += "table " + struct_def.name + " {\n"; for (auto field_it = struct_def.fields.vec.begin(); - field_it != struct_def.fields.vec.end(); ++field_it) { + field_it != struct_def.fields.vec.end(); ++field_it) { auto &field = **field_it; if (field.value.type.base_type != BASE_TYPE_UTYPE) { GenComment(field.doc_comment, &schema, nullptr, " "); @@ -123,12 +124,10 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) { return schema; } -bool GenerateFBS(const Parser &parser, - const std::string &path, +bool GenerateFBS(const Parser &parser, const std::string &path, const std::string &file_name) { return SaveFile((path + file_name + ".fbs").c_str(), GenerateFBS(parser, file_name), false); } } // namespace flatbuffers - diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp index 03293005f..79b4c2487 100644 --- a/src/idl_gen_general.cpp +++ b/src/idl_gen_general.cpp @@ -16,13 +16,13 @@ // independent from idl_parser, since this code is not needed for most clients +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" #if defined(FLATBUFFERS_CPP98_STL) - #include +# include #endif // defined(FLATBUFFERS_CPP98_STL) namespace flatbuffers { @@ -74,71 +74,72 @@ struct LanguageParameters { CommentConfig comment_config; }; -const LanguageParameters& GetLangParams(IDLOptions::Language lang) { +const LanguageParameters &GetLangParams(IDLOptions::Language lang) { static LanguageParameters language_parameters[] = { { - IDLOptions::kJava, - false, - ".java", - "String", - "boolean ", - " {\n", - "class ", - " final ", - "final ", - "final class ", - ";\n", - "()", - "", - " extends ", - "package ", - ";", - "", - "_bb.order(ByteOrder.LITTLE_ENDIAN); ", - "position()", - "offset()", - "", - "", - "", - "import java.nio.*;\nimport java.lang.*;\nimport java.util.*;\nimport com.google.flatbuffers.*;\n", - "\n@SuppressWarnings(\"unused\")\n", - { - "/**", - " *", - " */", - }, + IDLOptions::kJava, + false, + ".java", + "String", + "boolean ", + " {\n", + "class ", + " final ", + "final ", + "final class ", + ";\n", + "()", + "", + " extends ", + "package ", + ";", + "", + "_bb.order(ByteOrder.LITTLE_ENDIAN); ", + "position()", + "offset()", + "", + "", + "", + "import java.nio.*;\nimport java.lang.*;\nimport " + "java.util.*;\nimport com.google.flatbuffers.*;\n", + "\n@SuppressWarnings(\"unused\")\n", + { + "/**", + " *", + " */", + }, }, { - IDLOptions::kCSharp, - true, - ".cs", - "string", - "bool ", - "\n{\n", - "struct ", - " readonly ", - "", - "enum ", - ",\n", - " { get", - "} ", - " : ", - "namespace ", - "\n{", - "\n}\n", - "", - "Position", - "Offset", - "__p.", - "Table.", - "?", - "using global::System;\nusing global::FlatBuffers;\n\n", - "", - { - nullptr, - "///", - nullptr, - }, + IDLOptions::kCSharp, + true, + ".cs", + "string", + "bool ", + "\n{\n", + "struct ", + " readonly ", + "", + "enum ", + ",\n", + " { get", + "} ", + " : ", + "namespace ", + "\n{", + "\n}\n", + "", + "Position", + "Offset", + "__p.", + "Table.", + "?", + "using global::System;\nusing global::FlatBuffers;\n\n", + "", + { + nullptr, + "///", + nullptr, + }, }, }; @@ -157,8 +158,7 @@ class GeneralGenerator : public BaseGenerator { const std::string &file_name) : BaseGenerator(parser, path, file_name, "", "."), lang_(GetLangParams(parser_.opts.lang)), - cur_name_space_( nullptr ) { - } + cur_name_space_(nullptr) {} GeneralGenerator &operator=(const GeneralGenerator &); bool generate() { @@ -169,14 +169,14 @@ class GeneralGenerator : public BaseGenerator { ++it) { std::string enumcode; auto &enum_def = **it; - if (!parser_.opts.one_file) - cur_name_space_ = enum_def.defined_namespace; + if (!parser_.opts.one_file) cur_name_space_ = enum_def.defined_namespace; GenEnum(enum_def, &enumcode); if (parser_.opts.one_file) { one_file_code += enumcode; } else { - if (!SaveType(enum_def.name, *enum_def.defined_namespace, - enumcode, false)) return false; + if (!SaveType(enum_def.name, *enum_def.defined_namespace, enumcode, + false)) + return false; } } @@ -190,14 +190,15 @@ class GeneralGenerator : public BaseGenerator { if (parser_.opts.one_file) { one_file_code += declcode; } else { - if (!SaveType(struct_def.name, *struct_def.defined_namespace, - declcode, true)) return false; + if (!SaveType(struct_def.name, *struct_def.defined_namespace, declcode, + true)) + return false; } } if (parser_.opts.one_file) { - return SaveType(file_name_, *parser_.current_namespace_, - one_file_code, true); + return SaveType(file_name_, *parser_.current_namespace_, one_file_code, + true); } return true; } @@ -205,14 +206,17 @@ class GeneralGenerator : public BaseGenerator { // Save out the generated code for a single class while adding // declaration boilerplate. bool SaveType(const std::string &defname, const Namespace &ns, - const std::string &classcode, bool needs_includes) { + const std::string &classcode, bool needs_includes) { if (!classcode.length()) return true; std::string code; if (lang_.language == IDLOptions::kCSharp) { - code = "// \n" - "// " + std::string(FlatBuffersGeneratedWarning()) + "\n" - "// \n\n"; + code = + "// \n" + "// " + + std::string(FlatBuffersGeneratedWarning()) + + "\n" + "// \n\n"; } else { code = "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n"; } @@ -241,19 +245,21 @@ class GeneralGenerator : public BaseGenerator { return std::string() + (lang_.language == IDLOptions::kJava ? static_cast(tolower(upper)) : upper); -} + } -std::string GenNullableAnnotation(const Type& t) { - return lang_.language == IDLOptions::kJava - && parser_.opts.gen_nullable - && !IsScalar(DestinationType(t, true).base_type) ? " @Nullable ": ""; -} + std::string GenNullableAnnotation(const Type &t) { + return lang_.language == IDLOptions::kJava && parser_.opts.gen_nullable && + !IsScalar(DestinationType(t, true).base_type) + ? " @Nullable " + : ""; + } -static bool IsEnum(const Type& type) { - return type.enum_def != nullptr && IsInteger(type.base_type); -} + static bool IsEnum(const Type &type) { + return type.enum_def != nullptr && IsInteger(type.base_type); + } -std::string GenTypeBasic(const Type &type, bool enableLangOverrides) { + std::string GenTypeBasic(const Type &type, bool enableLangOverrides) { + // clang-format off static const char *java_typename[] = { #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ @@ -269,1132 +275,1126 @@ std::string GenTypeBasic(const Type &type, bool enableLangOverrides) { FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD }; + // clang-format on - if (enableLangOverrides) { - if (lang_.language == IDLOptions::kCSharp) { - if (IsEnum(type)) return WrapInNameSpace(*type.enum_def); - if (type.base_type == BASE_TYPE_STRUCT) { - return "Offset<" + WrapInNameSpace(*type.struct_def) + ">"; - } - } - } - - if (lang_.language == IDLOptions::kJava) { - return java_typename[type.base_type]; - } else { - assert(lang_.language == IDLOptions::kCSharp); - return csharp_typename[type.base_type]; - } -} - -std::string GenTypeBasic(const Type &type) { - return GenTypeBasic(type, true); -} - -std::string GenTypePointer(const Type &type) { - switch (type.base_type) { - case BASE_TYPE_STRING: - return lang_.string_type; - case BASE_TYPE_VECTOR: - return GenTypeGet(type.VectorType()); - case BASE_TYPE_STRUCT: - return WrapInNameSpace(*type.struct_def); - case BASE_TYPE_UNION: - // Unions in C# use a generic Table-derived type for better type safety - if (lang_.language == IDLOptions::kCSharp) return "TTable"; - // fall through - default: - return "Table"; - } -} - -std::string GenTypeGet(const Type &type) { - return IsScalar(type.base_type) - ? GenTypeBasic(type) - : GenTypePointer(type); -} - -// Find the destination type the user wants to receive the value in (e.g. -// one size higher signed types for unsigned serialized values in Java). -Type DestinationType(const Type &type, bool vectorelem) { - if (lang_.language != IDLOptions::kJava) return type; - switch (type.base_type) { - // We use int for both uchar/ushort, since that generally means less casting - // than using short for uchar. - case BASE_TYPE_UCHAR: return Type(BASE_TYPE_INT); - case BASE_TYPE_USHORT: return Type(BASE_TYPE_INT); - case BASE_TYPE_UINT: return Type(BASE_TYPE_LONG); - case BASE_TYPE_VECTOR: - if (vectorelem) - return DestinationType(type.VectorType(), vectorelem); - // else fall thru - default: return type; - } -} - -std::string GenOffsetType(const StructDef &struct_def) { - if(lang_.language == IDLOptions::kCSharp) { - return "Offset<" + WrapInNameSpace(struct_def) + ">"; - } else { - return "int"; - } -} - -std::string GenOffsetConstruct(const StructDef &struct_def, - const std::string &variable_name) -{ - if(lang_.language == IDLOptions::kCSharp) { - return "new Offset<" + WrapInNameSpace(struct_def) + ">(" + variable_name + - ")"; - } - return variable_name; -} - -std::string GenVectorOffsetType() { - if(lang_.language == IDLOptions::kCSharp) { - return "VectorOffset"; - } else { - return "int"; - } -} - -// Generate destination type name -std::string GenTypeNameDest(const Type &type) -{ - return GenTypeGet(DestinationType(type, true)); -} - -// Mask to turn serialized value into destination type value. -std::string DestinationMask(const Type &type, bool vectorelem) { - if (lang_.language != IDLOptions::kJava) return ""; - switch (type.base_type) { - case BASE_TYPE_UCHAR: return " & 0xFF"; - case BASE_TYPE_USHORT: return " & 0xFFFF"; - case BASE_TYPE_UINT: return " & 0xFFFFFFFFL"; - case BASE_TYPE_VECTOR: - if (vectorelem) - return DestinationMask(type.VectorType(), vectorelem); - // else fall thru - default: return ""; - } -} - -// Casts necessary to correctly read serialized data -std::string DestinationCast(const Type &type) { - if (type.base_type == BASE_TYPE_VECTOR) { - return DestinationCast(type.VectorType()); - } else { - switch (lang_.language) { - case IDLOptions::kJava: - // Cast necessary to correctly read serialized unsigned values. - if (type.base_type == BASE_TYPE_UINT) return "(long)"; - break; - - case IDLOptions::kCSharp: - // Cast from raw integral types to enum. - if (IsEnum(type)) return "(" + WrapInNameSpace(*type.enum_def) + ")"; - break; - - default: - break; - } - } - return ""; -} - -// Cast statements for mutator method parameters. -// In Java, parameters representing unsigned numbers need to be cast down to -// their respective type. For example, a long holding an unsigned int value -// would be cast down to int before being put onto the buffer. In C#, one cast -// directly cast an Enum to its underlying type, which is essential before -// putting it onto the buffer. -std::string SourceCast(const Type &type, bool castFromDest) { - if (type.base_type == BASE_TYPE_VECTOR) { - return SourceCast(type.VectorType(), castFromDest); - } else { - switch (lang_.language) { - case IDLOptions::kJava: - if (castFromDest) { - if (type.base_type == BASE_TYPE_UINT) return "(int)"; - else if (type.base_type == BASE_TYPE_USHORT) return "(short)"; - else if (type.base_type == BASE_TYPE_UCHAR) return "(byte)"; - } - break; - case IDLOptions::kCSharp: - if (IsEnum(type)) return "(" + GenTypeBasic(type, false) + ")"; - break; - default: - break; - } - } - return ""; -} - -std::string SourceCast(const Type &type) { - return SourceCast(type, true); -} - -std::string SourceCastBasic(const Type &type, bool castFromDest) { - return IsScalar(type.base_type) ? SourceCast(type, castFromDest) : ""; -} - -std::string SourceCastBasic(const Type &type) { - return SourceCastBasic(type, true); -} - - -std::string GenEnumDefaultValue(const Value &value) { - auto enum_def = value.type.enum_def; - auto vec = enum_def->vals.vec; - auto default_value = StringToInt(value.constant.c_str()); - - auto result = value.constant; - for (auto it = vec.begin(); it != vec.end(); ++it) { - auto enum_val = **it; - if (enum_val.value == default_value) { - result = WrapInNameSpace(*enum_def) + "." + enum_val.name; - break; - } - } - - return result; -} - -std::string GenDefaultValue(const Value &value, bool enableLangOverrides) { - if (enableLangOverrides) { - // handles both enum case and vector of enum case - if (lang_.language == IDLOptions::kCSharp && - value.type.enum_def != nullptr && - value.type.base_type != BASE_TYPE_UNION) { - return GenEnumDefaultValue(value); - } - } - - auto longSuffix = lang_.language == IDLOptions::kJava ? "L" : ""; - switch (value.type.base_type) { - case BASE_TYPE_FLOAT: return value.constant + "f"; - case BASE_TYPE_BOOL: return value.constant == "0" ? "false" : "true"; - case BASE_TYPE_ULONG: - { - if (lang_.language != IDLOptions::kJava) - return value.constant; - // Converts the ulong into its bits signed equivalent - uint64_t defaultValue = StringToUInt(value.constant.c_str()); - return NumToString(static_cast(defaultValue)) + longSuffix; - } - case BASE_TYPE_UINT: - case BASE_TYPE_LONG: return value.constant + longSuffix; - default: return value.constant; - } -} - -std::string GenDefaultValue(const Value &value) { - return GenDefaultValue(value, true); -} - -std::string GenDefaultValueBasic(const Value &value, bool enableLangOverrides) { - if (!IsScalar(value.type.base_type)) { if (enableLangOverrides) { if (lang_.language == IDLOptions::kCSharp) { - switch (value.type.base_type) { - case BASE_TYPE_STRING: - return "default(StringOffset)"; - case BASE_TYPE_STRUCT: - return "default(Offset<" + WrapInNameSpace(*value.type.struct_def) + - ">)"; - case BASE_TYPE_VECTOR: - return "default(VectorOffset)"; - default: - break; + if (IsEnum(type)) return WrapInNameSpace(*type.enum_def); + if (type.base_type == BASE_TYPE_STRUCT) { + return "Offset<" + WrapInNameSpace(*type.struct_def) + ">"; } } } - return "0"; - } - return GenDefaultValue(value, enableLangOverrides); -} -std::string GenDefaultValueBasic(const Value &value) { - return GenDefaultValueBasic(value, true); -} - -void GenEnum(EnumDef &enum_def, std::string *code_ptr) { - std::string &code = *code_ptr; - if (enum_def.generated) return; - - // Generate enum definitions of the form: - // public static (final) int name = value; - // In Java, we use ints rather than the Enum feature, because we want them - // to map directly to how they're used in C/C++ and file formats. - // That, and Java Enums are expensive, and not universally liked. - GenComment(enum_def.doc_comment, code_ptr, &lang_.comment_config); - code += std::string("public ") + lang_.enum_decl + enum_def.name; - if (lang_.language == IDLOptions::kCSharp) { - code += lang_.inheritance_marker + - GenTypeBasic(enum_def.underlying_type, false); - } - code += lang_.open_curly; - if (lang_.language == IDLOptions::kJava) { - code += " private " + enum_def.name + "() { }\n"; - } - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); - ++it) { - auto &ev = **it; - GenComment(ev.doc_comment, code_ptr, &lang_.comment_config, " "); - if (lang_.language != IDLOptions::kCSharp) { - code += " public static"; - code += lang_.const_decl; - code += GenTypeBasic(enum_def.underlying_type, false); - } - code += " " + ev.name + " = "; - code += NumToString(ev.value); - code += lang_.enum_separator; - } - - // Generate a generate string table for enum values. - // We do not do that for C# where this functionality is native. - if (lang_.language != IDLOptions::kCSharp) { - // Problem is, if values are very sparse that could generate really big - // tables. Ideally in that case we generate a map lookup instead, but for - // the moment we simply don't output a table at all. - auto range = enum_def.vals.vec.back()->value - - enum_def.vals.vec.front()->value + 1; - // Average distance between values above which we consider a table - // "too sparse". Change at will. - static const int kMaxSparseness = 5; - if (range / static_cast(enum_def.vals.vec.size()) < kMaxSparseness) { - code += "\n public static"; - code += lang_.const_decl; - code += lang_.string_type; - code += "[] names = { "; - auto val = enum_def.vals.vec.front()->value; - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); - ++it) { - while (val++ != (*it)->value) code += "\"\", "; - code += "\"" + (*it)->name + "\", "; - } - code += "};\n\n"; - code += " public static "; - code += lang_.string_type; - code += " " + MakeCamel("name", lang_.first_camel_upper); - code += "(int e) { return names[e"; - if (enum_def.vals.vec.front()->value) - code += " - " + enum_def.vals.vec.front()->name; - code += "]; }\n"; - } - } - - // Close the class - code += "}"; - // Java does not need the closing semi-colon on class definitions. - code += (lang_.language != IDLOptions::kJava) ? ";" : ""; - code += "\n\n"; -} - -// Returns the function name that is able to read a value of the given type. -std::string GenGetter(const Type &type) { - switch (type.base_type) { - case BASE_TYPE_STRING: return lang_.accessor_prefix + "__string"; - case BASE_TYPE_STRUCT: return lang_.accessor_prefix + "__struct"; - case BASE_TYPE_UNION: return lang_.accessor_prefix + "__union"; - case BASE_TYPE_VECTOR: return GenGetter(type.VectorType()); - default: { - std::string getter = - lang_.accessor_prefix + "bb." + FunctionStart('G') + "et"; - if (type.base_type == BASE_TYPE_BOOL) { - getter = "0!=" + getter; - } else if (GenTypeBasic(type, false) != "byte") { - getter += MakeCamel(GenTypeBasic(type, false)); - } - return getter; - } - } -} - -// Returns the function name that is able to read a value of the given type. -std::string GenGetterForLookupByKey(flatbuffers::FieldDef *key_field, - const std::string &data_buffer, - const char *num = nullptr) { - auto type = key_field->value.type; - auto dest_mask = DestinationMask(type, true); - auto dest_cast = DestinationCast(type); - auto getter = data_buffer + "." + FunctionStart('G') + "et"; - if (GenTypeBasic(type, false) != "byte") { - getter += MakeCamel(GenTypeBasic(type, false)); - } - getter = dest_cast + getter + "(" + GenOffsetGetter(key_field, num) + ")" - + dest_mask; - return getter; -} - -// Direct mutation is only allowed for scalar fields. -// Hence a setter method will only be generated for such fields. -std::string GenSetter(const Type &type) { - if (IsScalar(type.base_type)) { - std::string setter = - lang_.accessor_prefix + "bb." + FunctionStart('P') + "ut"; - if (GenTypeBasic(type, false) != "byte" && - type.base_type != BASE_TYPE_BOOL) { - setter += MakeCamel(GenTypeBasic(type, false)); - } - return setter; - } else { - return ""; - } -} - -// Returns the method name for use with add/put calls. -std::string GenMethod(const Type &type) { - return IsScalar(type.base_type) - ? MakeCamel(GenTypeBasic(type, false)) - : (IsStruct(type) ? "Struct" : "Offset"); -} - -// Recursively generate arguments for a constructor, to deal with nested -// structs. -void GenStructArgs(const StructDef &struct_def, std::string *code_ptr, - const char *nameprefix) { - std::string &code = *code_ptr; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (IsStruct(field.value.type)) { - // Generate arguments for a struct inside a struct. To ensure names - // don't clash, and to make it obvious these arguments are constructing - // a nested struct, prefix the name with the field name. - GenStructArgs(*field.value.type.struct_def, code_ptr, - (nameprefix + (field.name + "_")).c_str()); + if (lang_.language == IDLOptions::kJava) { + return java_typename[type.base_type]; } else { - code += ", "; - code += GenTypeBasic(DestinationType(field.value.type, false)); - code += " "; - code += nameprefix; - code += MakeCamel(field.name, lang_.first_camel_upper); + assert(lang_.language == IDLOptions::kCSharp); + return csharp_typename[type.base_type]; } } -} -// Recusively generate struct construction statements of the form: -// builder.putType(name); -// and insert manual padding. -void GenStructBody(const StructDef &struct_def, std::string *code_ptr, - const char *nameprefix) { - std::string &code = *code_ptr; - code += " builder." + FunctionStart('P') + "rep("; - code += NumToString(struct_def.minalign) + ", "; - code += NumToString(struct_def.bytesize) + ");\n"; - for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); ++it) { - auto &field = **it; - if (field.padding) { - code += " builder." + FunctionStart('P') + "ad("; - code += NumToString(field.padding) + ");\n"; - } - if (IsStruct(field.value.type)) { - GenStructBody(*field.value.type.struct_def, code_ptr, - (nameprefix + (field.name + "_")).c_str()); - } else { - code += " builder." + FunctionStart('P') + "ut"; - code += GenMethod(field.value.type) + "("; - code += SourceCast(field.value.type); - auto argname = nameprefix + MakeCamel(field.name, lang_.first_camel_upper); - code += argname; - code += ");\n"; + std::string GenTypeBasic(const Type &type) { + return GenTypeBasic(type, true); + } + + std::string GenTypePointer(const Type &type) { + switch (type.base_type) { + case BASE_TYPE_STRING: return lang_.string_type; + case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType()); + case BASE_TYPE_STRUCT: return WrapInNameSpace(*type.struct_def); + case BASE_TYPE_UNION: + // Unions in C# use a generic Table-derived type for better type safety + if (lang_.language == IDLOptions::kCSharp) return "TTable"; + // fall through + default: return "Table"; } } -} -std::string GenByteBufferLength(const char *bb_name) { - std::string bb_len = bb_name; - if (lang_.language == IDLOptions::kCSharp) bb_len += ".Length"; - else bb_len += ".capacity()"; - return bb_len; -} - -std::string GenOffsetGetter(flatbuffers::FieldDef *key_field, - const char *num = nullptr) { - std::string key_offset = ""; - key_offset += lang_.accessor_prefix_static + "__offset(" + - NumToString(key_field->value.offset) + ", "; - if (num) { - key_offset += num; - key_offset += (lang_.language == IDLOptions::kCSharp ? - ".Value, builder.DataBuffer)" : ", _bb)"); - } else { - key_offset += GenByteBufferLength("bb"); - key_offset += " - tableOffset, bb)"; + std::string GenTypeGet(const Type &type) { + return IsScalar(type.base_type) ? GenTypeBasic(type) : GenTypePointer(type); } - return key_offset; -} -std::string GenLookupKeyGetter(flatbuffers::FieldDef *key_field) { - std::string key_getter = " "; - key_getter += "int tableOffset = " + lang_.accessor_prefix_static; - key_getter += "__indirect(vectorLocation + 4 * (start + middle)"; - key_getter += ", bb);\n "; - if (key_field->value.type.base_type == BASE_TYPE_STRING) { - key_getter += "int comp = " + lang_.accessor_prefix_static; - key_getter += FunctionStart('C') + "ompareStrings("; - key_getter += GenOffsetGetter(key_field); - key_getter += ", byteKey, bb);\n"; - } else { - auto get_val = GenGetterForLookupByKey(key_field, "bb"); + // Find the destination type the user wants to receive the value in (e.g. + // one size higher signed types for unsigned serialized values in Java). + Type DestinationType(const Type &type, bool vectorelem) { + if (lang_.language != IDLOptions::kJava) return type; + switch (type.base_type) { + // We use int for both uchar/ushort, since that generally means less + // casting than using short for uchar. + case BASE_TYPE_UCHAR: return Type(BASE_TYPE_INT); + case BASE_TYPE_USHORT: return Type(BASE_TYPE_INT); + case BASE_TYPE_UINT: return Type(BASE_TYPE_LONG); + case BASE_TYPE_VECTOR: + if (vectorelem) return DestinationType(type.VectorType(), vectorelem); + // else fall thru + default: return type; + } + } + + std::string GenOffsetType(const StructDef &struct_def) { if (lang_.language == IDLOptions::kCSharp) { - key_getter += "int comp = " + get_val + ".CompareTo(key);\n"; + return "Offset<" + WrapInNameSpace(struct_def) + ">"; } else { - key_getter += GenTypeNameDest(key_field->value.type) + " val = "; - key_getter += get_val + ";\n"; - key_getter += " int comp = val > key ? 1 : val < key ? -1 : 0;\n"; + return "int"; } } - return key_getter; -} - -std::string GenKeyGetter(flatbuffers::FieldDef *key_field) { - std::string key_getter = ""; - auto data_buffer = (lang_.language == IDLOptions::kCSharp) ? - "builder.DataBuffer" : "_bb"; - if (key_field->value.type.base_type == BASE_TYPE_STRING) { - if (lang_.language == IDLOptions::kJava) - key_getter += " return "; - key_getter += lang_.accessor_prefix_static; - key_getter += FunctionStart('C') + "ompareStrings("; - key_getter += GenOffsetGetter(key_field, "o1") + ", "; - key_getter += GenOffsetGetter(key_field, "o2") + ", " + data_buffer + ")"; - if (lang_.language == IDLOptions::kJava) - key_getter += ";"; - } - else { - auto field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o1"); + std::string GenOffsetConstruct(const StructDef &struct_def, + const std::string &variable_name) { if (lang_.language == IDLOptions::kCSharp) { - key_getter += field_getter; - field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o2"); - key_getter += ".CompareTo(" + field_getter + ")"; - } - else { - key_getter += "\n " + GenTypeNameDest(key_field->value.type) + " val_1 = "; - key_getter += field_getter + ";\n " + GenTypeNameDest(key_field->value.type); - key_getter += " val_2 = "; - field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o2"); - key_getter += field_getter + ";\n"; - key_getter += " return val_1 > val_2 ? 1 : val_1 < val_2 ? -1 : 0;\n "; + return "new Offset<" + WrapInNameSpace(struct_def) + ">(" + + variable_name + ")"; } + return variable_name; } - return key_getter; -} - -void GenStruct(StructDef &struct_def, std::string *code_ptr) { - if (struct_def.generated) return; - std::string &code = *code_ptr; - - // Generate a struct accessor class, with methods of the form: - // public type name() { return bb.getType(i + offset); } - // or for tables of the form: - // public type name() { - // int o = __offset(offset); return o != 0 ? bb.getType(o + i) : default; - // } - GenComment(struct_def.doc_comment, code_ptr, &lang_.comment_config); - code += "public "; - if (lang_.language == IDLOptions::kCSharp && - struct_def.attributes.Lookup("csharp_partial")) { - // generate a partial class for this C# struct/table - code += "partial "; - } else { - code += lang_.unsubclassable_decl; - } - code += lang_.accessor_type + struct_def.name; - if (lang_.language == IDLOptions::kCSharp) { - code += " : IFlatbufferObject"; - code += lang_.open_curly; - code += " private "; - code += struct_def.fixed ? "Struct" : "Table"; - code += " __p;\n"; + std::string GenVectorOffsetType() { if (lang_.language == IDLOptions::kCSharp) { - code += " public ByteBuffer ByteBuffer { get { return __p.bb; } }\n"; - } - - } else { - code += lang_.inheritance_marker; - code += struct_def.fixed ? "Struct" : "Table"; - code += lang_.open_curly; - } - if (!struct_def.fixed) { - // Generate a special accessor for the table that when used as the root - // of a FlatBuffer - std::string method_name = FunctionStart('G') + "etRootAs" + struct_def.name; - std::string method_signature = " public static " + struct_def.name + " " + - method_name; - - // create convenience method that doesn't require an existing object - code += method_signature + "(ByteBuffer _bb) "; - code += "{ return " + method_name + "(_bb, new " + struct_def.name+ "()); }\n"; - - // create method that allows object reuse - code += method_signature + "(ByteBuffer _bb, " + struct_def.name + " obj) { "; - code += lang_.set_bb_byteorder; - code += "return (obj.__assign(_bb." + FunctionStart('G') + "etInt(_bb."; - code += lang_.get_bb_position; - code += ") + _bb."; - code += lang_.get_bb_position; - code += ", _bb)); }\n"; - if (parser_.root_struct_def_ == &struct_def) { - if (parser_.file_identifier_.length()) { - // Check if a buffer has the identifier. - code += " public static "; - code += lang_.bool_type + struct_def.name; - code += "BufferHasIdentifier(ByteBuffer _bb) { return "; - code += lang_.accessor_prefix_static + "__has_identifier(_bb, \""; - code += parser_.file_identifier_; - code += "\"); }\n"; - } - } - } - // Generate the __init method that sets the field in a pre-existing - // accessor object. This is to allow object reuse. - code += " public void __init(int _i, ByteBuffer _bb) "; - code += "{ " + lang_.accessor_prefix + "bb_pos = _i; "; - code += lang_.accessor_prefix + "bb = _bb; }\n"; - code += " public " + struct_def.name + " __assign(int _i, ByteBuffer _bb) "; - code += "{ __init(_i, _bb); return this; }\n\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (field.deprecated) continue; - GenComment(field.doc_comment, code_ptr, &lang_.comment_config, " "); - std::string type_name = GenTypeGet(field.value.type); - std::string type_name_dest = GenTypeNameDest(field.value.type); - std::string conditional_cast = ""; - std::string optional = ""; - if (lang_.language == IDLOptions::kCSharp && - !struct_def.fixed && - (field.value.type.base_type == BASE_TYPE_STRUCT || - field.value.type.base_type == BASE_TYPE_UNION || - (field.value.type.base_type == BASE_TYPE_VECTOR && - field.value.type.element == BASE_TYPE_STRUCT))) { - optional = lang_.optional_suffix; - conditional_cast = "(" + type_name_dest + optional + ")"; - } - std::string dest_mask = DestinationMask(field.value.type, true); - std::string dest_cast = DestinationCast(field.value.type); - std::string src_cast = SourceCast(field.value.type); - std::string method_start = " public " + GenNullableAnnotation(field.value.type) + - type_name_dest + optional + " " + - MakeCamel(field.name, lang_.first_camel_upper); - std::string obj = lang_.language == IDLOptions::kCSharp - ? "(new " + type_name + "())" - : "obj"; - - // Most field accessors need to retrieve and test the field offset first, - // this is the prefix code for that: - auto offset_prefix = " { int o = " + lang_.accessor_prefix + "__offset(" + - NumToString(field.value.offset) + - "); return o != 0 ? "; - // Generate the accessors that don't do object reuse. - if (field.value.type.base_type == BASE_TYPE_STRUCT) { - // Calls the accessor that takes an accessor object with a new object. - if (lang_.language != IDLOptions::kCSharp) { - code += method_start + "() { return "; - code += MakeCamel(field.name, lang_.first_camel_upper); - code += "(new "; - code += type_name + "()); }\n"; - } - } else if (field.value.type.base_type == BASE_TYPE_VECTOR && - field.value.type.element == BASE_TYPE_STRUCT) { - // Accessors for vectors of structs also take accessor objects, this - // generates a variant without that argument. - if (lang_.language != IDLOptions::kCSharp) { - code += method_start + "(int j) { return "; - code += MakeCamel(field.name, lang_.first_camel_upper); - code += "(new " + type_name + "(), j); }\n"; - } - } else if (field.value.type.base_type == BASE_TYPE_UNION) { - if (lang_.language == IDLOptions::kCSharp) { - // Union types in C# use generic Table-derived type for better type - // safety. - method_start += ""; - type_name = type_name_dest; - } - } - std::string getter = dest_cast + GenGetter(field.value.type); - code += method_start; - std::string default_cast = ""; - // only create default casts for c# scalars or vectors of scalars - if (lang_.language == IDLOptions::kCSharp && - (IsScalar(field.value.type.base_type) || - (field.value.type.base_type == BASE_TYPE_VECTOR && - IsScalar(field.value.type.element)))) { - // For scalars, default value will be returned by GetDefaultValue(). - // If the scalar is an enum, GetDefaultValue() returns an actual c# enum - // that doesn't need to be casted. However, default values for enum - // elements of vectors are integer literals ("0") and are still casted - // for clarity. - if (field.value.type.enum_def == nullptr || - field.value.type.base_type == BASE_TYPE_VECTOR) { - default_cast = "(" + type_name_dest + ")"; - } - } - std::string member_suffix = "; "; - if (IsScalar(field.value.type.base_type)) { - code += lang_.getter_prefix; - member_suffix += lang_.getter_suffix; - if (struct_def.fixed) { - code += " { return " + getter; - code += "(" + lang_.accessor_prefix + "bb_pos + "; - code += NumToString(field.value.offset) + ")"; - code += dest_mask; - } else { - code += offset_prefix + getter; - code += "(o + " + lang_.accessor_prefix + "bb_pos)" + dest_mask; - code += " : " + default_cast; - code += GenDefaultValue(field.value); - } + return "VectorOffset"; } else { - switch (field.value.type.base_type) { - case BASE_TYPE_STRUCT: - if (lang_.language != IDLOptions::kCSharp) { - code += "(" + type_name + " obj" + ")"; - } else { - code += lang_.getter_prefix; - member_suffix += lang_.getter_suffix; - } - if (struct_def.fixed) { - code += " { return " + obj + ".__assign(" + lang_.accessor_prefix; - code += "bb_pos + " + NumToString(field.value.offset) + ", "; - code += lang_.accessor_prefix + "bb)"; - } else { - code += offset_prefix + conditional_cast; - code += obj + ".__assign("; - code += field.value.type.struct_def->fixed - ? "o + " + lang_.accessor_prefix + "bb_pos" - : lang_.accessor_prefix + "__indirect(o + " + - lang_.accessor_prefix + "bb_pos)"; - code += ", " + lang_.accessor_prefix + "bb) : null"; - } - break; - case BASE_TYPE_STRING: - code += lang_.getter_prefix; - member_suffix += lang_.getter_suffix; - code += offset_prefix + getter + "(o + " + lang_.accessor_prefix; - code += "bb_pos) : null"; - break; - case BASE_TYPE_VECTOR: { - auto vectortype = field.value.type.VectorType(); - code += "("; - if (vectortype.base_type == BASE_TYPE_STRUCT) { - if (lang_.language != IDLOptions::kCSharp) - code += type_name + " obj, "; - getter = obj + ".__assign"; - } - code += "int j)" + offset_prefix + conditional_cast + getter +"("; - auto index = lang_.accessor_prefix + "__vector(o) + j * " + - NumToString(InlineSize(vectortype)); - if (vectortype.base_type == BASE_TYPE_STRUCT) { - code += vectortype.struct_def->fixed - ? index - : lang_.accessor_prefix + "__indirect(" + index + ")"; - code += ", " + lang_.accessor_prefix + "bb"; - } else { - code += index; - } - code += ")" + dest_mask + " : "; + return "int"; + } + } - code += field.value.type.element == BASE_TYPE_BOOL ? "false" : - (IsScalar(field.value.type.element) ? default_cast + "0" : "null"); - break; - } - case BASE_TYPE_UNION: - if (lang_.language == IDLOptions::kCSharp) { - code += "() where TTable : struct, IFlatbufferObject"; - code += offset_prefix + "(TTable?)" + getter; - code += "(o) : null"; - } else { - code += "(" + type_name + " obj)" + offset_prefix + getter; - code += "(obj, o) : null"; - } - break; - default: - assert(0); - } + // Generate destination type name + std::string GenTypeNameDest(const Type &type) { + return GenTypeGet(DestinationType(type, true)); + } + + // Mask to turn serialized value into destination type value. + std::string DestinationMask(const Type &type, bool vectorelem) { + if (lang_.language != IDLOptions::kJava) return ""; + switch (type.base_type) { + case BASE_TYPE_UCHAR: return " & 0xFF"; + case BASE_TYPE_USHORT: return " & 0xFFFF"; + case BASE_TYPE_UINT: return " & 0xFFFFFFFFL"; + case BASE_TYPE_VECTOR: + if (vectorelem) return DestinationMask(type.VectorType(), vectorelem); + // else fall thru + default: return ""; } - code += member_suffix; - code += "}\n"; - if (field.value.type.base_type == BASE_TYPE_VECTOR) { - code += " public int " + MakeCamel(field.name, lang_.first_camel_upper); - code += "Length"; - code += lang_.getter_prefix; - code += offset_prefix; - code += lang_.accessor_prefix + "__vector_len(o) : 0; "; - code += lang_.getter_suffix; - code += "}\n"; - // See if we should generate a by-key accessor. - if (field.value.type.element == BASE_TYPE_STRUCT && - !field.value.type.struct_def->fixed) { - auto &sd = *field.value.type.struct_def; - auto &fields = sd.fields.vec; - for (auto kit = fields.begin(); kit != fields.end(); ++kit) { - auto &key_field = **kit; - if (key_field.key) { - code += " public " + sd.name + lang_.optional_suffix + " "; - code += MakeCamel(field.name, lang_.first_camel_upper) + "ByKey("; - code += GenTypeNameDest(key_field.value.type) + " key)"; - code += offset_prefix; - code += sd.name + ".__lookup_by_key("; - code += lang_.accessor_prefix + "__vector(o), key, "; - code += lang_.accessor_prefix + "bb) : null; "; - code += "}\n"; - break; - } - } - } - } - // Generate a ByteBuffer accessor for strings & vectors of scalars. - if ((field.value.type.base_type == BASE_TYPE_VECTOR && - IsScalar(field.value.type.VectorType().base_type)) || - field.value.type.base_type == BASE_TYPE_STRING) { + } + + // Casts necessary to correctly read serialized data + std::string DestinationCast(const Type &type) { + if (type.base_type == BASE_TYPE_VECTOR) { + return DestinationCast(type.VectorType()); + } else { switch (lang_.language) { case IDLOptions::kJava: - code += " public ByteBuffer "; - code += MakeCamel(field.name, lang_.first_camel_upper); - code += "AsByteBuffer() { return "; - code += lang_.accessor_prefix + "__vector_as_bytebuffer("; - code += NumToString(field.value.offset) + ", "; - code += NumToString(field.value.type.base_type == BASE_TYPE_STRING - ? 1 - : InlineSize(field.value.type.VectorType())); - code += "); }\n"; + // Cast necessary to correctly read serialized unsigned values. + if (type.base_type == BASE_TYPE_UINT) return "(long)"; break; + case IDLOptions::kCSharp: - code += " public ArraySegment? Get"; - code += MakeCamel(field.name, lang_.first_camel_upper); - code += "Bytes() { return "; - code += lang_.accessor_prefix + "__vector_as_arraysegment("; - code += NumToString(field.value.offset); - code += "); }\n"; - break; - default: + // Cast from raw integral types to enum. + if (IsEnum(type)) return "(" + WrapInNameSpace(*type.enum_def) + ")"; break; + + default: break; } } - // generate object accessors if is nested_flatbuffer - if (field.nested_flatbuffer) { - auto nested_type_name = WrapInNameSpace(*field.nested_flatbuffer); - auto nested_method_name = MakeCamel(field.name, lang_.first_camel_upper) - + "As" + nested_type_name; - auto get_nested_method_name = nested_method_name; - if (lang_.language == IDLOptions::kCSharp) { - get_nested_method_name = "Get" + nested_method_name; - conditional_cast = "(" + nested_type_name + lang_.optional_suffix + ")"; - } - if (lang_.language != IDLOptions::kCSharp) { - code += " public " + nested_type_name + lang_.optional_suffix + " "; - code += nested_method_name + "() { return "; - code += get_nested_method_name + "(new " + nested_type_name + "()); }\n"; - } else { - obj = "(new " + nested_type_name + "())"; - } - code += " public " + nested_type_name + lang_.optional_suffix + " "; - code += get_nested_method_name + "("; - if (lang_.language != IDLOptions::kCSharp) - code += nested_type_name + " obj"; - code += ") { int o = " + lang_.accessor_prefix + "__offset("; - code += NumToString(field.value.offset) +"); "; - code += "return o != 0 ? " + conditional_cast + obj + ".__assign("; - code += lang_.accessor_prefix; - code += "__indirect(" + lang_.accessor_prefix + "__vector(o)), "; - code += lang_.accessor_prefix + "bb) : null; }\n"; + return ""; } - // Generate mutators for scalar fields or vectors of scalars. - if (parser_.opts.mutable_buffer) { - auto underlying_type = field.value.type.base_type == BASE_TYPE_VECTOR - ? field.value.type.VectorType() - : field.value.type; - // Boolean parameters have to be explicitly converted to byte - // representation. - auto setter_parameter = underlying_type.base_type == BASE_TYPE_BOOL - ? "(byte)(" + field.name + " ? 1 : 0)" - : field.name; - auto mutator_prefix = MakeCamel("mutate", lang_.first_camel_upper); - // A vector mutator also needs the index of the vector element it should - // mutate. - auto mutator_params = (field.value.type.base_type == BASE_TYPE_VECTOR - ? "(int j, " - : "(") + GenTypeNameDest(underlying_type) + " " + field.name + ") { "; - auto setter_index = field.value.type.base_type == BASE_TYPE_VECTOR - ? lang_.accessor_prefix + "__vector(o) + j * " + - NumToString(InlineSize(underlying_type)) - : (struct_def.fixed - ? lang_.accessor_prefix + "bb_pos + " + - NumToString(field.value.offset) - : "o + " + lang_.accessor_prefix + "bb_pos"); - if (IsScalar(field.value.type.base_type) || - (field.value.type.base_type == BASE_TYPE_VECTOR && - IsScalar(field.value.type.VectorType().base_type))) { - code += " public "; - code += struct_def.fixed ? "void " : lang_.bool_type; - code += mutator_prefix + MakeCamel(field.name, true); - code += mutator_params; - if (struct_def.fixed) { - code += GenSetter(underlying_type) + "(" + setter_index + ", "; - code += src_cast + setter_parameter + "); }\n"; - } else { - code += "int o = " + lang_.accessor_prefix + "__offset("; - code += NumToString(field.value.offset) + ");"; - code += " if (o != 0) { " + GenSetter(underlying_type); - code += "(" + setter_index + ", " + src_cast + setter_parameter + - "); return true; } else { return false; } }\n"; + + // Cast statements for mutator method parameters. + // In Java, parameters representing unsigned numbers need to be cast down to + // their respective type. For example, a long holding an unsigned int value + // would be cast down to int before being put onto the buffer. In C#, one cast + // directly cast an Enum to its underlying type, which is essential before + // putting it onto the buffer. + std::string SourceCast(const Type &type, bool castFromDest) { + if (type.base_type == BASE_TYPE_VECTOR) { + return SourceCast(type.VectorType(), castFromDest); + } else { + switch (lang_.language) { + case IDLOptions::kJava: + if (castFromDest) { + if (type.base_type == BASE_TYPE_UINT) + return "(int)"; + else if (type.base_type == BASE_TYPE_USHORT) + return "(short)"; + else if (type.base_type == BASE_TYPE_UCHAR) + return "(byte)"; + } + break; + case IDLOptions::kCSharp: + if (IsEnum(type)) return "(" + GenTypeBasic(type, false) + ")"; + break; + default: break; + } + } + return ""; + } + + std::string SourceCast(const Type &type) { return SourceCast(type, true); } + + std::string SourceCastBasic(const Type &type, bool castFromDest) { + return IsScalar(type.base_type) ? SourceCast(type, castFromDest) : ""; + } + + std::string SourceCastBasic(const Type &type) { + return SourceCastBasic(type, true); + } + + std::string GenEnumDefaultValue(const Value &value) { + auto enum_def = value.type.enum_def; + auto vec = enum_def->vals.vec; + auto default_value = StringToInt(value.constant.c_str()); + + auto result = value.constant; + for (auto it = vec.begin(); it != vec.end(); ++it) { + auto enum_val = **it; + if (enum_val.value == default_value) { + result = WrapInNameSpace(*enum_def) + "." + enum_val.name; + break; + } + } + + return result; + } + + std::string GenDefaultValue(const Value &value, bool enableLangOverrides) { + if (enableLangOverrides) { + // handles both enum case and vector of enum case + if (lang_.language == IDLOptions::kCSharp && + value.type.enum_def != nullptr && + value.type.base_type != BASE_TYPE_UNION) { + return GenEnumDefaultValue(value); + } + } + + auto longSuffix = lang_.language == IDLOptions::kJava ? "L" : ""; + switch (value.type.base_type) { + case BASE_TYPE_FLOAT: return value.constant + "f"; + case BASE_TYPE_BOOL: return value.constant == "0" ? "false" : "true"; + case BASE_TYPE_ULONG: { + if (lang_.language != IDLOptions::kJava) return value.constant; + // Converts the ulong into its bits signed equivalent + uint64_t defaultValue = StringToUInt(value.constant.c_str()); + return NumToString(static_cast(defaultValue)) + longSuffix; + } + case BASE_TYPE_UINT: + case BASE_TYPE_LONG: return value.constant + longSuffix; + default: return value.constant; + } + } + + std::string GenDefaultValue(const Value &value) { + return GenDefaultValue(value, true); + } + + std::string GenDefaultValueBasic(const Value &value, + bool enableLangOverrides) { + if (!IsScalar(value.type.base_type)) { + if (enableLangOverrides) { + if (lang_.language == IDLOptions::kCSharp) { + switch (value.type.base_type) { + case BASE_TYPE_STRING: return "default(StringOffset)"; + case BASE_TYPE_STRUCT: + return "default(Offset<" + + WrapInNameSpace(*value.type.struct_def) + ">)"; + case BASE_TYPE_VECTOR: return "default(VectorOffset)"; + default: break; + } + } + } + return "0"; + } + return GenDefaultValue(value, enableLangOverrides); + } + + std::string GenDefaultValueBasic(const Value &value) { + return GenDefaultValueBasic(value, true); + } + + void GenEnum(EnumDef &enum_def, std::string *code_ptr) { + std::string &code = *code_ptr; + if (enum_def.generated) return; + + // Generate enum definitions of the form: + // public static (final) int name = value; + // In Java, we use ints rather than the Enum feature, because we want them + // to map directly to how they're used in C/C++ and file formats. + // That, and Java Enums are expensive, and not universally liked. + GenComment(enum_def.doc_comment, code_ptr, &lang_.comment_config); + code += std::string("public ") + lang_.enum_decl + enum_def.name; + if (lang_.language == IDLOptions::kCSharp) { + code += lang_.inheritance_marker + + GenTypeBasic(enum_def.underlying_type, false); + } + code += lang_.open_curly; + if (lang_.language == IDLOptions::kJava) { + code += " private " + enum_def.name + "() { }\n"; + } + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); + ++it) { + auto &ev = **it; + GenComment(ev.doc_comment, code_ptr, &lang_.comment_config, " "); + if (lang_.language != IDLOptions::kCSharp) { + code += " public static"; + code += lang_.const_decl; + code += GenTypeBasic(enum_def.underlying_type, false); + } + code += " " + ev.name + " = "; + code += NumToString(ev.value); + code += lang_.enum_separator; + } + + // Generate a generate string table for enum values. + // We do not do that for C# where this functionality is native. + if (lang_.language != IDLOptions::kCSharp) { + // Problem is, if values are very sparse that could generate really big + // tables. Ideally in that case we generate a map lookup instead, but for + // the moment we simply don't output a table at all. + auto range = enum_def.vals.vec.back()->value - + enum_def.vals.vec.front()->value + 1; + // Average distance between values above which we consider a table + // "too sparse". Change at will. + static const int kMaxSparseness = 5; + if (range / static_cast(enum_def.vals.vec.size()) < + kMaxSparseness) { + code += "\n public static"; + code += lang_.const_decl; + code += lang_.string_type; + code += "[] names = { "; + auto val = enum_def.vals.vec.front()->value; + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); + ++it) { + while (val++ != (*it)->value) code += "\"\", "; + code += "\"" + (*it)->name + "\", "; + } + code += "};\n\n"; + code += " public static "; + code += lang_.string_type; + code += " " + MakeCamel("name", lang_.first_camel_upper); + code += "(int e) { return names[e"; + if (enum_def.vals.vec.front()->value) + code += " - " + enum_def.vals.vec.front()->name; + code += "]; }\n"; + } + } + + // Close the class + code += "}"; + // Java does not need the closing semi-colon on class definitions. + code += (lang_.language != IDLOptions::kJava) ? ";" : ""; + code += "\n\n"; + } + + // Returns the function name that is able to read a value of the given type. + std::string GenGetter(const Type &type) { + switch (type.base_type) { + case BASE_TYPE_STRING: return lang_.accessor_prefix + "__string"; + case BASE_TYPE_STRUCT: return lang_.accessor_prefix + "__struct"; + case BASE_TYPE_UNION: return lang_.accessor_prefix + "__union"; + case BASE_TYPE_VECTOR: return GenGetter(type.VectorType()); + default: { + std::string getter = + lang_.accessor_prefix + "bb." + FunctionStart('G') + "et"; + if (type.base_type == BASE_TYPE_BOOL) { + getter = "0!=" + getter; + } else if (GenTypeBasic(type, false) != "byte") { + getter += MakeCamel(GenTypeBasic(type, false)); + } + return getter; + } + } + } + + // Returns the function name that is able to read a value of the given type. + std::string GenGetterForLookupByKey(flatbuffers::FieldDef *key_field, + const std::string &data_buffer, + const char *num = nullptr) { + auto type = key_field->value.type; + auto dest_mask = DestinationMask(type, true); + auto dest_cast = DestinationCast(type); + auto getter = data_buffer + "." + FunctionStart('G') + "et"; + if (GenTypeBasic(type, false) != "byte") { + getter += MakeCamel(GenTypeBasic(type, false)); + } + getter = dest_cast + getter + "(" + GenOffsetGetter(key_field, num) + ")" + + dest_mask; + return getter; + } + + // Direct mutation is only allowed for scalar fields. + // Hence a setter method will only be generated for such fields. + std::string GenSetter(const Type &type) { + if (IsScalar(type.base_type)) { + std::string setter = + lang_.accessor_prefix + "bb." + FunctionStart('P') + "ut"; + if (GenTypeBasic(type, false) != "byte" && + type.base_type != BASE_TYPE_BOOL) { + setter += MakeCamel(GenTypeBasic(type, false)); + } + return setter; + } else { + return ""; + } + } + + // Returns the method name for use with add/put calls. + std::string GenMethod(const Type &type) { + return IsScalar(type.base_type) ? MakeCamel(GenTypeBasic(type, false)) + : (IsStruct(type) ? "Struct" : "Offset"); + } + + // Recursively generate arguments for a constructor, to deal with nested + // structs. + void GenStructArgs(const StructDef &struct_def, std::string *code_ptr, + const char *nameprefix) { + std::string &code = *code_ptr; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (IsStruct(field.value.type)) { + // Generate arguments for a struct inside a struct. To ensure names + // don't clash, and to make it obvious these arguments are constructing + // a nested struct, prefix the name with the field name. + GenStructArgs(*field.value.type.struct_def, code_ptr, + (nameprefix + (field.name + "_")).c_str()); + } else { + code += ", "; + code += GenTypeBasic(DestinationType(field.value.type, false)); + code += " "; + code += nameprefix; + code += MakeCamel(field.name, lang_.first_camel_upper); + } + } + } + + // Recusively generate struct construction statements of the form: + // builder.putType(name); + // and insert manual padding. + void GenStructBody(const StructDef &struct_def, std::string *code_ptr, + const char *nameprefix) { + std::string &code = *code_ptr; + code += " builder." + FunctionStart('P') + "rep("; + code += NumToString(struct_def.minalign) + ", "; + code += NumToString(struct_def.bytesize) + ");\n"; + for (auto it = struct_def.fields.vec.rbegin(); + it != struct_def.fields.vec.rend(); ++it) { + auto &field = **it; + if (field.padding) { + code += " builder." + FunctionStart('P') + "ad("; + code += NumToString(field.padding) + ");\n"; + } + if (IsStruct(field.value.type)) { + GenStructBody(*field.value.type.struct_def, code_ptr, + (nameprefix + (field.name + "_")).c_str()); + } else { + code += " builder." + FunctionStart('P') + "ut"; + code += GenMethod(field.value.type) + "("; + code += SourceCast(field.value.type); + auto argname = + nameprefix + MakeCamel(field.name, lang_.first_camel_upper); + code += argname; + code += ");\n"; + } + } + } + + std::string GenByteBufferLength(const char *bb_name) { + std::string bb_len = bb_name; + if (lang_.language == IDLOptions::kCSharp) + bb_len += ".Length"; + else + bb_len += ".capacity()"; + return bb_len; + } + + std::string GenOffsetGetter(flatbuffers::FieldDef *key_field, + const char *num = nullptr) { + std::string key_offset = ""; + key_offset += lang_.accessor_prefix_static + "__offset(" + + NumToString(key_field->value.offset) + ", "; + if (num) { + key_offset += num; + key_offset += + (lang_.language == IDLOptions::kCSharp ? ".Value, builder.DataBuffer)" + : ", _bb)"); + } else { + key_offset += GenByteBufferLength("bb"); + key_offset += " - tableOffset, bb)"; + } + return key_offset; + } + + std::string GenLookupKeyGetter(flatbuffers::FieldDef *key_field) { + std::string key_getter = " "; + key_getter += "int tableOffset = " + lang_.accessor_prefix_static; + key_getter += "__indirect(vectorLocation + 4 * (start + middle)"; + key_getter += ", bb);\n "; + if (key_field->value.type.base_type == BASE_TYPE_STRING) { + key_getter += "int comp = " + lang_.accessor_prefix_static; + key_getter += FunctionStart('C') + "ompareStrings("; + key_getter += GenOffsetGetter(key_field); + key_getter += ", byteKey, bb);\n"; + } else { + auto get_val = GenGetterForLookupByKey(key_field, "bb"); + if (lang_.language == IDLOptions::kCSharp) { + key_getter += "int comp = " + get_val + ".CompareTo(key);\n"; + } else { + key_getter += GenTypeNameDest(key_field->value.type) + " val = "; + key_getter += get_val + ";\n"; + key_getter += " int comp = val > key ? 1 : val < key ? -1 : 0;\n"; + } + } + return key_getter; + } + + std::string GenKeyGetter(flatbuffers::FieldDef *key_field) { + std::string key_getter = ""; + auto data_buffer = + (lang_.language == IDLOptions::kCSharp) ? "builder.DataBuffer" : "_bb"; + if (key_field->value.type.base_type == BASE_TYPE_STRING) { + if (lang_.language == IDLOptions::kJava) key_getter += " return "; + key_getter += lang_.accessor_prefix_static; + key_getter += FunctionStart('C') + "ompareStrings("; + key_getter += GenOffsetGetter(key_field, "o1") + ", "; + key_getter += GenOffsetGetter(key_field, "o2") + ", " + data_buffer + ")"; + if (lang_.language == IDLOptions::kJava) key_getter += ";"; + } else { + auto field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o1"); + if (lang_.language == IDLOptions::kCSharp) { + key_getter += field_getter; + field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o2"); + key_getter += ".CompareTo(" + field_getter + ")"; + } else { + key_getter += + "\n " + GenTypeNameDest(key_field->value.type) + " val_1 = "; + key_getter += + field_getter + ";\n " + GenTypeNameDest(key_field->value.type); + key_getter += " val_2 = "; + field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o2"); + key_getter += field_getter + ";\n"; + key_getter += + " return val_1 > val_2 ? 1 : val_1 < val_2 ? -1 : 0;\n "; + } + } + return key_getter; + } + + void GenStruct(StructDef &struct_def, std::string *code_ptr) { + if (struct_def.generated) return; + std::string &code = *code_ptr; + + // Generate a struct accessor class, with methods of the form: + // public type name() { return bb.getType(i + offset); } + // or for tables of the form: + // public type name() { + // int o = __offset(offset); return o != 0 ? bb.getType(o + i) : default; + // } + GenComment(struct_def.doc_comment, code_ptr, &lang_.comment_config); + code += "public "; + if (lang_.language == IDLOptions::kCSharp && + struct_def.attributes.Lookup("csharp_partial")) { + // generate a partial class for this C# struct/table + code += "partial "; + } else { + code += lang_.unsubclassable_decl; + } + code += lang_.accessor_type + struct_def.name; + if (lang_.language == IDLOptions::kCSharp) { + code += " : IFlatbufferObject"; + code += lang_.open_curly; + code += " private "; + code += struct_def.fixed ? "Struct" : "Table"; + code += " __p;\n"; + + if (lang_.language == IDLOptions::kCSharp) { + code += " public ByteBuffer ByteBuffer { get { return __p.bb; } }\n"; + } + + } else { + code += lang_.inheritance_marker; + code += struct_def.fixed ? "Struct" : "Table"; + code += lang_.open_curly; + } + if (!struct_def.fixed) { + // Generate a special accessor for the table that when used as the root + // of a FlatBuffer + std::string method_name = + FunctionStart('G') + "etRootAs" + struct_def.name; + std::string method_signature = + " public static " + struct_def.name + " " + method_name; + + // create convenience method that doesn't require an existing object + code += method_signature + "(ByteBuffer _bb) "; + code += "{ return " + method_name + "(_bb, new " + struct_def.name + + "()); }\n"; + + // create method that allows object reuse + code += + method_signature + "(ByteBuffer _bb, " + struct_def.name + " obj) { "; + code += lang_.set_bb_byteorder; + code += "return (obj.__assign(_bb." + FunctionStart('G') + "etInt(_bb."; + code += lang_.get_bb_position; + code += ") + _bb."; + code += lang_.get_bb_position; + code += ", _bb)); }\n"; + if (parser_.root_struct_def_ == &struct_def) { + if (parser_.file_identifier_.length()) { + // Check if a buffer has the identifier. + code += " public static "; + code += lang_.bool_type + struct_def.name; + code += "BufferHasIdentifier(ByteBuffer _bb) { return "; + code += lang_.accessor_prefix_static + "__has_identifier(_bb, \""; + code += parser_.file_identifier_; + code += "\"); }\n"; } } } - } - code += "\n"; - flatbuffers::FieldDef *key_field = nullptr; - if (struct_def.fixed) { - // create a struct constructor function - code += " public static " + GenOffsetType(struct_def) + " "; - code += FunctionStart('C') + "reate"; - code += struct_def.name + "(FlatBufferBuilder builder"; - GenStructArgs(struct_def, code_ptr, ""); - code += ") {\n"; - GenStructBody(struct_def, code_ptr, ""); - code += " return "; - code += GenOffsetConstruct(struct_def, - "builder." + std::string(lang_.get_fbb_offset)); - code += ";\n }\n"; - } else { - // Generate a method that creates a table in one go. This is only possible - // when the table has no struct fields, since those have to be created - // inline, and there's no way to do so in Java. - bool has_no_struct_fields = true; - int num_fields = 0; + // Generate the __init method that sets the field in a pre-existing + // accessor object. This is to allow object reuse. + code += " public void __init(int _i, ByteBuffer _bb) "; + code += "{ " + lang_.accessor_prefix + "bb_pos = _i; "; + code += lang_.accessor_prefix + "bb = _bb; }\n"; + code += + " public " + struct_def.name + " __assign(int _i, ByteBuffer _bb) "; + code += "{ __init(_i, _bb); return this; }\n\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (field.deprecated) continue; - if (IsStruct(field.value.type)) { - has_no_struct_fields = false; + GenComment(field.doc_comment, code_ptr, &lang_.comment_config, " "); + std::string type_name = GenTypeGet(field.value.type); + std::string type_name_dest = GenTypeNameDest(field.value.type); + std::string conditional_cast = ""; + std::string optional = ""; + if (lang_.language == IDLOptions::kCSharp && !struct_def.fixed && + (field.value.type.base_type == BASE_TYPE_STRUCT || + field.value.type.base_type == BASE_TYPE_UNION || + (field.value.type.base_type == BASE_TYPE_VECTOR && + field.value.type.element == BASE_TYPE_STRUCT))) { + optional = lang_.optional_suffix; + conditional_cast = "(" + type_name_dest + optional + ")"; + } + std::string dest_mask = DestinationMask(field.value.type, true); + std::string dest_cast = DestinationCast(field.value.type); + std::string src_cast = SourceCast(field.value.type); + std::string method_start = " public " + + GenNullableAnnotation(field.value.type) + + type_name_dest + optional + " " + + MakeCamel(field.name, lang_.first_camel_upper); + std::string obj = lang_.language == IDLOptions::kCSharp + ? "(new " + type_name + "())" + : "obj"; + + // Most field accessors need to retrieve and test the field offset first, + // this is the prefix code for that: + auto offset_prefix = " { int o = " + lang_.accessor_prefix + "__offset(" + + NumToString(field.value.offset) + + "); return o != 0 ? "; + // Generate the accessors that don't do object reuse. + if (field.value.type.base_type == BASE_TYPE_STRUCT) { + // Calls the accessor that takes an accessor object with a new object. + if (lang_.language != IDLOptions::kCSharp) { + code += method_start + "() { return "; + code += MakeCamel(field.name, lang_.first_camel_upper); + code += "(new "; + code += type_name + "()); }\n"; + } + } else if (field.value.type.base_type == BASE_TYPE_VECTOR && + field.value.type.element == BASE_TYPE_STRUCT) { + // Accessors for vectors of structs also take accessor objects, this + // generates a variant without that argument. + if (lang_.language != IDLOptions::kCSharp) { + code += method_start + "(int j) { return "; + code += MakeCamel(field.name, lang_.first_camel_upper); + code += "(new " + type_name + "(), j); }\n"; + } + } else if (field.value.type.base_type == BASE_TYPE_UNION) { + if (lang_.language == IDLOptions::kCSharp) { + // Union types in C# use generic Table-derived type for better type + // safety. + method_start += ""; + type_name = type_name_dest; + } + } + std::string getter = dest_cast + GenGetter(field.value.type); + code += method_start; + std::string default_cast = ""; + // only create default casts for c# scalars or vectors of scalars + if (lang_.language == IDLOptions::kCSharp && + (IsScalar(field.value.type.base_type) || + (field.value.type.base_type == BASE_TYPE_VECTOR && + IsScalar(field.value.type.element)))) { + // For scalars, default value will be returned by GetDefaultValue(). + // If the scalar is an enum, GetDefaultValue() returns an actual c# enum + // that doesn't need to be casted. However, default values for enum + // elements of vectors are integer literals ("0") and are still casted + // for clarity. + if (field.value.type.enum_def == nullptr || + field.value.type.base_type == BASE_TYPE_VECTOR) { + default_cast = "(" + type_name_dest + ")"; + } + } + std::string member_suffix = "; "; + if (IsScalar(field.value.type.base_type)) { + code += lang_.getter_prefix; + member_suffix += lang_.getter_suffix; + if (struct_def.fixed) { + code += " { return " + getter; + code += "(" + lang_.accessor_prefix + "bb_pos + "; + code += NumToString(field.value.offset) + ")"; + code += dest_mask; + } else { + code += offset_prefix + getter; + code += "(o + " + lang_.accessor_prefix + "bb_pos)" + dest_mask; + code += " : " + default_cast; + code += GenDefaultValue(field.value); + } } else { - num_fields++; + switch (field.value.type.base_type) { + case BASE_TYPE_STRUCT: + if (lang_.language != IDLOptions::kCSharp) { + code += "(" + type_name + " obj" + ")"; + } else { + code += lang_.getter_prefix; + member_suffix += lang_.getter_suffix; + } + if (struct_def.fixed) { + code += " { return " + obj + ".__assign(" + lang_.accessor_prefix; + code += "bb_pos + " + NumToString(field.value.offset) + ", "; + code += lang_.accessor_prefix + "bb)"; + } else { + code += offset_prefix + conditional_cast; + code += obj + ".__assign("; + code += field.value.type.struct_def->fixed + ? "o + " + lang_.accessor_prefix + "bb_pos" + : lang_.accessor_prefix + "__indirect(o + " + + lang_.accessor_prefix + "bb_pos)"; + code += ", " + lang_.accessor_prefix + "bb) : null"; + } + break; + case BASE_TYPE_STRING: + code += lang_.getter_prefix; + member_suffix += lang_.getter_suffix; + code += offset_prefix + getter + "(o + " + lang_.accessor_prefix; + code += "bb_pos) : null"; + break; + case BASE_TYPE_VECTOR: { + auto vectortype = field.value.type.VectorType(); + code += "("; + if (vectortype.base_type == BASE_TYPE_STRUCT) { + if (lang_.language != IDLOptions::kCSharp) + code += type_name + " obj, "; + getter = obj + ".__assign"; + } + code += "int j)" + offset_prefix + conditional_cast + getter + "("; + auto index = lang_.accessor_prefix + "__vector(o) + j * " + + NumToString(InlineSize(vectortype)); + if (vectortype.base_type == BASE_TYPE_STRUCT) { + code += vectortype.struct_def->fixed + ? index + : lang_.accessor_prefix + "__indirect(" + index + ")"; + code += ", " + lang_.accessor_prefix + "bb"; + } else { + code += index; + } + code += ")" + dest_mask + " : "; + + code += + field.value.type.element == BASE_TYPE_BOOL + ? "false" + : (IsScalar(field.value.type.element) ? default_cast + "0" + : "null"); + break; + } + case BASE_TYPE_UNION: + if (lang_.language == IDLOptions::kCSharp) { + code += "() where TTable : struct, IFlatbufferObject"; + code += offset_prefix + "(TTable?)" + getter; + code += "(o) : null"; + } else { + code += "(" + type_name + " obj)" + offset_prefix + getter; + code += "(obj, o) : null"; + } + break; + default: assert(0); + } + } + code += member_suffix; + code += "}\n"; + if (field.value.type.base_type == BASE_TYPE_VECTOR) { + code += + " public int " + MakeCamel(field.name, lang_.first_camel_upper); + code += "Length"; + code += lang_.getter_prefix; + code += offset_prefix; + code += lang_.accessor_prefix + "__vector_len(o) : 0; "; + code += lang_.getter_suffix; + code += "}\n"; + // See if we should generate a by-key accessor. + if (field.value.type.element == BASE_TYPE_STRUCT && + !field.value.type.struct_def->fixed) { + auto &sd = *field.value.type.struct_def; + auto &fields = sd.fields.vec; + for (auto kit = fields.begin(); kit != fields.end(); ++kit) { + auto &key_field = **kit; + if (key_field.key) { + code += " public " + sd.name + lang_.optional_suffix + " "; + code += MakeCamel(field.name, lang_.first_camel_upper) + "ByKey("; + code += GenTypeNameDest(key_field.value.type) + " key)"; + code += offset_prefix; + code += sd.name + ".__lookup_by_key("; + code += lang_.accessor_prefix + "__vector(o), key, "; + code += lang_.accessor_prefix + "bb) : null; "; + code += "}\n"; + break; + } + } + } + } + // Generate a ByteBuffer accessor for strings & vectors of scalars. + if ((field.value.type.base_type == BASE_TYPE_VECTOR && + IsScalar(field.value.type.VectorType().base_type)) || + field.value.type.base_type == BASE_TYPE_STRING) { + switch (lang_.language) { + case IDLOptions::kJava: + code += " public ByteBuffer "; + code += MakeCamel(field.name, lang_.first_camel_upper); + code += "AsByteBuffer() { return "; + code += lang_.accessor_prefix + "__vector_as_bytebuffer("; + code += NumToString(field.value.offset) + ", "; + code += + NumToString(field.value.type.base_type == BASE_TYPE_STRING + ? 1 + : InlineSize(field.value.type.VectorType())); + code += "); }\n"; + break; + case IDLOptions::kCSharp: + code += " public ArraySegment? Get"; + code += MakeCamel(field.name, lang_.first_camel_upper); + code += "Bytes() { return "; + code += lang_.accessor_prefix + "__vector_as_arraysegment("; + code += NumToString(field.value.offset); + code += "); }\n"; + break; + default: break; + } + } + // generate object accessors if is nested_flatbuffer + if (field.nested_flatbuffer) { + auto nested_type_name = WrapInNameSpace(*field.nested_flatbuffer); + auto nested_method_name = + MakeCamel(field.name, lang_.first_camel_upper) + "As" + + nested_type_name; + auto get_nested_method_name = nested_method_name; + if (lang_.language == IDLOptions::kCSharp) { + get_nested_method_name = "Get" + nested_method_name; + conditional_cast = + "(" + nested_type_name + lang_.optional_suffix + ")"; + } + if (lang_.language != IDLOptions::kCSharp) { + code += " public " + nested_type_name + lang_.optional_suffix + " "; + code += nested_method_name + "() { return "; + code += + get_nested_method_name + "(new " + nested_type_name + "()); }\n"; + } else { + obj = "(new " + nested_type_name + "())"; + } + code += " public " + nested_type_name + lang_.optional_suffix + " "; + code += get_nested_method_name + "("; + if (lang_.language != IDLOptions::kCSharp) + code += nested_type_name + " obj"; + code += ") { int o = " + lang_.accessor_prefix + "__offset("; + code += NumToString(field.value.offset) + "); "; + code += "return o != 0 ? " + conditional_cast + obj + ".__assign("; + code += lang_.accessor_prefix; + code += "__indirect(" + lang_.accessor_prefix + "__vector(o)), "; + code += lang_.accessor_prefix + "bb) : null; }\n"; + } + // Generate mutators for scalar fields or vectors of scalars. + if (parser_.opts.mutable_buffer) { + auto underlying_type = field.value.type.base_type == BASE_TYPE_VECTOR + ? field.value.type.VectorType() + : field.value.type; + // Boolean parameters have to be explicitly converted to byte + // representation. + auto setter_parameter = underlying_type.base_type == BASE_TYPE_BOOL + ? "(byte)(" + field.name + " ? 1 : 0)" + : field.name; + auto mutator_prefix = MakeCamel("mutate", lang_.first_camel_upper); + // A vector mutator also needs the index of the vector element it should + // mutate. + auto mutator_params = + (field.value.type.base_type == BASE_TYPE_VECTOR ? "(int j, " + : "(") + + GenTypeNameDest(underlying_type) + " " + field.name + ") { "; + auto setter_index = + field.value.type.base_type == BASE_TYPE_VECTOR + ? lang_.accessor_prefix + "__vector(o) + j * " + + NumToString(InlineSize(underlying_type)) + : (struct_def.fixed + ? lang_.accessor_prefix + "bb_pos + " + + NumToString(field.value.offset) + : "o + " + lang_.accessor_prefix + "bb_pos"); + if (IsScalar(field.value.type.base_type) || + (field.value.type.base_type == BASE_TYPE_VECTOR && + IsScalar(field.value.type.VectorType().base_type))) { + code += " public "; + code += struct_def.fixed ? "void " : lang_.bool_type; + code += mutator_prefix + MakeCamel(field.name, true); + code += mutator_params; + if (struct_def.fixed) { + code += GenSetter(underlying_type) + "(" + setter_index + ", "; + code += src_cast + setter_parameter + "); }\n"; + } else { + code += "int o = " + lang_.accessor_prefix + "__offset("; + code += NumToString(field.value.offset) + ");"; + code += " if (o != 0) { " + GenSetter(underlying_type); + code += "(" + setter_index + ", " + src_cast + setter_parameter + + "); return true; } else { return false; } }\n"; + } + } } } - // JVM specifications restrict default constructor params to be < 255. - // Longs and doubles take up 2 units, so we set the limit to be < 127. - if (has_no_struct_fields && num_fields && num_fields < 127) { - // Generate a table constructor of the form: - // public static int createName(FlatBufferBuilder builder, args...) + code += "\n"; + flatbuffers::FieldDef *key_field = nullptr; + if (struct_def.fixed) { + // create a struct constructor function code += " public static " + GenOffsetType(struct_def) + " "; - code += FunctionStart('C') + "reate" + struct_def.name; - code += "(FlatBufferBuilder builder"; + code += FunctionStart('C') + "reate"; + code += struct_def.name + "(FlatBufferBuilder builder"; + GenStructArgs(struct_def, code_ptr, ""); + code += ") {\n"; + GenStructBody(struct_def, code_ptr, ""); + code += " return "; + code += GenOffsetConstruct( + struct_def, "builder." + std::string(lang_.get_fbb_offset)); + code += ";\n }\n"; + } else { + // Generate a method that creates a table in one go. This is only possible + // when the table has no struct fields, since those have to be created + // inline, and there's no way to do so in Java. + bool has_no_struct_fields = true; + int num_fields = 0; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (field.deprecated) continue; - code += ",\n "; - code += GenTypeBasic(DestinationType(field.value.type, false)); - code += " "; - code += field.name; - if (!IsScalar(field.value.type.base_type)) code += "Offset"; - - // Java doesn't have defaults, which means this method must always - // supply all arguments, and thus won't compile when fields are added. - if (lang_.language != IDLOptions::kJava) { - code += " = "; - code += GenDefaultValueBasic(field.value); + if (IsStruct(field.value.type)) { + has_no_struct_fields = false; + } else { + num_fields++; } } - code += ") {\n builder."; - code += FunctionStart('S') + "tartObject("; - code += NumToString(struct_def.fields.vec.size()) + ");\n"; - for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; - size; - size /= 2) { - for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); ++it) { + // JVM specifications restrict default constructor params to be < 255. + // Longs and doubles take up 2 units, so we set the limit to be < 127. + if (has_no_struct_fields && num_fields && num_fields < 127) { + // Generate a table constructor of the form: + // public static int createName(FlatBufferBuilder builder, args...) + code += " public static " + GenOffsetType(struct_def) + " "; + code += FunctionStart('C') + "reate" + struct_def.name; + code += "(FlatBufferBuilder builder"; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { auto &field = **it; - if (!field.deprecated && - (!struct_def.sortbysize || - size == SizeOf(field.value.type.base_type))) { - code += " " + struct_def.name + "."; - code += FunctionStart('A') + "dd"; - code += MakeCamel(field.name) + "(builder, " + field.name; - if (!IsScalar(field.value.type.base_type)) code += "Offset"; - code += ");\n"; + if (field.deprecated) continue; + code += ",\n "; + code += GenTypeBasic(DestinationType(field.value.type, false)); + code += " "; + code += field.name; + if (!IsScalar(field.value.type.base_type)) code += "Offset"; + + // Java doesn't have defaults, which means this method must always + // supply all arguments, and thus won't compile when fields are added. + if (lang_.language != IDLOptions::kJava) { + code += " = "; + code += GenDefaultValueBasic(field.value); } } + code += ") {\n builder."; + code += FunctionStart('S') + "tartObject("; + code += NumToString(struct_def.fields.vec.size()) + ");\n"; + for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; + size; size /= 2) { + for (auto it = struct_def.fields.vec.rbegin(); + it != struct_def.fields.vec.rend(); ++it) { + auto &field = **it; + if (!field.deprecated && + (!struct_def.sortbysize || + size == SizeOf(field.value.type.base_type))) { + code += " " + struct_def.name + "."; + code += FunctionStart('A') + "dd"; + code += MakeCamel(field.name) + "(builder, " + field.name; + if (!IsScalar(field.value.type.base_type)) code += "Offset"; + code += ");\n"; + } + } + } + code += " return " + struct_def.name + "."; + code += FunctionStart('E') + "nd" + struct_def.name; + code += "(builder);\n }\n\n"; } - code += " return " + struct_def.name + "."; - code += FunctionStart('E') + "nd" + struct_def.name; - code += "(builder);\n }\n\n"; - } - // Generate a set of static methods that allow table construction, - // of the form: - // public static void addName(FlatBufferBuilder builder, short name) - // { builder.addShort(id, name, default); } - // Unlike the Create function, these always work. - code += " public static void " + FunctionStart('S') + "tart"; - code += struct_def.name; - code += "(FlatBufferBuilder builder) { builder."; - code += FunctionStart('S') + "tartObject("; - code += NumToString(struct_def.fields.vec.size()) + "); }\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; - if (field.key) key_field = &field; - code += " public static void " + FunctionStart('A') + "dd"; - code += MakeCamel(field.name); - code += "(FlatBufferBuilder builder, "; - code += GenTypeBasic(DestinationType(field.value.type, false)); - auto argname = MakeCamel(field.name, false); - if (!IsScalar(field.value.type.base_type)) argname += "Offset"; - code += " " + argname + ") { builder." + FunctionStart('A') + "dd"; - code += GenMethod(field.value.type) + "("; - code += NumToString(it - struct_def.fields.vec.begin()) + ", "; - code += SourceCastBasic(field.value.type); - code += argname; - if (!IsScalar(field.value.type.base_type) && - field.value.type.base_type != BASE_TYPE_UNION && - lang_.language == IDLOptions::kCSharp) { - code += ".Value"; - } - code += ", "; - if (lang_.language == IDLOptions::kJava) - code += SourceCastBasic( field.value.type ); - code += GenDefaultValue(field.value, false); - code += "); }\n"; - if (field.value.type.base_type == BASE_TYPE_VECTOR) { - auto vector_type = field.value.type.VectorType(); - auto alignment = InlineAlignment(vector_type); - auto elem_size = InlineSize(vector_type); - if (!IsStruct(vector_type)) { - // Generate a method to create a vector from a Java array. - code += " public static " + GenVectorOffsetType() + " "; - code += FunctionStart('C') + "reate"; + // Generate a set of static methods that allow table construction, + // of the form: + // public static void addName(FlatBufferBuilder builder, short name) + // { builder.addShort(id, name, default); } + // Unlike the Create function, these always work. + code += " public static void " + FunctionStart('S') + "tart"; + code += struct_def.name; + code += "(FlatBufferBuilder builder) { builder."; + code += FunctionStart('S') + "tartObject("; + code += NumToString(struct_def.fields.vec.size()) + "); }\n"; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + if (field.key) key_field = &field; + code += " public static void " + FunctionStart('A') + "dd"; + code += MakeCamel(field.name); + code += "(FlatBufferBuilder builder, "; + code += GenTypeBasic(DestinationType(field.value.type, false)); + auto argname = MakeCamel(field.name, false); + if (!IsScalar(field.value.type.base_type)) argname += "Offset"; + code += " " + argname + ") { builder." + FunctionStart('A') + "dd"; + code += GenMethod(field.value.type) + "("; + code += NumToString(it - struct_def.fields.vec.begin()) + ", "; + code += SourceCastBasic(field.value.type); + code += argname; + if (!IsScalar(field.value.type.base_type) && + field.value.type.base_type != BASE_TYPE_UNION && + lang_.language == IDLOptions::kCSharp) { + code += ".Value"; + } + code += ", "; + if (lang_.language == IDLOptions::kJava) + code += SourceCastBasic(field.value.type); + code += GenDefaultValue(field.value, false); + code += "); }\n"; + if (field.value.type.base_type == BASE_TYPE_VECTOR) { + auto vector_type = field.value.type.VectorType(); + auto alignment = InlineAlignment(vector_type); + auto elem_size = InlineSize(vector_type); + if (!IsStruct(vector_type)) { + // Generate a method to create a vector from a Java array. + code += " public static " + GenVectorOffsetType() + " "; + code += FunctionStart('C') + "reate"; + code += MakeCamel(field.name); + code += "Vector(FlatBufferBuilder builder, "; + code += GenTypeBasic(vector_type) + "[] data) "; + code += "{ builder." + FunctionStart('S') + "tartVector("; + code += NumToString(elem_size); + code += ", data." + FunctionStart('L') + "ength, "; + code += NumToString(alignment); + code += "); for (int i = data."; + code += FunctionStart('L') + "ength - 1; i >= 0; i--) builder."; + code += FunctionStart('A') + "dd"; + code += GenMethod(vector_type); + code += "("; + code += SourceCastBasic(vector_type, false); + code += "data[i]"; + if (lang_.language == IDLOptions::kCSharp && + (vector_type.base_type == BASE_TYPE_STRUCT || + vector_type.base_type == BASE_TYPE_STRING)) + code += ".Value"; + code += "); return "; + code += "builder." + FunctionStart('E') + "ndVector(); }\n"; + } + // Generate a method to start a vector, data to be added manually + // after. + code += " public static void " + FunctionStart('S') + "tart"; code += MakeCamel(field.name); - code += "Vector(FlatBufferBuilder builder, "; - code += GenTypeBasic(vector_type) + "[] data) "; + code += "Vector(FlatBufferBuilder builder, int numElems) "; code += "{ builder." + FunctionStart('S') + "tartVector("; code += NumToString(elem_size); - code += ", data." + FunctionStart('L') + "ength, "; - code += NumToString(alignment); - code += "); for (int i = data."; - code += FunctionStart('L') + "ength - 1; i >= 0; i--) builder."; - code += FunctionStart('A') + "dd"; - code += GenMethod(vector_type); - code += "("; - code += SourceCastBasic(vector_type, false); - code += "data[i]"; - if (lang_.language == IDLOptions::kCSharp && - (vector_type.base_type == BASE_TYPE_STRUCT || - vector_type.base_type == BASE_TYPE_STRING)) - code += ".Value"; - code += "); return "; - code += "builder." + FunctionStart('E') + "ndVector(); }\n"; + code += ", numElems, " + NumToString(alignment); + code += "); }\n"; } - // Generate a method to start a vector, data to be added manually after. - code += " public static void " + FunctionStart('S') + "tart"; - code += MakeCamel(field.name); - code += "Vector(FlatBufferBuilder builder, int numElems) "; - code += "{ builder." + FunctionStart('S') + "tartVector("; - code += NumToString(elem_size); - code += ", numElems, " + NumToString(alignment); + } + code += " public static " + GenOffsetType(struct_def) + " "; + code += FunctionStart('E') + "nd" + struct_def.name; + code += "(FlatBufferBuilder builder) {\n int o = builder."; + code += FunctionStart('E') + "ndObject();\n"; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (!field.deprecated && field.required) { + code += " builder." + FunctionStart('R') + "equired(o, "; + code += NumToString(field.value.offset); + code += "); // " + field.name + "\n"; + } + } + code += " return " + GenOffsetConstruct(struct_def, "o") + ";\n }\n"; + if (parser_.root_struct_def_ == &struct_def) { + code += " public static void "; + code += FunctionStart('F') + "inish" + struct_def.name; + code += + "Buffer(FlatBufferBuilder builder, " + GenOffsetType(struct_def); + code += " offset) {"; + code += " builder." + FunctionStart('F') + "inish(offset"; + if (lang_.language == IDLOptions::kCSharp) { code += ".Value"; } + + if (parser_.file_identifier_.length()) + code += ", \"" + parser_.file_identifier_ + "\""; code += "); }\n"; } } - code += " public static " + GenOffsetType(struct_def) + " "; - code += FunctionStart('E') + "nd" + struct_def.name; - code += "(FlatBufferBuilder builder) {\n int o = builder."; - code += FunctionStart('E') + "ndObject();\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (!field.deprecated && field.required) { - code += " builder." + FunctionStart('R') + "equired(o, "; - code += NumToString(field.value.offset); - code += "); // " + field.name + "\n"; - } - } - code += " return " + GenOffsetConstruct(struct_def, "o") + ";\n }\n"; - if (parser_.root_struct_def_ == &struct_def) { - code += " public static void "; - code += FunctionStart('F') + "inish" + struct_def.name; - code += "Buffer(FlatBufferBuilder builder, " + GenOffsetType(struct_def); - code += " offset) {"; - code += " builder." + FunctionStart('F') + "inish(offset"; - if (lang_.language == IDLOptions::kCSharp) { - code += ".Value"; + // Only generate key compare function for table, + // because `key_field` is not set for struct + if (struct_def.has_key && !struct_def.fixed) { + if (lang_.language == IDLOptions::kJava) { + code += "\n @Override\n protected int keysCompare("; + code += "Integer o1, Integer o2, ByteBuffer _bb) {"; + code += GenKeyGetter(key_field); + code += " }\n"; + } else { + code += "\n public static VectorOffset "; + code += "CreateSortedVectorOf" + struct_def.name; + code += "(FlatBufferBuilder builder, "; + code += "Offset<" + struct_def.name + ">"; + code += "[] offsets) {\n"; + code += " Array.Sort(offsets, (Offset<" + struct_def.name + + "> o1, Offset<" + struct_def.name + "> o2) => " + + GenKeyGetter(key_field); + code += ");\n"; + code += " return builder.CreateVectorOfTables(offsets);\n }\n"; } - if (parser_.file_identifier_.length()) - code += ", \"" + parser_.file_identifier_ + "\""; - code += "); }\n"; + code += "\n public static " + struct_def.name + lang_.optional_suffix; + code += " __lookup_by_key(int vectorLocation, "; + code += GenTypeNameDest(key_field->value.type); + code += " key, ByteBuffer bb) {\n"; + if (key_field->value.type.base_type == BASE_TYPE_STRING) { + code += " byte[] byteKey = "; + if (lang_.language == IDLOptions::kJava) + code += "key.getBytes(Table.UTF8_CHARSET.get());\n"; + else + code += "System.Text.Encoding.UTF8.GetBytes(key);\n"; + } + code += " int span = "; + code += "bb." + FunctionStart('G') + "etInt(vectorLocation - 4);\n"; + code += " int start = 0;\n"; + code += " while (span != 0) {\n"; + code += " int middle = span / 2;\n"; + code += GenLookupKeyGetter(key_field); + code += " if (comp > 0) {\n"; + code += " span = middle;\n"; + code += " } else if (comp < 0) {\n"; + code += " middle++;\n"; + code += " start += middle;\n"; + code += " span -= middle;\n"; + code += " } else {\n"; + code += " return new " + struct_def.name; + code += "().__assign(tableOffset, bb);\n"; + code += " }\n }\n"; + code += " return null;\n"; + code += " }\n"; } + code += "}"; + // Java does not need the closing semi-colon on class definitions. + code += (lang_.language != IDLOptions::kJava) ? ";" : ""; + code += "\n\n"; } - // Only generate key compare function for table, - // because `key_field` is not set for struct - if (struct_def.has_key && !struct_def.fixed) { - if (lang_.language == IDLOptions::kJava) { - code += "\n @Override\n protected int keysCompare("; - code += "Integer o1, Integer o2, ByteBuffer _bb) {"; - code += GenKeyGetter(key_field); - code += " }\n"; - } - else { - code += "\n public static VectorOffset "; - code += "CreateSortedVectorOf" + struct_def.name; - code += "(FlatBufferBuilder builder, "; - code += "Offset<" + struct_def.name + ">"; - code += "[] offsets) {\n"; - code += " Array.Sort(offsets, (Offset<" + struct_def.name + - "> o1, Offset<" + struct_def.name + "> o2) => " + GenKeyGetter(key_field); - code += ");\n"; - code += " return builder.CreateVectorOfTables(offsets);\n }\n"; - } - - code += "\n public static " + struct_def.name + lang_.optional_suffix; - code += " __lookup_by_key(int vectorLocation, "; - code += GenTypeNameDest(key_field->value.type); - code += " key, ByteBuffer bb) {\n"; - if (key_field->value.type.base_type == BASE_TYPE_STRING) { - code += " byte[] byteKey = "; - if (lang_.language == IDLOptions::kJava) - code += "key.getBytes(Table.UTF8_CHARSET.get());\n"; - else - code += "System.Text.Encoding.UTF8.GetBytes(key);\n"; - } - code += " int span = "; - code += "bb." + FunctionStart('G') + "etInt(vectorLocation - 4);\n"; - code += " int start = 0;\n"; - code += " while (span != 0) {\n"; - code += " int middle = span / 2;\n"; - code += GenLookupKeyGetter(key_field); - code += " if (comp > 0) {\n"; - code += " span = middle;\n"; - code += " } else if (comp < 0) {\n"; - code += " middle++;\n"; - code += " start += middle;\n"; - code += " span -= middle;\n"; - code += " } else {\n"; - code += " return new " + struct_def.name; - code += "().__assign(tableOffset, bb);\n"; - code += " }\n }\n"; - code += " return null;\n"; - code += " }\n"; - } - code += "}"; - // Java does not need the closing semi-colon on class definitions. - code += (lang_.language != IDLOptions::kJava) ? ";" : ""; - code += "\n\n"; -} - const LanguageParameters& lang_; - // This tracks the current namespace used to determine if a type need to be prefixed by its namespace - const Namespace *cur_name_space_; + const LanguageParameters &lang_; + // This tracks the current namespace used to determine if a type need to be + // prefixed by its namespace + const Namespace *cur_name_space_; }; } // namespace general @@ -1424,9 +1424,8 @@ std::string GeneralMakeRule(const Parser &parser, const std::string &path, ++it) { auto &struct_def = **it; if (make_rule != "") make_rule += " "; - std::string directory = - BaseGenerator::NamespaceDir(parser, path, - *struct_def.defined_namespace); + std::string directory = BaseGenerator::NamespaceDir( + parser, path, *struct_def.defined_namespace); make_rule += directory + struct_def.name + lang.file_extension; } @@ -1438,36 +1437,31 @@ std::string GeneralMakeRule(const Parser &parser, const std::string &path, return make_rule; } -std::string BinaryFileName(const Parser &parser, - const std::string &path, +std::string BinaryFileName(const Parser &parser, const std::string &path, const std::string &file_name) { auto ext = parser.file_extension_.length() ? parser.file_extension_ : "bin"; return path + file_name + "." + ext; } -bool GenerateBinary(const Parser &parser, - const std::string &path, +bool GenerateBinary(const Parser &parser, const std::string &path, const std::string &file_name) { return !parser.builder_.GetSize() || flatbuffers::SaveFile( - BinaryFileName(parser, path, file_name).c_str(), - reinterpret_cast(parser.builder_.GetBufferPointer()), - parser.builder_.GetSize(), - true); + BinaryFileName(parser, path, file_name).c_str(), + reinterpret_cast(parser.builder_.GetBufferPointer()), + parser.builder_.GetSize(), true); } -std::string BinaryMakeRule(const Parser &parser, - const std::string &path, +std::string BinaryMakeRule(const Parser &parser, const std::string &path, const std::string &file_name) { if (!parser.builder_.GetSize()) return ""; - std::string filebase = flatbuffers::StripPath( - flatbuffers::StripExtension(file_name)); - std::string make_rule = BinaryFileName(parser, path, filebase) + ": " + - file_name; - auto included_files = parser.GetIncludedFilesRecursive( - parser.root_struct_def_->file); - for (auto it = included_files.begin(); - it != included_files.end(); ++it) { + std::string filebase = + flatbuffers::StripPath(flatbuffers::StripExtension(file_name)); + std::string make_rule = + BinaryFileName(parser, path, filebase) + ": " + file_name; + auto included_files = + parser.GetIncludedFilesRecursive(parser.root_struct_def_->file); + for (auto it = included_files.begin(); it != included_files.end(); ++it) { make_rule += " " + *it; } return make_rule; diff --git a/src/idl_gen_go.cpp b/src/idl_gen_go.cpp index 1f8e09e07..ddf60a59f 100644 --- a/src/idl_gen_go.cpp +++ b/src/idl_gen_go.cpp @@ -16,21 +16,21 @@ // independent from idl_parser, since this code is not needed for most clients -#include #include +#include +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" #ifdef _WIN32 -#include -#define PATH_SEPARATOR "\\" -#define mkdir(n, m) _mkdir(n) +# include +# define PATH_SEPARATOR "\\" +# define mkdir(n, m) _mkdir(n) #else -#include -#define PATH_SEPARATOR "/" +# include +# define PATH_SEPARATOR "/" #endif namespace flatbuffers { @@ -44,9 +44,10 @@ namespace go { // see https://golang.org/ref/spec#Keywords static const char *g_golang_keywords[] = { - "break", "default", "func", "interface", "select", "case", "defer", "go", - "map", "struct", "chan", "else", "goto", "package", "switch", "const", - "fallthrough", "if", "range", "type", "continue", "for", "import", "return", "var", + "break", "default", "func", "interface", "select", "case", "defer", + "go", "map", "struct", "chan", "else", "goto", "package", + "switch", "const", "fallthrough", "if", "range", "type", "continue", + "for", "import", "return", "var", }; static std::string GenGetter(const Type &type); @@ -57,23 +58,20 @@ static void GenReceiver(const StructDef &struct_def, std::string *code_ptr); static std::string GenTypeBasic(const Type &type); static std::string GenTypeGet(const Type &type); static std::string TypeName(const FieldDef &field); -static std::string GoIdentity(const std::string& name) { - for (size_t i=0; iname; + case BASE_TYPE_STRING: return "[]byte"; + case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType()); + case BASE_TYPE_STRUCT: return type.struct_def->name; case BASE_TYPE_UNION: // fall through - default: - return "*flatbuffers.Table"; + default: return "*flatbuffers.Table"; } } static std::string GenTypeGet(const Type &type) { - return IsScalar(type.base_type) - ? GenTypeBasic(type) - : GenTypePointer(type); + return IsScalar(type.base_type) ? GenTypeBasic(type) : GenTypePointer(type); } static std::string TypeName(const FieldDef &field) { @@ -749,7 +718,8 @@ class GoGenerator : public BaseGenerator { public: GoGenerator(const Parser &parser, const std::string &path, const std::string &file_name, const std::string &go_namespace) - : BaseGenerator(parser, path, file_name, "" /* not used*/, "" /* not used */) { + : BaseGenerator(parser, path, file_name, "" /* not used*/, + "" /* not used */) { std::istringstream iss(go_namespace); std::string component; while (std::getline(iss, component, '.')) { @@ -802,8 +772,8 @@ class GoGenerator : public BaseGenerator { if (needs_imports) { code += "import (\n"; if (!parser_.opts.go_import.empty()) { - code += "\tflatbuffers \"" + parser_.opts.go_import +"\"\n"; - } else{ + code += "\tflatbuffers \"" + parser_.opts.go_import + "\"\n"; + } else { code += "\tflatbuffers \"github.com/google/flatbuffers/go\"\n"; } code += ")\n\n"; @@ -815,12 +785,12 @@ class GoGenerator : public BaseGenerator { bool needs_imports) { if (!classcode.length()) return true; - Namespace& ns = go_namespace_.components.empty() ? *def.defined_namespace : go_namespace_; + Namespace &ns = go_namespace_.components.empty() ? *def.defined_namespace + : go_namespace_; std::string code = ""; BeginFile(LastNamespacePart(ns), needs_imports, &code); code += classcode; - std::string filename = - NamespaceDir(ns) + def.name + ".go"; + std::string filename = NamespaceDir(ns) + def.name + ".go"; return SaveFile(filename.c_str(), code, false); } diff --git a/src/idl_gen_grpc.cpp b/src/idl_gen_grpc.cpp index 3744e6d31..5f9f35e44 100644 --- a/src/idl_gen_grpc.cpp +++ b/src/idl_gen_grpc.cpp @@ -16,18 +16,19 @@ // independent from idl_parser, since this code is not needed for most clients +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" #include "src/compiler/cpp_generator.h" #include "src/compiler/go_generator.h" #include "src/compiler/java_generator.h" #if defined(_MSC_VER) -#pragma warning(push) -#pragma warning(disable: 4512) // C4512: 'class' : assignment operator could not be generated +# pragma warning(push) +# pragma warning(disable : 4512) // C4512: 'class' : assignment operator could + // not be generated #endif namespace flatbuffers { @@ -36,8 +37,7 @@ class FlatBufMethod : public grpc_generator::Method { public: enum Streaming { kNone, kClient, kServer, kBiDi }; - FlatBufMethod(const RPCCall *method) - : method_(method) { + FlatBufMethod(const RPCCall *method) : method_(method) { streaming_ = kNone; auto val = method_->attributes.Lookup("streaming"); if (val) { @@ -47,12 +47,8 @@ class FlatBufMethod : public grpc_generator::Method { } } - grpc::string GetLeadingComments(const grpc::string) const { - return ""; - } - grpc::string GetTrailingComments(const grpc::string) const { - return ""; - } + grpc::string GetLeadingComments(const grpc::string) const { return ""; } + grpc::string GetTrailingComments(const grpc::string) const { return ""; } std::vector GetAllComments() const { return method_->rpc_comment; } @@ -63,16 +59,13 @@ class FlatBufMethod : public grpc_generator::Method { return "flatbuffers::grpc::Message<" + sd.name + ">"; } - std::string get_input_type_name() const { - return (*method_->request).name; - } - std::string get_output_type_name() const { - return (*method_->response).name; - } + std::string get_input_type_name() const { return (*method_->request).name; } + std::string get_output_type_name() const { return (*method_->response).name; } - bool get_module_and_message_path_input( - grpc::string * /*str*/, grpc::string /*generator_file_name*/, - bool /*generate_in_pb2_grpc*/, grpc::string /*import_prefix*/) const { + bool get_module_and_message_path_input(grpc::string * /*str*/, + grpc::string /*generator_file_name*/, + bool /*generate_in_pb2_grpc*/, + grpc::string /*import_prefix*/) const { return true; } @@ -82,13 +75,9 @@ class FlatBufMethod : public grpc_generator::Method { return true; } - std::string input_type_name() const { - return GRPCType(*method_->request); - } + std::string input_type_name() const { return GRPCType(*method_->request); } - std::string output_type_name() const { - return GRPCType(*method_->response); - } + std::string output_type_name() const { return GRPCType(*method_->response); } bool NoStreaming() const { return streaming_ == kNone; } bool ClientStreaming() const { return streaming_ == kClient; } @@ -104,12 +93,8 @@ class FlatBufService : public grpc_generator::Service { public: FlatBufService(const ServiceDef *service) : service_(service) {} - grpc::string GetLeadingComments(const grpc::string) const { - return ""; - } - grpc::string GetTrailingComments(const grpc::string) const { - return ""; - } + grpc::string GetLeadingComments(const grpc::string) const { return ""; } + grpc::string GetTrailingComments(const grpc::string) const { return ""; } std::vector GetAllComments() const { return service_->doc_comment; } @@ -122,7 +107,7 @@ class FlatBufService : public grpc_generator::Service { std::unique_ptr method(int i) const { return std::unique_ptr( - new FlatBufMethod(service_->calls.vec[i])); + new FlatBufMethod(service_->calls.vec[i])); }; private: @@ -131,8 +116,7 @@ class FlatBufService : public grpc_generator::Service { class FlatBufPrinter : public grpc_generator::Printer { public: - FlatBufPrinter(std::string *str) - : str_(str), escape_char_('$'), indent_(0) {} + FlatBufPrinter(std::string *str) : str_(str), escape_char_('$'), indent_(0) {} void Print(const std::map &vars, const char *string_template) { @@ -155,15 +139,13 @@ class FlatBufPrinter : public grpc_generator::Printer { } void Print(const char *s) { - if (s == nullptr || std::strlen(s) == 0) { - return; - } + if (s == nullptr || std::strlen(s) == 0) { return; } // Add this string, but for each part separated by \n, add indentation. for (;;) { // Current indentation. str_->insert(str_->end(), indent_ * 2, ' '); // See if this contains more than one line. - const char * lf = strchr(s, '\n'); + const char *lf = strchr(s, '\n'); if (lf) { (*str_) += std::string(s, lf + 1); s = lf + 1; @@ -176,7 +158,10 @@ class FlatBufPrinter : public grpc_generator::Printer { } void Indent() { indent_++; } - void Outdent() { indent_--; assert(indent_ >= 0); } + void Outdent() { + indent_--; + assert(indent_ >= 0); + } private: std::string *str_; @@ -186,23 +171,15 @@ class FlatBufPrinter : public grpc_generator::Printer { class FlatBufFile : public grpc_generator::File { public: - enum Language { - kLanguageGo, - kLanguageCpp, - kLanguageJava - }; + enum Language { kLanguageGo, kLanguageCpp, kLanguageJava }; - FlatBufFile( - const Parser &parser, const std::string &file_name, Language language) - : parser_(parser), file_name_(file_name), language_(language) {} + FlatBufFile(const Parser &parser, const std::string &file_name, + Language language) + : parser_(parser), file_name_(file_name), language_(language) {} FlatBufFile &operator=(const FlatBufFile &); - grpc::string GetLeadingComments(const grpc::string) const { - return ""; - } - grpc::string GetTrailingComments(const grpc::string) const { - return ""; - } + grpc::string GetLeadingComments(const grpc::string) const { return ""; } + grpc::string GetTrailingComments(const grpc::string) const { return ""; } std::vector GetAllComments() const { return std::vector(); } @@ -243,13 +220,13 @@ class FlatBufFile : public grpc_generator::File { }; std::unique_ptr service(int i) const { - return std::unique_ptr ( - new FlatBufService(parser_.services_.vec[i])); + return std::unique_ptr( + new FlatBufService(parser_.services_.vec[i])); } - std::unique_ptr CreatePrinter(std::string *str) const { - return std::unique_ptr( - new FlatBufPrinter(str)); + std::unique_ptr CreatePrinter( + std::string *str) const { + return std::unique_ptr(new FlatBufPrinter(str)); } private: @@ -262,8 +239,10 @@ class GoGRPCGenerator : public flatbuffers::BaseGenerator { public: GoGRPCGenerator(const Parser &parser, const std::string &path, const std::string &file_name) - : BaseGenerator(parser, path, file_name, "", "" /*Unused*/), - parser_(parser), path_(path), file_name_(file_name) {} + : BaseGenerator(parser, path, file_name, "", "" /*Unused*/), + parser_(parser), + path_(path), + file_name_(file_name) {} bool generate() { FlatBufFile file(parser_, file_name_, FlatBufFile::kLanguageGo); @@ -273,10 +252,11 @@ class GoGRPCGenerator : public flatbuffers::BaseGenerator { auto service = file.service(i); const Definition *def = parser_.services_.vec[i]; p.package_name = LastNamespacePart(*(def->defined_namespace)); - std::string output = grpc_go_generator::GenerateServiceSource(&file, service.get(), &p); - std::string filename = NamespaceDir(*def->defined_namespace) + def->name + "_grpc.go"; - if (!flatbuffers::SaveFile(filename.c_str(), output, false)) - return false; + std::string output = + grpc_go_generator::GenerateServiceSource(&file, service.get(), &p); + std::string filename = + NamespaceDir(*def->defined_namespace) + def->name + "_grpc.go"; + if (!flatbuffers::SaveFile(filename.c_str(), output, false)) return false; } return true; } @@ -286,25 +266,22 @@ class GoGRPCGenerator : public flatbuffers::BaseGenerator { const std::string &path_, &file_name_; }; -bool GenerateGoGRPC(const Parser &parser, - const std::string &path, +bool GenerateGoGRPC(const Parser &parser, const std::string &path, const std::string &file_name) { int nservices = 0; - for (auto it = parser.services_.vec.begin(); - it != parser.services_.vec.end(); ++it) { + for (auto it = parser.services_.vec.begin(); it != parser.services_.vec.end(); + ++it) { if (!(*it)->generated) nservices++; } if (!nservices) return true; return GoGRPCGenerator(parser, path, file_name).generate(); } -bool GenerateCppGRPC(const Parser &parser, - const std::string &path, - const std::string &file_name) { - +bool GenerateCppGRPC(const Parser &parser, const std::string &path, + const std::string &file_name) { int nservices = 0; - for (auto it = parser.services_.vec.begin(); - it != parser.services_.vec.end(); ++it) { + for (auto it = parser.services_.vec.begin(); it != parser.services_.vec.end(); + ++it) { if (!(*it)->generated) nservices++; } if (!nservices) return true; @@ -335,8 +312,8 @@ bool GenerateCppGRPC(const Parser &parser, class JavaGRPCGenerator : public flatbuffers::BaseGenerator { public: - JavaGRPCGenerator(const Parser& parser, const std::string& path, - const std::string& file_name) + JavaGRPCGenerator(const Parser &parser, const std::string &path, + const std::string &file_name) : BaseGenerator(parser, path, file_name, "", "." /*separator*/), parser_(parser), path_(path), @@ -347,7 +324,7 @@ class JavaGRPCGenerator : public flatbuffers::BaseGenerator { grpc_java_generator::Parameters p; for (int i = 0; i < file.service_count(); i++) { auto service = file.service(i); - const Definition* def = parser_.services_.vec[i]; + const Definition *def = parser_.services_.vec[i]; p.package_name = def->defined_namespace->GetFullyQualifiedName(""); // file.package(); std::string output = @@ -360,12 +337,12 @@ class JavaGRPCGenerator : public flatbuffers::BaseGenerator { } protected: - const Parser& parser_; + const Parser &parser_; const std::string &path_, &file_name_; }; -bool GenerateJavaGRPC(const Parser& parser, const std::string& path, - const std::string& file_name) { +bool GenerateJavaGRPC(const Parser &parser, const std::string &path, + const std::string &file_name) { int nservices = 0; for (auto it = parser.services_.vec.begin(); it != parser.services_.vec.end(); ++it) { @@ -378,5 +355,5 @@ bool GenerateJavaGRPC(const Parser& parser, const std::string& path, } // namespace flatbuffers #if defined(_MSC_VER) -#pragma warning(pop) +# pragma warning(pop) #endif diff --git a/src/idl_gen_js.cpp b/src/idl_gen_js.cpp index cf7ac2f9a..42647cbaf 100644 --- a/src/idl_gen_js.cpp +++ b/src/idl_gen_js.cpp @@ -15,14 +15,14 @@ */ // independent from idl_parser, since this code is not needed for most clients -#include -#include #include +#include +#include +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" namespace flatbuffers { @@ -39,15 +39,15 @@ struct ReexportDescription { std::string target_namespace; }; -const JsLanguageParameters& GetJsLangParams(IDLOptions::Language lang) { +const JsLanguageParameters &GetJsLangParams(IDLOptions::Language lang) { static JsLanguageParameters js_language_parameters[] = { { - IDLOptions::kJs, - ".js", + IDLOptions::kJs, + ".js", }, { - IDLOptions::kTs, - ".ts", + IDLOptions::kTs, + ".ts", }, }; @@ -72,14 +72,12 @@ class JsGenerator : public BaseGenerator { public: typedef std::unordered_set imported_fileset; typedef std::unordered_multimap - reexport_map; + reexport_map; JsGenerator(const Parser &parser, const std::string &path, const std::string &file_name) : BaseGenerator(parser, path, file_name, "", "."), - lang_(GetJsLangParams(parser_.opts.lang)) - { - }; + lang_(GetJsLangParams(parser_.opts.lang)){}; // Iterate through all definitions we haven't generate code for (enums, // structs, and tables) and output them to a single file. bool generate() { @@ -133,39 +131,37 @@ class JsGenerator : public BaseGenerator { // Generate reexports, which might not have been explicitly imported using the // "export import" trick - void generateReexports(std::string *code_ptr, - const reexport_map &reexports, + void generateReexports(std::string *code_ptr, const reexport_map &reexports, imported_fileset imported_files) { - if (!parser_.opts.reexport_ts_modules || - lang_.language != IDLOptions::kTs) { - return; - } + if (!parser_.opts.reexport_ts_modules || + lang_.language != IDLOptions::kTs) { + return; + } - std::string &code = *code_ptr; - for (auto it = reexports.begin(); it != reexports.end(); ++it) { - const auto &file = *it; - const auto basename = - flatbuffers::StripPath(flatbuffers::StripExtension(file.first)); - if (basename != file_name_) { - const auto file_name = basename + kGeneratedFileNamePostfix; + std::string &code = *code_ptr; + for (auto it = reexports.begin(); it != reexports.end(); ++it) { + const auto &file = *it; + const auto basename = + flatbuffers::StripPath(flatbuffers::StripExtension(file.first)); + if (basename != file_name_) { + const auto file_name = basename + kGeneratedFileNamePostfix; - if (imported_files.find(file.first) == imported_files.end()) { - code += GenPrefixedImport(file.first, file_name); - imported_files.emplace(file.first); - } - - code += "export namespace " + file.second.target_namespace + " { \n"; - code += "export import " + file.second.symbol + " = "; - code += GenFileNamespacePrefix(file.first) + "." + - file.second.source_namespace + "." + file.second.symbol + - "; }\n"; + if (imported_files.find(file.first) == imported_files.end()) { + code += GenPrefixedImport(file.first, file_name); + imported_files.emplace(file.first); } + + code += "export namespace " + file.second.target_namespace + " { \n"; + code += "export import " + file.second.symbol + " = "; + code += GenFileNamespacePrefix(file.first) + "." + + file.second.source_namespace + "." + file.second.symbol + + "; }\n"; } + } } // Generate code for all enums. - void generateEnums(std::string *enum_code_ptr, - std::string *exports_code_ptr, + void generateEnums(std::string *enum_code_ptr, std::string *exports_code_ptr, reexport_map &reexports) { for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); ++it) { @@ -186,995 +182,987 @@ class JsGenerator : public BaseGenerator { } } void GenNamespaces(std::string *code_ptr, std::string *exports_ptr) { - if (lang_.language == IDLOptions::kTs && - parser_.opts.skip_flatbuffers_import) { - return; - } - - std::set namespaces; - - for (auto it = parser_.namespaces_.begin(); - it != parser_.namespaces_.end(); ++it) { - std::string namespace_so_far; - - // Gather all parent namespaces for this namespace - for (auto component = (*it)->components.begin(); - component != (*it)->components.end(); ++component) { - if (!namespace_so_far.empty()) { - namespace_so_far += '.'; - } - namespace_so_far += *component; - namespaces.insert(namespace_so_far); + if (lang_.language == IDLOptions::kTs && + parser_.opts.skip_flatbuffers_import) { + return; } - } - // Make sure parent namespaces come before child namespaces - std::vector sorted_namespaces( - namespaces.begin(), namespaces.end()); - std::sort(sorted_namespaces.begin(), sorted_namespaces.end()); + std::set namespaces; - // Emit namespaces in a form that Closure Compiler can optimize - std::string &code = *code_ptr; - std::string &exports = *exports_ptr; - for (auto it = sorted_namespaces.begin(); - it != sorted_namespaces.end(); it++) { - if (lang_.language == IDLOptions::kTs) { - if (it->find('.') == std::string::npos) { - code += "import { flatbuffers } from \"./flatbuffers\"\n"; - break; + for (auto it = parser_.namespaces_.begin(); it != parser_.namespaces_.end(); + ++it) { + std::string namespace_so_far; + + // Gather all parent namespaces for this namespace + for (auto component = (*it)->components.begin(); + component != (*it)->components.end(); ++component) { + if (!namespace_so_far.empty()) { namespace_so_far += '.'; } + namespace_so_far += *component; + namespaces.insert(namespace_so_far); } - } else { - code += "/**\n * @const\n * @namespace\n */\n"; - if (it->find('.') == std::string::npos) { - code += "var "; - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportSymbol('" + *it + "', " + *it + ");\n"; - } else { - exports += "this." + *it + " = " + *it + ";\n"; + } + + // Make sure parent namespaces come before child namespaces + std::vector sorted_namespaces(namespaces.begin(), + namespaces.end()); + std::sort(sorted_namespaces.begin(), sorted_namespaces.end()); + + // Emit namespaces in a form that Closure Compiler can optimize + std::string &code = *code_ptr; + std::string &exports = *exports_ptr; + for (auto it = sorted_namespaces.begin(); it != sorted_namespaces.end(); + it++) { + if (lang_.language == IDLOptions::kTs) { + if (it->find('.') == std::string::npos) { + code += "import { flatbuffers } from \"./flatbuffers\"\n"; + break; } + } else { + code += "/**\n * @const\n * @namespace\n */\n"; + if (it->find('.') == std::string::npos) { + code += "var "; + if (parser_.opts.use_goog_js_export_format) { + exports += "goog.exportSymbol('" + *it + "', " + *it + ");\n"; + } else { + exports += "this." + *it + " = " + *it + ";\n"; + } + } + code += *it + " = " + *it + " || {};\n\n"; } - code += *it + " = " + *it + " || {};\n\n"; } } -} -// Generate a documentation comment, if available. -static void GenDocComment(const std::vector &dc, - std::string *code_ptr, - const std::string &extra_lines, - const char *indent = nullptr) { - if (dc.empty() && extra_lines.empty()) { - // Don't output empty comment blocks with 0 lines of comment content. - return; - } + // Generate a documentation comment, if available. + static void GenDocComment(const std::vector &dc, + std::string *code_ptr, + const std::string &extra_lines, + const char *indent = nullptr) { + if (dc.empty() && extra_lines.empty()) { + // Don't output empty comment blocks with 0 lines of comment content. + return; + } - std::string &code = *code_ptr; - if (indent) code += indent; - code += "/**\n"; - for (auto it = dc.begin(); it != dc.end(); ++it) { + std::string &code = *code_ptr; if (indent) code += indent; - code += " *" + *it + "\n"; - } - if (!extra_lines.empty()) { - if (!dc.empty()) { + code += "/**\n"; + for (auto it = dc.begin(); it != dc.end(); ++it) { if (indent) code += indent; - code += " *\n"; + code += " *" + *it + "\n"; + } + if (!extra_lines.empty()) { + if (!dc.empty()) { + if (indent) code += indent; + code += " *\n"; + } + if (indent) code += indent; + std::string::size_type start = 0; + for (;;) { + auto end = extra_lines.find('\n', start); + if (end != std::string::npos) { + code += " * " + extra_lines.substr(start, end - start) + "\n"; + start = end + 1; + } else { + code += " * " + extra_lines.substr(start) + "\n"; + break; + } + } } if (indent) code += indent; - std::string::size_type start = 0; - for (;;) { - auto end = extra_lines.find('\n', start); - if (end != std::string::npos) { - code += " * " + extra_lines.substr(start, end - start) + "\n"; - start = end + 1; - } else { - code += " * " + extra_lines.substr(start) + "\n"; - break; - } - } - } - if (indent) code += indent; - code += " */\n"; -} - -static void GenDocComment(std::string *code_ptr, - const std::string &extra_lines) { - GenDocComment(std::vector(), code_ptr, extra_lines); -} - -// Generate an enum declaration and an enum string lookup table. -void GenEnum(EnumDef &enum_def, std::string *code_ptr, - std::string *exports_ptr, reexport_map &reexports) { - if (enum_def.generated) return; - std::string &code = *code_ptr; - std::string &exports = *exports_ptr; - GenDocComment(enum_def.doc_comment, code_ptr, "@enum"); - std::string ns = GetNameSpace(enum_def); - if (lang_.language == IDLOptions::kTs) { - if (!ns.empty()) { - code += "export namespace " + ns + "{\n"; - } - code += "export enum " + enum_def.name + "{\n"; - } else { - if (enum_def.defined_namespace->components.empty()) { - code += "var "; - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportSymbol('" + enum_def.name + "', " + - enum_def.name + ");\n"; - } else { - exports += "this." + enum_def.name + " = " + enum_def.name + ";\n"; - } - } - code += WrapInNameSpace(enum_def) + " = {\n"; - } - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); ++it) { - auto &ev = **it; - if (!ev.doc_comment.empty()) { - if (it != enum_def.vals.vec.begin()) { - code += '\n'; - } - GenDocComment(ev.doc_comment, code_ptr, "", " "); - } - code += " " + ev.name; - code += lang_.language == IDLOptions::kTs ? "= " : ": "; - code += NumToString(ev.value); - code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n"; - - if (ev.union_type.struct_def) { - ReexportDescription desc = { - ev.name, - GetNameSpace(*ev.union_type.struct_def), - GetNameSpace(enum_def) - }; - reexports.insert(std::make_pair(ev.union_type.struct_def->file, - std::move(desc))); - } + code += " */\n"; } - if (lang_.language == IDLOptions::kTs && !ns.empty()) { - code += "}"; - } - code += "};\n\n"; -} - -static std::string GenType(const Type &type) { - switch (type.base_type) { - case BASE_TYPE_BOOL: - case BASE_TYPE_CHAR: return "Int8"; - case BASE_TYPE_UTYPE: - case BASE_TYPE_UCHAR: return "Uint8"; - case BASE_TYPE_SHORT: return "Int16"; - case BASE_TYPE_USHORT: return "Uint16"; - case BASE_TYPE_INT: return "Int32"; - case BASE_TYPE_UINT: return "Uint32"; - case BASE_TYPE_LONG: return "Int64"; - case BASE_TYPE_ULONG: return "Uint64"; - case BASE_TYPE_FLOAT: return "Float32"; - case BASE_TYPE_DOUBLE: return "Float64"; - case BASE_TYPE_STRING: return "String"; - case BASE_TYPE_VECTOR: return GenType(type.VectorType()); - case BASE_TYPE_STRUCT: return type.struct_def->name; - default: return "Table"; - } -} - -std::string GenGetter(const Type &type, const std::string &arguments) { - switch (type.base_type) { - case BASE_TYPE_STRING: return GenBBAccess() + ".__string" + arguments; - case BASE_TYPE_STRUCT: return GenBBAccess() + ".__struct" + arguments; - case BASE_TYPE_UNION: return GenBBAccess() + ".__union" + arguments; - case BASE_TYPE_VECTOR: return GenGetter(type.VectorType(), arguments); - default: { - auto getter = GenBBAccess() + ".read" + MakeCamel(GenType(type)) + arguments; - if (type.base_type == BASE_TYPE_BOOL) { - getter = "!!" + getter; - } - if (type.enum_def) { - getter = "/** @type {" + WrapInNameSpace(*type.enum_def) + "} */ (" + - getter + ")"; - } - return getter; - } - } -} - -std::string GenBBAccess() { - return lang_.language == IDLOptions::kTs ? "this.bb!" : "this.bb"; -} - -std::string GenDefaultValue(const Value &value, const std::string &context) { - if (value.type.enum_def) { - if (auto val = value.type.enum_def->ReverseLookup( - atoi(value.constant.c_str()), false)) { - if (lang_.language == IDLOptions::kTs) { - return GenPrefixedTypeName(WrapInNameSpace(*value.type.enum_def), - value.type.enum_def->file) + "." + val->name; - } else { - return WrapInNameSpace(*value.type.enum_def) + "." + val->name; - } - } else { - return "/** @type {" + WrapInNameSpace(*value.type.enum_def) + "} */ (" - + value.constant + ")"; - } + static void GenDocComment(std::string *code_ptr, + const std::string &extra_lines) { + GenDocComment(std::vector(), code_ptr, extra_lines); } - switch (value.type.base_type) { - case BASE_TYPE_BOOL: - return value.constant == "0" ? "false" : "true"; - - case BASE_TYPE_STRING: - return "null"; - - case BASE_TYPE_LONG: - case BASE_TYPE_ULONG: { - int64_t constant = StringToInt(value.constant.c_str()); - return context + ".createLong(" + NumToString((int32_t)constant) + - ", " + NumToString((int32_t)(constant >> 32)) + ")"; - } - - default: - return value.constant; - } -} - -std::string GenTypeName(const Type &type, bool input, bool allowNull = false) { - if (!input) { - if (type.base_type == BASE_TYPE_STRING || type.base_type == BASE_TYPE_STRUCT) { - std::string name; - if (type.base_type == BASE_TYPE_STRING) { - name = "string|Uint8Array"; - } else { - name = WrapInNameSpace(*type.struct_def); - } - return (allowNull) ? (name + "|null") : (name); - } - } - - switch (type.base_type) { - case BASE_TYPE_BOOL: return "boolean"; - case BASE_TYPE_LONG: - case BASE_TYPE_ULONG: return "flatbuffers.Long"; - default: - if (IsScalar(type.base_type)) { - if (type.enum_def) { - return WrapInNameSpace(*type.enum_def); - } - return "number"; - } - return "flatbuffers.Offset"; - } -} - -// Returns the method name for use with add/put calls. -static std::string GenWriteMethod(const Type &type) { - // Forward to signed versions since unsigned versions don't exist - switch (type.base_type) { - case BASE_TYPE_UTYPE: - case BASE_TYPE_UCHAR: return GenWriteMethod(Type(BASE_TYPE_CHAR)); - case BASE_TYPE_USHORT: return GenWriteMethod(Type(BASE_TYPE_SHORT)); - case BASE_TYPE_UINT: return GenWriteMethod(Type(BASE_TYPE_INT)); - case BASE_TYPE_ULONG: return GenWriteMethod(Type(BASE_TYPE_LONG)); - default: break; - } - - return IsScalar(type.base_type) - ? MakeCamel(GenType(type)) - : (IsStruct(type) ? "Struct" : "Offset"); -} - -template -static std::string MaybeAdd(T value) { - return value != 0 ? " + " + NumToString(value) : ""; -} - -template -static std::string MaybeScale(T value) { - return value != 1 ? " * " + NumToString(value) : ""; -} - -static std::string GenFileNamespacePrefix(const std::string &file) { - return "NS" + std::to_string( - static_cast(std::hash()(file))); -} - -static std::string GenPrefixedImport(const std::string &full_file_name, - const std::string &base_file_name) { - return "import * as "+ GenFileNamespacePrefix(full_file_name) + - " from \"./" + base_file_name + "\";\n"; -} - -// Adds a source-dependent prefix, for of import * statements. -std::string GenPrefixedTypeName(const std::string &typeName, - const std::string &file) { - const auto basename = - flatbuffers::StripPath(flatbuffers::StripExtension(file)); - if (basename == file_name_) { - return typeName; - } - return GenFileNamespacePrefix(file) + "." + typeName; -} - -void GenStructArgs(const StructDef &struct_def, - std::string *annotations, - std::string *arguments, - const std::string &nameprefix) { - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (IsStruct(field.value.type)) { - // Generate arguments for a struct inside a struct. To ensure names - // don't clash, and to make it obvious these arguments are constructing - // a nested struct, prefix the name with the field name. - GenStructArgs(*field.value.type.struct_def, annotations, arguments, - nameprefix + field.name + "_"); - } else { - *annotations += "@param {" + GenTypeName(field.value.type, true); - *annotations += "} " + nameprefix + field.name + "\n"; - - if (lang_.language == IDLOptions::kTs) { - *arguments += ", " + nameprefix + field.name + ": " + - GenTypeName(field.value.type, true); - } else { - *arguments += ", " + nameprefix + field.name; - } - } - } -} - -static void GenStructBody(const StructDef &struct_def, - std::string *body, - const std::string &nameprefix) { - *body += " builder.prep("; - *body += NumToString(struct_def.minalign) + ", "; - *body += NumToString(struct_def.bytesize) + ");\n"; - - for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); ++it) { - auto &field = **it; - if (field.padding) { - *body += " builder.pad(" + NumToString(field.padding) + ");\n"; - } - if (IsStruct(field.value.type)) { - // Generate arguments for a struct inside a struct. To ensure names - // don't clash, and to make it obvious these arguments are constructing - // a nested struct, prefix the name with the field name. - GenStructBody(*field.value.type.struct_def, body, - nameprefix + field.name + "_"); - } else { - *body += " builder.write" + GenWriteMethod(field.value.type) + "("; - if (field.value.type.base_type == BASE_TYPE_BOOL) { - *body += "+"; - } - *body += nameprefix + field.name + ");\n"; - } - } -} - -// Generate an accessor struct with constructor for a flatbuffers struct. -void GenStruct(const Parser &parser, StructDef &struct_def, - std::string *code_ptr, std::string *exports_ptr, - imported_fileset &imported_files) { - if (struct_def.generated) return; - std::string &code = *code_ptr; - std::string &exports = *exports_ptr; - - std::string object_name; - std::string object_namespace = GetNameSpace(struct_def); - - // Emit constructor - if (lang_.language == IDLOptions::kTs) { - object_name = struct_def.name; - GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); - if (!object_namespace.empty()) { - code += "export namespace " + object_namespace + "{\n"; - } - code += "export class " + struct_def.name; - code += " {\n"; - code += " /**\n"; - code += " * @type {flatbuffers.ByteBuffer}\n"; - code += " */\n"; - code += " bb: flatbuffers.ByteBuffer|null = null;\n"; - code += "\n"; - code += " /**\n"; - code += " * @type {number}\n"; - code += " */\n"; - code += " bb_pos:number = 0;\n"; - } else { - bool isStatement = struct_def.defined_namespace->components.empty(); - object_name = WrapInNameSpace(struct_def); - GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); - if (isStatement) { - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportSymbol('" + struct_def.name + "', " + - struct_def.name + ");\n"; - } else { - exports += "this." + struct_def.name + " = " + struct_def.name + ";\n"; - } - code += "function " + object_name; - } else { - code += object_name + " = function"; - } - code += "() {\n"; - code += " /**\n"; - code += " * @type {flatbuffers.ByteBuffer}\n"; - code += " */\n"; - code += " this.bb = null;\n"; - code += "\n"; - code += " /**\n"; - code += " * @type {number}\n"; - code += " */\n"; - code += " this.bb_pos = 0;\n"; - code += isStatement ? "}\n\n" : "};\n\n"; - } - - // Generate the __init method that sets the field in a pre-existing - // accessor object. This is to allow object reuse. - code += "/**\n"; - code += " * @param {number} i\n"; - code += " * @param {flatbuffers.ByteBuffer} bb\n"; - code += " * @returns {" + object_name + "}\n"; - code += " */\n"; - - if (lang_.language == IDLOptions::kTs) { - code += "__init(i:number, bb:flatbuffers.ByteBuffer):" + object_name + - " {\n"; - } else { - code += object_name + ".prototype.__init = function(i, bb) {\n"; - } - - code += " this.bb_pos = i;\n"; - code += " this.bb = bb;\n"; - code += " return this;\n"; - code += "};\n\n"; - - // Generate a special accessor for the table that when used as the root of a - // FlatBuffer - if (!struct_def.fixed) { - GenDocComment(code_ptr, - "@param {flatbuffers.ByteBuffer} bb\n" - "@param {" + object_name + "=} obj\n" - "@returns {" + object_name + "}"); + // Generate an enum declaration and an enum string lookup table. + void GenEnum(EnumDef &enum_def, std::string *code_ptr, + std::string *exports_ptr, reexport_map &reexports) { + if (enum_def.generated) return; + std::string &code = *code_ptr; + std::string &exports = *exports_ptr; + GenDocComment(enum_def.doc_comment, code_ptr, "@enum"); + std::string ns = GetNameSpace(enum_def); if (lang_.language == IDLOptions::kTs) { - code += "static getRootAs" + struct_def.name; - code += "(bb:flatbuffers.ByteBuffer, obj?:" + object_name + "):" + - object_name + " {\n"; + if (!ns.empty()) { code += "export namespace " + ns + "{\n"; } + code += "export enum " + enum_def.name + "{\n"; } else { - code += object_name + ".getRootAs" + struct_def.name; - code += " = function(bb, obj) {\n"; - } - code += " return (obj || new " + object_name; - code += ").__init(bb.readInt32(bb.position()) + bb.position(), bb);\n"; - code += "};\n\n"; - - // Generate the identifier check method - if (parser_.root_struct_def_ == &struct_def && - !parser_.file_identifier_.empty()) { - GenDocComment(code_ptr, - "@param {flatbuffers.ByteBuffer} bb\n" - "@returns {boolean}"); - if (lang_.language == IDLOptions::kTs) { - code += - "static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {\n"; - } else { - code += object_name + ".bufferHasIdentifier = function(bb) {\n"; + if (enum_def.defined_namespace->components.empty()) { + code += "var "; + if (parser_.opts.use_goog_js_export_format) { + exports += "goog.exportSymbol('" + enum_def.name + "', " + + enum_def.name + ");\n"; + } else { + exports += "this." + enum_def.name + " = " + enum_def.name + ";\n"; + } } + code += WrapInNameSpace(enum_def) + " = {\n"; + } + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); + ++it) { + auto &ev = **it; + if (!ev.doc_comment.empty()) { + if (it != enum_def.vals.vec.begin()) { code += '\n'; } + GenDocComment(ev.doc_comment, code_ptr, "", " "); + } + code += " " + ev.name; + code += lang_.language == IDLOptions::kTs ? "= " : ": "; + code += NumToString(ev.value); + code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n"; - code += " return bb.__has_identifier('" + parser_.file_identifier_; - code += "');\n};\n\n"; + if (ev.union_type.struct_def) { + ReexportDescription desc = { ev.name, + GetNameSpace(*ev.union_type.struct_def), + GetNameSpace(enum_def) }; + reexports.insert( + std::make_pair(ev.union_type.struct_def->file, std::move(desc))); + } + } + + if (lang_.language == IDLOptions::kTs && !ns.empty()) { code += "}"; } + code += "};\n\n"; + } + + static std::string GenType(const Type &type) { + switch (type.base_type) { + case BASE_TYPE_BOOL: + case BASE_TYPE_CHAR: return "Int8"; + case BASE_TYPE_UTYPE: + case BASE_TYPE_UCHAR: return "Uint8"; + case BASE_TYPE_SHORT: return "Int16"; + case BASE_TYPE_USHORT: return "Uint16"; + case BASE_TYPE_INT: return "Int32"; + case BASE_TYPE_UINT: return "Uint32"; + case BASE_TYPE_LONG: return "Int64"; + case BASE_TYPE_ULONG: return "Uint64"; + case BASE_TYPE_FLOAT: return "Float32"; + case BASE_TYPE_DOUBLE: return "Float64"; + case BASE_TYPE_STRING: return "String"; + case BASE_TYPE_VECTOR: return GenType(type.VectorType()); + case BASE_TYPE_STRUCT: return type.struct_def->name; + default: return "Table"; } } - // Emit field accessors - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; - auto offset_prefix = " var offset = " + GenBBAccess() + - ".__offset(this.bb_pos, " + NumToString(field.value.offset) + - ");\n return offset ? "; + std::string GenGetter(const Type &type, const std::string &arguments) { + switch (type.base_type) { + case BASE_TYPE_STRING: return GenBBAccess() + ".__string" + arguments; + case BASE_TYPE_STRUCT: return GenBBAccess() + ".__struct" + arguments; + case BASE_TYPE_UNION: return GenBBAccess() + ".__union" + arguments; + case BASE_TYPE_VECTOR: return GenGetter(type.VectorType(), arguments); + default: { + auto getter = + GenBBAccess() + ".read" + MakeCamel(GenType(type)) + arguments; + if (type.base_type == BASE_TYPE_BOOL) { getter = "!!" + getter; } + if (type.enum_def) { + getter = "/** @type {" + WrapInNameSpace(*type.enum_def) + "} */ (" + + getter + ")"; + } + return getter; + } + } + } - // Emit a scalar field - if (IsScalar(field.value.type.base_type) || - field.value.type.base_type == BASE_TYPE_STRING) { - GenDocComment(field.doc_comment, code_ptr, - std::string(field.value.type.base_type == BASE_TYPE_STRING ? - "@param {flatbuffers.Encoding=} optionalEncoding\n" : "") + - "@returns {" + GenTypeName(field.value.type, false, true) + "}"); - if (lang_.language == IDLOptions::kTs) { - std::string prefix = MakeCamel(field.name, false) + "("; - if (field.value.type.base_type == BASE_TYPE_STRING) { - code += prefix + "):string|null\n"; - code += prefix + "optionalEncoding:flatbuffers.Encoding"+"):" + - GenTypeName(field.value.type, false, true)+"\n"; - code += prefix + "optionalEncoding?:any"; + std::string GenBBAccess() { + return lang_.language == IDLOptions::kTs ? "this.bb!" : "this.bb"; + } + + std::string GenDefaultValue(const Value &value, const std::string &context) { + if (value.type.enum_def) { + if (auto val = value.type.enum_def->ReverseLookup( + atoi(value.constant.c_str()), false)) { + if (lang_.language == IDLOptions::kTs) { + return GenPrefixedTypeName(WrapInNameSpace(*value.type.enum_def), + value.type.enum_def->file) + + "." + val->name; } else { - code += prefix; + return WrapInNameSpace(*value.type.enum_def) + "." + val->name; } - if (field.value.type.enum_def) { - code += "):" + - GenPrefixedTypeName(GenTypeName(field.value.type, false, true), - field.value.type.enum_def->file) + " {\n"; + } else { + return "/** @type {" + WrapInNameSpace(*value.type.enum_def) + + "} */ (" + value.constant + ")"; + } + } + + switch (value.type.base_type) { + case BASE_TYPE_BOOL: return value.constant == "0" ? "false" : "true"; + + case BASE_TYPE_STRING: return "null"; + + case BASE_TYPE_LONG: + case BASE_TYPE_ULONG: { + int64_t constant = StringToInt(value.constant.c_str()); + return context + ".createLong(" + NumToString((int32_t)constant) + + ", " + NumToString((int32_t)(constant >> 32)) + ")"; + } + + default: return value.constant; + } + } + + std::string GenTypeName(const Type &type, bool input, + bool allowNull = false) { + if (!input) { + if (type.base_type == BASE_TYPE_STRING || + type.base_type == BASE_TYPE_STRUCT) { + std::string name; + if (type.base_type == BASE_TYPE_STRING) { + name = "string|Uint8Array"; } else { - code += "):" + GenTypeName(field.value.type, false, true) + " {\n"; + name = WrapInNameSpace(*type.struct_def); } - } else { - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function("; - if (field.value.type.base_type == BASE_TYPE_STRING) { - code += "optionalEncoding"; - } - code += ") {\n"; - } - - if (struct_def.fixed) { - code += " return " + GenGetter(field.value.type, "(this.bb_pos" + - MaybeAdd(field.value.offset) + ")") + ";\n"; - } else { - std::string index = "this.bb_pos + offset"; - if (field.value.type.base_type == BASE_TYPE_STRING) { - index += ", optionalEncoding"; - } - code += offset_prefix + GenGetter(field.value.type, - "(" + index + ")") + " : " + GenDefaultValue(field.value, GenBBAccess()); - code += ";\n"; + return (allowNull) ? (name + "|null") : (name); } } - // Emit an object field - else { - switch (field.value.type.base_type) { - case BASE_TYPE_STRUCT: { - auto type = WrapInNameSpace(*field.value.type.struct_def); - GenDocComment(field.doc_comment, code_ptr, - "@param {" + type + "=} obj\n@returns {" + type + "|null}"); - if (lang_.language == IDLOptions::kTs) { - type = GenPrefixedTypeName(type, field.value.type.struct_def->file); - code += MakeCamel(field.name, false); - code += "(obj?:" + type + "):" + type + "|null {\n"; - } else { - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function(obj) {\n"; - } - - if (struct_def.fixed) { - code += " return (obj || new " + type; - code += ").__init(this.bb_pos"; - code += MaybeAdd(field.value.offset) + ", " + GenBBAccess() + ");\n"; - } else { - code += offset_prefix + "(obj || new " + type + ").__init("; - code += field.value.type.struct_def->fixed - ? "this.bb_pos + offset" - : GenBBAccess() + ".__indirect(this.bb_pos + offset)"; - code += ", " + GenBBAccess() + ") : null;\n"; - } - - if (lang_.language == IDLOptions::kTs) { - imported_files.insert(field.value.type.struct_def->file); - } - - break; + switch (type.base_type) { + case BASE_TYPE_BOOL: return "boolean"; + case BASE_TYPE_LONG: + case BASE_TYPE_ULONG: return "flatbuffers.Long"; + default: + if (IsScalar(type.base_type)) { + if (type.enum_def) { return WrapInNameSpace(*type.enum_def); } + return "number"; } - - case BASE_TYPE_VECTOR: { - auto vectortype = field.value.type.VectorType(); - auto vectortypename = GenTypeName(vectortype, false); - auto inline_size = InlineSize(vectortype); - auto index = GenBBAccess() + ".__vector(this.bb_pos + offset) + index" + - MaybeScale(inline_size); - std::string args = "@param {number} index\n"; - std::string ret_type; - bool is_union = false; - switch (vectortype.base_type) { - case BASE_TYPE_STRUCT: - args += "@param {" + vectortypename + "=} obj\n"; - ret_type = vectortypename; - break; - case BASE_TYPE_STRING: - args += "@param {flatbuffers.Encoding=} optionalEncoding\n"; - ret_type = vectortypename; - break; - case BASE_TYPE_UNION: - args += "@param {flatbuffers.Table=} obj\n"; - ret_type = "?flatbuffers.Table"; - is_union = true; - break; - default: - ret_type = vectortypename; - } - GenDocComment(field.doc_comment, code_ptr, args + - "@returns {" + ret_type + "}"); - if (lang_.language == IDLOptions::kTs) { - std::string prefix = MakeCamel(field.name, false); - if (is_union) { - prefix += ""; - } - prefix += "(index: number"; - if (is_union) { - vectortypename = "T"; - code += prefix + ", obj:T"; - } else if (vectortype.base_type == BASE_TYPE_STRUCT) { - vectortypename = GenPrefixedTypeName(vectortypename, - vectortype.struct_def->file); - code += prefix + ", obj?:" + vectortypename; - imported_files.insert(vectortype.struct_def->file); - } else if (vectortype.base_type == BASE_TYPE_STRING) { - code += prefix + "):string\n"; - code += prefix + ",optionalEncoding:flatbuffers.Encoding" + "):" + - vectortypename + "\n"; - code += prefix + ",optionalEncoding?:any"; - } else { - code += prefix; - } - code += "):" + vectortypename + "|null {\n"; - } else { - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function(index"; - if (vectortype.base_type == BASE_TYPE_STRUCT || is_union) { - code += ", obj"; - } else if (vectortype.base_type == BASE_TYPE_STRING) { - code += ", optionalEncoding"; - } - code += ") {\n"; - } - - if (vectortype.base_type == BASE_TYPE_STRUCT) { - code += offset_prefix + "(obj || new " + vectortypename; - code += ").__init("; - code += vectortype.struct_def->fixed - ? index - : GenBBAccess() + ".__indirect(" + index + ")"; - code += ", " + GenBBAccess() + ")"; - } else { - if (is_union) { - index = "obj, " + index; - } else if (vectortype.base_type == BASE_TYPE_STRING) { - index += ", optionalEncoding"; - } - code += offset_prefix + GenGetter(vectortype, "(" + index + ")"); - } - code += " : "; - if (field.value.type.element == BASE_TYPE_BOOL) { - code += "false"; - } else if (field.value.type.element == BASE_TYPE_LONG || - field.value.type.element == BASE_TYPE_ULONG) { - code += GenBBAccess() + ".createLong(0, 0)"; - } else if (IsScalar(field.value.type.element)) { - if (field.value.type.enum_def) { - code += "/** @type {" + - WrapInNameSpace(*field.value.type.enum_def) + "} */ (" + - field.value.constant + ")"; - } else { - code += "0"; - } - } else { - code += "null"; - } - code += ";\n"; - break; - } - - case BASE_TYPE_UNION: - GenDocComment(field.doc_comment, code_ptr, - "@param {flatbuffers.Table} obj\n" - "@returns {?flatbuffers.Table}"); - if (lang_.language == IDLOptions::kTs) { - code += MakeCamel(field.name, false); - code += "(obj:T):T|null {\n"; - } else { - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += " = function(obj) {\n"; - } - - code += offset_prefix + GenGetter(field.value.type, - "(obj, this.bb_pos + offset)") + " : null;\n"; - break; - - default: - assert(0); - } + return "flatbuffers.Offset"; } - code += "};\n\n"; + } - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportProperty(" + object_name + ".prototype, '" + - MakeCamel(field.name, false) + "', " + object_name + ".prototype." + - MakeCamel(field.name, false) + ");\n"; + // Returns the method name for use with add/put calls. + static std::string GenWriteMethod(const Type &type) { + // Forward to signed versions since unsigned versions don't exist + switch (type.base_type) { + case BASE_TYPE_UTYPE: + case BASE_TYPE_UCHAR: return GenWriteMethod(Type(BASE_TYPE_CHAR)); + case BASE_TYPE_USHORT: return GenWriteMethod(Type(BASE_TYPE_SHORT)); + case BASE_TYPE_UINT: return GenWriteMethod(Type(BASE_TYPE_INT)); + case BASE_TYPE_ULONG: return GenWriteMethod(Type(BASE_TYPE_LONG)); + default: break; } - // Adds the mutable scalar value to the output - if (IsScalar(field.value.type.base_type) && parser.opts.mutable_buffer) { - std::string annotations = - "@param {" + GenTypeName(field.value.type, true) + "} value\n"; - GenDocComment(code_ptr, annotations + - "@returns {boolean}"); + return IsScalar(type.base_type) ? MakeCamel(GenType(type)) + : (IsStruct(type) ? "Struct" : "Offset"); + } - if (lang_.language == IDLOptions::kTs) { - std::string type; - if (field.value.type.enum_def) { - type = GenPrefixedTypeName(GenTypeName(field.value.type, true), - field.value.type.enum_def->file); - } else { - type = GenTypeName(field.value.type, true); - } + template static std::string MaybeAdd(T value) { + return value != 0 ? " + " + NumToString(value) : ""; + } - code += "mutate_" + field.name + "(value:" + type + "):boolean {\n"; + template static std::string MaybeScale(T value) { + return value != 1 ? " * " + NumToString(value) : ""; + } + + static std::string GenFileNamespacePrefix(const std::string &file) { + return "NS" + std::to_string(static_cast( + std::hash()(file))); + } + + static std::string GenPrefixedImport(const std::string &full_file_name, + const std::string &base_file_name) { + return "import * as " + GenFileNamespacePrefix(full_file_name) + + " from \"./" + base_file_name + "\";\n"; + } + + // Adds a source-dependent prefix, for of import * statements. + std::string GenPrefixedTypeName(const std::string &typeName, + const std::string &file) { + const auto basename = + flatbuffers::StripPath(flatbuffers::StripExtension(file)); + if (basename == file_name_) { return typeName; } + return GenFileNamespacePrefix(file) + "." + typeName; + } + + void GenStructArgs(const StructDef &struct_def, std::string *annotations, + std::string *arguments, const std::string &nameprefix) { + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (IsStruct(field.value.type)) { + // Generate arguments for a struct inside a struct. To ensure names + // don't clash, and to make it obvious these arguments are constructing + // a nested struct, prefix the name with the field name. + GenStructArgs(*field.value.type.struct_def, annotations, arguments, + nameprefix + field.name + "_"); } else { - code += object_name + ".prototype.mutate_" + field.name + - " = function(value) {\n"; - } - - code += " var offset = " + GenBBAccess() + ".__offset(this.bb_pos, " + - NumToString(field.value.offset) + ");\n\n"; - code += " if (offset === 0) {\n"; - code += " return false;\n"; - code += " }\n\n"; - - // special case for bools, which are treated as uint8 - code += " " + GenBBAccess() + ".write" + - MakeCamel(GenType(field.value.type)) + "(this.bb_pos + offset, "; - if (field.value.type.base_type == BASE_TYPE_BOOL && - lang_.language == IDLOptions::kTs) { - code += "+"; - } - - code += "value);\n"; - code += " return true;\n"; - code += "};\n\n"; - - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportProperty(" + object_name + - ".prototype, 'mutate_" + field.name + "', " + object_name + - ".prototype.mutate_" + field.name + ");\n"; - } - } - - // Emit vector helpers - if (field.value.type.base_type == BASE_TYPE_VECTOR) { - // Emit a length helper - GenDocComment(code_ptr, "@returns {number}"); - if (lang_.language == IDLOptions::kTs) { - code += MakeCamel(field.name, false); - code += "Length():number {\n" + offset_prefix; - } else { - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += "Length = function() {\n" + offset_prefix; - } - - code += GenBBAccess() + ".__vector_len(this.bb_pos + offset) : 0;\n};\n\n"; - - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportProperty(" + object_name + ".prototype, '" + - MakeCamel(field.name, false) + "Length', " + object_name + - ".prototype." + MakeCamel(field.name, false) + "Length);\n"; - } - - // For scalar types, emit a typed array helper - auto vectorType = field.value.type.VectorType(); - if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) { - GenDocComment(code_ptr, "@returns {" + GenType(vectorType) + "Array}"); + *annotations += "@param {" + GenTypeName(field.value.type, true); + *annotations += "} " + nameprefix + field.name + "\n"; if (lang_.language == IDLOptions::kTs) { - code += MakeCamel(field.name, false); - code += "Array():" + GenType(vectorType) + "Array|null {\n" + - offset_prefix; + *arguments += ", " + nameprefix + field.name + ": " + + GenTypeName(field.value.type, true); } else { - code += object_name + ".prototype." + MakeCamel(field.name, false); - code += "Array = function() {\n" + offset_prefix; - } - - code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() + - ".bytes().buffer, " + GenBBAccess() + ".bytes().byteOffset + " + - GenBBAccess() + ".__vector(this.bb_pos + offset), " + - GenBBAccess() + ".__vector_len(this.bb_pos + offset)) : null;\n};\n\n"; - - if(parser_.opts.use_goog_js_export_format) { - exports += "goog.exportProperty(" + object_name + ".prototype, '" + - MakeCamel(field.name, false) + "Array', " + object_name + - ".prototype." + MakeCamel(field.name, false) + "Array);\n"; + *arguments += ", " + nameprefix + field.name; } } } } - // Emit a factory constructor - if (struct_def.fixed) { - std::string annotations = "@param {flatbuffers.Builder} builder\n"; - std::string arguments; - GenStructArgs(struct_def, &annotations, &arguments, ""); - GenDocComment(code_ptr, annotations + - "@returns {flatbuffers.Offset}"); + static void GenStructBody(const StructDef &struct_def, std::string *body, + const std::string &nameprefix) { + *body += " builder.prep("; + *body += NumToString(struct_def.minalign) + ", "; + *body += NumToString(struct_def.bytesize) + ");\n"; + for (auto it = struct_def.fields.vec.rbegin(); + it != struct_def.fields.vec.rend(); ++it) { + auto &field = **it; + if (field.padding) { + *body += " builder.pad(" + NumToString(field.padding) + ");\n"; + } + if (IsStruct(field.value.type)) { + // Generate arguments for a struct inside a struct. To ensure names + // don't clash, and to make it obvious these arguments are constructing + // a nested struct, prefix the name with the field name. + GenStructBody(*field.value.type.struct_def, body, + nameprefix + field.name + "_"); + } else { + *body += " builder.write" + GenWriteMethod(field.value.type) + "("; + if (field.value.type.base_type == BASE_TYPE_BOOL) { *body += "+"; } + *body += nameprefix + field.name + ");\n"; + } + } + } + + // Generate an accessor struct with constructor for a flatbuffers struct. + void GenStruct(const Parser &parser, StructDef &struct_def, + std::string *code_ptr, std::string *exports_ptr, + imported_fileset &imported_files) { + if (struct_def.generated) return; + std::string &code = *code_ptr; + std::string &exports = *exports_ptr; + + std::string object_name; + std::string object_namespace = GetNameSpace(struct_def); + + // Emit constructor if (lang_.language == IDLOptions::kTs) { - code += "static create" + struct_def.name + "(builder:flatbuffers.Builder"; - code += arguments + "):flatbuffers.Offset {\n"; + object_name = struct_def.name; + GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); + if (!object_namespace.empty()) { + code += "export namespace " + object_namespace + "{\n"; + } + code += "export class " + struct_def.name; + code += " {\n"; + code += " /**\n"; + code += " * @type {flatbuffers.ByteBuffer}\n"; + code += " */\n"; + code += " bb: flatbuffers.ByteBuffer|null = null;\n"; + code += "\n"; + code += " /**\n"; + code += " * @type {number}\n"; + code += " */\n"; + code += " bb_pos:number = 0;\n"; } else { - code += object_name + ".create" + struct_def.name + " = function(builder"; - code += arguments + ") {\n"; + bool isStatement = struct_def.defined_namespace->components.empty(); + object_name = WrapInNameSpace(struct_def); + GenDocComment(struct_def.doc_comment, code_ptr, "@constructor"); + if (isStatement) { + if (parser_.opts.use_goog_js_export_format) { + exports += "goog.exportSymbol('" + struct_def.name + "', " + + struct_def.name + ");\n"; + } else { + exports += + "this." + struct_def.name + " = " + struct_def.name + ";\n"; + } + code += "function " + object_name; + } else { + code += object_name + " = function"; + } + code += "() {\n"; + code += " /**\n"; + code += " * @type {flatbuffers.ByteBuffer}\n"; + code += " */\n"; + code += " this.bb = null;\n"; + code += "\n"; + code += " /**\n"; + code += " * @type {number}\n"; + code += " */\n"; + code += " this.bb_pos = 0;\n"; + code += isStatement ? "}\n\n" : "};\n\n"; } - GenStructBody(struct_def, &code, ""); - code += " return builder.offset();\n};\n\n"; - } else { - // Generate a method to start building a new object - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder"); + // Generate the __init method that sets the field in a pre-existing + // accessor object. This is to allow object reuse. + code += "/**\n"; + code += " * @param {number} i\n"; + code += " * @param {flatbuffers.ByteBuffer} bb\n"; + code += " * @returns {" + object_name + "}\n"; + code += " */\n"; if (lang_.language == IDLOptions::kTs) { - code += "static start" + struct_def.name; - code += "(builder:flatbuffers.Builder) {\n"; + code += + "__init(i:number, bb:flatbuffers.ByteBuffer):" + object_name + " {\n"; } else { - code += object_name + ".start" + struct_def.name; - code += " = function(builder) {\n"; + code += object_name + ".prototype.__init = function(i, bb) {\n"; } - code += " builder.startObject(" + NumToString( - struct_def.fields.vec.size()) + ");\n"; + code += " this.bb_pos = i;\n"; + code += " this.bb = bb;\n"; + code += " return this;\n"; code += "};\n\n"; - // Generate a set of static methods that allow table construction + // Generate a special accessor for the table that when used as the root of a + // FlatBuffer + if (!struct_def.fixed) { + GenDocComment(code_ptr, + "@param {flatbuffers.ByteBuffer} bb\n" + "@param {" + + object_name + + "=} obj\n" + "@returns {" + + object_name + "}"); + if (lang_.language == IDLOptions::kTs) { + code += "static getRootAs" + struct_def.name; + code += "(bb:flatbuffers.ByteBuffer, obj?:" + object_name + + "):" + object_name + " {\n"; + } else { + code += object_name + ".getRootAs" + struct_def.name; + code += " = function(bb, obj) {\n"; + } + code += " return (obj || new " + object_name; + code += ").__init(bb.readInt32(bb.position()) + bb.position(), bb);\n"; + code += "};\n\n"; + + // Generate the identifier check method + if (parser_.root_struct_def_ == &struct_def && + !parser_.file_identifier_.empty()) { + GenDocComment(code_ptr, + "@param {flatbuffers.ByteBuffer} bb\n" + "@returns {boolean}"); + if (lang_.language == IDLOptions::kTs) { + code += + "static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean " + "{\n"; + } else { + code += object_name + ".bufferHasIdentifier = function(bb) {\n"; + } + + code += " return bb.__has_identifier('" + parser_.file_identifier_; + code += "');\n};\n\n"; + } + } + + // Emit field accessors for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (field.deprecated) continue; - auto argname = MakeCamel(field.name, false); - if (!IsScalar(field.value.type.base_type)) { - argname += "Offset"; - } + auto offset_prefix = + " var offset = " + GenBBAccess() + ".__offset(this.bb_pos, " + + NumToString(field.value.offset) + ");\n return offset ? "; - // Generate the field insertion method - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {" + GenTypeName(field.value.type, true) + "} " + - argname); - - if (lang_.language == IDLOptions::kTs) { - std::string argType; - if (field.value.type.enum_def) { - argType = GenPrefixedTypeName(GenTypeName(field.value.type, true), - field.value.type.enum_def->file); + // Emit a scalar field + if (IsScalar(field.value.type.base_type) || + field.value.type.base_type == BASE_TYPE_STRING) { + GenDocComment( + field.doc_comment, code_ptr, + std::string( + field.value.type.base_type == BASE_TYPE_STRING + ? "@param {flatbuffers.Encoding=} optionalEncoding\n" + : "") + + "@returns {" + GenTypeName(field.value.type, false, true) + + "}"); + if (lang_.language == IDLOptions::kTs) { + std::string prefix = MakeCamel(field.name, false) + "("; + if (field.value.type.base_type == BASE_TYPE_STRING) { + code += prefix + "):string|null\n"; + code += prefix + "optionalEncoding:flatbuffers.Encoding" + + "):" + GenTypeName(field.value.type, false, true) + "\n"; + code += prefix + "optionalEncoding?:any"; + } else { + code += prefix; + } + if (field.value.type.enum_def) { + code += + "):" + + GenPrefixedTypeName(GenTypeName(field.value.type, false, true), + field.value.type.enum_def->file) + + " {\n"; + } else { + code += "):" + GenTypeName(field.value.type, false, true) + " {\n"; + } } else { - argType = GenTypeName(field.value.type, true); + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function("; + if (field.value.type.base_type == BASE_TYPE_STRING) { + code += "optionalEncoding"; + } + code += ") {\n"; } - code += "static add" + MakeCamel(field.name); - code += "(builder:flatbuffers.Builder, " + argname + ":" + argType + - ") {\n"; - } else { - code += object_name + ".add" + MakeCamel(field.name); - code += " = function(builder, " + argname + ") {\n"; + if (struct_def.fixed) { + code += + " return " + + GenGetter(field.value.type, + "(this.bb_pos" + MaybeAdd(field.value.offset) + ")") + + ";\n"; + } else { + std::string index = "this.bb_pos + offset"; + if (field.value.type.base_type == BASE_TYPE_STRING) { + index += ", optionalEncoding"; + } + code += offset_prefix + + GenGetter(field.value.type, "(" + index + ")") + " : " + + GenDefaultValue(field.value, GenBBAccess()); + code += ";\n"; + } } - code += " builder.addField" + GenWriteMethod(field.value.type) + "("; - code += NumToString(it - struct_def.fields.vec.begin()) + ", "; - if (field.value.type.base_type == BASE_TYPE_BOOL) { - code += "+"; + // Emit an object field + else { + switch (field.value.type.base_type) { + case BASE_TYPE_STRUCT: { + auto type = WrapInNameSpace(*field.value.type.struct_def); + GenDocComment( + field.doc_comment, code_ptr, + "@param {" + type + "=} obj\n@returns {" + type + "|null}"); + if (lang_.language == IDLOptions::kTs) { + type = + GenPrefixedTypeName(type, field.value.type.struct_def->file); + code += MakeCamel(field.name, false); + code += "(obj?:" + type + "):" + type + "|null {\n"; + } else { + code += + object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function(obj) {\n"; + } + + if (struct_def.fixed) { + code += " return (obj || new " + type; + code += ").__init(this.bb_pos"; + code += + MaybeAdd(field.value.offset) + ", " + GenBBAccess() + ");\n"; + } else { + code += offset_prefix + "(obj || new " + type + ").__init("; + code += field.value.type.struct_def->fixed + ? "this.bb_pos + offset" + : GenBBAccess() + ".__indirect(this.bb_pos + offset)"; + code += ", " + GenBBAccess() + ") : null;\n"; + } + + if (lang_.language == IDLOptions::kTs) { + imported_files.insert(field.value.type.struct_def->file); + } + + break; + } + + case BASE_TYPE_VECTOR: { + auto vectortype = field.value.type.VectorType(); + auto vectortypename = GenTypeName(vectortype, false); + auto inline_size = InlineSize(vectortype); + auto index = GenBBAccess() + + ".__vector(this.bb_pos + offset) + index" + + MaybeScale(inline_size); + std::string args = "@param {number} index\n"; + std::string ret_type; + bool is_union = false; + switch (vectortype.base_type) { + case BASE_TYPE_STRUCT: + args += "@param {" + vectortypename + "=} obj\n"; + ret_type = vectortypename; + break; + case BASE_TYPE_STRING: + args += "@param {flatbuffers.Encoding=} optionalEncoding\n"; + ret_type = vectortypename; + break; + case BASE_TYPE_UNION: + args += "@param {flatbuffers.Table=} obj\n"; + ret_type = "?flatbuffers.Table"; + is_union = true; + break; + default: ret_type = vectortypename; + } + GenDocComment(field.doc_comment, code_ptr, + args + "@returns {" + ret_type + "}"); + if (lang_.language == IDLOptions::kTs) { + std::string prefix = MakeCamel(field.name, false); + if (is_union) { prefix += ""; } + prefix += "(index: number"; + if (is_union) { + vectortypename = "T"; + code += prefix + ", obj:T"; + } else if (vectortype.base_type == BASE_TYPE_STRUCT) { + vectortypename = GenPrefixedTypeName( + vectortypename, vectortype.struct_def->file); + code += prefix + ", obj?:" + vectortypename; + imported_files.insert(vectortype.struct_def->file); + } else if (vectortype.base_type == BASE_TYPE_STRING) { + code += prefix + "):string\n"; + code += prefix + ",optionalEncoding:flatbuffers.Encoding" + + "):" + vectortypename + "\n"; + code += prefix + ",optionalEncoding?:any"; + } else { + code += prefix; + } + code += "):" + vectortypename + "|null {\n"; + } else { + code += + object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function(index"; + if (vectortype.base_type == BASE_TYPE_STRUCT || is_union) { + code += ", obj"; + } else if (vectortype.base_type == BASE_TYPE_STRING) { + code += ", optionalEncoding"; + } + code += ") {\n"; + } + + if (vectortype.base_type == BASE_TYPE_STRUCT) { + code += offset_prefix + "(obj || new " + vectortypename; + code += ").__init("; + code += vectortype.struct_def->fixed + ? index + : GenBBAccess() + ".__indirect(" + index + ")"; + code += ", " + GenBBAccess() + ")"; + } else { + if (is_union) { + index = "obj, " + index; + } else if (vectortype.base_type == BASE_TYPE_STRING) { + index += ", optionalEncoding"; + } + code += offset_prefix + GenGetter(vectortype, "(" + index + ")"); + } + code += " : "; + if (field.value.type.element == BASE_TYPE_BOOL) { + code += "false"; + } else if (field.value.type.element == BASE_TYPE_LONG || + field.value.type.element == BASE_TYPE_ULONG) { + code += GenBBAccess() + ".createLong(0, 0)"; + } else if (IsScalar(field.value.type.element)) { + if (field.value.type.enum_def) { + code += "/** @type {" + + WrapInNameSpace(*field.value.type.enum_def) + "} */ (" + + field.value.constant + ")"; + } else { + code += "0"; + } + } else { + code += "null"; + } + code += ";\n"; + break; + } + + case BASE_TYPE_UNION: + GenDocComment(field.doc_comment, code_ptr, + "@param {flatbuffers.Table} obj\n" + "@returns {?flatbuffers.Table}"); + if (lang_.language == IDLOptions::kTs) { + code += MakeCamel(field.name, false); + code += "(obj:T):T|null {\n"; + } else { + code += + object_name + ".prototype." + MakeCamel(field.name, false); + code += " = function(obj) {\n"; + } + + code += offset_prefix + + GenGetter(field.value.type, "(obj, this.bb_pos + offset)") + + " : null;\n"; + break; + + default: assert(0); + } } - code += argname + ", "; - if (!IsScalar(field.value.type.base_type)) { - code += "0"; - } else { - if (field.value.type.base_type == BASE_TYPE_BOOL) { + code += "};\n\n"; + + if (parser_.opts.use_goog_js_export_format) { + exports += "goog.exportProperty(" + object_name + ".prototype, '" + + MakeCamel(field.name, false) + "', " + object_name + + ".prototype." + MakeCamel(field.name, false) + ");\n"; + } + + // Adds the mutable scalar value to the output + if (IsScalar(field.value.type.base_type) && parser.opts.mutable_buffer) { + std::string annotations = + "@param {" + GenTypeName(field.value.type, true) + "} value\n"; + GenDocComment(code_ptr, annotations + "@returns {boolean}"); + + if (lang_.language == IDLOptions::kTs) { + std::string type; + if (field.value.type.enum_def) { + type = GenPrefixedTypeName(GenTypeName(field.value.type, true), + field.value.type.enum_def->file); + } else { + type = GenTypeName(field.value.type, true); + } + + code += "mutate_" + field.name + "(value:" + type + "):boolean {\n"; + } else { + code += object_name + ".prototype.mutate_" + field.name + + " = function(value) {\n"; + } + + code += " var offset = " + GenBBAccess() + ".__offset(this.bb_pos, " + + NumToString(field.value.offset) + ");\n\n"; + code += " if (offset === 0) {\n"; + code += " return false;\n"; + code += " }\n\n"; + + // special case for bools, which are treated as uint8 + code += " " + GenBBAccess() + ".write" + + MakeCamel(GenType(field.value.type)) + + "(this.bb_pos + offset, "; + if (field.value.type.base_type == BASE_TYPE_BOOL && + lang_.language == IDLOptions::kTs) { code += "+"; } - code += GenDefaultValue(field.value, "builder"); + + code += "value);\n"; + code += " return true;\n"; + code += "};\n\n"; + + if (parser_.opts.use_goog_js_export_format) { + exports += "goog.exportProperty(" + object_name + + ".prototype, 'mutate_" + field.name + "', " + object_name + + ".prototype.mutate_" + field.name + ");\n"; + } } - code += ");\n};\n\n"; + // Emit vector helpers if (field.value.type.base_type == BASE_TYPE_VECTOR) { - auto vector_type = field.value.type.VectorType(); - auto alignment = InlineAlignment(vector_type); - auto elem_size = InlineSize(vector_type); + // Emit a length helper + GenDocComment(code_ptr, "@returns {number}"); + if (lang_.language == IDLOptions::kTs) { + code += MakeCamel(field.name, false); + code += "Length():number {\n" + offset_prefix; + } else { + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += "Length = function() {\n" + offset_prefix; + } - // Generate a method to create a vector from a JavaScript array - if (!IsStruct(vector_type)) { + code += + GenBBAccess() + ".__vector_len(this.bb_pos + offset) : 0;\n};\n\n"; + + if (parser_.opts.use_goog_js_export_format) { + exports += "goog.exportProperty(" + object_name + ".prototype, '" + + MakeCamel(field.name, false) + "Length', " + object_name + + ".prototype." + MakeCamel(field.name, false) + + "Length);\n"; + } + + // For scalar types, emit a typed array helper + auto vectorType = field.value.type.VectorType(); + if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) { GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {Array.<" + GenTypeName(vector_type, true) + - ">} data\n" - "@returns {flatbuffers.Offset}"); + "@returns {" + GenType(vectorType) + "Array}"); if (lang_.language == IDLOptions::kTs) { - code += "static create" + MakeCamel(field.name); - std::string type = GenTypeName(vector_type, true) + "[]"; - if (type == "number[]") { - type += " | Uint8Array"; - } - code += "Vector(builder:flatbuffers.Builder, data:" + type + - "):flatbuffers.Offset {\n"; + code += MakeCamel(field.name, false); + code += "Array():" + GenType(vectorType) + "Array|null {\n" + + offset_prefix; } else { - code += object_name + ".create" + MakeCamel(field.name); - code += "Vector = function(builder, data) {\n"; + code += object_name + ".prototype." + MakeCamel(field.name, false); + code += "Array = function() {\n" + offset_prefix; + } + + code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() + + ".bytes().buffer, " + GenBBAccess() + + ".bytes().byteOffset + " + GenBBAccess() + + ".__vector(this.bb_pos + offset), " + GenBBAccess() + + ".__vector_len(this.bb_pos + offset)) : null;\n};\n\n"; + + if (parser_.opts.use_goog_js_export_format) { + exports += "goog.exportProperty(" + object_name + ".prototype, '" + + MakeCamel(field.name, false) + "Array', " + object_name + + ".prototype." + MakeCamel(field.name, false) + + "Array);\n"; + } + } + } + } + + // Emit a factory constructor + if (struct_def.fixed) { + std::string annotations = "@param {flatbuffers.Builder} builder\n"; + std::string arguments; + GenStructArgs(struct_def, &annotations, &arguments, ""); + GenDocComment(code_ptr, annotations + "@returns {flatbuffers.Offset}"); + + if (lang_.language == IDLOptions::kTs) { + code += + "static create" + struct_def.name + "(builder:flatbuffers.Builder"; + code += arguments + "):flatbuffers.Offset {\n"; + } else { + code += + object_name + ".create" + struct_def.name + " = function(builder"; + code += arguments + ") {\n"; + } + + GenStructBody(struct_def, &code, ""); + code += " return builder.offset();\n};\n\n"; + } else { + // Generate a method to start building a new object + GenDocComment(code_ptr, "@param {flatbuffers.Builder} builder"); + + if (lang_.language == IDLOptions::kTs) { + code += "static start" + struct_def.name; + code += "(builder:flatbuffers.Builder) {\n"; + } else { + code += object_name + ".start" + struct_def.name; + code += " = function(builder) {\n"; + } + + code += " builder.startObject(" + + NumToString(struct_def.fields.vec.size()) + ");\n"; + code += "};\n\n"; + + // Generate a set of static methods that allow table construction + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + auto argname = MakeCamel(field.name, false); + if (!IsScalar(field.value.type.base_type)) { argname += "Offset"; } + + // Generate the field insertion method + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@param {" + + GenTypeName(field.value.type, true) + "} " + argname); + + if (lang_.language == IDLOptions::kTs) { + std::string argType; + if (field.value.type.enum_def) { + argType = GenPrefixedTypeName(GenTypeName(field.value.type, true), + field.value.type.enum_def->file); + } else { + argType = GenTypeName(field.value.type, true); + } + + code += "static add" + MakeCamel(field.name); + code += "(builder:flatbuffers.Builder, " + argname + ":" + argType + + ") {\n"; + } else { + code += object_name + ".add" + MakeCamel(field.name); + code += " = function(builder, " + argname + ") {\n"; + } + + code += " builder.addField" + GenWriteMethod(field.value.type) + "("; + code += NumToString(it - struct_def.fields.vec.begin()) + ", "; + if (field.value.type.base_type == BASE_TYPE_BOOL) { code += "+"; } + code += argname + ", "; + if (!IsScalar(field.value.type.base_type)) { + code += "0"; + } else { + if (field.value.type.base_type == BASE_TYPE_BOOL) { code += "+"; } + code += GenDefaultValue(field.value, "builder"); + } + code += ");\n};\n\n"; + + if (field.value.type.base_type == BASE_TYPE_VECTOR) { + auto vector_type = field.value.type.VectorType(); + auto alignment = InlineAlignment(vector_type); + auto elem_size = InlineSize(vector_type); + + // Generate a method to create a vector from a JavaScript array + if (!IsStruct(vector_type)) { + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@param {Array.<" + + GenTypeName(vector_type, true) + + ">} data\n" + "@returns {flatbuffers.Offset}"); + + if (lang_.language == IDLOptions::kTs) { + code += "static create" + MakeCamel(field.name); + std::string type = GenTypeName(vector_type, true) + "[]"; + if (type == "number[]") { type += " | Uint8Array"; } + code += "Vector(builder:flatbuffers.Builder, data:" + type + + "):flatbuffers.Offset {\n"; + } else { + code += object_name + ".create" + MakeCamel(field.name); + code += "Vector = function(builder, data) {\n"; + } + + code += " builder.startVector(" + NumToString(elem_size); + code += ", data.length, " + NumToString(alignment) + ");\n"; + code += " for (var i = data.length - 1; i >= 0; i--) {\n"; + code += " builder.add" + GenWriteMethod(vector_type) + "("; + if (vector_type.base_type == BASE_TYPE_BOOL) { code += "+"; } + code += "data[i]);\n"; + code += " }\n"; + code += " return builder.endVector();\n"; + code += "};\n\n"; + } + + // Generate a method to start a vector, data to be added manually + // after + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@param {number} numElems"); + + if (lang_.language == IDLOptions::kTs) { + code += "static start" + MakeCamel(field.name); + code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n"; + } else { + code += object_name + ".start" + MakeCamel(field.name); + code += "Vector = function(builder, numElems) {\n"; } code += " builder.startVector(" + NumToString(elem_size); - code += ", data.length, " + NumToString(alignment) + ");\n"; - code += " for (var i = data.length - 1; i >= 0; i--) {\n"; - code += " builder.add" + GenWriteMethod(vector_type) + "("; - if (vector_type.base_type == BASE_TYPE_BOOL) { - code += "+"; - } - code += "data[i]);\n"; - code += " }\n"; - code += " return builder.endVector();\n"; + code += ", numElems, " + NumToString(alignment) + ");\n"; code += "};\n\n"; } + } - // Generate a method to start a vector, data to be added manually after + // Generate a method to stop building a new object + GenDocComment(code_ptr, + "@param {flatbuffers.Builder} builder\n" + "@returns {flatbuffers.Offset}"); + + if (lang_.language == IDLOptions::kTs) { + code += "static end" + struct_def.name; + code += "(builder:flatbuffers.Builder):flatbuffers.Offset {\n"; + } else { + code += object_name + ".end" + struct_def.name; + code += " = function(builder) {\n"; + } + + code += " var offset = builder.endObject();\n"; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (!field.deprecated && field.required) { + code += " builder.requiredField(offset, "; + code += NumToString(field.value.offset); + code += "); // " + field.name + "\n"; + } + } + code += " return offset;\n"; + code += "};\n\n"; + + // Generate the method to complete buffer construction + if (parser_.root_struct_def_ == &struct_def) { GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {number} numElems"); + "@param {flatbuffers.Builder} builder\n" + "@param {flatbuffers.Offset} offset"); if (lang_.language == IDLOptions::kTs) { - code += "static start" + MakeCamel(field.name); - code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n"; + code += "static finish" + struct_def.name + "Buffer"; + code += + "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n"; } else { - code += object_name + ".start" + MakeCamel(field.name); - code += "Vector = function(builder, numElems) {\n"; + code += object_name + ".finish" + struct_def.name + "Buffer"; + code += " = function(builder, offset) {\n"; } - code += " builder.startVector(" + NumToString(elem_size); - code += ", numElems, " + NumToString(alignment) + ");\n"; + code += " builder.finish(offset"; + if (!parser_.file_identifier_.empty()) { + code += ", '" + parser_.file_identifier_ + "'"; + } + code += ");\n"; code += "};\n\n"; } } - // Generate a method to stop building a new object - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@returns {flatbuffers.Offset}"); - if (lang_.language == IDLOptions::kTs) { - code += "static end" + struct_def.name; - code += "(builder:flatbuffers.Builder):flatbuffers.Offset {\n"; - } else { - code += object_name + ".end" + struct_def.name; - code += " = function(builder) {\n"; - } - - code += " var offset = builder.endObject();\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (!field.deprecated && field.required) { - code += " builder.requiredField(offset, "; - code += NumToString(field.value.offset); - code += "); // " + field.name + "\n"; - } - } - code += " return offset;\n"; - code += "};\n\n"; - - // Generate the method to complete buffer construction - if (parser_.root_struct_def_ == &struct_def) { - GenDocComment(code_ptr, - "@param {flatbuffers.Builder} builder\n" - "@param {flatbuffers.Offset} offset"); - - if (lang_.language == IDLOptions::kTs) { - code += "static finish" + struct_def.name + "Buffer"; - code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n"; - } else { - code += object_name + ".finish" + struct_def.name + "Buffer"; - code += " = function(builder, offset) {\n"; - } - - code += " builder.finish(offset"; - if (!parser_.file_identifier_.empty()) { - code += ", '" + parser_.file_identifier_ + "'"; - } - code += ");\n"; - code += "};\n\n"; - } - } - - if (lang_.language == IDLOptions::kTs) { - if (!object_namespace.empty()) { + if (!object_namespace.empty()) { code += "}\n"; } code += "}\n"; } - code += "}\n"; } -} }; } // namespace js @@ -1184,22 +1172,20 @@ bool GenerateJS(const Parser &parser, const std::string &path, return generator.generate(); } -std::string JSMakeRule(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); const auto &lang = GetJsLangParams(parser.opts.lang); - std::string filebase = flatbuffers::StripPath( - flatbuffers::StripExtension(file_name)); + std::string filebase = + flatbuffers::StripPath(flatbuffers::StripExtension(file_name)); std::string make_rule = GeneratedFileName(path, filebase, lang) + ": "; auto included_files = parser.GetIncludedFilesRecursive(file_name); - for (auto it = included_files.begin(); - it != included_files.end(); ++it) { + for (auto it = included_files.begin(); it != included_files.end(); ++it) { make_rule += " " + *it; } -return make_rule; + return make_rule; } } // namespace flatbuffers diff --git a/src/idl_gen_json_schema.cpp b/src/idl_gen_json_schema.cpp index 2b6739838..188358017 100644 --- a/src/idl_gen_json_schema.cpp +++ b/src/idl_gen_json_schema.cpp @@ -1,23 +1,23 @@ /* -* Copyright 2014 Google Inc. All rights reserved. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ + * Copyright 2014 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include #include "flatbuffers/code_generators.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include namespace flatbuffers { @@ -30,8 +30,7 @@ namespace jsons { std::string GenNativeType(BaseType type) { switch (type) { - case BASE_TYPE_BOOL: - return "boolean"; + case BASE_TYPE_BOOL: return "boolean"; case BASE_TYPE_CHAR: case BASE_TYPE_UCHAR: case BASE_TYPE_SHORT: @@ -41,16 +40,13 @@ std::string GenNativeType(BaseType type) { case BASE_TYPE_LONG: case BASE_TYPE_ULONG: case BASE_TYPE_FLOAT: - case BASE_TYPE_DOUBLE: - return "number"; - case BASE_TYPE_STRING: - return "string"; - default: - return ""; + case BASE_TYPE_DOUBLE: return "number"; + case BASE_TYPE_STRING: return "string"; + default: return ""; } } -template std::string GenFullName(const T *enum_def) { +template std::string GenFullName(const T *enum_def) { std::string full_name; const auto &name_spaces = enum_def->defined_namespace->components; for (auto ns = name_spaces.cbegin(); ns != name_spaces.cend(); ++ns) { @@ -60,7 +56,7 @@ template std::string GenFullName(const T *enum_def) { return full_name; } -template std::string GenTypeRef(const T *enum_def) { +template std::string GenTypeRef(const T *enum_def) { return "\"$ref\" : \"#/definitions/" + GenFullName(enum_def) + "\""; } @@ -93,11 +89,10 @@ std::string GenType(const Type &type) { const auto &union_types = type.enum_def->vals.vec; for (auto ut = union_types.cbegin(); ut < union_types.cend(); ++ut) { auto &union_type = *ut; - if (union_type->union_type.base_type == BASE_TYPE_NONE) { - continue; - } + if (union_type->union_type.base_type == BASE_TYPE_NONE) { continue; } if (union_type->union_type.base_type == BASE_TYPE_STRUCT) { - union_type_string.append("{ " + GenTypeRef(union_type->union_type.struct_def) + " }"); + union_type_string.append( + "{ " + GenTypeRef(union_type->union_type.struct_def) + " }"); } if (union_type != *type.enum_def->vals.vec.rbegin()) { union_type_string.append(","); @@ -106,10 +101,8 @@ std::string GenType(const Type &type) { union_type_string.append("]"); return union_type_string; } - case BASE_TYPE_UTYPE: - return GenTypeRef(type.enum_def); - default: - return GenType(GenNativeType(type.base_type)); + case BASE_TYPE_UTYPE: return GenTypeRef(type.enum_def); + default: return GenType(GenNativeType(type.base_type)); } } @@ -130,35 +123,29 @@ class JsonSchemaGenerator : public BaseGenerator { code_ += "{"; code_ += " \"$schema\": \"http://json-schema.org/draft-04/schema#\","; code_ += " \"definitions\": {"; - for (auto e = parser_.enums_.vec.cbegin(); - e != parser_.enums_.vec.cend(); + for (auto e = parser_.enums_.vec.cbegin(); e != parser_.enums_.vec.cend(); ++e) { code_ += " \"" + GenFullName(*e) + "\" : {"; code_ += " " + GenType("string") + ","; std::string enumdef(" \"enum\": ["); - for (auto enum_value = (*e)->vals.vec.begin(); - enum_value != (*e)->vals.vec.end(); - ++enum_value) { + for (auto enum_value = (*e)->vals.vec.begin(); + enum_value != (*e)->vals.vec.end(); ++enum_value) { enumdef.append("\"" + (*enum_value)->name + "\""); - if (*enum_value != (*e)->vals.vec.back()) { - enumdef.append(", "); - } + if (*enum_value != (*e)->vals.vec.back()) { enumdef.append(", "); } } enumdef.append("]"); code_ += enumdef; code_ += " },"; // close type } - for (auto s = parser_.structs_.vec.cbegin(); - s != parser_.structs_.vec.cend(); - ++s) { + for (auto s = parser_.structs_.vec.cbegin(); + s != parser_.structs_.vec.cend(); ++s) { const auto &structure = *s; code_ += " \"" + GenFullName(structure) + "\" : {"; code_ += " " + GenType("object") + ","; std::string comment; const auto &comment_lines = structure->doc_comment; for (auto comment_line = comment_lines.cbegin(); - comment_line != comment_lines.cend(); - ++comment_line) { + comment_line != comment_lines.cend(); ++comment_line) { comment.append(*comment_line); } if (comment.size() > 0) { @@ -169,10 +156,9 @@ class JsonSchemaGenerator : public BaseGenerator { const auto &properties = structure->fields.vec; for (auto prop = properties.cbegin(); prop != properties.cend(); ++prop) { const auto &property = *prop; - std::string typeLine(" \"" + property->name + "\" : { " + GenType(property->value.type) + " }"); - if (property != properties.back()) { - typeLine.append(","); - } + std::string typeLine(" \"" + property->name + "\" : { " + + GenType(property->value.type) + " }"); + if (property != properties.back()) { typeLine.append(","); } code_ += typeLine; } code_ += " },"; // close properties @@ -184,8 +170,7 @@ class JsonSchemaGenerator : public BaseGenerator { if (requiredProperties.size() > 0) { std::string required_string(" \"required\" : ["); for (auto req_prop = requiredProperties.cbegin(); - req_prop != requiredProperties.cend(); - ++req_prop) { + req_prop != requiredProperties.cend(); ++req_prop) { required_string.append("\"" + (*req_prop)->name + "\""); if (*req_prop != requiredProperties.back()) { required_string.append(", "); @@ -196,9 +181,7 @@ class JsonSchemaGenerator : public BaseGenerator { } code_ += " \"additionalProperties\" : false"; std::string closeType(" }"); - if (*s != parser_.structs_.vec.back()) { - closeType.append(","); - } + if (*s != parser_.structs_.vec.back()) { closeType.append(","); } code_ += closeType; // close type } code_ += " },"; // close definitions diff --git a/src/idl_gen_php.cpp b/src/idl_gen_php.cpp index b2610892d..101f3c28f 100644 --- a/src/idl_gen_php.cpp +++ b/src/idl_gen_php.cpp @@ -1,370 +1,358 @@ /* -* Copyright 2014 Google Inc. All rights reserved. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ + * Copyright 2014 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ // independent from idl_parser, since this code is not needed for most clients #include +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" namespace flatbuffers { namespace php { - // Hardcode spaces per indentation. - const std::string Indent = " "; - class PhpGenerator : public BaseGenerator { - public: - PhpGenerator(const Parser &parser, const std::string &path, - const std::string &file_name) - : BaseGenerator(parser, path, file_name, "\\", "\\"){}; - bool generate() { - if (!generateEnums()) return false; - if (!generateStructs()) return false; - return true; - } +// Hardcode spaces per indentation. +const std::string Indent = " "; +class PhpGenerator : public BaseGenerator { + public: + PhpGenerator(const Parser &parser, const std::string &path, + const std::string &file_name) + : BaseGenerator(parser, path, file_name, "\\", "\\"){}; + bool generate() { + if (!generateEnums()) return false; + if (!generateStructs()) return false; + return true; + } - private: - bool generateEnums() { - for (auto it = parser_.enums_.vec.begin(); - it != parser_.enums_.vec.end(); ++it) { - auto &enum_def = **it; - std::string enumcode; - GenEnum(enum_def, &enumcode); - if (!SaveType(enum_def, enumcode, false)) return false; - } - return true; - } + private: + bool generateEnums() { + for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); + ++it) { + auto &enum_def = **it; + std::string enumcode; + GenEnum(enum_def, &enumcode); + if (!SaveType(enum_def, enumcode, false)) return false; + } + return true; + } - bool generateStructs() { - for (auto it = parser_.structs_.vec.begin(); - it != parser_.structs_.vec.end(); ++it) { - auto &struct_def = **it; - std::string declcode; - GenStruct(struct_def, &declcode); - if (!SaveType(struct_def, declcode, true)) return false; - } - return true; - } + bool generateStructs() { + for (auto it = parser_.structs_.vec.begin(); + it != parser_.structs_.vec.end(); ++it) { + auto &struct_def = **it; + std::string declcode; + GenStruct(struct_def, &declcode); + if (!SaveType(struct_def, declcode, true)) return false; + } + return true; + } - // Begin by declaring namespace and imports. - void BeginFile(const std::string name_space_name, - const bool needs_imports, std::string *code_ptr) { - std::string &code = *code_ptr; - code += "init($bb->getInt($bb->getPosition())"; + code += " + $bb->getPosition(), $bb));\n"; + code += Indent + "}\n\n"; + } + + // Initialize an existing object with other data, to avoid an allocation. + static void InitializeExisting(const StructDef &struct_def, + std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "/**\n"; + code += Indent + " * @param int $_i offset\n"; + code += Indent + " * @param ByteBuffer $_bb\n"; + code += Indent + " * @return " + struct_def.name + "\n"; + code += Indent + " **/\n"; + code += Indent + "public function init($_i, ByteBuffer $_bb)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$this->bb_pos = $_i;\n"; + code += Indent + Indent + "$this->bb = $_bb;\n"; + code += Indent + Indent + "return $this;\n"; + code += Indent + "}\n\n"; + } + + // Get the length of a vector. + static void GetVectorLen(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "/**\n"; + code += Indent + " * @return int\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name) + "Length()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $this->__offset("; + code += NumToString(field.value.offset) + ");\n"; + code += Indent + Indent; + code += "return $o != 0 ? $this->__vector_len($o) : 0;\n"; + code += Indent + "}\n\n"; + } + + // Get a [ubyte] vector as a byte array. + static void GetUByte(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "/**\n"; + code += Indent + " * @return string\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name) + "Bytes()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "return $this->__vector_as_bytes("; + code += NumToString(field.value.offset) + ");\n"; + code += Indent + "}\n\n"; + } + + // Get the value of a struct's scalar. + static void GetScalarFieldOfStruct(const FieldDef &field, + std::string *code_ptr) { + std::string &code = *code_ptr; + std::string getter = GenGetter(field.value.type); + + code += Indent + "/**\n"; + code += Indent + " * @return "; + code += GenTypeGet(field.value.type) + "\n"; + code += Indent + " */\n"; + code += Indent + "public function " + getter; + code += MakeCamel(field.name) + "()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "return "; + + code += "$this->bb->get"; + code += MakeCamel(GenTypeGet(field.value.type)); + code += "($this->bb_pos + "; + code += NumToString(field.value.offset) + ")"; + code += ";\n"; + + code += Indent + "}\n\n"; + } + + // Get the value of a table's scalar. + void GetScalarFieldOfTable(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + std::string getter = GenGetter(field.value.type); + + code += Indent + "/**\n"; + code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name); + code += "()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $this->__offset(" + + NumToString(field.value.offset) + ");\n" + Indent + Indent + + "return $o != 0 ? "; + code += "$this->bb->get"; + code += MakeCamel(GenTypeGet(field.value.type)) + "($o + $this->bb_pos)"; + code += " : " + GenDefaultValue(field.value) + ";\n"; + code += Indent + "}\n\n"; + } + + // Get a struct by initializing an existing struct. + // Specific to Struct. + void GetStructFieldOfStruct(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "/**\n"; + code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name) + "()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$obj = new "; + code += GenTypeGet(field.value.type) + "();\n"; + code += Indent + Indent + "$obj->init($this->bb_pos + "; + code += NumToString(field.value.offset) + ", $this->bb);"; + code += "\n" + Indent + Indent + "return $obj;\n"; + code += Indent + "}\n\n"; + } + + // Get a struct by initializing an existing struct. + // Specific to Table. + void GetStructFieldOfTable(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "public function get"; + code += MakeCamel(field.name); + code += "()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$obj = new "; + code += MakeCamel(GenTypeGet(field.value.type)) + "();\n"; + code += Indent + Indent + "$o = $this->__offset(" + + NumToString(field.value.offset) + ");\n"; + code += Indent + Indent; + code += "return $o != 0 ? $obj->init("; + if (field.value.type.struct_def->fixed) { + code += "$o + $this->bb_pos, $this->bb) : "; + } else { + code += "$this->__indirect($o + $this->bb_pos), $this->bb) : "; } + code += GenDefaultValue(field.value) + ";\n"; + code += Indent + "}\n\n"; + } - // End enum code. - static void EndEnum(std::string *code_ptr) { - std::string &code = *code_ptr; - code += "}\n"; - } + // Get the value of a string. + void GetStringField(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + code += Indent + "public function get"; + code += MakeCamel(field.name); + code += "()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $this->__offset(" + + NumToString(field.value.offset) + ");\n"; + code += Indent + Indent; + code += "return $o != 0 ? $this->__string($o + $this->bb_pos) : "; + code += GenDefaultValue(field.value) + ";\n"; + code += Indent + "}\n\n"; + } - // Initialize a new struct or table from existing data. - static void NewRootTypeFromBuffer(const StructDef &struct_def, - std::string *code_ptr) { - std::string &code = *code_ptr; + // Get the value of a union from an object. + void GetUnionField(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; - code += Indent + "/**\n"; - code += Indent + " * @param ByteBuffer $bb\n"; - code += Indent + " * @return " + struct_def.name + "\n"; - code += Indent + " */\n"; - code += Indent + "public static function getRootAs"; - code += struct_def.name; - code += "(ByteBuffer $bb)\n"; - code += Indent + "{\n"; + code += Indent + "/**\n"; + code += Indent + " * @return" + GenTypeBasic(field.value.type) + "\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name) + "($obj)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $this->__offset(" + + NumToString(field.value.offset) + ");\n"; + code += Indent + Indent; + code += "return $o != 0 ? $this->__union($obj, $o) : null;\n"; + code += Indent + "}\n\n"; + } - code += Indent + Indent + "$obj = new " + struct_def.name + "();\n"; - code += Indent + Indent; - code += "return ($obj->init($bb->getInt($bb->getPosition())"; - code += " + $bb->getPosition(), $bb));\n"; - code += Indent + "}\n\n"; - } + // Get the value of a vector's struct member. + void GetMemberOfVectorOfStruct(const StructDef &struct_def, + const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + auto vectortype = field.value.type.VectorType(); - // Initialize an existing object with other data, to avoid an allocation. - static void InitializeExisting(const StructDef &struct_def, - std::string *code_ptr) { - std::string &code = *code_ptr; + code += Indent + "/**\n"; + code += Indent + " * @return" + GenTypeBasic(field.value.type) + "\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name); + code += "($j)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $this->__offset(" + + NumToString(field.value.offset) + ");\n"; + code += Indent + Indent + "$obj = new "; + code += MakeCamel(GenTypeGet(field.value.type)) + "();\n"; - code += Indent + "/**\n"; - code += Indent + " * @param int $_i offset\n"; - code += Indent + " * @param ByteBuffer $_bb\n"; - code += Indent + " * @return " + struct_def.name + "\n"; - code += Indent + " **/\n"; - code += Indent + "public function init($_i, ByteBuffer $_bb)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$this->bb_pos = $_i;\n"; - code += Indent + Indent + "$this->bb = $_bb;\n"; - code += Indent + Indent + "return $this;\n"; - code += Indent + "}\n\n"; - } - - // Get the length of a vector. - static void GetVectorLen(const FieldDef &field, - std::string *code_ptr) { - std::string &code = *code_ptr; - - code += Indent + "/**\n"; - code += Indent + " * @return int\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name) + "Length()\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$o = $this->__offset("; - code += NumToString(field.value.offset) + ");\n"; - code += Indent + Indent; - code += "return $o != 0 ? $this->__vector_len($o) : 0;\n"; - code += Indent + "}\n\n"; - } - - // Get a [ubyte] vector as a byte array. - static void GetUByte(const FieldDef &field, - std::string *code_ptr) { - std::string &code = *code_ptr; - - code += Indent + "/**\n"; - code += Indent + " * @return string\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name) + "Bytes()\n"; - code += Indent + "{\n"; - code += Indent + Indent + "return $this->__vector_as_bytes("; - code += NumToString(field.value.offset) + ");\n"; - code += Indent + "}\n\n"; - } - - // Get the value of a struct's scalar. - static void GetScalarFieldOfStruct(const FieldDef &field, - std::string *code_ptr) { - std::string &code = *code_ptr; - std::string getter = GenGetter(field.value.type); - - code += Indent + "/**\n"; - code += Indent + " * @return "; - code += GenTypeGet(field.value.type) + "\n"; - code += Indent + " */\n"; - code += Indent + "public function " + getter; - code += MakeCamel(field.name) + "()\n"; - code += Indent + "{\n"; - code += Indent + Indent + "return "; - - code += "$this->bb->get"; - code += MakeCamel(GenTypeGet(field.value.type)); - code += "($this->bb_pos + "; - code += NumToString(field.value.offset) + ")"; - code += ";\n"; - - code += Indent + "}\n\n"; - } - - // Get the value of a table's scalar. - void GetScalarFieldOfTable(const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; - std::string getter = GenGetter(field.value.type); - - code += Indent + "/**\n"; - code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name); - code += "()\n"; - code += Indent + "{\n"; - code += Indent + Indent + - "$o = $this->__offset(" + - NumToString(field.value.offset) + - ");\n" + Indent + Indent + "return $o != 0 ? "; - code += "$this->bb->get"; - code += MakeCamel(GenTypeGet(field.value.type)) + "($o + $this->bb_pos)"; - code += " : " + GenDefaultValue(field.value) + ";\n"; - code += Indent + "}\n\n"; - } - - // Get a struct by initializing an existing struct. - // Specific to Struct. - void GetStructFieldOfStruct(const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; - - code += Indent + "/**\n"; - code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name) + "()\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$obj = new "; - code += GenTypeGet(field.value.type) + "();\n"; - code += Indent + Indent + "$obj->init($this->bb_pos + "; - code += NumToString(field.value.offset) + ", $this->bb);"; - code += "\n" + Indent + Indent + "return $obj;\n"; - code += Indent + "}\n\n"; - } - - // Get a struct by initializing an existing struct. - // Specific to Table. - void GetStructFieldOfTable(const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; - - code += Indent + "public function get"; - code += MakeCamel(field.name); - code += "()\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$obj = new "; - code += MakeCamel(GenTypeGet(field.value.type)) + "();\n"; - code += Indent + Indent + - "$o = $this->__offset(" + - NumToString(field.value.offset) + - ");\n"; - code += Indent + Indent; - code += "return $o != 0 ? $obj->init("; - if (field.value.type.struct_def->fixed) - { - code += "$o + $this->bb_pos, $this->bb) : "; - } else { - code += "$this->__indirect($o + $this->bb_pos), $this->bb) : "; - } - code += GenDefaultValue(field.value) + ";\n"; - code += Indent + "}\n\n"; - } - - // Get the value of a string. - void GetStringField(const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; - code += Indent + "public function get"; - code += MakeCamel(field.name); - code += "()\n"; - code += Indent + "{\n"; - code += Indent + Indent + - "$o = $this->__offset(" + - NumToString(field.value.offset) + - ");\n"; - code += Indent + Indent; - code += "return $o != 0 ? $this->__string($o + $this->bb_pos) : "; - code += GenDefaultValue(field.value) + ";\n"; - code += Indent + "}\n\n"; - } - - // Get the value of a union from an object. - void GetUnionField(const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; - - code += Indent + "/**\n"; - code += Indent + " * @return" + GenTypeBasic(field.value.type) + "\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name) + "($obj)\n"; - code += Indent + "{\n"; - code += Indent + Indent + - "$o = $this->__offset(" + - NumToString(field.value.offset) + - ");\n"; - code += Indent + Indent; - code += "return $o != 0 ? $this->__union($obj, $o) : null;\n"; - code += Indent + "}\n\n"; - } - - // Get the value of a vector's struct member. - void GetMemberOfVectorOfStruct(const StructDef &struct_def, - const FieldDef &field, std::string *code_ptr) { - std::string &code = *code_ptr; - auto vectortype = field.value.type.VectorType(); - - code += Indent + "/**\n"; - code += Indent + " * @return" + GenTypeBasic(field.value.type) + "\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name); - code += "($j)\n"; - code += Indent + "{\n"; - code += Indent + Indent + - "$o = $this->__offset(" + - NumToString(field.value.offset) + - ");\n"; - code += Indent + Indent + "$obj = new "; - code += MakeCamel(GenTypeGet(field.value.type)) + "();\n"; - - switch (field.value.type.base_type) { + switch (field.value.type.base_type) { case BASE_TYPE_STRUCT: if (struct_def.fixed) { code += Indent + Indent; - code += "return $o != 0 ? $obj->init($this->bb_pos +" - + NumToString(field.value.offset) + ", $this->bb) : null;\n"; + code += "return $o != 0 ? $obj->init($this->bb_pos +" + + NumToString(field.value.offset) + ", $this->bb) : null;\n"; } else { code += Indent + Indent + "return $o != 0 ? $obj->init("; code += field.value.type.struct_def->fixed - ? "$o + $this->bb_pos" - : "$this->__indirect($o + $this->bb_pos)"; + ? "$o + $this->bb_pos" + : "$this->__indirect($o + $this->bb_pos)"; code += ", $this->bb) : null;\n"; } break; @@ -389,336 +377,311 @@ namespace php { code += Indent + Indent + "return $o != 0 ? $this->"; code += GenGetter(field.value.type) + "($obj, $o); null;\n"; break; - default: - break; - } - - code += Indent + "}\n\n"; + default: break; } - // Get the value of a vector's non-struct member. Uses a named return - // argument to conveniently set the zero value for the result. - void GetMemberOfVectorOfNonStruct(const FieldDef &field, - std::string *code_ptr) { - std::string &code = *code_ptr; - auto vectortype = field.value.type.VectorType(); + code += Indent + "}\n\n"; + } - code += Indent + "/**\n"; - code += Indent + " * @param int offset\n"; - code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name); - code += "($j)\n"; - code += Indent + "{\n"; - code += Indent + Indent + - "$o = $this->__offset(" + - NumToString(field.value.offset) + - ");\n"; + // Get the value of a vector's non-struct member. Uses a named return + // argument to conveniently set the zero value for the result. + void GetMemberOfVectorOfNonStruct(const FieldDef &field, + std::string *code_ptr) { + std::string &code = *code_ptr; + auto vectortype = field.value.type.VectorType(); - if (field.value.type.VectorType().base_type == BASE_TYPE_STRING) { - code += Indent + Indent; - code += "return $o != 0 ? $this->__string($this->__vector($o) + $j * "; - code += NumToString(InlineSize(vectortype)) + ") : "; - code += GenDefaultValue(field.value) + ";\n"; - } else { - code += Indent + Indent + "return $o != 0 ? $this->bb->get"; - code += MakeCamel(GenTypeGet(field.value.type)); - code += "($this->__vector($o) + $j * "; - code += NumToString(InlineSize(vectortype)) + ") : "; - code += GenDefaultValue(field.value) + ";\n"; - } - code += Indent + "}\n\n"; - } + code += Indent + "/**\n"; + code += Indent + " * @param int offset\n"; + code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name); + code += "($j)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $this->__offset(" + + NumToString(field.value.offset) + ");\n"; - // Get the value of a vector's union member. Uses a named return - // argument to conveniently set the zero value for the result. - void GetMemberOfVectorOfUnion(const FieldDef &field, - std::string *code_ptr) { - std::string &code = *code_ptr; - auto vectortype = field.value.type.VectorType(); - - code += Indent + "/**\n"; - code += Indent + " * @param int offset\n"; - code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; - code += Indent + " */\n"; - code += Indent + "public function get"; - code += MakeCamel(field.name); - code += "($j, $obj)\n"; - code += Indent + "{\n"; - code += Indent + Indent + - "$o = $this->__offset(" + - NumToString(field.value.offset) + - ");\n"; - code += Indent + Indent + "return $o != 0 ? "; - code += "$this->__union($obj, $this->__vector($o) + $j * "; - code += NumToString(InlineSize(vectortype)) + " - $this->bb_pos) : null;\n"; - code += Indent + "}\n\n"; - } - - // Recursively generate arguments for a constructor, to deal with nested - // structs. - static void StructBuilderArgs(const StructDef &struct_def, - const char *nameprefix, - std::string *code_ptr) { - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (IsStruct(field.value.type)) { - // Generate arguments for a struct inside a struct. To ensure names - // don't clash, and to make it obvious - // these arguments are constructing - // a nested struct, prefix the name with the field name. - StructBuilderArgs(*field.value.type.struct_def, - (nameprefix + (field.name + "_")).c_str(), - code_ptr); - } else { - std::string &code = *code_ptr; - code += (std::string)", $" + nameprefix; - code += MakeCamel(field.name, false); - } - } - } - - // Recursively generate struct construction statements and instert manual - // padding. - static void StructBuilderBody(const StructDef &struct_def, - const char *nameprefix, - std::string *code_ptr) { - std::string &code = *code_ptr; - code += Indent + Indent + "$builder->prep("; - code += NumToString(struct_def.minalign) + ", "; - code += NumToString(struct_def.bytesize) + ");\n"; - for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); - ++it) { - auto &field = **it; - if (field.padding) { - code += Indent + Indent + "$builder->pad("; - code += NumToString(field.padding) + ");\n"; - } - if (IsStruct(field.value.type)) { - StructBuilderBody(*field.value.type.struct_def, - (nameprefix + (field.name + "_")).c_str(), - code_ptr); - } else { - code += Indent + Indent + "$builder->put" + GenMethod(field) + "($"; - code += nameprefix + MakeCamel(field.name, false) + ");\n"; - } - } - } - - // Get the value of a table's starting offset. - static void GetStartOfTable(const StructDef &struct_def, - std::string *code_ptr) { - std::string &code = *code_ptr; - - code += Indent + "/**\n"; - code += Indent + " * @param FlatBufferBuilder $builder\n"; - code += Indent + " * @return void\n"; - code += Indent + " */\n"; - code += Indent + "public static function start" + struct_def.name; - code += "(FlatBufferBuilder $builder)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$builder->StartObject("; - code += NumToString(struct_def.fields.vec.size()); - code += ");\n"; - code += Indent + "}\n\n"; - - code += Indent + "/**\n"; - code += Indent + " * @param FlatBufferBuilder $builder\n"; - code += Indent + " * @return " + struct_def.name + "\n"; - code += Indent + " */\n"; - code += Indent + "public static function create" + struct_def.name; - code += "(FlatBufferBuilder $builder, "; - - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - - if (field.deprecated) continue; - code += "$" + field.name; - if (!(it == (--struct_def.fields.vec.end()))) { - code += ", "; - } - } - code += ")\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$builder->startObject("; - code += NumToString(struct_def.fields.vec.size()); - code += ");\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (field.deprecated) continue; - - code += Indent + Indent + "self::add"; - code += MakeCamel(field.name) + "($builder, $" + field.name + ");\n"; - } - - code += Indent + Indent + "$o = $builder->endObject();\n"; - - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (!field.deprecated && field.required) { - code += Indent + Indent + "$builder->required($o, "; - code += NumToString(field.value.offset); - code += "); // " + field.name + "\n"; - } - } - code += Indent + Indent + "return $o;\n"; - code += Indent + "}\n\n"; - } - - // Set the value of a table's field. - static void BuildFieldOfTable(const FieldDef &field, - const size_t offset, - std::string *code_ptr) { - std::string &code = *code_ptr; - - - code += Indent + "/**\n"; - code += Indent + " * @param FlatBufferBuilder $builder\n"; - code += Indent + " * @param " + GenTypeBasic(field.value.type) + "\n"; - code += Indent + " * @return void\n"; - code += Indent + " */\n"; - code += Indent + "public static function "; - code += "add" + MakeCamel(field.name); - code += "(FlatBufferBuilder $builder, "; - code += "$" + MakeCamel(field.name, false); - code += ")\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$builder->add"; - code += GenMethod(field) + "X("; - code += NumToString(offset) + ", "; - - - code += "$" + MakeCamel(field.name, false); - code += ", "; - - if (field.value.type.base_type == BASE_TYPE_BOOL) { - code += "false"; - } else { - code += field.value.constant; - } - code += ");\n"; - code += Indent + "}\n\n"; - } - - // Set the value of one of the members of a table's vector. - static void BuildVectorOfTable(const FieldDef &field, - std::string *code_ptr) { - std::string &code = *code_ptr; - - auto vector_type = field.value.type.VectorType(); - auto alignment = InlineAlignment(vector_type); - auto elem_size = InlineSize(vector_type); - code += Indent + "/**\n"; - code += Indent + " * @param FlatBufferBuilder $builder\n"; - code += Indent + " * @param array offset array\n"; - code += Indent + " * @return int vector offset\n"; - code += Indent + " */\n"; - code += Indent + "public static function create"; - code += MakeCamel(field.name); - code += "Vector(FlatBufferBuilder $builder, array $data)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$builder->startVector("; - code += NumToString(elem_size); - code += ", count($data), " + NumToString(alignment); - code += ");\n"; + if (field.value.type.VectorType().base_type == BASE_TYPE_STRING) { code += Indent + Indent; - code += "for ($i = count($data) - 1; $i >= 0; $i--) {\n"; - if (IsScalar(field.value.type.VectorType().base_type)) { - code += Indent + Indent + Indent; - code += "$builder->add"; - code += MakeCamel(GenTypeBasic(field.value.type.VectorType())); - code += "($data[$i]);\n"; + code += "return $o != 0 ? $this->__string($this->__vector($o) + $j * "; + code += NumToString(InlineSize(vectortype)) + ") : "; + code += GenDefaultValue(field.value) + ";\n"; + } else { + code += Indent + Indent + "return $o != 0 ? $this->bb->get"; + code += MakeCamel(GenTypeGet(field.value.type)); + code += "($this->__vector($o) + $j * "; + code += NumToString(InlineSize(vectortype)) + ") : "; + code += GenDefaultValue(field.value) + ";\n"; + } + code += Indent + "}\n\n"; + } + + // Get the value of a vector's union member. Uses a named return + // argument to conveniently set the zero value for the result. + void GetMemberOfVectorOfUnion(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + auto vectortype = field.value.type.VectorType(); + + code += Indent + "/**\n"; + code += Indent + " * @param int offset\n"; + code += Indent + " * @return " + GenTypeGet(field.value.type) + "\n"; + code += Indent + " */\n"; + code += Indent + "public function get"; + code += MakeCamel(field.name); + code += "($j, $obj)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $this->__offset(" + + NumToString(field.value.offset) + ");\n"; + code += Indent + Indent + "return $o != 0 ? "; + code += "$this->__union($obj, $this->__vector($o) + $j * "; + code += NumToString(InlineSize(vectortype)) + " - $this->bb_pos) : null;\n"; + code += Indent + "}\n\n"; + } + + // Recursively generate arguments for a constructor, to deal with nested + // structs. + static void StructBuilderArgs(const StructDef &struct_def, + const char *nameprefix, std::string *code_ptr) { + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (IsStruct(field.value.type)) { + // Generate arguments for a struct inside a struct. To ensure names + // don't clash, and to make it obvious + // these arguments are constructing + // a nested struct, prefix the name with the field name. + StructBuilderArgs(*field.value.type.struct_def, + (nameprefix + (field.name + "_")).c_str(), code_ptr); } else { - code += Indent + Indent + Indent; - code += "$builder->addOffset($data[$i]);\n"; + std::string &code = *code_ptr; + code += (std::string) ", $" + nameprefix; + code += MakeCamel(field.name, false); } - code += Indent + Indent + "}\n"; - code += Indent + Indent + "return $builder->endVector();\n"; - code += Indent + "}\n\n"; + } + } + // Recursively generate struct construction statements and instert manual + // padding. + static void StructBuilderBody(const StructDef &struct_def, + const char *nameprefix, std::string *code_ptr) { + std::string &code = *code_ptr; + code += Indent + Indent + "$builder->prep("; + code += NumToString(struct_def.minalign) + ", "; + code += NumToString(struct_def.bytesize) + ");\n"; + for (auto it = struct_def.fields.vec.rbegin(); + it != struct_def.fields.vec.rend(); ++it) { + auto &field = **it; + if (field.padding) { + code += Indent + Indent + "$builder->pad("; + code += NumToString(field.padding) + ");\n"; + } + if (IsStruct(field.value.type)) { + StructBuilderBody(*field.value.type.struct_def, + (nameprefix + (field.name + "_")).c_str(), code_ptr); + } else { + code += Indent + Indent + "$builder->put" + GenMethod(field) + "($"; + code += nameprefix + MakeCamel(field.name, false) + ");\n"; + } + } + } - code += Indent + "/**\n"; - code += Indent + " * @param FlatBufferBuilder $builder\n"; - code += Indent + " * @param int $numElems\n"; - code += Indent + " * @return void\n"; - code += Indent + " */\n"; - code += Indent + "public static function start"; - code += MakeCamel(field.name); - code += "Vector(FlatBufferBuilder $builder, $numElems)\n"; + // Get the value of a table's starting offset. + static void GetStartOfTable(const StructDef &struct_def, + std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "/**\n"; + code += Indent + " * @param FlatBufferBuilder $builder\n"; + code += Indent + " * @return void\n"; + code += Indent + " */\n"; + code += Indent + "public static function start" + struct_def.name; + code += "(FlatBufferBuilder $builder)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$builder->StartObject("; + code += NumToString(struct_def.fields.vec.size()); + code += ");\n"; + code += Indent + "}\n\n"; + + code += Indent + "/**\n"; + code += Indent + " * @param FlatBufferBuilder $builder\n"; + code += Indent + " * @return " + struct_def.name + "\n"; + code += Indent + " */\n"; + code += Indent + "public static function create" + struct_def.name; + code += "(FlatBufferBuilder $builder, "; + + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + + if (field.deprecated) continue; + code += "$" + field.name; + if (!(it == (--struct_def.fields.vec.end()))) { code += ", "; } + } + code += ")\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$builder->startObject("; + code += NumToString(struct_def.fields.vec.size()); + code += ");\n"; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + + code += Indent + Indent + "self::add"; + code += MakeCamel(field.name) + "($builder, $" + field.name + ");\n"; + } + + code += Indent + Indent + "$o = $builder->endObject();\n"; + + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (!field.deprecated && field.required) { + code += Indent + Indent + "$builder->required($o, "; + code += NumToString(field.value.offset); + code += "); // " + field.name + "\n"; + } + } + code += Indent + Indent + "return $o;\n"; + code += Indent + "}\n\n"; + } + + // Set the value of a table's field. + static void BuildFieldOfTable(const FieldDef &field, const size_t offset, + std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "/**\n"; + code += Indent + " * @param FlatBufferBuilder $builder\n"; + code += Indent + " * @param " + GenTypeBasic(field.value.type) + "\n"; + code += Indent + " * @return void\n"; + code += Indent + " */\n"; + code += Indent + "public static function "; + code += "add" + MakeCamel(field.name); + code += "(FlatBufferBuilder $builder, "; + code += "$" + MakeCamel(field.name, false); + code += ")\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$builder->add"; + code += GenMethod(field) + "X("; + code += NumToString(offset) + ", "; + + code += "$" + MakeCamel(field.name, false); + code += ", "; + + if (field.value.type.base_type == BASE_TYPE_BOOL) { + code += "false"; + } else { + code += field.value.constant; + } + code += ");\n"; + code += Indent + "}\n\n"; + } + + // Set the value of one of the members of a table's vector. + static void BuildVectorOfTable(const FieldDef &field, std::string *code_ptr) { + std::string &code = *code_ptr; + + auto vector_type = field.value.type.VectorType(); + auto alignment = InlineAlignment(vector_type); + auto elem_size = InlineSize(vector_type); + code += Indent + "/**\n"; + code += Indent + " * @param FlatBufferBuilder $builder\n"; + code += Indent + " * @param array offset array\n"; + code += Indent + " * @return int vector offset\n"; + code += Indent + " */\n"; + code += Indent + "public static function create"; + code += MakeCamel(field.name); + code += "Vector(FlatBufferBuilder $builder, array $data)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$builder->startVector("; + code += NumToString(elem_size); + code += ", count($data), " + NumToString(alignment); + code += ");\n"; + code += Indent + Indent; + code += "for ($i = count($data) - 1; $i >= 0; $i--) {\n"; + if (IsScalar(field.value.type.VectorType().base_type)) { + code += Indent + Indent + Indent; + code += "$builder->add"; + code += MakeCamel(GenTypeBasic(field.value.type.VectorType())); + code += "($data[$i]);\n"; + } else { + code += Indent + Indent + Indent; + code += "$builder->addOffset($data[$i]);\n"; + } + code += Indent + Indent + "}\n"; + code += Indent + Indent + "return $builder->endVector();\n"; + code += Indent + "}\n\n"; + + code += Indent + "/**\n"; + code += Indent + " * @param FlatBufferBuilder $builder\n"; + code += Indent + " * @param int $numElems\n"; + code += Indent + " * @return void\n"; + code += Indent + " */\n"; + code += Indent + "public static function start"; + code += MakeCamel(field.name); + code += "Vector(FlatBufferBuilder $builder, $numElems)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$builder->startVector("; + code += NumToString(elem_size); + code += ", $numElems, " + NumToString(alignment); + code += ");\n"; + code += Indent + "}\n\n"; + } + + // Get the offset of the end of a table. + void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) { + std::string &code = *code_ptr; + + code += Indent + "/**\n"; + code += Indent + " * @param FlatBufferBuilder $builder\n"; + code += Indent + " * @return int table offset\n"; + code += Indent + " */\n"; + code += Indent + "public static function end" + struct_def.name; + code += "(FlatBufferBuilder $builder)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$o = $builder->endObject();\n"; + + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (!field.deprecated && field.required) { + code += Indent + Indent + "$builder->required($o, "; + code += NumToString(field.value.offset); + code += "); // " + field.name + "\n"; + } + } + code += Indent + Indent + "return $o;\n"; + code += Indent + "}\n"; + + if (parser_.root_struct_def_ == &struct_def) { + code += "\n"; + code += Indent + "public static function finish"; + code += struct_def.name; + code += "Buffer(FlatBufferBuilder $builder, $offset)\n"; code += Indent + "{\n"; - code += Indent + Indent + "$builder->startVector("; - code += NumToString(elem_size); - code += ", $numElems, " + NumToString(alignment); + code += Indent + Indent + "$builder->finish($offset"; + + if (parser_.file_identifier_.length()) + code += ", \"" + parser_.file_identifier_ + "\""; code += ");\n"; - code += Indent + "}\n\n"; - } - - // Get the offset of the end of a table. - void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) { - std::string &code = *code_ptr; - - - code += Indent + "/**\n"; - code += Indent + " * @param FlatBufferBuilder $builder\n"; - code += Indent + " * @return int table offset\n"; - code += Indent + " */\n"; - code += Indent + "public static function end" + struct_def.name; - code += "(FlatBufferBuilder $builder)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$o = $builder->endObject();\n"; - - - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (!field.deprecated && field.required) { - code += Indent + Indent + "$builder->required($o, "; - code += NumToString(field.value.offset); - code += "); // " + field.name + "\n"; - } - } - code += Indent + Indent + "return $o;\n"; code += Indent + "}\n"; - - if (parser_.root_struct_def_ == &struct_def) { - code += "\n"; - code += Indent + "public static function finish"; - code += struct_def.name; - code += "Buffer(FlatBufferBuilder $builder, $offset)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$builder->finish($offset"; - - if (parser_.file_identifier_.length()) - code += ", \"" + parser_.file_identifier_ + "\""; - code += ");\n"; - code += Indent + "}\n"; - } } + } // Generate a struct field, conditioned on its child type(s). - void GenStructAccessor(const StructDef &struct_def, const FieldDef &field, - std::string *code_ptr) { - GenComment(field.doc_comment, code_ptr, nullptr); + void GenStructAccessor(const StructDef &struct_def, const FieldDef &field, + std::string *code_ptr) { + GenComment(field.doc_comment, code_ptr, nullptr); - if (IsScalar(field.value.type.base_type)) { - if (struct_def.fixed) { - GetScalarFieldOfStruct(field, code_ptr); - } else { - GetScalarFieldOfTable(field, code_ptr); - } + if (IsScalar(field.value.type.base_type)) { + if (struct_def.fixed) { + GetScalarFieldOfStruct(field, code_ptr); } else { - switch (field.value.type.base_type) { + GetScalarFieldOfTable(field, code_ptr); + } + } else { + switch (field.value.type.base_type) { case BASE_TYPE_STRUCT: if (struct_def.fixed) { GetStructFieldOfStruct(field, code_ptr); @@ -726,9 +689,7 @@ namespace php { GetStructFieldOfTable(field, code_ptr); } break; - case BASE_TYPE_STRING: - GetStringField(field, code_ptr); - break; + case BASE_TYPE_STRING: GetStringField(field, code_ptr); break; case BASE_TYPE_VECTOR: { auto vectortype = field.value.type.VectorType(); if (vectortype.base_type == BASE_TYPE_UNION) { @@ -740,198 +701,190 @@ namespace php { } break; } - case BASE_TYPE_UNION: - GetUnionField(field, code_ptr); - break; - default: - assert(0); - } + case BASE_TYPE_UNION: GetUnionField(field, code_ptr); break; + default: assert(0); + } + } + if (field.value.type.base_type == BASE_TYPE_VECTOR) { + GetVectorLen(field, code_ptr); + if (field.value.type.element == BASE_TYPE_UCHAR) { + GetUByte(field, code_ptr); + } + } + } + + // Generate table constructors, conditioned on its members' types. + void GenTableBuilders(const StructDef &struct_def, std::string *code_ptr) { + GetStartOfTable(struct_def, code_ptr); + + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + + auto offset = it - struct_def.fields.vec.begin(); + if (field.value.type.base_type == BASE_TYPE_UNION) { + std::string &code = *code_ptr; + code += Indent + "public static function add"; + code += MakeCamel(field.name); + code += "(FlatBufferBuilder $builder, $offset)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "$builder->addOffsetX("; + code += NumToString(offset) + ", $offset, 0);\n"; + code += Indent + "}\n\n"; + } else { + BuildFieldOfTable(field, offset, code_ptr); } if (field.value.type.base_type == BASE_TYPE_VECTOR) { - GetVectorLen(field, code_ptr); - if (field.value.type.element == BASE_TYPE_UCHAR) { - GetUByte(field, code_ptr); - } + BuildVectorOfTable(field, code_ptr); } } - // Generate table constructors, conditioned on its members' types. - void GenTableBuilders(const StructDef &struct_def, std::string *code_ptr) { - GetStartOfTable(struct_def, code_ptr); + GetEndOffsetOnTable(struct_def, code_ptr); + } - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (field.deprecated) continue; + // Generate struct or table methods. + void GenStruct(const StructDef &struct_def, std::string *code_ptr) { + if (struct_def.generated) return; - auto offset = it - struct_def.fields.vec.begin(); - if (field.value.type.base_type == BASE_TYPE_UNION) { - std::string &code = *code_ptr; - code += Indent + "public static function add"; - code += MakeCamel(field.name); - code += "(FlatBufferBuilder $builder, $offset)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "$builder->addOffsetX("; - code += NumToString(offset) + ", $offset, 0);\n"; - code += Indent + "}\n\n"; - } else { - BuildFieldOfTable(field, offset, code_ptr); - } - if (field.value.type.base_type == BASE_TYPE_VECTOR) { - BuildVectorOfTable(field, code_ptr); - } - } + GenComment(struct_def.doc_comment, code_ptr, nullptr); + BeginClass(struct_def, code_ptr); - GetEndOffsetOnTable(struct_def, code_ptr); + if (!struct_def.fixed) { + // Generate a special accessor for the table that has been declared as + // the root type. + NewRootTypeFromBuffer(struct_def, code_ptr); } - // Generate struct or table methods. - void GenStruct(const StructDef &struct_def, - std::string *code_ptr) { - if (struct_def.generated) return; + std::string &code = *code_ptr; + if (!struct_def.fixed) { + if (parser_.file_identifier_.length()) { + // Return the identifier + code += Indent + "public static function " + struct_def.name; + code += "Identifier()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "return \""; + code += parser_.file_identifier_ + "\";\n"; + code += Indent + "}\n\n"; - GenComment(struct_def.doc_comment, code_ptr, nullptr); - BeginClass(struct_def, code_ptr); - - if (!struct_def.fixed) { - // Generate a special accessor for the table that has been declared as - // the root type. - NewRootTypeFromBuffer(struct_def, code_ptr); + // Check if a buffer has the identifier. + code += Indent + "public static function " + struct_def.name; + code += "BufferHasIdentifier(ByteBuffer $buf)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "return self::"; + code += "__has_identifier($buf, self::"; + code += struct_def.name + "Identifier());\n"; + code += Indent + "}\n\n"; } - std::string &code = *code_ptr; - if (!struct_def.fixed) { - if (parser_.file_identifier_.length()) { - // Return the identifier - code += Indent + "public static function " + struct_def.name; - code += "Identifier()\n"; - code += Indent + "{\n"; - code += Indent + Indent + "return \""; - code += parser_.file_identifier_ + "\";\n"; - code += Indent + "}\n\n"; - - // Check if a buffer has the identifier. - code += Indent + "public static function " + struct_def.name; - code += "BufferHasIdentifier(ByteBuffer $buf)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "return self::"; - code += "__has_identifier($buf, self::"; - code += struct_def.name + "Identifier());\n"; - code += Indent + "}\n\n"; - } - - if (parser_.file_extension_.length()) { - // Return the extension - code += Indent + "public static function " + struct_def.name; - code += "Extension()\n"; - code += Indent + "{\n"; - code += Indent + Indent + "return \"" + parser_.file_extension_; - code += "\";\n"; - code += Indent + "}\n\n"; - } + if (parser_.file_extension_.length()) { + // Return the extension + code += Indent + "public static function " + struct_def.name; + code += "Extension()\n"; + code += Indent + "{\n"; + code += Indent + Indent + "return \"" + parser_.file_extension_; + code += "\";\n"; + code += Indent + "}\n\n"; } - - // Generate the Init method that sets the field in a pre-existing - // accessor object. This is to allow object reuse. - InitializeExisting(struct_def, code_ptr); - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { - auto &field = **it; - if (field.deprecated) continue; - - GenStructAccessor(struct_def, field, code_ptr); - } - - if (struct_def.fixed) { - // create a struct constructor function - GenStructBuilder(struct_def, code_ptr); - } else { - // Create a set of functions that allow table construction. - GenTableBuilders(struct_def, code_ptr); - } - EndClass(code_ptr); } - // Generate enum declarations. - static void GenEnum(const EnumDef &enum_def, std::string *code_ptr) { - if (enum_def.generated) return; + // Generate the Init method that sets the field in a pre-existing + // accessor object. This is to allow object reuse. + InitializeExisting(struct_def, code_ptr); + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; - GenComment(enum_def.doc_comment, code_ptr, nullptr); - BeginEnum(enum_def.name, code_ptr); - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); - ++it) { - auto &ev = **it; - GenComment(ev.doc_comment, code_ptr, nullptr); - EnumMember(ev, code_ptr); - } - - std::string &code = *code_ptr; - code += "\n"; - code += Indent + "private static $names = array(\n"; - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); ++it) { - auto &ev = **it; - code += Indent + Indent + "\"" + ev.name + "\",\n"; - } - - code += Indent + ");\n\n"; - code += Indent + "public static function Name($e)\n"; - code += Indent + "{\n"; - code += Indent + Indent + "if (!isset(self::$names[$e])) {\n"; - code += Indent + Indent + Indent + "throw new \\Exception();\n"; - code += Indent + Indent + "}\n"; - code += Indent + Indent + "return self::$names[$e];\n"; - code += Indent + "}\n"; - EndEnum(code_ptr); + GenStructAccessor(struct_def, field, code_ptr); } - // Returns the function name that is able to read a value of the given type. - static std::string GenGetter(const Type &type) { - switch (type.base_type) { + if (struct_def.fixed) { + // create a struct constructor function + GenStructBuilder(struct_def, code_ptr); + } else { + // Create a set of functions that allow table construction. + GenTableBuilders(struct_def, code_ptr); + } + EndClass(code_ptr); + } + + // Generate enum declarations. + static void GenEnum(const EnumDef &enum_def, std::string *code_ptr) { + if (enum_def.generated) return; + + GenComment(enum_def.doc_comment, code_ptr, nullptr); + BeginEnum(enum_def.name, code_ptr); + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); + ++it) { + auto &ev = **it; + GenComment(ev.doc_comment, code_ptr, nullptr); + EnumMember(ev, code_ptr); + } + + std::string &code = *code_ptr; + code += "\n"; + code += Indent + "private static $names = array(\n"; + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); + ++it) { + auto &ev = **it; + code += Indent + Indent + "\"" + ev.name + "\",\n"; + } + + code += Indent + ");\n\n"; + code += Indent + "public static function Name($e)\n"; + code += Indent + "{\n"; + code += Indent + Indent + "if (!isset(self::$names[$e])) {\n"; + code += Indent + Indent + Indent + "throw new \\Exception();\n"; + code += Indent + Indent + "}\n"; + code += Indent + Indent + "return self::$names[$e];\n"; + code += Indent + "}\n"; + EndEnum(code_ptr); + } + + // Returns the function name that is able to read a value of the given type. + static std::string GenGetter(const Type &type) { + switch (type.base_type) { case BASE_TYPE_STRING: return "__string"; case BASE_TYPE_STRUCT: return "__struct"; case BASE_TYPE_UNION: return "__union"; case BASE_TYPE_VECTOR: return GenGetter(type.VectorType()); - default: - return "Get"; + default: return "Get"; + } + } + + // Returns the method name for use with add/put calls. + static std::string GenMethod(const FieldDef &field) { + return IsScalar(field.value.type.base_type) + ? MakeCamel(GenTypeBasic(field.value.type)) + : (IsStruct(field.value.type) ? "Struct" : "Offset"); + } + + static std::string GenTypeBasic(const Type &type) { + static const char *ctypename[] = { + // clang-format off + #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #NTYPE, + FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) + #undef FLATBUFFERS_TD + // clang-format on + }; + return ctypename[type.base_type]; + } + + std::string GenDefaultValue(const Value &value) { + if (value.type.enum_def) { + if (auto val = value.type.enum_def->ReverseLookup( + atoi(value.constant.c_str()), false)) { + return WrapInNameSpace(*value.type.enum_def) + "::" + val->name; } } - // Returns the method name for use with add/put calls. - static std::string GenMethod(const FieldDef &field) { - return IsScalar(field.value.type.base_type) - ? MakeCamel(GenTypeBasic(field.value.type)) - : (IsStruct(field.value.type) ? "Struct" : "Offset"); - } + switch (value.type.base_type) { + case BASE_TYPE_BOOL: return value.constant == "0" ? "false" : "true"; - static std::string GenTypeBasic(const Type &type) { - static const char *ctypename[] = { -#define FLATBUFFERS_TD(ENUM, IDLTYPE, \ - CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ - #NTYPE, - FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) -#undef FLATBUFFERS_TD - }; - return ctypename[type.base_type]; - } - - std::string GenDefaultValue(const Value &value) { - if (value.type.enum_def) { - if (auto val = value.type.enum_def->ReverseLookup( - atoi(value.constant.c_str()), false)) { - return WrapInNameSpace(*value.type.enum_def) + "::" + val->name; - } - } - - switch (value.type.base_type) { - case BASE_TYPE_BOOL: - return value.constant == "0" ? "false" : "true"; - - case BASE_TYPE_STRING: - return "null"; + case BASE_TYPE_STRING: return "null"; case BASE_TYPE_LONG: case BASE_TYPE_ULONG: @@ -941,58 +894,50 @@ namespace php { } return "0"; - default: - return value.constant; - } + default: return value.constant; } + } - static std::string GenTypePointer(const Type &type) { - switch (type.base_type) { - case BASE_TYPE_STRING: - return "string"; - case BASE_TYPE_VECTOR: - return GenTypeGet(type.VectorType()); - case BASE_TYPE_STRUCT: - return type.struct_def->name; + static std::string GenTypePointer(const Type &type) { + switch (type.base_type) { + case BASE_TYPE_STRING: return "string"; + case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType()); + case BASE_TYPE_STRUCT: return type.struct_def->name; case BASE_TYPE_UNION: // fall through - default: - return "Table"; - } + default: return "Table"; } + } - static std::string GenTypeGet(const Type &type) { - return IsScalar(type.base_type) - ? GenTypeBasic(type) - : GenTypePointer(type); - } + static std::string GenTypeGet(const Type &type) { + return IsScalar(type.base_type) ? GenTypeBasic(type) : GenTypePointer(type); + } - // Create a struct with a builder and the struct's arguments. - static void GenStructBuilder(const StructDef &struct_def, - std::string *code_ptr) { - std::string &code = *code_ptr; - code += "\n"; - code += Indent + "/**\n"; - code += Indent + " * @return int offset\n"; - code += Indent + " */\n"; - code += Indent + "public static function create" + struct_def.name; - code += "(FlatBufferBuilder $builder"; - StructBuilderArgs(struct_def, "", code_ptr); - code += ")\n"; - code += Indent + "{\n"; + // Create a struct with a builder and the struct's arguments. + static void GenStructBuilder(const StructDef &struct_def, + std::string *code_ptr) { + std::string &code = *code_ptr; + code += "\n"; + code += Indent + "/**\n"; + code += Indent + " * @return int offset\n"; + code += Indent + " */\n"; + code += Indent + "public static function create" + struct_def.name; + code += "(FlatBufferBuilder $builder"; + StructBuilderArgs(struct_def, "", code_ptr); + code += ")\n"; + code += Indent + "{\n"; - StructBuilderBody(struct_def, "", code_ptr); + StructBuilderBody(struct_def, "", code_ptr); - code += Indent + Indent + "return $builder->offset();\n"; - code += Indent + "}\n"; - } + code += Indent + Indent + "return $builder->offset();\n"; + code += Indent + "}\n"; + } +}; +} // namespace php - }; - } // namespace php - - bool GeneratePhp(const Parser &parser, const std::string &path, - const std::string &file_name) { - php::PhpGenerator generator(parser, path, file_name); - return generator.generate(); - } - } // namespace flatbuffers +bool GeneratePhp(const Parser &parser, const std::string &path, + const std::string &file_name) { + php::PhpGenerator generator(parser, path, file_name); + return generator.generate(); +} +} // namespace flatbuffers diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp index a1a96b5c8..76dd29ac2 100644 --- a/src/idl_gen_python.cpp +++ b/src/idl_gen_python.cpp @@ -18,10 +18,10 @@ #include +#include "flatbuffers/code_generators.h" #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/code_generators.h" namespace flatbuffers { namespace python { @@ -35,7 +35,6 @@ static std::string GenTypeBasic(const Type &type); static std::string GenTypeGet(const Type &type); static std::string TypeName(const FieldDef &field); - // Hardcode spaces per indentation. const std::string Indent = " "; @@ -44,9 +43,8 @@ const std::string Indent = " "; std::string OffsetPrefix(const FieldDef &field) { return "\n" + Indent + Indent + "o = flatbuffers.number_types.UOffsetTFlags.py_type" + - "(self._tab.Offset(" + - NumToString(field.value.offset) + - "))\n" + Indent + Indent + "if o != 0:\n"; + "(self._tab.Offset(" + NumToString(field.value.offset) + "))\n" + + Indent + Indent + "if o != 0:\n"; } // Begin a class declaration. @@ -109,8 +107,7 @@ static void InitializeExisting(const StructDef &struct_def, } // Get the length of a vector. -static void GetVectorLen(const StructDef &struct_def, - const FieldDef &field, +static void GetVectorLen(const StructDef &struct_def, const FieldDef &field, std::string *code_ptr) { std::string &code = *code_ptr; @@ -188,8 +185,7 @@ static void GetStructFieldOfTable(const StructDef &struct_def, } // Get the value of a string. -static void GetStringField(const StructDef &struct_def, - const FieldDef &field, +static void GetStringField(const StructDef &struct_def, const FieldDef &field, std::string *code_ptr) { std::string &code = *code_ptr; GenReceiver(struct_def, code_ptr); @@ -202,8 +198,7 @@ static void GetStringField(const StructDef &struct_def, } // Get the value of a union from an object. -static void GetUnionField(const StructDef &struct_def, - const FieldDef &field, +static void GetUnionField(const StructDef &struct_def, const FieldDef &field, std::string *code_ptr) { std::string &code = *code_ptr; GenReceiver(struct_def, code_ptr); @@ -284,9 +279,7 @@ static void GetVectorOfNonStructAsNumpy(const StructDef &struct_def, // Currently, we only support accessing as numpy array if // the vector type is a scalar. - if (!(IsScalar(vectortype.base_type))) { - return; - } + if (!(IsScalar(vectortype.base_type))) { return; } GenReceiver(struct_def, code_ptr); code += MakeCamel(field.name) + "AsNumpy(self):"; @@ -319,22 +312,19 @@ static void BeginBuilderArgs(const StructDef &struct_def, // Recursively generate arguments for a constructor, to deal with nested // structs. static void StructBuilderArgs(const StructDef &struct_def, - const char *nameprefix, - std::string *code_ptr) { + const char *nameprefix, std::string *code_ptr) { for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { + it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (IsStruct(field.value.type)) { // Generate arguments for a struct inside a struct. To ensure names // don't clash, and to make it obvious these arguments are constructing // a nested struct, prefix the name with the field name. StructBuilderArgs(*field.value.type.struct_def, - (nameprefix + (field.name + "_")).c_str(), - code_ptr); + (nameprefix + (field.name + "_")).c_str(), code_ptr); } else { std::string &code = *code_ptr; - code += (std::string)", " + nameprefix; + code += (std::string) ", " + nameprefix; code += MakeCamel(field.name, false); } } @@ -349,21 +339,18 @@ static void EndBuilderArgs(std::string *code_ptr) { // Recursively generate struct construction statements and instert manual // padding. static void StructBuilderBody(const StructDef &struct_def, - const char *nameprefix, - std::string *code_ptr) { + const char *nameprefix, std::string *code_ptr) { std::string &code = *code_ptr; code += " builder.Prep(" + NumToString(struct_def.minalign) + ", "; code += NumToString(struct_def.bytesize) + ")\n"; for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); - ++it) { + it != struct_def.fields.vec.rend(); ++it) { auto &field = **it; if (field.padding) code += " builder.Pad(" + NumToString(field.padding) + ")\n"; if (IsStruct(field.value.type)) { StructBuilderBody(*field.value.type.struct_def, - (nameprefix + (field.name + "_")).c_str(), - code_ptr); + (nameprefix + (field.name + "_")).c_str(), code_ptr); } else { code += " builder.Prepend" + GenMethod(field) + "("; code += nameprefix + MakeCamel(field.name, false) + ")\n"; @@ -389,8 +376,7 @@ static void GetStartOfTable(const StructDef &struct_def, // Set the value of a table's field. static void BuildFieldOfTable(const StructDef &struct_def, - const FieldDef &field, - const size_t offset, + const FieldDef &field, const size_t offset, std::string *code_ptr) { std::string &code = *code_ptr; code += "def " + struct_def.name + "Add" + MakeCamel(field.name); @@ -413,8 +399,7 @@ static void BuildFieldOfTable(const StructDef &struct_def, // Set the value of one of the members of a table's vector. static void BuildVectorOfTable(const StructDef &struct_def, - const FieldDef &field, - std::string *code_ptr) { + const FieldDef &field, std::string *code_ptr) { std::string &code = *code_ptr; code += "def " + struct_def.name + "Start"; code += MakeCamel(field.name); @@ -445,8 +430,7 @@ static void GenReceiver(const StructDef &struct_def, std::string *code_ptr) { // Generate a struct field, conditioned on its child type(s). static void GenStructAccessor(const StructDef &struct_def, - const FieldDef &field, - std::string *code_ptr) { + const FieldDef &field, std::string *code_ptr) { GenComment(field.doc_comment, code_ptr, nullptr, "# "); if (IsScalar(field.value.type.base_type)) { if (struct_def.fixed) { @@ -463,9 +447,7 @@ static void GenStructAccessor(const StructDef &struct_def, GetStructFieldOfTable(struct_def, field, code_ptr); } break; - case BASE_TYPE_STRING: - GetStringField(struct_def, field, code_ptr); - break; + case BASE_TYPE_STRING: GetStringField(struct_def, field, code_ptr); break; case BASE_TYPE_VECTOR: { auto vectortype = field.value.type.VectorType(); if (vectortype.base_type == BASE_TYPE_STRUCT) { @@ -476,11 +458,8 @@ static void GenStructAccessor(const StructDef &struct_def, } break; } - case BASE_TYPE_UNION: - GetUnionField(struct_def, field, code_ptr); - break; - default: - assert(0); + case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break; + default: assert(0); } } if (field.value.type.base_type == BASE_TYPE_VECTOR) { @@ -494,8 +473,7 @@ static void GenTableBuilders(const StructDef &struct_def, GetStartOfTable(struct_def, code_ptr); for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { + it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (field.deprecated) continue; @@ -510,8 +488,7 @@ static void GenTableBuilders(const StructDef &struct_def, } // Generate struct or table methods. -static void GenStruct(const StructDef &struct_def, - std::string *code_ptr) { +static void GenStruct(const StructDef &struct_def, std::string *code_ptr) { if (struct_def.generated) return; GenComment(struct_def.doc_comment, code_ptr, nullptr, "# "); @@ -525,8 +502,7 @@ static void GenStruct(const StructDef &struct_def, // accessor object. This is to allow object reuse. InitializeExisting(struct_def, code_ptr); for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { + it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (field.deprecated) continue; @@ -548,8 +524,7 @@ static void GenEnum(const EnumDef &enum_def, std::string *code_ptr) { GenComment(enum_def.doc_comment, code_ptr, nullptr, "# "); BeginEnum(enum_def.name, code_ptr); - for (auto it = enum_def.vals.vec.begin(); - it != enum_def.vals.vec.end(); + for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { auto &ev = **it; GenComment(ev.doc_comment, code_ptr, nullptr, "# "); @@ -565,49 +540,44 @@ static std::string GenGetter(const Type &type) { case BASE_TYPE_UNION: return "self._tab.Union("; case BASE_TYPE_VECTOR: return GenGetter(type.VectorType()); default: - return "self._tab.Get(flatbuffers.number_types." + \ - MakeCamel(GenTypeGet(type)) + \ - "Flags, "; + return "self._tab.Get(flatbuffers.number_types." + + MakeCamel(GenTypeGet(type)) + "Flags, "; } } // Returns the method name for use with add/put calls. static std::string GenMethod(const FieldDef &field) { return IsScalar(field.value.type.base_type) - ? MakeCamel(GenTypeBasic(field.value.type)) - : (IsStruct(field.value.type) ? "Struct" : "UOffsetTRelative"); + ? MakeCamel(GenTypeBasic(field.value.type)) + : (IsStruct(field.value.type) ? "Struct" : "UOffsetTRelative"); } static std::string GenTypeBasic(const Type &type) { static const char *ctypename[] = { + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #PTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD + // clang-format on }; return ctypename[type.base_type]; } static std::string GenTypePointer(const Type &type) { switch (type.base_type) { - case BASE_TYPE_STRING: - return "string"; - case BASE_TYPE_VECTOR: - return GenTypeGet(type.VectorType()); - case BASE_TYPE_STRUCT: - return type.struct_def->name; + case BASE_TYPE_STRING: return "string"; + case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType()); + case BASE_TYPE_STRUCT: return type.struct_def->name; case BASE_TYPE_UNION: // fall through - default: - return "*flatbuffers.Table"; + default: return "*flatbuffers.Table"; } } static std::string GenTypeGet(const Type &type) { - return IsScalar(type.base_type) - ? GenTypeBasic(type) - : GenTypePointer(type); + return IsScalar(type.base_type) ? GenTypeBasic(type) : GenTypePointer(type); } static std::string TypeName(const FieldDef &field) { @@ -666,9 +636,7 @@ class PythonGenerator : public BaseGenerator { std::string &code = *code_ptr; code = code + "# " + FlatBuffersGeneratedWarning() + "\n\n"; code += "# namespace: " + name_space_name + "\n\n"; - if (needs_imports) { - code += "import flatbuffers\n\n"; - } + if (needs_imports) { code += "import flatbuffers\n\n"; } } // Save out the generated code for a Python Table type. @@ -688,8 +656,8 @@ class PythonGenerator : public BaseGenerator { std::string code = ""; BeginFile(LastNamespacePart(*def.defined_namespace), needs_imports, &code); code += classcode; - std::string filename = NamespaceDir(*def.defined_namespace) + - def.name + ".py"; + std::string filename = + NamespaceDir(*def.defined_namespace) + def.name + ".py"; return SaveFile(filename.c_str(), code, false); } }; diff --git a/src/idl_gen_text.cpp b/src/idl_gen_text.cpp index 50d54c5fb..89a1810ac 100644 --- a/src/idl_gen_text.cpp +++ b/src/idl_gen_text.cpp @@ -17,15 +17,14 @@ // independent from idl_parser, since this code is not needed for most clients #include "flatbuffers/flatbuffers.h" +#include "flatbuffers/flexbuffers.h" #include "flatbuffers/idl.h" #include "flatbuffers/util.h" -#include "flatbuffers/flexbuffers.h" namespace flatbuffers { static bool GenStruct(const StructDef &struct_def, const Table *table, - int indent, const IDLOptions &opts, - std::string *_text); + int indent, const IDLOptions &opts, std::string *_text); // If indentation is less than 0, that indicates we don't want any newlines // either. @@ -33,9 +32,7 @@ const char *NewLine(const IDLOptions &opts) { return opts.indent_step >= 0 ? "\n" : ""; } -int Indent(const IDLOptions &opts) { - return std::max(opts.indent_step, 0); -} +int Indent(const IDLOptions &opts) { return std::max(opts.indent_step, 0); } // Output an identifier with or without quotes depending on strictness. void OutputIdentifier(const std::string &name, const IDLOptions &opts, @@ -49,10 +46,9 @@ void OutputIdentifier(const std::string &name, const IDLOptions &opts, // Print (and its template specialization below for pointers) generate text // for a single FlatBuffer value into JSON format. // The general case for scalars: -template bool Print(T val, Type type, int /*indent*/, - Type * /*union_type*/, - const IDLOptions &opts, - std::string *_text) { +template +bool Print(T val, Type type, int /*indent*/, Type * /*union_type*/, + const IDLOptions &opts, std::string *_text) { std::string &text = *_text; if (type.enum_def && opts.output_enum_identifiers) { auto enum_val = type.enum_def->ReverseLookup(static_cast(val)); @@ -72,9 +68,9 @@ template bool Print(T val, Type type, int /*indent*/, } // Print a vector a sequence of JSON values, comma separated, wrapped in "[]". -template bool PrintVector(const Vector &v, Type type, - int indent, const IDLOptions &opts, - std::string *_text) { +template +bool PrintVector(const Vector &v, Type type, int indent, + const IDLOptions &opts, std::string *_text) { std::string &text = *_text; text += "["; text += NewLine(opts); @@ -90,8 +86,7 @@ template bool PrintVector(const Vector &v, Type type, return false; } } else { - if (!Print(v[i], type, indent + Indent(opts), nullptr, - opts, _text)) { + if (!Print(v[i], type, indent + Indent(opts), nullptr, opts, _text)) { return false; } } @@ -103,11 +98,10 @@ template bool PrintVector(const Vector &v, Type type, } // Specialization of Print above for pointer types. -template<> bool Print(const void *val, - Type type, int indent, - Type *union_type, - const IDLOptions &opts, - std::string *_text) { +template<> +bool Print(const void *val, Type type, int indent, + Type *union_type, const IDLOptions &opts, + std::string *_text) { switch (type.base_type) { case BASE_TYPE_UNION: // If this assert hits, you have an corrupt buffer, a union type field @@ -116,11 +110,8 @@ template<> bool Print(const void *val, return Print(val, *union_type, indent, nullptr, opts, _text); case BASE_TYPE_STRUCT: - if (!GenStruct(*type.struct_def, - reinterpret_cast(val), - indent, - opts, - _text)) { + if (!GenStruct(*type.struct_def, reinterpret_cast(val), + indent, opts, _text)) { return false; } break; @@ -135,6 +126,7 @@ template<> bool Print(const void *val, type = type.VectorType(); // Call PrintVector above specifically for each element type: switch (type.base_type) { + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ @@ -146,6 +138,7 @@ template<> bool Print(const void *val, break; FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD + // clang-format on } break; default: assert(0); @@ -154,31 +147,28 @@ template<> bool Print(const void *val, } // Generate text for a scalar field. -template static bool GenField(const FieldDef &fd, - const Table *table, bool fixed, - const IDLOptions &opts, - int indent, - std::string *_text) { - return Print(fixed ? - reinterpret_cast(table)->GetField(fd.value.offset) : - table->GetField(fd.value.offset, 0), fd.value.type, indent, nullptr, - opts, _text); +template +static bool GenField(const FieldDef &fd, const Table *table, bool fixed, + const IDLOptions &opts, int indent, std::string *_text) { + return Print(fixed ? reinterpret_cast(table)->GetField( + fd.value.offset) + : table->GetField(fd.value.offset, 0), + fd.value.type, indent, nullptr, opts, _text); } static bool GenStruct(const StructDef &struct_def, const Table *table, - int indent, const IDLOptions &opts, - std::string *_text); + int indent, const IDLOptions &opts, std::string *_text); // Generate text for non-scalar field. static bool GenFieldOffset(const FieldDef &fd, const Table *table, bool fixed, - int indent, Type *union_type, - const IDLOptions &opts, std::string *_text) { + int indent, Type *union_type, const IDLOptions &opts, + std::string *_text) { const void *val = nullptr; if (fixed) { // The only non-scalar fields in structs are structs. assert(IsStruct(fd.value.type)); - val = reinterpret_cast(table)-> - GetStruct(fd.value.offset); + val = reinterpret_cast(table)->GetStruct( + fd.value.offset); } else if (fd.flexbuffer) { auto vec = table->GetPointer *>(fd.value.offset); auto root = flexbuffers::GetRoot(vec->data(), vec->size()); @@ -190,8 +180,8 @@ static bool GenFieldOffset(const FieldDef &fd, const Table *table, bool fixed, return GenStruct(*fd.nested_flatbuffer, root, indent, opts, _text); } else { val = IsStruct(fd.value.type) - ? table->GetStruct(fd.value.offset) - : table->GetPointer(fd.value.offset); + ? table->GetStruct(fd.value.offset) + : table->GetPointer(fd.value.offset); } return Print(val, fd.value.type, indent, union_type, opts, _text); } @@ -199,20 +189,17 @@ static bool GenFieldOffset(const FieldDef &fd, const Table *table, bool fixed, // Generate text for a struct or table, values separated by commas, indented, // and bracketed by "{}" static bool GenStruct(const StructDef &struct_def, const Table *table, - int indent, const IDLOptions &opts, - std::string *_text) { + int indent, const IDLOptions &opts, std::string *_text) { std::string &text = *_text; text += "{"; int fieldout = 0; Type *union_type = nullptr; for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); - ++it) { + it != struct_def.fields.vec.end(); ++it) { FieldDef &fd = **it; auto is_present = struct_def.fixed || table->CheckField(fd.value.offset); auto output_anyway = opts.output_default_scalars_in_json && - IsScalar(fd.value.type.base_type) && - !fd.deprecated; + IsScalar(fd.value.type.base_type) && !fd.deprecated; if (is_present || output_anyway) { if (fieldout++) { if (!opts.protobuf_ascii_alike) text += ","; @@ -222,18 +209,20 @@ static bool GenStruct(const StructDef &struct_def, const Table *table, OutputIdentifier(fd.name, opts, _text); if (!opts.protobuf_ascii_alike || (fd.value.type.base_type != BASE_TYPE_STRUCT && - fd.value.type.base_type != BASE_TYPE_VECTOR)) text += ":"; + fd.value.type.base_type != BASE_TYPE_VECTOR)) + text += ":"; text += " "; if (is_present) { switch (fd.value.type.base_type) { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ - CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ - case BASE_TYPE_ ## ENUM: \ - if (!GenField(fd, table, struct_def.fixed, \ - opts, indent + Indent(opts), _text)) { \ - return false; \ - } \ - break; + // clang-format off + #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + case BASE_TYPE_ ## ENUM: \ + if (!GenField(fd, table, struct_def.fixed, \ + opts, indent + Indent(opts), _text)) { \ + return false; \ + } \ + break; FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) #undef FLATBUFFERS_TD // Generate drop-thru case statements for all pointer types: @@ -247,16 +236,15 @@ static bool GenStruct(const StructDef &struct_def, const Table *table, return false; } break; + // clang-format on } if (fd.value.type.base_type == BASE_TYPE_UTYPE) { auto enum_val = fd.value.type.enum_def->ReverseLookup( - table->GetField(fd.value.offset, 0)); + table->GetField(fd.value.offset, 0)); assert(enum_val); union_type = &enum_val->union_type; } - } - else - { + } else { text += fd.value.constant; } } @@ -272,12 +260,9 @@ bool GenerateText(const Parser &parser, const void *flatbuffer, std::string *_text) { std::string &text = *_text; assert(parser.root_struct_def_); // call SetRootType() - text.reserve(1024); // Reduce amount of inevitable reallocs. - if (!GenStruct(*parser.root_struct_def_, - GetRoot
(flatbuffer), - 0, - parser.opts, - _text)) { + text.reserve(1024); // Reduce amount of inevitable reallocs. + if (!GenStruct(*parser.root_struct_def_, GetRoot
(flatbuffer), 0, + parser.opts, _text)) { return false; } text += NewLine(parser.opts); @@ -289,34 +274,29 @@ std::string TextFileName(const std::string &path, return path + file_name + ".json"; } -bool GenerateTextFile(const Parser &parser, - const std::string &path, +bool GenerateTextFile(const Parser &parser, const std::string &path, const std::string &file_name) { if (!parser.builder_.GetSize() || !parser.root_struct_def_) return true; std::string text; if (!GenerateText(parser, parser.builder_.GetBufferPointer(), &text)) { return false; } - return flatbuffers::SaveFile(TextFileName(path, file_name).c_str(), - text, + return flatbuffers::SaveFile(TextFileName(path, file_name).c_str(), text, false); } -std::string TextMakeRule(const Parser &parser, - const std::string &path, +std::string TextMakeRule(const Parser &parser, const std::string &path, const std::string &file_name) { if (!parser.builder_.GetSize() || !parser.root_struct_def_) return ""; - std::string filebase = flatbuffers::StripPath( - flatbuffers::StripExtension(file_name)); + std::string filebase = + flatbuffers::StripPath(flatbuffers::StripExtension(file_name)); std::string make_rule = TextFileName(path, filebase) + ": " + file_name; - auto included_files = parser.GetIncludedFilesRecursive( - parser.root_struct_def_->file); - for (auto it = included_files.begin(); - it != included_files.end(); ++it) { + auto included_files = + parser.GetIncludedFilesRecursive(parser.root_struct_def_->file); + for (auto it = included_files.begin(); it != included_files.end(); ++it) { make_rule += " " + *it; } return make_rule; } } // namespace flatbuffers - diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index c0a3b8f24..dc8f58132 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -15,8 +15,8 @@ */ #include -#include #include +#include #include @@ -28,32 +28,39 @@ namespace flatbuffers { const double kPi = 3.14159265358979323846; const char *const kTypeNames[] = { +// clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ IDLTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD + // clang-format on nullptr }; const char kTypeSizes[] = { +// clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ sizeof(CTYPE), FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD + // clang-format on }; // The enums in the reflection schema should match the ones we use internally. // Compare the last element to check if these go out of sync. -static_assert(BASE_TYPE_UNION == - static_cast(reflection::Union), +static_assert(BASE_TYPE_UNION == static_cast(reflection::Union), "enums don't match"); // Any parsing calls have to be wrapped in this macro, which automates // handling of recursive error checking a bit. It will check the received // CheckedError object, and return straight away on error. -#define ECHECK(call) { auto ce = (call); if (ce.Check()) return ce; } +#define ECHECK(call) \ + { \ + auto ce = (call); \ + if (ce.Check()) return ce; \ + } // These two functions are called hundreds of times below, so define a short // form: @@ -62,29 +69,27 @@ static_assert(BASE_TYPE_UNION == static bool ValidateUTF8(const std::string &str) { const char *s = &str[0]; - const char * const sEnd = s + str.length(); + const char *const sEnd = s + str.length(); while (s < sEnd) { - if (FromUTF8(&s) < 0) { - return false; - } + if (FromUTF8(&s) < 0) { return false; } } return true; } void Parser::Message(const std::string &msg) { error_ = file_being_parsed_.length() ? AbsolutePath(file_being_parsed_) : ""; + // clang-format off #ifdef _WIN32 error_ += "(" + NumToString(line_) + ")"; // MSVC alike #else if (file_being_parsed_.length()) error_ += ":"; error_ += NumToString(line_) + ":0"; // gcc alike #endif + // clang-format on error_ += ": " + msg; } -void Parser::Warning(const std::string &msg) { - Message("warning: " + msg); -} +void Parser::Warning(const std::string &msg) { Message("warning: " + msg); } CheckedError Parser::Error(const std::string &msg) { Message("error: " + msg); @@ -110,8 +115,8 @@ CheckedError Parser::CheckInRange(int64_t val, int64_t min, int64_t max) { } // atot: templated version of atoi/atof: convert a string to an instance of T. -template inline CheckedError atot(const char *s, Parser &parser, - T *val) { +template +inline CheckedError atot(const char *s, Parser &parser, T *val) { int64_t i = StringToInt(s); const int64_t min = flatbuffers::numeric_limits::min(); const int64_t max = flatbuffers::numeric_limits::max(); @@ -119,33 +124,35 @@ template inline CheckedError atot(const char *s, Parser &parser, *val = (T)i; return NoError(); } -template<> inline CheckedError atot(const char *s, Parser &parser, - uint64_t *val) { +template<> +inline CheckedError atot(const char *s, Parser &parser, + uint64_t *val) { (void)parser; *val = StringToUInt(s); return NoError(); } -template<> inline CheckedError atot(const char *s, Parser &parser, - bool *val) { +template<> +inline CheckedError atot(const char *s, Parser &parser, bool *val) { (void)parser; *val = 0 != atoi(s); return NoError(); } -template<> inline CheckedError atot(const char *s, Parser &parser, - float *val) { +template<> +inline CheckedError atot(const char *s, Parser &parser, float *val) { (void)parser; *val = static_cast(strtod(s, nullptr)); return NoError(); } -template<> inline CheckedError atot(const char *s, Parser &parser, - double *val) { +template<> +inline CheckedError atot(const char *s, Parser &parser, double *val) { (void)parser; *val = strtod(s, nullptr); return NoError(); } -template<> inline CheckedError atot>(const char *s, Parser &parser, - Offset *val) { +template<> +inline CheckedError atot>(const char *s, Parser &parser, + Offset *val) { (void)parser; *val = Offset(atoi(s)); return NoError(); @@ -154,15 +161,10 @@ template<> inline CheckedError atot>(const char *s, Parser &parser, std::string Namespace::GetFullyQualifiedName(const std::string &name, size_t max_components) const { // Early exit if we don't have a defined namespace. - if (components.size() == 0 || !max_components) { - return name; - } + if (components.size() == 0 || !max_components) { return name; } std::stringstream stream; - for (size_t i = 0; i < std::min(components.size(), max_components); - i++) { - if (i) { - stream << "."; - } + for (size_t i = 0; i < std::min(components.size(), max_components); i++) { + if (i) { stream << "."; } stream << components[i]; } if (name.length()) stream << "." << name; @@ -171,6 +173,7 @@ std::string Namespace::GetFullyQualifiedName(const std::string &name, // Declare tokens we'll use. Single character tokens are represented by their // ascii character code (e.g. '{'), others above 256. +// clang-format off #define FLATBUFFERS_GEN_TOKENS(TD) \ TD(Eof, 256, "end of file") \ TD(StringConstant, 257, "string constant") \ @@ -205,6 +208,7 @@ static std::string TokenToString(int t) { return tokens[t - 256]; } } +// clang-format on std::string Parser::TokenToStringId(int t) { return t == kTokenIdentifier ? attribute_ : TokenToString(t); @@ -223,8 +227,7 @@ CheckedError Parser::ParseHexNum(int nibbles, uint64_t *val) { } CheckedError Parser::SkipByteOrderMark() { - if (static_cast(*cursor_) != 0xef) - return NoError(); + if (static_cast(*cursor_) != 0xef) return NoError(); cursor_++; if (static_cast(*cursor_) != 0xbb) return Error("invalid utf-8 byte order mark"); @@ -247,13 +250,30 @@ CheckedError Parser::Next() { char c = *cursor_++; token_ = c; switch (c) { - case '\0': cursor_--; token_ = kTokenEof; return NoError(); - case ' ': case '\r': case '\t': break; - case '\n': line_++; seen_newline = true; break; - case '{': case '}': case '(': case ')': case '[': case ']': - case ',': case ':': case ';': case '=': return NoError(); + case '\0': + cursor_--; + token_ = kTokenEof; + return NoError(); + case ' ': + case '\r': + case '\t': break; + case '\n': + line_++; + seen_newline = true; + break; + case '{': + case '}': + case '(': + case ')': + case '[': + case ']': + case ',': + case ':': + case ';': + case '=': return NoError(); case '.': - if(!isdigit(static_cast(*cursor_))) return NoError(); + if (!isdigit(static_cast(*cursor_))) + return NoError(); return Error("floating point constant can\'t start with \".\""); case '\"': case '\'': { @@ -264,21 +284,47 @@ CheckedError Parser::Next() { return Error("illegal character in string constant"); if (*cursor_ == '\\') { cursor_++; - if (unicode_high_surrogate != -1 && - *cursor_ != 'u') { + if (unicode_high_surrogate != -1 && *cursor_ != 'u') { return Error( - "illegal Unicode sequence (unpaired high surrogate)"); + "illegal Unicode sequence (unpaired high surrogate)"); } switch (*cursor_) { - case 'n': attribute_ += '\n'; cursor_++; break; - case 't': attribute_ += '\t'; cursor_++; break; - case 'r': attribute_ += '\r'; cursor_++; break; - case 'b': attribute_ += '\b'; cursor_++; break; - case 'f': attribute_ += '\f'; cursor_++; break; - case '\"': attribute_ += '\"'; cursor_++; break; - case '\'': attribute_ += '\''; cursor_++; break; - case '\\': attribute_ += '\\'; cursor_++; break; - case '/': attribute_ += '/'; cursor_++; break; + case 'n': + attribute_ += '\n'; + cursor_++; + break; + case 't': + attribute_ += '\t'; + cursor_++; + break; + case 'r': + attribute_ += '\r'; + cursor_++; + break; + case 'b': + attribute_ += '\b'; + cursor_++; + break; + case 'f': + attribute_ += '\f'; + cursor_++; + break; + case '\"': + attribute_ += '\"'; + cursor_++; + break; + case '\'': + attribute_ += '\''; + cursor_++; + break; + case '\\': + attribute_ += '\\'; + cursor_++; + break; + case '/': + attribute_ += '/'; + cursor_++; + break; case 'x': { // Not in the JSON standard cursor_++; uint64_t val; @@ -293,25 +339,25 @@ CheckedError Parser::Next() { if (val >= 0xD800 && val <= 0xDBFF) { if (unicode_high_surrogate != -1) { return Error( - "illegal Unicode sequence (multiple high surrogates)"); + "illegal Unicode sequence (multiple high surrogates)"); } else { unicode_high_surrogate = static_cast(val); } } else if (val >= 0xDC00 && val <= 0xDFFF) { if (unicode_high_surrogate == -1) { return Error( - "illegal Unicode sequence (unpaired low surrogate)"); + "illegal Unicode sequence (unpaired low surrogate)"); } else { int code_point = 0x10000 + - ((unicode_high_surrogate & 0x03FF) << 10) + - (val & 0x03FF); + ((unicode_high_surrogate & 0x03FF) << 10) + + (val & 0x03FF); ToUTF8(code_point, &attribute_); unicode_high_surrogate = -1; } } else { if (unicode_high_surrogate != -1) { return Error( - "illegal Unicode sequence (unpaired high surrogate)"); + "illegal Unicode sequence (unpaired high surrogate)"); } ToUTF8(static_cast(val), &attribute_); } @@ -319,17 +365,16 @@ CheckedError Parser::Next() { } default: return Error("unknown escape code in string constant"); } - } else { // printable chars + UTF-8 bytes + } else { // printable chars + UTF-8 bytes if (unicode_high_surrogate != -1) { return Error( - "illegal Unicode sequence (unpaired high surrogate)"); + "illegal Unicode sequence (unpaired high surrogate)"); } attribute_ += *cursor_++; } } if (unicode_high_surrogate != -1) { - return Error( - "illegal Unicode sequence (unpaired high surrogate)"); + return Error("illegal Unicode sequence (unpaired high surrogate)"); } cursor_++; if (!opts.allow_non_utf8 && !ValidateUTF8(attribute_)) { @@ -345,7 +390,7 @@ CheckedError Parser::Next() { if (*start == '/') { // documentation comment if (cursor_ != source_ && !seen_newline) return Error( - "a documentation comment should be on a line on its own"); + "a documentation comment should be on a line on its own"); doc_comment_.push_back(std::string(start + 1, cursor_)); } break; @@ -381,13 +426,13 @@ CheckedError Parser::Next() { c = '0'; } if (c == '0' && (*cursor_ == 'x' || *cursor_ == 'X')) { - cursor_++; - while (isxdigit(static_cast(*cursor_))) cursor_++; - attribute_.append(start + 2, cursor_); - attribute_ = NumToString(static_cast( - StringToUInt(attribute_.c_str(), nullptr, 16))); - token_ = kTokenIntegerConstant; - return NoError(); + cursor_++; + while (isxdigit(static_cast(*cursor_))) cursor_++; + attribute_.append(start + 2, cursor_); + attribute_ = NumToString(static_cast( + StringToUInt(attribute_.c_str(), nullptr, 16))); + token_ = kTokenIntegerConstant; + return NoError(); } while (isdigit(static_cast(*cursor_))) cursor_++; if (*cursor_ == '.' || *cursor_ == 'e' || *cursor_ == 'E') { @@ -418,9 +463,7 @@ CheckedError Parser::Next() { } // Check if a given token is next. -bool Parser::Is(int t) { - return t == token_; -} +bool Parser::Is(int t) { return t == token_; } bool Parser::IsIdent(const char *id) { return token_ == kTokenIdentifier && attribute_ == id; @@ -429,8 +472,8 @@ bool Parser::IsIdent(const char *id) { // Expect a given token to be next, consume it, or error if not present. CheckedError Parser::Expect(int t) { if (t != token_) { - return Error("expecting: " + TokenToString(t) + " instead got: " + - TokenToStringId(token_)); + return Error("expecting: " + TokenToString(t) + + " instead got: " + TokenToStringId(token_)); } NEXT(); return NoError(); @@ -452,7 +495,7 @@ EnumDef *Parser::LookupEnum(const std::string &id) { for (int components = static_cast(current_namespace_->components.size()); components >= 0; components--) { auto ed = enums_.Lookup( - current_namespace_->GetFullyQualifiedName(id, components)); + current_namespace_->GetFullyQualifiedName(id, components)); if (ed) return ed; } return nullptr; @@ -528,8 +571,7 @@ CheckedError Parser::ParseType(Type &type) { if (subtype.base_type == BASE_TYPE_VECTOR) { // We could support this, but it will complicate things, and it's // easier to work around with a struct around the inner vector. - return Error( - "nested vector types not supported (wrap in table first)."); + return Error("nested vector types not supported (wrap in table first)."); } type = Type(BASE_TYPE_VECTOR, subtype.struct_def, subtype.enum_def); type.element = subtype.base_type; @@ -544,7 +586,7 @@ CheckedError Parser::AddField(StructDef &struct_def, const std::string &name, const Type &type, FieldDef **dest) { auto &field = *new FieldDef(); field.value.offset = - FieldIndexToOffset(static_cast(struct_def.fields.vec.size())); + FieldIndexToOffset(static_cast(struct_def.fields.vec.size())); field.name = name; field.file = struct_def.file; field.value.type = type; @@ -589,15 +631,16 @@ CheckedError Parser::ParseField(StructDef &struct_def) { type.element == BASE_TYPE_UNION) { // Only cpp, js and ts supports the union vector feature so far. if (!SupportsVectorOfUnions()) { - return Error("Vectors of unions are not yet supported in all " - "the specified programming languages."); + return Error( + "Vectors of unions are not yet supported in all " + "the specified programming languages."); } // For vector of union fields, add a second auto-generated vector field to // hold the types, with a special suffix. Type union_vector(BASE_TYPE_VECTOR, nullptr, type.enum_def); union_vector.element = BASE_TYPE_UTYPE; - ECHECK(AddField(struct_def, name + UnionTypeFieldSuffix(), - union_vector, &typefield)); + ECHECK(AddField(struct_def, name + UnionTypeFieldSuffix(), union_vector, + &typefield)); } FieldDef *field; @@ -614,15 +657,13 @@ CheckedError Parser::ParseField(StructDef &struct_def) { field->value.constant += ".0"; } - if (type.enum_def && - IsScalar(type.base_type) && - !struct_def.fixed && + if (type.enum_def && IsScalar(type.base_type) && !struct_def.fixed && !type.enum_def->attributes.Lookup("bit_flags") && - !type.enum_def->ReverseLookup(static_cast( - StringToInt(field->value.constant.c_str())))) + !type.enum_def->ReverseLookup( + static_cast(StringToInt(field->value.constant.c_str())))) Warning("enum " + type.enum_def->name + - " does not have a declaration for this field\'s default of " + - field->value.constant); + " does not have a declaration for this field\'s default of " + + field->value.constant); field->doc_comment = dc; ECHECK(ParseMetaData(&field->attributes)); @@ -634,19 +675,19 @@ CheckedError Parser::ParseField(StructDef &struct_def) { case BASE_TYPE_UINT: { if (FindHashFunction32(hash_name->constant.c_str()) == nullptr) return Error("Unknown hashing algorithm for 32 bit types: " + - hash_name->constant); + hash_name->constant); break; } case BASE_TYPE_LONG: case BASE_TYPE_ULONG: { if (FindHashFunction64(hash_name->constant.c_str()) == nullptr) return Error("Unknown hashing algorithm for 64 bit types: " + - hash_name->constant); + hash_name->constant); break; } default: return Error( - "only int, uint, long and ulong data types support hashing."); + "only int, uint, long and ulong data types support hashing."); } } auto cpp_type = field->attributes.Lookup("cpp_type"); @@ -657,13 +698,12 @@ CheckedError Parser::ParseField(StructDef &struct_def) { if (field->deprecated && struct_def.fixed) return Error("can't deprecate fields in a struct"); field->required = field->attributes.Lookup("required") != nullptr; - if (field->required && (struct_def.fixed || - IsScalar(field->value.type.base_type))) + if (field->required && + (struct_def.fixed || IsScalar(field->value.type.base_type))) return Error("only non-scalar fields in tables may be 'required'"); field->key = field->attributes.Lookup("key") != nullptr; if (field->key) { - if (struct_def.has_key) - return Error("only one field may be set as 'key'"); + if (struct_def.has_key) return Error("only one field may be set as 'key'"); struct_def.has_key = true; if (!IsScalar(field->value.type.base_type)) { field->required = true; @@ -672,9 +712,12 @@ CheckedError Parser::ParseField(StructDef &struct_def) { } } - auto field_native_custom_alloc = field->attributes.Lookup("native_custom_alloc"); + auto field_native_custom_alloc = + field->attributes.Lookup("native_custom_alloc"); if (field_native_custom_alloc) - return Error("native_custom_alloc can only be used with a table or struct definition"); + return Error( + "native_custom_alloc can only be used with a table or struct " + "definition"); field->native_inline = field->attributes.Lookup("native_inline") != nullptr; if (field->native_inline && !IsStruct(field->value.type)) @@ -684,11 +727,11 @@ CheckedError Parser::ParseField(StructDef &struct_def) { if (nested) { if (nested->type.base_type != BASE_TYPE_STRING) return Error( - "nested_flatbuffer attribute must be a string (the root type)"); + "nested_flatbuffer attribute must be a string (the root type)"); if (field->value.type.base_type != BASE_TYPE_VECTOR || field->value.type.element != BASE_TYPE_UCHAR) return Error( - "nested_flatbuffer attribute may only apply to a vector of ubyte"); + "nested_flatbuffer attribute may only apply to a vector of ubyte"); // This will cause an error if the root type of the nested flatbuffer // wasn't defined elsewhere. LookupCreateStruct(nested->constant); @@ -704,8 +747,7 @@ CheckedError Parser::ParseField(StructDef &struct_def) { uses_flexbuffers_ = true; if (field->value.type.base_type != BASE_TYPE_VECTOR || field->value.type.element != BASE_TYPE_UCHAR) - return Error( - "flexbuffer attribute may only apply to a vector of ubyte"); + return Error("flexbuffer attribute may only apply to a vector of ubyte"); } if (typefield) { @@ -831,9 +873,7 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field, } break; } - default: - ECHECK(ParseSingleValue(val)); - break; + default: ECHECK(ParseSingleValue(val)); break; } return NoError(); } @@ -891,71 +931,72 @@ CheckedError Parser::ParseTableDelimiters(size_t &fieldn, CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, uoffset_t *ovalue) { size_t fieldn_outer = 0; - auto err = ParseTableDelimiters(fieldn_outer, &struct_def, - [](const std::string &name, size_t &fieldn, - const StructDef *struct_def_inner, - void *state) -> CheckedError { - Parser *parser = static_cast(state); - if (name == "$schema") { - ECHECK(parser->Expect(kTokenStringConstant)); - return NoError(); - } - auto field = struct_def_inner->fields.Lookup(name); - if (!field) { - if (!parser->opts.skip_unexpected_fields_in_json) { - return parser->Error("unknown field: " + name); - } else { - ECHECK(parser->SkipAnyJsonValue()); - } - } else { - if (parser->IsIdent("null")) { - ECHECK(parser->Next()); // Ignore this field. - } else { - Value val = field->value; - if (field->flexbuffer) { - flexbuffers::Builder builder(1024, - flexbuffers::BUILDER_FLAG_SHARE_ALL); - ECHECK(parser->ParseFlexBufferValue(&builder)); - builder.Finish(); - auto off = parser->builder_.CreateVector(builder.GetBuffer()); - val.constant = NumToString(off.o); - } else if (field->nested_flatbuffer) { - ECHECK(parser->ParseNestedFlatbuffer(val, field, fieldn, struct_def_inner)); + auto err = ParseTableDelimiters( + fieldn_outer, &struct_def, + [](const std::string &name, size_t &fieldn, + const StructDef *struct_def_inner, void *state) -> CheckedError { + Parser *parser = static_cast(state); + if (name == "$schema") { + ECHECK(parser->Expect(kTokenStringConstant)); + return NoError(); + } + auto field = struct_def_inner->fields.Lookup(name); + if (!field) { + if (!parser->opts.skip_unexpected_fields_in_json) { + return parser->Error("unknown field: " + name); + } else { + ECHECK(parser->SkipAnyJsonValue()); + } } else { - ECHECK(parser->ParseAnyValue(val, field, fieldn, struct_def_inner)); + if (parser->IsIdent("null")) { + ECHECK(parser->Next()); // Ignore this field. + } else { + Value val = field->value; + if (field->flexbuffer) { + flexbuffers::Builder builder(1024, + flexbuffers::BUILDER_FLAG_SHARE_ALL); + ECHECK(parser->ParseFlexBufferValue(&builder)); + builder.Finish(); + auto off = parser->builder_.CreateVector(builder.GetBuffer()); + val.constant = NumToString(off.o); + } else if (field->nested_flatbuffer) { + ECHECK(parser->ParseNestedFlatbuffer(val, field, fieldn, + struct_def_inner)); + } else { + ECHECK( + parser->ParseAnyValue(val, field, fieldn, struct_def_inner)); + } + // Hardcoded insertion-sort with error-check. + // If fields are specified in order, then this loop exits + // immediately. + auto elem = parser->field_stack_.rbegin(); + for (; elem != parser->field_stack_.rbegin() + fieldn; ++elem) { + auto existing_field = elem->second; + if (existing_field == field) + return parser->Error("field set more than once: " + + field->name); + if (existing_field->value.offset < field->value.offset) break; + } + // Note: elem points to before the insertion point, thus .base() + // points to the correct spot. + parser->field_stack_.insert(elem.base(), + std::make_pair(val, field)); + fieldn++; + } } - // Hardcoded insertion-sort with error-check. - // If fields are specified in order, then this loop exits immediately. - auto elem = parser->field_stack_.rbegin(); - for (; elem != parser->field_stack_.rbegin() + fieldn; ++elem) { - auto existing_field = elem->second; - if (existing_field == field) - return parser->Error("field set more than once: " + field->name); - if (existing_field->value.offset < field->value.offset) break; - } - // Note: elem points to before the insertion point, thus .base() points - // to the correct spot. - parser->field_stack_.insert(elem.base(), - std::make_pair(val, field)); - fieldn++; - } - } - return NoError(); - }, this); + return NoError(); + }, + this); ECHECK(err); // Check if all required fields are parsed. for (auto field_it = struct_def.fields.vec.begin(); - field_it != struct_def.fields.vec.end(); - ++field_it) { + field_it != struct_def.fields.vec.end(); ++field_it) { auto required_field = *field_it; - if (!required_field->required) { - continue; - } + if (!required_field->required) { continue; } bool found = false; for (auto pf_it = field_stack_.end() - fieldn_outer; - pf_it != field_stack_.end(); - ++pf_it) { + pf_it != field_stack_.end(); ++pf_it) { auto parsed_field = pf_it->second; if (parsed_field == required_field) { found = true; @@ -963,29 +1004,28 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, } } if (!found) { - return Error("required field is missing: " + required_field->name + " in " + struct_def.name); + return Error("required field is missing: " + required_field->name + + " in " + struct_def.name); } } if (struct_def.fixed && fieldn_outer != struct_def.fields.vec.size()) return Error("struct: wrong number of initializers: " + struct_def.name); - auto start = struct_def.fixed - ? builder_.StartStruct(struct_def.minalign) - : builder_.StartTable(); + auto start = struct_def.fixed ? builder_.StartStruct(struct_def.minalign) + : builder_.StartTable(); - for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; - size; + for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; size; size /= 2) { // Go through elements in reverse, since we're building the data backwards. - for (auto it = field_stack_.rbegin(); it != field_stack_.rbegin() + - fieldn_outer; - ++it) { + for (auto it = field_stack_.rbegin(); + it != field_stack_.rbegin() + fieldn_outer; ++it) { auto &field_value = it->first; auto field = it->second; if (!struct_def.sortbysize || size == SizeOf(field_value.type.base_type)) { switch (field_value.type.base_type) { + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ @@ -1017,6 +1057,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, break; FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD); #undef FLATBUFFERS_TD + // clang-format on } } } @@ -1030,8 +1071,8 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *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); + reinterpret_cast(builder_.GetCurrentBufferPointer()), + struct_def.bytesize); builder_.PopBytes(struct_def.bytesize); assert(!ovalue); } else { @@ -1060,17 +1101,19 @@ CheckedError Parser::ParseVectorDelimiters(size_t &count, CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue) { size_t count = 0; std::pair parser_and_type_state(this, type); - auto err = ParseVectorDelimiters(count, - [](size_t &, void *state) -> CheckedError { - auto *parser_and_type = - static_cast *>(state); - auto *parser = parser_and_type->first; - Value val; - val.type = parser_and_type->second; - ECHECK(parser->ParseAnyValue(val, nullptr, 0, nullptr)); - parser->field_stack_.push_back(std::make_pair(val, nullptr)); - return NoError(); - }, &parser_and_type_state); + auto err = ParseVectorDelimiters( + count, + [](size_t &, void *state) -> CheckedError { + auto *parser_and_type = + static_cast *>(state); + auto *parser = parser_and_type->first; + Value val; + val.type = parser_and_type->second; + ECHECK(parser->ParseAnyValue(val, nullptr, 0, nullptr)); + parser->field_stack_.push_back(std::make_pair(val, nullptr)); + return NoError(); + }, + &parser_and_type_state); ECHECK(err); builder_.StartVector(count * InlineSize(type) / InlineAlignment(type), @@ -1079,6 +1122,7 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue) { // start at the back, since we're building the data backwards. auto &val = field_stack_.back().first; switch (val.type.base_type) { + // clang-format off #define FLATBUFFERS_TD(ENUM, IDLTYPE, \ CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ @@ -1091,6 +1135,7 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue) { break; FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD + // clang-format on } field_stack_.pop_back(); } @@ -1101,14 +1146,14 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue) { } CheckedError Parser::ParseNestedFlatbuffer(Value &val, FieldDef *field, - size_t fieldn, - const StructDef *parent_struct_def) { - if (token_ == '[') {// backwards compat for 'legacy' ubyte buffers + size_t fieldn, + const StructDef *parent_struct_def) { + if (token_ == '[') { // backwards compat for 'legacy' ubyte buffers ECHECK(ParseAnyValue(val, field, fieldn, parent_struct_def)); } else { auto cursor_at_value_begin = cursor_; ECHECK(SkipAnyJsonValue()); - std::string substring(cursor_at_value_begin -1 , cursor_ -1); + std::string substring(cursor_at_value_begin - 1, cursor_ - 1); // Create and initialize new parser Parser nested_parser; @@ -1122,10 +1167,12 @@ CheckedError Parser::ParseNestedFlatbuffer(Value &val, FieldDef *field, if (!nested_parser.Parse(substring.c_str(), nullptr, nullptr)) { ECHECK(Error(nested_parser.error_)); } - auto off = builder_.CreateVector(nested_parser.builder_.GetBufferPointer(), nested_parser.builder_.GetSize()); + auto off = builder_.CreateVector(nested_parser.builder_.GetBufferPointer(), + nested_parser.builder_.GetSize()); val.constant = NumToString(off.o); - // Clean nested_parser before destruction to avoid deleting the elements in the SymbolTables + // Clean nested_parser before destruction to avoid deleting the elements in + // the SymbolTables nested_parser.enums_.dict.clear(); nested_parser.enums_.vec.clear(); } @@ -1147,7 +1194,10 @@ CheckedError Parser::ParseMetaData(SymbolTable *attributes) { NEXT(); ECHECK(ParseSingleValue(*e)); } - if (Is(')')) { NEXT(); break; } + if (Is(')')) { + NEXT(); + break; + } EXPECT(','); } } @@ -1166,8 +1216,7 @@ CheckedError Parser::TryTypedValue(int dtoken, bool check, Value &e, } else { return Error(std::string("type mismatch: expecting: ") + kTypeNames[e.type.base_type] + - ", found: " + - kTypeNames[req]); + ", found: " + kTypeNames[req]); } } NEXT(); @@ -1193,7 +1242,7 @@ CheckedError Parser::ParseEnumFromString(Type &type, int64_t *result) { auto enum_val = type.enum_def->vals.Lookup(word); if (!enum_val) return Error("unknown enum value: " + word + - ", for enum: " + type.enum_def->name); + ", for enum: " + type.enum_def->name); *result |= enum_val->value; } else { // No enum type, probably integral field. if (!IsInteger(type.base_type)) @@ -1210,12 +1259,11 @@ CheckedError Parser::ParseEnumFromString(Type &type, int64_t *result) { if (!enum_val) return Error("unknown enum value: " + enum_val_str); *result |= enum_val->value; } - } while(*next); + } while (*next); return NoError(); } - -CheckedError Parser::ParseHash(Value &e, FieldDef* field) { +CheckedError Parser::ParseHash(Value &e, FieldDef *field) { assert(field); Value *hash_name = field->attributes.Lookup("hash"); switch (e.type.base_type) { @@ -1243,16 +1291,14 @@ CheckedError Parser::ParseHash(Value &e, FieldDef* field) { e.constant = NumToString(hashed_value); break; } - default: - assert(0); + default: assert(0); } NEXT(); return NoError(); } CheckedError Parser::TokenError() { - return Error("cannot parse value starting with: " + - TokenToStringId(token_)); + return Error("cannot parse value starting with: " + TokenToStringId(token_)); } CheckedError Parser::ParseSingleValue(Value &e) { @@ -1263,6 +1309,7 @@ CheckedError Parser::ParseSingleValue(Value &e) { EXPECT('('); ECHECK(ParseSingleValue(e)); EXPECT(')'); + // clang-format off #define FLATBUFFERS_FN_DOUBLE(name, op) \ if (functionname == name) { \ auto x = strtod(e.constant.c_str(), nullptr); \ @@ -1278,11 +1325,12 @@ CheckedError Parser::ParseSingleValue(Value &e) { FLATBUFFERS_FN_DOUBLE("atan", atan(x)); // TODO(wvo): add more useful conversion functions here. #undef FLATBUFFERS_FN_DOUBLE - // Then check if this could be a string/identifier enum value: + // clang-format on + // Then check if this could be a string/identifier enum value: } else if (e.type.base_type != BASE_TYPE_STRING && - e.type.base_type != BASE_TYPE_BOOL && - e.type.base_type != BASE_TYPE_NONE && - (token_ == kTokenIdentifier || token_ == kTokenStringConstant)) { + e.type.base_type != BASE_TYPE_BOOL && + e.type.base_type != BASE_TYPE_NONE && + (token_ == kTokenIdentifier || token_ == kTokenStringConstant)) { if (IsIdentifierStart(attribute_[0])) { // Enum value. int64_t val; ECHECK(ParseEnumFromString(e.type, &val)); @@ -1292,13 +1340,11 @@ CheckedError Parser::ParseSingleValue(Value &e) { if (IsInteger(e.type.base_type)) { char *end; e.constant = NumToString(StringToInt(attribute_.c_str(), &end)); - if (*end) - return Error("invalid integer: " + attribute_); + if (*end) return Error("invalid integer: " + attribute_); } else if (IsFloat(e.type.base_type)) { char *end; e.constant = NumToString(strtod(attribute_.c_str(), &end)); - if (*end) - return Error("invalid float: " + attribute_); + if (*end) return Error("invalid float: " + attribute_); } else { assert(0); // Shouldn't happen, we covered all types. e.constant = "0"; @@ -1307,29 +1353,18 @@ CheckedError Parser::ParseSingleValue(Value &e) { } } else { bool match = false; - ECHECK(TryTypedValue(kTokenIntegerConstant, - IsScalar(e.type.base_type), - e, - BASE_TYPE_INT, - &match)); - ECHECK(TryTypedValue(kTokenFloatConstant, - IsFloat(e.type.base_type), - e, - BASE_TYPE_FLOAT, - &match)); + ECHECK(TryTypedValue(kTokenIntegerConstant, IsScalar(e.type.base_type), e, + BASE_TYPE_INT, &match)); + ECHECK(TryTypedValue(kTokenFloatConstant, IsFloat(e.type.base_type), e, + BASE_TYPE_FLOAT, &match)); ECHECK(TryTypedValue(kTokenStringConstant, - e.type.base_type == BASE_TYPE_STRING, - e, - BASE_TYPE_STRING, - &match)); + e.type.base_type == BASE_TYPE_STRING, e, + BASE_TYPE_STRING, &match)); auto istrue = IsIdent("true"); if (istrue || IsIdent("false")) { attribute_ = NumToString(istrue); - ECHECK(TryTypedValue(kTokenIdentifier, - IsBool(e.type.base_type), - e, - BASE_TYPE_BOOL, - &match)); + ECHECK(TryTypedValue(kTokenIdentifier, IsBool(e.type.base_type), e, + BASE_TYPE_BOOL, &match)); } if (!match) return TokenError(); } @@ -1382,8 +1417,8 @@ StructDef *Parser::LookupCreateStruct(const std::string &name, structs_.Add(name, struct_def); struct_def->name = name; struct_def->defined_namespace = current_namespace_; - struct_def->original_location.reset(new std::string(file_being_parsed_ + - ":" + NumToString(line_))); + struct_def->original_location.reset( + new std::string(file_being_parsed_ + ":" + NumToString(line_))); } } return struct_def; @@ -1413,8 +1448,9 @@ CheckedError Parser::ParseEnum(bool is_union, EnumDef **dest) { // Give specialized error message, since this type spec used to // be optional in the first FlatBuffers release. if (!Is(':')) { - return Error("must specify the underlying integer type for this" - " enum (e.g. \': short\', which was the default)."); + return Error( + "must specify the underlying integer type for this" + " enum (e.g. \': short\', which was the default)."); } else { NEXT(); } @@ -1447,9 +1483,8 @@ CheckedError Parser::ParseEnum(bool is_union, EnumDef **dest) { } } auto prevsize = enum_def.vals.vec.size(); - auto value = enum_def.vals.vec.size() - ? enum_def.vals.vec.back()->value + 1 - : 0; + auto value = + enum_def.vals.vec.size() ? enum_def.vals.vec.back()->value + 1 : 0; auto &ev = *new EnumVal(value_name, value); if (enum_def.vals.Add(value_name, &ev)) return Error("enum value already exists: " + value_name); @@ -1494,7 +1529,7 @@ CheckedError Parser::ParseEnum(bool is_union, EnumDef **dest) { for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end(); ++it) { if (static_cast((*it)->value) >= - SizeOf(enum_def.underlying_type.base_type) * 8) + SizeOf(enum_def.underlying_type.base_type) * 8) return Error("bit flag out of range of underlying integral type"); (*it)->value = 1LL << (*it)->value; } @@ -1513,14 +1548,14 @@ CheckedError Parser::StartStruct(const std::string &name, StructDef **dest) { struct_def.file = file_being_parsed_; // Move this struct to the back of the vector just in case it was predeclared, // to preserve declaration order. - *std::remove(structs_.vec.begin(), structs_.vec.end(), &struct_def) = &struct_def; + *std::remove(structs_.vec.begin(), structs_.vec.end(), &struct_def) = + &struct_def; *dest = &struct_def; return NoError(); } -CheckedError Parser::CheckClash(std::vector &fields, - StructDef *struct_def, - const char *suffix, +CheckedError Parser::CheckClash(std::vector &fields, + StructDef *struct_def, const char *suffix, BaseType basetype) { auto len = strlen(suffix); for (auto it = fields.begin(); it != fields.end(); ++it) { @@ -1528,8 +1563,8 @@ CheckedError Parser::CheckClash(std::vector &fields, if (fname.length() > len && fname.compare(fname.length() - len, len, suffix) == 0 && (*it)->value.type.base_type != BASE_TYPE_UTYPE) { - auto field = struct_def->fields.Lookup( - fname.substr(0, fname.length() - len)); + auto field = + struct_def->fields.Lookup(fname.substr(0, fname.length() - len)); if (field && field->value.type.base_type == basetype) return Error("Field " + fname + " would clash with generated functions for field " + @@ -1540,8 +1575,9 @@ CheckedError Parser::CheckClash(std::vector &fields, } bool Parser::SupportsVectorOfUnions() const { - return opts.lang_to_generate != 0 && (opts.lang_to_generate & - ~(IDLOptions::kCpp | IDLOptions::kJs | IDLOptions::kTs | IDLOptions::kPhp)) == 0; + return opts.lang_to_generate != 0 && + (opts.lang_to_generate & ~(IDLOptions::kCpp | IDLOptions::kJs | + IDLOptions::kTs | IDLOptions::kPhp)) == 0; } Namespace *Parser::UniqueNamespace(Namespace *ns) { @@ -1574,19 +1610,19 @@ CheckedError Parser::ParseDecl() { struct_def->fixed = fixed; ECHECK(ParseMetaData(&struct_def->attributes)); struct_def->sortbysize = - struct_def->attributes.Lookup("original_order") == nullptr && !fixed; + struct_def->attributes.Lookup("original_order") == nullptr && !fixed; EXPECT('{'); while (token_ != '}') ECHECK(ParseField(*struct_def)); auto force_align = struct_def->attributes.Lookup("force_align"); if (fixed && force_align) { auto align = static_cast(atoi(force_align->constant.c_str())); if (force_align->type.base_type != BASE_TYPE_INT || - align < struct_def->minalign || - align > FLATBUFFERS_MAX_ALIGNMENT || + align < struct_def->minalign || align > FLATBUFFERS_MAX_ALIGNMENT || align & (align - 1)) - return Error("force_align must be a power of two integer ranging from the" - "struct\'s natural alignment to " + - NumToString(FLATBUFFERS_MAX_ALIGNMENT)); + return Error( + "force_align must be a power of two integer ranging from the" + "struct\'s natural alignment to " + + NumToString(FLATBUFFERS_MAX_ALIGNMENT)); struct_def->minalign = align; } struct_def->PadLastField(struct_def->minalign); @@ -1602,7 +1638,7 @@ CheckedError Parser::ParseDecl() { // Then all fields must have them. if (num_id_fields != fields.size()) return Error( - "either all fields or no fields must have an 'id' attribute"); + "either all fields or no fields must have an 'id' attribute"); // Simply sort by id, then the fields are the same as if no ids had // been specified. std::sort(fields.begin(), fields.end(), compareFieldDefs); @@ -1610,14 +1646,14 @@ CheckedError Parser::ParseDecl() { for (int i = 0; i < static_cast(fields.size()); i++) { if (i != atoi(fields[i]->attributes.Lookup("id")->constant.c_str())) return Error("field id\'s must be consecutive from 0, id " + - NumToString(i) + " missing or set twice"); + NumToString(i) + " missing or set twice"); fields[i]->value.offset = FieldIndexToOffset(static_cast(i)); } } } - ECHECK(CheckClash(fields, struct_def, UnionTypeFieldSuffix(), - BASE_TYPE_UNION)); + ECHECK( + CheckClash(fields, struct_def, UnionTypeFieldSuffix(), BASE_TYPE_UNION)); ECHECK(CheckClash(fields, struct_def, "Type", BASE_TYPE_UNION)); ECHECK(CheckClash(fields, struct_def, "_length", BASE_TYPE_VECTOR)); ECHECK(CheckClash(fields, struct_def, "Length", BASE_TYPE_VECTOR)); @@ -1656,7 +1692,7 @@ CheckedError Parser::ParseService() { ECHECK(ParseTypeIdent(resptype)); if (reqtype.base_type != BASE_TYPE_STRUCT || reqtype.struct_def->fixed || resptype.base_type != BASE_TYPE_STRUCT || resptype.struct_def->fixed) - return Error("rpc request and response types must be tables"); + return Error("rpc request and response types must be tables"); auto &rpc = *new RPCCall(); rpc.name = rpc_name; rpc.request = reqtype.struct_def; @@ -1674,8 +1710,8 @@ CheckedError Parser::ParseService() { bool Parser::SetRootType(const char *name) { root_struct_def_ = LookupStruct(name); if (!root_struct_def_) - root_struct_def_ = LookupStruct( - current_namespace_->GetFullyQualifiedName(name)); + root_struct_def_ = + LookupStruct(current_namespace_->GetFullyQualifiedName(name)); return root_struct_def_ != nullptr; } @@ -1683,18 +1719,13 @@ void Parser::MarkGenerated() { // This function marks all existing definitions as having already // been generated, which signals no code for included files should be // generated. - for (auto it = enums_.vec.begin(); - it != enums_.vec.end(); ++it) { + for (auto it = enums_.vec.begin(); it != enums_.vec.end(); ++it) { (*it)->generated = true; } - for (auto it = structs_.vec.begin(); - it != structs_.vec.end(); ++it) { - if (!(*it)->predecl) { - (*it)->generated = true; - } + for (auto it = structs_.vec.begin(); it != structs_.vec.end(); ++it) { + if (!(*it)->predecl) { (*it)->generated = true; } } - for (auto it = services_.vec.begin(); - it != services_.vec.end(); ++it) { + for (auto it = services_.vec.begin(); it != services_.vec.end(); ++it) { (*it)->generated = true; } } @@ -1716,7 +1747,7 @@ CheckedError Parser::ParseNamespace() { return NoError(); } -static bool compareEnumVals(const EnumVal *a, const EnumVal* b) { +static bool compareEnumVals(const EnumVal *a, const EnumVal *b) { return a->value < b->value; } @@ -1758,9 +1789,7 @@ CheckedError Parser::ParseProtoDecl() { } struct_def->doc_comment = struct_comment; ECHECK(ParseProtoFields(struct_def, isextend, false)); - if (!isextend) { - current_namespace_ = parent_namespace; - } + if (!isextend) { current_namespace_ = parent_namespace; } if (Is(';')) NEXT(); } else if (IsIdent("enum")) { // These are almost the same, just with different terminator: @@ -1772,9 +1801,11 @@ CheckedError Parser::ParseProtoDecl() { std::sort(v.begin(), v.end(), compareEnumVals); // Temp: remove any duplicates, as .fbs files can't handle them. - for (auto it = v.begin(); it != v.end(); ) { - if (it != v.begin() && it[0]->value == it[-1]->value) it = v.erase(it); - else ++it; + for (auto it = v.begin(); it != v.end();) { + if (it != v.begin() && it[0]->value == it[-1]->value) + it = v.erase(it); + else + ++it; } } else if (IsIdent("syntax")) { // Skip these. NEXT(); @@ -1790,7 +1821,7 @@ CheckedError Parser::ParseProtoDecl() { ECHECK(ParseProtoCurliesOrIdent()); } else { return Error("don\'t know how to parse .proto declaration starting with " + - TokenToStringId(token_)); + TokenToStringId(token_)); } return NoError(); } @@ -1920,7 +1951,10 @@ CheckedError Parser::ParseProtoKey() { // Skip "(a.b)" style custom attributes. while (token_ == '.' || token_ == kTokenIdentifier) NEXT(); EXPECT(')'); - while (Is('.')) { NEXT(); EXPECT(kTokenIdentifier); } + while (Is('.')) { + NEXT(); + EXPECT(kTokenIdentifier); + } } else { EXPECT(kTokenIdentifier); } @@ -1930,9 +1964,11 @@ CheckedError Parser::ParseProtoKey() { CheckedError Parser::ParseProtoCurliesOrIdent() { if (Is('{')) { NEXT(); - for (int nesting = 1; nesting; ) { - if (token_ == '{') nesting++; - else if (token_ == '}') nesting--; + for (int nesting = 1; nesting;) { + if (token_ == '{') + nesting++; + else if (token_ == '}') + nesting--; NEXT(); } } else { @@ -1951,7 +1987,10 @@ CheckedError Parser::ParseProtoOption() { // Parse a protobuf type, and map it to the corresponding FlatBuffer one. CheckedError Parser::ParseTypeFromProtoType(Type *type) { - struct type_lookup { const char *proto_type; BaseType fb_type, element; }; + struct type_lookup { + const char *proto_type; + BaseType fb_type, element; + }; static type_lookup lookup[] = { { "float", BASE_TYPE_FLOAT, BASE_TYPE_NONE }, { "double", BASE_TYPE_DOUBLE, BASE_TYPE_NONE }, @@ -1987,10 +2026,10 @@ CheckedError Parser::SkipAnyJsonValue() { switch (token_) { case '{': { size_t fieldn_outer = 0; - return ParseTableDelimiters(fieldn_outer, nullptr, - [](const std::string &, - size_t &fieldn, const StructDef *, - void *state) -> CheckedError { + return ParseTableDelimiters( + fieldn_outer, nullptr, + [](const std::string &, size_t &fieldn, const StructDef *, + void *state) -> CheckedError { auto *parser = static_cast(state); ECHECK(parser->SkipAnyJsonValue()); fieldn++; @@ -2000,20 +2039,21 @@ CheckedError Parser::SkipAnyJsonValue() { } case '[': { size_t count = 0; - return ParseVectorDelimiters(count, [](size_t &, - void *state) -> CheckedError { - return static_cast(state)->SkipAnyJsonValue(); - }, - this); + return ParseVectorDelimiters( + count, + [](size_t &, void *state) -> CheckedError { + return static_cast(state)->SkipAnyJsonValue(); + }, + this); } case kTokenStringConstant: case kTokenIntegerConstant: - case kTokenFloatConstant: - NEXT(); - break; + case kTokenFloatConstant: NEXT(); break; default: - if (IsIdent("true") || IsIdent("false") || IsIdent("null")) { NEXT(); } - else return TokenError(); + if (IsIdent("true") || IsIdent("false") || IsIdent("null")) { + NEXT(); + } else + return TokenError(); } return NoError(); } @@ -2025,10 +2065,10 @@ CheckedError Parser::ParseFlexBufferValue(flexbuffers::Builder *builder) { this, builder); auto start = builder->StartMap(); size_t fieldn_outer = 0; - auto err = ParseTableDelimiters(fieldn_outer, nullptr, - [](const std::string &name, - size_t &fieldn, const StructDef *, - void *state) -> CheckedError { + auto err = ParseTableDelimiters( + fieldn_outer, nullptr, + [](const std::string &name, size_t &fieldn, const StructDef *, + void *state) -> CheckedError { auto *parser_and_builder = static_cast *>( state); @@ -2044,13 +2084,14 @@ CheckedError Parser::ParseFlexBufferValue(flexbuffers::Builder *builder) { builder->EndMap(start); break; } - case '[':{ + case '[': { auto start = builder->StartVector(); size_t count = 0; std::pair parser_and_builder_state( this, builder); - ECHECK(ParseVectorDelimiters(count, [](size_t &, - void *state) -> CheckedError { + ECHECK(ParseVectorDelimiters( + count, + [](size_t &, void *state) -> CheckedError { auto *parser_and_builder = static_cast *>( state); @@ -2074,10 +2115,17 @@ CheckedError Parser::ParseFlexBufferValue(flexbuffers::Builder *builder) { EXPECT(kTokenFloatConstant); break; default: - if (IsIdent("true")) { builder->Bool(true); NEXT(); } - else if (IsIdent("false")) { builder->Bool(false); NEXT(); } - else if (IsIdent("null")) { builder->Null(); NEXT(); } - else return TokenError(); + if (IsIdent("true")) { + builder->Bool(true); + NEXT(); + } else if (IsIdent("false")) { + builder->Bool(false); + NEXT(); + } else if (IsIdent("null")) { + builder->Null(); + NEXT(); + } else + return TokenError(); } return NoError(); } @@ -2095,55 +2143,53 @@ bool Parser::Parse(const char *source, const char **include_paths, return !ParseRoot(source, include_paths, source_filename).Check(); } -CheckedError Parser::StartParseFile(const char *source, const char *source_filename) { +CheckedError Parser::StartParseFile(const char *source, + const char *source_filename) { file_being_parsed_ = source_filename ? source_filename : ""; source_ = cursor_ = source; line_ = 1; error_.clear(); ECHECK(SkipByteOrderMark()); NEXT(); - if (Is(kTokenEof)) - return Error("input file is empty"); + if (Is(kTokenEof)) return Error("input file is empty"); return NoError(); } CheckedError Parser::ParseRoot(const char *source, const char **include_paths, - const char *source_filename) { + const char *source_filename) { ECHECK(DoParse(source, include_paths, source_filename, nullptr)); // Check that all types were defined. - for (auto it = structs_.vec.begin(); it != structs_.vec.end(); ) { + for (auto it = structs_.vec.begin(); it != structs_.vec.end();) { auto &struct_def = **it; if (struct_def.predecl) { if (opts.proto_mode) { // Protos allow enums to be used before declaration, so check if that // is the case here. EnumDef *enum_def = nullptr; - for (size_t components = struct_def.defined_namespace-> - components.size() + 1; + for (size_t components = + struct_def.defined_namespace->components.size() + 1; components && !enum_def; components--) { - auto qualified_name = struct_def.defined_namespace-> - GetFullyQualifiedName(struct_def.name, - components - 1); + auto qualified_name = + struct_def.defined_namespace->GetFullyQualifiedName( + struct_def.name, components - 1); enum_def = LookupEnum(qualified_name); } if (enum_def) { // This is pretty slow, but a simple solution for now. auto initial_count = struct_def.refcount; for (auto struct_it = structs_.vec.begin(); - struct_it != structs_.vec.end(); - ++struct_it) { + struct_it != structs_.vec.end(); ++struct_it) { auto &sd = **struct_it; for (auto field_it = sd.fields.vec.begin(); - field_it != sd.fields.vec.end(); - ++field_it) { + field_it != sd.fields.vec.end(); ++field_it) { auto &field = **field_it; if (field.value.type.struct_def == &struct_def) { field.value.type.struct_def = nullptr; field.value.type.enum_def = enum_def; auto &bt = field.value.type.base_type == BASE_TYPE_VECTOR - ? field.value.type.element - : field.value.type.base_type; + ? field.value.type.element + : field.value.type.base_type; assert(bt == BASE_TYPE_STRUCT); bt = enum_def->underlying_type.base_type; struct_def.refcount--; @@ -2154,8 +2200,8 @@ CheckedError Parser::ParseRoot(const char *source, const char **include_paths, if (struct_def.refcount) return Error("internal: " + NumToString(struct_def.refcount) + "/" + NumToString(initial_count) + - " use(s) of pre-declaration enum not accounted for: " - + enum_def->name); + " use(s) of pre-declaration enum not accounted for: " + + enum_def->name); structs_.dict.erase(structs_.dict.find(struct_def.name)); it = structs_.vec.erase(it); delete &struct_def; @@ -2177,24 +2223,22 @@ CheckedError Parser::ParseRoot(const char *source, const char **include_paths, auto &enum_def = **it; if (enum_def.is_union) { for (auto val_it = enum_def.vals.vec.begin(); - val_it != enum_def.vals.vec.end(); - ++val_it) { + val_it != enum_def.vals.vec.end(); ++val_it) { auto &val = **val_it; - if (!SupportsVectorOfUnions() && - val.union_type.struct_def && val.union_type.struct_def->fixed) + if (!SupportsVectorOfUnions() && val.union_type.struct_def && + val.union_type.struct_def->fixed) return Error( - "only tables can be union elements in the generated language: " - + val.name); + "only tables can be union elements in the generated language: " + + val.name); } } } return NoError(); } -CheckedError Parser::DoParse(const char *source, - const char **include_paths, - const char *source_filename, - const char *include_filename) { +CheckedError Parser::DoParse(const char *source, const char **include_paths, + const char *source_filename, + const char *include_filename) { if (source_filename && included_files_.find(source_filename) == included_files_.end()) { included_files_[source_filename] = include_filename ? include_filename : ""; @@ -2214,10 +2258,9 @@ CheckedError Parser::DoParse(const char *source, // Includes must come before type declarations: for (;;) { // Parse pre-include proto statements if any: - if (opts.proto_mode && - (attribute_ == "option" || attribute_ == "syntax" || - attribute_ == "package")) { - ECHECK(ParseProtoDecl()); + if (opts.proto_mode && (attribute_ == "option" || attribute_ == "syntax" || + attribute_ == "package")) { + ECHECK(ParseProtoDecl()); } else if (IsIdent("native_include")) { NEXT(); vector_emplace_back(&native_included_files_, attribute_); @@ -2231,7 +2274,7 @@ CheckedError Parser::DoParse(const char *source, std::string filepath; for (auto paths = include_paths; paths && *paths; paths++) { filepath = flatbuffers::ConCatPathFileName(*paths, name); - if(FileExists(filepath.c_str())) break; + if (FileExists(filepath.c_str())) break; } if (filepath.empty()) return Error("unable to locate include file: " + name); @@ -2259,7 +2302,8 @@ CheckedError Parser::DoParse(const char *source, // entered into included_files_. // This is recursive, but only go as deep as the number of include // statements. - return DoParse(source, include_paths, source_filename, include_filename); + return DoParse(source, include_paths, source_filename, + include_filename); } EXPECT(';'); } else { @@ -2280,8 +2324,9 @@ CheckedError Parser::DoParse(const char *source, } uoffset_t toff; ECHECK(ParseTable(*root_struct_def_, nullptr, &toff)); - builder_.Finish(Offset
(toff), - file_identifier_.length() ? file_identifier_.c_str() : nullptr); + builder_.Finish(Offset
(toff), file_identifier_.length() + ? file_identifier_.c_str() + : nullptr); } else if (IsIdent("enum")) { ECHECK(ParseEnum(false, nullptr)); } else if (IsIdent("union")) { @@ -2293,27 +2338,25 @@ CheckedError Parser::DoParse(const char *source, ECHECK(ParseNamespacing(&root_type, nullptr)); if (!SetRootType(root_type.c_str())) return Error("unknown root type: " + root_type); - if (root_struct_def_->fixed) - return Error("root type must be a table"); + if (root_struct_def_->fixed) return Error("root type must be a table"); EXPECT(';'); } else if (IsIdent("file_identifier")) { NEXT(); file_identifier_ = attribute_; EXPECT(kTokenStringConstant); - if (file_identifier_.length() != - FlatBufferBuilder::kFileIdentifierLength) + if (file_identifier_.length() != FlatBufferBuilder::kFileIdentifierLength) return Error("file_identifier must be exactly " + - NumToString(FlatBufferBuilder::kFileIdentifierLength) + - " characters"); + NumToString(FlatBufferBuilder::kFileIdentifierLength) + + " characters"); EXPECT(';'); } else if (IsIdent("file_extension")) { NEXT(); file_extension_ = attribute_; EXPECT(kTokenStringConstant); EXPECT(';'); - } else if(IsIdent("include")) { + } else if (IsIdent("include")) { return Error("includes must come before declarations"); - } else if(IsIdent("attribute")) { + } else if (IsIdent("attribute")) { NEXT(); auto name = attribute_; EXPECT(kTokenStringConstant); @@ -2356,9 +2399,9 @@ std::set Parser::GetIncludedFilesRecursive( // Schema serialization functionality: -template bool compareName(const T* a, const T* b) { - return a->defined_namespace->GetFullyQualifiedName(a->name) - < b->defined_namespace->GetFullyQualifiedName(b->name); +template bool compareName(const T *a, const T *b) { + return a->defined_namespace->GetFullyQualifiedName(a->name) < + b->defined_namespace->GetFullyQualifiedName(b->name); } template void AssignIndices(const std::vector &defvec) { @@ -2385,14 +2428,11 @@ void Parser::Serialize() { (*it)->serialized_location = offset.o; } auto schema_offset = reflection::CreateSchema( - builder_, - builder_.CreateVectorOfSortedTables(&object_offsets), - builder_.CreateVectorOfSortedTables(&enum_offsets), - builder_.CreateString(file_identifier_), - builder_.CreateString(file_extension_), - root_struct_def_ - ? root_struct_def_->serialized_location - : 0); + builder_, builder_.CreateVectorOfSortedTables(&object_offsets), + builder_.CreateVectorOfSortedTables(&enum_offsets), + builder_.CreateString(file_identifier_), + builder_.CreateString(file_extension_), + root_struct_def_ ? root_struct_def_->serialized_location : 0); builder_.Finish(schema_offset, reflection::SchemaIdentifier()); } @@ -2400,46 +2440,33 @@ Offset StructDef::Serialize(FlatBufferBuilder *builder, const Parser &parser) const { std::vector> field_offsets; for (auto it = fields.vec.begin(); it != fields.vec.end(); ++it) { - field_offsets.push_back( - (*it)->Serialize(builder, - static_cast(it - fields.vec.begin()), parser)); + field_offsets.push_back((*it)->Serialize( + builder, static_cast(it - fields.vec.begin()), parser)); } auto qualified_name = defined_namespace->GetFullyQualifiedName(name); - return reflection::CreateObject(*builder, - builder->CreateString(qualified_name), - builder->CreateVectorOfSortedTables( - &field_offsets), - fixed, - static_cast(minalign), - static_cast(bytesize), - SerializeAttributes(builder, parser), - parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings( - doc_comment) - : 0); + return reflection::CreateObject( + *builder, builder->CreateString(qualified_name), + builder->CreateVectorOfSortedTables(&field_offsets), fixed, + static_cast(minalign), static_cast(bytesize), + SerializeAttributes(builder, parser), + parser.opts.binary_schema_comments + ? builder->CreateVectorOfStrings(doc_comment) + : 0); } Offset FieldDef::Serialize(FlatBufferBuilder *builder, uint16_t id, const Parser &parser) const { - return reflection::CreateField(*builder, - builder->CreateString(name), - value.type.Serialize(builder), - id, - value.offset, - IsInteger(value.type.base_type) - ? StringToInt(value.constant.c_str()) - : 0, - IsFloat(value.type.base_type) - ? strtod(value.constant.c_str(), nullptr) - : 0.0, - deprecated, - required, - key, - SerializeAttributes(builder, parser), - parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0); + return reflection::CreateField( + *builder, builder->CreateString(name), value.type.Serialize(builder), id, + value.offset, + IsInteger(value.type.base_type) ? StringToInt(value.constant.c_str()) : 0, + IsFloat(value.type.base_type) ? strtod(value.constant.c_str(), nullptr) + : 0.0, + deprecated, required, key, SerializeAttributes(builder, parser), + parser.opts.binary_schema_comments + ? builder->CreateVectorOfStrings(doc_comment) + : 0); // TODO: value.constant is almost always "0", we could save quite a bit of // space by sharing it. Same for common values of value.type. } @@ -2451,50 +2478,42 @@ Offset EnumDef::Serialize(FlatBufferBuilder *builder, enumval_offsets.push_back((*it)->Serialize(builder)); } auto qualified_name = defined_namespace->GetFullyQualifiedName(name); - return reflection::CreateEnum(*builder, - builder->CreateString(qualified_name), - builder->CreateVector(enumval_offsets), - is_union, - underlying_type.Serialize(builder), - SerializeAttributes(builder, parser), - parser.opts.binary_schema_comments - ? builder->CreateVectorOfStrings(doc_comment) - : 0); + return reflection::CreateEnum( + *builder, builder->CreateString(qualified_name), + builder->CreateVector(enumval_offsets), is_union, + underlying_type.Serialize(builder), SerializeAttributes(builder, parser), + parser.opts.binary_schema_comments + ? builder->CreateVectorOfStrings(doc_comment) + : 0); } -Offset EnumVal::Serialize(FlatBufferBuilder *builder) const - { - return reflection::CreateEnumVal(*builder, - builder->CreateString(name), - value, - union_type.struct_def - ? union_type.struct_def-> - serialized_location - : 0, - union_type.Serialize(builder)); +Offset EnumVal::Serialize( + FlatBufferBuilder *builder) const { + return reflection::CreateEnumVal( + *builder, builder->CreateString(name), value, + union_type.struct_def ? union_type.struct_def->serialized_location : 0, + union_type.Serialize(builder)); } Offset Type::Serialize(FlatBufferBuilder *builder) const { - return reflection::CreateType(*builder, - static_cast(base_type), - static_cast(element), - struct_def ? struct_def->index : - (enum_def ? enum_def->index : -1)); + return reflection::CreateType( + *builder, static_cast(base_type), + static_cast(element), + struct_def ? struct_def->index : (enum_def ? enum_def->index : -1)); } -flatbuffers::Offset>> - Definition::SerializeAttributes(FlatBufferBuilder *builder, - const Parser &parser) const { +flatbuffers::Offset< + flatbuffers::Vector>> +Definition::SerializeAttributes(FlatBufferBuilder *builder, + const Parser &parser) const { 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()); if (!it->second) { // Custom attribute. - attrs.push_back( - reflection::CreateKeyValue(*builder, builder->CreateString(kv->first), - builder->CreateString( - kv->second->constant))); + attrs.push_back(reflection::CreateKeyValue( + *builder, builder->CreateString(kv->first), + builder->CreateString(kv->second->constant))); } } if (attrs.size()) { @@ -2512,7 +2531,7 @@ std::string Parser::ConformTo(const Parser &base) { auto struct_def_base = base.LookupStruct(qualified_name); if (!struct_def_base) continue; for (auto fit = struct_def.fields.vec.begin(); - fit != struct_def.fields.vec.end(); ++fit) { + fit != struct_def.fields.vec.end(); ++fit) { auto &field = **fit; auto field_base = struct_def_base->fields.Lookup(field.name); if (field_base) { @@ -2527,7 +2546,7 @@ std::string Parser::ConformTo(const Parser &base) { // But we should check if there is a field that has the same offset // but is incompatible (in the case of field renaming). for (auto fbit = struct_def_base->fields.vec.begin(); - fbit != struct_def_base->fields.vec.end(); ++fbit) { + fbit != struct_def_base->fields.vec.end(); ++fbit) { field_base = *fbit; if (field.value.offset == field_base->value.offset) { if (!EqualByName(field.value.type, field_base->value.type)) @@ -2544,8 +2563,8 @@ std::string Parser::ConformTo(const Parser &base) { enum_def.defined_namespace->GetFullyQualifiedName(enum_def.name); auto enum_def_base = base.enums_.Lookup(qualified_name); if (!enum_def_base) continue; - for (auto evit = enum_def.vals.vec.begin(); - evit != enum_def.vals.vec.end(); ++evit) { + for (auto evit = enum_def.vals.vec.begin(); evit != enum_def.vals.vec.end(); + ++evit) { auto &enum_val = **evit; auto enum_val_base = enum_def_base->vals.Lookup(enum_val.name); if (enum_val_base) { diff --git a/src/reflection.cpp b/src/reflection.cpp index 6736ec7b0..d93859fd2 100644 --- a/src/reflection.cpp +++ b/src/reflection.cpp @@ -22,7 +22,8 @@ namespace flatbuffers { int64_t GetAnyValueI(reflection::BaseType type, const uint8_t *data) { -# define FLATBUFFERS_GET(T) static_cast(ReadScalar(data)) + // clang-format off + #define FLATBUFFERS_GET(T) static_cast(ReadScalar(data)) switch (type) { case reflection::UType: case reflection::Bool: @@ -43,16 +44,17 @@ int64_t GetAnyValueI(reflection::BaseType type, const uint8_t *data) { } default: return 0; // Tables & vectors do not make sense. } -# undef FLATBUFFERS_GET + #undef FLATBUFFERS_GET + // clang-format on } double GetAnyValueF(reflection::BaseType type, const uint8_t *data) { switch (type) { - case reflection::Float: return static_cast(ReadScalar(data)); + case reflection::Float: return static_cast(ReadScalar(data)); case reflection::Double: return ReadScalar(data); case reflection::String: { - auto s = reinterpret_cast(ReadScalar(data) + - data); + auto s = + reinterpret_cast(ReadScalar(data) + data); return s ? strtod(s->c_str(), nullptr) : 0.0; } default: return static_cast(GetAnyValueI(type, data)); @@ -65,8 +67,8 @@ std::string GetAnyValueS(reflection::BaseType type, const uint8_t *data, case reflection::Float: case reflection::Double: return NumToString(GetAnyValueF(type, data)); case reflection::String: { - auto s = reinterpret_cast(ReadScalar(data) + - data); + auto s = + reinterpret_cast(ReadScalar(data) + data); return s ? s->c_str() : ""; } case reflection::Obj: @@ -80,7 +82,7 @@ std::string GetAnyValueS(reflection::BaseType type, const uint8_t *data, s += "(struct)"; // TODO: implement this as well. } else { auto table_field = reinterpret_cast( - ReadScalar(data) + data); + ReadScalar(data) + data); s += " { "; auto fielddefs = objectdef.fields(); for (auto it = fielddefs->begin(); it != fielddefs->end(); ++it) { @@ -104,15 +106,15 @@ std::string GetAnyValueS(reflection::BaseType type, const uint8_t *data, return "(table)"; } case reflection::Vector: - return "[(elements)]"; // TODO: implement this as well. - case reflection::Union: - return "(union)"; // TODO: implement this as well. + return "[(elements)]"; // TODO: implement this as well. + case reflection::Union: return "(union)"; // TODO: implement this as well. default: return NumToString(GetAnyValueI(type, data)); } } void SetAnyValueI(reflection::BaseType type, uint8_t *data, int64_t val) { -# define FLATBUFFERS_SET(T) WriteScalar(data, static_cast(val)) + // clang-format off + #define FLATBUFFERS_SET(T) WriteScalar(data, static_cast(val)) switch (type) { case reflection::UType: case reflection::Bool: @@ -129,12 +131,13 @@ void SetAnyValueI(reflection::BaseType type, uint8_t *data, int64_t val) { // TODO: support strings default: break; } -# undef FLATBUFFERS_SET + #undef FLATBUFFERS_SET + // clang-format on } void SetAnyValueF(reflection::BaseType type, uint8_t *data, double val) { switch (type) { - case reflection::Float: WriteScalar(data, static_cast(val)); break; + case reflection::Float: WriteScalar(data, static_cast(val)); break; case reflection::Double: WriteScalar(data, val); break; // TODO: support strings. default: SetAnyValueI(type, data, static_cast(val)); break; @@ -165,9 +168,11 @@ class ResizeContext { ResizeContext(const reflection::Schema &schema, uoffset_t start, int delta, std::vector *flatbuf, const reflection::Object *root_table = nullptr) - : schema_(schema), startptr_(vector_data(*flatbuf) + start), - delta_(delta), buf_(*flatbuf), - dag_check_(flatbuf->size() / sizeof(uoffset_t), false) { + : schema_(schema), + startptr_(vector_data(*flatbuf) + start), + delta_(delta), + buf_(*flatbuf), + dag_check_(flatbuf->size() / sizeof(uoffset_t), false) { auto mask = static_cast(sizeof(largest_scalar_t) - 1); delta_ = (delta_ + mask) & ~mask; if (!delta_) return; // We can't shrink by less than largest_scalar_t. @@ -176,16 +181,17 @@ class ResizeContext { Straddle(vector_data(buf_), root, vector_data(buf_)); ResizeTable(root_table ? *root_table : *schema.root_table(), root); // We can now add or remove bytes at start. - if (delta_ > 0) buf_.insert(buf_.begin() + start, delta_, 0); - else buf_.erase(buf_.begin() + start, buf_.begin() + start - delta_); + if (delta_ > 0) + buf_.insert(buf_.begin() + start, delta_, 0); + else + buf_.erase(buf_.begin() + start, buf_.begin() + start - delta_); } // Check if the range between first (lower address) and second straddles // the insertion point. If it does, change the offset at offsetloc (of // type T, with direction D). - template void Straddle(const void *first, - const void *second, - void *offsetloc) { + template + void Straddle(const void *first, const void *second, void *offsetloc) { if (first <= startptr_ && second >= startptr_) { WriteScalar(offsetloc, ReadScalar(offsetloc) + delta_ * D); DagCheck(offsetloc) = true; @@ -205,8 +211,7 @@ class ResizeContext { } void ResizeTable(const reflection::Object &objectdef, Table *table) { - if (DagCheck(table)) - return; // Table already visited. + if (DagCheck(table)) return; // Table already visited. auto vtable = table->GetVTable(); // Early out: since all fields inside the table must point forwards in // memory, if the insertion point is before the table we can stop here. @@ -228,13 +233,14 @@ class ResizeContext { auto offset = table->GetOptionalFieldOffset(fielddef.offset()); if (!offset) continue; // Ignore structs. - auto subobjectdef = base_type == reflection::Obj ? - schema_.objects()->Get(fielddef.type()->index()) : nullptr; + auto subobjectdef = + base_type == reflection::Obj + ? schema_.objects()->Get(fielddef.type()->index()) + : nullptr; if (subobjectdef && subobjectdef->is_struct()) continue; // Get this fields' offset, and read it if safe. auto offsetloc = tableloc + offset; - if (DagCheck(offsetloc)) - continue; // This offset already visited. + if (DagCheck(offsetloc)) continue; // This offset already visited. auto ref = offsetloc + ReadScalar(offsetloc); Straddle(offsetloc, ref, offsetloc); // Recurse. @@ -248,16 +254,16 @@ class ResizeContext { if (elem_type != reflection::Obj && elem_type != reflection::String) break; auto vec = reinterpret_cast *>(ref); - auto elemobjectdef = elem_type == reflection::Obj - ? schema_.objects()->Get(fielddef.type()->index()) - : nullptr; + auto elemobjectdef = + elem_type == reflection::Obj + ? schema_.objects()->Get(fielddef.type()->index()) + : nullptr; if (elemobjectdef && elemobjectdef->is_struct()) break; for (uoffset_t i = 0; i < vec->size(); i++) { auto loc = vec->Data() + i * sizeof(uoffset_t); - if (DagCheck(loc)) - continue; // This offset already visited. + if (DagCheck(loc)) continue; // This offset already visited. auto dest = loc + vec->Get(i); - Straddle(loc, dest ,loc); + Straddle(loc, dest, loc); if (elemobjectdef) ResizeTable(*elemobjectdef, reinterpret_cast
(dest)); } @@ -268,10 +274,8 @@ class ResizeContext { reinterpret_cast
(ref)); break; } - case reflection::String: - break; - default: - assert(false); + case reflection::String: break; + default: assert(false); } } // Check if the vtable offset points beyond the insertion point. @@ -292,8 +296,8 @@ class ResizeContext { }; void SetString(const reflection::Schema &schema, const std::string &val, - const String *str, std::vector *flatbuf, - const reflection::Object *root_table) { + const String *str, std::vector *flatbuf, + const reflection::Object *root_table) { auto delta = static_cast(val.size()) - static_cast(str->Length()); auto str_start = static_cast( reinterpret_cast(str) - vector_data(*flatbuf)); @@ -317,8 +321,8 @@ uint8_t *ResizeAnyVector(const reflection::Schema &schema, uoffset_t newsize, const reflection::Object *root_table) { auto delta_elem = static_cast(newsize) - static_cast(num_elems); auto delta_bytes = delta_elem * static_cast(elem_size); - auto vec_start = reinterpret_cast(vec) - - vector_data(*flatbuf); + auto vec_start = + reinterpret_cast(vec) - vector_data(*flatbuf); auto start = static_cast(vec_start + sizeof(uoffset_t) + elem_size * num_elems); if (delta_bytes) { @@ -363,8 +367,7 @@ void CopyInline(FlatBufferBuilder &fbb, const reflection::Field &fielddef, Offset CopyTable(FlatBufferBuilder &fbb, const reflection::Schema &schema, const reflection::Object &objectdef, - const Table &table, - bool use_string_pooling) { + const Table &table, bool use_string_pooling) { // Before we can construct the table, we have to first generate any // subobjects, and collect their offsets. std::vector offsets; @@ -377,39 +380,41 @@ Offset CopyTable(FlatBufferBuilder &fbb, switch (fielddef.type()->base_type()) { case reflection::String: { offset = use_string_pooling - ? fbb.CreateSharedString(GetFieldS(table, fielddef)).o - : fbb.CreateString(GetFieldS(table, fielddef)).o; + ? fbb.CreateSharedString(GetFieldS(table, fielddef)).o + : fbb.CreateString(GetFieldS(table, fielddef)).o; break; } case reflection::Obj: { auto &subobjectdef = *schema.objects()->Get(fielddef.type()->index()); if (!subobjectdef.is_struct()) { - offset = CopyTable(fbb, schema, subobjectdef, - *GetFieldT(table, fielddef)).o; + offset = + CopyTable(fbb, schema, subobjectdef, *GetFieldT(table, fielddef)) + .o; } break; } case reflection::Union: { auto &subobjectdef = GetUnionType(schema, objectdef, fielddef, table); - offset = CopyTable(fbb, schema, subobjectdef, - *GetFieldT(table, fielddef)).o; + offset = + CopyTable(fbb, schema, subobjectdef, *GetFieldT(table, fielddef)).o; break; } case reflection::Vector: { - auto vec = table.GetPointer> *>( - fielddef.offset()); + auto vec = + table.GetPointer> *>(fielddef.offset()); auto element_base_type = fielddef.type()->element(); - auto elemobjectdef = element_base_type == reflection::Obj - ? schema.objects()->Get(fielddef.type()->index()) - : nullptr; + auto elemobjectdef = + element_base_type == reflection::Obj + ? schema.objects()->Get(fielddef.type()->index()) + : nullptr; switch (element_base_type) { case reflection::String: { std::vector> elements(vec->size()); auto vec_s = reinterpret_cast> *>(vec); for (uoffset_t i = 0; i < vec_s->size(); i++) { elements[i] = use_string_pooling - ? fbb.CreateSharedString(vec_s->Get(i)).o - : fbb.CreateString(vec_s->Get(i)).o; + ? fbb.CreateSharedString(vec_s->Get(i)).o + : fbb.CreateString(vec_s->Get(i)).o; } offset = fbb.CreateVector(elements).o; break; @@ -419,7 +424,7 @@ Offset CopyTable(FlatBufferBuilder &fbb, std::vector> elements(vec->size()); for (uoffset_t i = 0; i < vec->size(); i++) { elements[i] = - CopyTable(fbb, schema, *elemobjectdef, *vec->Get(i)); + CopyTable(fbb, schema, *elemobjectdef, *vec->Get(i)); } offset = fbb.CreateVector(elements).o; break; @@ -441,14 +446,11 @@ Offset CopyTable(FlatBufferBuilder &fbb, default: // Scalars. break; } - if (offset) { - offsets.push_back(offset); - } + if (offset) { offsets.push_back(offset); } } // Now we can build the actual table from either offsets or scalar data. - auto start = objectdef.is_struct() - ? fbb.StartStruct(objectdef.minalign()) - : fbb.StartTable(); + auto start = objectdef.is_struct() ? fbb.StartStruct(objectdef.minalign()) + : fbb.StartTable(); size_t offset_idx = 0; for (auto it = fielddefs->begin(); it != fielddefs->end(); ++it) { auto &fielddef = **it; @@ -469,7 +471,7 @@ Offset CopyTable(FlatBufferBuilder &fbb, case reflection::Vector: fbb.AddOffset(fielddef.offset(), Offset(offsets[offset_idx++])); break; - default: { // Scalars. + default: { // Scalars. auto size = GetTypeSize(base_type); CopyInline(fbb, fielddef, table, size, size); break; @@ -487,51 +489,40 @@ Offset CopyTable(FlatBufferBuilder &fbb, bool VerifyStruct(flatbuffers::Verifier &v, const flatbuffers::Table &parent_table, - voffset_t field_offset, - const reflection::Object &obj, + voffset_t field_offset, const reflection::Object &obj, bool required) { auto offset = parent_table.GetOptionalFieldOffset(field_offset); - if (required && !offset) { - return false; - } + if (required && !offset) { return false; } - return !offset || v.Verify(reinterpret_cast(&parent_table) - + offset, obj.bytesize()); + return !offset || + v.Verify(reinterpret_cast(&parent_table) + offset, + obj.bytesize()); } bool VerifyVectorOfStructs(flatbuffers::Verifier &v, const flatbuffers::Table &parent_table, voffset_t field_offset, - const reflection::Object &obj, - bool required) { - auto p = parent_table.GetPointer(field_offset); - const uint8_t* end; - if (required && !p) { - return false; - } + const reflection::Object &obj, bool required) { + auto p = parent_table.GetPointer(field_offset); + const uint8_t *end; + if (required && !p) { return false; } return !p || v.VerifyVector(p, obj.bytesize(), &end); } // forward declare to resolve cyclic deps between VerifyObject and VerifyVector -bool VerifyObject(flatbuffers::Verifier &v, - const reflection::Schema &schema, +bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema, const reflection::Object &obj, - const flatbuffers::Table *table, - bool isRequired); + const flatbuffers::Table *table, bool isRequired); -bool VerifyVector(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); - if (!table.VerifyField(v, vec_field.offset())) - return false; + if (!table.VerifyField(v, vec_field.offset())) return false; switch (vec_field.type()->element()) { - case reflection::None: - assert(false); - break; + case reflection::None: assert(false); break; case reflection::UType: return v.Verify(flatbuffers::GetFieldV(table, vec_field)); case reflection::Bool: @@ -553,17 +544,15 @@ bool VerifyVector(flatbuffers::Verifier &v, return v.Verify(flatbuffers::GetFieldV(table, vec_field)); case reflection::String: { auto vecString = - flatbuffers::GetFieldV>(table, vec_field); + flatbuffers::GetFieldV>( + table, vec_field); if (v.Verify(vecString) && v.VerifyVectorOfStrings(vecString)) { return true; } else { return false; } } - case reflection::Vector: - assert(false); - break; + case reflection::Vector: assert(false); break; case reflection::Obj: { auto obj = schema.objects()->Get(vec_field.type()->index()); if (obj->is_struct()) { @@ -573,10 +562,9 @@ bool VerifyVector(flatbuffers::Verifier &v, } } else { auto vec = - flatbuffers::GetFieldV>(table, vec_field); - if (!v.Verify(vec)) - return false; + flatbuffers::GetFieldV>( + table, vec_field); + if (!v.Verify(vec)) return false; if (vec) { for (uoffset_t j = 0; j < vec->size(); j++) { if (!VerifyObject(v, schema, *obj, vec->Get(j), true)) { @@ -587,22 +575,16 @@ bool VerifyVector(flatbuffers::Verifier &v, } return true; } - case reflection::Union: - assert(false); - break; - default: - assert(false); - break; + case reflection::Union: assert(false); break; + default: assert(false); break; } return false; } -bool VerifyObject(flatbuffers::Verifier &v, - const reflection::Schema &schema, +bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema, const reflection::Object &obj, - const flatbuffers::Table *table, - bool required) { + const flatbuffers::Table *table, bool required) { if (!table) { if (!required) return true; @@ -610,47 +592,37 @@ bool VerifyObject(flatbuffers::Verifier &v, return false; } - if (!table->VerifyTableStart(v)) - return false; + if (!table->VerifyTableStart(v)) return false; 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: assert(false); break; case reflection::UType: - if (!table->VerifyField(v, field_def->offset())) - return false; + if (!table->VerifyField(v, field_def->offset())) return false; break; case reflection::Bool: case reflection::Byte: case reflection::UByte: - if (!table->VerifyField(v, field_def->offset())) - return false; + if (!table->VerifyField(v, field_def->offset())) return false; break; case reflection::Short: case reflection::UShort: - if (!table->VerifyField(v, field_def->offset())) - return false; + if (!table->VerifyField(v, field_def->offset())) return false; break; case reflection::Int: case reflection::UInt: - if (!table->VerifyField(v, field_def->offset())) - return false; + if (!table->VerifyField(v, field_def->offset())) return false; break; case reflection::Long: case reflection::ULong: - if (!table->VerifyField(v, field_def->offset())) - return false; + if (!table->VerifyField(v, field_def->offset())) return false; break; case reflection::Float: - if (!table->VerifyField(v, field_def->offset())) - return false; + if (!table->VerifyField(v, field_def->offset())) return false; break; case reflection::Double: - if (!table->VerifyField(v, field_def->offset())) - return false; + if (!table->VerifyField(v, field_def->offset())) return false; break; case reflection::String: if (!table->VerifyField(v, field_def->offset()) || @@ -659,8 +631,7 @@ bool VerifyObject(flatbuffers::Verifier &v, } break; case reflection::Vector: - if (!VerifyVector(v, schema, *table, *field_def)) - return false; + if (!VerifyVector(v, schema, *table, *field_def)) return false; break; case reflection::Obj: { auto child_obj = schema.objects()->Get(field_def->type()->index()); @@ -694,22 +665,17 @@ bool VerifyObject(flatbuffers::Verifier &v, } break; } - default: - assert(false); - break; + default: assert(false); break; } } - if (!v.EndTable()) - return false; - + if (!v.EndTable()) return false; + return true; } -bool Verify(const reflection::Schema &schema, - const reflection::Object &root, - const uint8_t *buf, - size_t length) { +bool Verify(const reflection::Schema &schema, const reflection::Object &root, + const uint8_t *buf, size_t length) { Verifier v(buf, length); return VerifyObject(v, schema, root, flatbuffers::GetAnyRoot(buf), true); } diff --git a/src/util.cpp b/src/util.cpp index f4aecb5c3..2c8f2d045 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -57,6 +57,7 @@ bool FileExists(const char *name) { } bool DirExists(const char *name) { + // clang-format off #ifdef _WIN32 #define flatbuffers_stat _stat #define FLATBUFFERS_S_IFDIR _S_IFDIR @@ -64,6 +65,7 @@ bool DirExists(const char *name) { #define flatbuffers_stat stat #define FLATBUFFERS_S_IFDIR S_IFDIR #endif + // clang-format on struct flatbuffers_stat file_info; if (flatbuffers_stat(name, &file_info) != 0) return false; return (file_info.st_mode & FLATBUFFERS_S_IFDIR) != 0; @@ -78,8 +80,8 @@ LoadFileFunction SetLoadFileFunction(LoadFileFunction load_file_function) { FileExistsFunction SetFileExistsFunction( FileExistsFunction file_exists_function) { FileExistsFunction previous_function = g_file_exists_function; - g_file_exists_function = file_exists_function ? - file_exists_function : FileExistsRaw; + g_file_exists_function = + file_exists_function ? file_exists_function : FileExistsRaw; return previous_function; } diff --git a/tests/monster_test.grpc.fb.cc b/tests/monster_test.grpc.fb.cc index 95ccc0bfb..90b2764a4 100644 --- a/tests/monster_test.grpc.fb.cc +++ b/tests/monster_test.grpc.fb.cc @@ -27,44 +27,36 @@ std::unique_ptr< MonsterStorage::Stub> MonsterStorage::NewStub(const std::shared } MonsterStorage::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) - : channel_(channel) , rpcmethod_Store_(MonsterStorage_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_Retrieve_(MonsterStorage_method_names[1], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + : channel_(channel) , rpcmethod_Store_(MonsterStorage_method_names[0], ::grpc::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Retrieve_(MonsterStorage_method_names[1], ::grpc::RpcMethod::SERVER_STREAMING, channel) {} ::grpc::Status MonsterStorage::Stub::Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Store_, context, request, response); + return ::grpc::BlockingUnaryCall(channel_.get(), rpcmethod_Store_, context, request, response); } ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, true); -} - -::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, false); + return ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request); } ::grpc::ClientReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { - return ::grpc::internal::ClientReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_Retrieve_, context, request); + return new ::grpc::ClientReader< flatbuffers::grpc::Message>(channel_.get(), rpcmethod_Retrieve_, context, request); } ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { - return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, true, tag); -} - -::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, false, nullptr); + return ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, tag); } MonsterStorage::Service::Service() { - AddMethod(new ::grpc::internal::RpcServiceMethod( + AddMethod(new ::grpc::RpcServiceMethod( MonsterStorage_method_names[0], - ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + ::grpc::RpcMethod::NORMAL_RPC, + new ::grpc::RpcMethodHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( std::mem_fn(&MonsterStorage::Service::Store), this))); - AddMethod(new ::grpc::internal::RpcServiceMethod( + AddMethod(new ::grpc::RpcServiceMethod( MonsterStorage_method_names[1], - ::grpc::internal::RpcMethod::SERVER_STREAMING, - new ::grpc::internal::ServerStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + ::grpc::RpcMethod::SERVER_STREAMING, + new ::grpc::ServerStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( std::mem_fn(&MonsterStorage::Service::Retrieve), this))); } diff --git a/tests/monster_test.grpc.fb.h b/tests/monster_test.grpc.fb.h index b905d8fce..1942317fb 100644 --- a/tests/monster_test.grpc.fb.h +++ b/tests/monster_test.grpc.fb.h @@ -4,8 +4,8 @@ #ifndef GRPC_monster_5ftest__INCLUDED #define GRPC_monster_5ftest__INCLUDED -#include "monster_test_generated.h" #include "flatbuffers/grpc.h" +#include "monster_test_generated.h" #include #include @@ -20,6 +20,7 @@ namespace grpc { class CompletionQueue; class Channel; +class RpcService; class ServerCompletionQueue; class ServerContext; } // namespace grpc @@ -39,24 +40,16 @@ class MonsterStorage final { std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); - } std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); - } private: virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) = 0; - virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: @@ -65,28 +58,20 @@ class MonsterStorage final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); - } std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { return std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); - } private: std::shared_ptr< ::grpc::ChannelInterface> channel_; ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) override; ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) override; - ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; - const ::grpc::internal::RpcMethod rpcmethod_Store_; - const ::grpc::internal::RpcMethod rpcmethod_Retrieve_; + const ::grpc::RpcMethod rpcmethod_Store_; + const ::grpc::RpcMethod rpcmethod_Retrieve_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); @@ -179,7 +164,7 @@ class MonsterStorage final { public: WithStreamedUnaryMethod_Store() { ::grpc::Service::MarkMethodStreamed(0, - new ::grpc::internal::StreamedUnaryHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithStreamedUnaryMethod_Store::StreamedStore, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::StreamedUnaryHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithStreamedUnaryMethod_Store::StreamedStore, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_Store() override { BaseClassMustBeDerivedFromService(this); @@ -200,7 +185,7 @@ class MonsterStorage final { public: WithSplitStreamingMethod_Retrieve() { ::grpc::Service::MarkMethodStreamed(1, - new ::grpc::internal::SplitServerStreamingHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithSplitStreamingMethod_Retrieve::StreamedRetrieve, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::SplitServerStreamingHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithSplitStreamingMethod_Retrieve::StreamedRetrieve, this, std::placeholders::_1, std::placeholders::_2))); } ~WithSplitStreamingMethod_Retrieve() override { BaseClassMustBeDerivedFromService(this); diff --git a/tests/monster_test_generated.ts b/tests/monster_test_generated.ts index 98fc4c5e3..fa4e96305 100644 --- a/tests/monster_test_generated.ts +++ b/tests/monster_test_generated.ts @@ -29,7 +29,7 @@ export class InParentNamespace { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -81,7 +81,7 @@ export class Monster { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -133,7 +133,7 @@ export class Test { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -154,7 +154,7 @@ __init(i:number, bb:flatbuffers.ByteBuffer):Test { * @returns {number} */ a():number { - return this.bb!.readInt16(this.bb_pos); + return this.bb.readInt16(this.bb_pos); }; /** @@ -162,13 +162,13 @@ a():number { * @returns {boolean} */ mutate_a(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 0); + var offset = this.bb.__offset(this.bb_pos, 0); if (offset === 0) { return false; } - this.bb!.writeInt16(this.bb_pos + offset, value); + this.bb.writeInt16(this.bb_pos + offset, value); return true; }; @@ -176,7 +176,7 @@ mutate_a(value:number):boolean { * @returns {number} */ b():number { - return this.bb!.readInt8(this.bb_pos + 2); + return this.bb.readInt8(this.bb_pos + 2); }; /** @@ -184,13 +184,13 @@ b():number { * @returns {boolean} */ mutate_b(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 2); + var offset = this.bb.__offset(this.bb_pos, 2); if (offset === 0) { return false; } - this.bb!.writeInt8(this.bb_pos + offset, value); + this.bb.writeInt8(this.bb_pos + offset, value); return true; }; @@ -218,7 +218,7 @@ export class TestSimpleTableWithEnum { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -248,8 +248,8 @@ static getRootAsTestSimpleTableWithEnum(bb:flatbuffers.ByteBuffer, obj?:TestSimp * @returns {MyGame.Example.Color} */ color():MyGame.Example.Color { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? /** @type {MyGame.Example.Color} */ (this.bb!.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Green; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Green; }; /** @@ -257,13 +257,13 @@ color():MyGame.Example.Color { * @returns {boolean} */ mutate_color(value:MyGame.Example.Color):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeInt8(this.bb_pos + offset, value); + this.bb.writeInt8(this.bb_pos + offset, value); return true; }; @@ -301,7 +301,7 @@ export class Vec3 { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -322,7 +322,7 @@ __init(i:number, bb:flatbuffers.ByteBuffer):Vec3 { * @returns {number} */ x():number { - return this.bb!.readFloat32(this.bb_pos); + return this.bb.readFloat32(this.bb_pos); }; /** @@ -330,13 +330,13 @@ x():number { * @returns {boolean} */ mutate_x(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 0); + var offset = this.bb.__offset(this.bb_pos, 0); if (offset === 0) { return false; } - this.bb!.writeFloat32(this.bb_pos + offset, value); + this.bb.writeFloat32(this.bb_pos + offset, value); return true; }; @@ -344,7 +344,7 @@ mutate_x(value:number):boolean { * @returns {number} */ y():number { - return this.bb!.readFloat32(this.bb_pos + 4); + return this.bb.readFloat32(this.bb_pos + 4); }; /** @@ -352,13 +352,13 @@ y():number { * @returns {boolean} */ mutate_y(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeFloat32(this.bb_pos + offset, value); + this.bb.writeFloat32(this.bb_pos + offset, value); return true; }; @@ -366,7 +366,7 @@ mutate_y(value:number):boolean { * @returns {number} */ z():number { - return this.bb!.readFloat32(this.bb_pos + 8); + return this.bb.readFloat32(this.bb_pos + 8); }; /** @@ -374,13 +374,13 @@ z():number { * @returns {boolean} */ mutate_z(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 8); + var offset = this.bb.__offset(this.bb_pos, 8); if (offset === 0) { return false; } - this.bb!.writeFloat32(this.bb_pos + offset, value); + this.bb.writeFloat32(this.bb_pos + offset, value); return true; }; @@ -388,7 +388,7 @@ mutate_z(value:number):boolean { * @returns {number} */ test1():number { - return this.bb!.readFloat64(this.bb_pos + 16); + return this.bb.readFloat64(this.bb_pos + 16); }; /** @@ -396,13 +396,13 @@ test1():number { * @returns {boolean} */ mutate_test1(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 16); + var offset = this.bb.__offset(this.bb_pos, 16); if (offset === 0) { return false; } - this.bb!.writeFloat64(this.bb_pos + offset, value); + this.bb.writeFloat64(this.bb_pos + offset, value); return true; }; @@ -410,7 +410,7 @@ mutate_test1(value:number):boolean { * @returns {MyGame.Example.Color} */ test2():MyGame.Example.Color { - return /** @type {MyGame.Example.Color} */ (this.bb!.readInt8(this.bb_pos + 24)); + return /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + 24)); }; /** @@ -418,13 +418,13 @@ test2():MyGame.Example.Color { * @returns {boolean} */ mutate_test2(value:MyGame.Example.Color):boolean { - var offset = this.bb!.__offset(this.bb_pos, 24); + var offset = this.bb.__offset(this.bb_pos, 24); if (offset === 0) { return false; } - this.bb!.writeInt8(this.bb_pos + offset, value); + this.bb.writeInt8(this.bb_pos + offset, value); return true; }; @@ -433,7 +433,7 @@ mutate_test2(value:MyGame.Example.Color):boolean { * @returns {MyGame.Example.Test|null} */ test3(obj?:MyGame.Example.Test):MyGame.Example.Test|null { - return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb!); + return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb); }; /** @@ -474,7 +474,7 @@ export class Ability { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -495,7 +495,7 @@ __init(i:number, bb:flatbuffers.ByteBuffer):Ability { * @returns {number} */ id():number { - return this.bb!.readUint32(this.bb_pos); + return this.bb.readUint32(this.bb_pos); }; /** @@ -503,13 +503,13 @@ id():number { * @returns {boolean} */ mutate_id(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 0); + var offset = this.bb.__offset(this.bb_pos, 0); if (offset === 0) { return false; } - this.bb!.writeUint32(this.bb_pos + offset, value); + this.bb.writeUint32(this.bb_pos + offset, value); return true; }; @@ -517,7 +517,7 @@ mutate_id(value:number):boolean { * @returns {number} */ distance():number { - return this.bb!.readUint32(this.bb_pos + 4); + return this.bb.readUint32(this.bb_pos + 4); }; /** @@ -525,13 +525,13 @@ distance():number { * @returns {boolean} */ mutate_distance(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeUint32(this.bb_pos + offset, value); + this.bb.writeUint32(this.bb_pos + offset, value); return true; }; @@ -558,7 +558,7 @@ export class Stat { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -591,16 +591,16 @@ static getRootAsStat(bb:flatbuffers.ByteBuffer, obj?:Stat):Stat { id():string|null id(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null id(optionalEncoding?:any):string|Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; }; /** * @returns {flatbuffers.Long} */ val():flatbuffers.Long { - var offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); }; /** @@ -608,13 +608,13 @@ val():flatbuffers.Long { * @returns {boolean} */ mutate_val(value:flatbuffers.Long):boolean { - var offset = this.bb!.__offset(this.bb_pos, 6); + var offset = this.bb.__offset(this.bb_pos, 6); if (offset === 0) { return false; } - this.bb!.writeInt64(this.bb_pos + offset, value); + this.bb.writeInt64(this.bb_pos + offset, value); return true; }; @@ -622,8 +622,8 @@ mutate_val(value:flatbuffers.Long):boolean { * @returns {number} */ count():number { - var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; }; /** @@ -631,13 +631,13 @@ count():number { * @returns {boolean} */ mutate_count(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 8); + var offset = this.bb.__offset(this.bb_pos, 8); if (offset === 0) { return false; } - this.bb!.writeUint16(this.bb_pos + offset, value); + this.bb.writeUint16(this.bb_pos + offset, value); return true; }; @@ -693,7 +693,7 @@ export class Monster { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -732,16 +732,16 @@ static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean { * @returns {MyGame.Example.Vec3|null} */ pos(obj?:MyGame.Example.Vec3):MyGame.Example.Vec3|null { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb) : null; }; /** * @returns {number} */ mana():number { - var offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readInt16(this.bb_pos + offset) : 150; + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 150; }; /** @@ -749,13 +749,13 @@ mana():number { * @returns {boolean} */ mutate_mana(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 6); + var offset = this.bb.__offset(this.bb_pos, 6); if (offset === 0) { return false; } - this.bb!.writeInt16(this.bb_pos + offset, value); + this.bb.writeInt16(this.bb_pos + offset, value); return true; }; @@ -763,8 +763,8 @@ mutate_mana(value:number):boolean { * @returns {number} */ hp():number { - var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readInt16(this.bb_pos + offset) : 100; + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 100; }; /** @@ -772,13 +772,13 @@ hp():number { * @returns {boolean} */ mutate_hp(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 8); + var offset = this.bb.__offset(this.bb_pos, 8); if (offset === 0) { return false; } - this.bb!.writeInt16(this.bb_pos + offset, value); + this.bb.writeInt16(this.bb_pos + offset, value); return true; }; @@ -789,8 +789,8 @@ mutate_hp(value:number):boolean { name():string|null name(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null name(optionalEncoding?:any):string|Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; }; /** @@ -798,32 +798,32 @@ name(optionalEncoding?:any):string|Uint8Array|null { * @returns {number} */ inventory(index: number):number|null { - var offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; }; /** * @returns {number} */ inventoryLength():number { - var offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Uint8Array} */ inventoryArray():Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** * @returns {MyGame.Example.Color} */ color():MyGame.Example.Color { - var offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? /** @type {MyGame.Example.Color} */ (this.bb!.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Blue; + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Color.Blue; }; /** @@ -831,13 +831,13 @@ color():MyGame.Example.Color { * @returns {boolean} */ mutate_color(value:MyGame.Example.Color):boolean { - var offset = this.bb!.__offset(this.bb_pos, 16); + var offset = this.bb.__offset(this.bb_pos, 16); if (offset === 0) { return false; } - this.bb!.writeInt8(this.bb_pos + offset, value); + this.bb.writeInt8(this.bb_pos + offset, value); return true; }; @@ -845,8 +845,8 @@ mutate_color(value:MyGame.Example.Color):boolean { * @returns {MyGame.Example.Any} */ testType():MyGame.Example.Any { - var offset = this.bb!.__offset(this.bb_pos, 18); - return offset ? /** @type {MyGame.Example.Any} */ (this.bb!.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE; + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? /** @type {MyGame.Example.Any} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE; }; /** @@ -854,13 +854,13 @@ testType():MyGame.Example.Any { * @returns {boolean} */ mutate_test_type(value:MyGame.Example.Any):boolean { - var offset = this.bb!.__offset(this.bb_pos, 18); + var offset = this.bb.__offset(this.bb_pos, 18); if (offset === 0) { return false; } - this.bb!.writeUint8(this.bb_pos + offset, value); + this.bb.writeUint8(this.bb_pos + offset, value); return true; }; @@ -869,8 +869,8 @@ mutate_test_type(value:MyGame.Example.Any):boolean { * @returns {?flatbuffers.Table} */ test(obj:T):T|null { - var offset = this.bb!.__offset(this.bb_pos, 20); - return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__union(obj, this.bb_pos + offset) : null; }; /** @@ -879,16 +879,16 @@ test(obj:T):T|null { * @returns {MyGame.Example.Test} */ test4(index: number, obj?:MyGame.Example.Test):MyGame.Example.Test|null { - var offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? (obj || new MyGame.Example.Test).__init(this.bb!.__vector(this.bb_pos + offset) + index * 4, this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null; }; /** * @returns {number} */ test4Length():number { - var offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** @@ -899,16 +899,16 @@ test4Length():number { testarrayofstring(index: number):string testarrayofstring(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array testarrayofstring(index: number,optionalEncoding?:any):string|Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; }; /** * @returns {number} */ testarrayofstringLength():number { - var offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** @@ -920,16 +920,16 @@ testarrayofstringLength():number { * @returns {MyGame.Example.Monster} */ testarrayoftables(index: number, obj?:MyGame.Example.Monster):MyGame.Example.Monster|null { - var offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? (obj || new MyGame.Example.Monster).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; }; /** * @returns {number} */ testarrayoftablesLength():number { - var offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** @@ -937,8 +937,8 @@ testarrayoftablesLength():number { * @returns {MyGame.Example.Monster|null} */ enemy(obj?:MyGame.Example.Monster):MyGame.Example.Monster|null { - var offset = this.bb!.__offset(this.bb_pos, 28); - return offset ? (obj || new MyGame.Example.Monster).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; }; /** @@ -946,24 +946,24 @@ enemy(obj?:MyGame.Example.Monster):MyGame.Example.Monster|null { * @returns {number} */ testnestedflatbuffer(index: number):number|null { - var offset = this.bb!.__offset(this.bb_pos, 30); - return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; }; /** * @returns {number} */ testnestedflatbufferLength():number { - var offset = this.bb!.__offset(this.bb_pos, 30); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Uint8Array} */ testnestedflatbufferArray():Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 30); - return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** @@ -971,16 +971,16 @@ testnestedflatbufferArray():Uint8Array|null { * @returns {MyGame.Example.Stat|null} */ testempty(obj?:MyGame.Example.Stat):MyGame.Example.Stat|null { - var offset = this.bb!.__offset(this.bb_pos, 32); - return offset ? (obj || new MyGame.Example.Stat).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 32); + return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; }; /** * @returns {boolean} */ testbool():boolean { - var offset = this.bb!.__offset(this.bb_pos, 34); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; + var offset = this.bb.__offset(this.bb_pos, 34); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; }; /** @@ -988,13 +988,13 @@ testbool():boolean { * @returns {boolean} */ mutate_testbool(value:boolean):boolean { - var offset = this.bb!.__offset(this.bb_pos, 34); + var offset = this.bb.__offset(this.bb_pos, 34); if (offset === 0) { return false; } - this.bb!.writeInt8(this.bb_pos + offset, +value); + this.bb.writeInt8(this.bb_pos + offset, +value); return true; }; @@ -1002,8 +1002,8 @@ mutate_testbool(value:boolean):boolean { * @returns {number} */ testhashs32Fnv1():number { - var offset = this.bb!.__offset(this.bb_pos, 36); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 36); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; }; /** @@ -1011,13 +1011,13 @@ testhashs32Fnv1():number { * @returns {boolean} */ mutate_testhashs32_fnv1(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 36); + var offset = this.bb.__offset(this.bb_pos, 36); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -1025,8 +1025,8 @@ mutate_testhashs32_fnv1(value:number):boolean { * @returns {number} */ testhashu32Fnv1():number { - var offset = this.bb!.__offset(this.bb_pos, 38); - return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 38); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; }; /** @@ -1034,13 +1034,13 @@ testhashu32Fnv1():number { * @returns {boolean} */ mutate_testhashu32_fnv1(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 38); + var offset = this.bb.__offset(this.bb_pos, 38); if (offset === 0) { return false; } - this.bb!.writeUint32(this.bb_pos + offset, value); + this.bb.writeUint32(this.bb_pos + offset, value); return true; }; @@ -1048,8 +1048,8 @@ mutate_testhashu32_fnv1(value:number):boolean { * @returns {flatbuffers.Long} */ testhashs64Fnv1():flatbuffers.Long { - var offset = this.bb!.__offset(this.bb_pos, 40); - return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 40); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); }; /** @@ -1057,13 +1057,13 @@ testhashs64Fnv1():flatbuffers.Long { * @returns {boolean} */ mutate_testhashs64_fnv1(value:flatbuffers.Long):boolean { - var offset = this.bb!.__offset(this.bb_pos, 40); + var offset = this.bb.__offset(this.bb_pos, 40); if (offset === 0) { return false; } - this.bb!.writeInt64(this.bb_pos + offset, value); + this.bb.writeInt64(this.bb_pos + offset, value); return true; }; @@ -1071,8 +1071,8 @@ mutate_testhashs64_fnv1(value:flatbuffers.Long):boolean { * @returns {flatbuffers.Long} */ testhashu64Fnv1():flatbuffers.Long { - var offset = this.bb!.__offset(this.bb_pos, 42); - return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 42); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); }; /** @@ -1080,13 +1080,13 @@ testhashu64Fnv1():flatbuffers.Long { * @returns {boolean} */ mutate_testhashu64_fnv1(value:flatbuffers.Long):boolean { - var offset = this.bb!.__offset(this.bb_pos, 42); + var offset = this.bb.__offset(this.bb_pos, 42); if (offset === 0) { return false; } - this.bb!.writeUint64(this.bb_pos + offset, value); + this.bb.writeUint64(this.bb_pos + offset, value); return true; }; @@ -1094,8 +1094,8 @@ mutate_testhashu64_fnv1(value:flatbuffers.Long):boolean { * @returns {number} */ testhashs32Fnv1a():number { - var offset = this.bb!.__offset(this.bb_pos, 44); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 44); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; }; /** @@ -1103,13 +1103,13 @@ testhashs32Fnv1a():number { * @returns {boolean} */ mutate_testhashs32_fnv1a(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 44); + var offset = this.bb.__offset(this.bb_pos, 44); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -1117,8 +1117,8 @@ mutate_testhashs32_fnv1a(value:number):boolean { * @returns {number} */ testhashu32Fnv1a():number { - var offset = this.bb!.__offset(this.bb_pos, 46); - return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 46); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; }; /** @@ -1126,13 +1126,13 @@ testhashu32Fnv1a():number { * @returns {boolean} */ mutate_testhashu32_fnv1a(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 46); + var offset = this.bb.__offset(this.bb_pos, 46); if (offset === 0) { return false; } - this.bb!.writeUint32(this.bb_pos + offset, value); + this.bb.writeUint32(this.bb_pos + offset, value); return true; }; @@ -1140,8 +1140,8 @@ mutate_testhashu32_fnv1a(value:number):boolean { * @returns {flatbuffers.Long} */ testhashs64Fnv1a():flatbuffers.Long { - var offset = this.bb!.__offset(this.bb_pos, 48); - return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 48); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); }; /** @@ -1149,13 +1149,13 @@ testhashs64Fnv1a():flatbuffers.Long { * @returns {boolean} */ mutate_testhashs64_fnv1a(value:flatbuffers.Long):boolean { - var offset = this.bb!.__offset(this.bb_pos, 48); + var offset = this.bb.__offset(this.bb_pos, 48); if (offset === 0) { return false; } - this.bb!.writeInt64(this.bb_pos + offset, value); + this.bb.writeInt64(this.bb_pos + offset, value); return true; }; @@ -1163,8 +1163,8 @@ mutate_testhashs64_fnv1a(value:flatbuffers.Long):boolean { * @returns {flatbuffers.Long} */ testhashu64Fnv1a():flatbuffers.Long { - var offset = this.bb!.__offset(this.bb_pos, 50); - return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 50); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); }; /** @@ -1172,13 +1172,13 @@ testhashu64Fnv1a():flatbuffers.Long { * @returns {boolean} */ mutate_testhashu64_fnv1a(value:flatbuffers.Long):boolean { - var offset = this.bb!.__offset(this.bb_pos, 50); + var offset = this.bb.__offset(this.bb_pos, 50); if (offset === 0) { return false; } - this.bb!.writeUint64(this.bb_pos + offset, value); + this.bb.writeUint64(this.bb_pos + offset, value); return true; }; @@ -1187,32 +1187,32 @@ mutate_testhashu64_fnv1a(value:flatbuffers.Long):boolean { * @returns {boolean} */ testarrayofbools(index: number):boolean|null { - var offset = this.bb!.__offset(this.bb_pos, 52); - return offset ? !!this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : false; + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false; }; /** * @returns {number} */ testarrayofboolsLength():number { - var offset = this.bb!.__offset(this.bb_pos, 52); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Int8Array} */ testarrayofboolsArray():Int8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 52); - return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 52); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** * @returns {number} */ testf():number { - var offset = this.bb!.__offset(this.bb_pos, 54); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 3.14159; + var offset = this.bb.__offset(this.bb_pos, 54); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.14159; }; /** @@ -1220,13 +1220,13 @@ testf():number { * @returns {boolean} */ mutate_testf(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 54); + var offset = this.bb.__offset(this.bb_pos, 54); if (offset === 0) { return false; } - this.bb!.writeFloat32(this.bb_pos + offset, value); + this.bb.writeFloat32(this.bb_pos + offset, value); return true; }; @@ -1234,8 +1234,8 @@ mutate_testf(value:number):boolean { * @returns {number} */ testf2():number { - var offset = this.bb!.__offset(this.bb_pos, 56); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 3.0; + var offset = this.bb.__offset(this.bb_pos, 56); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.0; }; /** @@ -1243,13 +1243,13 @@ testf2():number { * @returns {boolean} */ mutate_testf2(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 56); + var offset = this.bb.__offset(this.bb_pos, 56); if (offset === 0) { return false; } - this.bb!.writeFloat32(this.bb_pos + offset, value); + this.bb.writeFloat32(this.bb_pos + offset, value); return true; }; @@ -1257,8 +1257,8 @@ mutate_testf2(value:number):boolean { * @returns {number} */ testf3():number { - var offset = this.bb!.__offset(this.bb_pos, 58); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; + var offset = this.bb.__offset(this.bb_pos, 58); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; }; /** @@ -1266,13 +1266,13 @@ testf3():number { * @returns {boolean} */ mutate_testf3(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 58); + var offset = this.bb.__offset(this.bb_pos, 58); if (offset === 0) { return false; } - this.bb!.writeFloat32(this.bb_pos + offset, value); + this.bb.writeFloat32(this.bb_pos + offset, value); return true; }; @@ -1284,16 +1284,16 @@ mutate_testf3(value:number):boolean { testarrayofstring2(index: number):string testarrayofstring2(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array testarrayofstring2(index: number,optionalEncoding?:any):string|Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 60); - return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; }; /** * @returns {number} */ testarrayofstring2Length():number { - var offset = this.bb!.__offset(this.bb_pos, 60); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** @@ -1302,16 +1302,16 @@ testarrayofstring2Length():number { * @returns {MyGame.Example.Ability} */ testarrayofsortedstruct(index: number, obj?:MyGame.Example.Ability):MyGame.Example.Ability|null { - var offset = this.bb!.__offset(this.bb_pos, 62); - return offset ? (obj || new MyGame.Example.Ability).__init(this.bb!.__vector(this.bb_pos + offset) + index * 8, this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? (obj || new MyGame.Example.Ability).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null; }; /** * @returns {number} */ testarrayofsortedstructLength():number { - var offset = this.bb!.__offset(this.bb_pos, 62); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 62); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** @@ -1319,24 +1319,24 @@ testarrayofsortedstructLength():number { * @returns {number} */ flex(index: number):number|null { - var offset = this.bb!.__offset(this.bb_pos, 64); - return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; + var offset = this.bb.__offset(this.bb_pos, 64); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; }; /** * @returns {number} */ flexLength():number { - var offset = this.bb!.__offset(this.bb_pos, 64); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 64); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Uint8Array} */ flexArray():Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 64); - return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 64); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** @@ -1345,16 +1345,16 @@ flexArray():Uint8Array|null { * @returns {MyGame.Example.Test} */ test5(index: number, obj?:MyGame.Example.Test):MyGame.Example.Test|null { - var offset = this.bb!.__offset(this.bb_pos, 66); - return offset ? (obj || new MyGame.Example.Test).__init(this.bb!.__vector(this.bb_pos + offset) + index * 4, this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 66); + return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null; }; /** * @returns {number} */ test5Length():number { - var offset = this.bb!.__offset(this.bb_pos, 66); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 66); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** @@ -1362,16 +1362,16 @@ test5Length():number { * @returns {flatbuffers.Long} */ vectorOfLongs(index: number):flatbuffers.Long|null { - var offset = this.bb!.__offset(this.bb_pos, 68); - return offset ? this.bb!.readInt64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 68); + return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0); }; /** * @returns {number} */ vectorOfLongsLength():number { - var offset = this.bb!.__offset(this.bb_pos, 68); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 68); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** @@ -1379,24 +1379,24 @@ vectorOfLongsLength():number { * @returns {number} */ vectorOfDoubles(index: number):number|null { - var offset = this.bb!.__offset(this.bb_pos, 70); - return offset ? this.bb!.readFloat64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : 0; + var offset = this.bb.__offset(this.bb_pos, 70); + return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0; }; /** * @returns {number} */ vectorOfDoublesLength():number { - var offset = this.bb!.__offset(this.bb_pos, 70); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 70); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Float64Array} */ vectorOfDoublesArray():Float64Array|null { - var offset = this.bb!.__offset(this.bb_pos, 70); - return offset ? new Float64Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 70); + return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** @@ -1404,8 +1404,8 @@ vectorOfDoublesArray():Float64Array|null { * @returns {MyGame.InParentNamespace|null} */ parentNamespaceTest(obj?:MyGame.InParentNamespace):MyGame.InParentNamespace|null { - var offset = this.bb!.__offset(this.bb_pos, 72); - return offset ? (obj || new MyGame.InParentNamespace).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 72); + return offset ? (obj || new MyGame.InParentNamespace).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; }; /** @@ -1928,7 +1928,7 @@ export class TypeAliases { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -1958,8 +1958,8 @@ static getRootAsTypeAliases(bb:flatbuffers.ByteBuffer, obj?:TypeAliases):TypeAli * @returns {number} */ i8():number { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readInt8(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt8(this.bb_pos + offset) : 0; }; /** @@ -1967,13 +1967,13 @@ i8():number { * @returns {boolean} */ mutate_i8(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeInt8(this.bb_pos + offset, value); + this.bb.writeInt8(this.bb_pos + offset, value); return true; }; @@ -1981,8 +1981,8 @@ mutate_i8(value:number):boolean { * @returns {number} */ u8():number { - var offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; }; /** @@ -1990,13 +1990,13 @@ u8():number { * @returns {boolean} */ mutate_u8(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 6); + var offset = this.bb.__offset(this.bb_pos, 6); if (offset === 0) { return false; } - this.bb!.writeUint8(this.bb_pos + offset, value); + this.bb.writeUint8(this.bb_pos + offset, value); return true; }; @@ -2004,8 +2004,8 @@ mutate_u8(value:number):boolean { * @returns {number} */ i16():number { - var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 0; }; /** @@ -2013,13 +2013,13 @@ i16():number { * @returns {boolean} */ mutate_i16(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 8); + var offset = this.bb.__offset(this.bb_pos, 8); if (offset === 0) { return false; } - this.bb!.writeInt16(this.bb_pos + offset, value); + this.bb.writeInt16(this.bb_pos + offset, value); return true; }; @@ -2027,8 +2027,8 @@ mutate_i16(value:number):boolean { * @returns {number} */ u16():number { - var offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; }; /** @@ -2036,13 +2036,13 @@ u16():number { * @returns {boolean} */ mutate_u16(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 10); + var offset = this.bb.__offset(this.bb_pos, 10); if (offset === 0) { return false; } - this.bb!.writeUint16(this.bb_pos + offset, value); + this.bb.writeUint16(this.bb_pos + offset, value); return true; }; @@ -2050,8 +2050,8 @@ mutate_u16(value:number):boolean { * @returns {number} */ i32():number { - var offset = this.bb!.__offset(this.bb_pos, 12); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; }; /** @@ -2059,13 +2059,13 @@ i32():number { * @returns {boolean} */ mutate_i32(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 12); + var offset = this.bb.__offset(this.bb_pos, 12); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -2073,8 +2073,8 @@ mutate_i32(value:number):boolean { * @returns {number} */ u32():number { - var offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; }; /** @@ -2082,13 +2082,13 @@ u32():number { * @returns {boolean} */ mutate_u32(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 14); + var offset = this.bb.__offset(this.bb_pos, 14); if (offset === 0) { return false; } - this.bb!.writeUint32(this.bb_pos + offset, value); + this.bb.writeUint32(this.bb_pos + offset, value); return true; }; @@ -2096,8 +2096,8 @@ mutate_u32(value:number):boolean { * @returns {flatbuffers.Long} */ i64():flatbuffers.Long { - var offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); }; /** @@ -2105,13 +2105,13 @@ i64():flatbuffers.Long { * @returns {boolean} */ mutate_i64(value:flatbuffers.Long):boolean { - var offset = this.bb!.__offset(this.bb_pos, 16); + var offset = this.bb.__offset(this.bb_pos, 16); if (offset === 0) { return false; } - this.bb!.writeInt64(this.bb_pos + offset, value); + this.bb.writeInt64(this.bb_pos + offset, value); return true; }; @@ -2119,8 +2119,8 @@ mutate_i64(value:flatbuffers.Long):boolean { * @returns {flatbuffers.Long} */ u64():flatbuffers.Long { - var offset = this.bb!.__offset(this.bb_pos, 18); - return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(0, 0); + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); }; /** @@ -2128,13 +2128,13 @@ u64():flatbuffers.Long { * @returns {boolean} */ mutate_u64(value:flatbuffers.Long):boolean { - var offset = this.bb!.__offset(this.bb_pos, 18); + var offset = this.bb.__offset(this.bb_pos, 18); if (offset === 0) { return false; } - this.bb!.writeUint64(this.bb_pos + offset, value); + this.bb.writeUint64(this.bb_pos + offset, value); return true; }; @@ -2142,8 +2142,8 @@ mutate_u64(value:flatbuffers.Long):boolean { * @returns {number} */ f32():number { - var offset = this.bb!.__offset(this.bb_pos, 20); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; }; /** @@ -2151,13 +2151,13 @@ f32():number { * @returns {boolean} */ mutate_f32(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 20); + var offset = this.bb.__offset(this.bb_pos, 20); if (offset === 0) { return false; } - this.bb!.writeFloat32(this.bb_pos + offset, value); + this.bb.writeFloat32(this.bb_pos + offset, value); return true; }; @@ -2165,8 +2165,8 @@ mutate_f32(value:number):boolean { * @returns {number} */ f64():number { - var offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0; + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; }; /** @@ -2174,13 +2174,13 @@ f64():number { * @returns {boolean} */ mutate_f64(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 22); + var offset = this.bb.__offset(this.bb_pos, 22); if (offset === 0) { return false; } - this.bb!.writeFloat64(this.bb_pos + offset, value); + this.bb.writeFloat64(this.bb_pos + offset, value); return true; }; @@ -2189,24 +2189,24 @@ mutate_f64(value:number):boolean { * @returns {number} */ v8(index: number):number|null { - var offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0; }; /** * @returns {number} */ v8Length():number { - var offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Int8Array} */ v8Array():Int8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** @@ -2214,24 +2214,24 @@ v8Array():Int8Array|null { * @returns {number} */ vf64(index: number):number|null { - var offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? this.bb!.readFloat64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : 0; + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0; }; /** * @returns {number} */ vf64Length():number { - var offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Float64Array} */ vf64Array():Float64Array|null { - var offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? new Float64Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** diff --git a/tests/namespace_test/namespace_test1_generated.ts b/tests/namespace_test/namespace_test1_generated.ts index 31a243500..54d935a4e 100644 --- a/tests/namespace_test/namespace_test1_generated.ts +++ b/tests/namespace_test/namespace_test1_generated.ts @@ -18,7 +18,7 @@ export class TableInNestedNS { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -48,8 +48,8 @@ static getRootAsTableInNestedNS(bb:flatbuffers.ByteBuffer, obj?:TableInNestedNS) * @returns {number} */ foo():number { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; }; /** @@ -57,13 +57,13 @@ foo():number { * @returns {boolean} */ mutate_foo(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -101,7 +101,7 @@ export class StructInNestedNS { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -122,7 +122,7 @@ __init(i:number, bb:flatbuffers.ByteBuffer):StructInNestedNS { * @returns {number} */ a():number { - return this.bb!.readInt32(this.bb_pos); + return this.bb.readInt32(this.bb_pos); }; /** @@ -130,13 +130,13 @@ a():number { * @returns {boolean} */ mutate_a(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 0); + var offset = this.bb.__offset(this.bb_pos, 0); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -144,7 +144,7 @@ mutate_a(value:number):boolean { * @returns {number} */ b():number { - return this.bb!.readInt32(this.bb_pos + 4); + return this.bb.readInt32(this.bb_pos + 4); }; /** @@ -152,13 +152,13 @@ b():number { * @returns {boolean} */ mutate_b(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index 18f1d6e87..8deae09c4 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -9,7 +9,7 @@ export class TableInFirstNS { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -40,16 +40,16 @@ static getRootAsTableInFirstNS(bb:flatbuffers.ByteBuffer, obj?:TableInFirstNS):T * @returns {NamespaceA.NamespaceB.TableInNestedNS|null} */ fooTable(obj?:NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS):NS9459827973991502386.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; + 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; }; /** * @returns {NamespaceA.NamespaceB.EnumInNestedNS} */ fooEnum():NS9459827973991502386.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; + 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; }; /** @@ -57,13 +57,13 @@ fooEnum():NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS { * @returns {boolean} */ mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS):boolean { - var offset = this.bb!.__offset(this.bb_pos, 6); + var offset = this.bb.__offset(this.bb_pos, 6); if (offset === 0) { return false; } - this.bb!.writeInt8(this.bb_pos + offset, value); + this.bb.writeInt8(this.bb_pos + offset, value); return true; }; @@ -72,8 +72,8 @@ mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS * @returns {NamespaceA.NamespaceB.StructInNestedNS|null} */ fooStruct(obj?:NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS):NS9459827973991502386.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; + 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; }; /** @@ -126,7 +126,7 @@ export class TableInC { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -157,8 +157,8 @@ static getRootAsTableInC(bb:flatbuffers.ByteBuffer, obj?:TableInC):TableInC { * @returns {NamespaceA.TableInFirstNS|null} */ referToA1(obj?:NamespaceA.TableInFirstNS):NamespaceA.TableInFirstNS|null { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new NamespaceA.TableInFirstNS).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new NamespaceA.TableInFirstNS).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; }; /** @@ -166,8 +166,8 @@ referToA1(obj?:NamespaceA.TableInFirstNS):NamespaceA.TableInFirstNS|null { * @returns {NamespaceA.SecondTableInA|null} */ referToA2(obj?:NamespaceA.SecondTableInA):NamespaceA.SecondTableInA|null { - var offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? (obj || new NamespaceA.SecondTableInA).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? (obj || new NamespaceA.SecondTableInA).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; }; /** @@ -212,7 +212,7 @@ export class SecondTableInA { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -243,8 +243,8 @@ static getRootAsSecondTableInA(bb:flatbuffers.ByteBuffer, obj?:SecondTableInA):S * @returns {NamespaceC.TableInC|null} */ referToC(obj?:NamespaceC.TableInC):NamespaceC.TableInC|null { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new NamespaceC.TableInC).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? (obj || new NamespaceC.TableInC).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; }; /** diff --git a/tests/test.cpp b/tests/test.cpp index dd76c0d4b..56d96c2fc 100644 --- a/tests/test.cpp +++ b/tests/test.cpp @@ -16,15 +16,16 @@ #include "flatbuffers/flatbuffers.h" #include "flatbuffers/idl.h" -#include "flatbuffers/util.h" -#include "flatbuffers/registry.h" #include "flatbuffers/minireflect.h" +#include "flatbuffers/registry.h" +#include "flatbuffers/util.h" #include "monster_test_generated.h" #include "namespace_test/namespace_test1_generated.h" #include "namespace_test/namespace_test2_generated.h" #include "union_vector/union_vector_generated.h" +// clang-format off #ifndef FLATBUFFERS_CPP98_STL #include #endif @@ -42,6 +43,7 @@ using namespace MyGame::Example; #define TEST_OUTPUT_LINE(...) \ { printf(__VA_ARGS__); printf("\n"); } #endif +// clang-format on int testing_fails = 0; @@ -56,30 +58,27 @@ void TestFail(const char *expval, const char *val, const char *exp, void TestEqStr(const char *expval, const char *val, const char *exp, const char *file, int line) { - if (strcmp(expval, val) != 0) { - TestFail(expval, val, exp, file, line); - } + if (strcmp(expval, val) != 0) { TestFail(expval, val, exp, file, line); } } template void TestEq(T expval, U val, const char *exp, const char *file, int line) { if (U(expval) != val) { TestFail(flatbuffers::NumToString(expval).c_str(), - flatbuffers::NumToString(val).c_str(), - exp, file, line); + flatbuffers::NumToString(val).c_str(), exp, file, line); } } -#define TEST_EQ(exp, val) TestEq(exp, val, #exp, __FILE__, __LINE__) +#define TEST_EQ(exp, val) TestEq(exp, val, #exp, __FILE__, __LINE__) #define TEST_NOTNULL(exp) TestEq(exp == NULL, false, #exp, __FILE__, __LINE__) -#define TEST_EQ_STR(exp, val) TestEqStr(exp, val, #exp, __FILE__, __LINE__) +#define TEST_EQ_STR(exp, val) TestEqStr(exp, val, #exp, __FILE__, __LINE__) // Include simple random number generator to ensure results will be the // same cross platform. // http://en.wikipedia.org/wiki/Park%E2%80%93Miller_random_number_generator uint32_t lcg_seed = 48271; uint32_t lcg_rand() { - return lcg_seed = ((uint64_t)lcg_seed * 279470273UL) % 4294967291UL; + return lcg_seed = ((uint64_t)lcg_seed * 279470273UL) % 4294967291UL; } void lcg_reset() { lcg_seed = 48271; } @@ -105,7 +104,7 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) { Test tests[] = { Test(10, 20), Test(30, 40) }; auto testv = builder.CreateVectorOfStructs(tests, 2); - + // clang-format off #ifndef FLATBUFFERS_CPP98_STL // Create a vector of structures from a lambda. auto testv2 = builder.CreateVectorOfStructs( @@ -119,6 +118,7 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) { *s = (reinterpret_cast(state))[i]; }, tests); #endif // FLATBUFFERS_CPP98_STL + // clang-format on // create monster with very few fields set: // (same functionality as CreateMonster below, but sets fields manually) @@ -139,12 +139,14 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) { // Create an array of strings. Also test string pooling, and lambdas. auto vecofstrings = - builder.CreateVector>(4, - [](size_t i, flatbuffers::FlatBufferBuilder *b) - -> flatbuffers::Offset { - static const char *names[] = { "bob", "fred", "bob", "fred" }; - return b->CreateSharedString(names[i]); - }, &builder); + builder.CreateVector>( + 4, + [](size_t i, flatbuffers::FlatBufferBuilder *b) + -> flatbuffers::Offset { + static const char *names[] = { "bob", "fred", "bob", "fred" }; + return b->CreateSharedString(names[i]); + }, + &builder); // Creating vectors of strings in one convenient call. std::vector names2; @@ -182,9 +184,8 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) { // If for whatever reason you don't have the nested_builder available, you // can substitute flatbuffers::largest_scalar_t (64-bit) for the alignment, or // the largest force_align value in your schema if you're using it. - auto nested_flatbuffer_vector = - builder.CreateVector(nested_builder.GetBufferPointer(), - nested_builder.GetSize()); + auto nested_flatbuffer_vector = builder.CreateVector( + nested_builder.GetBufferPointer(), nested_builder.GetSize()); // Test a nested FlexBuffer: flexbuffers::Builder flexbuild; @@ -194,24 +195,26 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) { // shortcut for creating monster with all fields set: auto mloc = CreateMonster(builder, &vec, 150, 80, name, inventory, Color_Blue, - Any_Monster, mlocs[1].Union(), // Store a union. + Any_Monster, mlocs[1].Union(), // Store a union. testv, vecofstrings, vecoftables, 0, - nested_flatbuffer_vector, 0, false, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3.14159f, 3.0f, 0.0f, - vecofstrings2, vecofstructs, flex, testv2); + nested_flatbuffer_vector, 0, false, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3.14159f, 3.0f, 0.0f, vecofstrings2, + vecofstructs, flex, testv2); FinishMonsterBuffer(builder, mloc); + // clang-format off #ifdef FLATBUFFERS_TEST_VERBOSE // print byte data for debugging: auto p = builder.GetBufferPointer(); for (flatbuffers::uoffset_t i = 0; i < builder.GetSize(); i++) printf("%d ", p[i]); #endif + // clang-format on // return the buffer for the caller to use. auto bufferpointer = - reinterpret_cast(builder.GetBufferPointer()); + reinterpret_cast(builder.GetBufferPointer()); buffer.assign(bufferpointer, bufferpointer + builder.GetSize()); return builder.ReleaseBufferPointer(); @@ -220,15 +223,14 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) { // example of accessing a buffer loaded in memory: void AccessFlatBufferTest(const uint8_t *flatbuf, size_t length, bool pooled = true) { - // First, verify the buffers integrity (optional) flatbuffers::Verifier verifier(flatbuf, length); TEST_EQ(VerifyMonsterBuffer(verifier), true); std::vector test_buff; test_buff.resize(length * 2); - std::memcpy(&test_buff[0], flatbuf , length); - std::memcpy(&test_buff[length], flatbuf , length); + std::memcpy(&test_buff[0], flatbuf, length); + std::memcpy(&test_buff[length], flatbuf, length); flatbuffers::Verifier verifier1(&test_buff[0], length); TEST_EQ(VerifyMonsterBuffer(verifier1), true); @@ -307,13 +309,14 @@ void AccessFlatBufferTest(const uint8_t *flatbuf, size_t length, // Test accessing a vector of sorted structs auto vecofstructs = monster->testarrayofsortedstruct(); if (vecofstructs) { // not filled in monster_test.bfbs - for (flatbuffers::uoffset_t i = 0; i < vecofstructs->size()-1; i++) { + for (flatbuffers::uoffset_t i = 0; i < vecofstructs->size() - 1; i++) { auto left = vecofstructs->Get(i); - auto right = vecofstructs->Get(i+1); + auto right = vecofstructs->Get(i + 1); TEST_EQ(true, (left->KeyCompareLessThan(right))); } TEST_NOTNULL(vecofstructs->LookupByKey(3)); - TEST_EQ(static_cast(nullptr), vecofstructs->LookupByKey(5)); + TEST_EQ(static_cast(nullptr), + vecofstructs->LookupByKey(5)); } // Test nested FlatBuffers if available: @@ -340,7 +343,7 @@ void AccessFlatBufferTest(const uint8_t *flatbuf, size_t length, TEST_EQ(flatbuffers::AlignOf(), 2UL); TEST_EQ(sizeof(Test), 4UL); - const flatbuffers::Vector* tests_array[] = { + const flatbuffers::Vector *tests_array[] = { monster->test4(), monster->test5(), }; @@ -388,7 +391,8 @@ void MutateFlatBuffersTest(uint8_t *flatbuf, std::size_t length) { // Monster originally at 150 mana (default value) auto mana_default_ok = monster->mutate_mana(150); // Mutate to default value. - TEST_EQ(mana_default_ok, true); // Mutation should succeed, because default value. + TEST_EQ(mana_default_ok, + true); // Mutation should succeed, because default value. TEST_EQ(monster->mana(), 150); auto mana_ok = monster->mutate_mana(10); TEST_EQ(mana_ok, false); // Field was NOT present, because default value. @@ -425,16 +429,16 @@ void ObjectFlatBuffersTest(uint8_t *flatbuf) { // strings into object pointers and back, to implement remote references // and such. auto resolver = flatbuffers::resolver_function_t( - [](void **pointer_adr, flatbuffers::hash_value_t hash) { - (void)pointer_adr; - (void)hash; - // Don't actually do anything, leave variable null. - }); + [](void **pointer_adr, flatbuffers::hash_value_t hash) { + (void)pointer_adr; + (void)hash; + // Don't actually do anything, leave variable null. + }); auto rehasher = flatbuffers::rehasher_function_t( - [](void *pointer) -> flatbuffers::hash_value_t { - (void)pointer; - return 0; - }); + [](void *pointer) -> flatbuffers::hash_value_t { + (void)pointer; + return 0; + }); // Turn a buffer into C++ objects. auto monster1 = UnPackMonster(flatbuf, &resolver); @@ -454,8 +458,7 @@ void ObjectFlatBuffersTest(uint8_t *flatbuf) { auto len1 = fbb1.GetSize(); auto len2 = fbb2.GetSize(); TEST_EQ(len1, len2); - TEST_EQ(memcmp(fbb1.GetBufferPointer(), fbb2.GetBufferPointer(), - len1), 0); + TEST_EQ(memcmp(fbb1.GetBufferPointer(), fbb2.GetBufferPointer(), len1), 0); // Test it with the original buffer test to make sure all data survived. AccessFlatBufferTest(fbb2.GetBufferPointer(), len2, false); @@ -511,8 +514,8 @@ void ObjectFlatBuffersTest(uint8_t *flatbuf) { void SizePrefixedTest() { // Create size prefixed buffer. flatbuffers::FlatBufferBuilder fbb; - fbb.FinishSizePrefixed(CreateMonster(fbb, 0, 200, 300, - fbb.CreateString("bob"))); + fbb.FinishSizePrefixed( + CreateMonster(fbb, 0, 200, 300, fbb.CreateString("bob"))); // Verify it. flatbuffers::Verifier verifier(fbb.GetBufferPointer(), fbb.GetSize()); @@ -520,14 +523,14 @@ void SizePrefixedTest() { // Access it. auto m = flatbuffers::GetSizePrefixedRoot( - fbb.GetBufferPointer()); + fbb.GetBufferPointer()); TEST_EQ(m->mana(), 200); TEST_EQ(m->hp(), 300); TEST_EQ_STR(m->name()->c_str(), "bob"); } - void TriviallyCopyableTest() { + // clang-format off #if __GNUG__ && __GNUC__ < 5 TEST_EQ(__has_trivial_copy(Vec3), true); #else @@ -535,28 +538,29 @@ void TriviallyCopyableTest() { TEST_EQ(std::is_trivially_copyable::value, true); #endif #endif + // clang-format on } - // example of parsing text straight into a buffer, and generating // text back from it: void ParseAndGenerateTextTest() { // load FlatBuffer schema (.fbs) and JSON from disk std::string schemafile; std::string jsonfile; + TEST_EQ(flatbuffers::LoadFile((test_data_path + "monster_test.fbs").c_str(), + false, &schemafile), + true); TEST_EQ(flatbuffers::LoadFile( - (test_data_path + "monster_test.fbs").c_str(), false, &schemafile), true); - TEST_EQ(flatbuffers::LoadFile( - (test_data_path + "monsterdata_test.golden").c_str(), false, &jsonfile), - true); + (test_data_path + "monsterdata_test.golden").c_str(), false, + &jsonfile), + true); // parse schema first, so we can use it to parse the data after flatbuffers::Parser parser; auto include_test_path = flatbuffers::ConCatPathFileName(test_data_path, "include_test"); - const char *include_directories[] = { - test_data_path.c_str(), include_test_path.c_str(), nullptr - }; + const char *include_directories[] = { test_data_path.c_str(), + include_test_path.c_str(), nullptr }; TEST_EQ(parser.Parse(schemafile.c_str(), include_directories), true); TEST_EQ(parser.Parse(jsonfile.c_str(), include_directories), true); @@ -573,7 +577,8 @@ void ParseAndGenerateTextTest() { // to ensure it is correct, we now generate text back from the binary, // and compare the two: std::string jsongen; - auto result = GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); + auto result = + GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); TEST_EQ(result, true); TEST_EQ_STR(jsongen.c_str(), jsonfile.c_str()); @@ -588,8 +593,7 @@ void ParseAndGenerateTextTest() { (test_data_path + "monster_test.fbs").c_str()); // Now we got this set up, we can parse by just specifying the identifier, // the correct schema will be loaded on the fly: - auto buf = registry.TextToFlatBuffer(jsonfile.c_str(), - MonsterIdentifier()); + auto buf = registry.TextToFlatBuffer(jsonfile.c_str(), MonsterIdentifier()); // If this fails, check registry.lasterror_. TEST_NOTNULL(buf.data()); // Test the buffer, to be sure: @@ -606,13 +610,13 @@ void ParseAndGenerateTextTest() { void ReflectionTest(uint8_t *flatbuf, size_t length) { // Load a binary schema. std::string bfbsfile; - TEST_EQ(flatbuffers::LoadFile( - (test_data_path + "monster_test.bfbs").c_str(), true, &bfbsfile), - true); + TEST_EQ(flatbuffers::LoadFile((test_data_path + "monster_test.bfbs").c_str(), + true, &bfbsfile), + true); // Verify it, just in case: flatbuffers::Verifier verifier( - reinterpret_cast(bfbsfile.c_str()), bfbsfile.length()); + reinterpret_cast(bfbsfile.c_str()), bfbsfile.length()); TEST_EQ(reflection::VerifySchemaBuffer(verifier), true); // Make sure the schema is what we expect it to be. @@ -661,16 +665,18 @@ void ReflectionTest(uint8_t *flatbuf, size_t length) { // Get struct field through reflection auto pos_struct = flatbuffers::GetFieldStruct(root, *pos_field_ptr); TEST_NOTNULL(pos_struct); - TEST_EQ(flatbuffers::GetAnyFieldF( - *pos_struct, *pos_table_ptr->fields()->LookupByKey("z")), 3.0f); + TEST_EQ(flatbuffers::GetAnyFieldF(*pos_struct, + *pos_table_ptr->fields()->LookupByKey("z")), + 3.0f); auto test3_field = pos_table_ptr->fields()->LookupByKey("test3"); auto test3_struct = flatbuffers::GetFieldStruct(*pos_struct, *test3_field); TEST_NOTNULL(test3_struct); auto test3_object = schema.objects()->Get(test3_field->type()->index()); - TEST_EQ(flatbuffers::GetAnyFieldF( - *test3_struct, *test3_object->fields()->LookupByKey("a")), 10); + TEST_EQ(flatbuffers::GetAnyFieldF(*test3_struct, + *test3_object->fields()->LookupByKey("a")), + 10); // We can also modify it. flatbuffers::SetField(&root, hp_field, 200); @@ -703,8 +709,9 @@ void ReflectionTest(uint8_t *flatbuf, size_t length) { // Get the root. // This time we wrap the result from GetAnyRoot in a smartpointer that // will keep rroot valid as resizingbuf resizes. - auto rroot = flatbuffers::piv(flatbuffers::GetAnyRoot( - flatbuffers::vector_data(resizingbuf)), resizingbuf); + auto rroot = flatbuffers::piv( + flatbuffers::GetAnyRoot(flatbuffers::vector_data(resizingbuf)), + resizingbuf); SetString(schema, "totally new string", GetFieldS(**rroot, name_field), &resizingbuf); // Here resizingbuf has changed, but rroot is still valid. @@ -712,8 +719,7 @@ void ReflectionTest(uint8_t *flatbuf, size_t length) { // Now lets extend a vector by 100 elements (10 -> 110). auto &inventory_field = *fields->LookupByKey("inventory"); auto rinventory = flatbuffers::piv( - flatbuffers::GetFieldV(**rroot, inventory_field), - resizingbuf); + flatbuffers::GetFieldV(**rroot, inventory_field), resizingbuf); flatbuffers::ResizeVector(schema, 110, 50, *rinventory, &resizingbuf); // rinventory still valid, so lets read from it. @@ -727,13 +733,13 @@ void ReflectionTest(uint8_t *flatbuf, size_t length) { auto &testarrayofstring_field = *fields->LookupByKey("testarrayofstring"); // Find the vector value: auto rtestarrayofstring = flatbuffers::piv( - flatbuffers::GetFieldV>( - **rroot, testarrayofstring_field), - resizingbuf); + flatbuffers::GetFieldV>( + **rroot, testarrayofstring_field), + resizingbuf); // It's a vector of 2 strings, to which we add one more, initialized to // offset 0. flatbuffers::ResizeVector>( - schema, 3, 0, *rtestarrayofstring, &resizingbuf); + schema, 3, 0, *rtestarrayofstring, &resizingbuf); // Here we just create a buffer that contans a single string, but this // could also be any complex set of tables and other values. flatbuffers::FlatBufferBuilder stringfbb; @@ -741,24 +747,23 @@ void ReflectionTest(uint8_t *flatbuf, size_t length) { // Add the contents of it to our existing FlatBuffer. // We do this last, so the pointer doesn't get invalidated (since it is // at the end of the buffer): - auto string_ptr = flatbuffers::AddFlatBuffer(resizingbuf, - stringfbb.GetBufferPointer(), - stringfbb.GetSize()); + auto string_ptr = flatbuffers::AddFlatBuffer( + resizingbuf, stringfbb.GetBufferPointer(), stringfbb.GetSize()); // Finally, set the new value in the vector. rtestarrayofstring->MutateOffset(2, string_ptr); TEST_EQ_STR(rtestarrayofstring->Get(0)->c_str(), "bob"); TEST_EQ_STR(rtestarrayofstring->Get(2)->c_str(), "hank"); // Test integrity of all resize operations above. flatbuffers::Verifier resize_verifier( - reinterpret_cast( - flatbuffers::vector_data(resizingbuf)), - resizingbuf.size()); + reinterpret_cast(flatbuffers::vector_data(resizingbuf)), + resizingbuf.size()); TEST_EQ(VerifyMonsterBuffer(resize_verifier), true); // Test buffer is valid using reflection as well TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(), flatbuffers::vector_data(resizingbuf), - resizingbuf.size()), true); + resizingbuf.size()), + true); // As an additional test, also set it on the name field. // Note: unlike the name change above, this just overwrites the offset, @@ -770,44 +775,47 @@ void ReflectionTest(uint8_t *flatbuf, size_t length) { // tables and other things out of other FlatBuffers into a FlatBufferBuilder, // either part or whole. flatbuffers::FlatBufferBuilder fbb; - auto root_offset = flatbuffers::CopyTable(fbb, schema, *root_table, - *flatbuffers::GetAnyRoot(flatbuf), - true); + auto root_offset = flatbuffers::CopyTable( + fbb, schema, *root_table, *flatbuffers::GetAnyRoot(flatbuf), true); fbb.Finish(root_offset, MonsterIdentifier()); // Test that it was copied correctly: AccessFlatBufferTest(fbb.GetBufferPointer(), fbb.GetSize()); // Test buffer is valid using reflection as well TEST_EQ(flatbuffers::Verify(schema, *schema.root_table(), - fbb.GetBufferPointer(), fbb.GetSize()), true); + fbb.GetBufferPointer(), fbb.GetSize()), + true); } void MiniReflectFlatBuffersTest(uint8_t *flatbuf) { auto s = flatbuffers::FlatBufferToString(flatbuf, MonsterTypeTable()); - TEST_EQ_STR(s.c_str(), - "{ " - "pos: { x: 1.0, y: 2.0, z: 3.0, test1: 0.0, test2: Red, test3: " + TEST_EQ_STR( + s.c_str(), + "{ " + "pos: { x: 1.0, y: 2.0, z: 3.0, test1: 0.0, test2: Red, test3: " "{ a: 10, b: 20 } }, " - "hp: 80, " - "name: \"MyMonster\", " - "inventory: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], " - "test_type: Monster, " - "test: { name: \"Fred\" }, " - "test4: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], " - "testarrayofstring: [ \"bob\", \"fred\", \"bob\", \"fred\" ], " - "testarrayoftables: [ { hp: 1000, name: \"Barney\" }, { name: \"Fred\" }, " + "hp: 80, " + "name: \"MyMonster\", " + "inventory: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], " + "test_type: Monster, " + "test: { name: \"Fred\" }, " + "test4: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], " + "testarrayofstring: [ \"bob\", \"fred\", \"bob\", \"fred\" ], " + "testarrayoftables: [ { hp: 1000, name: \"Barney\" }, { name: \"Fred\" " + "}, " "{ name: \"Wilma\" } ], " - // TODO(wvo): should really print this nested buffer correctly. - "testnestedflatbuffer: [ 20, 0, 0, 0, 77, 79, 78, 83, 12, 0, 12, 0, 0, 0, " + // TODO(wvo): should really print this nested buffer correctly. + "testnestedflatbuffer: [ 20, 0, 0, 0, 77, 79, 78, 83, 12, 0, 12, 0, 0, " + "0, " "4, 0, 6, 0, 8, 0, 12, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 13, 0, 0, 0, 78, " "101, 115, 116, 101, 100, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0 ], " - "testarrayofstring2: [ \"jane\", \"mary\" ], " - "testarrayofsortedstruct: [ { id: 1, distance: 10 }, " + "testarrayofstring2: [ \"jane\", \"mary\" ], " + "testarrayofsortedstruct: [ { id: 1, distance: 10 }, " "{ id: 2, distance: 20 }, { id: 3, distance: 30 }, " "{ id: 4, distance: 40 } ], " - "flex: [ 210, 4, 5, 2 ], " - "test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ] " - "}"); + "flex: [ 210, 4, 5, 2 ], " + "test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ] " + "}"); } // Parse a .proto schema, output as .fbs @@ -815,12 +823,14 @@ void ParseProtoTest() { // load the .proto and the golden file from disk std::string protofile; std::string goldenfile; - TEST_EQ(flatbuffers::LoadFile( - (test_data_path + "prototest/test.proto").c_str(), false, &protofile), - true); - TEST_EQ(flatbuffers::LoadFile( - (test_data_path + "prototest/test.golden").c_str(), false, &goldenfile), - true); + TEST_EQ( + flatbuffers::LoadFile((test_data_path + "prototest/test.proto").c_str(), + false, &protofile), + true); + TEST_EQ( + flatbuffers::LoadFile((test_data_path + "prototest/test.golden").c_str(), + false, &goldenfile), + true); flatbuffers::IDLOptions opts; opts.include_dependence_headers = false; @@ -841,9 +851,9 @@ void ParseProtoTest() { TEST_EQ_STR(fbs.c_str(), goldenfile.c_str()); } -template void CompareTableFieldValue(flatbuffers::Table *table, - flatbuffers::voffset_t voffset, - T val) { +template +void CompareTableFieldValue(flatbuffers::Table *table, + flatbuffers::voffset_t voffset, T val) { T read = table->GetField(voffset, static_cast(0)); TEST_EQ(read, val); } @@ -851,20 +861,19 @@ template void CompareTableFieldValue(flatbuffers::Table *table, // Low level stress/fuzz test: serialize/deserialize a variety of // different kinds of data in different combinations void FuzzTest1() { - // Values we're testing against: chosen to ensure no bits get chopped // off anywhere, and also be different from eachother. - const uint8_t bool_val = true; - const int8_t char_val = -127; // 0x81 - const uint8_t uchar_val = 0xFF; - const int16_t short_val = -32222; // 0x8222; + const uint8_t bool_val = true; + const int8_t char_val = -127; // 0x81 + const uint8_t uchar_val = 0xFF; + const int16_t short_val = -32222; // 0x8222; const uint16_t ushort_val = 0xFEEE; - const int32_t int_val = 0x83333333; - const uint32_t uint_val = 0xFDDDDDDD; - const int64_t long_val = 0x8444444444444444LL; - const uint64_t ulong_val = 0xFCCCCCCCCCCCCCCCULL; - const float float_val = 3.14159f; - const double double_val = 3.14159265359; + const int32_t int_val = 0x83333333; + const uint32_t uint_val = 0xFDDDDDDD; + const int64_t long_val = 0x8444444444444444LL; + const uint64_t ulong_val = 0xFCCCCCCCCCCCCCCCULL; + const float float_val = 3.14159f; + const double double_val = 3.14159265359; const int test_values_max = 11; const flatbuffers::voffset_t fields_per_object = 4; @@ -884,17 +893,17 @@ void FuzzTest1() { int choice = lcg_rand() % test_values_max; auto off = flatbuffers::FieldIndexToOffset(f); switch (choice) { - case 0: builder.AddElement(off, bool_val, 0); break; - case 1: builder.AddElement(off, char_val, 0); break; - case 2: builder.AddElement(off, uchar_val, 0); break; - case 3: builder.AddElement(off, short_val, 0); break; - case 4: builder.AddElement(off, ushort_val, 0); break; - case 5: builder.AddElement(off, int_val, 0); break; - case 6: builder.AddElement(off, uint_val, 0); break; - case 7: builder.AddElement(off, long_val, 0); break; - case 8: builder.AddElement(off, ulong_val, 0); break; - case 9: builder.AddElement(off, float_val, 0); break; - case 10: builder.AddElement(off, double_val, 0); break; + case 0: builder.AddElement(off, bool_val, 0); break; + case 1: builder.AddElement(off, char_val, 0); break; + case 2: builder.AddElement(off, uchar_val, 0); break; + case 3: builder.AddElement(off, short_val, 0); break; + case 4: builder.AddElement(off, ushort_val, 0); break; + case 5: builder.AddElement(off, int_val, 0); break; + case 6: builder.AddElement(off, uint_val, 0); break; + case 7: builder.AddElement(off, long_val, 0); break; + case 8: builder.AddElement(off, ulong_val, 0); break; + case 9: builder.AddElement(off, float_val, 0); break; + case 10: builder.AddElement(off, double_val, 0); break; } } objects[i] = builder.EndTable(start); @@ -914,16 +923,16 @@ void FuzzTest1() { int choice = lcg_rand() % test_values_max; flatbuffers::voffset_t off = flatbuffers::FieldIndexToOffset(f); switch (choice) { - case 0: CompareTableFieldValue(table, off, bool_val ); break; - case 1: CompareTableFieldValue(table, off, char_val ); break; - case 2: CompareTableFieldValue(table, off, uchar_val ); break; - case 3: CompareTableFieldValue(table, off, short_val ); break; - case 4: CompareTableFieldValue(table, off, ushort_val); break; - case 5: CompareTableFieldValue(table, off, int_val ); break; - case 6: CompareTableFieldValue(table, off, uint_val ); break; - case 7: CompareTableFieldValue(table, off, long_val ); break; - case 8: CompareTableFieldValue(table, off, ulong_val ); break; - case 9: CompareTableFieldValue(table, off, float_val ); break; + case 0: CompareTableFieldValue(table, off, bool_val); break; + case 1: CompareTableFieldValue(table, off, char_val); break; + case 2: CompareTableFieldValue(table, off, uchar_val); break; + case 3: CompareTableFieldValue(table, off, short_val); break; + case 4: CompareTableFieldValue(table, off, ushort_val); break; + case 5: CompareTableFieldValue(table, off, int_val); break; + case 6: CompareTableFieldValue(table, off, uint_val); break; + case 7: CompareTableFieldValue(table, off, long_val); break; + case 8: CompareTableFieldValue(table, off, ulong_val); break; + case 9: CompareTableFieldValue(table, off, float_val); break; case 10: CompareTableFieldValue(table, off, double_val); break; } } @@ -940,8 +949,8 @@ void FuzzTest2() { const int num_struct_definitions = 5; // Subset of num_definitions. const int fields_per_definition = 15; const int instances_per_definition = 5; - const int deprecation_rate = 10; // 1 in deprecation_rate fields will - // be deprecated. + const int deprecation_rate = 10; // 1 in deprecation_rate fields will + // be deprecated. std::string schema = "namespace test;\n\n"; @@ -951,8 +960,7 @@ void FuzzTest2() { // Since we're generating schema and corresponding data in tandem, // this convenience function adds strings to both at once. static void Add(RndDef (&definitions_l)[num_definitions], - std::string &schema_l, - const int instances_per_definition_l, + std::string &schema_l, const int instances_per_definition_l, const char *schema_add, const char *instance_add, int definition) { schema_l += schema_add; @@ -961,6 +969,7 @@ void FuzzTest2() { } }; + // clang-format off #define AddToSchemaAndInstances(schema_add, instance_add) \ RndDef::Add(definitions, schema, instances_per_definition, \ schema_add, instance_add, definition) @@ -968,6 +977,7 @@ void FuzzTest2() { #define Dummy() \ RndDef::Add(definitions, schema, instances_per_definition, \ "byte", "1", definition) + // clang-format on RndDef definitions[num_definitions]; @@ -985,8 +995,8 @@ void FuzzTest2() { bool is_struct = definition < num_struct_definitions; AddToSchemaAndInstances( - ((is_struct ? "struct " : "table ") + definition_name + " {\n").c_str(), - "{\n"); + ((is_struct ? "struct " : "table ") + definition_name + " {\n").c_str(), + "{\n"); for (int field = 0; field < fields_per_definition; field++) { const bool is_last_field = field == fields_per_definition - 1; @@ -994,16 +1004,15 @@ void FuzzTest2() { // Deprecate 1 in deprecation_rate fields. Only table fields can be // deprecated. // Don't deprecate the last field to avoid dangling commas in JSON. - const bool deprecated = !is_struct && - !is_last_field && - (lcg_rand() % deprecation_rate == 0); + const bool deprecated = + !is_struct && !is_last_field && (lcg_rand() % deprecation_rate == 0); std::string field_name = "f" + flatbuffers::NumToString(field); AddToSchemaAndInstances((" " + field_name + ":").c_str(), deprecated ? "" : (field_name + ": ").c_str()); // Pick random type: auto base_type = static_cast( - lcg_rand() % (flatbuffers::BASE_TYPE_UNION + 1)); + lcg_rand() % (flatbuffers::BASE_TYPE_UNION + 1)); switch (base_type) { case flatbuffers::BASE_TYPE_STRING: if (is_struct) { @@ -1015,8 +1024,7 @@ void FuzzTest2() { case flatbuffers::BASE_TYPE_VECTOR: if (is_struct) { Dummy(); // No vectors in structs. - } - else { + } else { AddToSchemaAndInstances("[ubyte]", deprecated ? "" : "[\n0,\n1,\n255\n]"); } @@ -1031,10 +1039,9 @@ void FuzzTest2() { int defref = lcg_rand() % definition; int instance = lcg_rand() % instances_per_definition; AddToSchemaAndInstances( - ("D" + flatbuffers::NumToString(defref)).c_str(), - deprecated - ? "" - : definitions[defref].instances[instance].c_str()); + ("D" + flatbuffers::NumToString(defref)).c_str(), + deprecated ? "" + : definitions[defref].instances[instance].c_str()); } else { // If this is the first definition, we have no definition we can // refer to. @@ -1042,9 +1049,8 @@ void FuzzTest2() { } break; case flatbuffers::BASE_TYPE_BOOL: - AddToSchemaAndInstances("bool", deprecated - ? "" - : (lcg_rand() % 2 ? "true" : "false")); + AddToSchemaAndInstances( + "bool", deprecated ? "" : (lcg_rand() % 2 ? "true" : "false")); break; default: // All the scalar types. @@ -1054,14 +1060,14 @@ void FuzzTest2() { // We want each instance to use its own random value. for (int inst = 0; inst < instances_per_definition; inst++) definitions[definition].instances[inst] += - flatbuffers::IsFloat(base_type) - ? flatbuffers::NumToString(lcg_rand() % 128).c_str() - : flatbuffers::NumToString(lcg_rand() % 128).c_str(); + flatbuffers::IsFloat(base_type) + ? flatbuffers::NumToString(lcg_rand() % 128) + .c_str() + : flatbuffers::NumToString(lcg_rand() % 128).c_str(); } } - AddToSchemaAndInstances( - deprecated ? "(deprecated);\n" : ";\n", - deprecated ? "" : is_last_field ? "\n" : ",\n"); + AddToSchemaAndInstances(deprecated ? "(deprecated);\n" : ";\n", + deprecated ? "" : is_last_field ? "\n" : ",\n"); } AddToSchemaAndInstances("}\n\n", "}"); } @@ -1079,13 +1085,14 @@ void FuzzTest2() { TEST_EQ(parser.Parse(schema.c_str()), true); const std::string &json = - definitions[num_definitions - 1].instances[0] + "\n"; + definitions[num_definitions - 1].instances[0] + "\n"; TEST_EQ(parser.Parse(json.c_str()), true); std::string jsongen; parser.opts.indent_step = 0; - auto result = GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); + auto result = + GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); TEST_EQ(result, true); if (jsongen != json) { @@ -1094,7 +1101,7 @@ void FuzzTest2() { size_t len = std::min(json.length(), jsongen.length()); for (size_t i = 0; i < len; i++) { if (json[i] != jsongen[i]) { - i -= std::min(static_cast(10), i); // show some context; + i -= std::min(static_cast(10), i); // show some context; size_t end = std::min(len, i + 20); for (; i < end; i++) TEST_OUTPUT_LINE("at %d: found \"%c\", expected \"%c\"\n", @@ -1105,11 +1112,13 @@ void FuzzTest2() { TEST_NOTNULL(NULL); } + // clang-format off #ifdef FLATBUFFERS_TEST_VERBOSE TEST_OUTPUT_LINE("%dk schema tested with %dk of json\n", static_cast(schema.length() / 1024), static_cast(json.length() / 1024)); #endif + // clang-format on } // Test that parser errors are actually generated. @@ -1148,8 +1157,10 @@ void ErrorTest() { TestError("table X { Y:int; } root_type X; { Y:", "string constant", true); TestError("table X { Y:int; } root_type X; { \"Y\":1, }", "string constant", true); - TestError("struct X { Y:int; Z:int; } table W { V:X; } root_type W; " - "{ V:{ Y:1 } }", "wrong number"); + TestError( + "struct X { Y:int; Z:int; } table W { V:X; } root_type W; " + "{ V:{ Y:1 } }", + "wrong number"); TestError("enum E:byte { A } table X { Y:E; } root_type X; { Y:U }", "unknown enum value"); TestError("table X { Y:byte; } root_type X; { Y:; }", "starting"); @@ -1177,11 +1188,13 @@ template T TestValue(const char *json, const char *type_name) { // Simple schema. TEST_EQ(parser.Parse(std::string("table X { Y:" + std::string(type_name) + - "; } root_type X;").c_str()), true); + "; } root_type X;") + .c_str()), + true); TEST_EQ(parser.Parse(json), true); auto root = flatbuffers::GetRoot( - parser.builder_.GetBufferPointer()); + parser.builder_.GetBufferPointer()); return root->GetField(flatbuffers::FieldIndexToOffset(0), 0); } @@ -1190,37 +1203,41 @@ bool FloatCompare(float a, float b) { return fabs(a - b) < 0.001; } // Additional parser testing not covered elsewhere. void ValueTest() { // Test scientific notation numbers. - TEST_EQ(FloatCompare(TestValue("{ Y:0.0314159e+2 }","float"), - (float)3.14159), true); + TEST_EQ(FloatCompare(TestValue("{ Y:0.0314159e+2 }", "float"), + (float)3.14159), + true); // Test conversion functions. - TEST_EQ(FloatCompare(TestValue("{ Y:cos(rad(180)) }","float"), -1), + TEST_EQ(FloatCompare(TestValue("{ Y:cos(rad(180)) }", "float"), -1), true); // Test negative hex constant. - TEST_EQ(TestValue("{ Y:-0x80 }","int"), -128); + TEST_EQ(TestValue("{ Y:-0x80 }", "int"), -128); // Make sure we do unsigned 64bit correctly. - TEST_EQ(TestValue("{ Y:12335089644688340133 }","ulong"), - 12335089644688340133ULL); + TEST_EQ(TestValue("{ Y:12335089644688340133 }", "ulong"), + 12335089644688340133ULL); } void NestedListTest() { flatbuffers::Parser parser1; TEST_EQ(parser1.Parse("struct Test { a:short; b:byte; } table T { F:[Test]; }" "root_type T;" - "{ F:[ [10,20], [30,40]] }"), true); + "{ F:[ [10,20], [30,40]] }"), + true); } void EnumStringsTest() { flatbuffers::Parser parser1; TEST_EQ(parser1.Parse("enum E:byte { A, B, C } table T { F:[E]; }" "root_type T;" - "{ F:[ A, B, \"C\", \"A B C\" ] }"), true); + "{ F:[ A, B, \"C\", \"A B C\" ] }"), + true); flatbuffers::Parser parser2; TEST_EQ(parser2.Parse("enum E:byte { A, B, C } table T { F:[int]; }" "root_type T;" - "{ F:[ \"E.C\", \"E.A E.B E.C\" ] }"), true); + "{ F:[ \"E.C\", \"E.A E.B E.C\" ] }"), + true); } void IntegerOutOfRangeTest() { @@ -1251,201 +1268,238 @@ void IntegerOutOfRangeTest() { } void IntegerBoundaryTest() { - TEST_EQ(TestValue("{ Y:127 }","byte"), 127); - TEST_EQ(TestValue("{ Y:-128 }","byte"), -128); - TEST_EQ(TestValue("{ Y:255 }","ubyte"), 255); - TEST_EQ(TestValue("{ Y:0 }","ubyte"), 0); - TEST_EQ(TestValue("{ Y:32767 }","short"), 32767); - TEST_EQ(TestValue("{ Y:-32768 }","short"), -32768); - TEST_EQ(TestValue("{ Y:65535 }","ushort"), 65535); - TEST_EQ(TestValue("{ Y:0 }","ushort"), 0); - TEST_EQ(TestValue("{ Y:2147483647 }","int"), 2147483647); - TEST_EQ(TestValue("{ Y:-2147483648 }","int"), (-2147483647 - 1)); - TEST_EQ(TestValue("{ Y:4294967295 }","uint"), 4294967295); - TEST_EQ(TestValue("{ Y:0 }","uint"), 0); - TEST_EQ(TestValue("{ Y:9223372036854775807 }","long"), 9223372036854775807); - TEST_EQ(TestValue("{ Y:-9223372036854775808 }","long"), (-9223372036854775807 - 1)); - TEST_EQ(TestValue("{ Y:18446744073709551615 }","ulong"), 18446744073709551615U); - TEST_EQ(TestValue("{ Y:0 }","ulong"), 0); + TEST_EQ(TestValue("{ Y:127 }", "byte"), 127); + TEST_EQ(TestValue("{ Y:-128 }", "byte"), -128); + TEST_EQ(TestValue("{ Y:255 }", "ubyte"), 255); + TEST_EQ(TestValue("{ Y:0 }", "ubyte"), 0); + TEST_EQ(TestValue("{ Y:32767 }", "short"), 32767); + TEST_EQ(TestValue("{ Y:-32768 }", "short"), -32768); + TEST_EQ(TestValue("{ Y:65535 }", "ushort"), 65535); + TEST_EQ(TestValue("{ Y:0 }", "ushort"), 0); + TEST_EQ(TestValue("{ Y:2147483647 }", "int"), 2147483647); + TEST_EQ(TestValue("{ Y:-2147483648 }", "int"), (-2147483647 - 1)); + TEST_EQ(TestValue("{ Y:4294967295 }", "uint"), 4294967295); + TEST_EQ(TestValue("{ Y:0 }", "uint"), 0); + TEST_EQ(TestValue("{ Y:9223372036854775807 }", "long"), + 9223372036854775807); + TEST_EQ(TestValue("{ Y:-9223372036854775808 }", "long"), + (-9223372036854775807 - 1)); + TEST_EQ(TestValue("{ Y:18446744073709551615 }", "ulong"), + 18446744073709551615U); + TEST_EQ(TestValue("{ Y:0 }", "ulong"), 0); } void UnicodeTest() { flatbuffers::Parser parser; - // Without setting allow_non_utf8 = true, we treat \x sequences as byte sequences - // which are then validated as UTF-8. + // Without setting allow_non_utf8 = true, we treat \x sequences as byte + // sequences which are then validated as UTF-8. TEST_EQ(parser.Parse("table T { F:string; }" "root_type T;" "{ F:\"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" - "\\u5225\\u30B5\\u30A4\\u30C8\\xE2\\x82\\xAC\\u0080\\uD83D\\uDE0E\" }"), + "\\u5225\\u30B5\\u30A4\\u30C8\\xE2\\x82\\xAC\\u0080\\uD8" + "3D\\uDE0E\" }"), true); std::string jsongen; parser.opts.indent_step = -1; - auto result = GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); + auto result = + GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); TEST_EQ(result, true); TEST_EQ_STR(jsongen.c_str(), - "{F: \"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" - "\\u5225\\u30B5\\u30A4\\u30C8\\u20AC\\u0080\\uD83D\\uDE0E\"}"); + "{F: \"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" + "\\u5225\\u30B5\\u30A4\\u30C8\\u20AC\\u0080\\uD83D\\uDE0E\"}"); } void UnicodeTestAllowNonUTF8() { flatbuffers::Parser parser; parser.opts.allow_non_utf8 = true; - TEST_EQ(parser.Parse("table T { F:string; }" - "root_type T;" - "{ F:\"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" - "\\u5225\\u30B5\\u30A4\\u30C8\\x01\\x80\\u0080\\uD83D\\uDE0E\" }"), true); + TEST_EQ( + parser.Parse( + "table T { F:string; }" + "root_type T;" + "{ F:\"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" + "\\u5225\\u30B5\\u30A4\\u30C8\\x01\\x80\\u0080\\uD83D\\uDE0E\" }"), + true); std::string jsongen; parser.opts.indent_step = -1; - auto result = GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); + auto result = + GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); TEST_EQ(result, true); - TEST_EQ_STR(jsongen.c_str(), - "{F: \"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" - "\\u5225\\u30B5\\u30A4\\u30C8\\u0001\\x80\\u0080\\uD83D\\uDE0E\"}"); + TEST_EQ_STR( + jsongen.c_str(), + "{F: \"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" + "\\u5225\\u30B5\\u30A4\\u30C8\\u0001\\x80\\u0080\\uD83D\\uDE0E\"}"); } void UnicodeTestGenerateTextFailsOnNonUTF8() { flatbuffers::Parser parser; - // Allow non-UTF-8 initially to model what happens when we load a binary flatbuffer from disk - // which contains non-UTF-8 strings. + // Allow non-UTF-8 initially to model what happens when we load a binary + // flatbuffer from disk which contains non-UTF-8 strings. parser.opts.allow_non_utf8 = true; - TEST_EQ(parser.Parse("table T { F:string; }" - "root_type T;" - "{ F:\"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" - "\\u5225\\u30B5\\u30A4\\u30C8\\x01\\x80\\u0080\\uD83D\\uDE0E\" }"), true); + TEST_EQ( + parser.Parse( + "table T { F:string; }" + "root_type T;" + "{ F:\"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC" + "\\u5225\\u30B5\\u30A4\\u30C8\\x01\\x80\\u0080\\uD83D\\uDE0E\" }"), + true); std::string jsongen; parser.opts.indent_step = -1; - // Now, disallow non-UTF-8 (the default behavior) so GenerateText indicates failure. + // Now, disallow non-UTF-8 (the default behavior) so GenerateText indicates + // failure. parser.opts.allow_non_utf8 = false; - auto result = GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); + auto result = + GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); TEST_EQ(result, false); } void UnicodeSurrogatesTest() { flatbuffers::Parser parser; - TEST_EQ( - parser.Parse( - "table T { F:string (id: 0); }" - "root_type T;" - "{ F:\"\\uD83D\\uDCA9\"}"), true); + TEST_EQ(parser.Parse("table T { F:string (id: 0); }" + "root_type T;" + "{ F:\"\\uD83D\\uDCA9\"}"), + true); auto root = flatbuffers::GetRoot( - parser.builder_.GetBufferPointer()); + parser.builder_.GetBufferPointer()); auto string = root->GetPointer( - flatbuffers::FieldIndexToOffset(0)); + flatbuffers::FieldIndexToOffset(0)); TEST_EQ_STR(string->c_str(), "\xF0\x9F\x92\xA9"); } void UnicodeInvalidSurrogatesTest() { TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\\uD800\"}", "unpaired high surrogate"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\\uD800\"}", + "unpaired high surrogate"); TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\\uD800abcd\"}", "unpaired high surrogate"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\\uD800abcd\"}", + "unpaired high surrogate"); TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\\uD800\\n\"}", "unpaired high surrogate"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\\uD800\\n\"}", + "unpaired high surrogate"); TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\\uD800\\uD800\"}", "multiple high surrogates"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\\uD800\\uD800\"}", + "multiple high surrogates"); TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\\uDC00\"}", "unpaired low surrogate"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\\uDC00\"}", + "unpaired low surrogate"); } void InvalidUTF8Test() { // "1 byte" pattern, under min length of 2 bytes TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\x80\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\x80\"}", + "illegal UTF-8 sequence"); // 2 byte pattern, string too short TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xDF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xDF\"}", + "illegal UTF-8 sequence"); // 3 byte pattern, string too short TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xEF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xEF\xBF\"}", + "illegal UTF-8 sequence"); // 4 byte pattern, string too short TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xF7\xBF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xF7\xBF\xBF\"}", + "illegal UTF-8 sequence"); // "5 byte" pattern, string too short TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xFB\xBF\xBF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xFB\xBF\xBF\xBF\"}", + "illegal UTF-8 sequence"); // "6 byte" pattern, string too short TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xFD\xBF\xBF\xBF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xFD\xBF\xBF\xBF\xBF\"}", + "illegal UTF-8 sequence"); // "7 byte" pattern, string too short TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xFE\xBF\xBF\xBF\xBF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xFE\xBF\xBF\xBF\xBF\xBF\"}", + "illegal UTF-8 sequence"); // "5 byte" pattern, over max length of 4 bytes TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xFB\xBF\xBF\xBF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xFB\xBF\xBF\xBF\xBF\"}", + "illegal UTF-8 sequence"); // "6 byte" pattern, over max length of 4 bytes TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xFD\xBF\xBF\xBF\xBF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xFD\xBF\xBF\xBF\xBF\xBF\"}", + "illegal UTF-8 sequence"); // "7 byte" pattern, over max length of 4 bytes TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xFE\xBF\xBF\xBF\xBF\xBF\xBF\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xFE\xBF\xBF\xBF\xBF\xBF\xBF\"}", + "illegal UTF-8 sequence"); // Three invalid encodings for U+000A (\n, aka NEWLINE) TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xC0\x8A\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xC0\x8A\"}", + "illegal UTF-8 sequence"); TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xE0\x80\x8A\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xE0\x80\x8A\"}", + "illegal UTF-8 sequence"); TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xF0\x80\x80\x8A\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xF0\x80\x80\x8A\"}", + "illegal UTF-8 sequence"); // Two invalid encodings for U+00A9 (COPYRIGHT SYMBOL) TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xE0\x81\xA9\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xE0\x81\xA9\"}", + "illegal UTF-8 sequence"); TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xF0\x80\x81\xA9\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xF0\x80\x81\xA9\"}", + "illegal UTF-8 sequence"); // Invalid encoding for U+20AC (EURO SYMBOL) TestError( - "table T { F:string; }" - "root_type T;" - "{ F:\"\xF0\x82\x82\xAC\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + "{ F:\"\xF0\x82\x82\xAC\"}", + "illegal UTF-8 sequence"); - // UTF-16 surrogate values between U+D800 and U+DFFF cannot be encoded in UTF-8 + // UTF-16 surrogate values between U+D800 and U+DFFF cannot be encoded in + // UTF-8 TestError( - "table T { F:string; }" - "root_type T;" - // U+10400 "encoded" as U+D801 U+DC00 - "{ F:\"\xED\xA0\x81\xED\xB0\x80\"}", "illegal UTF-8 sequence"); + "table T { F:string; }" + "root_type T;" + // U+10400 "encoded" as U+D801 U+DC00 + "{ F:\"\xED\xA0\x81\xED\xB0\x80\"}", + "illegal UTF-8 sequence"); } void UnknownFieldsTest() { @@ -1463,11 +1517,13 @@ void UnknownFieldsTest() { "unknown_array: [ 1, 2, 3, 4]," "unknown_object: { i: 10 }," "\"unknown_object\": { \"i\": 10 }," - "i:10}"), true); + "i:10}"), + true); std::string jsongen; parser.opts.indent_step = -1; - auto result = GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); + auto result = + GenerateText(parser, parser.builder_.GetBufferPointer(), &jsongen); TEST_EQ(result, true); TEST_EQ_STR(jsongen.c_str(), "{str: \"test\",i: 10}"); } @@ -1479,12 +1535,14 @@ void ParseUnionTest() { "union U { T }" "table V { X:U; }" "root_type V;" - "{ X:{ A:1 }, X_type: T }"), true); + "{ X:{ A:1 }, X_type: T }"), + true); // Unions must be parsable with prefixed namespace. flatbuffers::Parser parser2; TEST_EQ(parser2.Parse("namespace N; table A {} namespace; union U { N.A }" "table B { e:U; } root_type B;" - "{ e_type: N_A, e: {} }"), true); + "{ e_type: N_A, e: {} }"), + true); } void UnionVectorTest() { @@ -1492,8 +1550,9 @@ void UnionVectorTest() { // TODO: load a JSON file with such a vector when JSON support is ready. std::string schemafile; TEST_EQ(flatbuffers::LoadFile( - (test_data_path + "union_vector/union_vector.fbs").c_str(), false, - &schemafile), true); + (test_data_path + "union_vector/union_vector.fbs").c_str(), false, + &schemafile), + true); // parse schema. flatbuffers::IDLOptions idl_opts; @@ -1521,11 +1580,9 @@ void UnionVectorTest() { // create Movie. const auto movie_offset = - CreateMovie(fbb, - Character_Rapunzel, + CreateMovie(fbb, Character_Rapunzel, fbb.CreateStruct(Rapunzel(/*hair_length=*/6)).Union(), - fbb.CreateVector(types), - fbb.CreateVector(characters)); + fbb.CreateVector(types), fbb.CreateVector(characters)); FinishMovieBuffer(fbb, movie_offset); auto buf = fbb.GetBufferPointer(); @@ -1581,21 +1638,22 @@ void UnionVectorTest() { TestMovie(repacked_movie); - auto s = flatbuffers::FlatBufferToString(fbb.GetBufferPointer(), - MovieTypeTable()); - TEST_EQ_STR(s.c_str(), - "{ main_character_type: Rapunzel, main_character: { hair_length: 6 }, " - "characters_type: [ Belle, MuLan, BookFan, Other, Unused ], " - "characters: [ { books_read: 7 }, { sword_attack_damage: 5 }, " - "{ books_read: 2 }, \"Other\", \"Unused\" ] }"); + auto s = + flatbuffers::FlatBufferToString(fbb.GetBufferPointer(), MovieTypeTable()); + TEST_EQ_STR( + s.c_str(), + "{ main_character_type: Rapunzel, main_character: { hair_length: 6 }, " + "characters_type: [ Belle, MuLan, BookFan, Other, Unused ], " + "characters: [ { books_read: 7 }, { sword_attack_damage: 5 }, " + "{ books_read: 2 }, \"Other\", \"Unused\" ] }"); } void ConformTest() { flatbuffers::Parser parser; TEST_EQ(parser.Parse("table T { A:int; } enum E:byte { A }"), true); - auto test_conform = [](flatbuffers::Parser &parser1, - const char *test, const char *expected_err) { + auto test_conform = [](flatbuffers::Parser &parser1, const char *test, + const char *expected_err) { flatbuffers::Parser parser2; TEST_EQ(parser2.Parse(test), true); auto err = parser2.ConformTo(parser1); @@ -1617,14 +1675,14 @@ void ParseProtoBufAsciiTest() { // omits `,`, `:` before `{` and a couple of other features. flatbuffers::Parser parser; parser.opts.protobuf_ascii_alike = true; - TEST_EQ(parser.Parse( - "table S { B:int; } table T { A:[int]; C:S; } root_type T;"), true); + TEST_EQ( + parser.Parse("table S { B:int; } table T { A:[int]; C:S; } root_type T;"), + true); TEST_EQ(parser.Parse("{ A [1 2] C { B:2 }}"), true); // Similarly, in text output, it should omit these. std::string text; - auto ok = flatbuffers::GenerateText(parser, - parser.builder_.GetBufferPointer(), - &text); + auto ok = flatbuffers::GenerateText( + parser, parser.builder_.GetBufferPointer(), &text); TEST_EQ(ok, true); TEST_EQ_STR(text.c_str(), "{\n A [\n 1\n 2\n ]\n C {\n B: 2\n }\n}\n"); @@ -1635,7 +1693,9 @@ void FlexBuffersTest() { flexbuffers::BUILDER_FLAG_SHARE_KEYS_AND_STRINGS); // Write the equivalent of: - // { vec: [ -100, "Fred", 4.0, false ], bar: [ 1, 2, 3 ], bar3: [ 1, 2, 3 ], foo: 100, bool: true, mymap: { foo: "Fred" } } + // { vec: [ -100, "Fred", 4.0, false ], bar: [ 1, 2, 3 ], bar3: [ 1, 2, 3 ], + // foo: 100, bool: true, mymap: { foo: "Fred" } } + // clang-format off #ifndef FLATBUFFERS_CPP98_STL // It's possible to do this without std::function support as well. slb.Map([&]() { @@ -1687,6 +1747,7 @@ void FlexBuffersTest() { printf("%d ", flatbuffers::vector_data(slb.GetBuffer())[i]); printf("\n"); #endif + // clang-format on auto map = flexbuffers::GetRoot(slb.GetBuffer()).AsMap(); TEST_EQ(map.size(), 7); @@ -1697,7 +1758,7 @@ void FlexBuffersTest() { TEST_EQ(vec[1].AsInt64(), 0); // Number parsing failed. TEST_EQ(vec[2].AsDouble(), 4.0); TEST_EQ(vec[2].AsString().IsTheEmptyString(), true); // Wrong Type. - TEST_EQ_STR(vec[2].AsString().c_str(), ""); // This still works though. + TEST_EQ_STR(vec[2].AsString().c_str(), ""); // This still works though. TEST_EQ_STR(vec[2].ToString().c_str(), "4.0"); // Or have it converted. // Few tests for templated version of As. @@ -1711,7 +1772,7 @@ void FlexBuffersTest() { auto blob = vec[3].AsBlob(); TEST_EQ(blob.size(), 1); TEST_EQ(blob.data()[0], 77); - TEST_EQ(vec[4].IsBool(), true); // Check if type is a bool + TEST_EQ(vec[4].IsBool(), true); // Check if type is a bool TEST_EQ(vec[4].AsBool(), false); // Check if value is false auto tvec = map["bar"].AsTypedVector(); TEST_EQ(tvec.size(), 3); @@ -1737,46 +1798,42 @@ void FlexBuffersTest() { TEST_EQ(vec[2].MutateFloat(2.0f), true); TEST_EQ(vec[2].AsFloat(), 2.0f); TEST_EQ(vec[2].MutateFloat(3.14159), false); // Double does not fit in float. - TEST_EQ(vec[4].AsBool(), false); // Is false before change - TEST_EQ(vec[4].MutateBool(true), true); // Can change a bool - TEST_EQ(vec[4].AsBool(), true); // Changed bool is now true + TEST_EQ(vec[4].AsBool(), false); // Is false before change + TEST_EQ(vec[4].MutateBool(true), true); // Can change a bool + TEST_EQ(vec[4].AsBool(), true); // Changed bool is now true // Parse from JSON: flatbuffers::Parser parser; slb.Clear(); auto jsontest = "{ a: [ 123, 456.0 ], b: \"hello\", c: true, d: false }"; - TEST_EQ(parser.ParseFlexBuffer(jsontest, nullptr, &slb), - true); + TEST_EQ(parser.ParseFlexBuffer(jsontest, nullptr, &slb), true); auto jroot = flexbuffers::GetRoot(slb.GetBuffer()); auto jmap = jroot.AsMap(); auto jvec = jmap["a"].AsVector(); TEST_EQ(jvec[0].AsInt64(), 123); TEST_EQ(jvec[1].AsDouble(), 456.0); TEST_EQ_STR(jmap["b"].AsString().c_str(), "hello"); - TEST_EQ(jmap["c"].IsBool(), true); // Parsed correctly to a bool - TEST_EQ(jmap["c"].AsBool(), true); // Parsed correctly to true - TEST_EQ(jmap["d"].IsBool(), true); // Parsed correctly to a bool - TEST_EQ(jmap["d"].AsBool(), false); // Parsed correctly to false + TEST_EQ(jmap["c"].IsBool(), true); // Parsed correctly to a bool + TEST_EQ(jmap["c"].AsBool(), true); // Parsed correctly to true + TEST_EQ(jmap["d"].IsBool(), true); // Parsed correctly to a bool + TEST_EQ(jmap["d"].AsBool(), false); // Parsed correctly to false // And from FlexBuffer back to JSON: auto jsonback = jroot.ToString(); TEST_EQ_STR(jsontest, jsonback.c_str()); } -void TypeAliasesTest() -{ +void TypeAliasesTest() { flatbuffers::FlatBufferBuilder builder; builder.Finish(CreateTypeAliases( - builder, - flatbuffers::numeric_limits::min(), + builder, flatbuffers::numeric_limits::min(), flatbuffers::numeric_limits::max(), flatbuffers::numeric_limits::min(), flatbuffers::numeric_limits::max(), flatbuffers::numeric_limits::min(), flatbuffers::numeric_limits::max(), flatbuffers::numeric_limits::min(), - flatbuffers::numeric_limits::max(), - 2.3f, 2.3)); + flatbuffers::numeric_limits::max(), 2.3f, 2.3)); auto p = builder.GetBufferPointer(); auto ta = flatbuffers::GetRoot(p); @@ -1804,8 +1861,7 @@ void TypeAliasesTest() } void EndianSwapTest() { - TEST_EQ(flatbuffers::EndianSwap(static_cast(0x1234)), - 0x3412); + TEST_EQ(flatbuffers::EndianSwap(static_cast(0x1234)), 0x3412); TEST_EQ(flatbuffers::EndianSwap(static_cast(0x12345678)), 0x78563412); TEST_EQ(flatbuffers::EndianSwap(static_cast(0x1234567890ABCDEF)), @@ -1813,7 +1869,8 @@ void EndianSwapTest() { TEST_EQ(flatbuffers::EndianSwap(flatbuffers::EndianSwap(3.14f)), 3.14f); } -int main(int /*argc*/, const char * /*argv*/[]) { +int main(int /*argc*/, const char * /*argv*/ []) { + // clang-format off #if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING) && \ defined(_MSC_VER) && defined(_DEBUG) _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF @@ -1856,6 +1913,7 @@ int main(int /*argc*/, const char * /*argv*/[]) { ParseProtoTest(); UnionVectorTest(); #endif + // clang-format on FuzzTest1(); FuzzTest2(); diff --git a/tests/union_vector/union_vector_generated.ts b/tests/union_vector/union_vector_generated.ts index 65cf15b6d..62e310541 100644 --- a/tests/union_vector/union_vector_generated.ts +++ b/tests/union_vector/union_vector_generated.ts @@ -20,7 +20,7 @@ export class Attacker { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -50,8 +50,8 @@ static getRootAsAttacker(bb:flatbuffers.ByteBuffer, obj?:Attacker):Attacker { * @returns {number} */ swordAttackDamage():number { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; }; /** @@ -59,13 +59,13 @@ swordAttackDamage():number { * @returns {boolean} */ mutate_sword_attack_damage(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -101,7 +101,7 @@ export class Rapunzel { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -122,7 +122,7 @@ __init(i:number, bb:flatbuffers.ByteBuffer):Rapunzel { * @returns {number} */ hairLength():number { - return this.bb!.readInt32(this.bb_pos); + return this.bb.readInt32(this.bb_pos); }; /** @@ -130,13 +130,13 @@ hairLength():number { * @returns {boolean} */ mutate_hair_length(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 0); + var offset = this.bb.__offset(this.bb_pos, 0); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -159,7 +159,7 @@ export class BookReader { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -180,7 +180,7 @@ __init(i:number, bb:flatbuffers.ByteBuffer):BookReader { * @returns {number} */ booksRead():number { - return this.bb!.readInt32(this.bb_pos); + return this.bb.readInt32(this.bb_pos); }; /** @@ -188,13 +188,13 @@ booksRead():number { * @returns {boolean} */ mutate_books_read(value:number):boolean { - var offset = this.bb!.__offset(this.bb_pos, 0); + var offset = this.bb.__offset(this.bb_pos, 0); if (offset === 0) { return false; } - this.bb!.writeInt32(this.bb_pos + offset, value); + this.bb.writeInt32(this.bb_pos + offset, value); return true; }; @@ -217,7 +217,7 @@ export class Movie { /** * @type {flatbuffers.ByteBuffer} */ - bb: flatbuffers.ByteBuffer|null = null; + bb: flatbuffers.ByteBuffer; /** * @type {number} @@ -255,8 +255,8 @@ static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean { * @returns {Character} */ mainCharacterType():Character { - var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? /** @type {Character} */ (this.bb!.readUint8(this.bb_pos + offset)) : Character.NONE; + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? /** @type {Character} */ (this.bb.readUint8(this.bb_pos + offset)) : Character.NONE; }; /** @@ -264,13 +264,13 @@ mainCharacterType():Character { * @returns {boolean} */ mutate_main_character_type(value:Character):boolean { - var offset = this.bb!.__offset(this.bb_pos, 4); + var offset = this.bb.__offset(this.bb_pos, 4); if (offset === 0) { return false; } - this.bb!.writeUint8(this.bb_pos + offset, value); + this.bb.writeUint8(this.bb_pos + offset, value); return true; }; @@ -279,8 +279,8 @@ mutate_main_character_type(value:Character):boolean { * @returns {?flatbuffers.Table} */ mainCharacter(obj:T):T|null { - var offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__union(obj, this.bb_pos + offset) : null; }; /** @@ -288,24 +288,24 @@ mainCharacter(obj:T):T|null { * @returns {Character} */ charactersType(index: number):Character|null { - var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? /** @type {Character} */ (this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index)) : /** @type {Character} */ (0); + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? /** @type {Character} */ (this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index)) : /** @type {Character} */ (0); }; /** * @returns {number} */ charactersTypeLength():number { - var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /** * @returns {Uint8Array} */ charactersTypeArray():Uint8Array|null { - var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; }; /** @@ -314,16 +314,16 @@ charactersTypeArray():Uint8Array|null { * @returns {?flatbuffers.Table} */ characters(index: number, obj:T):T|null { - var offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.__union(obj, this.bb!.__vector(this.bb_pos + offset) + index * 4) : null; + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__union(obj, this.bb.__vector(this.bb_pos + offset) + index * 4) : null; }; /** * @returns {number} */ charactersLength():number { - var offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; /**