Source file src/github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/examplepb/response_body_service.pb.gw.go

Documentation: github.com/grpc-ecosystem/grpc-gateway/v2/examples/internal/proto/examplepb

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: examples/internal/proto/examplepb/response_body_service.proto
     3  
     4  /*
     5  Package examplepb is a reverse proxy.
     6  
     7  It translates gRPC into RESTful JSON APIs.
     8  */
     9  package examplepb
    10  
    11  import (
    12  	"context"
    13  	"io"
    14  	"net/http"
    15  
    16  	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    17  	"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
    18  	"google.golang.org/grpc"
    19  	"google.golang.org/grpc/codes"
    20  	"google.golang.org/grpc/grpclog"
    21  	"google.golang.org/grpc/metadata"
    22  	"google.golang.org/grpc/status"
    23  	"google.golang.org/protobuf/proto"
    24  )
    25  
    26  // Suppress "imported and not used" errors
    27  var _ codes.Code
    28  var _ io.Reader
    29  var _ status.Status
    30  var _ = runtime.String
    31  var _ = utilities.NewDoubleArray
    32  var _ = metadata.Join
    33  
    34  func request_ResponseBodyService_GetResponseBody_0(ctx context.Context, marshaler runtime.Marshaler, client ResponseBodyServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    35  	var protoReq ResponseBodyIn
    36  	var metadata runtime.ServerMetadata
    37  
    38  	var (
    39  		val string
    40  		ok  bool
    41  		err error
    42  		_   = err
    43  	)
    44  
    45  	val, ok = pathParams["data"]
    46  	if !ok {
    47  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "data")
    48  	}
    49  
    50  	protoReq.Data, err = runtime.String(val)
    51  	if err != nil {
    52  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "data", err)
    53  	}
    54  
    55  	msg, err := client.GetResponseBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    56  	return msg, metadata, err
    57  
    58  }
    59  
    60  func local_request_ResponseBodyService_GetResponseBody_0(ctx context.Context, marshaler runtime.Marshaler, server ResponseBodyServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    61  	var protoReq ResponseBodyIn
    62  	var metadata runtime.ServerMetadata
    63  
    64  	var (
    65  		val string
    66  		ok  bool
    67  		err error
    68  		_   = err
    69  	)
    70  
    71  	val, ok = pathParams["data"]
    72  	if !ok {
    73  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "data")
    74  	}
    75  
    76  	protoReq.Data, err = runtime.String(val)
    77  	if err != nil {
    78  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "data", err)
    79  	}
    80  
    81  	msg, err := server.GetResponseBody(ctx, &protoReq)
    82  	return msg, metadata, err
    83  
    84  }
    85  
    86  func request_ResponseBodyService_ListResponseBodies_0(ctx context.Context, marshaler runtime.Marshaler, client ResponseBodyServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    87  	var protoReq ResponseBodyIn
    88  	var metadata runtime.ServerMetadata
    89  
    90  	var (
    91  		val string
    92  		ok  bool
    93  		err error
    94  		_   = err
    95  	)
    96  
    97  	val, ok = pathParams["data"]
    98  	if !ok {
    99  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "data")
   100  	}
   101  
   102  	protoReq.Data, err = runtime.String(val)
   103  	if err != nil {
   104  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "data", err)
   105  	}
   106  
   107  	msg, err := client.ListResponseBodies(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   108  	return msg, metadata, err
   109  
   110  }
   111  
   112  func local_request_ResponseBodyService_ListResponseBodies_0(ctx context.Context, marshaler runtime.Marshaler, server ResponseBodyServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   113  	var protoReq ResponseBodyIn
   114  	var metadata runtime.ServerMetadata
   115  
   116  	var (
   117  		val string
   118  		ok  bool
   119  		err error
   120  		_   = err
   121  	)
   122  
   123  	val, ok = pathParams["data"]
   124  	if !ok {
   125  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "data")
   126  	}
   127  
   128  	protoReq.Data, err = runtime.String(val)
   129  	if err != nil {
   130  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "data", err)
   131  	}
   132  
   133  	msg, err := server.ListResponseBodies(ctx, &protoReq)
   134  	return msg, metadata, err
   135  
   136  }
   137  
   138  func request_ResponseBodyService_ListResponseStrings_0(ctx context.Context, marshaler runtime.Marshaler, client ResponseBodyServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   139  	var protoReq ResponseBodyIn
   140  	var metadata runtime.ServerMetadata
   141  
   142  	var (
   143  		val string
   144  		ok  bool
   145  		err error
   146  		_   = err
   147  	)
   148  
   149  	val, ok = pathParams["data"]
   150  	if !ok {
   151  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "data")
   152  	}
   153  
   154  	protoReq.Data, err = runtime.String(val)
   155  	if err != nil {
   156  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "data", err)
   157  	}
   158  
   159  	msg, err := client.ListResponseStrings(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   160  	return msg, metadata, err
   161  
   162  }
   163  
   164  func local_request_ResponseBodyService_ListResponseStrings_0(ctx context.Context, marshaler runtime.Marshaler, server ResponseBodyServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   165  	var protoReq ResponseBodyIn
   166  	var metadata runtime.ServerMetadata
   167  
   168  	var (
   169  		val string
   170  		ok  bool
   171  		err error
   172  		_   = err
   173  	)
   174  
   175  	val, ok = pathParams["data"]
   176  	if !ok {
   177  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "data")
   178  	}
   179  
   180  	protoReq.Data, err = runtime.String(val)
   181  	if err != nil {
   182  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "data", err)
   183  	}
   184  
   185  	msg, err := server.ListResponseStrings(ctx, &protoReq)
   186  	return msg, metadata, err
   187  
   188  }
   189  
   190  func request_ResponseBodyService_GetResponseBodyStream_0(ctx context.Context, marshaler runtime.Marshaler, client ResponseBodyServiceClient, req *http.Request, pathParams map[string]string) (ResponseBodyService_GetResponseBodyStreamClient, runtime.ServerMetadata, error) {
   191  	var protoReq ResponseBodyIn
   192  	var metadata runtime.ServerMetadata
   193  
   194  	var (
   195  		val string
   196  		ok  bool
   197  		err error
   198  		_   = err
   199  	)
   200  
   201  	val, ok = pathParams["data"]
   202  	if !ok {
   203  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "data")
   204  	}
   205  
   206  	protoReq.Data, err = runtime.String(val)
   207  	if err != nil {
   208  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "data", err)
   209  	}
   210  
   211  	stream, err := client.GetResponseBodyStream(ctx, &protoReq)
   212  	if err != nil {
   213  		return nil, metadata, err
   214  	}
   215  	header, err := stream.Header()
   216  	if err != nil {
   217  		return nil, metadata, err
   218  	}
   219  	metadata.HeaderMD = header
   220  	return stream, metadata, nil
   221  
   222  }
   223  
   224  // RegisterResponseBodyServiceHandlerServer registers the http handlers for service ResponseBodyService to "mux".
   225  // UnaryRPC     :call ResponseBodyServiceServer directly.
   226  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   227  // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterResponseBodyServiceHandlerFromEndpoint instead.
   228  func RegisterResponseBodyServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ResponseBodyServiceServer) error {
   229  
   230  	mux.Handle("GET", pattern_ResponseBodyService_GetResponseBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   231  		ctx, cancel := context.WithCancel(req.Context())
   232  		defer cancel()
   233  		var stream runtime.ServerTransportStream
   234  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   235  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   236  		var err error
   237  		var annotatedContext context.Context
   238  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/GetResponseBody", runtime.WithHTTPPathPattern("/responsebody/{data}"))
   239  		if err != nil {
   240  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   241  			return
   242  		}
   243  		resp, md, err := local_request_ResponseBodyService_GetResponseBody_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   244  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   245  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   246  		if err != nil {
   247  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   248  			return
   249  		}
   250  
   251  		forward_ResponseBodyService_GetResponseBody_0(annotatedContext, mux, outboundMarshaler, w, req, response_ResponseBodyService_GetResponseBody_0{resp}, mux.GetForwardResponseOptions()...)
   252  
   253  	})
   254  
   255  	mux.Handle("GET", pattern_ResponseBodyService_ListResponseBodies_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   256  		ctx, cancel := context.WithCancel(req.Context())
   257  		defer cancel()
   258  		var stream runtime.ServerTransportStream
   259  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   260  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   261  		var err error
   262  		var annotatedContext context.Context
   263  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/ListResponseBodies", runtime.WithHTTPPathPattern("/responsebodies/{data}"))
   264  		if err != nil {
   265  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   266  			return
   267  		}
   268  		resp, md, err := local_request_ResponseBodyService_ListResponseBodies_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   269  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   270  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   271  		if err != nil {
   272  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   273  			return
   274  		}
   275  
   276  		forward_ResponseBodyService_ListResponseBodies_0(annotatedContext, mux, outboundMarshaler, w, req, response_ResponseBodyService_ListResponseBodies_0{resp}, mux.GetForwardResponseOptions()...)
   277  
   278  	})
   279  
   280  	mux.Handle("GET", pattern_ResponseBodyService_ListResponseStrings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   281  		ctx, cancel := context.WithCancel(req.Context())
   282  		defer cancel()
   283  		var stream runtime.ServerTransportStream
   284  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   285  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   286  		var err error
   287  		var annotatedContext context.Context
   288  		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/ListResponseStrings", runtime.WithHTTPPathPattern("/responsestrings/{data}"))
   289  		if err != nil {
   290  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   291  			return
   292  		}
   293  		resp, md, err := local_request_ResponseBodyService_ListResponseStrings_0(annotatedContext, inboundMarshaler, server, req, pathParams)
   294  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   295  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   296  		if err != nil {
   297  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   298  			return
   299  		}
   300  
   301  		forward_ResponseBodyService_ListResponseStrings_0(annotatedContext, mux, outboundMarshaler, w, req, response_ResponseBodyService_ListResponseStrings_0{resp}, mux.GetForwardResponseOptions()...)
   302  
   303  	})
   304  
   305  	mux.Handle("GET", pattern_ResponseBodyService_GetResponseBodyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   306  		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
   307  		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   308  		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   309  		return
   310  	})
   311  
   312  	return nil
   313  }
   314  
   315  // RegisterResponseBodyServiceHandlerFromEndpoint is same as RegisterResponseBodyServiceHandler but
   316  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   317  func RegisterResponseBodyServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   318  	conn, err := grpc.DialContext(ctx, endpoint, opts...)
   319  	if err != nil {
   320  		return err
   321  	}
   322  	defer func() {
   323  		if err != nil {
   324  			if cerr := conn.Close(); cerr != nil {
   325  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   326  			}
   327  			return
   328  		}
   329  		go func() {
   330  			<-ctx.Done()
   331  			if cerr := conn.Close(); cerr != nil {
   332  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   333  			}
   334  		}()
   335  	}()
   336  
   337  	return RegisterResponseBodyServiceHandler(ctx, mux, conn)
   338  }
   339  
   340  // RegisterResponseBodyServiceHandler registers the http handlers for service ResponseBodyService to "mux".
   341  // The handlers forward requests to the grpc endpoint over "conn".
   342  func RegisterResponseBodyServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
   343  	return RegisterResponseBodyServiceHandlerClient(ctx, mux, NewResponseBodyServiceClient(conn))
   344  }
   345  
   346  // RegisterResponseBodyServiceHandlerClient registers the http handlers for service ResponseBodyService
   347  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ResponseBodyServiceClient".
   348  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ResponseBodyServiceClient"
   349  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
   350  // "ResponseBodyServiceClient" to call the correct interceptors.
   351  func RegisterResponseBodyServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ResponseBodyServiceClient) error {
   352  
   353  	mux.Handle("GET", pattern_ResponseBodyService_GetResponseBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   354  		ctx, cancel := context.WithCancel(req.Context())
   355  		defer cancel()
   356  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   357  		var err error
   358  		var annotatedContext context.Context
   359  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/GetResponseBody", runtime.WithHTTPPathPattern("/responsebody/{data}"))
   360  		if err != nil {
   361  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   362  			return
   363  		}
   364  		resp, md, err := request_ResponseBodyService_GetResponseBody_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   365  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   366  		if err != nil {
   367  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   368  			return
   369  		}
   370  
   371  		forward_ResponseBodyService_GetResponseBody_0(annotatedContext, mux, outboundMarshaler, w, req, response_ResponseBodyService_GetResponseBody_0{resp}, mux.GetForwardResponseOptions()...)
   372  
   373  	})
   374  
   375  	mux.Handle("GET", pattern_ResponseBodyService_ListResponseBodies_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   376  		ctx, cancel := context.WithCancel(req.Context())
   377  		defer cancel()
   378  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   379  		var err error
   380  		var annotatedContext context.Context
   381  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/ListResponseBodies", runtime.WithHTTPPathPattern("/responsebodies/{data}"))
   382  		if err != nil {
   383  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   384  			return
   385  		}
   386  		resp, md, err := request_ResponseBodyService_ListResponseBodies_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   387  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   388  		if err != nil {
   389  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   390  			return
   391  		}
   392  
   393  		forward_ResponseBodyService_ListResponseBodies_0(annotatedContext, mux, outboundMarshaler, w, req, response_ResponseBodyService_ListResponseBodies_0{resp}, mux.GetForwardResponseOptions()...)
   394  
   395  	})
   396  
   397  	mux.Handle("GET", pattern_ResponseBodyService_ListResponseStrings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   398  		ctx, cancel := context.WithCancel(req.Context())
   399  		defer cancel()
   400  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   401  		var err error
   402  		var annotatedContext context.Context
   403  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/ListResponseStrings", runtime.WithHTTPPathPattern("/responsestrings/{data}"))
   404  		if err != nil {
   405  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   406  			return
   407  		}
   408  		resp, md, err := request_ResponseBodyService_ListResponseStrings_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   409  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   410  		if err != nil {
   411  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   412  			return
   413  		}
   414  
   415  		forward_ResponseBodyService_ListResponseStrings_0(annotatedContext, mux, outboundMarshaler, w, req, response_ResponseBodyService_ListResponseStrings_0{resp}, mux.GetForwardResponseOptions()...)
   416  
   417  	})
   418  
   419  	mux.Handle("GET", pattern_ResponseBodyService_GetResponseBodyStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   420  		ctx, cancel := context.WithCancel(req.Context())
   421  		defer cancel()
   422  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   423  		var err error
   424  		var annotatedContext context.Context
   425  		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/GetResponseBodyStream", runtime.WithHTTPPathPattern("/responsebody/stream/{data}"))
   426  		if err != nil {
   427  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   428  			return
   429  		}
   430  		resp, md, err := request_ResponseBodyService_GetResponseBodyStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
   431  		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
   432  		if err != nil {
   433  			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
   434  			return
   435  		}
   436  
   437  		forward_ResponseBodyService_GetResponseBodyStream_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) {
   438  			res, err := resp.Recv()
   439  			return response_ResponseBodyService_GetResponseBodyStream_0{res}, err
   440  		}, mux.GetForwardResponseOptions()...)
   441  
   442  	})
   443  
   444  	return nil
   445  }
   446  
   447  type response_ResponseBodyService_GetResponseBody_0 struct {
   448  	proto.Message
   449  }
   450  
   451  func (m response_ResponseBodyService_GetResponseBody_0) XXX_ResponseBody() interface{} {
   452  	response := m.Message.(*ResponseBodyOut)
   453  	return response.Response
   454  }
   455  
   456  type response_ResponseBodyService_ListResponseBodies_0 struct {
   457  	proto.Message
   458  }
   459  
   460  func (m response_ResponseBodyService_ListResponseBodies_0) XXX_ResponseBody() interface{} {
   461  	response := m.Message.(*RepeatedResponseBodyOut)
   462  	return response.Response
   463  }
   464  
   465  type response_ResponseBodyService_ListResponseStrings_0 struct {
   466  	proto.Message
   467  }
   468  
   469  func (m response_ResponseBodyService_ListResponseStrings_0) XXX_ResponseBody() interface{} {
   470  	response := m.Message.(*RepeatedResponseStrings)
   471  	return response.Values
   472  }
   473  
   474  type response_ResponseBodyService_GetResponseBodyStream_0 struct {
   475  	proto.Message
   476  }
   477  
   478  func (m response_ResponseBodyService_GetResponseBodyStream_0) XXX_ResponseBody() interface{} {
   479  	response := m.Message.(*ResponseBodyOut)
   480  	return response.Response
   481  }
   482  
   483  var (
   484  	pattern_ResponseBodyService_GetResponseBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"responsebody", "data"}, ""))
   485  
   486  	pattern_ResponseBodyService_ListResponseBodies_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"responsebodies", "data"}, ""))
   487  
   488  	pattern_ResponseBodyService_ListResponseStrings_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"responsestrings", "data"}, ""))
   489  
   490  	pattern_ResponseBodyService_GetResponseBodyStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"responsebody", "stream", "data"}, ""))
   491  )
   492  
   493  var (
   494  	forward_ResponseBodyService_GetResponseBody_0 = runtime.ForwardResponseMessage
   495  
   496  	forward_ResponseBodyService_ListResponseBodies_0 = runtime.ForwardResponseMessage
   497  
   498  	forward_ResponseBodyService_ListResponseStrings_0 = runtime.ForwardResponseMessage
   499  
   500  	forward_ResponseBodyService_GetResponseBodyStream_0 = runtime.ForwardResponseStream
   501  )
   502  

View as plain text