tools/fidl/fidlgen_hlcpp/goldens/bindings/protocols_test_base.h.golden

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

#pragma once

#include <fidl/test/protocols/cpp/fidl.h>
namespace fidl {
namespace test {
namespace protocols {
namespace testing {
class HandleRightsProtocol_TestBase
    : public ::fidl::test::protocols::HandleRightsProtocol {
 public:
  virtual ~HandleRightsProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void NoResponseMethod(::zx::socket h) override {
    NotImplemented_("NoResponseMethod");
  }
  void ResponseMethod(::zx::socket h,
                      ResponseMethodCallback callback) override {
    NotImplemented_("ResponseMethod");
  }
};

class WithAndWithoutRequestResponse_TestBase
    : public ::fidl::test::protocols::WithAndWithoutRequestResponse {
 public:
  virtual ~WithAndWithoutRequestResponse_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void NoRequestNoResponse() override {
    NotImplemented_("NoRequestNoResponse");
  }
  void NoRequestEmptyResponse(
      NoRequestEmptyResponseCallback callback) override {
    NotImplemented_("NoRequestEmptyResponse");
  }
  void NoRequestWithResponse(NoRequestWithResponseCallback callback) override {
    NotImplemented_("NoRequestWithResponse");
  }
  void WithRequestNoResponse(::std::string arg) override {
    NotImplemented_("WithRequestNoResponse");
  }
  void WithRequestEmptyResponse(
      ::std::string arg, WithRequestEmptyResponseCallback callback) override {
    NotImplemented_("WithRequestEmptyResponse");
  }
  void WithRequestWithResponse(
      ::std::string arg, WithRequestWithResponseCallback callback) override {
    NotImplemented_("WithRequestWithResponse");
  }
};

class Transitional_TestBase : public ::fidl::test::protocols::Transitional {
 public:
  virtual ~Transitional_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void Request(int64_t x, RequestCallback callback) override {
    NotImplemented_("Request");
  }
  void OneWay(int64_t x) override { NotImplemented_("OneWay"); }
};

class MethodWithUnion_TestBase
    : public ::fidl::test::protocols::MethodWithUnion {
 public:
  virtual ~MethodWithUnion_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void UnionMethod(::fidl::test::protocols::TheUnion u) override {
    NotImplemented_("UnionMethod");
  }
};

class WithProtocolEnds_TestBase
    : public ::fidl::test::protocols::WithProtocolEnds {
 public:
  virtual ~WithProtocolEnds_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void ClientEnds(
      ::fidl::InterfaceHandle<::fidl::test::protocols::DiscoverableProtocol> in,
      ClientEndsCallback callback) override {
    NotImplemented_("ClientEnds");
  }
  void ServerEnds(
      ::fidl::InterfaceRequest<::fidl::test::protocols::DiscoverableProtocol>
          in,
      ServerEndsCallback callback) override {
    NotImplemented_("ServerEnds");
  }
  void StructContainingEnds(::fidl::test::protocols::ProtocolEnds in,
                            StructContainingEndsCallback callback) override {
    NotImplemented_("StructContainingEnds");
  }
};

class ManyParameters_TestBase : public ::fidl::test::protocols::ManyParameters {
 public:
  virtual ~ManyParameters_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void Fifteen(bool p1, bool p2, bool p3, bool p4, bool p5, bool p6, bool p7,
               bool p8, bool p9, bool p10, bool p11, bool p12, bool p13,
               bool p14, bool p15) override {
    NotImplemented_("Fifteen");
  }
};

class WithErrorSyntax_TestBase
    : public ::fidl::test::protocols::WithErrorSyntax {
 public:
  virtual ~WithErrorSyntax_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void ResponseAsStruct(ResponseAsStructCallback callback) override {
    NotImplemented_("ResponseAsStruct");
  }
  void ErrorAsPrimitive(ErrorAsPrimitiveCallback callback) override {
    NotImplemented_("ErrorAsPrimitive");
  }
  void ErrorAsEnum(ErrorAsEnumCallback callback) override {
    NotImplemented_("ErrorAsEnum");
  }
  void HandleInResult(HandleInResultCallback callback) override {
    NotImplemented_("HandleInResult");
  }
};

class DiscoverableProtocol_TestBase
    : public ::fidl::test::protocols::DiscoverableProtocol {
 public:
  virtual ~DiscoverableProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void Method() override { NotImplemented_("Method"); }
};

class ChannelProtocol_TestBase
    : public ::fidl::test::protocols::ChannelProtocol {
 public:
  virtual ~ChannelProtocol_TestBase() {}
  virtual void NotImplemented_(const std::string& name) = 0;
  void MethodA(int64_t a, int64_t b) override { NotImplemented_("MethodA"); }
  void MethodB(int64_t a, int64_t b, MethodBCallback callback) override {
    NotImplemented_("MethodB");
  }
  void TakeHandle(::zx::handle h, TakeHandleCallback callback) override {
    NotImplemented_("TakeHandle");
  }
  void MutateSocket(::zx::socket a, MutateSocketCallback callback) override {
    NotImplemented_("MutateSocket");
  }
};
}  // namespace testing
}  // namespace protocols
}  // namespace test
}  // namespace fidl