tools/fidl/fidlgen_llcpp/goldens/protocols_test_base.h.golden

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

#pragma once

#include <fidl/test/protocols/llcpp/fidl.h>
namespace fidl_test_protocols {
namespace testing {

class DiscoverableProtocol_TestBase
    : public ::fidl::WireInterface<
          ::fidl_test_protocols::DiscoverableProtocol> {
 public:
  virtual ~DiscoverableProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;

  using Interface =
      ::fidl::WireInterface<::fidl_test_protocols::DiscoverableProtocol>;
  virtual void Method(
      ::fidl::WireServer<::fidl_test_protocols::DiscoverableProtocol>::
          MethodCompleter::Sync& completer) override {
    NotImplemented_("Method", completer);
  }
};

class Transitional_TestBase
    : public ::fidl::WireInterface<::fidl_test_protocols::Transitional> {
 public:
  virtual ~Transitional_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;

  using Interface = ::fidl::WireInterface<::fidl_test_protocols::Transitional>;
  virtual void Request(int64_t x,
                       ::fidl::WireServer<::fidl_test_protocols::Transitional>::
                           RequestCompleter::Sync& completer) override {
    NotImplemented_("Request", completer);
  }
  virtual void OneWay(int64_t x,
                      ::fidl::WireServer<::fidl_test_protocols::Transitional>::
                          OneWayCompleter::Sync& completer) override {
    NotImplemented_("OneWay", completer);
  }
};

class ChannelProtocol_TestBase
    : public ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol> {
 public:
  virtual ~ChannelProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;

  using Interface =
      ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>;
  virtual void MethodA(
      int64_t a, int64_t b,
      ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
          MethodACompleter::Sync& completer) override {
    NotImplemented_("MethodA", completer);
  }
  virtual void MethodB(
      int64_t a, int64_t b,
      ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
          MethodBCompleter::Sync& completer) override {
    NotImplemented_("MethodB", completer);
  }
  virtual void TakeHandle(
      ::zx::handle h,
      ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
          TakeHandleCompleter::Sync& completer) override {
    NotImplemented_("TakeHandle", completer);
  }
  virtual void MutateSocket(
      ::zx::socket a,
      ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
          MutateSocketCompleter::Sync& completer) override {
    NotImplemented_("MutateSocket", completer);
  }
};

class WithAndWithoutRequestResponse_TestBase
    : public ::fidl::WireInterface<
          ::fidl_test_protocols::WithAndWithoutRequestResponse> {
 public:
  virtual ~WithAndWithoutRequestResponse_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;

  using Interface = ::fidl::WireInterface<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>;
  virtual void NoRequestNoResponse(
      ::fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
          NoRequestNoResponseCompleter::Sync& completer) override {
    NotImplemented_("NoRequestNoResponse", completer);
  }
  virtual void NoRequestEmptyResponse(
      ::fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
          NoRequestEmptyResponseCompleter::Sync& completer) override {
    NotImplemented_("NoRequestEmptyResponse", completer);
  }
  virtual void NoRequestWithResponse(
      ::fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
          NoRequestWithResponseCompleter::Sync& completer) override {
    NotImplemented_("NoRequestWithResponse", completer);
  }
  virtual void WithRequestNoResponse(
      ::fidl::StringView arg,
      ::fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
          WithRequestNoResponseCompleter::Sync& completer) override {
    NotImplemented_("WithRequestNoResponse", completer);
  }
  virtual void WithRequestEmptyResponse(
      ::fidl::StringView arg,
      ::fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
          WithRequestEmptyResponseCompleter::Sync& completer) override {
    NotImplemented_("WithRequestEmptyResponse", completer);
  }
  virtual void WithRequestWithResponse(
      ::fidl::StringView arg,
      ::fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
          WithRequestWithResponseCompleter::Sync& completer) override {
    NotImplemented_("WithRequestWithResponse", completer);
  }
};

class WithErrorSyntax_TestBase
    : public ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax> {
 public:
  virtual ~WithErrorSyntax_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;

  using Interface =
      ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>;
  virtual void ResponseAsStruct(
      ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
          ResponseAsStructCompleter::Sync& completer) override {
    NotImplemented_("ResponseAsStruct", completer);
  }
  virtual void ErrorAsPrimitive(
      ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
          ErrorAsPrimitiveCompleter::Sync& completer) override {
    NotImplemented_("ErrorAsPrimitive", completer);
  }
  virtual void ErrorAsEnum(
      ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
          ErrorAsEnumCompleter::Sync& completer) override {
    NotImplemented_("ErrorAsEnum", completer);
  }
};
}  // namespace testing
}  // namespace fidl_test_protocols