1 // automatically generated by the FlatBuffers compiler, do not modify
2 
3 
4 #ifndef FLATBUFFERS_GENERATED_HEADER_FLATGEOBUF_H_
5 #define FLATBUFFERS_GENERATED_HEADER_FLATGEOBUF_H_
6 
7 #include "flatbuffers/flatbuffers.h"
8 
9 namespace FlatGeobuf {
10 
11 struct Column;
12 struct ColumnBuilder;
13 
14 struct Crs;
15 struct CrsBuilder;
16 
17 struct Header;
18 struct HeaderBuilder;
19 
20 enum class GeometryType : uint8_t {
21   Unknown = 0,
22   Point = 1,
23   LineString = 2,
24   Polygon = 3,
25   MultiPoint = 4,
26   MultiLineString = 5,
27   MultiPolygon = 6,
28   GeometryCollection = 7,
29   CircularString = 8,
30   CompoundCurve = 9,
31   CurvePolygon = 10,
32   MultiCurve = 11,
33   MultiSurface = 12,
34   Curve = 13,
35   Surface = 14,
36   PolyhedralSurface = 15,
37   TIN = 16,
38   Triangle = 17,
39   MIN = Unknown,
40   MAX = Triangle
41 };
42 
EnumValuesGeometryType()43 inline const GeometryType (&EnumValuesGeometryType())[18] {
44   static const GeometryType values[] = {
45     GeometryType::Unknown,
46     GeometryType::Point,
47     GeometryType::LineString,
48     GeometryType::Polygon,
49     GeometryType::MultiPoint,
50     GeometryType::MultiLineString,
51     GeometryType::MultiPolygon,
52     GeometryType::GeometryCollection,
53     GeometryType::CircularString,
54     GeometryType::CompoundCurve,
55     GeometryType::CurvePolygon,
56     GeometryType::MultiCurve,
57     GeometryType::MultiSurface,
58     GeometryType::Curve,
59     GeometryType::Surface,
60     GeometryType::PolyhedralSurface,
61     GeometryType::TIN,
62     GeometryType::Triangle
63   };
64   return values;
65 }
66 
EnumNamesGeometryType()67 inline const char * const *EnumNamesGeometryType() {
68   static const char * const names[19] = {
69     "Unknown",
70     "Point",
71     "LineString",
72     "Polygon",
73     "MultiPoint",
74     "MultiLineString",
75     "MultiPolygon",
76     "GeometryCollection",
77     "CircularString",
78     "CompoundCurve",
79     "CurvePolygon",
80     "MultiCurve",
81     "MultiSurface",
82     "Curve",
83     "Surface",
84     "PolyhedralSurface",
85     "TIN",
86     "Triangle",
87     nullptr
88   };
89   return names;
90 }
91 
EnumNameGeometryType(GeometryType e)92 inline const char *EnumNameGeometryType(GeometryType e) {
93   if (flatbuffers::IsOutRange(e, GeometryType::Unknown, GeometryType::Triangle)) return "";
94   const size_t index = static_cast<size_t>(e);
95   return EnumNamesGeometryType()[index];
96 }
97 
98 enum class ColumnType : uint8_t {
99   Byte = 0,
100   UByte = 1,
101   Bool = 2,
102   Short = 3,
103   UShort = 4,
104   Int = 5,
105   UInt = 6,
106   Long = 7,
107   ULong = 8,
108   Float = 9,
109   Double = 10,
110   String = 11,
111   Json = 12,
112   DateTime = 13,
113   Binary = 14,
114   MIN = Byte,
115   MAX = Binary
116 };
117 
EnumValuesColumnType()118 inline const ColumnType (&EnumValuesColumnType())[15] {
119   static const ColumnType values[] = {
120     ColumnType::Byte,
121     ColumnType::UByte,
122     ColumnType::Bool,
123     ColumnType::Short,
124     ColumnType::UShort,
125     ColumnType::Int,
126     ColumnType::UInt,
127     ColumnType::Long,
128     ColumnType::ULong,
129     ColumnType::Float,
130     ColumnType::Double,
131     ColumnType::String,
132     ColumnType::Json,
133     ColumnType::DateTime,
134     ColumnType::Binary
135   };
136   return values;
137 }
138 
EnumNamesColumnType()139 inline const char * const *EnumNamesColumnType() {
140   static const char * const names[16] = {
141     "Byte",
142     "UByte",
143     "Bool",
144     "Short",
145     "UShort",
146     "Int",
147     "UInt",
148     "Long",
149     "ULong",
150     "Float",
151     "Double",
152     "String",
153     "Json",
154     "DateTime",
155     "Binary",
156     nullptr
157   };
158   return names;
159 }
160 
EnumNameColumnType(ColumnType e)161 inline const char *EnumNameColumnType(ColumnType e) {
162   if (flatbuffers::IsOutRange(e, ColumnType::Byte, ColumnType::Binary)) return "";
163   const size_t index = static_cast<size_t>(e);
164   return EnumNamesColumnType()[index];
165 }
166 
167 struct Column FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
168   typedef ColumnBuilder Builder;
169   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
170     VT_NAME = 4,
171     VT_TYPE = 6,
172     VT_TITLE = 8,
173     VT_DESCRIPTION = 10,
174     VT_WIDTH = 12,
175     VT_PRECISION = 14,
176     VT_SCALE = 16,
177     VT_NULLABLE = 18,
178     VT_UNIQUE = 20,
179     VT_PRIMARY_KEY = 22,
180     VT_METADATA = 24
181   };
nameFLATBUFFERS_FINAL_CLASS182   const flatbuffers::String *name() const {
183     return GetPointer<const flatbuffers::String *>(VT_NAME);
184   }
typeFLATBUFFERS_FINAL_CLASS185   FlatGeobuf::ColumnType type() const {
186     return static_cast<FlatGeobuf::ColumnType>(GetField<uint8_t>(VT_TYPE, 0));
187   }
titleFLATBUFFERS_FINAL_CLASS188   const flatbuffers::String *title() const {
189     return GetPointer<const flatbuffers::String *>(VT_TITLE);
190   }
descriptionFLATBUFFERS_FINAL_CLASS191   const flatbuffers::String *description() const {
192     return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
193   }
widthFLATBUFFERS_FINAL_CLASS194   int32_t width() const {
195     return GetField<int32_t>(VT_WIDTH, -1);
196   }
precisionFLATBUFFERS_FINAL_CLASS197   int32_t precision() const {
198     return GetField<int32_t>(VT_PRECISION, -1);
199   }
scaleFLATBUFFERS_FINAL_CLASS200   int32_t scale() const {
201     return GetField<int32_t>(VT_SCALE, -1);
202   }
nullableFLATBUFFERS_FINAL_CLASS203   bool nullable() const {
204     return GetField<uint8_t>(VT_NULLABLE, 1) != 0;
205   }
uniqueFLATBUFFERS_FINAL_CLASS206   bool unique() const {
207     return GetField<uint8_t>(VT_UNIQUE, 0) != 0;
208   }
primary_keyFLATBUFFERS_FINAL_CLASS209   bool primary_key() const {
210     return GetField<uint8_t>(VT_PRIMARY_KEY, 0) != 0;
211   }
metadataFLATBUFFERS_FINAL_CLASS212   const flatbuffers::String *metadata() const {
213     return GetPointer<const flatbuffers::String *>(VT_METADATA);
214   }
VerifyFLATBUFFERS_FINAL_CLASS215   bool Verify(flatbuffers::Verifier &verifier) const {
216     return VerifyTableStart(verifier) &&
217            VerifyOffsetRequired(verifier, VT_NAME) &&
218            verifier.VerifyString(name()) &&
219            VerifyField<uint8_t>(verifier, VT_TYPE) &&
220            VerifyOffset(verifier, VT_TITLE) &&
221            verifier.VerifyString(title()) &&
222            VerifyOffset(verifier, VT_DESCRIPTION) &&
223            verifier.VerifyString(description()) &&
224            VerifyField<int32_t>(verifier, VT_WIDTH) &&
225            VerifyField<int32_t>(verifier, VT_PRECISION) &&
226            VerifyField<int32_t>(verifier, VT_SCALE) &&
227            VerifyField<uint8_t>(verifier, VT_NULLABLE) &&
228            VerifyField<uint8_t>(verifier, VT_UNIQUE) &&
229            VerifyField<uint8_t>(verifier, VT_PRIMARY_KEY) &&
230            VerifyOffset(verifier, VT_METADATA) &&
231            verifier.VerifyString(metadata()) &&
232            verifier.EndTable();
233   }
234 };
235 
236 struct ColumnBuilder {
237   typedef Column Table;
238   flatbuffers::FlatBufferBuilder &fbb_;
239   flatbuffers::uoffset_t start_;
add_nameColumnBuilder240   void add_name(flatbuffers::Offset<flatbuffers::String> name) {
241     fbb_.AddOffset(Column::VT_NAME, name);
242   }
add_typeColumnBuilder243   void add_type(FlatGeobuf::ColumnType type) {
244     fbb_.AddElement<uint8_t>(Column::VT_TYPE, static_cast<uint8_t>(type), 0);
245   }
add_titleColumnBuilder246   void add_title(flatbuffers::Offset<flatbuffers::String> title) {
247     fbb_.AddOffset(Column::VT_TITLE, title);
248   }
add_descriptionColumnBuilder249   void add_description(flatbuffers::Offset<flatbuffers::String> description) {
250     fbb_.AddOffset(Column::VT_DESCRIPTION, description);
251   }
add_widthColumnBuilder252   void add_width(int32_t width) {
253     fbb_.AddElement<int32_t>(Column::VT_WIDTH, width, -1);
254   }
add_precisionColumnBuilder255   void add_precision(int32_t precision) {
256     fbb_.AddElement<int32_t>(Column::VT_PRECISION, precision, -1);
257   }
add_scaleColumnBuilder258   void add_scale(int32_t scale) {
259     fbb_.AddElement<int32_t>(Column::VT_SCALE, scale, -1);
260   }
add_nullableColumnBuilder261   void add_nullable(bool nullable) {
262     fbb_.AddElement<uint8_t>(Column::VT_NULLABLE, static_cast<uint8_t>(nullable), 1);
263   }
add_uniqueColumnBuilder264   void add_unique(bool unique) {
265     fbb_.AddElement<uint8_t>(Column::VT_UNIQUE, static_cast<uint8_t>(unique), 0);
266   }
add_primary_keyColumnBuilder267   void add_primary_key(bool primary_key) {
268     fbb_.AddElement<uint8_t>(Column::VT_PRIMARY_KEY, static_cast<uint8_t>(primary_key), 0);
269   }
add_metadataColumnBuilder270   void add_metadata(flatbuffers::Offset<flatbuffers::String> metadata) {
271     fbb_.AddOffset(Column::VT_METADATA, metadata);
272   }
ColumnBuilderColumnBuilder273   explicit ColumnBuilder(flatbuffers::FlatBufferBuilder &_fbb)
274         : fbb_(_fbb) {
275     start_ = fbb_.StartTable();
276   }
277   ColumnBuilder &operator=(const ColumnBuilder &);
FinishColumnBuilder278   flatbuffers::Offset<Column> Finish() {
279     const auto end = fbb_.EndTable(start_);
280     auto o = flatbuffers::Offset<Column>(end);
281     fbb_.Required(o, Column::VT_NAME);
282     return o;
283   }
284 };
285 
286 inline flatbuffers::Offset<Column> CreateColumn(
287     flatbuffers::FlatBufferBuilder &_fbb,
288     flatbuffers::Offset<flatbuffers::String> name = 0,
289     FlatGeobuf::ColumnType type = FlatGeobuf::ColumnType::Byte,
290     flatbuffers::Offset<flatbuffers::String> title = 0,
291     flatbuffers::Offset<flatbuffers::String> description = 0,
292     int32_t width = -1,
293     int32_t precision = -1,
294     int32_t scale = -1,
295     bool nullable = true,
296     bool unique = false,
297     bool primary_key = false,
298     flatbuffers::Offset<flatbuffers::String> metadata = 0) {
299   ColumnBuilder builder_(_fbb);
300   builder_.add_metadata(metadata);
301   builder_.add_scale(scale);
302   builder_.add_precision(precision);
303   builder_.add_width(width);
304   builder_.add_description(description);
305   builder_.add_title(title);
306   builder_.add_name(name);
307   builder_.add_primary_key(primary_key);
308   builder_.add_unique(unique);
309   builder_.add_nullable(nullable);
310   builder_.add_type(type);
311   return builder_.Finish();
312 }
313 
314 inline flatbuffers::Offset<Column> CreateColumnDirect(
315     flatbuffers::FlatBufferBuilder &_fbb,
316     const char *name = nullptr,
317     FlatGeobuf::ColumnType type = FlatGeobuf::ColumnType::Byte,
318     const char *title = nullptr,
319     const char *description = nullptr,
320     int32_t width = -1,
321     int32_t precision = -1,
322     int32_t scale = -1,
323     bool nullable = true,
324     bool unique = false,
325     bool primary_key = false,
326     const char *metadata = nullptr) {
327   auto name__ = name ? _fbb.CreateString(name) : 0;
328   auto title__ = title ? _fbb.CreateString(title) : 0;
329   auto description__ = description ? _fbb.CreateString(description) : 0;
330   auto metadata__ = metadata ? _fbb.CreateString(metadata) : 0;
331   return FlatGeobuf::CreateColumn(
332       _fbb,
333       name__,
334       type,
335       title__,
336       description__,
337       width,
338       precision,
339       scale,
340       nullable,
341       unique,
342       primary_key,
343       metadata__);
344 }
345 
346 struct Crs FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
347   typedef CrsBuilder Builder;
348   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
349     VT_ORG = 4,
350     VT_CODE = 6,
351     VT_NAME = 8,
352     VT_DESCRIPTION = 10,
353     VT_WKT = 12,
354     VT_CODE_STRING = 14
355   };
orgFLATBUFFERS_FINAL_CLASS356   const flatbuffers::String *org() const {
357     return GetPointer<const flatbuffers::String *>(VT_ORG);
358   }
codeFLATBUFFERS_FINAL_CLASS359   int32_t code() const {
360     return GetField<int32_t>(VT_CODE, 0);
361   }
nameFLATBUFFERS_FINAL_CLASS362   const flatbuffers::String *name() const {
363     return GetPointer<const flatbuffers::String *>(VT_NAME);
364   }
descriptionFLATBUFFERS_FINAL_CLASS365   const flatbuffers::String *description() const {
366     return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
367   }
wktFLATBUFFERS_FINAL_CLASS368   const flatbuffers::String *wkt() const {
369     return GetPointer<const flatbuffers::String *>(VT_WKT);
370   }
code_stringFLATBUFFERS_FINAL_CLASS371   const flatbuffers::String *code_string() const {
372     return GetPointer<const flatbuffers::String *>(VT_CODE_STRING);
373   }
VerifyFLATBUFFERS_FINAL_CLASS374   bool Verify(flatbuffers::Verifier &verifier) const {
375     return VerifyTableStart(verifier) &&
376            VerifyOffset(verifier, VT_ORG) &&
377            verifier.VerifyString(org()) &&
378            VerifyField<int32_t>(verifier, VT_CODE) &&
379            VerifyOffset(verifier, VT_NAME) &&
380            verifier.VerifyString(name()) &&
381            VerifyOffset(verifier, VT_DESCRIPTION) &&
382            verifier.VerifyString(description()) &&
383            VerifyOffset(verifier, VT_WKT) &&
384            verifier.VerifyString(wkt()) &&
385            VerifyOffset(verifier, VT_CODE_STRING) &&
386            verifier.VerifyString(code_string()) &&
387            verifier.EndTable();
388   }
389 };
390 
391 struct CrsBuilder {
392   typedef Crs Table;
393   flatbuffers::FlatBufferBuilder &fbb_;
394   flatbuffers::uoffset_t start_;
add_orgCrsBuilder395   void add_org(flatbuffers::Offset<flatbuffers::String> org) {
396     fbb_.AddOffset(Crs::VT_ORG, org);
397   }
add_codeCrsBuilder398   void add_code(int32_t code) {
399     fbb_.AddElement<int32_t>(Crs::VT_CODE, code, 0);
400   }
add_nameCrsBuilder401   void add_name(flatbuffers::Offset<flatbuffers::String> name) {
402     fbb_.AddOffset(Crs::VT_NAME, name);
403   }
add_descriptionCrsBuilder404   void add_description(flatbuffers::Offset<flatbuffers::String> description) {
405     fbb_.AddOffset(Crs::VT_DESCRIPTION, description);
406   }
add_wktCrsBuilder407   void add_wkt(flatbuffers::Offset<flatbuffers::String> wkt) {
408     fbb_.AddOffset(Crs::VT_WKT, wkt);
409   }
add_code_stringCrsBuilder410   void add_code_string(flatbuffers::Offset<flatbuffers::String> code_string) {
411     fbb_.AddOffset(Crs::VT_CODE_STRING, code_string);
412   }
CrsBuilderCrsBuilder413   explicit CrsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
414         : fbb_(_fbb) {
415     start_ = fbb_.StartTable();
416   }
417   CrsBuilder &operator=(const CrsBuilder &);
FinishCrsBuilder418   flatbuffers::Offset<Crs> Finish() {
419     const auto end = fbb_.EndTable(start_);
420     auto o = flatbuffers::Offset<Crs>(end);
421     return o;
422   }
423 };
424 
425 inline flatbuffers::Offset<Crs> CreateCrs(
426     flatbuffers::FlatBufferBuilder &_fbb,
427     flatbuffers::Offset<flatbuffers::String> org = 0,
428     int32_t code = 0,
429     flatbuffers::Offset<flatbuffers::String> name = 0,
430     flatbuffers::Offset<flatbuffers::String> description = 0,
431     flatbuffers::Offset<flatbuffers::String> wkt = 0,
432     flatbuffers::Offset<flatbuffers::String> code_string = 0) {
433   CrsBuilder builder_(_fbb);
434   builder_.add_code_string(code_string);
435   builder_.add_wkt(wkt);
436   builder_.add_description(description);
437   builder_.add_name(name);
438   builder_.add_code(code);
439   builder_.add_org(org);
440   return builder_.Finish();
441 }
442 
443 inline flatbuffers::Offset<Crs> CreateCrsDirect(
444     flatbuffers::FlatBufferBuilder &_fbb,
445     const char *org = nullptr,
446     int32_t code = 0,
447     const char *name = nullptr,
448     const char *description = nullptr,
449     const char *wkt = nullptr,
450     const char *code_string = nullptr) {
451   auto org__ = org ? _fbb.CreateString(org) : 0;
452   auto name__ = name ? _fbb.CreateString(name) : 0;
453   auto description__ = description ? _fbb.CreateString(description) : 0;
454   auto wkt__ = wkt ? _fbb.CreateString(wkt) : 0;
455   auto code_string__ = code_string ? _fbb.CreateString(code_string) : 0;
456   return FlatGeobuf::CreateCrs(
457       _fbb,
458       org__,
459       code,
460       name__,
461       description__,
462       wkt__,
463       code_string__);
464 }
465 
466 struct Header FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
467   typedef HeaderBuilder Builder;
468   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
469     VT_NAME = 4,
470     VT_ENVELOPE = 6,
471     VT_GEOMETRY_TYPE = 8,
472     VT_HASZ = 10,
473     VT_HASM = 12,
474     VT_HAST = 14,
475     VT_HASTM = 16,
476     VT_COLUMNS = 18,
477     VT_FEATURES_COUNT = 20,
478     VT_INDEX_NODE_SIZE = 22,
479     VT_CRS = 24,
480     VT_TITLE = 26,
481     VT_DESCRIPTION = 28,
482     VT_METADATA = 30
483   };
nameFLATBUFFERS_FINAL_CLASS484   const flatbuffers::String *name() const {
485     return GetPointer<const flatbuffers::String *>(VT_NAME);
486   }
envelopeFLATBUFFERS_FINAL_CLASS487   const flatbuffers::Vector<double> *envelope() const {
488     return GetPointer<const flatbuffers::Vector<double> *>(VT_ENVELOPE);
489   }
geometry_typeFLATBUFFERS_FINAL_CLASS490   FlatGeobuf::GeometryType geometry_type() const {
491     return static_cast<FlatGeobuf::GeometryType>(GetField<uint8_t>(VT_GEOMETRY_TYPE, 0));
492   }
hasZFLATBUFFERS_FINAL_CLASS493   bool hasZ() const {
494     return GetField<uint8_t>(VT_HASZ, 0) != 0;
495   }
hasMFLATBUFFERS_FINAL_CLASS496   bool hasM() const {
497     return GetField<uint8_t>(VT_HASM, 0) != 0;
498   }
hasTFLATBUFFERS_FINAL_CLASS499   bool hasT() const {
500     return GetField<uint8_t>(VT_HAST, 0) != 0;
501   }
hasTMFLATBUFFERS_FINAL_CLASS502   bool hasTM() const {
503     return GetField<uint8_t>(VT_HASTM, 0) != 0;
504   }
columnsFLATBUFFERS_FINAL_CLASS505   const flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Column>> *columns() const {
506     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Column>> *>(VT_COLUMNS);
507   }
features_countFLATBUFFERS_FINAL_CLASS508   uint64_t features_count() const {
509     return GetField<uint64_t>(VT_FEATURES_COUNT, 0);
510   }
index_node_sizeFLATBUFFERS_FINAL_CLASS511   uint16_t index_node_size() const {
512     return GetField<uint16_t>(VT_INDEX_NODE_SIZE, 16);
513   }
crsFLATBUFFERS_FINAL_CLASS514   const FlatGeobuf::Crs *crs() const {
515     return GetPointer<const FlatGeobuf::Crs *>(VT_CRS);
516   }
titleFLATBUFFERS_FINAL_CLASS517   const flatbuffers::String *title() const {
518     return GetPointer<const flatbuffers::String *>(VT_TITLE);
519   }
descriptionFLATBUFFERS_FINAL_CLASS520   const flatbuffers::String *description() const {
521     return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
522   }
metadataFLATBUFFERS_FINAL_CLASS523   const flatbuffers::String *metadata() const {
524     return GetPointer<const flatbuffers::String *>(VT_METADATA);
525   }
VerifyFLATBUFFERS_FINAL_CLASS526   bool Verify(flatbuffers::Verifier &verifier) const {
527     return VerifyTableStart(verifier) &&
528            VerifyOffset(verifier, VT_NAME) &&
529            verifier.VerifyString(name()) &&
530            VerifyOffset(verifier, VT_ENVELOPE) &&
531            verifier.VerifyVector(envelope()) &&
532            VerifyField<uint8_t>(verifier, VT_GEOMETRY_TYPE) &&
533            VerifyField<uint8_t>(verifier, VT_HASZ) &&
534            VerifyField<uint8_t>(verifier, VT_HASM) &&
535            VerifyField<uint8_t>(verifier, VT_HAST) &&
536            VerifyField<uint8_t>(verifier, VT_HASTM) &&
537            VerifyOffset(verifier, VT_COLUMNS) &&
538            verifier.VerifyVector(columns()) &&
539            verifier.VerifyVectorOfTables(columns()) &&
540            VerifyField<uint64_t>(verifier, VT_FEATURES_COUNT) &&
541            VerifyField<uint16_t>(verifier, VT_INDEX_NODE_SIZE) &&
542            VerifyOffset(verifier, VT_CRS) &&
543            verifier.VerifyTable(crs()) &&
544            VerifyOffset(verifier, VT_TITLE) &&
545            verifier.VerifyString(title()) &&
546            VerifyOffset(verifier, VT_DESCRIPTION) &&
547            verifier.VerifyString(description()) &&
548            VerifyOffset(verifier, VT_METADATA) &&
549            verifier.VerifyString(metadata()) &&
550            verifier.EndTable();
551   }
552 };
553 
554 struct HeaderBuilder {
555   typedef Header Table;
556   flatbuffers::FlatBufferBuilder &fbb_;
557   flatbuffers::uoffset_t start_;
add_nameHeaderBuilder558   void add_name(flatbuffers::Offset<flatbuffers::String> name) {
559     fbb_.AddOffset(Header::VT_NAME, name);
560   }
add_envelopeHeaderBuilder561   void add_envelope(flatbuffers::Offset<flatbuffers::Vector<double>> envelope) {
562     fbb_.AddOffset(Header::VT_ENVELOPE, envelope);
563   }
add_geometry_typeHeaderBuilder564   void add_geometry_type(FlatGeobuf::GeometryType geometry_type) {
565     fbb_.AddElement<uint8_t>(Header::VT_GEOMETRY_TYPE, static_cast<uint8_t>(geometry_type), 0);
566   }
add_hasZHeaderBuilder567   void add_hasZ(bool hasZ) {
568     fbb_.AddElement<uint8_t>(Header::VT_HASZ, static_cast<uint8_t>(hasZ), 0);
569   }
add_hasMHeaderBuilder570   void add_hasM(bool hasM) {
571     fbb_.AddElement<uint8_t>(Header::VT_HASM, static_cast<uint8_t>(hasM), 0);
572   }
add_hasTHeaderBuilder573   void add_hasT(bool hasT) {
574     fbb_.AddElement<uint8_t>(Header::VT_HAST, static_cast<uint8_t>(hasT), 0);
575   }
add_hasTMHeaderBuilder576   void add_hasTM(bool hasTM) {
577     fbb_.AddElement<uint8_t>(Header::VT_HASTM, static_cast<uint8_t>(hasTM), 0);
578   }
add_columnsHeaderBuilder579   void add_columns(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Column>>> columns) {
580     fbb_.AddOffset(Header::VT_COLUMNS, columns);
581   }
add_features_countHeaderBuilder582   void add_features_count(uint64_t features_count) {
583     fbb_.AddElement<uint64_t>(Header::VT_FEATURES_COUNT, features_count, 0);
584   }
add_index_node_sizeHeaderBuilder585   void add_index_node_size(uint16_t index_node_size) {
586     fbb_.AddElement<uint16_t>(Header::VT_INDEX_NODE_SIZE, index_node_size, 16);
587   }
add_crsHeaderBuilder588   void add_crs(flatbuffers::Offset<FlatGeobuf::Crs> crs) {
589     fbb_.AddOffset(Header::VT_CRS, crs);
590   }
add_titleHeaderBuilder591   void add_title(flatbuffers::Offset<flatbuffers::String> title) {
592     fbb_.AddOffset(Header::VT_TITLE, title);
593   }
add_descriptionHeaderBuilder594   void add_description(flatbuffers::Offset<flatbuffers::String> description) {
595     fbb_.AddOffset(Header::VT_DESCRIPTION, description);
596   }
add_metadataHeaderBuilder597   void add_metadata(flatbuffers::Offset<flatbuffers::String> metadata) {
598     fbb_.AddOffset(Header::VT_METADATA, metadata);
599   }
HeaderBuilderHeaderBuilder600   explicit HeaderBuilder(flatbuffers::FlatBufferBuilder &_fbb)
601         : fbb_(_fbb) {
602     start_ = fbb_.StartTable();
603   }
604   HeaderBuilder &operator=(const HeaderBuilder &);
FinishHeaderBuilder605   flatbuffers::Offset<Header> Finish() {
606     const auto end = fbb_.EndTable(start_);
607     auto o = flatbuffers::Offset<Header>(end);
608     return o;
609   }
610 };
611 
612 inline flatbuffers::Offset<Header> CreateHeader(
613     flatbuffers::FlatBufferBuilder &_fbb,
614     flatbuffers::Offset<flatbuffers::String> name = 0,
615     flatbuffers::Offset<flatbuffers::Vector<double>> envelope = 0,
616     FlatGeobuf::GeometryType geometry_type = FlatGeobuf::GeometryType::Unknown,
617     bool hasZ = false,
618     bool hasM = false,
619     bool hasT = false,
620     bool hasTM = false,
621     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Column>>> columns = 0,
622     uint64_t features_count = 0,
623     uint16_t index_node_size = 16,
624     flatbuffers::Offset<FlatGeobuf::Crs> crs = 0,
625     flatbuffers::Offset<flatbuffers::String> title = 0,
626     flatbuffers::Offset<flatbuffers::String> description = 0,
627     flatbuffers::Offset<flatbuffers::String> metadata = 0) {
628   HeaderBuilder builder_(_fbb);
629   builder_.add_features_count(features_count);
630   builder_.add_metadata(metadata);
631   builder_.add_description(description);
632   builder_.add_title(title);
633   builder_.add_crs(crs);
634   builder_.add_columns(columns);
635   builder_.add_envelope(envelope);
636   builder_.add_name(name);
637   builder_.add_index_node_size(index_node_size);
638   builder_.add_hasTM(hasTM);
639   builder_.add_hasT(hasT);
640   builder_.add_hasM(hasM);
641   builder_.add_hasZ(hasZ);
642   builder_.add_geometry_type(geometry_type);
643   return builder_.Finish();
644 }
645 
646 inline flatbuffers::Offset<Header> CreateHeaderDirect(
647     flatbuffers::FlatBufferBuilder &_fbb,
648     const char *name = nullptr,
649     const std::vector<double> *envelope = nullptr,
650     FlatGeobuf::GeometryType geometry_type = FlatGeobuf::GeometryType::Unknown,
651     bool hasZ = false,
652     bool hasM = false,
653     bool hasT = false,
654     bool hasTM = false,
655     const std::vector<flatbuffers::Offset<FlatGeobuf::Column>> *columns = nullptr,
656     uint64_t features_count = 0,
657     uint16_t index_node_size = 16,
658     flatbuffers::Offset<FlatGeobuf::Crs> crs = 0,
659     const char *title = nullptr,
660     const char *description = nullptr,
661     const char *metadata = nullptr) {
662   auto name__ = name ? _fbb.CreateString(name) : 0;
663   auto envelope__ = envelope ? _fbb.CreateVector<double>(*envelope) : 0;
664   auto columns__ = columns ? _fbb.CreateVector<flatbuffers::Offset<FlatGeobuf::Column>>(*columns) : 0;
665   auto title__ = title ? _fbb.CreateString(title) : 0;
666   auto description__ = description ? _fbb.CreateString(description) : 0;
667   auto metadata__ = metadata ? _fbb.CreateString(metadata) : 0;
668   return FlatGeobuf::CreateHeader(
669       _fbb,
670       name__,
671       envelope__,
672       geometry_type,
673       hasZ,
674       hasM,
675       hasT,
676       hasTM,
677       columns__,
678       features_count,
679       index_node_size,
680       crs,
681       title__,
682       description__,
683       metadata__);
684 }
685 
GetHeader(const void * buf)686 inline const FlatGeobuf::Header *GetHeader(const void *buf) {
687   return flatbuffers::GetRoot<FlatGeobuf::Header>(buf);
688 }
689 
GetSizePrefixedHeader(const void * buf)690 inline const FlatGeobuf::Header *GetSizePrefixedHeader(const void *buf) {
691   return flatbuffers::GetSizePrefixedRoot<FlatGeobuf::Header>(buf);
692 }
693 
VerifyHeaderBuffer(flatbuffers::Verifier & verifier)694 inline bool VerifyHeaderBuffer(
695     flatbuffers::Verifier &verifier) {
696   return verifier.VerifyBuffer<FlatGeobuf::Header>(nullptr);
697 }
698 
VerifySizePrefixedHeaderBuffer(flatbuffers::Verifier & verifier)699 inline bool VerifySizePrefixedHeaderBuffer(
700     flatbuffers::Verifier &verifier) {
701   return verifier.VerifySizePrefixedBuffer<FlatGeobuf::Header>(nullptr);
702 }
703 
FinishHeaderBuffer(flatbuffers::FlatBufferBuilder & fbb,flatbuffers::Offset<FlatGeobuf::Header> root)704 inline void FinishHeaderBuffer(
705     flatbuffers::FlatBufferBuilder &fbb,
706     flatbuffers::Offset<FlatGeobuf::Header> root) {
707   fbb.Finish(root);
708 }
709 
FinishSizePrefixedHeaderBuffer(flatbuffers::FlatBufferBuilder & fbb,flatbuffers::Offset<FlatGeobuf::Header> root)710 inline void FinishSizePrefixedHeaderBuffer(
711     flatbuffers::FlatBufferBuilder &fbb,
712     flatbuffers::Offset<FlatGeobuf::Header> root) {
713   fbb.FinishSizePrefixed(root);
714 }
715 
716 }  // namespace FlatGeobuf
717 
718 #endif  // FLATBUFFERS_GENERATED_HEADER_FLATGEOBUF_H_
719