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

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

#pragma once

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

namespace test {
namespace name {

#ifdef __Fuchsia__

class Parent;
using ParentPtr = ::fidl::InterfacePtr<Parent>;
class Parent_Proxy;
class Parent_Stub;
class Parent_EventSender;
class Parent_Sync;
using ParentSyncPtr = ::fidl::SynchronousInterfacePtr<Parent>;
class Parent_SyncProxy;
using ParentHandle = ::fidl::InterfaceHandle<Parent>;
namespace internal {
constexpr uint64_t kParent_GetChild_Ordinal = 0x3692bc6900000000lu;
constexpr uint64_t kParent_GetChild_GenOrdinal = 0x57e26ed694158086lu;
constexpr uint64_t kParent_GetChildRequest_Ordinal = 0x3faacc7e00000000lu;
constexpr uint64_t kParent_GetChildRequest_GenOrdinal = 0x5ea0990a698a80lu;
constexpr uint64_t kParent_TakeChild_Ordinal = 0x4c0642f900000000lu;
constexpr uint64_t kParent_TakeChild_GenOrdinal = 0x6a9827d18871f87dlu;
constexpr uint64_t kParent_TakeChildRequest_Ordinal = 0x5ec3867a00000000lu;
constexpr uint64_t kParent_TakeChildRequest_GenOrdinal = 0x6c4a70e2a2126637lu;

}  // namespace internal
#endif  // __Fuchsia__
#ifdef __Fuchsia__

class Child;
using ChildPtr = ::fidl::InterfacePtr<Child>;
class Child_Proxy;
class Child_Stub;
class Child_EventSender;
class Child_Sync;
using ChildSyncPtr = ::fidl::SynchronousInterfacePtr<Child>;
class Child_SyncProxy;
using ChildHandle = ::fidl::InterfaceHandle<Child>;
namespace internal {}  // namespace internal
#endif                 // __Fuchsia__
#ifdef __Fuchsia__

class Parent {
 public:
  using Proxy_ = Parent_Proxy;
  using Stub_ = Parent_Stub;
  using EventSender_ = Parent_EventSender;
  using Sync_ = Parent_Sync;
  virtual ~Parent();
  using GetChildCallback =
      fit::function<void(::fidl::InterfaceHandle<class Child>)>;

  virtual void GetChild(GetChildCallback callback) = 0;
  using GetChildRequestCallback =
      fit::function<void(::fidl::InterfaceRequest<Child>)>;

  virtual void GetChildRequest(GetChildRequestCallback callback) = 0;

  virtual void TakeChild(::fidl::InterfaceHandle<class Child> c) = 0;

  virtual void TakeChildRequest(::fidl::InterfaceRequest<Child> r) = 0;
};

class Parent_RequestEncoder {
 public:
  static ::fidl::Message GetChild(::fidl::Encoder* _encoder) {
    _encoder->Alloc(16 - sizeof(fidl_message_header_t));
    return _encoder->GetMessage();
  }
  static ::fidl::Message GetChildRequest(::fidl::Encoder* _encoder) {
    _encoder->Alloc(16 - sizeof(fidl_message_header_t));
    return _encoder->GetMessage();
  }
  static ::fidl::Message TakeChild(::fidl::Encoder* _encoder,
                                   ::fidl::InterfaceHandle<class Child>* c) {
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, c, 16);
    return _encoder->GetMessage();
  }
  static ::fidl::Message TakeChildRequest(::fidl::Encoder* _encoder,
                                          ::fidl::InterfaceRequest<Child>* r) {
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, r, 16);
    return _encoder->GetMessage();
  }
};

class Parent_RequestDecoder {
 public:
  Parent_RequestDecoder() = default;
  virtual ~Parent_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::kParent_GetChild_Ordinal:
      case internal::kParent_GetChild_GenOrdinal: {
        GetChild();
        break;
      }
      case internal::kParent_GetChildRequest_Ordinal:
      case internal::kParent_GetChildRequest_GenOrdinal: {
        GetChildRequest();
        break;
      }
      case internal::kParent_TakeChild_Ordinal:
      case internal::kParent_TakeChild_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<::fidl::InterfaceHandle<class Child>>(
            &request_decoder, 16);
        TakeChild(std::move(arg0));
        break;
      }
      case internal::kParent_TakeChildRequest_Ordinal:
      case internal::kParent_TakeChildRequest_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<::fidl::InterfaceRequest<Child>>(
            &request_decoder, 16);
        TakeChildRequest(std::move(arg0));
        break;
      }
      default: {
        status = ZX_ERR_NOT_SUPPORTED;
        break;
      }
    }
    return status;
  }
  virtual void GetChild() = 0;
  virtual void GetChildRequest() = 0;
  virtual void TakeChild(::fidl::InterfaceHandle<class Child> c) = 0;
  virtual void TakeChildRequest(::fidl::InterfaceRequest<Child> r) = 0;
};

class Parent_ResponseEncoder {
 public:
  static ::fidl::Message GetChild(::fidl::Encoder* _encoder,
                                  ::fidl::InterfaceHandle<class Child>* c) {
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, c, 16);
    return _encoder->GetMessage();
  }
  static ::fidl::Message GetChildRequest(::fidl::Encoder* _encoder,
                                         ::fidl::InterfaceRequest<Child>* r) {
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, r, 16);
    return _encoder->GetMessage();
  }
};

class Parent_ResponseDecoder {
 public:
  Parent_ResponseDecoder() = default;
  virtual ~Parent_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::kParent_GetChild_Ordinal:
      case internal::kParent_GetChild_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<::fidl::InterfaceHandle<class Child>>(
            &response_decoder, 16);
        GetChild(std::move(arg0));
        break;
      }
      case internal::kParent_GetChildRequest_Ordinal:
      case internal::kParent_GetChildRequest_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<::fidl::InterfaceRequest<Child>>(
            &response_decoder, 16);
        GetChildRequest(std::move(arg0));
        break;
      }
      default: {
        break;
      }
    }
    return ZX_OK;
  }
  virtual void GetChild(::fidl::InterfaceHandle<class Child> c) = 0;
  virtual void GetChildRequest(::fidl::InterfaceRequest<Child> r) = 0;
};

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

class Parent_Sync {
 public:
  using Proxy_ = Parent_SyncProxy;
  virtual ~Parent_Sync();
  virtual zx_status_t GetChild(::fidl::InterfaceHandle<class Child>* out_c) = 0;
  virtual zx_status_t GetChildRequest(
      ::fidl::InterfaceRequest<Child>* out_r) = 0;
  virtual zx_status_t TakeChild(::fidl::InterfaceHandle<class Child> c) = 0;
  virtual zx_status_t TakeChildRequest(::fidl::InterfaceRequest<Child> r) = 0;
};

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

  zx_status_t Dispatch_(::fidl::Message message) override;
  void GetChild(GetChildCallback callback) override;
  void GetChildRequest(GetChildRequestCallback callback) override;
  void TakeChild(::fidl::InterfaceHandle<class Child> c) override;
  void TakeChildRequest(::fidl::InterfaceRequest<Child> r) override;

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

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

class Parent_Stub final : public ::fidl::internal::Stub,
                          public Parent_EventSender {
 public:
  typedef class ::test::name::Parent Parent_clazz;
  explicit Parent_Stub(Parent_clazz* impl);
  ~Parent_Stub() override;

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

 private:
  Parent_clazz* impl_;
};

class Parent_SyncProxy : public Parent_Sync {
 public:
  explicit Parent_SyncProxy(::zx::channel channel);
  ~Parent_SyncProxy() override;
  zx_status_t GetChild(::fidl::InterfaceHandle<class Child>* out_c) override;
  zx_status_t GetChildRequest(::fidl::InterfaceRequest<Child>* out_r) override;
  zx_status_t TakeChild(::fidl::InterfaceHandle<class Child> c) override;
  zx_status_t TakeChildRequest(::fidl::InterfaceRequest<Child> r) override;

 private:
  ::fidl::internal::SynchronousProxy proxy_;
  friend class ::fidl::SynchronousInterfacePtr<Parent>;
};
#endif  // __Fuchsia__
#ifdef __Fuchsia__

class Child {
 public:
  using Proxy_ = Child_Proxy;
  using Stub_ = Child_Stub;
  using EventSender_ = Child_EventSender;
  using Sync_ = Child_Sync;
  virtual ~Child();
};

class Child_RequestEncoder {
 public:
};

class Child_RequestDecoder {
 public:
  Child_RequestDecoder() = default;
  virtual ~Child_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()) {
      default: {
        status = ZX_ERR_NOT_SUPPORTED;
        break;
      }
    }
    return status;
  }
};

class Child_ResponseEncoder {
 public:
};

class Child_ResponseDecoder {
 public:
  Child_ResponseDecoder() = default;
  virtual ~Child_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()) {
      default: {
        break;
      }
    }
    return ZX_OK;
  }
};

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

class Child_Sync {
 public:
  using Proxy_ = Child_SyncProxy;
  virtual ~Child_Sync();
};

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

  zx_status_t Dispatch_(::fidl::Message message) override;

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

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

class Child_Stub final : public ::fidl::internal::Stub,
                         public Child_EventSender {
 public:
  typedef class ::test::name::Child Child_clazz;
  explicit Child_Stub(Child_clazz* impl);
  ~Child_Stub() override;

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

 private:
  Child_clazz* impl_;
};

class Child_SyncProxy : public Child_Sync {
 public:
  explicit Child_SyncProxy(::zx::channel channel);
  ~Child_SyncProxy() override;

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