1
2
3
4 package types
5
6 import (
7 bytes "bytes"
8 fmt "fmt"
9 proto "github.com/gogo/protobuf/proto"
10 io "io"
11 math "math"
12 math_bits "math/bits"
13 reflect "reflect"
14 strings "strings"
15 )
16
17
18 var _ = proto.Marshal
19 var _ = fmt.Errorf
20 var _ = math.Inf
21
22
23
24
25
26 const _ = proto.GoGoProtoPackageIsVersion3
27
28
29
30
31
32
33
34
35
36
37 type Empty struct {
38 XXX_NoUnkeyedLiteral struct{} `json:"-"`
39 XXX_unrecognized []byte `json:"-"`
40 XXX_sizecache int32 `json:"-"`
41 }
42
43 func (m *Empty) Reset() { *m = Empty{} }
44 func (*Empty) ProtoMessage() {}
45 func (*Empty) Descriptor() ([]byte, []int) {
46 return fileDescriptor_900544acb223d5b8, []int{0}
47 }
48 func (*Empty) XXX_WellKnownType() string { return "Empty" }
49 func (m *Empty) XXX_Unmarshal(b []byte) error {
50 return m.Unmarshal(b)
51 }
52 func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
53 if deterministic {
54 return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
55 } else {
56 b = b[:cap(b)]
57 n, err := m.MarshalToSizedBuffer(b)
58 if err != nil {
59 return nil, err
60 }
61 return b[:n], nil
62 }
63 }
64 func (m *Empty) XXX_Merge(src proto.Message) {
65 xxx_messageInfo_Empty.Merge(m, src)
66 }
67 func (m *Empty) XXX_Size() int {
68 return m.Size()
69 }
70 func (m *Empty) XXX_DiscardUnknown() {
71 xxx_messageInfo_Empty.DiscardUnknown(m)
72 }
73
74 var xxx_messageInfo_Empty proto.InternalMessageInfo
75
76 func (*Empty) XXX_MessageName() string {
77 return "google.protobuf.Empty"
78 }
79 func init() {
80 proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
81 }
82
83 func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8) }
84
85 var fileDescriptor_900544acb223d5b8 = []byte{
86
87 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
88 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
89 0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
90 0x90, 0xbc, 0x53, 0x0b, 0xe3, 0x8d, 0x87, 0x72, 0x0c, 0x1f, 0x1e, 0xca, 0x31, 0xfe, 0x78, 0x28,
91 0xc7, 0xd8, 0xf0, 0x48, 0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c,
92 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0xf1, 0xc5, 0x23, 0x39, 0x86, 0x0f, 0x20, 0xf1, 0xc7, 0x72,
93 0x8c, 0x27, 0x1e, 0xcb, 0x31, 0x72, 0x09, 0x27, 0xe7, 0xe7, 0xea, 0xa1, 0x19, 0xe8, 0xc4, 0x05,
94 0x36, 0x2e, 0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x62, 0x2d, 0xa9, 0x2c, 0x48, 0x2d, 0xfe, 0xc1, 0xc8,
95 0xb8, 0x88, 0x89, 0xd9, 0x3d, 0xc0, 0x69, 0x15, 0x93, 0x9c, 0x3b, 0x44, 0x7d, 0x00, 0x54, 0xbd,
96 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x65, 0x12, 0x1b, 0xd8,
97 0x20, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x21, 0xbe, 0xb6, 0x31, 0xc6, 0x00, 0x00, 0x00,
98 }
99
100 func (this *Empty) Compare(that interface{}) int {
101 if that == nil {
102 if this == nil {
103 return 0
104 }
105 return 1
106 }
107
108 that1, ok := that.(*Empty)
109 if !ok {
110 that2, ok := that.(Empty)
111 if ok {
112 that1 = &that2
113 } else {
114 return 1
115 }
116 }
117 if that1 == nil {
118 if this == nil {
119 return 0
120 }
121 return 1
122 } else if this == nil {
123 return -1
124 }
125 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
126 return c
127 }
128 return 0
129 }
130 func (this *Empty) Equal(that interface{}) bool {
131 if that == nil {
132 return this == nil
133 }
134
135 that1, ok := that.(*Empty)
136 if !ok {
137 that2, ok := that.(Empty)
138 if ok {
139 that1 = &that2
140 } else {
141 return false
142 }
143 }
144 if that1 == nil {
145 return this == nil
146 } else if this == nil {
147 return false
148 }
149 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
150 return false
151 }
152 return true
153 }
154 func (this *Empty) GoString() string {
155 if this == nil {
156 return "nil"
157 }
158 s := make([]string, 0, 4)
159 s = append(s, "&types.Empty{")
160 if this.XXX_unrecognized != nil {
161 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
162 }
163 s = append(s, "}")
164 return strings.Join(s, "")
165 }
166 func valueToGoStringEmpty(v interface{}, typ string) string {
167 rv := reflect.ValueOf(v)
168 if rv.IsNil() {
169 return "nil"
170 }
171 pv := reflect.Indirect(rv).Interface()
172 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
173 }
174 func (m *Empty) Marshal() (dAtA []byte, err error) {
175 size := m.Size()
176 dAtA = make([]byte, size)
177 n, err := m.MarshalToSizedBuffer(dAtA[:size])
178 if err != nil {
179 return nil, err
180 }
181 return dAtA[:n], nil
182 }
183
184 func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
185 size := m.Size()
186 return m.MarshalToSizedBuffer(dAtA[:size])
187 }
188
189 func (m *Empty) MarshalToSizedBuffer(dAtA []byte) (int, error) {
190 i := len(dAtA)
191 _ = i
192 var l int
193 _ = l
194 if m.XXX_unrecognized != nil {
195 i -= len(m.XXX_unrecognized)
196 copy(dAtA[i:], m.XXX_unrecognized)
197 }
198 return len(dAtA) - i, nil
199 }
200
201 func encodeVarintEmpty(dAtA []byte, offset int, v uint64) int {
202 offset -= sovEmpty(v)
203 base := offset
204 for v >= 1<<7 {
205 dAtA[offset] = uint8(v&0x7f | 0x80)
206 v >>= 7
207 offset++
208 }
209 dAtA[offset] = uint8(v)
210 return base
211 }
212 func NewPopulatedEmpty(r randyEmpty, easy bool) *Empty {
213 this := &Empty{}
214 if !easy && r.Intn(10) != 0 {
215 this.XXX_unrecognized = randUnrecognizedEmpty(r, 1)
216 }
217 return this
218 }
219
220 type randyEmpty interface {
221 Float32() float32
222 Float64() float64
223 Int63() int64
224 Int31() int32
225 Uint32() uint32
226 Intn(n int) int
227 }
228
229 func randUTF8RuneEmpty(r randyEmpty) rune {
230 ru := r.Intn(62)
231 if ru < 10 {
232 return rune(ru + 48)
233 } else if ru < 36 {
234 return rune(ru + 55)
235 }
236 return rune(ru + 61)
237 }
238 func randStringEmpty(r randyEmpty) string {
239 v1 := r.Intn(100)
240 tmps := make([]rune, v1)
241 for i := 0; i < v1; i++ {
242 tmps[i] = randUTF8RuneEmpty(r)
243 }
244 return string(tmps)
245 }
246 func randUnrecognizedEmpty(r randyEmpty, maxFieldNumber int) (dAtA []byte) {
247 l := r.Intn(5)
248 for i := 0; i < l; i++ {
249 wire := r.Intn(4)
250 if wire == 3 {
251 wire = 5
252 }
253 fieldNumber := maxFieldNumber + r.Intn(100)
254 dAtA = randFieldEmpty(dAtA, r, fieldNumber, wire)
255 }
256 return dAtA
257 }
258 func randFieldEmpty(dAtA []byte, r randyEmpty, fieldNumber int, wire int) []byte {
259 key := uint32(fieldNumber)<<3 | uint32(wire)
260 switch wire {
261 case 0:
262 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
263 v2 := r.Int63()
264 if r.Intn(2) == 0 {
265 v2 *= -1
266 }
267 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(v2))
268 case 1:
269 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
270 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
271 case 2:
272 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
273 ll := r.Intn(100)
274 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(ll))
275 for j := 0; j < ll; j++ {
276 dAtA = append(dAtA, byte(r.Intn(256)))
277 }
278 default:
279 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key))
280 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
281 }
282 return dAtA
283 }
284 func encodeVarintPopulateEmpty(dAtA []byte, v uint64) []byte {
285 for v >= 1<<7 {
286 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
287 v >>= 7
288 }
289 dAtA = append(dAtA, uint8(v))
290 return dAtA
291 }
292 func (m *Empty) Size() (n int) {
293 if m == nil {
294 return 0
295 }
296 var l int
297 _ = l
298 if m.XXX_unrecognized != nil {
299 n += len(m.XXX_unrecognized)
300 }
301 return n
302 }
303
304 func sovEmpty(x uint64) (n int) {
305 return (math_bits.Len64(x|1) + 6) / 7
306 }
307 func sozEmpty(x uint64) (n int) {
308 return sovEmpty(uint64((x << 1) ^ uint64((int64(x) >> 63))))
309 }
310 func (this *Empty) String() string {
311 if this == nil {
312 return "nil"
313 }
314 s := strings.Join([]string{`&Empty{`,
315 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
316 `}`,
317 }, "")
318 return s
319 }
320 func valueToStringEmpty(v interface{}) string {
321 rv := reflect.ValueOf(v)
322 if rv.IsNil() {
323 return "nil"
324 }
325 pv := reflect.Indirect(rv).Interface()
326 return fmt.Sprintf("*%v", pv)
327 }
328 func (m *Empty) Unmarshal(dAtA []byte) error {
329 l := len(dAtA)
330 iNdEx := 0
331 for iNdEx < l {
332 preIndex := iNdEx
333 var wire uint64
334 for shift := uint(0); ; shift += 7 {
335 if shift >= 64 {
336 return ErrIntOverflowEmpty
337 }
338 if iNdEx >= l {
339 return io.ErrUnexpectedEOF
340 }
341 b := dAtA[iNdEx]
342 iNdEx++
343 wire |= uint64(b&0x7F) << shift
344 if b < 0x80 {
345 break
346 }
347 }
348 fieldNum := int32(wire >> 3)
349 wireType := int(wire & 0x7)
350 if wireType == 4 {
351 return fmt.Errorf("proto: Empty: wiretype end group for non-group")
352 }
353 if fieldNum <= 0 {
354 return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
355 }
356 switch fieldNum {
357 default:
358 iNdEx = preIndex
359 skippy, err := skipEmpty(dAtA[iNdEx:])
360 if err != nil {
361 return err
362 }
363 if (skippy < 0) || (iNdEx+skippy) < 0 {
364 return ErrInvalidLengthEmpty
365 }
366 if (iNdEx + skippy) > l {
367 return io.ErrUnexpectedEOF
368 }
369 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
370 iNdEx += skippy
371 }
372 }
373
374 if iNdEx > l {
375 return io.ErrUnexpectedEOF
376 }
377 return nil
378 }
379 func skipEmpty(dAtA []byte) (n int, err error) {
380 l := len(dAtA)
381 iNdEx := 0
382 depth := 0
383 for iNdEx < l {
384 var wire uint64
385 for shift := uint(0); ; shift += 7 {
386 if shift >= 64 {
387 return 0, ErrIntOverflowEmpty
388 }
389 if iNdEx >= l {
390 return 0, io.ErrUnexpectedEOF
391 }
392 b := dAtA[iNdEx]
393 iNdEx++
394 wire |= (uint64(b) & 0x7F) << shift
395 if b < 0x80 {
396 break
397 }
398 }
399 wireType := int(wire & 0x7)
400 switch wireType {
401 case 0:
402 for shift := uint(0); ; shift += 7 {
403 if shift >= 64 {
404 return 0, ErrIntOverflowEmpty
405 }
406 if iNdEx >= l {
407 return 0, io.ErrUnexpectedEOF
408 }
409 iNdEx++
410 if dAtA[iNdEx-1] < 0x80 {
411 break
412 }
413 }
414 case 1:
415 iNdEx += 8
416 case 2:
417 var length int
418 for shift := uint(0); ; shift += 7 {
419 if shift >= 64 {
420 return 0, ErrIntOverflowEmpty
421 }
422 if iNdEx >= l {
423 return 0, io.ErrUnexpectedEOF
424 }
425 b := dAtA[iNdEx]
426 iNdEx++
427 length |= (int(b) & 0x7F) << shift
428 if b < 0x80 {
429 break
430 }
431 }
432 if length < 0 {
433 return 0, ErrInvalidLengthEmpty
434 }
435 iNdEx += length
436 case 3:
437 depth++
438 case 4:
439 if depth == 0 {
440 return 0, ErrUnexpectedEndOfGroupEmpty
441 }
442 depth--
443 case 5:
444 iNdEx += 4
445 default:
446 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
447 }
448 if iNdEx < 0 {
449 return 0, ErrInvalidLengthEmpty
450 }
451 if depth == 0 {
452 return iNdEx, nil
453 }
454 }
455 return 0, io.ErrUnexpectedEOF
456 }
457
458 var (
459 ErrInvalidLengthEmpty = fmt.Errorf("proto: negative length found during unmarshaling")
460 ErrIntOverflowEmpty = fmt.Errorf("proto: integer overflow")
461 ErrUnexpectedEndOfGroupEmpty = fmt.Errorf("proto: unexpected end of group")
462 )
463
View as plain text