/src/gdal/frmts/icechunk/generated/snapshot_generated.h

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


#ifndef FLATBUFFERS_GENERATED_SNAPSHOT_GENERATED_H_
#define FLATBUFFERS_GENERATED_SNAPSHOT_GENERATED_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 == 2 &&
              FLATBUFFERS_VERSION_MINOR == 0 &&
              FLATBUFFERS_VERSION_REVISION == 8,
             "Non-compatible flatbuffers version included");

#include "common_generated.h"

namespace generated {

struct ManifestFileInfo;

struct ManifestFileInfoV2;
struct ManifestFileInfoV2Builder;

struct ChunkIndexRange;

struct ManifestRef;
struct ManifestRefBuilder;

struct DimensionShape;

struct DimensionShapeV2;
struct DimensionShapeV2Builder;

struct DimensionName;
struct DimensionNameBuilder;

struct GroupNodeData;
struct GroupNodeDataBuilder;

struct ArrayNodeData;
struct ArrayNodeDataBuilder;

struct NodeSnapshot;
struct NodeSnapshotBuilder;

struct Snapshot;
struct SnapshotBuilder;

enum class NodeData : uint8_t {
  NONE = 0,
  Array = 1,
  Group = 2,
  MIN = NONE,
  MAX = Group
};

inline const NodeData (&EnumValuesNodeData())[3] {
  static const NodeData values[] = {
    NodeData::NONE,
    NodeData::Array,
    NodeData::Group
  };
  return values;
}

inline const char * const *EnumNamesNodeData() {
  static const char * const names[4] = {
    "NONE",
    "Array",
    "Group",
    nullptr
  };
  return names;
}

inline const char *EnumNameNodeData(NodeData e) {
  if (flatbuffers::IsOutRange(e, NodeData::NONE, NodeData::Group)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesNodeData()[index];
}

template<typename T> struct NodeDataTraits {
  static const NodeData enum_value = NodeData::NONE;
};

template<> struct NodeDataTraits<generated::ArrayNodeData> {
  static const NodeData enum_value = NodeData::Array;
};

template<> struct NodeDataTraits<generated::GroupNodeData> {
  static const NodeData enum_value = NodeData::Group;
};

bool VerifyNodeData(flatbuffers::Verifier &verifier, const void *obj, NodeData type);
bool VerifyNodeDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<NodeData> *types);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ManifestFileInfo FLATBUFFERS_FINAL_CLASS {
 private:
  generated::ObjectId12 id_;
  int32_t padding0__;
  uint64_t size_bytes_;
  uint32_t num_chunk_refs_;
  int32_t padding1__;

 public:
  struct Traits;
  ManifestFileInfo()
      : id_(),
        padding0__(0),
        size_bytes_(0),
        num_chunk_refs_(0),
        padding1__(0) {
    (void)padding0__;
    (void)padding1__;
  }
  ManifestFileInfo(const generated::ObjectId12 &_id, uint64_t _size_bytes, uint32_t _num_chunk_refs)
      : id_(_id),
        padding0__(0),
        size_bytes_(flatbuffers::EndianScalar(_size_bytes)),
        num_chunk_refs_(flatbuffers::EndianScalar(_num_chunk_refs)),
        padding1__(0) {
    (void)padding0__;
    (void)padding1__;
  }
  const generated::ObjectId12 &id() const {
    return id_;
  }
  uint64_t size_bytes() const {
    return flatbuffers::EndianScalar(size_bytes_);
  }
  uint32_t num_chunk_refs() const {
    return flatbuffers::EndianScalar(num_chunk_refs_);
  }
};
FLATBUFFERS_STRUCT_END(ManifestFileInfo, 32);

struct ManifestFileInfo::Traits {
  using type = ManifestFileInfo;
};

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) ChunkIndexRange FLATBUFFERS_FINAL_CLASS {
 private:
  uint32_t from_;
  uint32_t to_;

 public:
  struct Traits;
  ChunkIndexRange()
      : from_(0),
        to_(0) {
  }
  ChunkIndexRange(uint32_t _from, uint32_t _to)
      : from_(flatbuffers::EndianScalar(_from)),
        to_(flatbuffers::EndianScalar(_to)) {
  }
  uint32_t from() const {
    return flatbuffers::EndianScalar(from_);
  }
  uint32_t to() const {
    return flatbuffers::EndianScalar(to_);
  }
};
FLATBUFFERS_STRUCT_END(ChunkIndexRange, 8);

struct ChunkIndexRange::Traits {
  using type = ChunkIndexRange;
};

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) DimensionShape FLATBUFFERS_FINAL_CLASS {
 private:
  uint64_t array_length_;
  uint64_t chunk_length_;

 public:
  struct Traits;
  DimensionShape()
      : array_length_(0),
        chunk_length_(0) {
  }
  DimensionShape(uint64_t _array_length, uint64_t _chunk_length)
      : array_length_(flatbuffers::EndianScalar(_array_length)),
        chunk_length_(flatbuffers::EndianScalar(_chunk_length)) {
  }
  uint64_t array_length() const {
    return flatbuffers::EndianScalar(array_length_);
  }
  uint64_t chunk_length() const {
    return flatbuffers::EndianScalar(chunk_length_);
  }
};
FLATBUFFERS_STRUCT_END(DimensionShape, 16);

struct DimensionShape::Traits {
  using type = DimensionShape;
};

struct ManifestFileInfoV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ManifestFileInfoV2Builder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_SIZE_BYTES = 6,
    VT_NUM_CHUNK_REFS = 8,
    VT_EXTRA = 10
  };
  const generated::ObjectId12 *id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_ID);
  }
  uint64_t size_bytes() const {
    return GetField<uint64_t>(VT_SIZE_BYTES, 0);
  }
  uint32_t num_chunk_refs() const {
    return GetField<uint32_t>(VT_NUM_CHUNK_REFS, 0);
  }
  const flatbuffers::Vector<uint8_t> *extra() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTRA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<generated::ObjectId12>(verifier, VT_ID, 1) &&
           VerifyField<uint64_t>(verifier, VT_SIZE_BYTES, 8) &&
           VerifyField<uint32_t>(verifier, VT_NUM_CHUNK_REFS, 4) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.EndTable();
  }
};

struct ManifestFileInfoV2Builder {
  typedef ManifestFileInfoV2 Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(const generated::ObjectId12 *id) {
    fbb_.AddStruct(ManifestFileInfoV2::VT_ID, id);
  }
  void add_size_bytes(uint64_t size_bytes) {
    fbb_.AddElement<uint64_t>(ManifestFileInfoV2::VT_SIZE_BYTES, size_bytes, 0);
  }
  void add_num_chunk_refs(uint32_t num_chunk_refs) {
    fbb_.AddElement<uint32_t>(ManifestFileInfoV2::VT_NUM_CHUNK_REFS, num_chunk_refs, 0);
  }
  void add_extra(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra) {
    fbb_.AddOffset(ManifestFileInfoV2::VT_EXTRA, extra);
  }
  explicit ManifestFileInfoV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ManifestFileInfoV2> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ManifestFileInfoV2>(end);
    return o;
  }
};

inline flatbuffers::Offset<ManifestFileInfoV2> CreateManifestFileInfoV2(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *id = nullptr,
    uint64_t size_bytes = 0,
    uint32_t num_chunk_refs = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra = 0) {
  ManifestFileInfoV2Builder builder_(_fbb);
  builder_.add_size_bytes(size_bytes);
  builder_.add_extra(extra);
  builder_.add_num_chunk_refs(num_chunk_refs);
  builder_.add_id(id);
  return builder_.Finish();
}

struct ManifestFileInfoV2::Traits {
  using type = ManifestFileInfoV2;
  static auto constexpr Create = CreateManifestFileInfoV2;
};

inline flatbuffers::Offset<ManifestFileInfoV2> CreateManifestFileInfoV2Direct(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *id = nullptr,
    uint64_t size_bytes = 0,
    uint32_t num_chunk_refs = 0,
    const std::vector<uint8_t> *extra = nullptr) {
  auto extra__ = extra ? _fbb.CreateVector<uint8_t>(*extra) : 0;
  return generated::CreateManifestFileInfoV2(
      _fbb,
      id,
      size_bytes,
      num_chunk_refs,
      extra__);
}

struct ManifestRef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ManifestRefBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_EXTENTS = 6
  };
  const generated::ObjectId12 *object_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_OBJECT_ID);
  }
  const flatbuffers::Vector<const generated::ChunkIndexRange *> *extents() const {
    return GetPointer<const flatbuffers::Vector<const generated::ChunkIndexRange *> *>(VT_EXTENTS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_OBJECT_ID, 1) &&
           VerifyOffsetRequired(verifier, VT_EXTENTS) &&
           verifier.VerifyVector(extents()) &&
           verifier.EndTable();
  }
};

struct ManifestRefBuilder {
  typedef ManifestRef Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(const generated::ObjectId12 *object_id) {
    fbb_.AddStruct(ManifestRef::VT_OBJECT_ID, object_id);
  }
  void add_extents(flatbuffers::Offset<flatbuffers::Vector<const generated::ChunkIndexRange *>> extents) {
    fbb_.AddOffset(ManifestRef::VT_EXTENTS, extents);
  }
  explicit ManifestRefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ManifestRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ManifestRef>(end);
    fbb_.Required(o, ManifestRef::VT_OBJECT_ID);
    fbb_.Required(o, ManifestRef::VT_EXTENTS);
    return o;
  }
};

inline flatbuffers::Offset<ManifestRef> CreateManifestRef(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *object_id = nullptr,
    flatbuffers::Offset<flatbuffers::Vector<const generated::ChunkIndexRange *>> extents = 0) {
  ManifestRefBuilder builder_(_fbb);
  builder_.add_extents(extents);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

struct ManifestRef::Traits {
  using type = ManifestRef;
  static auto constexpr Create = CreateManifestRef;
};

inline flatbuffers::Offset<ManifestRef> CreateManifestRefDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *object_id = nullptr,
    const std::vector<generated::ChunkIndexRange> *extents = nullptr) {
  auto extents__ = extents ? _fbb.CreateVectorOfStructs<generated::ChunkIndexRange>(*extents) : 0;
  return generated::CreateManifestRef(
      _fbb,
      object_id,
      extents__);
}

struct DimensionShapeV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef DimensionShapeV2Builder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ARRAY_LENGTH = 4,
    VT_NUM_CHUNKS = 6
  };
  uint64_t array_length() const {
    return GetField<uint64_t>(VT_ARRAY_LENGTH, 0);
  }
  uint32_t num_chunks() const {
    return GetField<uint32_t>(VT_NUM_CHUNKS, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ARRAY_LENGTH, 8) &&
           VerifyField<uint32_t>(verifier, VT_NUM_CHUNKS, 4) &&
           verifier.EndTable();
  }
};

struct DimensionShapeV2Builder {
  typedef DimensionShapeV2 Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_array_length(uint64_t array_length) {
    fbb_.AddElement<uint64_t>(DimensionShapeV2::VT_ARRAY_LENGTH, array_length, 0);
  }
  void add_num_chunks(uint32_t num_chunks) {
    fbb_.AddElement<uint32_t>(DimensionShapeV2::VT_NUM_CHUNKS, num_chunks, 0);
  }
  explicit DimensionShapeV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<DimensionShapeV2> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<DimensionShapeV2>(end);
    return o;
  }
};

inline flatbuffers::Offset<DimensionShapeV2> CreateDimensionShapeV2(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t array_length = 0,
    uint32_t num_chunks = 0) {
  DimensionShapeV2Builder builder_(_fbb);
  builder_.add_array_length(array_length);
  builder_.add_num_chunks(num_chunks);
  return builder_.Finish();
}

struct DimensionShapeV2::Traits {
  using type = DimensionShapeV2;
  static auto constexpr Create = CreateDimensionShapeV2;
};

struct DimensionName FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef DimensionNameBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};

struct DimensionNameBuilder {
  typedef DimensionName Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(DimensionName::VT_NAME, name);
  }
  explicit DimensionNameBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<DimensionName> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<DimensionName>(end);
    return o;
  }
};

inline flatbuffers::Offset<DimensionName> CreateDimensionName(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0) {
  DimensionNameBuilder builder_(_fbb);
  builder_.add_name(name);
  return builder_.Finish();
}

struct DimensionName::Traits {
  using type = DimensionName;
  static auto constexpr Create = CreateDimensionName;
};

inline flatbuffers::Offset<DimensionName> CreateDimensionNameDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return generated::CreateDimensionName(
      _fbb,
      name__);
}

struct GroupNodeData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GroupNodeDataBuilder Builder;
  struct Traits;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct GroupNodeDataBuilder {
  typedef GroupNodeData Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit GroupNodeDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GroupNodeData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GroupNodeData>(end);
    return o;
  }
};

inline flatbuffers::Offset<GroupNodeData> CreateGroupNodeData(
    flatbuffers::FlatBufferBuilder &_fbb) {
  GroupNodeDataBuilder builder_(_fbb);
  return builder_.Finish();
}

struct GroupNodeData::Traits {
  using type = GroupNodeData;
  static auto constexpr Create = CreateGroupNodeData;
};

struct ArrayNodeData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ArrayNodeDataBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_DIMENSION_NAMES = 6,
    VT_MANIFESTS = 8,
    VT_SHAPE_V2 = 10
  };
  const flatbuffers::Vector<const generated::DimensionShape *> *shape() const {
    return GetPointer<const flatbuffers::Vector<const generated::DimensionShape *> *>(VT_SHAPE);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::DimensionName>> *dimension_names() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::DimensionName>> *>(VT_DIMENSION_NAMES);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::ManifestRef>> *manifests() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::ManifestRef>> *>(VT_MANIFESTS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::DimensionShapeV2>> *shape_v2() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::DimensionShapeV2>> *>(VT_SHAPE_V2);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyOffset(verifier, VT_DIMENSION_NAMES) &&
           verifier.VerifyVector(dimension_names()) &&
           verifier.VerifyVectorOfTables(dimension_names()) &&
           VerifyOffsetRequired(verifier, VT_MANIFESTS) &&
           verifier.VerifyVector(manifests()) &&
           verifier.VerifyVectorOfTables(manifests()) &&
           VerifyOffset(verifier, VT_SHAPE_V2) &&
           verifier.VerifyVector(shape_v2()) &&
           verifier.VerifyVectorOfTables(shape_v2()) &&
           verifier.EndTable();
  }
};

struct ArrayNodeDataBuilder {
  typedef ArrayNodeData Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_shape(flatbuffers::Offset<flatbuffers::Vector<const generated::DimensionShape *>> shape) {
    fbb_.AddOffset(ArrayNodeData::VT_SHAPE, shape);
  }
  void add_dimension_names(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::DimensionName>>> dimension_names) {
    fbb_.AddOffset(ArrayNodeData::VT_DIMENSION_NAMES, dimension_names);
  }
  void add_manifests(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ManifestRef>>> manifests) {
    fbb_.AddOffset(ArrayNodeData::VT_MANIFESTS, manifests);
  }
  void add_shape_v2(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::DimensionShapeV2>>> shape_v2) {
    fbb_.AddOffset(ArrayNodeData::VT_SHAPE_V2, shape_v2);
  }
  explicit ArrayNodeDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ArrayNodeData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ArrayNodeData>(end);
    fbb_.Required(o, ArrayNodeData::VT_SHAPE);
    fbb_.Required(o, ArrayNodeData::VT_MANIFESTS);
    return o;
  }
};

inline flatbuffers::Offset<ArrayNodeData> CreateArrayNodeData(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<const generated::DimensionShape *>> shape = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::DimensionName>>> dimension_names = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ManifestRef>>> manifests = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::DimensionShapeV2>>> shape_v2 = 0) {
  ArrayNodeDataBuilder builder_(_fbb);
  builder_.add_shape_v2(shape_v2);
  builder_.add_manifests(manifests);
  builder_.add_dimension_names(dimension_names);
  builder_.add_shape(shape);
  return builder_.Finish();
}

struct ArrayNodeData::Traits {
  using type = ArrayNodeData;
  static auto constexpr Create = CreateArrayNodeData;
};

inline flatbuffers::Offset<ArrayNodeData> CreateArrayNodeDataDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<generated::DimensionShape> *shape = nullptr,
    const std::vector<flatbuffers::Offset<generated::DimensionName>> *dimension_names = nullptr,
    const std::vector<flatbuffers::Offset<generated::ManifestRef>> *manifests = nullptr,
    const std::vector<flatbuffers::Offset<generated::DimensionShapeV2>> *shape_v2 = nullptr) {
  auto shape__ = shape ? _fbb.CreateVectorOfStructs<generated::DimensionShape>(*shape) : 0;
  auto dimension_names__ = dimension_names ? _fbb.CreateVector<flatbuffers::Offset<generated::DimensionName>>(*dimension_names) : 0;
  auto manifests__ = manifests ? _fbb.CreateVector<flatbuffers::Offset<generated::ManifestRef>>(*manifests) : 0;
  auto shape_v2__ = shape_v2 ? _fbb.CreateVector<flatbuffers::Offset<generated::DimensionShapeV2>>(*shape_v2) : 0;
  return generated::CreateArrayNodeData(
      _fbb,
      shape__,
      dimension_names__,
      manifests__,
      shape_v2__);
}

struct NodeSnapshot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NodeSnapshotBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_PATH = 6,
    VT_USER_DATA = 8,
    VT_NODE_DATA_TYPE = 10,
    VT_NODE_DATA = 12,
    VT_EXTRA = 14
  };
  const generated::ObjectId8 *id() const {
    return GetStruct<const generated::ObjectId8 *>(VT_ID);
  }
  const flatbuffers::String *path() const {
    return GetPointer<const flatbuffers::String *>(VT_PATH);
  }
  const flatbuffers::Vector<uint8_t> *user_data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_USER_DATA);
  }
  generated::NodeData node_data_type() const {
    return static_cast<generated::NodeData>(GetField<uint8_t>(VT_NODE_DATA_TYPE, 0));
  }
  const void *node_data() const {
    return GetPointer<const void *>(VT_NODE_DATA);
  }
  template<typename T> const T *node_data_as() const;
  const generated::ArrayNodeData *node_data_as_Array() const {
    return node_data_type() == generated::NodeData::Array ? static_cast<const generated::ArrayNodeData *>(node_data()) : nullptr;
  }
  const generated::GroupNodeData *node_data_as_Group() const {
    return node_data_type() == generated::NodeData::Group ? static_cast<const generated::GroupNodeData *>(node_data()) : nullptr;
  }
  const flatbuffers::Vector<uint8_t> *extra() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTRA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyFieldRequired<generated::ObjectId8>(verifier, VT_ID, 1) &&
           VerifyOffsetRequired(verifier, VT_PATH) &&
           verifier.VerifyString(path()) &&
           VerifyOffsetRequired(verifier, VT_USER_DATA) &&
           verifier.VerifyVector(user_data()) &&
           VerifyField<uint8_t>(verifier, VT_NODE_DATA_TYPE, 1) &&
           VerifyOffsetRequired(verifier, VT_NODE_DATA) &&
           VerifyNodeData(verifier, node_data(), node_data_type()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.EndTable();
  }
};

template<> inline const generated::ArrayNodeData *NodeSnapshot::node_data_as<generated::ArrayNodeData>() const {
  return node_data_as_Array();
}

template<> inline const generated::GroupNodeData *NodeSnapshot::node_data_as<generated::GroupNodeData>() const {
  return node_data_as_Group();
}

struct NodeSnapshotBuilder {
  typedef NodeSnapshot Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(const generated::ObjectId8 *id) {
    fbb_.AddStruct(NodeSnapshot::VT_ID, id);
  }
  void add_path(flatbuffers::Offset<flatbuffers::String> path) {
    fbb_.AddOffset(NodeSnapshot::VT_PATH, path);
  }
  void add_user_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> user_data) {
    fbb_.AddOffset(NodeSnapshot::VT_USER_DATA, user_data);
  }
  void add_node_data_type(generated::NodeData node_data_type) {
    fbb_.AddElement<uint8_t>(NodeSnapshot::VT_NODE_DATA_TYPE, static_cast<uint8_t>(node_data_type), 0);
  }
  void add_node_data(flatbuffers::Offset<void> node_data) {
    fbb_.AddOffset(NodeSnapshot::VT_NODE_DATA, node_data);
  }
  void add_extra(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra) {
    fbb_.AddOffset(NodeSnapshot::VT_EXTRA, extra);
  }
  explicit NodeSnapshotBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<NodeSnapshot> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NodeSnapshot>(end);
    fbb_.Required(o, NodeSnapshot::VT_ID);
    fbb_.Required(o, NodeSnapshot::VT_PATH);
    fbb_.Required(o, NodeSnapshot::VT_USER_DATA);
    fbb_.Required(o, NodeSnapshot::VT_NODE_DATA);
    return o;
  }
};

inline flatbuffers::Offset<NodeSnapshot> CreateNodeSnapshot(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId8 *id = nullptr,
    flatbuffers::Offset<flatbuffers::String> path = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> user_data = 0,
    generated::NodeData node_data_type = generated::NodeData::NONE,
    flatbuffers::Offset<void> node_data = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra = 0) {
  NodeSnapshotBuilder builder_(_fbb);
  builder_.add_extra(extra);
  builder_.add_node_data(node_data);
  builder_.add_user_data(user_data);
  builder_.add_path(path);
  builder_.add_id(id);
  builder_.add_node_data_type(node_data_type);
  return builder_.Finish();
}

struct NodeSnapshot::Traits {
  using type = NodeSnapshot;
  static auto constexpr Create = CreateNodeSnapshot;
};

inline flatbuffers::Offset<NodeSnapshot> CreateNodeSnapshotDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId8 *id = nullptr,
    const char *path = nullptr,
    const std::vector<uint8_t> *user_data = nullptr,
    generated::NodeData node_data_type = generated::NodeData::NONE,
    flatbuffers::Offset<void> node_data = 0,
    const std::vector<uint8_t> *extra = nullptr) {
  auto path__ = path ? _fbb.CreateString(path) : 0;
  auto user_data__ = user_data ? _fbb.CreateVector<uint8_t>(*user_data) : 0;
  auto extra__ = extra ? _fbb.CreateVector<uint8_t>(*extra) : 0;
  return generated::CreateNodeSnapshot(
      _fbb,
      id,
      path__,
      user_data__,
      node_data_type,
      node_data,
      extra__);
}

struct Snapshot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SnapshotBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_PARENT_ID = 6,
    VT_NODES = 8,
    VT_FLUSHED_AT = 10,
    VT_MESSAGE = 12,
    VT_METADATA = 14,
    VT_MANIFEST_FILES = 16,
    VT_MANIFEST_FILES_V2 = 18,
    VT_EXTRA = 20
  };
  const generated::ObjectId12 *id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_ID);
  }
  const generated::ObjectId12 *parent_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_PARENT_ID);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::NodeSnapshot>> *nodes() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::NodeSnapshot>> *>(VT_NODES);
  }
  uint64_t flushed_at() const {
    return GetField<uint64_t>(VT_FLUSHED_AT, 0);
  }
  const flatbuffers::String *message() const {
    return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>> *metadata() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>> *>(VT_METADATA);
  }
  const flatbuffers::Vector<const generated::ManifestFileInfo *> *manifest_files() const {
    return GetPointer<const flatbuffers::Vector<const generated::ManifestFileInfo *> *>(VT_MANIFEST_FILES);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::ManifestFileInfoV2>> *manifest_files_v2() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::ManifestFileInfoV2>> *>(VT_MANIFEST_FILES_V2);
  }
  const flatbuffers::Vector<uint8_t> *extra() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTRA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_ID, 1) &&
           VerifyField<generated::ObjectId12>(verifier, VT_PARENT_ID, 1) &&
           VerifyOffsetRequired(verifier, VT_NODES) &&
           verifier.VerifyVector(nodes()) &&
           verifier.VerifyVectorOfTables(nodes()) &&
           VerifyField<uint64_t>(verifier, VT_FLUSHED_AT, 8) &&
           VerifyOffsetRequired(verifier, VT_MESSAGE) &&
           verifier.VerifyString(message()) &&
           VerifyOffsetRequired(verifier, VT_METADATA) &&
           verifier.VerifyVector(metadata()) &&
           verifier.VerifyVectorOfTables(metadata()) &&
           VerifyOffsetRequired(verifier, VT_MANIFEST_FILES) &&
           verifier.VerifyVector(manifest_files()) &&
           VerifyOffset(verifier, VT_MANIFEST_FILES_V2) &&
           verifier.VerifyVector(manifest_files_v2()) &&
           verifier.VerifyVectorOfTables(manifest_files_v2()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.EndTable();
  }
};

struct SnapshotBuilder {
  typedef Snapshot Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(const generated::ObjectId12 *id) {
    fbb_.AddStruct(Snapshot::VT_ID, id);
  }
  void add_parent_id(const generated::ObjectId12 *parent_id) {
    fbb_.AddStruct(Snapshot::VT_PARENT_ID, parent_id);
  }
  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::NodeSnapshot>>> nodes) {
    fbb_.AddOffset(Snapshot::VT_NODES, nodes);
  }
  void add_flushed_at(uint64_t flushed_at) {
    fbb_.AddElement<uint64_t>(Snapshot::VT_FLUSHED_AT, flushed_at, 0);
  }
  void add_message(flatbuffers::Offset<flatbuffers::String> message) {
    fbb_.AddOffset(Snapshot::VT_MESSAGE, message);
  }
  void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>>> metadata) {
    fbb_.AddOffset(Snapshot::VT_METADATA, metadata);
  }
  void add_manifest_files(flatbuffers::Offset<flatbuffers::Vector<const generated::ManifestFileInfo *>> manifest_files) {
    fbb_.AddOffset(Snapshot::VT_MANIFEST_FILES, manifest_files);
  }
  void add_manifest_files_v2(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ManifestFileInfoV2>>> manifest_files_v2) {
    fbb_.AddOffset(Snapshot::VT_MANIFEST_FILES_V2, manifest_files_v2);
  }
  void add_extra(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra) {
    fbb_.AddOffset(Snapshot::VT_EXTRA, extra);
  }
  explicit SnapshotBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<Snapshot> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Snapshot>(end);
    fbb_.Required(o, Snapshot::VT_ID);
    fbb_.Required(o, Snapshot::VT_NODES);
    fbb_.Required(o, Snapshot::VT_MESSAGE);
    fbb_.Required(o, Snapshot::VT_METADATA);
    fbb_.Required(o, Snapshot::VT_MANIFEST_FILES);
    return o;
  }
};

inline flatbuffers::Offset<Snapshot> CreateSnapshot(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *id = nullptr,
    const generated::ObjectId12 *parent_id = nullptr,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::NodeSnapshot>>> nodes = 0,
    uint64_t flushed_at = 0,
    flatbuffers::Offset<flatbuffers::String> message = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>>> metadata = 0,
    flatbuffers::Offset<flatbuffers::Vector<const generated::ManifestFileInfo *>> manifest_files = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::ManifestFileInfoV2>>> manifest_files_v2 = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra = 0) {
  SnapshotBuilder builder_(_fbb);
  builder_.add_flushed_at(flushed_at);
  builder_.add_extra(extra);
  builder_.add_manifest_files_v2(manifest_files_v2);
  builder_.add_manifest_files(manifest_files);
  builder_.add_metadata(metadata);
  builder_.add_message(message);
  builder_.add_nodes(nodes);
  builder_.add_parent_id(parent_id);
  builder_.add_id(id);
  return builder_.Finish();
}

struct Snapshot::Traits {
  using type = Snapshot;
  static auto constexpr Create = CreateSnapshot;
};

inline flatbuffers::Offset<Snapshot> CreateSnapshotDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *id = nullptr,
    const generated::ObjectId12 *parent_id = nullptr,
    const std::vector<flatbuffers::Offset<generated::NodeSnapshot>> *nodes = nullptr,
    uint64_t flushed_at = 0,
    const char *message = nullptr,
    const std::vector<flatbuffers::Offset<generated::MetadataItem>> *metadata = nullptr,
    const std::vector<generated::ManifestFileInfo> *manifest_files = nullptr,
    const std::vector<flatbuffers::Offset<generated::ManifestFileInfoV2>> *manifest_files_v2 = nullptr,
    const std::vector<uint8_t> *extra = nullptr) {
  auto nodes__ = nodes ? _fbb.CreateVector<flatbuffers::Offset<generated::NodeSnapshot>>(*nodes) : 0;
  auto message__ = message ? _fbb.CreateString(message) : 0;
  auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<generated::MetadataItem>>(*metadata) : 0;
  auto manifest_files__ = manifest_files ? _fbb.CreateVectorOfStructs<generated::ManifestFileInfo>(*manifest_files) : 0;
  auto manifest_files_v2__ = manifest_files_v2 ? _fbb.CreateVector<flatbuffers::Offset<generated::ManifestFileInfoV2>>(*manifest_files_v2) : 0;
  auto extra__ = extra ? _fbb.CreateVector<uint8_t>(*extra) : 0;
  return generated::CreateSnapshot(
      _fbb,
      id,
      parent_id,
      nodes__,
      flushed_at,
      message__,
      metadata__,
      manifest_files__,
      manifest_files_v2__,
      extra__);
}

inline bool VerifyNodeData(flatbuffers::Verifier &verifier, const void *obj, NodeData type) {
  switch (type) {
    case NodeData::NONE: {
      return true;
    }
    case NodeData::Array: {
      auto ptr = reinterpret_cast<const generated::ArrayNodeData *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case NodeData::Group: {
      auto ptr = reinterpret_cast<const generated::GroupNodeData *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyNodeDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<NodeData> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyNodeData(
        verifier,  values->Get(i), types->GetEnum<NodeData>(i))) {
      return false;
    }
  }
  return true;
}

inline const generated::Snapshot *GetSnapshot(const void *buf) {
  return flatbuffers::GetRoot<generated::Snapshot>(buf);
}

inline const generated::Snapshot *GetSizePrefixedSnapshot(const void *buf) {
  return flatbuffers::GetSizePrefixedRoot<generated::Snapshot>(buf);
}

inline bool VerifySnapshotBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<generated::Snapshot>(nullptr);
}

inline bool VerifySizePrefixedSnapshotBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<generated::Snapshot>(nullptr);
}

inline void FinishSnapshotBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<generated::Snapshot> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedSnapshotBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<generated::Snapshot> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace generated

#endif  // FLATBUFFERS_GENERATED_SNAPSHOT_GENERATED_H_

Coverage Report

Created: 2026-06-30 08:33