// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_APPARAMSFLATBUFFERS_APPARAMS_FB_H_
#define FLATBUFFERS_GENERATED_APPARAMSFLATBUFFERS_APPARAMS_FB_H_

#include "flatbuffers/flatbuffers.h"

namespace apParams {
namespace fb {

struct FBDimension;

struct FBInputTensor;

struct FBOutputTensor;

struct FBNetwork;

struct FBApParams;

struct FBDimension FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_SIZE = 6,
    VT_SERIALIZATIONINDEX = 8,
    VT_PADDING = 10
  };
  uint8_t id() const {
    return GetField<uint8_t>(VT_ID, 0);
  }
  uint16_t size() const {
    return GetField<uint16_t>(VT_SIZE, 0);
  }
  uint8_t serializationIndex() const {
    return GetField<uint8_t>(VT_SERIALIZATIONINDEX, 0);
  }
  uint8_t padding() const {
    return GetField<uint8_t>(VT_PADDING, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ID) &&
           VerifyField<uint16_t>(verifier, VT_SIZE) &&
           VerifyField<uint8_t>(verifier, VT_SERIALIZATIONINDEX) &&
           VerifyField<uint8_t>(verifier, VT_PADDING) &&
           verifier.EndTable();
  }
};

struct FBDimensionBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint8_t id) {
    fbb_.AddElement<uint8_t>(FBDimension::VT_ID, id, 0);
  }
  void add_size(uint16_t size) {
    fbb_.AddElement<uint16_t>(FBDimension::VT_SIZE, size, 0);
  }
  void add_serializationIndex(uint8_t serializationIndex) {
    fbb_.AddElement<uint8_t>(FBDimension::VT_SERIALIZATIONINDEX, serializationIndex, 0);
  }
  void add_padding(uint8_t padding) {
    fbb_.AddElement<uint8_t>(FBDimension::VT_PADDING, padding, 0);
  }
  explicit FBDimensionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  FBDimensionBuilder &operator=(const FBDimensionBuilder &);
  flatbuffers::Offset<FBDimension> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FBDimension>(end);
    return o;
  }
};

inline flatbuffers::Offset<FBDimension> CreateFBDimension(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t id = 0,
    uint16_t size = 0,
    uint8_t serializationIndex = 0,
    uint8_t padding = 0) {
  FBDimensionBuilder builder_(_fbb);
  builder_.add_size(size);
  builder_.add_padding(padding);
  builder_.add_serializationIndex(serializationIndex);
  builder_.add_id(id);
  return builder_.Finish();
}

struct FBInputTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_NAME = 6,
    VT_NUMOFDIMENSIONS = 8,
    VT_DIMENSIONS = 10,
    VT_SHIFT = 12,
    VT_SCALE = 14,
    VT_FORMAT = 16
  };
  uint8_t id() const {
    return GetField<uint8_t>(VT_ID, 0);
  }
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  uint8_t numOfDimensions() const {
    return GetField<uint8_t>(VT_NUMOFDIMENSIONS, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *dimensions() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *>(VT_DIMENSIONS);
  }
  uint16_t shift() const {
    return GetField<uint16_t>(VT_SHIFT, 0);
  }
  float scale() const {
    return GetField<float>(VT_SCALE, 0.0f);
  }
  uint8_t format() const {
    return GetField<uint8_t>(VT_FORMAT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ID) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint8_t>(verifier, VT_NUMOFDIMENSIONS) &&
           VerifyOffset(verifier, VT_DIMENSIONS) &&
           verifier.VerifyVector(dimensions()) &&
           verifier.VerifyVectorOfTables(dimensions()) &&
           VerifyField<uint16_t>(verifier, VT_SHIFT) &&
           VerifyField<float>(verifier, VT_SCALE) &&
           VerifyField<uint8_t>(verifier, VT_FORMAT) &&
           verifier.EndTable();
  }
};

struct FBInputTensorBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint8_t id) {
    fbb_.AddElement<uint8_t>(FBInputTensor::VT_ID, id, 0);
  }
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(FBInputTensor::VT_NAME, name);
  }
  void add_numOfDimensions(uint8_t numOfDimensions) {
    fbb_.AddElement<uint8_t>(FBInputTensor::VT_NUMOFDIMENSIONS, numOfDimensions, 0);
  }
  void add_dimensions(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions) {
    fbb_.AddOffset(FBInputTensor::VT_DIMENSIONS, dimensions);
  }
  void add_shift(uint16_t shift) {
    fbb_.AddElement<uint16_t>(FBInputTensor::VT_SHIFT, shift, 0);
  }
  void add_scale(float scale) {
    fbb_.AddElement<float>(FBInputTensor::VT_SCALE, scale, 0.0f);
  }
  void add_format(uint8_t format) {
    fbb_.AddElement<uint8_t>(FBInputTensor::VT_FORMAT, format, 0);
  }
  explicit FBInputTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  FBInputTensorBuilder &operator=(const FBInputTensorBuilder &);
  flatbuffers::Offset<FBInputTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FBInputTensor>(end);
    return o;
  }
};

inline flatbuffers::Offset<FBInputTensor> CreateFBInputTensor(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t id = 0,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    uint8_t numOfDimensions = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions = 0,
    uint16_t shift = 0,
    float scale = 0.0f,
    uint8_t format = 0) {
  FBInputTensorBuilder builder_(_fbb);
  builder_.add_scale(scale);
  builder_.add_dimensions(dimensions);
  builder_.add_name(name);
  builder_.add_shift(shift);
  builder_.add_format(format);
  builder_.add_numOfDimensions(numOfDimensions);
  builder_.add_id(id);
  return builder_.Finish();
}

inline flatbuffers::Offset<FBInputTensor> CreateFBInputTensorDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t id = 0,
    const char *name = nullptr,
    uint8_t numOfDimensions = 0,
    const std::vector<flatbuffers::Offset<FBDimension>> *dimensions = nullptr,
    uint16_t shift = 0,
    float scale = 0.0f,
    uint8_t format = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto dimensions__ = dimensions ? _fbb.CreateVector<flatbuffers::Offset<FBDimension>>(*dimensions) : 0;
  return apParams::fb::CreateFBInputTensor(
      _fbb,
      id,
      name__,
      numOfDimensions,
      dimensions__,
      shift,
      scale,
      format);
}

struct FBOutputTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_NAME = 6,
    VT_NUMOFDIMENSIONS = 8,
    VT_DIMENSIONS = 10,
    VT_BITSPERELEMENT = 12,
    VT_SHIFT = 14,
    VT_SCALE = 16,
    VT_FORMAT = 18
  };
  uint8_t id() const {
    return GetField<uint8_t>(VT_ID, 0);
  }
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  uint8_t numOfDimensions() const {
    return GetField<uint8_t>(VT_NUMOFDIMENSIONS, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *dimensions() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBDimension>> *>(VT_DIMENSIONS);
  }
  uint8_t bitsPerElement() const {
    return GetField<uint8_t>(VT_BITSPERELEMENT, 0);
  }
  uint16_t shift() const {
    return GetField<uint16_t>(VT_SHIFT, 0);
  }
  float scale() const {
    return GetField<float>(VT_SCALE, 0.0f);
  }
  uint8_t format() const {
    return GetField<uint8_t>(VT_FORMAT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ID) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint8_t>(verifier, VT_NUMOFDIMENSIONS) &&
           VerifyOffset(verifier, VT_DIMENSIONS) &&
           verifier.VerifyVector(dimensions()) &&
           verifier.VerifyVectorOfTables(dimensions()) &&
           VerifyField<uint8_t>(verifier, VT_BITSPERELEMENT) &&
           VerifyField<uint16_t>(verifier, VT_SHIFT) &&
           VerifyField<float>(verifier, VT_SCALE) &&
           VerifyField<uint8_t>(verifier, VT_FORMAT) &&
           verifier.EndTable();
  }
};

struct FBOutputTensorBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint8_t id) {
    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_ID, id, 0);
  }
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(FBOutputTensor::VT_NAME, name);
  }
  void add_numOfDimensions(uint8_t numOfDimensions) {
    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_NUMOFDIMENSIONS, numOfDimensions, 0);
  }
  void add_dimensions(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions) {
    fbb_.AddOffset(FBOutputTensor::VT_DIMENSIONS, dimensions);
  }
  void add_bitsPerElement(uint8_t bitsPerElement) {
    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_BITSPERELEMENT, bitsPerElement, 0);
  }
  void add_shift(uint16_t shift) {
    fbb_.AddElement<uint16_t>(FBOutputTensor::VT_SHIFT, shift, 0);
  }
  void add_scale(float scale) {
    fbb_.AddElement<float>(FBOutputTensor::VT_SCALE, scale, 0.0f);
  }
  void add_format(uint8_t format) {
    fbb_.AddElement<uint8_t>(FBOutputTensor::VT_FORMAT, format, 0);
  }
  explicit FBOutputTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  FBOutputTensorBuilder &operator=(const FBOutputTensorBuilder &);
  flatbuffers::Offset<FBOutputTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FBOutputTensor>(end);
    return o;
  }
};

inline flatbuffers::Offset<FBOutputTensor> CreateFBOutputTensor(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t id = 0,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    uint8_t numOfDimensions = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBDimension>>> dimensions = 0,
    uint8_t bitsPerElement = 0,
    uint16_t shift = 0,
    float scale = 0.0f,
    uint8_t format = 0) {
  FBOutputTensorBuilder builder_(_fbb);
  builder_.add_scale(scale);
  builder_.add_dimensions(dimensions);
  builder_.add_name(name);
  builder_.add_shift(shift);
  builder_.add_format(format);
  builder_.add_bitsPerElement(bitsPerElement);
  builder_.add_numOfDimensions(numOfDimensions);
  builder_.add_id(id);
  return builder_.Finish();
}

inline flatbuffers::Offset<FBOutputTensor> CreateFBOutputTensorDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t id = 0,
    const char *name = nullptr,
    uint8_t numOfDimensions = 0,
    const std::vector<flatbuffers::Offset<FBDimension>> *dimensions = nullptr,
    uint8_t bitsPerElement = 0,
    uint16_t shift = 0,
    float scale = 0.0f,
    uint8_t format = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto dimensions__ = dimensions ? _fbb.CreateVector<flatbuffers::Offset<FBDimension>>(*dimensions) : 0;
  return apParams::fb::CreateFBOutputTensor(
      _fbb,
      id,
      name__,
      numOfDimensions,
      dimensions__,
      bitsPerElement,
      shift,
      scale,
      format);
}

struct FBNetwork FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_NAME = 6,
    VT_TYPE = 8,
    VT_INPUTTENSORS = 10,
    VT_OUTPUTTENSORS = 12
  };
  uint16_t id() const {
    return GetField<uint16_t>(VT_ID, 0);
  }
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  const flatbuffers::String *type() const {
    return GetPointer<const flatbuffers::String *>(VT_TYPE);
  }
  const flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>> *inputTensors() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>> *>(VT_INPUTTENSORS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>> *outputTensors() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>> *>(VT_OUTPUTTENSORS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_ID) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_TYPE) &&
           verifier.VerifyString(type()) &&
           VerifyOffset(verifier, VT_INPUTTENSORS) &&
           verifier.VerifyVector(inputTensors()) &&
           verifier.VerifyVectorOfTables(inputTensors()) &&
           VerifyOffset(verifier, VT_OUTPUTTENSORS) &&
           verifier.VerifyVector(outputTensors()) &&
           verifier.VerifyVectorOfTables(outputTensors()) &&
           verifier.EndTable();
  }
};

struct FBNetworkBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint16_t id) {
    fbb_.AddElement<uint16_t>(FBNetwork::VT_ID, id, 0);
  }
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(FBNetwork::VT_NAME, name);
  }
  void add_type(flatbuffers::Offset<flatbuffers::String> type) {
    fbb_.AddOffset(FBNetwork::VT_TYPE, type);
  }
  void add_inputTensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>>> inputTensors) {
    fbb_.AddOffset(FBNetwork::VT_INPUTTENSORS, inputTensors);
  }
  void add_outputTensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>>> outputTensors) {
    fbb_.AddOffset(FBNetwork::VT_OUTPUTTENSORS, outputTensors);
  }
  explicit FBNetworkBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  FBNetworkBuilder &operator=(const FBNetworkBuilder &);
  flatbuffers::Offset<FBNetwork> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FBNetwork>(end);
    return o;
  }
};

inline flatbuffers::Offset<FBNetwork> CreateFBNetwork(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t id = 0,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    flatbuffers::Offset<flatbuffers::String> type = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBInputTensor>>> inputTensors = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBOutputTensor>>> outputTensors = 0) {
  FBNetworkBuilder builder_(_fbb);
  builder_.add_outputTensors(outputTensors);
  builder_.add_inputTensors(inputTensors);
  builder_.add_type(type);
  builder_.add_name(name);
  builder_.add_id(id);
  return builder_.Finish();
}

inline flatbuffers::Offset<FBNetwork> CreateFBNetworkDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t id = 0,
    const char *name = nullptr,
    const char *type = nullptr,
    const std::vector<flatbuffers::Offset<FBInputTensor>> *inputTensors = nullptr,
    const std::vector<flatbuffers::Offset<FBOutputTensor>> *outputTensors = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto type__ = type ? _fbb.CreateString(type) : 0;
  auto inputTensors__ = inputTensors ? _fbb.CreateVector<flatbuffers::Offset<FBInputTensor>>(*inputTensors) : 0;
  auto outputTensors__ = outputTensors ? _fbb.CreateVector<flatbuffers::Offset<FBOutputTensor>>(*outputTensors) : 0;
  return apParams::fb::CreateFBNetwork(
      _fbb,
      id,
      name__,
      type__,
      inputTensors__,
      outputTensors__);
}

struct FBApParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NETWORKS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<FBNetwork>> *networks() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBNetwork>> *>(VT_NETWORKS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NETWORKS) &&
           verifier.VerifyVector(networks()) &&
           verifier.VerifyVectorOfTables(networks()) &&
           verifier.EndTable();
  }
};

struct FBApParamsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_networks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBNetwork>>> networks) {
    fbb_.AddOffset(FBApParams::VT_NETWORKS, networks);
  }
  explicit FBApParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  FBApParamsBuilder &operator=(const FBApParamsBuilder &);
  flatbuffers::Offset<FBApParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FBApParams>(end);
    return o;
  }
};

inline flatbuffers::Offset<FBApParams> CreateFBApParams(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBNetwork>>> networks = 0) {
  FBApParamsBuilder builder_(_fbb);
  builder_.add_networks(networks);
  return builder_.Finish();
}

inline flatbuffers::Offset<FBApParams> CreateFBApParamsDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<FBNetwork>> *networks = nullptr) {
  auto networks__ = networks ? _fbb.CreateVector<flatbuffers::Offset<FBNetwork>>(*networks) : 0;
  return apParams::fb::CreateFBApParams(
      _fbb,
      networks__);
}

inline const apParams::fb::FBApParams *GetFBApParams(const void *buf) {
  return flatbuffers::GetRoot<apParams::fb::FBApParams>(buf);
}

inline const apParams::fb::FBApParams *GetSizePrefixedFBApParams(const void *buf) {
  return flatbuffers::GetSizePrefixedRoot<apParams::fb::FBApParams>(buf);
}

inline bool VerifyFBApParamsBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<apParams::fb::FBApParams>(nullptr);
}

inline bool VerifySizePrefixedFBApParamsBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<apParams::fb::FBApParams>(nullptr);
}

inline void FinishFBApParamsBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<apParams::fb::FBApParams> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedFBApParamsBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<apParams::fb::FBApParams> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace fb
}  // namespace apParams

#endif  // FLATBUFFERS_GENERATED_APPARAMSFLATBUFFERS_APPARAMS_FB_H_
