func (c *valueStoreClient) StreamDelete(ctx context.Context, opts ...grpc.CallOption) (ValueStore_StreamDeleteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ValueStore_serviceDesc.Streams[3], c.cc, "/valueproto.ValueStore/StreamDelete", opts...)
if err != nil {
return nil, err
}
x := &valueStoreStreamDeleteClient{stream}
return x, nil
}
func (c *gameServiceClient) Stream(ctx context.Context, opts ...grpc.CallOption) (GameService_StreamClient, error) {
stream, err := grpc.NewClientStream(ctx, &_GameService_serviceDesc.Streams[0], c.cc, "/proto.GameService/Stream", opts...)
if err != nil {
return nil, err
}
x := &gameServiceStreamClient{stream}
return x, nil
}
func (c *routeGuideClient) RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RouteGuide_serviceDesc.Streams[2], c.cc, "/routeguide.RouteGuide/RouteChat", opts...)
if err != nil {
return nil, err
}
x := &routeGuideRouteChatClient{stream}
return x, nil
}
func (c *testServiceClient) HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[3], c.cc, "/grpc.testing.TestService/HalfDuplexCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceHalfDuplexCallClient{stream}
return x, nil
}
func (c *peerClient) Chat(ctx context.Context, opts ...grpc.CallOption) (Peer_ChatClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Peer_serviceDesc.Streams[0], c.cc, "/protos.Peer/Chat", opts...)
if err != nil {
return nil, err
}
x := &peerChatClient{stream}
return x, nil
}
func (c *longTestsClient) CharCount(ctx context.Context, opts ...grpc.CallOption) (LongTests_CharCountClient, error) {
stream, err := grpc.NewClientStream(ctx, &_LongTests_serviceDesc.Streams[0], c.cc, "/LongTests/char_count", opts...)
if err != nil {
return nil, err
}
x := &longTestsCharCountClient{stream}
return x, nil
}
func (c *aPIClient) Do(ctx context.Context, opts ...grpc.CallOption) (API_DoClient, error) {
stream, err := grpc.NewClientStream(ctx, &_API_serviceDesc.Streams[0], c.cc, "/protoprocess.API/Do", opts...)
if err != nil {
return nil, err
}
x := &aPIDoClient{stream}
return x, nil
}
func (c *myTestClient) Bidi(ctx context.Context, opts ...grpc1.CallOption) (MyTest_BidiClient, error) {
stream, err := grpc1.NewClientStream(ctx, &_MyTest_serviceDesc.Streams[2], c.cc, "/grpc.MyTest/Bidi", opts...)
if err != nil {
return nil, err
}
x := &myTestBidiClient{stream}
return x, nil
}
func (c *playsourceClient) QueueSong(ctx context.Context, opts ...grpc.CallOption) (Playsource_QueueSongClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Playsource_serviceDesc.Streams[0], c.cc, "/Playsource.Playsource/QueueSong", opts...)
if err != nil {
return nil, err
}
x := &playsourceQueueSongClient{stream}
return x, nil
}
func (c *leverRPCClient) HandleStreamingRPC(ctx context.Context, opts ...grpc.CallOption) (LeverRPC_HandleStreamingRPCClient, error) {
stream, err := grpc.NewClientStream(ctx, &_LeverRPC_serviceDesc.Streams[0], c.cc, "/core.LeverRPC/HandleStreamingRPC", opts...)
if err != nil {
return nil, err
}
x := &leverRPCHandleStreamingRPCClient{stream}
return x, nil
}
func (c *chatClient) Chat(ctx context.Context, opts ...grpc.CallOption) (Chat_ChatClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Chat_serviceDesc.Streams[0], c.cc, "/chat_msg.Chat/Chat", opts...)
if err != nil {
return nil, err
}
x := &chatChatClient{stream}
return x, nil
}
func (c *kurmaClient) Enter(ctx context.Context, opts ...grpc.CallOption) (Kurma_EnterClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Kurma_serviceDesc.Streams[1], c.cc, "/client.Kurma/Enter", opts...)
if err != nil {
return nil, err
}
x := &kurmaEnterClient{stream}
return x, nil
}
func (c *kurmaClient) UploadImage(ctx context.Context, opts ...grpc.CallOption) (Kurma_UploadImageClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Kurma_serviceDesc.Streams[0], c.cc, "/client.Kurma/UploadImage", opts...)
if err != nil {
return nil, err
}
x := &kurmaUploadImageClient{stream}
return x, nil
}
func (c *loadBalancerClient) BalanceLoad(ctx context.Context, opts ...grpc.CallOption) (LoadBalancer_BalanceLoadClient, error) {
stream, err := grpc.NewClientStream(ctx, &_LoadBalancer_serviceDesc.Streams[0], c.cc, "/grpc.lb.v1.LoadBalancer/BalanceLoad", opts...)
if err != nil {
return nil, err
}
x := &loadBalancerBalanceLoadClient{stream}
return x, nil
}
func (c *workerServiceClient) RunClient(ctx context.Context, opts ...grpc.CallOption) (WorkerService_RunClientClient, error) {
stream, err := grpc.NewClientStream(ctx, &_WorkerService_serviceDesc.Streams[1], c.cc, "/grpc.testing.WorkerService/RunClient", opts...)
if err != nil {
return nil, err
}
x := &workerServiceRunClientClient{stream}
return x, nil
}
func (c *searchServiceClient) StreamingSearch(ctx context.Context, opts ...grpc.CallOption) (SearchService_StreamingSearchClient, error) {
stream, err := grpc.NewClientStream(ctx, &_SearchService_serviceDesc.Streams[0], c.cc, "/grpc.testing.SearchService/StreamingSearch", opts...)
if err != nil {
return nil, err
}
x := &searchServiceStreamingSearchClient{stream}
return x, nil
}
func (c *benchmarkServiceClient) StreamingCall(ctx context.Context, opts ...grpc.CallOption) (BenchmarkService_StreamingCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_BenchmarkService_serviceDesc.Streams[0], c.cc, "/grpc.testing.BenchmarkService/StreamingCall", opts...)
if err != nil {
return nil, err
}
x := &benchmarkServiceStreamingCallClient{stream}
return x, nil
}
func (c *routeGuideClient) RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RouteGuide_serviceDesc.Streams[1], c.cc, "/proto.RouteGuide/RecordRoute", opts...)
if err != nil {
return nil, err
}
x := &routeGuideRecordRouteClient{stream}
return x, nil
}
func (c *distSQLClient) FlowStream(ctx context.Context, opts ...grpc.CallOption) (DistSQL_FlowStreamClient, error) {
stream, err := grpc.NewClientStream(ctx, &_DistSQL_serviceDesc.Streams[1], c.cc, "/cockroach.sql.distsql.DistSQL/FlowStream", opts...)
if err != nil {
return nil, err
}
x := &distSQLFlowStreamClient{stream}
return x, nil
}
func (c *fooClient) Bar(ctx context.Context, opts ...grpc.CallOption) (Foo_BarClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Foo_serviceDesc.Streams[0], c.cc, "/Foo/Bar", opts...)
if err != nil {
return nil, err
}
x := &fooBarClient{stream}
return x, nil
}
func (c *aPIClient) PutBlock(ctx context.Context, opts ...grpc.CallOption) (API_PutBlockClient, error) {
stream, err := grpc.NewClientStream(ctx, &_API_serviceDesc.Streams[0], c.cc, "/.API/PutBlock", opts...)
if err != nil {
return nil, err
}
x := &aPIPutBlockClient{stream}
return x, nil
}
func (c *gossipClient) GossipStream(ctx context.Context, opts ...grpc.CallOption) (Gossip_GossipStreamClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Gossip_serviceDesc.Streams[0], c.cc, "/proto.Gossip/GossipStream", opts...)
if err != nil {
return nil, err
}
x := &gossipGossipStreamClient{stream}
return x, nil
}
func (c *byteStreamClient) Write(ctx context.Context, opts ...grpc.CallOption) (ByteStream_WriteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ByteStream_serviceDesc.Streams[1], c.cc, "/google.bytestream.ByteStream/Write", opts...)
if err != nil {
return nil, err
}
x := &byteStreamWriteClient{stream}
return x, nil
}
func (c *chaincodeSupportClient) Register(ctx context.Context, opts ...grpc.CallOption) (ChaincodeSupport_RegisterClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ChaincodeSupport_serviceDesc.Streams[0], c.cc, "/protos.ChaincodeSupport/Register", opts...)
if err != nil {
return nil, err
}
x := &chaincodeSupportRegisterClient{stream}
return x, nil
}
func (c *multiRaftClient) RaftMessage(ctx context.Context, opts ...grpc.CallOption) (MultiRaft_RaftMessageClient, error) {
stream, err := grpc.NewClientStream(ctx, &_MultiRaft_serviceDesc.Streams[0], c.cc, "/cockroach.storage.MultiRaft/RaftMessage", opts...)
if err != nil {
return nil, err
}
x := &multiRaftRaftMessageClient{stream}
return x, nil
}
func (c *aBitOfEverythingServiceClient) BulkEcho(ctx context.Context, opts ...grpc.CallOption) (ABitOfEverythingService_BulkEchoClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ABitOfEverythingService_serviceDesc.Streams[2], c.cc, "/gengo.grpc.gateway.examples.examplepb.ABitOfEverythingService/BulkEcho", opts...)
if err != nil {
return nil, err
}
x := &aBitOfEverythingServiceBulkEchoClient{stream}
return x, nil
}
func (c *eventsClient) Chat(ctx context.Context, opts ...grpc.CallOption) (Events_ChatClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Events_serviceDesc.Streams[0], c.cc, "/protos.Events/Chat", opts...)
if err != nil {
return nil, err
}
x := &eventsChatClient{stream}
return x, nil
}
func (c *apiClient) ForceArchiveFeed(ctx context.Context, opts ...grpc.CallOption) (Api_ForceArchiveFeedClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Api_serviceDesc.Streams[1], c.cc, "/proto.Api/ForceArchiveFeed", opts...)
if err != nil {
return nil, err
}
x := &apiForceArchiveFeedClient{stream}
return x, nil
}
func (c *flowCombinationClient) StreamEmptyStream(ctx context.Context, opts ...grpc.CallOption) (FlowCombination_StreamEmptyStreamClient, error) {
stream, err := grpc.NewClientStream(ctx, &_FlowCombination_serviceDesc.Streams[2], c.cc, "/gengo.grpc.gateway.examples.examplepb.FlowCombination/StreamEmptyStream", opts...)
if err != nil {
return nil, err
}
x := &flowCombinationStreamEmptyStreamClient{stream}
return x, nil
}
func (c *fileDataServiceClient) Get(ctx context.Context, opts ...grpc.CallOption) (FileDataService_GetClient, error) {
stream, err := grpc.NewClientStream(ctx, &_FileDataService_serviceDesc.Streams[0], c.cc, "/kythe.proto.FileDataService/Get", opts...)
if err != nil {
return nil, err
}
x := &fileDataServiceGetClient{stream}
return x, nil
}