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