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

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

#pragma once

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

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

#ifdef __Fuchsia__

class EmptyProtocol;
using EmptyProtocolHandle = ::fidl::InterfaceHandle<EmptyProtocol>;
#endif  // __Fuchsia__

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

  uint8_t __reserved = 0u;

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

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

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

using EmptyPtr = ::std::unique_ptr<Empty>;

#ifdef __Fuchsia__

namespace _internal {
extern "C" const fidl_type_t
    fidl_test_emptystruct_EmptyProtocolSendRequestTable;

extern "C" const fidl_type_t
    fidl_test_emptystruct_EmptyProtocolSendAndReceiveRequestTable;

}  // namespace _internal
class EmptyProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage Send(
      ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, e, 16);

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage SendAndReceive(
      ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, e, 16);

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

    return _encoder->GetMessage();
  }
};
namespace _internal {
extern "C" const fidl_type_t
    fidl_test_emptystruct_EmptyProtocolReceiveEventTable;

extern "C" const fidl_type_t
    fidl_test_emptystruct_EmptyProtocolSendAndReceiveResponseTable;

}  // namespace _internal
class EmptyProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage Receive(
      ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, e, 16);

    fidl_trace(DidHLCPPEncode,
               &::fidl::test::emptystruct::_internal::
                   fidl_test_emptystruct_EmptyProtocolReceiveEventTable,
               _encoder->GetPtr<const char>(0), _encoder->CurrentLength(),
               _encoder->CurrentHandleCount());
    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage SendAndReceive(
      ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, e, 16);

    fidl_trace(
        DidHLCPPEncode,
        &::fidl::test::emptystruct::_internal::
            fidl_test_emptystruct_EmptyProtocolSendAndReceiveResponseTable,
        _encoder->GetPtr<const char>(0), _encoder->CurrentLength(),
        _encoder->CurrentHandleCount());
    return _encoder->GetMessage();
  }
};
#endif  // __Fuchsia__

}  // namespace emptystruct
}  // namespace test
template <>
struct CodingTraits<::fidl::test::emptystruct::Empty>
    : public EncodableCodingTraits<::fidl::test::emptystruct::Empty, 1> {};

template <>
struct IsMemcpyCompatible<::fidl::test::emptystruct::Empty>
    : public internal::BoolConstant<
          !HasPadding<::fidl::test::emptystruct::Empty>::value &&
          IsMemcpyCompatible<uint8_t>::value> {};

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

template <>
struct Equality<::fidl::test::emptystruct::Empty> {
  bool operator()(const ::fidl::test::emptystruct::Empty& _lhs,
                  const ::fidl::test::emptystruct::Empty& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};

}  // namespace fidl