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

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

#pragma once

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

class HandleRightsProtocol_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::HandleRightsProtocol> {
 public:
  virtual ~HandleRightsProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void NoResponseMethod(
      NoResponseMethodRequestView request,
      NoResponseMethodCompleter::Sync& _completer) override {
    NotImplemented_("NoResponseMethod", _completer);
  }
  virtual void ResponseMethod(
      ResponseMethodRequestView request,
      ResponseMethodCompleter::Sync& _completer) override {
    NotImplemented_("ResponseMethod", _completer);
  }
};

class WithAndWithoutRequestResponse_TestBase
    : public ::fidl::WireServer<
          ::fidl_test_protocols::WithAndWithoutRequestResponse> {
 public:
  virtual ~WithAndWithoutRequestResponse_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void NoRequestNoResponse(
      NoRequestNoResponseRequestView request,
      NoRequestNoResponseCompleter::Sync& _completer) override {
    NotImplemented_("NoRequestNoResponse", _completer);
  }
  virtual void NoRequestEmptyResponse(
      NoRequestEmptyResponseRequestView request,
      NoRequestEmptyResponseCompleter::Sync& _completer) override {
    NotImplemented_("NoRequestEmptyResponse", _completer);
  }
  virtual void NoRequestWithResponse(
      NoRequestWithResponseRequestView request,
      NoRequestWithResponseCompleter::Sync& _completer) override {
    NotImplemented_("NoRequestWithResponse", _completer);
  }
  virtual void WithRequestNoResponse(
      WithRequestNoResponseRequestView request,
      WithRequestNoResponseCompleter::Sync& _completer) override {
    NotImplemented_("WithRequestNoResponse", _completer);
  }
  virtual void WithRequestEmptyResponse(
      WithRequestEmptyResponseRequestView request,
      WithRequestEmptyResponseCompleter::Sync& _completer) override {
    NotImplemented_("WithRequestEmptyResponse", _completer);
  }
  virtual void WithRequestWithResponse(
      WithRequestWithResponseRequestView request,
      WithRequestWithResponseCompleter::Sync& _completer) override {
    NotImplemented_("WithRequestWithResponse", _completer);
  }
};

class Transitional_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::Transitional> {
 public:
  virtual ~Transitional_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void Request(RequestRequestView request,
                       RequestCompleter::Sync& _completer) override {
    NotImplemented_("Request", _completer);
  }
  virtual void OneWay(OneWayRequestView request,
                      OneWayCompleter::Sync& _completer) override {
    NotImplemented_("OneWay", _completer);
  }
};

class MethodWithUnion_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::MethodWithUnion> {
 public:
  virtual ~MethodWithUnion_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void UnionMethod(UnionMethodRequestView request,
                           UnionMethodCompleter::Sync& _completer) override {
    NotImplemented_("UnionMethod", _completer);
  }
};

class WithProtocolEnds_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::WithProtocolEnds> {
 public:
  virtual ~WithProtocolEnds_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void ClientEnds(ClientEndsRequestView request,
                          ClientEndsCompleter::Sync& _completer) override {
    NotImplemented_("ClientEnds", _completer);
  }
  virtual void ServerEnds(ServerEndsRequestView request,
                          ServerEndsCompleter::Sync& _completer) override {
    NotImplemented_("ServerEnds", _completer);
  }
  virtual void StructContainingEnds(
      StructContainingEndsRequestView request,
      StructContainingEndsCompleter::Sync& _completer) override {
    NotImplemented_("StructContainingEnds", _completer);
  }
};

class ManyParameters_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::ManyParameters> {
 public:
  virtual ~ManyParameters_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void Fifteen(FifteenRequestView request,
                       FifteenCompleter::Sync& _completer) override {
    NotImplemented_("Fifteen", _completer);
  }
};

class WithErrorSyntax_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax> {
 public:
  virtual ~WithErrorSyntax_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void ResponseAsStruct(
      ResponseAsStructRequestView request,
      ResponseAsStructCompleter::Sync& _completer) override {
    NotImplemented_("ResponseAsStruct", _completer);
  }
  virtual void ErrorAsPrimitive(
      ErrorAsPrimitiveRequestView request,
      ErrorAsPrimitiveCompleter::Sync& _completer) override {
    NotImplemented_("ErrorAsPrimitive", _completer);
  }
  virtual void ErrorAsEnum(ErrorAsEnumRequestView request,
                           ErrorAsEnumCompleter::Sync& _completer) override {
    NotImplemented_("ErrorAsEnum", _completer);
  }
  virtual void HandleInResult(
      HandleInResultRequestView request,
      HandleInResultCompleter::Sync& _completer) override {
    NotImplemented_("HandleInResult", _completer);
  }
};

class DiscoverableProtocol_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::DiscoverableProtocol> {
 public:
  virtual ~DiscoverableProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void Method(MethodRequestView request,
                      MethodCompleter::Sync& _completer) override {
    NotImplemented_("Method", _completer);
  }
};

class ChannelProtocol_TestBase
    : public ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol> {
 public:
  virtual ~ChannelProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name,
                               ::fidl::CompleterBase& completer) = 0;
  virtual void MethodA(MethodARequestView request,
                       MethodACompleter::Sync& _completer) override {
    NotImplemented_("MethodA", _completer);
  }
  virtual void MethodB(MethodBRequestView request,
                       MethodBCompleter::Sync& _completer) override {
    NotImplemented_("MethodB", _completer);
  }
  virtual void TakeHandle(TakeHandleRequestView request,
                          TakeHandleCompleter::Sync& _completer) override {
    NotImplemented_("TakeHandle", _completer);
  }
  virtual void MutateSocket(MutateSocketRequestView request,
                            MutateSocketCompleter::Sync& _completer) override {
    NotImplemented_("MutateSocket", _completer);
  }
};
}  // namespace testing
}  // namespace fidl_test_protocols