1
16
17
18
19
20 package v1beta1
21
22 import (
23 context "context"
24 fmt "fmt"
25 _ "github.com/gogo/protobuf/gogoproto"
26 proto "github.com/gogo/protobuf/proto"
27 grpc "google.golang.org/grpc"
28 codes "google.golang.org/grpc/codes"
29 status "google.golang.org/grpc/status"
30 io "io"
31 math "math"
32 math_bits "math/bits"
33 reflect "reflect"
34 strings "strings"
35 )
36
37
38 var _ = proto.Marshal
39 var _ = fmt.Errorf
40 var _ = math.Inf
41
42
43
44
45
46 const _ = proto.GoGoProtoPackageIsVersion3
47
48 type ExampleRequest struct {
49 Request string `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
50 V1Beta1Field string `protobuf:"bytes,2,opt,name=v1beta1_field,json=v1beta1Field,proto3" json:"v1beta1_field,omitempty"`
51 XXX_NoUnkeyedLiteral struct{} `json:"-"`
52 XXX_sizecache int32 `json:"-"`
53 }
54
55 func (m *ExampleRequest) Reset() { *m = ExampleRequest{} }
56 func (*ExampleRequest) ProtoMessage() {}
57 func (*ExampleRequest) Descriptor() ([]byte, []int) {
58 return fileDescriptor_00212fb1f9d3bf1c, []int{0}
59 }
60 func (m *ExampleRequest) XXX_Unmarshal(b []byte) error {
61 return m.Unmarshal(b)
62 }
63 func (m *ExampleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
64 if deterministic {
65 return xxx_messageInfo_ExampleRequest.Marshal(b, m, deterministic)
66 } else {
67 b = b[:cap(b)]
68 n, err := m.MarshalToSizedBuffer(b)
69 if err != nil {
70 return nil, err
71 }
72 return b[:n], nil
73 }
74 }
75 func (m *ExampleRequest) XXX_Merge(src proto.Message) {
76 xxx_messageInfo_ExampleRequest.Merge(m, src)
77 }
78 func (m *ExampleRequest) XXX_Size() int {
79 return m.Size()
80 }
81 func (m *ExampleRequest) XXX_DiscardUnknown() {
82 xxx_messageInfo_ExampleRequest.DiscardUnknown(m)
83 }
84
85 var xxx_messageInfo_ExampleRequest proto.InternalMessageInfo
86
87 func (m *ExampleRequest) GetRequest() string {
88 if m != nil {
89 return m.Request
90 }
91 return ""
92 }
93
94 func (m *ExampleRequest) GetV1Beta1Field() string {
95 if m != nil {
96 return m.V1Beta1Field
97 }
98 return ""
99 }
100
101 type ExampleResponse struct {
102 Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
103 XXX_NoUnkeyedLiteral struct{} `json:"-"`
104 XXX_sizecache int32 `json:"-"`
105 }
106
107 func (m *ExampleResponse) Reset() { *m = ExampleResponse{} }
108 func (*ExampleResponse) ProtoMessage() {}
109 func (*ExampleResponse) Descriptor() ([]byte, []int) {
110 return fileDescriptor_00212fb1f9d3bf1c, []int{1}
111 }
112 func (m *ExampleResponse) XXX_Unmarshal(b []byte) error {
113 return m.Unmarshal(b)
114 }
115 func (m *ExampleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
116 if deterministic {
117 return xxx_messageInfo_ExampleResponse.Marshal(b, m, deterministic)
118 } else {
119 b = b[:cap(b)]
120 n, err := m.MarshalToSizedBuffer(b)
121 if err != nil {
122 return nil, err
123 }
124 return b[:n], nil
125 }
126 }
127 func (m *ExampleResponse) XXX_Merge(src proto.Message) {
128 xxx_messageInfo_ExampleResponse.Merge(m, src)
129 }
130 func (m *ExampleResponse) XXX_Size() int {
131 return m.Size()
132 }
133 func (m *ExampleResponse) XXX_DiscardUnknown() {
134 xxx_messageInfo_ExampleResponse.DiscardUnknown(m)
135 }
136
137 var xxx_messageInfo_ExampleResponse proto.InternalMessageInfo
138
139 func (m *ExampleResponse) GetError() string {
140 if m != nil {
141 return m.Error
142 }
143 return ""
144 }
145
146 func init() {
147 proto.RegisterType((*ExampleRequest)(nil), "v1beta1.ExampleRequest")
148 proto.RegisterType((*ExampleResponse)(nil), "v1beta1.ExampleResponse")
149 }
150
151 func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) }
152
153 var fileDescriptor_00212fb1f9d3bf1c = []byte{
154
155 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4a, 0x34, 0x31,
156 0x14, 0xc5, 0x37, 0x1f, 0x7c, 0x2e, 0x1b, 0x74, 0x85, 0x20, 0x38, 0x6c, 0x11, 0x64, 0x2c, 0xb4,
157 0x71, 0xc2, 0x6a, 0x63, 0x2d, 0xac, 0x62, 0xa5, 0x2c, 0xd8, 0xd8, 0x0c, 0x99, 0xf5, 0x4e, 0x36,
158 0xcc, 0x9f, 0xc4, 0x24, 0xa3, 0x96, 0x3e, 0x82, 0x8f, 0xb5, 0xa5, 0xa5, 0xa5, 0x3b, 0xbe, 0x88,
159 0x98, 0x44, 0x41, 0xec, 0xee, 0xef, 0x9c, 0xe4, 0x9c, 0xcb, 0xc5, 0x23, 0xae, 0x65, 0xa6, 0x8d,
160 0x72, 0x8a, 0x0c, 0x1f, 0xa6, 0x05, 0x38, 0x3e, 0x9d, 0x1c, 0x09, 0xe9, 0x96, 0x5d, 0x91, 0x2d,
161 0x54, 0xc3, 0x84, 0x12, 0x8a, 0x79, 0xbf, 0xe8, 0x4a, 0x4f, 0x1e, 0xfc, 0x14, 0xfe, 0xa5, 0x57,
162 0x78, 0x3c, 0x7b, 0xe2, 0x8d, 0xae, 0x61, 0x0e, 0xf7, 0x1d, 0x58, 0x47, 0x12, 0x3c, 0x34, 0x61,
163 0x4c, 0xd0, 0x1e, 0x3a, 0x1c, 0xcd, 0xbf, 0x91, 0xec, 0xe3, 0xad, 0xd8, 0x92, 0x97, 0x12, 0xea,
164 0xbb, 0xe4, 0x9f, 0xf7, 0x37, 0xa3, 0x78, 0xfe, 0xa5, 0xa5, 0x07, 0x78, 0xfb, 0x27, 0xd0, 0x6a,
165 0xd5, 0x5a, 0x20, 0x3b, 0xf8, 0x3f, 0x18, 0xa3, 0x4c, 0xcc, 0x0b, 0x70, 0x7c, 0x8d, 0x87, 0xf1,
166 0x21, 0x99, 0xe1, 0xf1, 0x05, 0xb8, 0x48, 0x97, 0x6d, 0xa9, 0xc8, 0x6e, 0x16, 0x43, 0xb3, 0xdf,
167 0xdb, 0x4d, 0x92, 0xbf, 0x46, 0x68, 0x49, 0x07, 0x67, 0x76, 0xb5, 0xa6, 0xe8, 0x6d, 0x4d, 0x07,
168 0xcf, 0x3d, 0x45, 0xab, 0x9e, 0xa2, 0xd7, 0x9e, 0xa2, 0xf7, 0x9e, 0xa2, 0x97, 0x0f, 0x3a, 0xb8,
169 0xbd, 0xa9, 0x4e, 0x6d, 0x26, 0x15, 0xab, 0xba, 0x02, 0x4c, 0x0b, 0x0e, 0x2c, 0xd3, 0x95, 0xf0,
170 0x58, 0x83, 0x63, 0xba, 0xee, 0x84, 0x6c, 0x1b, 0xde, 0x72, 0x01, 0x26, 0xd2, 0x23, 0x77, 0x8b,
171 0x25, 0x18, 0x06, 0xa1, 0x2a, 0x0f, 0x6a, 0xce, 0xb5, 0xb4, 0x2c, 0xae, 0x51, 0x6c, 0xf8, 0x3b,
172 0x9e, 0x7c, 0x06, 0x00, 0x00, 0xff, 0xff, 0x25, 0xab, 0xfe, 0x7d, 0x8c, 0x01, 0x00, 0x00,
173 }
174
175
176 var _ context.Context
177 var _ grpc.ClientConn
178
179
180
181 const _ = grpc.SupportPackageIsVersion4
182
183
184
185
186 type ExampleClient interface {
187 GetExampleInfo(ctx context.Context, in *ExampleRequest, opts ...grpc.CallOption) (*ExampleResponse, error)
188 }
189
190 type exampleClient struct {
191 cc *grpc.ClientConn
192 }
193
194 func NewExampleClient(cc *grpc.ClientConn) ExampleClient {
195 return &exampleClient{cc}
196 }
197
198 func (c *exampleClient) GetExampleInfo(ctx context.Context, in *ExampleRequest, opts ...grpc.CallOption) (*ExampleResponse, error) {
199 out := new(ExampleResponse)
200 err := c.cc.Invoke(ctx, "/v1beta1.Example/GetExampleInfo", in, out, opts...)
201 if err != nil {
202 return nil, err
203 }
204 return out, nil
205 }
206
207
208 type ExampleServer interface {
209 GetExampleInfo(context.Context, *ExampleRequest) (*ExampleResponse, error)
210 }
211
212
213 type UnimplementedExampleServer struct {
214 }
215
216 func (*UnimplementedExampleServer) GetExampleInfo(ctx context.Context, req *ExampleRequest) (*ExampleResponse, error) {
217 return nil, status.Errorf(codes.Unimplemented, "method GetExampleInfo not implemented")
218 }
219
220 func RegisterExampleServer(s *grpc.Server, srv ExampleServer) {
221 s.RegisterService(&_Example_serviceDesc, srv)
222 }
223
224 func _Example_GetExampleInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
225 in := new(ExampleRequest)
226 if err := dec(in); err != nil {
227 return nil, err
228 }
229 if interceptor == nil {
230 return srv.(ExampleServer).GetExampleInfo(ctx, in)
231 }
232 info := &grpc.UnaryServerInfo{
233 Server: srv,
234 FullMethod: "/v1beta1.Example/GetExampleInfo",
235 }
236 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
237 return srv.(ExampleServer).GetExampleInfo(ctx, req.(*ExampleRequest))
238 }
239 return interceptor(ctx, in, info, handler)
240 }
241
242 var _Example_serviceDesc = grpc.ServiceDesc{
243 ServiceName: "v1beta1.Example",
244 HandlerType: (*ExampleServer)(nil),
245 Methods: []grpc.MethodDesc{
246 {
247 MethodName: "GetExampleInfo",
248 Handler: _Example_GetExampleInfo_Handler,
249 },
250 },
251 Streams: []grpc.StreamDesc{},
252 Metadata: "api.proto",
253 }
254
255 func (m *ExampleRequest) Marshal() (dAtA []byte, err error) {
256 size := m.Size()
257 dAtA = make([]byte, size)
258 n, err := m.MarshalToSizedBuffer(dAtA[:size])
259 if err != nil {
260 return nil, err
261 }
262 return dAtA[:n], nil
263 }
264
265 func (m *ExampleRequest) MarshalTo(dAtA []byte) (int, error) {
266 size := m.Size()
267 return m.MarshalToSizedBuffer(dAtA[:size])
268 }
269
270 func (m *ExampleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
271 i := len(dAtA)
272 _ = i
273 var l int
274 _ = l
275 if len(m.V1Beta1Field) > 0 {
276 i -= len(m.V1Beta1Field)
277 copy(dAtA[i:], m.V1Beta1Field)
278 i = encodeVarintApi(dAtA, i, uint64(len(m.V1Beta1Field)))
279 i--
280 dAtA[i] = 0x12
281 }
282 if len(m.Request) > 0 {
283 i -= len(m.Request)
284 copy(dAtA[i:], m.Request)
285 i = encodeVarintApi(dAtA, i, uint64(len(m.Request)))
286 i--
287 dAtA[i] = 0xa
288 }
289 return len(dAtA) - i, nil
290 }
291
292 func (m *ExampleResponse) Marshal() (dAtA []byte, err error) {
293 size := m.Size()
294 dAtA = make([]byte, size)
295 n, err := m.MarshalToSizedBuffer(dAtA[:size])
296 if err != nil {
297 return nil, err
298 }
299 return dAtA[:n], nil
300 }
301
302 func (m *ExampleResponse) MarshalTo(dAtA []byte) (int, error) {
303 size := m.Size()
304 return m.MarshalToSizedBuffer(dAtA[:size])
305 }
306
307 func (m *ExampleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
308 i := len(dAtA)
309 _ = i
310 var l int
311 _ = l
312 if len(m.Error) > 0 {
313 i -= len(m.Error)
314 copy(dAtA[i:], m.Error)
315 i = encodeVarintApi(dAtA, i, uint64(len(m.Error)))
316 i--
317 dAtA[i] = 0xa
318 }
319 return len(dAtA) - i, nil
320 }
321
322 func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
323 offset -= sovApi(v)
324 base := offset
325 for v >= 1<<7 {
326 dAtA[offset] = uint8(v&0x7f | 0x80)
327 v >>= 7
328 offset++
329 }
330 dAtA[offset] = uint8(v)
331 return base
332 }
333 func (m *ExampleRequest) Size() (n int) {
334 if m == nil {
335 return 0
336 }
337 var l int
338 _ = l
339 l = len(m.Request)
340 if l > 0 {
341 n += 1 + l + sovApi(uint64(l))
342 }
343 l = len(m.V1Beta1Field)
344 if l > 0 {
345 n += 1 + l + sovApi(uint64(l))
346 }
347 return n
348 }
349
350 func (m *ExampleResponse) Size() (n int) {
351 if m == nil {
352 return 0
353 }
354 var l int
355 _ = l
356 l = len(m.Error)
357 if l > 0 {
358 n += 1 + l + sovApi(uint64(l))
359 }
360 return n
361 }
362
363 func sovApi(x uint64) (n int) {
364 return (math_bits.Len64(x|1) + 6) / 7
365 }
366 func sozApi(x uint64) (n int) {
367 return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
368 }
369 func (this *ExampleRequest) String() string {
370 if this == nil {
371 return "nil"
372 }
373 s := strings.Join([]string{`&ExampleRequest{`,
374 `Request:` + fmt.Sprintf("%v", this.Request) + `,`,
375 `V1Beta1Field:` + fmt.Sprintf("%v", this.V1Beta1Field) + `,`,
376 `}`,
377 }, "")
378 return s
379 }
380 func (this *ExampleResponse) String() string {
381 if this == nil {
382 return "nil"
383 }
384 s := strings.Join([]string{`&ExampleResponse{`,
385 `Error:` + fmt.Sprintf("%v", this.Error) + `,`,
386 `}`,
387 }, "")
388 return s
389 }
390 func valueToStringApi(v interface{}) string {
391 rv := reflect.ValueOf(v)
392 if rv.IsNil() {
393 return "nil"
394 }
395 pv := reflect.Indirect(rv).Interface()
396 return fmt.Sprintf("*%v", pv)
397 }
398 func (m *ExampleRequest) Unmarshal(dAtA []byte) error {
399 l := len(dAtA)
400 iNdEx := 0
401 for iNdEx < l {
402 preIndex := iNdEx
403 var wire uint64
404 for shift := uint(0); ; shift += 7 {
405 if shift >= 64 {
406 return ErrIntOverflowApi
407 }
408 if iNdEx >= l {
409 return io.ErrUnexpectedEOF
410 }
411 b := dAtA[iNdEx]
412 iNdEx++
413 wire |= uint64(b&0x7F) << shift
414 if b < 0x80 {
415 break
416 }
417 }
418 fieldNum := int32(wire >> 3)
419 wireType := int(wire & 0x7)
420 if wireType == 4 {
421 return fmt.Errorf("proto: ExampleRequest: wiretype end group for non-group")
422 }
423 if fieldNum <= 0 {
424 return fmt.Errorf("proto: ExampleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
425 }
426 switch fieldNum {
427 case 1:
428 if wireType != 2 {
429 return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
430 }
431 var stringLen uint64
432 for shift := uint(0); ; shift += 7 {
433 if shift >= 64 {
434 return ErrIntOverflowApi
435 }
436 if iNdEx >= l {
437 return io.ErrUnexpectedEOF
438 }
439 b := dAtA[iNdEx]
440 iNdEx++
441 stringLen |= uint64(b&0x7F) << shift
442 if b < 0x80 {
443 break
444 }
445 }
446 intStringLen := int(stringLen)
447 if intStringLen < 0 {
448 return ErrInvalidLengthApi
449 }
450 postIndex := iNdEx + intStringLen
451 if postIndex < 0 {
452 return ErrInvalidLengthApi
453 }
454 if postIndex > l {
455 return io.ErrUnexpectedEOF
456 }
457 m.Request = string(dAtA[iNdEx:postIndex])
458 iNdEx = postIndex
459 case 2:
460 if wireType != 2 {
461 return fmt.Errorf("proto: wrong wireType = %d for field V1Beta1Field", wireType)
462 }
463 var stringLen uint64
464 for shift := uint(0); ; shift += 7 {
465 if shift >= 64 {
466 return ErrIntOverflowApi
467 }
468 if iNdEx >= l {
469 return io.ErrUnexpectedEOF
470 }
471 b := dAtA[iNdEx]
472 iNdEx++
473 stringLen |= uint64(b&0x7F) << shift
474 if b < 0x80 {
475 break
476 }
477 }
478 intStringLen := int(stringLen)
479 if intStringLen < 0 {
480 return ErrInvalidLengthApi
481 }
482 postIndex := iNdEx + intStringLen
483 if postIndex < 0 {
484 return ErrInvalidLengthApi
485 }
486 if postIndex > l {
487 return io.ErrUnexpectedEOF
488 }
489 m.V1Beta1Field = string(dAtA[iNdEx:postIndex])
490 iNdEx = postIndex
491 default:
492 iNdEx = preIndex
493 skippy, err := skipApi(dAtA[iNdEx:])
494 if err != nil {
495 return err
496 }
497 if (skippy < 0) || (iNdEx+skippy) < 0 {
498 return ErrInvalidLengthApi
499 }
500 if (iNdEx + skippy) > l {
501 return io.ErrUnexpectedEOF
502 }
503 iNdEx += skippy
504 }
505 }
506
507 if iNdEx > l {
508 return io.ErrUnexpectedEOF
509 }
510 return nil
511 }
512 func (m *ExampleResponse) Unmarshal(dAtA []byte) error {
513 l := len(dAtA)
514 iNdEx := 0
515 for iNdEx < l {
516 preIndex := iNdEx
517 var wire uint64
518 for shift := uint(0); ; shift += 7 {
519 if shift >= 64 {
520 return ErrIntOverflowApi
521 }
522 if iNdEx >= l {
523 return io.ErrUnexpectedEOF
524 }
525 b := dAtA[iNdEx]
526 iNdEx++
527 wire |= uint64(b&0x7F) << shift
528 if b < 0x80 {
529 break
530 }
531 }
532 fieldNum := int32(wire >> 3)
533 wireType := int(wire & 0x7)
534 if wireType == 4 {
535 return fmt.Errorf("proto: ExampleResponse: wiretype end group for non-group")
536 }
537 if fieldNum <= 0 {
538 return fmt.Errorf("proto: ExampleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
539 }
540 switch fieldNum {
541 case 1:
542 if wireType != 2 {
543 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
544 }
545 var stringLen uint64
546 for shift := uint(0); ; shift += 7 {
547 if shift >= 64 {
548 return ErrIntOverflowApi
549 }
550 if iNdEx >= l {
551 return io.ErrUnexpectedEOF
552 }
553 b := dAtA[iNdEx]
554 iNdEx++
555 stringLen |= uint64(b&0x7F) << shift
556 if b < 0x80 {
557 break
558 }
559 }
560 intStringLen := int(stringLen)
561 if intStringLen < 0 {
562 return ErrInvalidLengthApi
563 }
564 postIndex := iNdEx + intStringLen
565 if postIndex < 0 {
566 return ErrInvalidLengthApi
567 }
568 if postIndex > l {
569 return io.ErrUnexpectedEOF
570 }
571 m.Error = string(dAtA[iNdEx:postIndex])
572 iNdEx = postIndex
573 default:
574 iNdEx = preIndex
575 skippy, err := skipApi(dAtA[iNdEx:])
576 if err != nil {
577 return err
578 }
579 if (skippy < 0) || (iNdEx+skippy) < 0 {
580 return ErrInvalidLengthApi
581 }
582 if (iNdEx + skippy) > l {
583 return io.ErrUnexpectedEOF
584 }
585 iNdEx += skippy
586 }
587 }
588
589 if iNdEx > l {
590 return io.ErrUnexpectedEOF
591 }
592 return nil
593 }
594 func skipApi(dAtA []byte) (n int, err error) {
595 l := len(dAtA)
596 iNdEx := 0
597 depth := 0
598 for iNdEx < l {
599 var wire uint64
600 for shift := uint(0); ; shift += 7 {
601 if shift >= 64 {
602 return 0, ErrIntOverflowApi
603 }
604 if iNdEx >= l {
605 return 0, io.ErrUnexpectedEOF
606 }
607 b := dAtA[iNdEx]
608 iNdEx++
609 wire |= (uint64(b) & 0x7F) << shift
610 if b < 0x80 {
611 break
612 }
613 }
614 wireType := int(wire & 0x7)
615 switch wireType {
616 case 0:
617 for shift := uint(0); ; shift += 7 {
618 if shift >= 64 {
619 return 0, ErrIntOverflowApi
620 }
621 if iNdEx >= l {
622 return 0, io.ErrUnexpectedEOF
623 }
624 iNdEx++
625 if dAtA[iNdEx-1] < 0x80 {
626 break
627 }
628 }
629 case 1:
630 iNdEx += 8
631 case 2:
632 var length int
633 for shift := uint(0); ; shift += 7 {
634 if shift >= 64 {
635 return 0, ErrIntOverflowApi
636 }
637 if iNdEx >= l {
638 return 0, io.ErrUnexpectedEOF
639 }
640 b := dAtA[iNdEx]
641 iNdEx++
642 length |= (int(b) & 0x7F) << shift
643 if b < 0x80 {
644 break
645 }
646 }
647 if length < 0 {
648 return 0, ErrInvalidLengthApi
649 }
650 iNdEx += length
651 case 3:
652 depth++
653 case 4:
654 if depth == 0 {
655 return 0, ErrUnexpectedEndOfGroupApi
656 }
657 depth--
658 case 5:
659 iNdEx += 4
660 default:
661 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
662 }
663 if iNdEx < 0 {
664 return 0, ErrInvalidLengthApi
665 }
666 if depth == 0 {
667 return iNdEx, nil
668 }
669 }
670 return 0, io.ErrUnexpectedEOF
671 }
672
673 var (
674 ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")
675 ErrIntOverflowApi = fmt.Errorf("proto: integer overflow")
676 ErrUnexpectedEndOfGroupApi = fmt.Errorf("proto: unexpected end of group")
677 )
678
View as plain text