text: // automatically generated by the FlatBuffers compiler, do not modify
  
  
  #ifndef FLATBUFFERS_GENERATED_UINT32_COMM_DATALAYER_H_
  #define FLATBUFFERS_GENERATED_UINT32_COMM_DATALAYER_H_
  
  #include "flatbuffers/flatbuffers.h"
  
  namespace comm {
  namespace datalayer {
  
  struct UInt32;
  struct UInt32Builder;
  struct UInt32T;
  
  struct UInt32T : public flatbuffers::NativeTable {
    typedef UInt32 TableType;
    uint32_t value = 0;
  };
  
  struct UInt32 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    typedef UInt32T NativeTableType;
    typedef UInt32Builder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
      VT_VALUE = 4
    };
    uint32_t value() const {
      return GetField<uint32_t>(VT_VALUE, 0);
    }
    bool mutate_value(uint32_t _value) {
      return SetField<uint32_t>(VT_VALUE, _value, 0);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
      return VerifyTableStart(verifier) &&
             VerifyField<uint32_t>(verifier, VT_VALUE) &&
             verifier.EndTable();
    }
    UInt32T *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
    void UnPackTo(UInt32T *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
    static flatbuffers::Offset<UInt32> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UInt32T* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
  };
  
  struct UInt32Builder {
    typedef UInt32 Table;
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_value(uint32_t value) {
      fbb_.AddElement<uint32_t>(UInt32::VT_VALUE, value, 0);
    }
    explicit UInt32Builder(flatbuffers::FlatBufferBuilder &_fbb)
          : fbb_(_fbb) {
      start_ = fbb_.StartTable();
    }
    flatbuffers::Offset<UInt32> Finish() {
      const auto end = fbb_.EndTable(start_);
      auto o = flatbuffers::Offset<UInt32>(end);
      return o;
    }
  };
  
  inline flatbuffers::Offset<UInt32> CreateUInt32(
      flatbuffers::FlatBufferBuilder &_fbb,
      uint32_t value = 0) {
    UInt32Builder builder_(_fbb);
    builder_.add_value(value);
    return builder_.Finish();
  }
  
  flatbuffers::Offset<UInt32> CreateUInt32(flatbuffers::FlatBufferBuilder &_fbb, const UInt32T *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
  
  inline UInt32T *UInt32::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
    auto _o = std::unique_ptr<UInt32T>(new UInt32T());
    UnPackTo(_o.get(), _resolver);
    return _o.release();
  }
  
  inline void UInt32::UnPackTo(UInt32T *_o, const flatbuffers::resolver_function_t *_resolver) const {
    (void)_o;
    (void)_resolver;
    { auto _e = value(); _o->value = _e; }
  }
  
  inline flatbuffers::Offset<UInt32> UInt32::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UInt32T* _o, const flatbuffers::rehasher_function_t *_rehasher) {
    return CreateUInt32(_fbb, _o, _rehasher);
  }
  
  inline flatbuffers::Offset<UInt32> CreateUInt32(flatbuffers::FlatBufferBuilder &_fbb, const UInt32T *_o, const flatbuffers::rehasher_function_t *_rehasher) {
    (void)_rehasher;
    (void)_o;
    struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UInt32T* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
    auto _value = _o->value;
    return comm::datalayer::CreateUInt32(
        _fbb,
        _value);
  }
  
  inline const comm::datalayer::UInt32 *GetUInt32(const void *buf) {
    return flatbuffers::GetRoot<comm::datalayer::UInt32>(buf);
  }
  
  inline const comm::datalayer::UInt32 *GetSizePrefixedUInt32(const void *buf) {
    return flatbuffers::GetSizePrefixedRoot<comm::datalayer::UInt32>(buf);
  }
  
  inline UInt32 *GetMutableUInt32(void *buf) {
    return flatbuffers::GetMutableRoot<UInt32>(buf);
  }
  
  inline bool VerifyUInt32Buffer(
      flatbuffers::Verifier &verifier) {
    return verifier.VerifyBuffer<comm::datalayer::UInt32>(nullptr);
  }
  
  inline bool VerifySizePrefixedUInt32Buffer(
      flatbuffers::Verifier &verifier) {
    return verifier.VerifySizePrefixedBuffer<comm::datalayer::UInt32>(nullptr);
  }
  
  inline void FinishUInt32Buffer(
      flatbuffers::FlatBufferBuilder &fbb,
      flatbuffers::Offset<comm::datalayer::UInt32> root) {
    fbb.Finish(root);
  }
  
  inline void FinishSizePrefixedUInt32Buffer(
      flatbuffers::FlatBufferBuilder &fbb,
      flatbuffers::Offset<comm::datalayer::UInt32> root) {
    fbb.FinishSizePrefixed(root);
  }
  
  inline std::unique_ptr<comm::datalayer::UInt32T> UnPackUInt32(
      const void *buf,
      const flatbuffers::resolver_function_t *res = nullptr) {
    return std::unique_ptr<comm::datalayer::UInt32T>(GetUInt32(buf)->UnPack(res));
  }
  
  inline std::unique_ptr<comm::datalayer::UInt32T> UnPackSizePrefixedUInt32(
      const void *buf,
      const flatbuffers::resolver_function_t *res = nullptr) {
    return std::unique_ptr<comm::datalayer::UInt32T>(GetSizePrefixedUInt32(buf)->UnPack(res));
  }
  
  }  // namespace datalayer
  }  // namespace comm
  
  #endif  // FLATBUFFERS_GENERATED_UINT32_COMM_DATALAYER_H_
  