tools/fidl/fidlgen_hlcpp/goldens/encapsulated_structs.h.golden

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

#pragma once

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

namespace test {
namespace encapsulatedstructs {

//
// Domain objects declarations
//

class NonInlineStructTestStruct;

class Int8Int32;

class Int16Int8;

class ArrayInt16Int8;

class StructPaddingTestStruct;

class TopLevelStruct;

#ifdef __Fuchsia__

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

  ::std::unique_ptr<::test::encapsulatedstructs::Int16Int8> element{};

  ::zx::handle h{};

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

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

inline zx_status_t Clone(const ::test::encapsulatedstructs::NonInlineStructTestStruct& _value,
                         ::test::encapsulatedstructs::NonInlineStructTestStruct* _result) {
  return _value.Clone(_result);
}

using NonInlineStructTestStructPtr = ::std::unique_ptr<NonInlineStructTestStruct>;
#endif  // __Fuchsia__

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

  int8_t a{};

  int32_t b{};

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

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

inline zx_status_t Clone(const ::test::encapsulatedstructs::Int8Int32& _value,
                         ::test::encapsulatedstructs::Int8Int32* _result) {
  return _value.Clone(_result);
}

using Int8Int32Ptr = ::std::unique_ptr<Int8Int32>;

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

  int16_t a{};

  int8_t b{};

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

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

inline zx_status_t Clone(const ::test::encapsulatedstructs::Int16Int8& _value,
                         ::test::encapsulatedstructs::Int16Int8* _result) {
  return _value.Clone(_result);
}

using Int16Int8Ptr = ::std::unique_ptr<Int16Int8>;

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

  ::std::array<::test::encapsulatedstructs::Int16Int8, 3> arr{};

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

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

inline zx_status_t Clone(const ::test::encapsulatedstructs::ArrayInt16Int8& _value,
                         ::test::encapsulatedstructs::ArrayInt16Int8* _result) {
  return _value.Clone(_result);
}

using ArrayInt16Int8Ptr = ::std::unique_ptr<ArrayInt16Int8>;

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

  ::test::encapsulatedstructs::Int16Int8 trailing{};

  ::test::encapsulatedstructs::Int8Int32 inner{};

  ::test::encapsulatedstructs::ArrayInt16Int8 array{};

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

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

inline zx_status_t Clone(const ::test::encapsulatedstructs::StructPaddingTestStruct& _value,
                         ::test::encapsulatedstructs::StructPaddingTestStruct* _result) {
  return _value.Clone(_result);
}

using StructPaddingTestStructPtr = ::std::unique_ptr<StructPaddingTestStruct>;

#ifdef __Fuchsia__

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

  ::test::encapsulatedstructs::StructPaddingTestStruct a{};

  ::test::encapsulatedstructs::NonInlineStructTestStruct b{};

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

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

inline zx_status_t Clone(const ::test::encapsulatedstructs::TopLevelStruct& _value,
                         ::test::encapsulatedstructs::TopLevelStruct* _result) {
  return _value.Clone(_result);
}

using TopLevelStructPtr = ::std::unique_ptr<TopLevelStruct>;
#endif  // __Fuchsia__

}  // namespace encapsulatedstructs
}  // namespace test
namespace fidl {
#ifdef __Fuchsia__

template <>
struct CodingTraits<::test::encapsulatedstructs::NonInlineStructTestStruct>
    : public EncodableCodingTraits<::test::encapsulatedstructs::NonInlineStructTestStruct, 16> {};

template <>
struct HasPadding<::test::encapsulatedstructs::NonInlineStructTestStruct> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::encapsulatedstructs::NonInlineStructTestStruct> : public internal::BoolConstant<
                                                                                        !HasPadding<::test::encapsulatedstructs::NonInlineStructTestStruct>::value && IsMemcpyCompatible<::std::unique_ptr<::test::encapsulatedstructs::Int16Int8>>::value && IsMemcpyCompatible<::zx::handle>::value> {};

inline zx_status_t Clone(const ::test::encapsulatedstructs::NonInlineStructTestStruct& value,
                         ::test::encapsulatedstructs::NonInlineStructTestStruct* result) {
  return ::test::encapsulatedstructs::Clone(value, result);
}

template <>
struct Equality<::test::encapsulatedstructs::NonInlineStructTestStruct> {
  bool operator()(const ::test::encapsulatedstructs::NonInlineStructTestStruct& _lhs, const ::test::encapsulatedstructs::NonInlineStructTestStruct& _rhs) const {
    if (!::fidl::Equals(_lhs.element, _rhs.element)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.h, _rhs.h)) {
      return false;
    }
    return true;
  }
};
#endif  // __Fuchsia__

template <>
struct CodingTraits<::test::encapsulatedstructs::Int8Int32>
    : public EncodableCodingTraits<::test::encapsulatedstructs::Int8Int32, 8> {};

template <>
struct HasPadding<::test::encapsulatedstructs::Int8Int32> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::encapsulatedstructs::Int8Int32> : public internal::BoolConstant<
                                                                        !HasPadding<::test::encapsulatedstructs::Int8Int32>::value && IsMemcpyCompatible<int8_t>::value && IsMemcpyCompatible<int32_t>::value> {};

inline zx_status_t Clone(const ::test::encapsulatedstructs::Int8Int32& value,
                         ::test::encapsulatedstructs::Int8Int32* result) {
  return ::test::encapsulatedstructs::Clone(value, result);
}

template <>
struct Equality<::test::encapsulatedstructs::Int8Int32> {
  bool operator()(const ::test::encapsulatedstructs::Int8Int32& _lhs, const ::test::encapsulatedstructs::Int8Int32& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::encapsulatedstructs::Int16Int8>
    : public EncodableCodingTraits<::test::encapsulatedstructs::Int16Int8, 4> {};

template <>
struct HasPadding<::test::encapsulatedstructs::Int16Int8> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::encapsulatedstructs::Int16Int8> : public internal::BoolConstant<
                                                                        !HasPadding<::test::encapsulatedstructs::Int16Int8>::value && IsMemcpyCompatible<int16_t>::value && IsMemcpyCompatible<int8_t>::value> {};

inline zx_status_t Clone(const ::test::encapsulatedstructs::Int16Int8& value,
                         ::test::encapsulatedstructs::Int16Int8* result) {
  return ::test::encapsulatedstructs::Clone(value, result);
}

template <>
struct Equality<::test::encapsulatedstructs::Int16Int8> {
  bool operator()(const ::test::encapsulatedstructs::Int16Int8& _lhs, const ::test::encapsulatedstructs::Int16Int8& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::encapsulatedstructs::ArrayInt16Int8>
    : public EncodableCodingTraits<::test::encapsulatedstructs::ArrayInt16Int8, 12> {};

template <>
struct HasPadding<::test::encapsulatedstructs::ArrayInt16Int8> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::encapsulatedstructs::ArrayInt16Int8> : public internal::BoolConstant<
                                                                             !HasPadding<::test::encapsulatedstructs::ArrayInt16Int8>::value && IsMemcpyCompatible<::std::array<::test::encapsulatedstructs::Int16Int8, 3>>::value> {};

inline zx_status_t Clone(const ::test::encapsulatedstructs::ArrayInt16Int8& value,
                         ::test::encapsulatedstructs::ArrayInt16Int8* result) {
  return ::test::encapsulatedstructs::Clone(value, result);
}

template <>
struct Equality<::test::encapsulatedstructs::ArrayInt16Int8> {
  bool operator()(const ::test::encapsulatedstructs::ArrayInt16Int8& _lhs, const ::test::encapsulatedstructs::ArrayInt16Int8& _rhs) const {
    if (!::fidl::Equals(_lhs.arr, _rhs.arr)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::encapsulatedstructs::StructPaddingTestStruct>
    : public EncodableCodingTraits<::test::encapsulatedstructs::StructPaddingTestStruct, 24> {};

template <>
struct HasPadding<::test::encapsulatedstructs::StructPaddingTestStruct> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::encapsulatedstructs::StructPaddingTestStruct> : public internal::BoolConstant<
                                                                                      !HasPadding<::test::encapsulatedstructs::StructPaddingTestStruct>::value && IsMemcpyCompatible<::test::encapsulatedstructs::Int16Int8>::value && IsMemcpyCompatible<::test::encapsulatedstructs::Int8Int32>::value && IsMemcpyCompatible<::test::encapsulatedstructs::ArrayInt16Int8>::value> {};

inline zx_status_t Clone(const ::test::encapsulatedstructs::StructPaddingTestStruct& value,
                         ::test::encapsulatedstructs::StructPaddingTestStruct* result) {
  return ::test::encapsulatedstructs::Clone(value, result);
}

template <>
struct Equality<::test::encapsulatedstructs::StructPaddingTestStruct> {
  bool operator()(const ::test::encapsulatedstructs::StructPaddingTestStruct& _lhs, const ::test::encapsulatedstructs::StructPaddingTestStruct& _rhs) const {
    if (!::fidl::Equals(_lhs.trailing, _rhs.trailing)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.inner, _rhs.inner)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array, _rhs.array)) {
      return false;
    }
    return true;
  }
};
#ifdef __Fuchsia__

template <>
struct CodingTraits<::test::encapsulatedstructs::TopLevelStruct>
    : public EncodableCodingTraits<::test::encapsulatedstructs::TopLevelStruct, 40> {};

template <>
struct HasPadding<::test::encapsulatedstructs::TopLevelStruct> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::encapsulatedstructs::TopLevelStruct> : public internal::BoolConstant<
                                                                             !HasPadding<::test::encapsulatedstructs::TopLevelStruct>::value && IsMemcpyCompatible<::test::encapsulatedstructs::StructPaddingTestStruct>::value && IsMemcpyCompatible<::test::encapsulatedstructs::NonInlineStructTestStruct>::value> {};

inline zx_status_t Clone(const ::test::encapsulatedstructs::TopLevelStruct& value,
                         ::test::encapsulatedstructs::TopLevelStruct* result) {
  return ::test::encapsulatedstructs::Clone(value, result);
}

template <>
struct Equality<::test::encapsulatedstructs::TopLevelStruct> {
  bool operator()(const ::test::encapsulatedstructs::TopLevelStruct& _lhs, const ::test::encapsulatedstructs::TopLevelStruct& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
#endif  // __Fuchsia__

//
// Proxies and stubs declarations
//
}  // namespace fidl