tools/fidl/fidlgen_hlcpp/goldens/natural_types/placement_of_attributes.h.golden

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

#pragma once

#include <exampleusing/cpp/natural_types.h>

#include "lib/fidl/cpp/internal/natural_types_header.h"

//
// Domain objects declarations (i.e. "natural types" in unified bindings).
//
namespace fidl {
namespace test {
namespace placementofattributes {
class ExampleXUnion;

class ExampleUnion;

class ExampleTable;

class ExampleStruct;

enum class ExampleEnum : uint32_t {

  MEMBER = 1u,
};

inline zx_status_t Clone(
    ::fidl::test::placementofattributes::ExampleEnum value,
    ::fidl::test::placementofattributes::ExampleEnum* result) {
  *result = value;
  return ZX_OK;
}

enum class ExampleBits : uint32_t {

  MEMBER = 1u,
};

const static ExampleBits ExampleBitsMask = static_cast<ExampleBits>(1u);

constexpr inline ::fidl::test::placementofattributes::ExampleBits operator|(
    ::fidl::test::placementofattributes::ExampleBits _lhs,
    ::fidl::test::placementofattributes::ExampleBits _rhs) {
  return static_cast<::fidl::test::placementofattributes::ExampleBits>(
      static_cast<uint32_t>(_lhs) | static_cast<uint32_t>(_rhs));
}

constexpr inline ::fidl::test::placementofattributes::ExampleBits& operator|=(
    ::fidl::test::placementofattributes::ExampleBits& _lhs,
    ::fidl::test::placementofattributes::ExampleBits _rhs) {
  _lhs = _lhs | _rhs;
  return _lhs;
}

constexpr inline ::fidl::test::placementofattributes::ExampleBits operator&(
    ::fidl::test::placementofattributes::ExampleBits _lhs,
    ::fidl::test::placementofattributes::ExampleBits _rhs) {
  return static_cast<::fidl::test::placementofattributes::ExampleBits>(
      static_cast<uint32_t>(_lhs) & static_cast<uint32_t>(_rhs));
}

constexpr inline ::fidl::test::placementofattributes::ExampleBits& operator&=(
    ::fidl::test::placementofattributes::ExampleBits& _lhs,
    ::fidl::test::placementofattributes::ExampleBits _rhs) {
  _lhs = _lhs & _rhs;
  return _lhs;
}

constexpr inline ::fidl::test::placementofattributes::ExampleBits operator^(
    ::fidl::test::placementofattributes::ExampleBits _lhs,
    ::fidl::test::placementofattributes::ExampleBits _rhs) {
  return static_cast<::fidl::test::placementofattributes::ExampleBits>(
      static_cast<uint32_t>(_lhs) ^ static_cast<uint32_t>(_rhs));
}

constexpr inline ::fidl::test::placementofattributes::ExampleBits& operator^=(
    ::fidl::test::placementofattributes::ExampleBits& _lhs,
    ::fidl::test::placementofattributes::ExampleBits _rhs) {
  _lhs = _lhs ^ _rhs;
  return _lhs;
}

constexpr inline ::fidl::test::placementofattributes::ExampleBits operator~(
    ::fidl::test::placementofattributes::ExampleBits _value) {
  return static_cast<::fidl::test::placementofattributes::ExampleBits>(
      ~static_cast<uint32_t>(_value) &
      static_cast<uint32_t>(
          ::fidl::test::placementofattributes::ExampleBitsMask));
}

inline zx_status_t Clone(
    ::fidl::test::placementofattributes::ExampleBits value,
    ::fidl::test::placementofattributes::ExampleBits* result) {
  *result = value;
  return ZX_OK;
}

#ifdef __Fuchsia__

class ExampleProtocol;
using ExampleProtocolHandle = ::fidl::InterfaceHandle<ExampleProtocol>;
#endif  // __Fuchsia__

class ExampleXUnion final {
 public:
  static const fidl_type_t* FidlType;

  ExampleXUnion();
  ~ExampleXUnion();

  ExampleXUnion(ExampleXUnion&&);
  ExampleXUnion& operator=(ExampleXUnion&&);

  static ExampleXUnion WithVariant(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,
    Empty = kUnknown,  // DEPRECATED: use kUnknown instead.

    kVariant = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExampleXUnion> New() {
    return ::std::make_unique<ExampleXUnion>();
  }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info =
                  cpp17::nullopt);
  static void Decode(::fidl::Decoder* decoder, ExampleXUnion* value,
                     size_t offset);
  zx_status_t Clone(ExampleXUnion* result) const;

  bool has_invalid_tag() const { return tag_ == Invalid; }

  bool is_variant() const {
    return tag_ ==
           ::fidl::test::placementofattributes::ExampleXUnion::Tag::kVariant;
  }

  uint32_t& variant() {
    EnsureStorageInitialized(
        ::fidl::test::placementofattributes::ExampleXUnion::Tag::kVariant);
    return variant_;
  }

  const uint32_t& variant() const {
    ZX_ASSERT(is_variant());
    return variant_;
  }
  ExampleXUnion& set_variant(uint32_t value);
  ExampleXUnion& SetUnknownData(fidl_xunion_tag_t ordinal,
                                std::vector<uint8_t> bytes);

  ::fidl::test::placementofattributes::ExampleXUnion::Tag Which() const {
    switch (tag_) {
      case ::fidl::test::placementofattributes::ExampleXUnion::Tag::Invalid:
      case ::fidl::test::placementofattributes::ExampleXUnion::Tag::kVariant:
        return ::fidl::test::placementofattributes::ExampleXUnion::Tag(tag_);
      default:
        return ::fidl::test::placementofattributes::ExampleXUnion::Tag::
            kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal()
  // only when you need access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const { return tag_; }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() !=
        ::fidl::test::placementofattributes::ExampleXUnion::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::fidl::test::placementofattributes::ExampleXUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(
      ::fidl::test::placementofattributes::ExampleXUnion::Tag::Invalid);
  union {
    uint32_t variant_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(
    const ::fidl::test::placementofattributes::ExampleXUnion& value,
    ::fidl::test::placementofattributes::ExampleXUnion* result) {
  return value.Clone(result);
}

using ExampleXUnionPtr = ::std::unique_ptr<ExampleXUnion>;

class ExampleUnion final {
 public:
  static const fidl_type_t* FidlType;

  ExampleUnion();
  ~ExampleUnion();

  ExampleUnion(ExampleUnion&&);
  ExampleUnion& operator=(ExampleUnion&&);

  static ExampleUnion WithVariant(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kVariant = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExampleUnion> New() {
    return ::std::make_unique<ExampleUnion>();
  }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info =
                  cpp17::nullopt);
  static void Decode(::fidl::Decoder* decoder, ExampleUnion* value,
                     size_t offset);
  zx_status_t Clone(ExampleUnion* result) const;

  bool has_invalid_tag() const { return tag_ == Invalid; }

  bool is_variant() const {
    return tag_ ==
           ::fidl::test::placementofattributes::ExampleUnion::Tag::kVariant;
  }

  uint32_t& variant() {
    EnsureStorageInitialized(
        ::fidl::test::placementofattributes::ExampleUnion::Tag::kVariant);
    return variant_;
  }

  const uint32_t& variant() const {
    ZX_ASSERT(is_variant());
    return variant_;
  }
  ExampleUnion& set_variant(uint32_t value);

  ::fidl::test::placementofattributes::ExampleUnion::Tag Which() const {
    return ::fidl::test::placementofattributes::ExampleUnion::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal()
  // only when you need access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const { return tag_; }

  friend ::fidl::Equality<::fidl::test::placementofattributes::ExampleUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(
      ::fidl::test::placementofattributes::ExampleUnion::Tag::Invalid);
  union {
    uint32_t variant_;
  };
};

inline zx_status_t Clone(
    const ::fidl::test::placementofattributes::ExampleUnion& value,
    ::fidl::test::placementofattributes::ExampleUnion* result) {
  return value.Clone(result);
}

using ExampleUnionPtr = ::std::unique_ptr<ExampleUnion>;

class ExampleTable final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;

  const uint32_t& member() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return member_value_.value;
  }
  bool has_member() const { return field_presence_.IsSet<0>(); }

  uint32_t* mutable_member() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&member_value_.value);
    }
    return &member_value_.value;
  }
  ExampleTable& set_member(uint32_t _value) {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&member_value_.value, std::move(_value));
    } else {
      member_value_.value = std::move(_value);
    }
    return *this;
  }
  void clear_member() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&member_value_.value);
  }

  const std::map<uint64_t, std::vector<uint8_t>>& UnknownData() const {
    return _unknown_data;
  }

  void SetUnknownDataEntry(uint32_t ordinal, std::vector<uint8_t>&& data) {
    auto ord = static_cast<uint64_t>(ordinal);
    ZX_ASSERT(!IsOrdinalKnown(ord));
    _unknown_data.insert({ord, std::move(data)});
  }

  ExampleTable();
  ExampleTable(ExampleTable&& other);
  ~ExampleTable();
  ExampleTable& operator=(ExampleTable&& other);

  static inline ::std::unique_ptr<ExampleTable> New() {
    return ::std::make_unique<ExampleTable>();
  }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info =
                  cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExampleTable* _value,
                     size_t _offset);
  zx_status_t Clone(ExampleTable* _result) const;

 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    size_t max_ordinal =
        static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
    for (const auto& data : _unknown_data) {
      if (data.first > max_ordinal) {
        max_ordinal = data.first;
      }
    }
    return max_ordinal;
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
      case 1:
        return true;
      default:
        return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_member {
    ValueUnion_member() {}
    ~ValueUnion_member() {}

    uint32_t value;
  };
  ValueUnion_member member_value_;
  std::map<uint64_t, std::vector<uint8_t>> _unknown_data;
};

using ExampleTablePtr = ::std::unique_ptr<ExampleTable>;

class ExampleStruct final {
 public:
  static const fidl_type_t* FidlType;

  uint32_t member{};

  static inline ::std::unique_ptr<ExampleStruct> New() {
    return ::std::make_unique<ExampleStruct>();
  }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info =
                  cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExampleStruct* value,
                     size_t _offset);
  zx_status_t Clone(ExampleStruct* result) const;
};

inline zx_status_t Clone(
    const ::fidl::test::placementofattributes::ExampleStruct& _value,
    ::fidl::test::placementofattributes::ExampleStruct* _result) {
  return _value.Clone(_result);
}

using ExampleStructPtr = ::std::unique_ptr<ExampleStruct>;

constexpr uint32_t EXAMPLE_CONST = 0u;

#ifdef __Fuchsia__

namespace _internal {
extern "C" const fidl_type_t
    fidl_test_placementofattributes_ExampleProtocolMethodRequestTable;

}  // namespace _internal
class ExampleProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage Method(::fidl::Encoder* _encoder,
                                             ::exampleusing::Empty* arg) {
    fidl_trace(WillHLCPPEncode);
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, arg, 16);

    fidl_trace(
        DidHLCPPEncode,
        &::fidl::test::placementofattributes::_internal::
            fidl_test_placementofattributes_ExampleProtocolMethodRequestTable,
        _encoder->GetPtr<const char>(0), _encoder->CurrentLength(),
        _encoder->CurrentHandleCount());

    return _encoder->GetMessage();
  }
};

class ExampleProtocol_ResponseEncoder {
 public:
};
#endif  // __Fuchsia__

}  // namespace placementofattributes
}  // namespace test
template <>
struct IsFidlXUnion<::fidl::test::placementofattributes::ExampleXUnion>
    : public std::true_type {};

template <>
struct CodingTraits<::fidl::test::placementofattributes::ExampleXUnion>
    : public EncodableCodingTraits<
          ::fidl::test::placementofattributes::ExampleXUnion, 24> {};

template <>
struct CodingTraits<
    std::unique_ptr<::fidl::test::placementofattributes::ExampleXUnion>> {
  static constexpr size_t inline_size_v1_no_ee = 24;

  static void Encode(
      Encoder* encoder,
      std::unique_ptr<::fidl::test::placementofattributes::ExampleXUnion>*
          value,
      size_t offset,
      cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(
      Decoder* decoder,
      std::unique_ptr<::fidl::test::placementofattributes::ExampleXUnion>*
          value,
      size_t offset) {
    fidl_xunion_t* encoded = decoder->GetPtr<fidl_xunion_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::fidl::test::placementofattributes::ExampleXUnion);

    ::fidl::test::placementofattributes::ExampleXUnion::Decode(
        decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(
    const ::fidl::test::placementofattributes::ExampleXUnion& value,
    ::fidl::test::placementofattributes::ExampleXUnion* result) {
  return ::fidl::test::placementofattributes::Clone(value, result);
}

template <>
struct Equality<::fidl::test::placementofattributes::ExampleXUnion> {
  bool operator()(
      const ::fidl::test::placementofattributes::ExampleXUnion& _lhs,
      const ::fidl::test::placementofattributes::ExampleXUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::placementofattributes::ExampleXUnion::Tag::Invalid):
        return true;
      case ::fidl::test::placementofattributes::ExampleXUnion::Tag::kVariant:
        return ::fidl::Equals(_lhs.variant_, _rhs.variant_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::fidl::test::placementofattributes::ExampleUnion>
    : public std::true_type {};

template <>
struct CodingTraits<::fidl::test::placementofattributes::ExampleUnion>
    : public EncodableCodingTraits<
          ::fidl::test::placementofattributes::ExampleUnion, 24> {};

template <>
struct CodingTraits<
    std::unique_ptr<::fidl::test::placementofattributes::ExampleUnion>> {
  static constexpr size_t inline_size_v1_no_ee = 24;

  static void Encode(
      Encoder* encoder,
      std::unique_ptr<::fidl::test::placementofattributes::ExampleUnion>* value,
      size_t offset,
      cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(
      Decoder* decoder,
      std::unique_ptr<::fidl::test::placementofattributes::ExampleUnion>* value,
      size_t offset) {
    fidl_xunion_t* encoded = decoder->GetPtr<fidl_xunion_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::fidl::test::placementofattributes::ExampleUnion);

    ::fidl::test::placementofattributes::ExampleUnion::Decode(
        decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(
    const ::fidl::test::placementofattributes::ExampleUnion& value,
    ::fidl::test::placementofattributes::ExampleUnion* result) {
  return ::fidl::test::placementofattributes::Clone(value, result);
}

template <>
struct Equality<::fidl::test::placementofattributes::ExampleUnion> {
  bool operator()(
      const ::fidl::test::placementofattributes::ExampleUnion& _lhs,
      const ::fidl::test::placementofattributes::ExampleUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::placementofattributes::ExampleUnion::Tag::Invalid):
        return true;
      case ::fidl::test::placementofattributes::ExampleUnion::Tag::kVariant:
        return ::fidl::Equals(_lhs.variant_, _rhs.variant_);

      default:
        return false;
    }
  }
};
template <>
struct CodingTraits<::fidl::test::placementofattributes::ExampleTable>
    : public EncodableCodingTraits<
          ::fidl::test::placementofattributes::ExampleTable, 16> {};

inline zx_status_t Clone(
    const ::fidl::test::placementofattributes::ExampleTable& _value,
    ::fidl::test::placementofattributes::ExampleTable* result) {
  return _value.Clone(result);
}
template <>
struct Equality<::fidl::test::placementofattributes::ExampleTable> {
  bool operator()(
      const ::fidl::test::placementofattributes::ExampleTable& _lhs,
      const ::fidl::test::placementofattributes::ExampleTable& _rhs) const {
    if (_lhs.has_member()) {
      if (!_rhs.has_member()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.member(), _rhs.member())) {
        return false;
      }
    } else if (_rhs.has_member()) {
      return false;
    }
    return ::fidl::Equals(_lhs.UnknownData(), _rhs.UnknownData());
  }
};
template <>
struct CodingTraits<::fidl::test::placementofattributes::ExampleStruct>
    : public EncodableCodingTraits<
          ::fidl::test::placementofattributes::ExampleStruct, 4> {};

template <>
struct IsMemcpyCompatible<::fidl::test::placementofattributes::ExampleStruct>
    : public internal::BoolConstant<
          !HasPadding<
              ::fidl::test::placementofattributes::ExampleStruct>::value &&
          IsMemcpyCompatible<uint32_t>::value> {};

inline zx_status_t Clone(
    const ::fidl::test::placementofattributes::ExampleStruct& value,
    ::fidl::test::placementofattributes::ExampleStruct* result) {
  return ::fidl::test::placementofattributes::Clone(value, result);
}

template <>
struct Equality<::fidl::test::placementofattributes::ExampleStruct> {
  bool operator()(
      const ::fidl::test::placementofattributes::ExampleStruct& _lhs,
      const ::fidl::test::placementofattributes::ExampleStruct& _rhs) const {
    if (!::fidl::Equals(_lhs.member, _rhs.member)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::fidl::test::placementofattributes::ExampleEnum> {
  static constexpr size_t inline_size_old =
      sizeof(::fidl::test::placementofattributes::ExampleEnum);
  static constexpr size_t inline_size_v1_no_ee =
      sizeof(::fidl::test::placementofattributes::ExampleEnum);
  static void Encode(
      Encoder* encoder, ::fidl::test::placementofattributes::ExampleEnum* value,
      size_t offset,
      cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
    ZX_DEBUG_ASSERT(!maybe_handle_info);
    uint32_t underlying = static_cast<uint32_t>(*value);
    ::fidl::Encode(encoder, &underlying, offset);
  }
  static void Decode(Decoder* decoder,
                     ::fidl::test::placementofattributes::ExampleEnum* value,
                     size_t offset) {
    uint32_t underlying = {};
    ::fidl::Decode(decoder, &underlying, offset);
    *value = static_cast<::fidl::test::placementofattributes::ExampleEnum>(
        underlying);
  }
};

inline zx_status_t Clone(
    ::fidl::test::placementofattributes::ExampleEnum value,
    ::fidl::test::placementofattributes::ExampleEnum* result) {
  return ::fidl::test::placementofattributes::Clone(value, result);
}
template <>
struct Equality<::fidl::test::placementofattributes::ExampleEnum> {
  bool operator()(
      const ::fidl::test::placementofattributes::ExampleEnum& _lhs,
      const ::fidl::test::placementofattributes::ExampleEnum& _rhs) const {
    return _lhs == _rhs;
  }
};

template <>
struct CodingTraits<::fidl::test::placementofattributes::ExampleBits> {
  static constexpr size_t inline_size_old =
      sizeof(::fidl::test::placementofattributes::ExampleBits);
  static constexpr size_t inline_size_v1_no_ee =
      sizeof(::fidl::test::placementofattributes::ExampleBits);
  static void Encode(
      Encoder* encoder, ::fidl::test::placementofattributes::ExampleBits* value,
      size_t offset,
      cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
    ZX_DEBUG_ASSERT(!maybe_handle_info);
    uint32_t underlying = static_cast<uint32_t>(*value);
    ::fidl::Encode(encoder, &underlying, offset);
  }
  static void Decode(Decoder* decoder,
                     ::fidl::test::placementofattributes::ExampleBits* value,
                     size_t offset) {
    uint32_t underlying = {};
    ::fidl::Decode(decoder, &underlying, offset);
    *value = static_cast<::fidl::test::placementofattributes::ExampleBits>(
        underlying);
  }
};

inline zx_status_t Clone(
    ::fidl::test::placementofattributes::ExampleBits value,
    ::fidl::test::placementofattributes::ExampleBits* result) {
  return ::fidl::test::placementofattributes::Clone(value, result);
}

template <>
struct Equality<::fidl::test::placementofattributes::ExampleBits> {
  bool operator()(
      const ::fidl::test::placementofattributes::ExampleBits& _lhs,
      const ::fidl::test::placementofattributes::ExampleBits& _rhs) const {
    uint32_t _lhs_underlying = static_cast<uint32_t>(_lhs);
    uint32_t _rhs_underlying = static_cast<uint32_t>(_rhs);
    return ::fidl::Equals(_lhs_underlying, _rhs_underlying);
  }
};

}  // namespace fidl