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	math_bits "math/bits"
13	reflect "reflect"
14	strings "strings"
15)
16
17// Reference imports to suppress errors if they are not otherwise used.
18var _ = proto.Marshal
19var _ = fmt.Errorf
20var _ = math.Inf
21
22// This is a compile-time assertion to ensure that this generated file
23// is compatible with the proto package it is being compiled against.
24// A compilation error at this line likely means your copy of the
25// proto package needs to be updated.
26const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
27
28// A generic empty message that you can re-use to avoid defining duplicated
29// empty messages in your APIs. A typical example is to use it as the request
30// or the response type of an API method. For instance:
31//
32//     service Foo {
33//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
34//     }
35//
36// The JSON representation for `Empty` is empty JSON object `{}`.
37type Empty struct {
38	XXX_NoUnkeyedLiteral struct{} `json:"-"`
39	XXX_unrecognized     []byte   `json:"-"`
40	XXX_sizecache        int32    `json:"-"`
41}
42
43func (m *Empty) Reset()      { *m = Empty{} }
44func (*Empty) ProtoMessage() {}
45func (*Empty) Descriptor() ([]byte, []int) {
46	return fileDescriptor_900544acb223d5b8, []int{0}
47}
48func (*Empty) XXX_WellKnownType() string { return "Empty" }
49func (m *Empty) XXX_Unmarshal(b []byte) error {
50	return m.Unmarshal(b)
51}
52func (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}
64func (m *Empty) XXX_Merge(src proto.Message) {
65	xxx_messageInfo_Empty.Merge(m, src)
66}
67func (m *Empty) XXX_Size() int {
68	return m.Size()
69}
70func (m *Empty) XXX_DiscardUnknown() {
71	xxx_messageInfo_Empty.DiscardUnknown(m)
72}
73
74var xxx_messageInfo_Empty proto.InternalMessageInfo
75
76func (*Empty) XXX_MessageName() string {
77	return "google.protobuf.Empty"
78}
79func init() {
80	proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
81}
82
83func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8) }
84
85var fileDescriptor_900544acb223d5b8 = []byte{
86	// 176 bytes of a gzipped FileDescriptorProto
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
100func (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}
130func (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}
154func (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}
166func 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}
174func (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
184func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
185	size := m.Size()
186	return m.MarshalToSizedBuffer(dAtA[:size])
187}
188
189func (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
201func 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}
212func 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
220type randyEmpty interface {
221	Float32() float32
222	Float64() float64
223	Int63() int64
224	Int31() int32
225	Uint32() uint32
226	Intn(n int) int
227}
228
229func 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}
238func 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}
246func 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}
258func 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}
284func 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}
292func (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
304func sovEmpty(x uint64) (n int) {
305	return (math_bits.Len64(x|1) + 6) / 7
306}
307func sozEmpty(x uint64) (n int) {
308	return sovEmpty(uint64((x << 1) ^ uint64((int64(x) >> 63))))
309}
310func (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}
320func 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}
328func (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}
379func 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
458var (
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