Line data    Source code

       1             : // automatically generated by the FlatBuffers compiler, do not modify
       2             : 
       3             : #ifndef FLATBUFFERS_GENERATED_FEATURE_FLATGEOBUF_H_
       4             : #define FLATBUFFERS_GENERATED_FEATURE_FLATGEOBUF_H_
       5             : 
       6             : #include "flatbuffers/flatbuffers.h"
       7             : 
       8             : // Ensure the included flatbuffers.h is the same version as when this file was
       9             : // generated, otherwise it may not be compatible.
      10             : static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
      11             :                   FLATBUFFERS_VERSION_MINOR == 0 &&
      12             :                   FLATBUFFERS_VERSION_REVISION == 6,
      13             :               "Non-compatible flatbuffers version included");
      14             : 
      15             : #include "header_generated.h"
      16             : 
      17             : namespace FlatGeobuf
      18             : {
      19             : 
      20             : struct Geometry;
      21             : struct GeometryBuilder;
      22             : 
      23             : struct Feature;
      24             : struct FeatureBuilder;
      25             : 
      26             : struct Geometry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
      27             : {
      28             :     typedef GeometryBuilder Builder;
      29             : 
      30             :     enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
      31             :     {
      32             :         VT_ENDS = 4,
      33             :         VT_XY = 6,
      34             :         VT_Z = 8,
      35             :         VT_M = 10,
      36             :         VT_T = 12,
      37             :         VT_TM = 14,
      38             :         VT_TYPE = 16,
      39             :         VT_PARTS = 18
      40             :     };
      41             : 
      42        1276 :     const flatbuffers::Vector<uint32_t> *ends() const
      43             :     {
      44        1276 :         return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_ENDS);
      45             :     }
      46             : 
      47        1554 :     const flatbuffers::Vector<double> *xy() const
      48             :     {
      49        1554 :         return GetPointer<const flatbuffers::Vector<double> *>(VT_XY);
      50             :     }
      51             : 
      52         975 :     const flatbuffers::Vector<double> *z() const
      53             :     {
      54         975 :         return GetPointer<const flatbuffers::Vector<double> *>(VT_Z);
      55             :     }
      56             : 
      57         958 :     const flatbuffers::Vector<double> *m() const
      58             :     {
      59         958 :         return GetPointer<const flatbuffers::Vector<double> *>(VT_M);
      60             :     }
      61             : 
      62         816 :     const flatbuffers::Vector<double> *t() const
      63             :     {
      64         816 :         return GetPointer<const flatbuffers::Vector<double> *>(VT_T);
      65             :     }
      66             : 
      67         816 :     const flatbuffers::Vector<uint64_t> *tm() const
      68             :     {
      69         816 :         return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_TM);
      70             :     }
      71             : 
      72          82 :     FlatGeobuf::GeometryType type() const
      73             :     {
      74             :         return static_cast<FlatGeobuf::GeometryType>(
      75          82 :             GetField<uint8_t>(VT_TYPE, 0));
      76             :     }
      77             : 
      78             :     const flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Geometry>> *
      79        1696 :     parts() const
      80             :     {
      81             :         return GetPointer<const flatbuffers::Vector<
      82        1696 :             flatbuffers::Offset<FlatGeobuf::Geometry>> *>(VT_PARTS);
      83             :     }
      84             : 
      85         816 :     bool Verify(flatbuffers::Verifier &verifier) const
      86             :     {
      87        1632 :         return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_ENDS) &&
      88         816 :                verifier.VerifyVector(ends()) && VerifyOffset(verifier, VT_XY) &&
      89         816 :                verifier.VerifyVector(xy()) && VerifyOffset(verifier, VT_Z) &&
      90         816 :                verifier.VerifyVector(z()) && VerifyOffset(verifier, VT_M) &&
      91         816 :                verifier.VerifyVector(m()) && VerifyOffset(verifier, VT_T) &&
      92         816 :                verifier.VerifyVector(t()) && VerifyOffset(verifier, VT_TM) &&
      93         816 :                verifier.VerifyVector(tm()) &&
      94         816 :                VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
      95         816 :                VerifyOffset(verifier, VT_PARTS) &&
      96         816 :                verifier.VerifyVector(parts()) &&
      97        1632 :                verifier.VerifyVectorOfTables(parts()) && verifier.EndTable();
      98             :     }
      99             : };
     100             : 
     101             : struct GeometryBuilder
     102             : {
     103             :     typedef Geometry Table;
     104             :     flatbuffers::FlatBufferBuilder &fbb_;
     105             :     flatbuffers::uoffset_t start_;
     106             : 
     107         307 :     void add_ends(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ends)
     108             :     {
     109         307 :         fbb_.AddOffset(Geometry::VT_ENDS, ends);
     110         307 :     }
     111             : 
     112         307 :     void add_xy(flatbuffers::Offset<flatbuffers::Vector<double>> xy)
     113             :     {
     114         307 :         fbb_.AddOffset(Geometry::VT_XY, xy);
     115         307 :     }
     116             : 
     117         307 :     void add_z(flatbuffers::Offset<flatbuffers::Vector<double>> z)
     118             :     {
     119         307 :         fbb_.AddOffset(Geometry::VT_Z, z);
     120         307 :     }
     121             : 
     122         307 :     void add_m(flatbuffers::Offset<flatbuffers::Vector<double>> m)
     123             :     {
     124         307 :         fbb_.AddOffset(Geometry::VT_M, m);
     125         307 :     }
     126             : 
     127         307 :     void add_t(flatbuffers::Offset<flatbuffers::Vector<double>> t)
     128             :     {
     129         307 :         fbb_.AddOffset(Geometry::VT_T, t);
     130         307 :     }
     131             : 
     132         307 :     void add_tm(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> tm)
     133             :     {
     134         307 :         fbb_.AddOffset(Geometry::VT_TM, tm);
     135         307 :     }
     136             : 
     137         307 :     void add_type(FlatGeobuf::GeometryType type)
     138             :     {
     139         307 :         fbb_.AddElement<uint8_t>(Geometry::VT_TYPE, static_cast<uint8_t>(type),
     140             :                                  0);
     141         307 :     }
     142             : 
     143             :     void
     144         307 :     add_parts(flatbuffers::Offset<
     145             :               flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Geometry>>>
     146             :                   parts)
     147             :     {
     148         307 :         fbb_.AddOffset(Geometry::VT_PARTS, parts);
     149         307 :     }
     150             : 
     151         307 :     explicit GeometryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
     152             :     {
     153         307 :         start_ = fbb_.StartTable();
     154         307 :     }
     155             : 
     156         307 :     flatbuffers::Offset<Geometry> Finish()
     157             :     {
     158         307 :         const auto end = fbb_.EndTable(start_);
     159         307 :         auto o = flatbuffers::Offset<Geometry>(end);
     160         307 :         return o;
     161             :     }
     162             : };
     163             : 
     164         307 : inline flatbuffers::Offset<Geometry> CreateGeometry(
     165             :     flatbuffers::FlatBufferBuilder &_fbb,
     166             :     flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ends = 0,
     167             :     flatbuffers::Offset<flatbuffers::Vector<double>> xy = 0,
     168             :     flatbuffers::Offset<flatbuffers::Vector<double>> z = 0,
     169             :     flatbuffers::Offset<flatbuffers::Vector<double>> m = 0,
     170             :     flatbuffers::Offset<flatbuffers::Vector<double>> t = 0,
     171             :     flatbuffers::Offset<flatbuffers::Vector<uint64_t>> tm = 0,
     172             :     FlatGeobuf::GeometryType type = FlatGeobuf::GeometryType::Unknown,
     173             :     flatbuffers::Offset<
     174             :         flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Geometry>>>
     175             :         parts = 0)
     176             : {
     177         307 :     GeometryBuilder builder_(_fbb);
     178         307 :     builder_.add_parts(parts);
     179         307 :     builder_.add_tm(tm);
     180         307 :     builder_.add_t(t);
     181         307 :     builder_.add_m(m);
     182         307 :     builder_.add_z(z);
     183         307 :     builder_.add_xy(xy);
     184         307 :     builder_.add_ends(ends);
     185         307 :     builder_.add_type(type);
     186         614 :     return builder_.Finish();
     187             : }
     188             : 
     189         307 : inline flatbuffers::Offset<Geometry> CreateGeometryDirect(
     190             :     flatbuffers::FlatBufferBuilder &_fbb,
     191             :     const std::vector<uint32_t> *ends = nullptr,
     192             :     const std::vector<double> *xy = nullptr,
     193             :     const std::vector<double> *z = nullptr,
     194             :     const std::vector<double> *m = nullptr,
     195             :     const std::vector<double> *t = nullptr,
     196             :     const std::vector<uint64_t> *tm = nullptr,
     197             :     FlatGeobuf::GeometryType type = FlatGeobuf::GeometryType::Unknown,
     198             :     const std::vector<flatbuffers::Offset<FlatGeobuf::Geometry>> *parts =
     199             :         nullptr)
     200             : {
     201         307 :     auto ends__ = ends ? _fbb.CreateVector<uint32_t>(*ends) : 0;
     202         307 :     auto xy__ = xy ? _fbb.CreateVector<double>(*xy) : 0;
     203         307 :     auto z__ = z ? _fbb.CreateVector<double>(*z) : 0;
     204         307 :     auto m__ = m ? _fbb.CreateVector<double>(*m) : 0;
     205         307 :     auto t__ = t ? _fbb.CreateVector<double>(*t) : 0;
     206         307 :     auto tm__ = tm ? _fbb.CreateVector<uint64_t>(*tm) : 0;
     207             :     auto parts__ =
     208             :         parts ? _fbb.CreateVector<flatbuffers::Offset<FlatGeobuf::Geometry>>(
     209          57 :                     *parts)
     210         307 :               : 0;
     211             :     return FlatGeobuf::CreateGeometry(_fbb, ends__, xy__, z__, m__, t__, tm__,
     212         614 :                                       type, parts__);
     213             : }
     214             : 
     215             : struct Feature FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
     216             : {
     217             :     typedef FeatureBuilder Builder;
     218             : 
     219             :     enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
     220             :     {
     221             :         VT_GEOMETRY = 4,
     222             :         VT_PROPERTIES = 6,
     223             :         VT_COLUMNS = 8
     224             :     };
     225             : 
     226        1394 :     const FlatGeobuf::Geometry *geometry() const
     227             :     {
     228        1394 :         return GetPointer<const FlatGeobuf::Geometry *>(VT_GEOMETRY);
     229             :     }
     230             : 
     231        1390 :     const flatbuffers::Vector<uint8_t> *properties() const
     232             :     {
     233        1390 :         return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PROPERTIES);
     234             :     }
     235             : 
     236             :     const flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Column>> *
     237        1394 :     columns() const
     238             :     {
     239             :         return GetPointer<const flatbuffers::Vector<
     240        1394 :             flatbuffers::Offset<FlatGeobuf::Column>> *>(VT_COLUMNS);
     241             :     }
     242             : 
     243         697 :     bool Verify(flatbuffers::Verifier &verifier) const
     244             :     {
     245         697 :         return VerifyTableStart(verifier) &&
     246         697 :                VerifyOffset(verifier, VT_GEOMETRY) &&
     247         697 :                verifier.VerifyTable(geometry()) &&
     248         697 :                VerifyOffset(verifier, VT_PROPERTIES) &&
     249         697 :                verifier.VerifyVector(properties()) &&
     250         697 :                VerifyOffset(verifier, VT_COLUMNS) &&
     251         697 :                verifier.VerifyVector(columns()) &&
     252        1394 :                verifier.VerifyVectorOfTables(columns()) && verifier.EndTable();
     253             :     }
     254             : };
     255             : 
     256             : struct FeatureBuilder
     257             : {
     258             :     typedef Feature Table;
     259             :     flatbuffers::FlatBufferBuilder &fbb_;
     260             :     flatbuffers::uoffset_t start_;
     261             : 
     262         198 :     void add_geometry(flatbuffers::Offset<FlatGeobuf::Geometry> geometry)
     263             :     {
     264         198 :         fbb_.AddOffset(Feature::VT_GEOMETRY, geometry);
     265         198 :     }
     266             : 
     267             :     void
     268         198 :     add_properties(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> properties)
     269             :     {
     270         198 :         fbb_.AddOffset(Feature::VT_PROPERTIES, properties);
     271         198 :     }
     272             : 
     273             :     void
     274         198 :     add_columns(flatbuffers::Offset<
     275             :                 flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Column>>>
     276             :                     columns)
     277             :     {
     278         198 :         fbb_.AddOffset(Feature::VT_COLUMNS, columns);
     279         198 :     }
     280             : 
     281         198 :     explicit FeatureBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
     282             :     {
     283         198 :         start_ = fbb_.StartTable();
     284         198 :     }
     285             : 
     286         198 :     flatbuffers::Offset<Feature> Finish()
     287             :     {
     288         198 :         const auto end = fbb_.EndTable(start_);
     289         198 :         auto o = flatbuffers::Offset<Feature>(end);
     290         198 :         return o;
     291             :     }
     292             : };
     293             : 
     294             : inline flatbuffers::Offset<Feature>
     295         198 : CreateFeature(flatbuffers::FlatBufferBuilder &_fbb,
     296             :               flatbuffers::Offset<FlatGeobuf::Geometry> geometry = 0,
     297             :               flatbuffers::Offset<flatbuffers::Vector<uint8_t>> properties = 0,
     298             :               flatbuffers::Offset<
     299             :                   flatbuffers::Vector<flatbuffers::Offset<FlatGeobuf::Column>>>
     300             :                   columns = 0)
     301             : {
     302         198 :     FeatureBuilder builder_(_fbb);
     303         198 :     builder_.add_columns(columns);
     304         198 :     builder_.add_properties(properties);
     305         198 :     builder_.add_geometry(geometry);
     306         396 :     return builder_.Finish();
     307             : }
     308             : 
     309         198 : inline flatbuffers::Offset<Feature> CreateFeatureDirect(
     310             :     flatbuffers::FlatBufferBuilder &_fbb,
     311             :     flatbuffers::Offset<FlatGeobuf::Geometry> geometry = 0,
     312             :     const std::vector<uint8_t> *properties = nullptr,
     313             :     const std::vector<flatbuffers::Offset<FlatGeobuf::Column>> *columns =
     314             :         nullptr)
     315             : {
     316             :     auto properties__ =
     317         198 :         properties ? _fbb.CreateVector<uint8_t>(*properties) : 0;
     318             :     auto columns__ =
     319             :         columns ? _fbb.CreateVector<flatbuffers::Offset<FlatGeobuf::Column>>(
     320           0 :                       *columns)
     321         198 :                 : 0;
     322         396 :     return FlatGeobuf::CreateFeature(_fbb, geometry, properties__, columns__);
     323             : }
     324             : 
     325             : inline const FlatGeobuf::Feature *GetFeature(const void *buf)
     326             : {
     327             :     return flatbuffers::GetRoot<FlatGeobuf::Feature>(buf);
     328             : }
     329             : 
     330             : inline const FlatGeobuf::Feature *GetSizePrefixedFeature(const void *buf)
     331             : {
     332             :     return flatbuffers::GetSizePrefixedRoot<FlatGeobuf::Feature>(buf);
     333             : }
     334             : 
     335         697 : inline bool VerifyFeatureBuffer(flatbuffers::Verifier &verifier)
     336             : {
     337         697 :     return verifier.VerifyBuffer<FlatGeobuf::Feature>(nullptr);
     338             : }
     339             : 
     340             : inline bool VerifySizePrefixedFeatureBuffer(flatbuffers::Verifier &verifier)
     341             : {
     342             :     return verifier.VerifySizePrefixedBuffer<FlatGeobuf::Feature>(nullptr);
     343             : }
     344             : 
     345             : inline void FinishFeatureBuffer(flatbuffers::FlatBufferBuilder &fbb,
     346             :                                 flatbuffers::Offset<FlatGeobuf::Feature> root)
     347             : {
     348             :     fbb.Finish(root);
     349             : }
     350             : 
     351             : inline void
     352             : FinishSizePrefixedFeatureBuffer(flatbuffers::FlatBufferBuilder &fbb,
     353             :                                 flatbuffers::Offset<FlatGeobuf::Feature> root)
     354             : {
     355             :     fbb.FinishSizePrefixed(root);
     356             : }
     357             : 
     358             : }  // namespace FlatGeobuf
     359             : 
     360             : #endif  // FLATBUFFERS_GENERATED_FEATURE_FLATGEOBUF_H_