Line data    Source code

       1             : // automatically generated by the FlatBuffers compiler, do not modify
       2             : 
       3             : 
       4             : #ifndef FLATBUFFERS_GENERATED_MANIFEST_GENERATED_H_
       5             : #define FLATBUFFERS_GENERATED_MANIFEST_GENERATED_H_
       6             : 
       7             : #include "flatbuffers/flatbuffers.h"
       8             : 
       9             : // Ensure the included flatbuffers.h is the same version as when this file was
      10             : // generated, otherwise it may not be compatible.
      11             : static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
      12             :               FLATBUFFERS_VERSION_MINOR == 0 &&
      13             :               FLATBUFFERS_VERSION_REVISION == 8,
      14             :              "Non-compatible flatbuffers version included");
      15             : 
      16             : #include "common_generated.h"
      17             : 
      18             : namespace generated {
      19             : 
      20             : struct ChunkRef;
      21             : struct ChunkRefBuilder;
      22             : 
      23             : struct ArrayManifest;
      24             : struct ArrayManifestBuilder;
      25             : 
      26             : struct Manifest;
      27             : struct ManifestBuilder;
      28             : 
      29             : struct ChunkRef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
      30             :   typedef ChunkRefBuilder Builder;
      31             :   struct Traits;
      32             :   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
      33             :     VT_INDEX = 4,
      34             :     VT_INLINE_ = 6,
      35             :     VT_OFFSET = 8,
      36             :     VT_LENGTH = 10,
      37             :     VT_CHUNK_ID = 12,
      38             :     VT_LOCATION = 14,
      39             :     VT_CHECKSUM_ETAG = 16,
      40             :     VT_CHECKSUM_LAST_MODIFIED = 18,
      41             :     VT_COMPRESSED_LOCATION = 20,
      42             :     VT_EXTRA = 22
      43             :   };
      44       25292 :   const flatbuffers::Vector<uint32_t> *index() const {
      45       25292 :     return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INDEX);
      46             :   }
      47       25289 :   const flatbuffers::Vector<uint8_t> *inline_() const {
      48       25289 :     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INLINE_);
      49             :   }
      50       12644 :   uint64_t offset() const {
      51       12644 :     return GetField<uint64_t>(VT_OFFSET, 0);
      52             :   }
      53       12644 :   uint64_t length() const {
      54       12644 :     return GetField<uint64_t>(VT_LENGTH, 0);
      55             :   }
      56       12642 :   const generated::ObjectId12 *chunk_id() const {
      57       12642 :     return GetStruct<const generated::ObjectId12 *>(VT_CHUNK_ID);
      58             :   }
      59       25288 :   const flatbuffers::String *location() const {
      60       25288 :     return GetPointer<const flatbuffers::String *>(VT_LOCATION);
      61             :   }
      62       25289 :   const flatbuffers::String *checksum_etag() const {
      63       25289 :     return GetPointer<const flatbuffers::String *>(VT_CHECKSUM_ETAG);
      64             :   }
      65       12643 :   uint32_t checksum_last_modified() const {
      66       12643 :     return GetField<uint32_t>(VT_CHECKSUM_LAST_MODIFIED, 0);
      67             :   }
      68       25288 :   const flatbuffers::Vector<uint8_t> *compressed_location() const {
      69       25288 :     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_COMPRESSED_LOCATION);
      70             :   }
      71       12646 :   const flatbuffers::Vector<uint8_t> *extra() const {
      72       12646 :     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTRA);
      73             :   }
      74       12646 :   bool Verify(flatbuffers::Verifier &verifier) const {
      75       12646 :     return VerifyTableStart(verifier) &&
      76       12646 :            VerifyOffsetRequired(verifier, VT_INDEX) &&
      77       12646 :            verifier.VerifyVector(index()) &&
      78       12646 :            VerifyOffset(verifier, VT_INLINE_) &&
      79       12646 :            verifier.VerifyVector(inline_()) &&
      80       12646 :            VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
      81       12646 :            VerifyField<uint64_t>(verifier, VT_LENGTH, 8) &&
      82       12646 :            VerifyField<generated::ObjectId12>(verifier, VT_CHUNK_ID, 1) &&
      83       12646 :            VerifyOffset(verifier, VT_LOCATION) &&
      84       12646 :            verifier.VerifyString(location()) &&
      85       12646 :            VerifyOffset(verifier, VT_CHECKSUM_ETAG) &&
      86       12646 :            verifier.VerifyString(checksum_etag()) &&
      87       12646 :            VerifyField<uint32_t>(verifier, VT_CHECKSUM_LAST_MODIFIED, 4) &&
      88       12646 :            VerifyOffset(verifier, VT_COMPRESSED_LOCATION) &&
      89       12646 :            verifier.VerifyVector(compressed_location()) &&
      90       12646 :            VerifyOffset(verifier, VT_EXTRA) &&
      91       37938 :            verifier.VerifyVector(extra()) &&
      92       25292 :            verifier.EndTable();
      93             :   }
      94             : };
      95             : 
      96             : struct ChunkRefBuilder {
      97             :   typedef ChunkRef Table;
      98             :   flatbuffers::FlatBufferBuilder &fbb_;
      99             :   flatbuffers::uoffset_t start_;
     100             :   void add_index(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> index) {
     101             :     fbb_.AddOffset(ChunkRef::VT_INDEX, index);
     102             :   }
     103             :   void add_inline_(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inline_) {
     104             :     fbb_.AddOffset(ChunkRef::VT_INLINE_, inline_);
     105             :   }
     106             :   void add_offset(uint64_t offset) {
     107             :     fbb_.AddElement<uint64_t>(ChunkRef::VT_OFFSET, offset, 0);
     108             :   }
     109             :   void add_length(uint64_t length) {
     110             :     fbb_.AddElement<uint64_t>(ChunkRef::VT_LENGTH, length, 0);
     111             :   }
     112             :   void add_chunk_id(const generated::ObjectId12 *chunk_id) {
     113             :     fbb_.AddStruct(ChunkRef::VT_CHUNK_ID, chunk_id);
     114             :   }
     115             :   void add_location(flatbuffers::Offset<flatbuffers::String> location) {
     116             :     fbb_.AddOffset(ChunkRef::VT_LOCATION, location);
     117             :   }
     118             :   void add_checksum_etag(flatbuffers::Offset<flatbuffers::String> checksum_etag) {
     119             :     fbb_.AddOffset(ChunkRef::VT_CHECKSUM_ETAG, checksum_etag);
     120             :   }
     121             :   void add_checksum_last_modified(uint32_t checksum_last_modified) {
     122             :     fbb_.AddElement<uint32_t>(ChunkRef::VT_CHECKSUM_LAST_MODIFIED, checksum_last_modified, 0);
     123             :   }
     124             :   void add_compressed_location(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> compressed_location) {
     125             :     fbb_.AddOffset(ChunkRef::VT_COMPRESSED_LOCATION, compressed_location);
     126             :   }
     127             :   void add_extra(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra) {
     128             :     fbb_.AddOffset(ChunkRef::VT_EXTRA, extra);
     129             :   }
     130             :   explicit ChunkRefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
     131             :         : fbb_(_fbb) {
     132             :     start_ = fbb_.StartTable();
     133             :   }
     134             :   flatbuffers::Offset<ChunkRef> Finish() {
     135             :     const auto end = fbb_.EndTable(start_);
     136             :     auto o = flatbuffers::Offset<ChunkRef>(end);
     137             :     fbb_.Required(o, ChunkRef::VT_INDEX);
     138             :     return o;
     139             :   }
     140             : };
     141             : 
     142             : inline flatbuffers::Offset<ChunkRef> CreateChunkRef(
     143             :     flatbuffers::FlatBufferBuilder &_fbb,
     144             :     flatbuffers::Offset<flatbuffers::Vector<uint32_t>> index = 0,
     145             :     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inline_ = 0,
     146             :     uint64_t offset = 0,
     147             :     uint64_t length = 0,
     148             :     const generated::ObjectId12 *chunk_id = nullptr,
     149             :     flatbuffers::Offset<flatbuffers::String> location = 0,
     150             :     flatbuffers::Offset<flatbuffers::String> checksum_etag = 0,
     151             :     uint32_t checksum_last_modified = 0,
     152             :     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> compressed_location = 0,
     153             :     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra = 0) {
     154             :   ChunkRefBuilder builder_(_fbb);
     155             :   builder_.add_length(length);
     156             :   builder_.add_offset(offset);
     157             :   builder_.add_extra(extra);
     158             :   builder_.add_compressed_location(compressed_location);
     159             :   builder_.add_checksum_last_modified(checksum_last_modified);
     160             :   builder_.add_checksum_etag(checksum_etag);
     161             :   builder_.add_location(location);
     162             :   builder_.add_chunk_id(chunk_id);
     163             :   builder_.add_inline_(inline_);
     164             :   builder_.add_index(index);
     165             :   return builder_.Finish();
     166             : }
     167             : 
     168             : struct ChunkRef::Traits {
     169             :   using type = ChunkRef;
     170             :   static auto constexpr Create = CreateChunkRef;
     171             : };
     172             : 
     173             : inline flatbuffers::Offset<ChunkRef> CreateChunkRefDirect(
     174             :     flatbuffers::FlatBufferBuilder &_fbb,
     175             :     const std::vector<uint32_t> *index = nullptr,
     176             :     const std::vector<uint8_t> *inline_ = nullptr,
     177             :     uint64_t offset = 0,
     178             :     uint64_t length = 0,
     179             :     const generated::ObjectId12 *chunk_id = nullptr,
     180             :     const char *location = nullptr,
     181             :     const char *checksum_etag = nullptr,
     182             :     uint32_t checksum_last_modified = 0,
     183             :     const std::vector<uint8_t> *compressed_location = nullptr,
     184             :     const std::vector<uint8_t> *extra = nullptr) {
     185             :   auto index__ = index ? _fbb.CreateVector<uint32_t>(*index) : 0;
     186             :   auto inline___ = inline_ ? _fbb.CreateVector<uint8_t>(*inline_) : 0;
     187             :   auto location__ = location ? _fbb.CreateString(location) : 0;
     188             :   auto checksum_etag__ = checksum_etag ? _fbb.CreateString(checksum_etag) : 0;
     189             :   auto compressed_location__ = compressed_location ? _fbb.CreateVector<uint8_t>(*compressed_location) : 0;
     190             :   auto extra__ = extra ? _fbb.CreateVector<uint8_t>(*extra) : 0;
     191             :   return generated::CreateChunkRef(
     192             :       _fbb,
     193             :       index__,
     194             :       inline___,
     195             :       offset,
     196             :       length,
     197             :       chunk_id,
     198             :       location__,
     199             :       checksum_etag__,
     200             :       checksum_last_modified,
     201             :       compressed_location__,
     202             :       extra__);
     203             : }
     204             : 
     205             : struct ArrayManifest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     206             :   typedef ArrayManifestBuilder Builder;
     207             :   struct Traits;
     208             :   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     209             :     VT_NODE_ID = 4,
     210             :     VT_REFS = 6,
     211             :     VT_EXTRA = 8
     212             :   };
     213        2092 :   const generated::ObjectId8 *node_id() const {
     214        2092 :     return GetStruct<const generated::ObjectId8 *>(VT_NODE_ID);
     215             :   }
     216        6275 :   const flatbuffers::Vector<flatbuffers::Offset<generated::ChunkRef>> *refs() const {
     217        6275 :     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::ChunkRef>> *>(VT_REFS);
     218             :   }
     219        2092 :   const flatbuffers::Vector<uint8_t> *extra() const {
     220        2092 :     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTRA);
     221             :   }
     222        2092 :   bool Verify(flatbuffers::Verifier &verifier) const {
     223        2092 :     return VerifyTableStart(verifier) &&
     224        2092 :            VerifyFieldRequired<generated::ObjectId8>(verifier, VT_NODE_ID, 1) &&
     225        2092 :            VerifyOffsetRequired(verifier, VT_REFS) &&
     226        2092 :            verifier.VerifyVector(refs()) &&
     227        2092 :            verifier.VerifyVectorOfTables(refs()) &&
     228        2092 :            VerifyOffset(verifier, VT_EXTRA) &&
     229        6276 :            verifier.VerifyVector(extra()) &&
     230        4184 :            verifier.EndTable();
     231             :   }
     232             : };
     233             : 
     234             : struct ArrayManifestBuilder {
     235             :   typedef ArrayManifest Table;
     236             :   flatbuffers::FlatBufferBuilder &fbb_;
     237             :   flatbuffers::uoffset_t start_;
     238             :   void add_node_id(const generated::ObjectId8 *node_id) {
     239             :     fbb_.AddStruct(ArrayManifest::VT_NODE_ID, node_id);
     240             :   }
     241             :   void add_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ChunkRef>>> refs) {
     242             :     fbb_.AddOffset(ArrayManifest::VT_REFS, refs);
     243             :   }
     244             :   void add_extra(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra) {
     245             :     fbb_.AddOffset(ArrayManifest::VT_EXTRA, extra);
     246             :   }
     247             :   explicit ArrayManifestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
     248             :         : fbb_(_fbb) {
     249             :     start_ = fbb_.StartTable();
     250             :   }
     251             :   flatbuffers::Offset<ArrayManifest> Finish() {
     252             :     const auto end = fbb_.EndTable(start_);
     253             :     auto o = flatbuffers::Offset<ArrayManifest>(end);
     254             :     fbb_.Required(o, ArrayManifest::VT_NODE_ID);
     255             :     fbb_.Required(o, ArrayManifest::VT_REFS);
     256             :     return o;
     257             :   }
     258             : };
     259             : 
     260             : inline flatbuffers::Offset<ArrayManifest> CreateArrayManifest(
     261             :     flatbuffers::FlatBufferBuilder &_fbb,
     262             :     const generated::ObjectId8 *node_id = nullptr,
     263             :     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ChunkRef>>> refs = 0,
     264             :     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra = 0) {
     265             :   ArrayManifestBuilder builder_(_fbb);
     266             :   builder_.add_extra(extra);
     267             :   builder_.add_refs(refs);
     268             :   builder_.add_node_id(node_id);
     269             :   return builder_.Finish();
     270             : }
     271             : 
     272             : struct ArrayManifest::Traits {
     273             :   using type = ArrayManifest;
     274             :   static auto constexpr Create = CreateArrayManifest;
     275             : };
     276             : 
     277             : inline flatbuffers::Offset<ArrayManifest> CreateArrayManifestDirect(
     278             :     flatbuffers::FlatBufferBuilder &_fbb,
     279             :     const generated::ObjectId8 *node_id = nullptr,
     280             :     const std::vector<flatbuffers::Offset<generated::ChunkRef>> *refs = nullptr,
     281             :     const std::vector<uint8_t> *extra = nullptr) {
     282             :   auto refs__ = refs ? _fbb.CreateVector<flatbuffers::Offset<generated::ChunkRef>>(*refs) : 0;
     283             :   auto extra__ = extra ? _fbb.CreateVector<uint8_t>(*extra) : 0;
     284             :   return generated::CreateArrayManifest(
     285             :       _fbb,
     286             :       node_id,
     287             :       refs__,
     288             :       extra__);
     289             : }
     290             : 
     291             : struct Manifest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     292             :   typedef ManifestBuilder Builder;
     293             :   struct Traits;
     294             :   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     295             :     VT_ID = 4,
     296             :     VT_ARRAYS = 6,
     297             :     VT_LOCATION_DICTIONARY = 8,
     298             :     VT_COMPRESSION_ALGORITHM = 10,
     299             :     VT_EXTRA = 12
     300             :   };
     301        2094 :   const generated::ObjectId12 *id() const {
     302        2094 :     return GetStruct<const generated::ObjectId12 *>(VT_ID);
     303             :   }
     304        6279 :   const flatbuffers::Vector<flatbuffers::Offset<generated::ArrayManifest>> *arrays() const {
     305        6279 :     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::ArrayManifest>> *>(VT_ARRAYS);
     306             :   }
     307        2107 :   const flatbuffers::Vector<uint8_t> *location_dictionary() const {
     308        2107 :     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LOCATION_DICTIONARY);
     309             :   }
     310        2091 :   uint8_t compression_algorithm() const {
     311        2091 :     return GetField<uint8_t>(VT_COMPRESSION_ALGORITHM, 1);
     312             :   }
     313        2094 :   const flatbuffers::Vector<uint8_t> *extra() const {
     314        2094 :     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTRA);
     315             :   }
     316        2094 :   bool Verify(flatbuffers::Verifier &verifier) const {
     317        2094 :     return VerifyTableStart(verifier) &&
     318        2094 :            VerifyFieldRequired<generated::ObjectId12>(verifier, VT_ID, 1) &&
     319        2094 :            VerifyOffsetRequired(verifier, VT_ARRAYS) &&
     320        2094 :            verifier.VerifyVector(arrays()) &&
     321        2094 :            verifier.VerifyVectorOfTables(arrays()) &&
     322        2094 :            VerifyOffset(verifier, VT_LOCATION_DICTIONARY) &&
     323        2094 :            verifier.VerifyVector(location_dictionary()) &&
     324        2094 :            VerifyField<uint8_t>(verifier, VT_COMPRESSION_ALGORITHM, 1) &&
     325        2094 :            VerifyOffset(verifier, VT_EXTRA) &&
     326        6282 :            verifier.VerifyVector(extra()) &&
     327        4188 :            verifier.EndTable();
     328             :   }
     329             : };
     330             : 
     331             : struct ManifestBuilder {
     332             :   typedef Manifest Table;
     333             :   flatbuffers::FlatBufferBuilder &fbb_;
     334             :   flatbuffers::uoffset_t start_;
     335             :   void add_id(const generated::ObjectId12 *id) {
     336             :     fbb_.AddStruct(Manifest::VT_ID, id);
     337             :   }
     338             :   void add_arrays(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ArrayManifest>>> arrays) {
     339             :     fbb_.AddOffset(Manifest::VT_ARRAYS, arrays);
     340             :   }
     341             :   void add_location_dictionary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> location_dictionary) {
     342             :     fbb_.AddOffset(Manifest::VT_LOCATION_DICTIONARY, location_dictionary);
     343             :   }
     344             :   void add_compression_algorithm(uint8_t compression_algorithm) {
     345             :     fbb_.AddElement<uint8_t>(Manifest::VT_COMPRESSION_ALGORITHM, compression_algorithm, 1);
     346             :   }
     347             :   void add_extra(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra) {
     348             :     fbb_.AddOffset(Manifest::VT_EXTRA, extra);
     349             :   }
     350             :   explicit ManifestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
     351             :         : fbb_(_fbb) {
     352             :     start_ = fbb_.StartTable();
     353             :   }
     354             :   flatbuffers::Offset<Manifest> Finish() {
     355             :     const auto end = fbb_.EndTable(start_);
     356             :     auto o = flatbuffers::Offset<Manifest>(end);
     357             :     fbb_.Required(o, Manifest::VT_ID);
     358             :     fbb_.Required(o, Manifest::VT_ARRAYS);
     359             :     return o;
     360             :   }
     361             : };
     362             : 
     363             : inline flatbuffers::Offset<Manifest> CreateManifest(
     364             :     flatbuffers::FlatBufferBuilder &_fbb,
     365             :     const generated::ObjectId12 *id = nullptr,
     366             :     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ArrayManifest>>> arrays = 0,
     367             :     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> location_dictionary = 0,
     368             :     uint8_t compression_algorithm = 1,
     369             :     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra = 0) {
     370             :   ManifestBuilder builder_(_fbb);
     371             :   builder_.add_extra(extra);
     372             :   builder_.add_location_dictionary(location_dictionary);
     373             :   builder_.add_arrays(arrays);
     374             :   builder_.add_id(id);
     375             :   builder_.add_compression_algorithm(compression_algorithm);
     376             :   return builder_.Finish();
     377             : }
     378             : 
     379             : struct Manifest::Traits {
     380             :   using type = Manifest;
     381             :   static auto constexpr Create = CreateManifest;
     382             : };
     383             : 
     384             : inline flatbuffers::Offset<Manifest> CreateManifestDirect(
     385             :     flatbuffers::FlatBufferBuilder &_fbb,
     386             :     const generated::ObjectId12 *id = nullptr,
     387             :     const std::vector<flatbuffers::Offset<generated::ArrayManifest>> *arrays = nullptr,
     388             :     const std::vector<uint8_t> *location_dictionary = nullptr,
     389             :     uint8_t compression_algorithm = 1,
     390             :     const std::vector<uint8_t> *extra = nullptr) {
     391             :   auto arrays__ = arrays ? _fbb.CreateVector<flatbuffers::Offset<generated::ArrayManifest>>(*arrays) : 0;
     392             :   auto location_dictionary__ = location_dictionary ? _fbb.CreateVector<uint8_t>(*location_dictionary) : 0;
     393             :   auto extra__ = extra ? _fbb.CreateVector<uint8_t>(*extra) : 0;
     394             :   return generated::CreateManifest(
     395             :       _fbb,
     396             :       id,
     397             :       arrays__,
     398             :       location_dictionary__,
     399             :       compression_algorithm,
     400             :       extra__);
     401             : }
     402             : 
     403        2094 : inline const generated::Manifest *GetManifest(const void *buf) {
     404        2094 :   return flatbuffers::GetRoot<generated::Manifest>(buf);
     405             : }
     406             : 
     407             : inline const generated::Manifest *GetSizePrefixedManifest(const void *buf) {
     408             :   return flatbuffers::GetSizePrefixedRoot<generated::Manifest>(buf);
     409             : }
     410             : 
     411        2095 : inline bool VerifyManifestBuffer(
     412             :     flatbuffers::Verifier &verifier) {
     413        2095 :   return verifier.VerifyBuffer<generated::Manifest>(nullptr);
     414             : }
     415             : 
     416             : inline bool VerifySizePrefixedManifestBuffer(
     417             :     flatbuffers::Verifier &verifier) {
     418             :   return verifier.VerifySizePrefixedBuffer<generated::Manifest>(nullptr);
     419             : }
     420             : 
     421             : inline void FinishManifestBuffer(
     422             :     flatbuffers::FlatBufferBuilder &fbb,
     423             :     flatbuffers::Offset<generated::Manifest> root) {
     424             :   fbb.Finish(root);
     425             : }
     426             : 
     427             : inline void FinishSizePrefixedManifestBuffer(
     428             :     flatbuffers::FlatBufferBuilder &fbb,
     429             :     flatbuffers::Offset<generated::Manifest> root) {
     430             :   fbb.FinishSizePrefixed(root);
     431             : }
     432             : 
     433             : }  // namespace generated
     434             : 
     435             : #endif  // FLATBUFFERS_GENERATED_MANIFEST_GENERATED_H_