1// Code generated by protoc-gen-gogo. DO NOT EDIT.
2// source: github.com/containerd/containerd/api/events/namespace.proto
3
4package events
5
6import (
7	fmt "fmt"
8	proto "github.com/gogo/protobuf/proto"
9	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
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
27type NamespaceCreate struct {
28	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
29	Labels               map[string]string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
30	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
31	XXX_unrecognized     []byte            `json:"-"`
32	XXX_sizecache        int32             `json:"-"`
33}
34
35func (m *NamespaceCreate) Reset()      { *m = NamespaceCreate{} }
36func (*NamespaceCreate) ProtoMessage() {}
37func (*NamespaceCreate) Descriptor() ([]byte, []int) {
38	return fileDescriptor_6cd45d1d5adffe29, []int{0}
39}
40func (m *NamespaceCreate) XXX_Unmarshal(b []byte) error {
41	return m.Unmarshal(b)
42}
43func (m *NamespaceCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
44	if deterministic {
45		return xxx_messageInfo_NamespaceCreate.Marshal(b, m, deterministic)
46	} else {
47		b = b[:cap(b)]
48		n, err := m.MarshalTo(b)
49		if err != nil {
50			return nil, err
51		}
52		return b[:n], nil
53	}
54}
55func (m *NamespaceCreate) XXX_Merge(src proto.Message) {
56	xxx_messageInfo_NamespaceCreate.Merge(m, src)
57}
58func (m *NamespaceCreate) XXX_Size() int {
59	return m.Size()
60}
61func (m *NamespaceCreate) XXX_DiscardUnknown() {
62	xxx_messageInfo_NamespaceCreate.DiscardUnknown(m)
63}
64
65var xxx_messageInfo_NamespaceCreate proto.InternalMessageInfo
66
67type NamespaceUpdate struct {
68	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
69	Labels               map[string]string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
70	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
71	XXX_unrecognized     []byte            `json:"-"`
72	XXX_sizecache        int32             `json:"-"`
73}
74
75func (m *NamespaceUpdate) Reset()      { *m = NamespaceUpdate{} }
76func (*NamespaceUpdate) ProtoMessage() {}
77func (*NamespaceUpdate) Descriptor() ([]byte, []int) {
78	return fileDescriptor_6cd45d1d5adffe29, []int{1}
79}
80func (m *NamespaceUpdate) XXX_Unmarshal(b []byte) error {
81	return m.Unmarshal(b)
82}
83func (m *NamespaceUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
84	if deterministic {
85		return xxx_messageInfo_NamespaceUpdate.Marshal(b, m, deterministic)
86	} else {
87		b = b[:cap(b)]
88		n, err := m.MarshalTo(b)
89		if err != nil {
90			return nil, err
91		}
92		return b[:n], nil
93	}
94}
95func (m *NamespaceUpdate) XXX_Merge(src proto.Message) {
96	xxx_messageInfo_NamespaceUpdate.Merge(m, src)
97}
98func (m *NamespaceUpdate) XXX_Size() int {
99	return m.Size()
100}
101func (m *NamespaceUpdate) XXX_DiscardUnknown() {
102	xxx_messageInfo_NamespaceUpdate.DiscardUnknown(m)
103}
104
105var xxx_messageInfo_NamespaceUpdate proto.InternalMessageInfo
106
107type NamespaceDelete struct {
108	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
109	XXX_NoUnkeyedLiteral struct{} `json:"-"`
110	XXX_unrecognized     []byte   `json:"-"`
111	XXX_sizecache        int32    `json:"-"`
112}
113
114func (m *NamespaceDelete) Reset()      { *m = NamespaceDelete{} }
115func (*NamespaceDelete) ProtoMessage() {}
116func (*NamespaceDelete) Descriptor() ([]byte, []int) {
117	return fileDescriptor_6cd45d1d5adffe29, []int{2}
118}
119func (m *NamespaceDelete) XXX_Unmarshal(b []byte) error {
120	return m.Unmarshal(b)
121}
122func (m *NamespaceDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
123	if deterministic {
124		return xxx_messageInfo_NamespaceDelete.Marshal(b, m, deterministic)
125	} else {
126		b = b[:cap(b)]
127		n, err := m.MarshalTo(b)
128		if err != nil {
129			return nil, err
130		}
131		return b[:n], nil
132	}
133}
134func (m *NamespaceDelete) XXX_Merge(src proto.Message) {
135	xxx_messageInfo_NamespaceDelete.Merge(m, src)
136}
137func (m *NamespaceDelete) XXX_Size() int {
138	return m.Size()
139}
140func (m *NamespaceDelete) XXX_DiscardUnknown() {
141	xxx_messageInfo_NamespaceDelete.DiscardUnknown(m)
142}
143
144var xxx_messageInfo_NamespaceDelete proto.InternalMessageInfo
145
146func init() {
147	proto.RegisterType((*NamespaceCreate)(nil), "containerd.events.NamespaceCreate")
148	proto.RegisterMapType((map[string]string)(nil), "containerd.events.NamespaceCreate.LabelsEntry")
149	proto.RegisterType((*NamespaceUpdate)(nil), "containerd.events.NamespaceUpdate")
150	proto.RegisterMapType((map[string]string)(nil), "containerd.events.NamespaceUpdate.LabelsEntry")
151	proto.RegisterType((*NamespaceDelete)(nil), "containerd.events.NamespaceDelete")
152}
153
154func init() {
155	proto.RegisterFile("github.com/containerd/containerd/api/events/namespace.proto", fileDescriptor_6cd45d1d5adffe29)
156}
157
158var fileDescriptor_6cd45d1d5adffe29 = []byte{
159	// 296 bytes of a gzipped FileDescriptorProto
160	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9,
161	0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d,
162	0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0xa7, 0x96, 0xa5, 0xe6, 0x95, 0x14, 0xeb, 0xe7, 0x25,
163	0xe6, 0xa6, 0x16, 0x17, 0x24, 0x26, 0xa7, 0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x22,
164	0x94, 0xe9, 0x41, 0x94, 0x48, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x65, 0xf5, 0x41, 0x2c, 0x88,
165	0x42, 0x29, 0x07, 0x82, 0xb6, 0x80, 0xd5, 0x25, 0x95, 0xa6, 0xe9, 0x17, 0xe4, 0x94, 0xa6, 0x67,
166	0xe6, 0xe9, 0xa7, 0x65, 0xa6, 0xe6, 0xa4, 0x14, 0x24, 0x96, 0x64, 0x40, 0x4c, 0x50, 0x5a, 0xc1,
167	0xc8, 0xc5, 0xef, 0x07, 0xb3, 0xde, 0xb9, 0x28, 0x35, 0xb1, 0x24, 0x55, 0x48, 0x88, 0x8b, 0x05,
168	0xe4, 0x22, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x30, 0x5b, 0xc8, 0x8d, 0x8b, 0x2d, 0x27,
169	0x31, 0x29, 0x35, 0xa7, 0x58, 0x82, 0x49, 0x81, 0x59, 0x83, 0xdb, 0x48, 0x4f, 0x0f, 0xc3, 0x8d,
170	0x7a, 0x68, 0xe6, 0xe8, 0xf9, 0x80, 0x35, 0xb8, 0xe6, 0x95, 0x14, 0x55, 0x06, 0x41, 0x75, 0x4b,
171	0x59, 0x72, 0x71, 0x23, 0x09, 0x0b, 0x09, 0x70, 0x31, 0x67, 0xa7, 0x56, 0x42, 0x6d, 0x02, 0x31,
172	0x85, 0x44, 0xb8, 0x58, 0xcb, 0x12, 0x73, 0x4a, 0x53, 0x25, 0x98, 0xc0, 0x62, 0x10, 0x8e, 0x15,
173	0x93, 0x05, 0x23, 0xaa, 0x53, 0x43, 0x0b, 0x52, 0xa8, 0xe2, 0x54, 0x88, 0x39, 0xd4, 0x76, 0xaa,
174	0x2a, 0x92, 0x4b, 0x5d, 0x52, 0x73, 0x52, 0xb1, 0xbb, 0xd4, 0x29, 0xe0, 0xc4, 0x43, 0x39, 0x86,
175	0x1b, 0x0f, 0xe5, 0x18, 0x1a, 0x1e, 0xc9, 0x31, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c,
176	0xe3, 0x83, 0x47, 0x72, 0x8c, 0x0b, 0xbe, 0xc8, 0x31, 0x46, 0x19, 0x91, 0x90, 0x84, 0xac, 0x21,
177	0x54, 0x04, 0x43, 0x04, 0x63, 0x12, 0x1b, 0x38, 0x66, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff,
178	0x00, 0x50, 0x87, 0x59, 0x83, 0x02, 0x00, 0x00,
179}
180
181// Field returns the value for the given fieldpath as a string, if defined.
182// If the value is not defined, the second value will be false.
183func (m *NamespaceCreate) Field(fieldpath []string) (string, bool) {
184	if len(fieldpath) == 0 {
185		return "", false
186	}
187
188	switch fieldpath[0] {
189	case "name":
190		return string(m.Name), len(m.Name) > 0
191	case "labels":
192		// Labels fields have been special-cased by name. If this breaks,
193		// add better special casing to fieldpath plugin.
194		if len(m.Labels) == 0 {
195			return "", false
196		}
197		value, ok := m.Labels[strings.Join(fieldpath[1:], ".")]
198		return value, ok
199	}
200	return "", false
201}
202
203// Field returns the value for the given fieldpath as a string, if defined.
204// If the value is not defined, the second value will be false.
205func (m *NamespaceUpdate) Field(fieldpath []string) (string, bool) {
206	if len(fieldpath) == 0 {
207		return "", false
208	}
209
210	switch fieldpath[0] {
211	case "name":
212		return string(m.Name), len(m.Name) > 0
213	case "labels":
214		// Labels fields have been special-cased by name. If this breaks,
215		// add better special casing to fieldpath plugin.
216		if len(m.Labels) == 0 {
217			return "", false
218		}
219		value, ok := m.Labels[strings.Join(fieldpath[1:], ".")]
220		return value, ok
221	}
222	return "", false
223}
224
225// Field returns the value for the given fieldpath as a string, if defined.
226// If the value is not defined, the second value will be false.
227func (m *NamespaceDelete) Field(fieldpath []string) (string, bool) {
228	if len(fieldpath) == 0 {
229		return "", false
230	}
231
232	switch fieldpath[0] {
233	case "name":
234		return string(m.Name), len(m.Name) > 0
235	}
236	return "", false
237}
238func (m *NamespaceCreate) Marshal() (dAtA []byte, err error) {
239	size := m.Size()
240	dAtA = make([]byte, size)
241	n, err := m.MarshalTo(dAtA)
242	if err != nil {
243		return nil, err
244	}
245	return dAtA[:n], nil
246}
247
248func (m *NamespaceCreate) MarshalTo(dAtA []byte) (int, error) {
249	var i int
250	_ = i
251	var l int
252	_ = l
253	if len(m.Name) > 0 {
254		dAtA[i] = 0xa
255		i++
256		i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name)))
257		i += copy(dAtA[i:], m.Name)
258	}
259	if len(m.Labels) > 0 {
260		for k, _ := range m.Labels {
261			dAtA[i] = 0x12
262			i++
263			v := m.Labels[k]
264			mapSize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v)))
265			i = encodeVarintNamespace(dAtA, i, uint64(mapSize))
266			dAtA[i] = 0xa
267			i++
268			i = encodeVarintNamespace(dAtA, i, uint64(len(k)))
269			i += copy(dAtA[i:], k)
270			dAtA[i] = 0x12
271			i++
272			i = encodeVarintNamespace(dAtA, i, uint64(len(v)))
273			i += copy(dAtA[i:], v)
274		}
275	}
276	if m.XXX_unrecognized != nil {
277		i += copy(dAtA[i:], m.XXX_unrecognized)
278	}
279	return i, nil
280}
281
282func (m *NamespaceUpdate) Marshal() (dAtA []byte, err error) {
283	size := m.Size()
284	dAtA = make([]byte, size)
285	n, err := m.MarshalTo(dAtA)
286	if err != nil {
287		return nil, err
288	}
289	return dAtA[:n], nil
290}
291
292func (m *NamespaceUpdate) MarshalTo(dAtA []byte) (int, error) {
293	var i int
294	_ = i
295	var l int
296	_ = l
297	if len(m.Name) > 0 {
298		dAtA[i] = 0xa
299		i++
300		i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name)))
301		i += copy(dAtA[i:], m.Name)
302	}
303	if len(m.Labels) > 0 {
304		for k, _ := range m.Labels {
305			dAtA[i] = 0x12
306			i++
307			v := m.Labels[k]
308			mapSize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v)))
309			i = encodeVarintNamespace(dAtA, i, uint64(mapSize))
310			dAtA[i] = 0xa
311			i++
312			i = encodeVarintNamespace(dAtA, i, uint64(len(k)))
313			i += copy(dAtA[i:], k)
314			dAtA[i] = 0x12
315			i++
316			i = encodeVarintNamespace(dAtA, i, uint64(len(v)))
317			i += copy(dAtA[i:], v)
318		}
319	}
320	if m.XXX_unrecognized != nil {
321		i += copy(dAtA[i:], m.XXX_unrecognized)
322	}
323	return i, nil
324}
325
326func (m *NamespaceDelete) Marshal() (dAtA []byte, err error) {
327	size := m.Size()
328	dAtA = make([]byte, size)
329	n, err := m.MarshalTo(dAtA)
330	if err != nil {
331		return nil, err
332	}
333	return dAtA[:n], nil
334}
335
336func (m *NamespaceDelete) MarshalTo(dAtA []byte) (int, error) {
337	var i int
338	_ = i
339	var l int
340	_ = l
341	if len(m.Name) > 0 {
342		dAtA[i] = 0xa
343		i++
344		i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name)))
345		i += copy(dAtA[i:], m.Name)
346	}
347	if m.XXX_unrecognized != nil {
348		i += copy(dAtA[i:], m.XXX_unrecognized)
349	}
350	return i, nil
351}
352
353func encodeVarintNamespace(dAtA []byte, offset int, v uint64) int {
354	for v >= 1<<7 {
355		dAtA[offset] = uint8(v&0x7f | 0x80)
356		v >>= 7
357		offset++
358	}
359	dAtA[offset] = uint8(v)
360	return offset + 1
361}
362func (m *NamespaceCreate) Size() (n int) {
363	if m == nil {
364		return 0
365	}
366	var l int
367	_ = l
368	l = len(m.Name)
369	if l > 0 {
370		n += 1 + l + sovNamespace(uint64(l))
371	}
372	if len(m.Labels) > 0 {
373		for k, v := range m.Labels {
374			_ = k
375			_ = v
376			mapEntrySize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v)))
377			n += mapEntrySize + 1 + sovNamespace(uint64(mapEntrySize))
378		}
379	}
380	if m.XXX_unrecognized != nil {
381		n += len(m.XXX_unrecognized)
382	}
383	return n
384}
385
386func (m *NamespaceUpdate) Size() (n int) {
387	if m == nil {
388		return 0
389	}
390	var l int
391	_ = l
392	l = len(m.Name)
393	if l > 0 {
394		n += 1 + l + sovNamespace(uint64(l))
395	}
396	if len(m.Labels) > 0 {
397		for k, v := range m.Labels {
398			_ = k
399			_ = v
400			mapEntrySize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v)))
401			n += mapEntrySize + 1 + sovNamespace(uint64(mapEntrySize))
402		}
403	}
404	if m.XXX_unrecognized != nil {
405		n += len(m.XXX_unrecognized)
406	}
407	return n
408}
409
410func (m *NamespaceDelete) Size() (n int) {
411	if m == nil {
412		return 0
413	}
414	var l int
415	_ = l
416	l = len(m.Name)
417	if l > 0 {
418		n += 1 + l + sovNamespace(uint64(l))
419	}
420	if m.XXX_unrecognized != nil {
421		n += len(m.XXX_unrecognized)
422	}
423	return n
424}
425
426func sovNamespace(x uint64) (n int) {
427	for {
428		n++
429		x >>= 7
430		if x == 0 {
431			break
432		}
433	}
434	return n
435}
436func sozNamespace(x uint64) (n int) {
437	return sovNamespace(uint64((x << 1) ^ uint64((int64(x) >> 63))))
438}
439func (this *NamespaceCreate) String() string {
440	if this == nil {
441		return "nil"
442	}
443	keysForLabels := make([]string, 0, len(this.Labels))
444	for k, _ := range this.Labels {
445		keysForLabels = append(keysForLabels, k)
446	}
447	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
448	mapStringForLabels := "map[string]string{"
449	for _, k := range keysForLabels {
450		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
451	}
452	mapStringForLabels += "}"
453	s := strings.Join([]string{`&NamespaceCreate{`,
454		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
455		`Labels:` + mapStringForLabels + `,`,
456		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
457		`}`,
458	}, "")
459	return s
460}
461func (this *NamespaceUpdate) String() string {
462	if this == nil {
463		return "nil"
464	}
465	keysForLabels := make([]string, 0, len(this.Labels))
466	for k, _ := range this.Labels {
467		keysForLabels = append(keysForLabels, k)
468	}
469	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
470	mapStringForLabels := "map[string]string{"
471	for _, k := range keysForLabels {
472		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
473	}
474	mapStringForLabels += "}"
475	s := strings.Join([]string{`&NamespaceUpdate{`,
476		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
477		`Labels:` + mapStringForLabels + `,`,
478		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
479		`}`,
480	}, "")
481	return s
482}
483func (this *NamespaceDelete) String() string {
484	if this == nil {
485		return "nil"
486	}
487	s := strings.Join([]string{`&NamespaceDelete{`,
488		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
489		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
490		`}`,
491	}, "")
492	return s
493}
494func valueToStringNamespace(v interface{}) string {
495	rv := reflect.ValueOf(v)
496	if rv.IsNil() {
497		return "nil"
498	}
499	pv := reflect.Indirect(rv).Interface()
500	return fmt.Sprintf("*%v", pv)
501}
502func (m *NamespaceCreate) Unmarshal(dAtA []byte) error {
503	l := len(dAtA)
504	iNdEx := 0
505	for iNdEx < l {
506		preIndex := iNdEx
507		var wire uint64
508		for shift := uint(0); ; shift += 7 {
509			if shift >= 64 {
510				return ErrIntOverflowNamespace
511			}
512			if iNdEx >= l {
513				return io.ErrUnexpectedEOF
514			}
515			b := dAtA[iNdEx]
516			iNdEx++
517			wire |= uint64(b&0x7F) << shift
518			if b < 0x80 {
519				break
520			}
521		}
522		fieldNum := int32(wire >> 3)
523		wireType := int(wire & 0x7)
524		if wireType == 4 {
525			return fmt.Errorf("proto: NamespaceCreate: wiretype end group for non-group")
526		}
527		if fieldNum <= 0 {
528			return fmt.Errorf("proto: NamespaceCreate: illegal tag %d (wire type %d)", fieldNum, wire)
529		}
530		switch fieldNum {
531		case 1:
532			if wireType != 2 {
533				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
534			}
535			var stringLen uint64
536			for shift := uint(0); ; shift += 7 {
537				if shift >= 64 {
538					return ErrIntOverflowNamespace
539				}
540				if iNdEx >= l {
541					return io.ErrUnexpectedEOF
542				}
543				b := dAtA[iNdEx]
544				iNdEx++
545				stringLen |= uint64(b&0x7F) << shift
546				if b < 0x80 {
547					break
548				}
549			}
550			intStringLen := int(stringLen)
551			if intStringLen < 0 {
552				return ErrInvalidLengthNamespace
553			}
554			postIndex := iNdEx + intStringLen
555			if postIndex < 0 {
556				return ErrInvalidLengthNamespace
557			}
558			if postIndex > l {
559				return io.ErrUnexpectedEOF
560			}
561			m.Name = string(dAtA[iNdEx:postIndex])
562			iNdEx = postIndex
563		case 2:
564			if wireType != 2 {
565				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
566			}
567			var msglen int
568			for shift := uint(0); ; shift += 7 {
569				if shift >= 64 {
570					return ErrIntOverflowNamespace
571				}
572				if iNdEx >= l {
573					return io.ErrUnexpectedEOF
574				}
575				b := dAtA[iNdEx]
576				iNdEx++
577				msglen |= int(b&0x7F) << shift
578				if b < 0x80 {
579					break
580				}
581			}
582			if msglen < 0 {
583				return ErrInvalidLengthNamespace
584			}
585			postIndex := iNdEx + msglen
586			if postIndex < 0 {
587				return ErrInvalidLengthNamespace
588			}
589			if postIndex > l {
590				return io.ErrUnexpectedEOF
591			}
592			if m.Labels == nil {
593				m.Labels = make(map[string]string)
594			}
595			var mapkey string
596			var mapvalue string
597			for iNdEx < postIndex {
598				entryPreIndex := iNdEx
599				var wire uint64
600				for shift := uint(0); ; shift += 7 {
601					if shift >= 64 {
602						return ErrIntOverflowNamespace
603					}
604					if iNdEx >= l {
605						return io.ErrUnexpectedEOF
606					}
607					b := dAtA[iNdEx]
608					iNdEx++
609					wire |= uint64(b&0x7F) << shift
610					if b < 0x80 {
611						break
612					}
613				}
614				fieldNum := int32(wire >> 3)
615				if fieldNum == 1 {
616					var stringLenmapkey uint64
617					for shift := uint(0); ; shift += 7 {
618						if shift >= 64 {
619							return ErrIntOverflowNamespace
620						}
621						if iNdEx >= l {
622							return io.ErrUnexpectedEOF
623						}
624						b := dAtA[iNdEx]
625						iNdEx++
626						stringLenmapkey |= uint64(b&0x7F) << shift
627						if b < 0x80 {
628							break
629						}
630					}
631					intStringLenmapkey := int(stringLenmapkey)
632					if intStringLenmapkey < 0 {
633						return ErrInvalidLengthNamespace
634					}
635					postStringIndexmapkey := iNdEx + intStringLenmapkey
636					if postStringIndexmapkey < 0 {
637						return ErrInvalidLengthNamespace
638					}
639					if postStringIndexmapkey > l {
640						return io.ErrUnexpectedEOF
641					}
642					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
643					iNdEx = postStringIndexmapkey
644				} else if fieldNum == 2 {
645					var stringLenmapvalue uint64
646					for shift := uint(0); ; shift += 7 {
647						if shift >= 64 {
648							return ErrIntOverflowNamespace
649						}
650						if iNdEx >= l {
651							return io.ErrUnexpectedEOF
652						}
653						b := dAtA[iNdEx]
654						iNdEx++
655						stringLenmapvalue |= uint64(b&0x7F) << shift
656						if b < 0x80 {
657							break
658						}
659					}
660					intStringLenmapvalue := int(stringLenmapvalue)
661					if intStringLenmapvalue < 0 {
662						return ErrInvalidLengthNamespace
663					}
664					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
665					if postStringIndexmapvalue < 0 {
666						return ErrInvalidLengthNamespace
667					}
668					if postStringIndexmapvalue > l {
669						return io.ErrUnexpectedEOF
670					}
671					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
672					iNdEx = postStringIndexmapvalue
673				} else {
674					iNdEx = entryPreIndex
675					skippy, err := skipNamespace(dAtA[iNdEx:])
676					if err != nil {
677						return err
678					}
679					if skippy < 0 {
680						return ErrInvalidLengthNamespace
681					}
682					if (iNdEx + skippy) > postIndex {
683						return io.ErrUnexpectedEOF
684					}
685					iNdEx += skippy
686				}
687			}
688			m.Labels[mapkey] = mapvalue
689			iNdEx = postIndex
690		default:
691			iNdEx = preIndex
692			skippy, err := skipNamespace(dAtA[iNdEx:])
693			if err != nil {
694				return err
695			}
696			if skippy < 0 {
697				return ErrInvalidLengthNamespace
698			}
699			if (iNdEx + skippy) < 0 {
700				return ErrInvalidLengthNamespace
701			}
702			if (iNdEx + skippy) > l {
703				return io.ErrUnexpectedEOF
704			}
705			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
706			iNdEx += skippy
707		}
708	}
709
710	if iNdEx > l {
711		return io.ErrUnexpectedEOF
712	}
713	return nil
714}
715func (m *NamespaceUpdate) Unmarshal(dAtA []byte) error {
716	l := len(dAtA)
717	iNdEx := 0
718	for iNdEx < l {
719		preIndex := iNdEx
720		var wire uint64
721		for shift := uint(0); ; shift += 7 {
722			if shift >= 64 {
723				return ErrIntOverflowNamespace
724			}
725			if iNdEx >= l {
726				return io.ErrUnexpectedEOF
727			}
728			b := dAtA[iNdEx]
729			iNdEx++
730			wire |= uint64(b&0x7F) << shift
731			if b < 0x80 {
732				break
733			}
734		}
735		fieldNum := int32(wire >> 3)
736		wireType := int(wire & 0x7)
737		if wireType == 4 {
738			return fmt.Errorf("proto: NamespaceUpdate: wiretype end group for non-group")
739		}
740		if fieldNum <= 0 {
741			return fmt.Errorf("proto: NamespaceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
742		}
743		switch fieldNum {
744		case 1:
745			if wireType != 2 {
746				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
747			}
748			var stringLen uint64
749			for shift := uint(0); ; shift += 7 {
750				if shift >= 64 {
751					return ErrIntOverflowNamespace
752				}
753				if iNdEx >= l {
754					return io.ErrUnexpectedEOF
755				}
756				b := dAtA[iNdEx]
757				iNdEx++
758				stringLen |= uint64(b&0x7F) << shift
759				if b < 0x80 {
760					break
761				}
762			}
763			intStringLen := int(stringLen)
764			if intStringLen < 0 {
765				return ErrInvalidLengthNamespace
766			}
767			postIndex := iNdEx + intStringLen
768			if postIndex < 0 {
769				return ErrInvalidLengthNamespace
770			}
771			if postIndex > l {
772				return io.ErrUnexpectedEOF
773			}
774			m.Name = string(dAtA[iNdEx:postIndex])
775			iNdEx = postIndex
776		case 2:
777			if wireType != 2 {
778				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
779			}
780			var msglen int
781			for shift := uint(0); ; shift += 7 {
782				if shift >= 64 {
783					return ErrIntOverflowNamespace
784				}
785				if iNdEx >= l {
786					return io.ErrUnexpectedEOF
787				}
788				b := dAtA[iNdEx]
789				iNdEx++
790				msglen |= int(b&0x7F) << shift
791				if b < 0x80 {
792					break
793				}
794			}
795			if msglen < 0 {
796				return ErrInvalidLengthNamespace
797			}
798			postIndex := iNdEx + msglen
799			if postIndex < 0 {
800				return ErrInvalidLengthNamespace
801			}
802			if postIndex > l {
803				return io.ErrUnexpectedEOF
804			}
805			if m.Labels == nil {
806				m.Labels = make(map[string]string)
807			}
808			var mapkey string
809			var mapvalue string
810			for iNdEx < postIndex {
811				entryPreIndex := iNdEx
812				var wire uint64
813				for shift := uint(0); ; shift += 7 {
814					if shift >= 64 {
815						return ErrIntOverflowNamespace
816					}
817					if iNdEx >= l {
818						return io.ErrUnexpectedEOF
819					}
820					b := dAtA[iNdEx]
821					iNdEx++
822					wire |= uint64(b&0x7F) << shift
823					if b < 0x80 {
824						break
825					}
826				}
827				fieldNum := int32(wire >> 3)
828				if fieldNum == 1 {
829					var stringLenmapkey uint64
830					for shift := uint(0); ; shift += 7 {
831						if shift >= 64 {
832							return ErrIntOverflowNamespace
833						}
834						if iNdEx >= l {
835							return io.ErrUnexpectedEOF
836						}
837						b := dAtA[iNdEx]
838						iNdEx++
839						stringLenmapkey |= uint64(b&0x7F) << shift
840						if b < 0x80 {
841							break
842						}
843					}
844					intStringLenmapkey := int(stringLenmapkey)
845					if intStringLenmapkey < 0 {
846						return ErrInvalidLengthNamespace
847					}
848					postStringIndexmapkey := iNdEx + intStringLenmapkey
849					if postStringIndexmapkey < 0 {
850						return ErrInvalidLengthNamespace
851					}
852					if postStringIndexmapkey > l {
853						return io.ErrUnexpectedEOF
854					}
855					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
856					iNdEx = postStringIndexmapkey
857				} else if fieldNum == 2 {
858					var stringLenmapvalue uint64
859					for shift := uint(0); ; shift += 7 {
860						if shift >= 64 {
861							return ErrIntOverflowNamespace
862						}
863						if iNdEx >= l {
864							return io.ErrUnexpectedEOF
865						}
866						b := dAtA[iNdEx]
867						iNdEx++
868						stringLenmapvalue |= uint64(b&0x7F) << shift
869						if b < 0x80 {
870							break
871						}
872					}
873					intStringLenmapvalue := int(stringLenmapvalue)
874					if intStringLenmapvalue < 0 {
875						return ErrInvalidLengthNamespace
876					}
877					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
878					if postStringIndexmapvalue < 0 {
879						return ErrInvalidLengthNamespace
880					}
881					if postStringIndexmapvalue > l {
882						return io.ErrUnexpectedEOF
883					}
884					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
885					iNdEx = postStringIndexmapvalue
886				} else {
887					iNdEx = entryPreIndex
888					skippy, err := skipNamespace(dAtA[iNdEx:])
889					if err != nil {
890						return err
891					}
892					if skippy < 0 {
893						return ErrInvalidLengthNamespace
894					}
895					if (iNdEx + skippy) > postIndex {
896						return io.ErrUnexpectedEOF
897					}
898					iNdEx += skippy
899				}
900			}
901			m.Labels[mapkey] = mapvalue
902			iNdEx = postIndex
903		default:
904			iNdEx = preIndex
905			skippy, err := skipNamespace(dAtA[iNdEx:])
906			if err != nil {
907				return err
908			}
909			if skippy < 0 {
910				return ErrInvalidLengthNamespace
911			}
912			if (iNdEx + skippy) < 0 {
913				return ErrInvalidLengthNamespace
914			}
915			if (iNdEx + skippy) > l {
916				return io.ErrUnexpectedEOF
917			}
918			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
919			iNdEx += skippy
920		}
921	}
922
923	if iNdEx > l {
924		return io.ErrUnexpectedEOF
925	}
926	return nil
927}
928func (m *NamespaceDelete) Unmarshal(dAtA []byte) error {
929	l := len(dAtA)
930	iNdEx := 0
931	for iNdEx < l {
932		preIndex := iNdEx
933		var wire uint64
934		for shift := uint(0); ; shift += 7 {
935			if shift >= 64 {
936				return ErrIntOverflowNamespace
937			}
938			if iNdEx >= l {
939				return io.ErrUnexpectedEOF
940			}
941			b := dAtA[iNdEx]
942			iNdEx++
943			wire |= uint64(b&0x7F) << shift
944			if b < 0x80 {
945				break
946			}
947		}
948		fieldNum := int32(wire >> 3)
949		wireType := int(wire & 0x7)
950		if wireType == 4 {
951			return fmt.Errorf("proto: NamespaceDelete: wiretype end group for non-group")
952		}
953		if fieldNum <= 0 {
954			return fmt.Errorf("proto: NamespaceDelete: illegal tag %d (wire type %d)", fieldNum, wire)
955		}
956		switch fieldNum {
957		case 1:
958			if wireType != 2 {
959				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
960			}
961			var stringLen uint64
962			for shift := uint(0); ; shift += 7 {
963				if shift >= 64 {
964					return ErrIntOverflowNamespace
965				}
966				if iNdEx >= l {
967					return io.ErrUnexpectedEOF
968				}
969				b := dAtA[iNdEx]
970				iNdEx++
971				stringLen |= uint64(b&0x7F) << shift
972				if b < 0x80 {
973					break
974				}
975			}
976			intStringLen := int(stringLen)
977			if intStringLen < 0 {
978				return ErrInvalidLengthNamespace
979			}
980			postIndex := iNdEx + intStringLen
981			if postIndex < 0 {
982				return ErrInvalidLengthNamespace
983			}
984			if postIndex > l {
985				return io.ErrUnexpectedEOF
986			}
987			m.Name = string(dAtA[iNdEx:postIndex])
988			iNdEx = postIndex
989		default:
990			iNdEx = preIndex
991			skippy, err := skipNamespace(dAtA[iNdEx:])
992			if err != nil {
993				return err
994			}
995			if skippy < 0 {
996				return ErrInvalidLengthNamespace
997			}
998			if (iNdEx + skippy) < 0 {
999				return ErrInvalidLengthNamespace
1000			}
1001			if (iNdEx + skippy) > l {
1002				return io.ErrUnexpectedEOF
1003			}
1004			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1005			iNdEx += skippy
1006		}
1007	}
1008
1009	if iNdEx > l {
1010		return io.ErrUnexpectedEOF
1011	}
1012	return nil
1013}
1014func skipNamespace(dAtA []byte) (n int, err error) {
1015	l := len(dAtA)
1016	iNdEx := 0
1017	for iNdEx < l {
1018		var wire uint64
1019		for shift := uint(0); ; shift += 7 {
1020			if shift >= 64 {
1021				return 0, ErrIntOverflowNamespace
1022			}
1023			if iNdEx >= l {
1024				return 0, io.ErrUnexpectedEOF
1025			}
1026			b := dAtA[iNdEx]
1027			iNdEx++
1028			wire |= (uint64(b) & 0x7F) << shift
1029			if b < 0x80 {
1030				break
1031			}
1032		}
1033		wireType := int(wire & 0x7)
1034		switch wireType {
1035		case 0:
1036			for shift := uint(0); ; shift += 7 {
1037				if shift >= 64 {
1038					return 0, ErrIntOverflowNamespace
1039				}
1040				if iNdEx >= l {
1041					return 0, io.ErrUnexpectedEOF
1042				}
1043				iNdEx++
1044				if dAtA[iNdEx-1] < 0x80 {
1045					break
1046				}
1047			}
1048			return iNdEx, nil
1049		case 1:
1050			iNdEx += 8
1051			return iNdEx, nil
1052		case 2:
1053			var length int
1054			for shift := uint(0); ; shift += 7 {
1055				if shift >= 64 {
1056					return 0, ErrIntOverflowNamespace
1057				}
1058				if iNdEx >= l {
1059					return 0, io.ErrUnexpectedEOF
1060				}
1061				b := dAtA[iNdEx]
1062				iNdEx++
1063				length |= (int(b) & 0x7F) << shift
1064				if b < 0x80 {
1065					break
1066				}
1067			}
1068			if length < 0 {
1069				return 0, ErrInvalidLengthNamespace
1070			}
1071			iNdEx += length
1072			if iNdEx < 0 {
1073				return 0, ErrInvalidLengthNamespace
1074			}
1075			return iNdEx, nil
1076		case 3:
1077			for {
1078				var innerWire uint64
1079				var start int = iNdEx
1080				for shift := uint(0); ; shift += 7 {
1081					if shift >= 64 {
1082						return 0, ErrIntOverflowNamespace
1083					}
1084					if iNdEx >= l {
1085						return 0, io.ErrUnexpectedEOF
1086					}
1087					b := dAtA[iNdEx]
1088					iNdEx++
1089					innerWire |= (uint64(b) & 0x7F) << shift
1090					if b < 0x80 {
1091						break
1092					}
1093				}
1094				innerWireType := int(innerWire & 0x7)
1095				if innerWireType == 4 {
1096					break
1097				}
1098				next, err := skipNamespace(dAtA[start:])
1099				if err != nil {
1100					return 0, err
1101				}
1102				iNdEx = start + next
1103				if iNdEx < 0 {
1104					return 0, ErrInvalidLengthNamespace
1105				}
1106			}
1107			return iNdEx, nil
1108		case 4:
1109			return iNdEx, nil
1110		case 5:
1111			iNdEx += 4
1112			return iNdEx, nil
1113		default:
1114			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1115		}
1116	}
1117	panic("unreachable")
1118}
1119
1120var (
1121	ErrInvalidLengthNamespace = fmt.Errorf("proto: negative length found during unmarshaling")
1122	ErrIntOverflowNamespace   = fmt.Errorf("proto: integer overflow")
1123)
1124