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


#ifndef FLATBUFFERS_GENERATED_PROPERTY_IKARUS_H_
#define FLATBUFFERS_GENERATED_PROPERTY_IKARUS_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
              FLATBUFFERS_VERSION_MINOR == 3 &&
              FLATBUFFERS_VERSION_REVISION == 25,
             "Non-compatible flatbuffers version included");

#include "value_generated.h"

namespace Ikarus {

struct Property;
struct PropertyBuilder;

struct Property FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PropertyBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_NAME = 6,
    VT_DESCRIPTION = 8,
    VT_TAGS = 10,
    VT_VALUE_SCHEMA_TYPE = 12,
    VT_VALUE_SCHEMA = 14,
    VT_DEFAULT_VALUE_TYPE = 16,
    VT_DEFAULT_VALUE = 18
  };
  int64_t id() const {
    return GetField<int64_t>(VT_ID, 0);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::String *description() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
  }
  Ikarus::Value::Schema value_schema_type() const {
    return static_cast<Ikarus::Value::Schema>(GetField<uint8_t>(VT_VALUE_SCHEMA_TYPE, 0));
  }
  const void *value_schema() const {
    return GetPointer<const void *>(VT_VALUE_SCHEMA);
  }
  template<typename T> const T *value_schema_as() const;
  const Ikarus::Value::ConstantSchema *value_schema_as_ConstantSchema() const {
    return value_schema_type() == Ikarus::Value::Schema::ConstantSchema ? static_cast<const Ikarus::Value::ConstantSchema *>(value_schema()) : nullptr;
  }
  const Ikarus::Value::SimpleSchema *value_schema_as_SimpleSchema() const {
    return value_schema_type() == Ikarus::Value::Schema::SimpleSchema ? static_cast<const Ikarus::Value::SimpleSchema *>(value_schema()) : nullptr;
  }
  const Ikarus::Value::CombinedSchema *value_schema_as_CombinedSchema() const {
    return value_schema_type() == Ikarus::Value::Schema::CombinedSchema ? static_cast<const Ikarus::Value::CombinedSchema *>(value_schema()) : nullptr;
  }
  const Ikarus::Value::ListSchema *value_schema_as_ListSchema() const {
    return value_schema_type() == Ikarus::Value::Schema::ListSchema ? static_cast<const Ikarus::Value::ListSchema *>(value_schema()) : nullptr;
  }
  const Ikarus::Value::ComplexSchema *value_schema_as_ComplexSchema() const {
    return value_schema_type() == Ikarus::Value::Schema::ComplexSchema ? static_cast<const Ikarus::Value::ComplexSchema *>(value_schema()) : nullptr;
  }
  Ikarus::Value::Data default_value_type() const {
    return static_cast<Ikarus::Value::Data>(GetField<uint8_t>(VT_DEFAULT_VALUE_TYPE, 0));
  }
  const void *default_value() const {
    return GetPointer<const void *>(VT_DEFAULT_VALUE);
  }
  template<typename T> const T *default_value_as() const;
  const Ikarus::Value::ToggleDataPoint *default_value_as_ToggleDataPoint() const {
    return default_value_type() == Ikarus::Value::Data::ToggleDataPoint ? static_cast<const Ikarus::Value::ToggleDataPoint *>(default_value()) : nullptr;
  }
  const Ikarus::Value::NumberDataPoint *default_value_as_NumberDataPoint() const {
    return default_value_type() == Ikarus::Value::Data::NumberDataPoint ? static_cast<const Ikarus::Value::NumberDataPoint *>(default_value()) : nullptr;
  }
  const Ikarus::Value::TextDataPoint *default_value_as_TextDataPoint() const {
    return default_value_type() == Ikarus::Value::Data::TextDataPoint ? static_cast<const Ikarus::Value::TextDataPoint *>(default_value()) : nullptr;
  }
  const Ikarus::Value::SimpleData *default_value_as_SimpleData() const {
    return default_value_type() == Ikarus::Value::Data::SimpleData ? static_cast<const Ikarus::Value::SimpleData *>(default_value()) : nullptr;
  }
  const Ikarus::Value::CombinedData *default_value_as_CombinedData() const {
    return default_value_type() == Ikarus::Value::Data::CombinedData ? static_cast<const Ikarus::Value::CombinedData *>(default_value()) : nullptr;
  }
  const Ikarus::Value::ListData *default_value_as_ListData() const {
    return default_value_type() == Ikarus::Value::Data::ListData ? static_cast<const Ikarus::Value::ListData *>(default_value()) : nullptr;
  }
  const Ikarus::Value::ComplexData *default_value_as_ComplexData() const {
    return default_value_type() == Ikarus::Value::Data::ComplexData ? static_cast<const Ikarus::Value::ComplexData *>(default_value()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_ID, 8) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_DESCRIPTION) &&
           verifier.VerifyString(description()) &&
           VerifyOffset(verifier, VT_TAGS) &&
           verifier.VerifyVector(tags()) &&
           verifier.VerifyVectorOfStrings(tags()) &&
           VerifyField<uint8_t>(verifier, VT_VALUE_SCHEMA_TYPE, 1) &&
           VerifyOffset(verifier, VT_VALUE_SCHEMA) &&
           VerifySchema(verifier, value_schema(), value_schema_type()) &&
           VerifyField<uint8_t>(verifier, VT_DEFAULT_VALUE_TYPE, 1) &&
           VerifyOffset(verifier, VT_DEFAULT_VALUE) &&
           VerifyData(verifier, default_value(), default_value_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ConstantSchema *Property::value_schema_as<Ikarus::Value::ConstantSchema>() const {
  return value_schema_as_ConstantSchema();
}

template<> inline const Ikarus::Value::SimpleSchema *Property::value_schema_as<Ikarus::Value::SimpleSchema>() const {
  return value_schema_as_SimpleSchema();
}

template<> inline const Ikarus::Value::CombinedSchema *Property::value_schema_as<Ikarus::Value::CombinedSchema>() const {
  return value_schema_as_CombinedSchema();
}

template<> inline const Ikarus::Value::ListSchema *Property::value_schema_as<Ikarus::Value::ListSchema>() const {
  return value_schema_as_ListSchema();
}

template<> inline const Ikarus::Value::ComplexSchema *Property::value_schema_as<Ikarus::Value::ComplexSchema>() const {
  return value_schema_as_ComplexSchema();
}

template<> inline const Ikarus::Value::ToggleDataPoint *Property::default_value_as<Ikarus::Value::ToggleDataPoint>() const {
  return default_value_as_ToggleDataPoint();
}

template<> inline const Ikarus::Value::NumberDataPoint *Property::default_value_as<Ikarus::Value::NumberDataPoint>() const {
  return default_value_as_NumberDataPoint();
}

template<> inline const Ikarus::Value::TextDataPoint *Property::default_value_as<Ikarus::Value::TextDataPoint>() const {
  return default_value_as_TextDataPoint();
}

template<> inline const Ikarus::Value::SimpleData *Property::default_value_as<Ikarus::Value::SimpleData>() const {
  return default_value_as_SimpleData();
}

template<> inline const Ikarus::Value::CombinedData *Property::default_value_as<Ikarus::Value::CombinedData>() const {
  return default_value_as_CombinedData();
}

template<> inline const Ikarus::Value::ListData *Property::default_value_as<Ikarus::Value::ListData>() const {
  return default_value_as_ListData();
}

template<> inline const Ikarus::Value::ComplexData *Property::default_value_as<Ikarus::Value::ComplexData>() const {
  return default_value_as_ComplexData();
}

struct PropertyBuilder {
  typedef Property Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(int64_t id) {
    fbb_.AddElement<int64_t>(Property::VT_ID, id, 0);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Property::VT_NAME, name);
  }
  void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
    fbb_.AddOffset(Property::VT_DESCRIPTION, description);
  }
  void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) {
    fbb_.AddOffset(Property::VT_TAGS, tags);
  }
  void add_value_schema_type(Ikarus::Value::Schema value_schema_type) {
    fbb_.AddElement<uint8_t>(Property::VT_VALUE_SCHEMA_TYPE, static_cast<uint8_t>(value_schema_type), 0);
  }
  void add_value_schema(::flatbuffers::Offset<void> value_schema) {
    fbb_.AddOffset(Property::VT_VALUE_SCHEMA, value_schema);
  }
  void add_default_value_type(Ikarus::Value::Data default_value_type) {
    fbb_.AddElement<uint8_t>(Property::VT_DEFAULT_VALUE_TYPE, static_cast<uint8_t>(default_value_type), 0);
  }
  void add_default_value(::flatbuffers::Offset<void> default_value) {
    fbb_.AddOffset(Property::VT_DEFAULT_VALUE, default_value);
  }
  explicit PropertyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Property> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Property>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Property> CreateProperty(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::String> description = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0,
    Ikarus::Value::Schema value_schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> value_schema = 0,
    Ikarus::Value::Data default_value_type = Ikarus::Value::Data::NONE,
    ::flatbuffers::Offset<void> default_value = 0) {
  PropertyBuilder builder_(_fbb);
  builder_.add_id(id);
  builder_.add_default_value(default_value);
  builder_.add_value_schema(value_schema);
  builder_.add_tags(tags);
  builder_.add_description(description);
  builder_.add_name(name);
  builder_.add_default_value_type(default_value_type);
  builder_.add_value_schema_type(value_schema_type);
  return builder_.Finish();
}

struct Property::Traits {
  using type = Property;
  static auto constexpr Create = CreateProperty;
};

inline ::flatbuffers::Offset<Property> CreatePropertyDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t id = 0,
    const char *name = nullptr,
    const char *description = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr,
    Ikarus::Value::Schema value_schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> value_schema = 0,
    Ikarus::Value::Data default_value_type = Ikarus::Value::Data::NONE,
    ::flatbuffers::Offset<void> default_value = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto description__ = description ? _fbb.CreateString(description) : 0;
  auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0;
  return Ikarus::CreateProperty(
      _fbb,
      id,
      name__,
      description__,
      tags__,
      value_schema_type,
      value_schema,
      default_value_type,
      default_value);
}

inline const Ikarus::Property *GetProperty(const void *buf) {
  return ::flatbuffers::GetRoot<Ikarus::Property>(buf);
}

inline const Ikarus::Property *GetSizePrefixedProperty(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<Ikarus::Property>(buf);
}

inline bool VerifyPropertyBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<Ikarus::Property>(nullptr);
}

inline bool VerifySizePrefixedPropertyBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<Ikarus::Property>(nullptr);
}

inline void FinishPropertyBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Ikarus::Property> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedPropertyBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Ikarus::Property> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace Ikarus

#endif  // FLATBUFFERS_GENERATED_PROPERTY_IKARUS_H_