garnet/go/src/fidl/compiler/backend/goldens/request_flexible_envelope.test.json.h.golden

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

#pragma once

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

namespace fidl {
namespace test {
namespace json {

class StrictFoo;
class FlexibleFoo;
#ifdef __Fuchsia__

class Protocol;
using ProtocolPtr = ::fidl::InterfacePtr<Protocol>;
class Protocol_Proxy;
class Protocol_Stub;
class Protocol_EventSender;
class Protocol_Sync;
using ProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<Protocol>;
class Protocol_SyncProxy;
using ProtocolHandle = ::fidl::InterfaceHandle<Protocol>;
namespace internal {
constexpr uint64_t kProtocol_RequestStrictResponseFlexible_Ordinal =
    0x1143e3c200000000lu;
constexpr uint64_t kProtocol_RequestStrictResponseFlexible_GenOrdinal =
    0x72b1a46e5e2af282lu;
constexpr uint64_t kProtocol_RequestFlexibleResponseStrict_Ordinal =
    0x3136aeff00000000lu;
constexpr uint64_t kProtocol_RequestFlexibleResponseStrict_GenOrdinal =
    0x42a34ad5c4a1d952lu;

}  // namespace internal
#endif  // __Fuchsia__

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

  StrictFoo();
  ~StrictFoo();

  StrictFoo(StrictFoo&&);
  StrictFoo& operator=(StrictFoo&&);

  static StrictFoo WithS(::std::string&&);
  static StrictFoo WithI(int32_t&&);

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

    kS = 1,  // 0x1
    kI = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

  void Encode(::fidl::Encoder* encoder, size_t offset);
  static void Decode(::fidl::Decoder* decoder, StrictFoo* value, size_t offset);
  zx_status_t Clone(StrictFoo* result) const;

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

  bool is_s() const { return tag_ == Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  StrictFoo& set_s(::std::string value);

  bool is_i() const { return tag_ == Tag::kI; }

  int32_t& i() {
    EnsureStorageInitialized(Tag::kI);
    return i_;
  }

  const int32_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  StrictFoo& set_i(int32_t value);

  Tag Which() const { return 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_; }

  const std::vector<uint8_t>* UnknownData() const { return nullptr; }

  friend ::fidl::Equality<::fidl::test::json::StrictFoo>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(Tag::Invalid);
  union {
    ::std::string s_;
    int32_t i_;
  };
};

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

using StrictFooPtr = ::std::unique_ptr<StrictFoo>;

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

  FlexibleFoo();
  ~FlexibleFoo();

  FlexibleFoo(FlexibleFoo&&);
  FlexibleFoo& operator=(FlexibleFoo&&);

  static FlexibleFoo WithS(::std::string&&);
  static FlexibleFoo WithI(int32_t&&);

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

    kS = 1,  // 0x1
    kI = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

  void Encode(::fidl::Encoder* encoder, size_t offset);
  static void Decode(::fidl::Decoder* decoder, FlexibleFoo* value,
                     size_t offset);
  zx_status_t Clone(FlexibleFoo* result) const;

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

  bool is_s() const { return tag_ == Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  FlexibleFoo& set_s(::std::string value);

  bool is_i() const { return tag_ == Tag::kI; }

  int32_t& i() {
    EnsureStorageInitialized(Tag::kI);
    return i_;
  }

  const int32_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  FlexibleFoo& set_i(int32_t value);

  Tag Which() const {
    switch (tag_) {
      case Tag::kS:
      case Tag::kI:
        return Tag(tag_);
      default:
        return 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>* UnknownData() const {
    if (Which() != Tag::kUnknown) {
      return nullptr;
    }

    return &unknown_data_;
  }

  friend ::fidl::Equality<::fidl::test::json::FlexibleFoo>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(Tag::Invalid);
  union {
    ::std::string s_;
    int32_t i_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using FlexibleFooPtr = ::std::unique_ptr<FlexibleFoo>;
#ifdef __Fuchsia__

class Protocol {
 public:
  using Proxy_ = Protocol_Proxy;
  using Stub_ = Protocol_Stub;
  using EventSender_ = Protocol_EventSender;
  using Sync_ = Protocol_Sync;
  virtual ~Protocol();
  using RequestStrictResponseFlexibleCallback =
      fit::function<void(FlexibleFoo)>;

  virtual void RequestStrictResponseFlexible(
      StrictFoo s, RequestStrictResponseFlexibleCallback callback) = 0;
  using RequestFlexibleResponseStrictCallback = fit::function<void(StrictFoo)>;

  virtual void RequestFlexibleResponseStrict(
      FlexibleFoo s, RequestFlexibleResponseStrictCallback callback) = 0;
};

class Protocol_RequestEncoder {
 public:
  static ::fidl::Message RequestStrictResponseFlexible(
      ::fidl::Encoder* _encoder, StrictFoo* s) {
    _encoder->Alloc(40 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, s, 16);
    return _encoder->GetMessage();
  }
  static ::fidl::Message RequestFlexibleResponseStrict(
      ::fidl::Encoder* _encoder, FlexibleFoo* s) {
    _encoder->Alloc(40 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, s, 16);
    return _encoder->GetMessage();
  }
};

class Protocol_RequestDecoder {
 public:
  Protocol_RequestDecoder() = default;
  virtual ~Protocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response);
  zx_status_t Decode_(::fidl::Message request) {
    bool needs_response;
    const fidl_type_t* request_type =
        GetType(request.ordinal(), &needs_response);
    if (request_type == nullptr) {
      return ZX_ERR_NOT_SUPPORTED;
    }
    const char* error_msg = nullptr;
    zx_status_t status = request.Decode(request_type, &error_msg);
    if (status != ZX_OK) {
      FIDL_REPORT_DECODING_ERROR(request, request_type, error_msg);
      return status;
    }
    ::fidl::Decoder request_decoder(std::move(request));
    switch (request.ordinal()) {
      case internal::kProtocol_RequestStrictResponseFlexible_Ordinal:
      case internal::kProtocol_RequestStrictResponseFlexible_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<StrictFoo>(&request_decoder, 16);
        RequestStrictResponseFlexible(std::move(arg0));
        break;
      }
      case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal:
      case internal::kProtocol_RequestFlexibleResponseStrict_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<FlexibleFoo>(&request_decoder, 16);
        RequestFlexibleResponseStrict(std::move(arg0));
        break;
      }
      default: {
        status = ZX_ERR_NOT_SUPPORTED;
        break;
      }
    }
    return status;
  }
  virtual void RequestStrictResponseFlexible(StrictFoo s) = 0;
  virtual void RequestFlexibleResponseStrict(FlexibleFoo s) = 0;
};

class Protocol_ResponseEncoder {
 public:
  static ::fidl::Message RequestStrictResponseFlexible(
      ::fidl::Encoder* _encoder, FlexibleFoo* f) {
    _encoder->Alloc(40 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, f, 16);
    return _encoder->GetMessage();
  }
  static ::fidl::Message RequestFlexibleResponseStrict(
      ::fidl::Encoder* _encoder, StrictFoo* f) {
    _encoder->Alloc(40 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, f, 16);
    return _encoder->GetMessage();
  }
};

class Protocol_ResponseDecoder {
 public:
  Protocol_ResponseDecoder() = default;
  virtual ~Protocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  zx_status_t Decode_(::fidl::Message response) {
    const fidl_type_t* response_type = GetType(response.ordinal());
    if (response_type == nullptr) {
      return ZX_ERR_NOT_SUPPORTED;
    }
    const char* error_msg = nullptr;
    zx_status_t status = response.Decode(response_type, &error_msg);
    if (status != ZX_OK) {
      FIDL_REPORT_DECODING_ERROR(response, response_type, error_msg);
      return status;
    }
    ::fidl::Decoder response_decoder(std::move(response));
    switch (response.ordinal()) {
      case internal::kProtocol_RequestStrictResponseFlexible_Ordinal:
      case internal::kProtocol_RequestStrictResponseFlexible_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<FlexibleFoo>(&response_decoder, 16);
        RequestStrictResponseFlexible(std::move(arg0));
        break;
      }
      case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal:
      case internal::kProtocol_RequestFlexibleResponseStrict_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<StrictFoo>(&response_decoder, 16);
        RequestFlexibleResponseStrict(std::move(arg0));
        break;
      }
      default: {
        break;
      }
    }
    return ZX_OK;
  }
  virtual void RequestStrictResponseFlexible(FlexibleFoo f) = 0;
  virtual void RequestFlexibleResponseStrict(StrictFoo f) = 0;
};

class Protocol_EventSender {
 public:
  virtual ~Protocol_EventSender();
};

class Protocol_Sync {
 public:
  using Proxy_ = Protocol_SyncProxy;
  virtual ~Protocol_Sync();
  virtual zx_status_t RequestStrictResponseFlexible(StrictFoo s,
                                                    FlexibleFoo* out_f) = 0;
  virtual zx_status_t RequestFlexibleResponseStrict(FlexibleFoo s,
                                                    StrictFoo* out_f) = 0;
};

class Protocol_Proxy final : public ::fidl::internal::Proxy, public Protocol {
 public:
  explicit Protocol_Proxy(::fidl::internal::ProxyController* controller);
  ~Protocol_Proxy() override;

  zx_status_t Dispatch_(::fidl::Message message) override;
  void RequestStrictResponseFlexible(
      StrictFoo s, RequestStrictResponseFlexibleCallback callback) override;
  void RequestFlexibleResponseStrict(
      FlexibleFoo s, RequestFlexibleResponseStrictCallback callback) override;

 private:
  Protocol_Proxy(const Protocol_Proxy&) = delete;
  Protocol_Proxy& operator=(const Protocol_Proxy&) = delete;

  ::fidl::internal::ProxyController* controller_;
};

class Protocol_Stub final : public ::fidl::internal::Stub,
                            public Protocol_EventSender {
 public:
  typedef class ::fidl::test::json::Protocol Protocol_clazz;
  explicit Protocol_Stub(Protocol_clazz* impl);
  ~Protocol_Stub() override;

  zx_status_t Dispatch_(::fidl::Message message,
                        ::fidl::internal::PendingResponse response) override;

 private:
  Protocol_clazz* impl_;
};

class Protocol_SyncProxy : public Protocol_Sync {
 public:
  explicit Protocol_SyncProxy(::zx::channel channel);
  ~Protocol_SyncProxy() override;
  zx_status_t RequestStrictResponseFlexible(StrictFoo s,
                                            FlexibleFoo* out_f) override;
  zx_status_t RequestFlexibleResponseStrict(FlexibleFoo s,
                                            StrictFoo* out_f) override;

 private:
  ::fidl::internal::SynchronousProxy proxy_;
  friend class ::fidl::SynchronousInterfacePtr<Protocol>;
};
#endif  // __Fuchsia__
}  // namespace json
}  // namespace test
}  // namespace fidl
namespace fidl {

template <>
struct IsFidlXUnion<::fidl::test::json::StrictFoo> : public std::true_type {};

template <>
struct CodingTraits<::fidl::test::json::StrictFoo>
    : public EncodableCodingTraits<::fidl::test::json::StrictFoo, 24> {};

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

  static void Encode(Encoder* encoder,
                     std::unique_ptr<::fidl::test::json::StrictFoo>* value,
                     size_t offset) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* decoder,
                     std::unique_ptr<::fidl::test::json::StrictFoo>* 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::json::StrictFoo);

    ::fidl::test::json::StrictFoo::Decode(decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::json::StrictFoo::Tag::Invalid):
        return true;
      case ::fidl::test::json::StrictFoo::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);
      case ::fidl::test::json::StrictFoo::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::fidl::test::json::FlexibleFoo> : public std::true_type {};

template <>
struct CodingTraits<::fidl::test::json::FlexibleFoo>
    : public EncodableCodingTraits<::fidl::test::json::FlexibleFoo, 24> {};

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

  static void Encode(Encoder* encoder,
                     std::unique_ptr<::fidl::test::json::FlexibleFoo>* value,
                     size_t offset) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* decoder,
                     std::unique_ptr<::fidl::test::json::FlexibleFoo>* 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::json::FlexibleFoo);

    ::fidl::test::json::FlexibleFoo::Decode(decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::json::FlexibleFoo::Tag::Invalid):
        return true;
      case ::fidl::test::json::FlexibleFoo::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);
      case ::fidl::test::json::FlexibleFoo::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      default:
        return *_lhs.UnknownData() == *_rhs.UnknownData();
    }
  }
};
}  // namespace fidl