tools/fidl/fidlgen_llcpp/goldens/table_natural_types.h.golden

// WARNING: This file is machine generated by fidlgen.

#pragma once

#include <fidl/test.table/cpp/common_types.h>
#include <fidl/test.table/cpp/markers.h>
#include <lib/fidl/cpp/natural_coding_traits.h>
#include <lib/fidl/cpp/natural_types.h>

#include <cinttypes>
#include <string>

#ifdef __Fuchsia__

#endif  // __Fuchsia__

namespace test_table {

class TableWithAttributes;

class SimpleTable;

class ReverseOrdinalTable;

class OlderSimpleTable;

class NewerSimpleTable;

class ExtensionTable;

class SixtyFourOrdinalTable;

class EmptyTable;

extern "C" const fidl_type_t test_table_TableWithAttributesTable;

class TableWithAttributes {
 private:
  struct Storage_;

 public:
  TableWithAttributes(Storage_ storage) noexcept
      : storage_(std::move(storage)) {}
  TableWithAttributes() noexcept = default;
  TableWithAttributes(TableWithAttributes&&) noexcept = default;
  TableWithAttributes& operator=(TableWithAttributes&&) noexcept = default;
  TableWithAttributes(const TableWithAttributes& other) noexcept
      : TableWithAttributes(other.CloneStorage_()) {}
  TableWithAttributes& operator=(const TableWithAttributes& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const TableWithAttributes& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::TableWithAttributes>::Equal(this, &other);
  }
  bool operator!=(const TableWithAttributes& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::TableWithAttributes>::Equal(this, &other);
  }

  bool IsEmpty() const { return !(storage_.x.has_value()); }

  const std::optional<int64_t>& x() const { return storage_.x; }
  ::std::optional<int64_t>& x() { return storage_.x; }

  TableWithAttributes(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : TableWithAttributes(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<int64_t> x{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::TableWithAttributes>;
  friend struct ::fidl::internal::MemberVisitor<
      ::test_table::TableWithAttributes>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          1, &Storage_::x});
};

extern "C" const fidl_type_t test_table_SimpleTableTable;

class SimpleTable {
 private:
  struct Storage_;

 public:
  SimpleTable(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  SimpleTable() noexcept = default;
  SimpleTable(SimpleTable&&) noexcept = default;
  SimpleTable& operator=(SimpleTable&&) noexcept = default;
  SimpleTable(const SimpleTable& other) noexcept
      : SimpleTable(other.CloneStorage_()) {}
  SimpleTable& operator=(const SimpleTable& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const SimpleTable& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::SimpleTable>::Equal(this, &other);
  }
  bool operator!=(const SimpleTable& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::SimpleTable>::Equal(this, &other);
  }

  bool IsEmpty() const {
    return !(storage_.x.has_value() || storage_.y.has_value());
  }

  const std::optional<int64_t>& x() const { return storage_.x; }
  ::std::optional<int64_t>& x() { return storage_.x; }

  const std::optional<int64_t>& y() const { return storage_.y; }
  ::std::optional<int64_t>& y() { return storage_.y; }

  SimpleTable(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : SimpleTable(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<int64_t> x{};
    ::std::optional<int64_t> y{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::SimpleTable>;
  friend struct ::fidl::internal::MemberVisitor<::test_table::SimpleTable>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          1, &Storage_::x},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          5, &Storage_::y});
};

extern "C" const fidl_type_t test_table_ReverseOrdinalTableTable;

class ReverseOrdinalTable {
 private:
  struct Storage_;

 public:
  ReverseOrdinalTable(Storage_ storage) noexcept
      : storage_(std::move(storage)) {}
  ReverseOrdinalTable() noexcept = default;
  ReverseOrdinalTable(ReverseOrdinalTable&&) noexcept = default;
  ReverseOrdinalTable& operator=(ReverseOrdinalTable&&) noexcept = default;
  ReverseOrdinalTable(const ReverseOrdinalTable& other) noexcept
      : ReverseOrdinalTable(other.CloneStorage_()) {}
  ReverseOrdinalTable& operator=(const ReverseOrdinalTable& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const ReverseOrdinalTable& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::ReverseOrdinalTable>::Equal(this, &other);
  }
  bool operator!=(const ReverseOrdinalTable& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::ReverseOrdinalTable>::Equal(this, &other);
  }

  bool IsEmpty() const {
    return !(storage_.z.has_value() || storage_.y.has_value() ||
             storage_.x.has_value());
  }

  const std::optional<int64_t>& z() const { return storage_.z; }
  ::std::optional<int64_t>& z() { return storage_.z; }

  const std::optional<int64_t>& y() const { return storage_.y; }
  ::std::optional<int64_t>& y() { return storage_.y; }

  const std::optional<int64_t>& x() const { return storage_.x; }
  ::std::optional<int64_t>& x() { return storage_.x; }

  ReverseOrdinalTable(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : ReverseOrdinalTable(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<int64_t> z{};
    ::std::optional<int64_t> y{};
    ::std::optional<int64_t> x{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::ReverseOrdinalTable>;
  friend struct ::fidl::internal::MemberVisitor<
      ::test_table::ReverseOrdinalTable>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          1, &Storage_::z},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          2, &Storage_::y},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          3, &Storage_::x});
};

extern "C" const fidl_type_t test_table_OlderSimpleTableTable;

class OlderSimpleTable {
 private:
  struct Storage_;

 public:
  OlderSimpleTable(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  OlderSimpleTable() noexcept = default;
  OlderSimpleTable(OlderSimpleTable&&) noexcept = default;
  OlderSimpleTable& operator=(OlderSimpleTable&&) noexcept = default;
  OlderSimpleTable(const OlderSimpleTable& other) noexcept
      : OlderSimpleTable(other.CloneStorage_()) {}
  OlderSimpleTable& operator=(const OlderSimpleTable& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const OlderSimpleTable& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::OlderSimpleTable>::Equal(this, &other);
  }
  bool operator!=(const OlderSimpleTable& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::OlderSimpleTable>::Equal(this, &other);
  }

  bool IsEmpty() const { return !(storage_.x.has_value()); }

  const std::optional<int64_t>& x() const { return storage_.x; }
  ::std::optional<int64_t>& x() { return storage_.x; }

  OlderSimpleTable(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : OlderSimpleTable(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<int64_t> x{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::OlderSimpleTable>;
  friend struct ::fidl::internal::MemberVisitor<::test_table::OlderSimpleTable>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          1, &Storage_::x});
};

extern "C" const fidl_type_t test_table_NewerSimpleTableTable;

class NewerSimpleTable {
 private:
  struct Storage_;

 public:
  NewerSimpleTable(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  NewerSimpleTable() noexcept = default;
  NewerSimpleTable(NewerSimpleTable&&) noexcept = default;
  NewerSimpleTable& operator=(NewerSimpleTable&&) noexcept = default;
  NewerSimpleTable(const NewerSimpleTable& other) noexcept
      : NewerSimpleTable(other.CloneStorage_()) {}
  NewerSimpleTable& operator=(const NewerSimpleTable& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const NewerSimpleTable& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::NewerSimpleTable>::Equal(this, &other);
  }
  bool operator!=(const NewerSimpleTable& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::NewerSimpleTable>::Equal(this, &other);
  }

  bool IsEmpty() const {
    return !(storage_.x.has_value() || storage_.y.has_value() ||
             storage_.z.has_value());
  }

  const std::optional<int64_t>& x() const { return storage_.x; }
  ::std::optional<int64_t>& x() { return storage_.x; }

  const std::optional<int64_t>& y() const { return storage_.y; }
  ::std::optional<int64_t>& y() { return storage_.y; }

  const std::optional<int64_t>& z() const { return storage_.z; }
  ::std::optional<int64_t>& z() { return storage_.z; }

  NewerSimpleTable(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : NewerSimpleTable(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<int64_t> x{};
    ::std::optional<int64_t> y{};
    ::std::optional<int64_t> z{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::NewerSimpleTable>;
  friend struct ::fidl::internal::MemberVisitor<::test_table::NewerSimpleTable>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          1, &Storage_::x},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          5, &Storage_::y},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          6, &Storage_::z});
};

extern "C" const fidl_type_t test_table_ExtensionTableTable;

class ExtensionTable {
 private:
  struct Storage_;

 public:
  ExtensionTable(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  ExtensionTable() noexcept = default;
  ExtensionTable(ExtensionTable&&) noexcept = default;
  ExtensionTable& operator=(ExtensionTable&&) noexcept = default;
  ExtensionTable(const ExtensionTable& other) noexcept
      : ExtensionTable(other.CloneStorage_()) {}
  ExtensionTable& operator=(const ExtensionTable& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const ExtensionTable& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::ExtensionTable>::Equal(this, &other);
  }
  bool operator!=(const ExtensionTable& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::ExtensionTable>::Equal(this, &other);
  }

  bool IsEmpty() const { return true; }

  ExtensionTable(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : ExtensionTable(Storage_{}) {}

 private:
  struct Storage_ final {};

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::ExtensionTable>;
  friend struct ::fidl::internal::MemberVisitor<::test_table::ExtensionTable>;
  static constexpr auto kMembers = std::make_tuple();
};

extern "C" const fidl_type_t test_table_SixtyFourOrdinalTableTable;

class SixtyFourOrdinalTable {
 private:
  struct Storage_;

 public:
  SixtyFourOrdinalTable(Storage_ storage) noexcept
      : storage_(std::move(storage)) {}
  SixtyFourOrdinalTable() noexcept = default;
  SixtyFourOrdinalTable(SixtyFourOrdinalTable&&) noexcept = default;
  SixtyFourOrdinalTable& operator=(SixtyFourOrdinalTable&&) noexcept = default;
  SixtyFourOrdinalTable(const SixtyFourOrdinalTable& other) noexcept
      : SixtyFourOrdinalTable(other.CloneStorage_()) {}
  SixtyFourOrdinalTable& operator=(
      const SixtyFourOrdinalTable& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const SixtyFourOrdinalTable& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::SixtyFourOrdinalTable>::Equal(this, &other);
  }
  bool operator!=(const SixtyFourOrdinalTable& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::SixtyFourOrdinalTable>::Equal(this, &other);
  }

  bool IsEmpty() const {
    return !(storage_.v1.has_value() || storage_.v2.has_value() ||
             storage_.v3.has_value() || storage_.v4.has_value() ||
             storage_.v5.has_value() || storage_.v6.has_value() ||
             storage_.v7.has_value() || storage_.v8.has_value() ||
             storage_.v9.has_value() || storage_.v10.has_value() ||
             storage_.v11.has_value() || storage_.v12.has_value() ||
             storage_.v13.has_value() || storage_.v14.has_value() ||
             storage_.v15.has_value() || storage_.v16.has_value() ||
             storage_.v17.has_value() || storage_.v18.has_value() ||
             storage_.v19.has_value() || storage_.v20.has_value() ||
             storage_.v21.has_value() || storage_.v22.has_value() ||
             storage_.v23.has_value() || storage_.v24.has_value() ||
             storage_.v25.has_value() || storage_.v26.has_value() ||
             storage_.v27.has_value() || storage_.v28.has_value() ||
             storage_.v29.has_value() || storage_.v30.has_value() ||
             storage_.v31.has_value() || storage_.v32.has_value() ||
             storage_.v33.has_value() || storage_.v34.has_value() ||
             storage_.v35.has_value() || storage_.v36.has_value() ||
             storage_.v37.has_value() || storage_.v38.has_value() ||
             storage_.v39.has_value() || storage_.v40.has_value() ||
             storage_.v41.has_value() || storage_.v42.has_value() ||
             storage_.v43.has_value() || storage_.v44.has_value() ||
             storage_.v45.has_value() || storage_.v46.has_value() ||
             storage_.v47.has_value() || storage_.v48.has_value() ||
             storage_.v49.has_value() || storage_.v50.has_value() ||
             storage_.v51.has_value() || storage_.v52.has_value() ||
             storage_.v53.has_value() || storage_.v54.has_value() ||
             storage_.v55.has_value() || storage_.v56.has_value() ||
             storage_.v57.has_value() || storage_.v58.has_value() ||
             storage_.v59.has_value() || storage_.v60.has_value() ||
             storage_.v61.has_value() || storage_.v62.has_value() ||
             storage_.v63.has_value() || storage_.v64.has_value());
  }

  const std::optional<int64_t>& v1() const { return storage_.v1; }
  ::std::optional<int64_t>& v1() { return storage_.v1; }

  const std::optional<int64_t>& v2() const { return storage_.v2; }
  ::std::optional<int64_t>& v2() { return storage_.v2; }

  const std::optional<int64_t>& v3() const { return storage_.v3; }
  ::std::optional<int64_t>& v3() { return storage_.v3; }

  const std::optional<int64_t>& v4() const { return storage_.v4; }
  ::std::optional<int64_t>& v4() { return storage_.v4; }

  const std::optional<int64_t>& v5() const { return storage_.v5; }
  ::std::optional<int64_t>& v5() { return storage_.v5; }

  const std::optional<int64_t>& v6() const { return storage_.v6; }
  ::std::optional<int64_t>& v6() { return storage_.v6; }

  const std::optional<int64_t>& v7() const { return storage_.v7; }
  ::std::optional<int64_t>& v7() { return storage_.v7; }

  const std::optional<int64_t>& v8() const { return storage_.v8; }
  ::std::optional<int64_t>& v8() { return storage_.v8; }

  const std::optional<int64_t>& v9() const { return storage_.v9; }
  ::std::optional<int64_t>& v9() { return storage_.v9; }

  const std::optional<int64_t>& v10() const { return storage_.v10; }
  ::std::optional<int64_t>& v10() { return storage_.v10; }

  const std::optional<int64_t>& v11() const { return storage_.v11; }
  ::std::optional<int64_t>& v11() { return storage_.v11; }

  const std::optional<int64_t>& v12() const { return storage_.v12; }
  ::std::optional<int64_t>& v12() { return storage_.v12; }

  const std::optional<int64_t>& v13() const { return storage_.v13; }
  ::std::optional<int64_t>& v13() { return storage_.v13; }

  const std::optional<int64_t>& v14() const { return storage_.v14; }
  ::std::optional<int64_t>& v14() { return storage_.v14; }

  const std::optional<int64_t>& v15() const { return storage_.v15; }
  ::std::optional<int64_t>& v15() { return storage_.v15; }

  const std::optional<int64_t>& v16() const { return storage_.v16; }
  ::std::optional<int64_t>& v16() { return storage_.v16; }

  const std::optional<int64_t>& v17() const { return storage_.v17; }
  ::std::optional<int64_t>& v17() { return storage_.v17; }

  const std::optional<int64_t>& v18() const { return storage_.v18; }
  ::std::optional<int64_t>& v18() { return storage_.v18; }

  const std::optional<int64_t>& v19() const { return storage_.v19; }
  ::std::optional<int64_t>& v19() { return storage_.v19; }

  const std::optional<int64_t>& v20() const { return storage_.v20; }
  ::std::optional<int64_t>& v20() { return storage_.v20; }

  const std::optional<int64_t>& v21() const { return storage_.v21; }
  ::std::optional<int64_t>& v21() { return storage_.v21; }

  const std::optional<int64_t>& v22() const { return storage_.v22; }
  ::std::optional<int64_t>& v22() { return storage_.v22; }

  const std::optional<int64_t>& v23() const { return storage_.v23; }
  ::std::optional<int64_t>& v23() { return storage_.v23; }

  const std::optional<int64_t>& v24() const { return storage_.v24; }
  ::std::optional<int64_t>& v24() { return storage_.v24; }

  const std::optional<int64_t>& v25() const { return storage_.v25; }
  ::std::optional<int64_t>& v25() { return storage_.v25; }

  const std::optional<int64_t>& v26() const { return storage_.v26; }
  ::std::optional<int64_t>& v26() { return storage_.v26; }

  const std::optional<int64_t>& v27() const { return storage_.v27; }
  ::std::optional<int64_t>& v27() { return storage_.v27; }

  const std::optional<int64_t>& v28() const { return storage_.v28; }
  ::std::optional<int64_t>& v28() { return storage_.v28; }

  const std::optional<int64_t>& v29() const { return storage_.v29; }
  ::std::optional<int64_t>& v29() { return storage_.v29; }

  const std::optional<int64_t>& v30() const { return storage_.v30; }
  ::std::optional<int64_t>& v30() { return storage_.v30; }

  const std::optional<int64_t>& v31() const { return storage_.v31; }
  ::std::optional<int64_t>& v31() { return storage_.v31; }

  const std::optional<int64_t>& v32() const { return storage_.v32; }
  ::std::optional<int64_t>& v32() { return storage_.v32; }

  const std::optional<int64_t>& v33() const { return storage_.v33; }
  ::std::optional<int64_t>& v33() { return storage_.v33; }

  const std::optional<int64_t>& v34() const { return storage_.v34; }
  ::std::optional<int64_t>& v34() { return storage_.v34; }

  const std::optional<int64_t>& v35() const { return storage_.v35; }
  ::std::optional<int64_t>& v35() { return storage_.v35; }

  const std::optional<int64_t>& v36() const { return storage_.v36; }
  ::std::optional<int64_t>& v36() { return storage_.v36; }

  const std::optional<int64_t>& v37() const { return storage_.v37; }
  ::std::optional<int64_t>& v37() { return storage_.v37; }

  const std::optional<int64_t>& v38() const { return storage_.v38; }
  ::std::optional<int64_t>& v38() { return storage_.v38; }

  const std::optional<int64_t>& v39() const { return storage_.v39; }
  ::std::optional<int64_t>& v39() { return storage_.v39; }

  const std::optional<int64_t>& v40() const { return storage_.v40; }
  ::std::optional<int64_t>& v40() { return storage_.v40; }

  const std::optional<int64_t>& v41() const { return storage_.v41; }
  ::std::optional<int64_t>& v41() { return storage_.v41; }

  const std::optional<int64_t>& v42() const { return storage_.v42; }
  ::std::optional<int64_t>& v42() { return storage_.v42; }

  const std::optional<int64_t>& v43() const { return storage_.v43; }
  ::std::optional<int64_t>& v43() { return storage_.v43; }

  const std::optional<int64_t>& v44() const { return storage_.v44; }
  ::std::optional<int64_t>& v44() { return storage_.v44; }

  const std::optional<int64_t>& v45() const { return storage_.v45; }
  ::std::optional<int64_t>& v45() { return storage_.v45; }

  const std::optional<int64_t>& v46() const { return storage_.v46; }
  ::std::optional<int64_t>& v46() { return storage_.v46; }

  const std::optional<int64_t>& v47() const { return storage_.v47; }
  ::std::optional<int64_t>& v47() { return storage_.v47; }

  const std::optional<int64_t>& v48() const { return storage_.v48; }
  ::std::optional<int64_t>& v48() { return storage_.v48; }

  const std::optional<int64_t>& v49() const { return storage_.v49; }
  ::std::optional<int64_t>& v49() { return storage_.v49; }

  const std::optional<int64_t>& v50() const { return storage_.v50; }
  ::std::optional<int64_t>& v50() { return storage_.v50; }

  const std::optional<int64_t>& v51() const { return storage_.v51; }
  ::std::optional<int64_t>& v51() { return storage_.v51; }

  const std::optional<int64_t>& v52() const { return storage_.v52; }
  ::std::optional<int64_t>& v52() { return storage_.v52; }

  const std::optional<int64_t>& v53() const { return storage_.v53; }
  ::std::optional<int64_t>& v53() { return storage_.v53; }

  const std::optional<int64_t>& v54() const { return storage_.v54; }
  ::std::optional<int64_t>& v54() { return storage_.v54; }

  const std::optional<int64_t>& v55() const { return storage_.v55; }
  ::std::optional<int64_t>& v55() { return storage_.v55; }

  const std::optional<int64_t>& v56() const { return storage_.v56; }
  ::std::optional<int64_t>& v56() { return storage_.v56; }

  const std::optional<int64_t>& v57() const { return storage_.v57; }
  ::std::optional<int64_t>& v57() { return storage_.v57; }

  const std::optional<int64_t>& v58() const { return storage_.v58; }
  ::std::optional<int64_t>& v58() { return storage_.v58; }

  const std::optional<int64_t>& v59() const { return storage_.v59; }
  ::std::optional<int64_t>& v59() { return storage_.v59; }

  const std::optional<int64_t>& v60() const { return storage_.v60; }
  ::std::optional<int64_t>& v60() { return storage_.v60; }

  const std::optional<int64_t>& v61() const { return storage_.v61; }
  ::std::optional<int64_t>& v61() { return storage_.v61; }

  const std::optional<int64_t>& v62() const { return storage_.v62; }
  ::std::optional<int64_t>& v62() { return storage_.v62; }

  const std::optional<int64_t>& v63() const { return storage_.v63; }
  ::std::optional<int64_t>& v63() { return storage_.v63; }

  const std::optional<::test_table::ExtensionTable>& v64() const {
    return storage_.v64;
  }
  ::std::optional<::test_table::ExtensionTable>& v64() { return storage_.v64; }

  SixtyFourOrdinalTable(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : SixtyFourOrdinalTable(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<int64_t> v1{};
    ::std::optional<int64_t> v2{};
    ::std::optional<int64_t> v3{};
    ::std::optional<int64_t> v4{};
    ::std::optional<int64_t> v5{};
    ::std::optional<int64_t> v6{};
    ::std::optional<int64_t> v7{};
    ::std::optional<int64_t> v8{};
    ::std::optional<int64_t> v9{};
    ::std::optional<int64_t> v10{};
    ::std::optional<int64_t> v11{};
    ::std::optional<int64_t> v12{};
    ::std::optional<int64_t> v13{};
    ::std::optional<int64_t> v14{};
    ::std::optional<int64_t> v15{};
    ::std::optional<int64_t> v16{};
    ::std::optional<int64_t> v17{};
    ::std::optional<int64_t> v18{};
    ::std::optional<int64_t> v19{};
    ::std::optional<int64_t> v20{};
    ::std::optional<int64_t> v21{};
    ::std::optional<int64_t> v22{};
    ::std::optional<int64_t> v23{};
    ::std::optional<int64_t> v24{};
    ::std::optional<int64_t> v25{};
    ::std::optional<int64_t> v26{};
    ::std::optional<int64_t> v27{};
    ::std::optional<int64_t> v28{};
    ::std::optional<int64_t> v29{};
    ::std::optional<int64_t> v30{};
    ::std::optional<int64_t> v31{};
    ::std::optional<int64_t> v32{};
    ::std::optional<int64_t> v33{};
    ::std::optional<int64_t> v34{};
    ::std::optional<int64_t> v35{};
    ::std::optional<int64_t> v36{};
    ::std::optional<int64_t> v37{};
    ::std::optional<int64_t> v38{};
    ::std::optional<int64_t> v39{};
    ::std::optional<int64_t> v40{};
    ::std::optional<int64_t> v41{};
    ::std::optional<int64_t> v42{};
    ::std::optional<int64_t> v43{};
    ::std::optional<int64_t> v44{};
    ::std::optional<int64_t> v45{};
    ::std::optional<int64_t> v46{};
    ::std::optional<int64_t> v47{};
    ::std::optional<int64_t> v48{};
    ::std::optional<int64_t> v49{};
    ::std::optional<int64_t> v50{};
    ::std::optional<int64_t> v51{};
    ::std::optional<int64_t> v52{};
    ::std::optional<int64_t> v53{};
    ::std::optional<int64_t> v54{};
    ::std::optional<int64_t> v55{};
    ::std::optional<int64_t> v56{};
    ::std::optional<int64_t> v57{};
    ::std::optional<int64_t> v58{};
    ::std::optional<int64_t> v59{};
    ::std::optional<int64_t> v60{};
    ::std::optional<int64_t> v61{};
    ::std::optional<int64_t> v62{};
    ::std::optional<int64_t> v63{};
    ::std::optional<::test_table::ExtensionTable> v64{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::SixtyFourOrdinalTable>;
  friend struct ::fidl::internal::MemberVisitor<
      ::test_table::SixtyFourOrdinalTable>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          1, &Storage_::v1},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          2, &Storage_::v2},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          3, &Storage_::v3},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          4, &Storage_::v4},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          5, &Storage_::v5},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          6, &Storage_::v6},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          7, &Storage_::v7},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          8, &Storage_::v8},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          9, &Storage_::v9},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          10, &Storage_::v10},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          11, &Storage_::v11},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          12, &Storage_::v12},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          13, &Storage_::v13},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          14, &Storage_::v14},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          15, &Storage_::v15},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          16, &Storage_::v16},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          17, &Storage_::v17},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          18, &Storage_::v18},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          19, &Storage_::v19},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          20, &Storage_::v20},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          21, &Storage_::v21},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          22, &Storage_::v22},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          23, &Storage_::v23},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          24, &Storage_::v24},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          25, &Storage_::v25},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          26, &Storage_::v26},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          27, &Storage_::v27},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          28, &Storage_::v28},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          29, &Storage_::v29},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          30, &Storage_::v30},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          31, &Storage_::v31},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          32, &Storage_::v32},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          33, &Storage_::v33},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          34, &Storage_::v34},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          35, &Storage_::v35},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          36, &Storage_::v36},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          37, &Storage_::v37},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          38, &Storage_::v38},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          39, &Storage_::v39},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          40, &Storage_::v40},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          41, &Storage_::v41},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          42, &Storage_::v42},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          43, &Storage_::v43},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          44, &Storage_::v44},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          45, &Storage_::v45},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          46, &Storage_::v46},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          47, &Storage_::v47},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          48, &Storage_::v48},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          49, &Storage_::v49},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          50, &Storage_::v50},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          51, &Storage_::v51},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          52, &Storage_::v52},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          53, &Storage_::v53},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          54, &Storage_::v54},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          55, &Storage_::v55},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          56, &Storage_::v56},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          57, &Storage_::v57},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          58, &Storage_::v58},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          59, &Storage_::v59},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          60, &Storage_::v60},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          61, &Storage_::v61},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          62, &Storage_::v62},
      ::fidl::internal::NaturalTableMember<
          Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
          63, &Storage_::v63},
      ::fidl::internal::NaturalTableMember<
          Storage_, ::test_table::ExtensionTable,
          fidl::internal::NaturalCodingConstraintEmpty>{64, &Storage_::v64});
};

extern "C" const fidl_type_t test_table_EmptyTableTable;

class EmptyTable {
 private:
  struct Storage_;

 public:
  EmptyTable(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  EmptyTable() noexcept = default;
  EmptyTable(EmptyTable&&) noexcept = default;
  EmptyTable& operator=(EmptyTable&&) noexcept = default;
  EmptyTable(const EmptyTable& other) noexcept
      : EmptyTable(other.CloneStorage_()) {}
  EmptyTable& operator=(const EmptyTable& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const EmptyTable& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_table::EmptyTable>::Equal(this, &other);
  }
  bool operator!=(const EmptyTable& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_table::EmptyTable>::Equal(this, &other);
  }

  bool IsEmpty() const { return true; }

  EmptyTable(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : EmptyTable(Storage_{}) {}

 private:
  struct Storage_ final {};

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_table::EmptyTable>;
  friend struct ::fidl::internal::MemberVisitor<::test_table::EmptyTable>;
  static constexpr auto kMembers = std::make_tuple();
};

}  // namespace test_table
namespace fidl {

extern "C" const fidl_type_t test_table_TableWithAttributesTable;

template <>
struct IsFidlType<::test_table::TableWithAttributes> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_table::TableWithAttributes> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_TableWithAttributesTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::TableWithAttributes,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::TableWithAttributes> {};

extern "C" const fidl_type_t test_table_SimpleTableTable;

template <>
struct IsFidlType<::test_table::SimpleTable> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_table::SimpleTable> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_SimpleTableTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::SimpleTable, ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::SimpleTable> {};

extern "C" const fidl_type_t test_table_ReverseOrdinalTableTable;

template <>
struct IsFidlType<::test_table::ReverseOrdinalTable> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_table::ReverseOrdinalTable> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_ReverseOrdinalTableTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::ReverseOrdinalTable,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::ReverseOrdinalTable> {};

extern "C" const fidl_type_t test_table_OlderSimpleTableTable;

template <>
struct IsFidlType<::test_table::OlderSimpleTable> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_table::OlderSimpleTable> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_OlderSimpleTableTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::OlderSimpleTable,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::OlderSimpleTable> {};

extern "C" const fidl_type_t test_table_NewerSimpleTableTable;

template <>
struct IsFidlType<::test_table::NewerSimpleTable> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_table::NewerSimpleTable> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_NewerSimpleTableTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::NewerSimpleTable,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::NewerSimpleTable> {};

extern "C" const fidl_type_t test_table_ExtensionTableTable;

template <>
struct IsFidlType<::test_table::ExtensionTable> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_table::ExtensionTable> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_ExtensionTableTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::ExtensionTable,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::ExtensionTable> {};

extern "C" const fidl_type_t test_table_SixtyFourOrdinalTableTable;

template <>
struct IsFidlType<::test_table::SixtyFourOrdinalTable> : public std::true_type {
};

template <>
struct ::fidl::internal::TypeTraits<::test_table::SixtyFourOrdinalTable> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_SixtyFourOrdinalTableTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::SixtyFourOrdinalTable,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::SixtyFourOrdinalTable> {};

extern "C" const fidl_type_t test_table_EmptyTableTable;

template <>
struct IsFidlType<::test_table::EmptyTable> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_table::EmptyTable> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_table_EmptyTableTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_table::EmptyTable, ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_table::EmptyTable> {};

}  // namespace fidl