1
16
17
18
19
20 package v1
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
29 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
30
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 func (m *Carp) Reset() { *m = Carp{} }
49 func (*Carp) ProtoMessage() {}
50 func (*Carp) Descriptor() ([]byte, []int) {
51 return fileDescriptor_83e19b543dd132db, []int{0}
52 }
53 func (m *Carp) XXX_Unmarshal(b []byte) error {
54 return m.Unmarshal(b)
55 }
56 func (m *Carp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
57 b = b[:cap(b)]
58 n, err := m.MarshalToSizedBuffer(b)
59 if err != nil {
60 return nil, err
61 }
62 return b[:n], nil
63 }
64 func (m *Carp) XXX_Merge(src proto.Message) {
65 xxx_messageInfo_Carp.Merge(m, src)
66 }
67 func (m *Carp) XXX_Size() int {
68 return m.Size()
69 }
70 func (m *Carp) XXX_DiscardUnknown() {
71 xxx_messageInfo_Carp.DiscardUnknown(m)
72 }
73
74 var xxx_messageInfo_Carp proto.InternalMessageInfo
75
76 func (m *CarpCondition) Reset() { *m = CarpCondition{} }
77 func (*CarpCondition) ProtoMessage() {}
78 func (*CarpCondition) Descriptor() ([]byte, []int) {
79 return fileDescriptor_83e19b543dd132db, []int{1}
80 }
81 func (m *CarpCondition) XXX_Unmarshal(b []byte) error {
82 return m.Unmarshal(b)
83 }
84 func (m *CarpCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
85 b = b[:cap(b)]
86 n, err := m.MarshalToSizedBuffer(b)
87 if err != nil {
88 return nil, err
89 }
90 return b[:n], nil
91 }
92 func (m *CarpCondition) XXX_Merge(src proto.Message) {
93 xxx_messageInfo_CarpCondition.Merge(m, src)
94 }
95 func (m *CarpCondition) XXX_Size() int {
96 return m.Size()
97 }
98 func (m *CarpCondition) XXX_DiscardUnknown() {
99 xxx_messageInfo_CarpCondition.DiscardUnknown(m)
100 }
101
102 var xxx_messageInfo_CarpCondition proto.InternalMessageInfo
103
104 func (m *CarpList) Reset() { *m = CarpList{} }
105 func (*CarpList) ProtoMessage() {}
106 func (*CarpList) Descriptor() ([]byte, []int) {
107 return fileDescriptor_83e19b543dd132db, []int{2}
108 }
109 func (m *CarpList) XXX_Unmarshal(b []byte) error {
110 return m.Unmarshal(b)
111 }
112 func (m *CarpList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
113 b = b[:cap(b)]
114 n, err := m.MarshalToSizedBuffer(b)
115 if err != nil {
116 return nil, err
117 }
118 return b[:n], nil
119 }
120 func (m *CarpList) XXX_Merge(src proto.Message) {
121 xxx_messageInfo_CarpList.Merge(m, src)
122 }
123 func (m *CarpList) XXX_Size() int {
124 return m.Size()
125 }
126 func (m *CarpList) XXX_DiscardUnknown() {
127 xxx_messageInfo_CarpList.DiscardUnknown(m)
128 }
129
130 var xxx_messageInfo_CarpList proto.InternalMessageInfo
131
132 func (m *CarpSpec) Reset() { *m = CarpSpec{} }
133 func (*CarpSpec) ProtoMessage() {}
134 func (*CarpSpec) Descriptor() ([]byte, []int) {
135 return fileDescriptor_83e19b543dd132db, []int{3}
136 }
137 func (m *CarpSpec) XXX_Unmarshal(b []byte) error {
138 return m.Unmarshal(b)
139 }
140 func (m *CarpSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
141 b = b[:cap(b)]
142 n, err := m.MarshalToSizedBuffer(b)
143 if err != nil {
144 return nil, err
145 }
146 return b[:n], nil
147 }
148 func (m *CarpSpec) XXX_Merge(src proto.Message) {
149 xxx_messageInfo_CarpSpec.Merge(m, src)
150 }
151 func (m *CarpSpec) XXX_Size() int {
152 return m.Size()
153 }
154 func (m *CarpSpec) XXX_DiscardUnknown() {
155 xxx_messageInfo_CarpSpec.DiscardUnknown(m)
156 }
157
158 var xxx_messageInfo_CarpSpec proto.InternalMessageInfo
159
160 func (m *CarpStatus) Reset() { *m = CarpStatus{} }
161 func (*CarpStatus) ProtoMessage() {}
162 func (*CarpStatus) Descriptor() ([]byte, []int) {
163 return fileDescriptor_83e19b543dd132db, []int{4}
164 }
165 func (m *CarpStatus) XXX_Unmarshal(b []byte) error {
166 return m.Unmarshal(b)
167 }
168 func (m *CarpStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
169 b = b[:cap(b)]
170 n, err := m.MarshalToSizedBuffer(b)
171 if err != nil {
172 return nil, err
173 }
174 return b[:n], nil
175 }
176 func (m *CarpStatus) XXX_Merge(src proto.Message) {
177 xxx_messageInfo_CarpStatus.Merge(m, src)
178 }
179 func (m *CarpStatus) XXX_Size() int {
180 return m.Size()
181 }
182 func (m *CarpStatus) XXX_DiscardUnknown() {
183 xxx_messageInfo_CarpStatus.DiscardUnknown(m)
184 }
185
186 var xxx_messageInfo_CarpStatus proto.InternalMessageInfo
187
188 func init() {
189 proto.RegisterType((*Carp)(nil), "k8s.io.apimachinery.pkg.apis.testapigroup.v1.Carp")
190 proto.RegisterType((*CarpCondition)(nil), "k8s.io.apimachinery.pkg.apis.testapigroup.v1.CarpCondition")
191 proto.RegisterType((*CarpList)(nil), "k8s.io.apimachinery.pkg.apis.testapigroup.v1.CarpList")
192 proto.RegisterType((*CarpSpec)(nil), "k8s.io.apimachinery.pkg.apis.testapigroup.v1.CarpSpec")
193 proto.RegisterMapType((map[string]string)(nil), "k8s.io.apimachinery.pkg.apis.testapigroup.v1.CarpSpec.NodeSelectorEntry")
194 proto.RegisterType((*CarpStatus)(nil), "k8s.io.apimachinery.pkg.apis.testapigroup.v1.CarpStatus")
195 }
196
197 func init() {
198 proto.RegisterFile("k8s.io/apimachinery/pkg/apis/testapigroup/v1/generated.proto", fileDescriptor_83e19b543dd132db)
199 }
200
201 var fileDescriptor_83e19b543dd132db = []byte{
202
203 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xc1, 0x6e, 0xdb, 0x46,
204 0x13, 0x36, 0x2d, 0xc9, 0x96, 0xd6, 0x56, 0x62, 0x6f, 0x62, 0x80, 0xbf, 0x81, 0x48, 0x8e, 0x0f,
205 0x86, 0xff, 0xc2, 0xa5, 0x62, 0xa3, 0x09, 0xdc, 0xa6, 0x40, 0x11, 0xda, 0x45, 0xa5, 0xc2, 0x71,
206 0x84, 0x95, 0x81, 0x14, 0x45, 0x0f, 0x59, 0x51, 0x5b, 0x8a, 0x95, 0xc8, 0x25, 0x76, 0x57, 0x2a,
207 0x74, 0x2b, 0xfa, 0x04, 0x7d, 0x88, 0xde, 0x7a, 0xee, 0x03, 0xf4, 0x50, 0xc0, 0xc7, 0x1c, 0x73,
208 0x12, 0x6a, 0xf5, 0x2d, 0x7c, 0x2a, 0x76, 0xb9, 0xa4, 0x48, 0x4b, 0x55, 0xa3, 0xdc, 0xb8, 0x33,
209 0xdf, 0xf7, 0xcd, 0xec, 0xce, 0x68, 0x46, 0xe0, 0xf3, 0xde, 0x29, 0xb7, 0x3c, 0x5a, 0xc3, 0xa1,
210 0xe7, 0x63, 0xa7, 0xeb, 0x05, 0x84, 0x8d, 0x6a, 0x61, 0xcf, 0x95, 0x06, 0x5e, 0x13, 0x84, 0x0b,
211 0x1c, 0x7a, 0x2e, 0xa3, 0x83, 0xb0, 0x36, 0x3c, 0xae, 0xb9, 0x24, 0x20, 0x0c, 0x0b, 0xd2, 0xb1,
212 0x42, 0x46, 0x05, 0x85, 0x47, 0x11, 0xdb, 0x4a, 0xb3, 0xad, 0xb0, 0xe7, 0x4a, 0x03, 0xb7, 0xd2,
213 0x6c, 0x6b, 0x78, 0xbc, 0xfb, 0xb1, 0xeb, 0x89, 0xee, 0xa0, 0x6d, 0x39, 0xd4, 0xaf, 0xb9, 0xd4,
214 0xa5, 0x35, 0x25, 0xd2, 0x1e, 0x7c, 0xaf, 0x4e, 0xea, 0xa0, 0xbe, 0x22, 0xf1, 0xdd, 0x4f, 0x16,
215 0xa6, 0xe6, 0x13, 0x81, 0xe7, 0xa4, 0xb4, 0x5b, 0xfb, 0x37, 0x16, 0x1b, 0x04, 0xc2, 0xf3, 0xc9,
216 0x0c, 0xe1, 0xd9, 0x7f, 0x11, 0xb8, 0xd3, 0x25, 0x3e, 0xbe, 0xcb, 0xdb, 0xff, 0x75, 0x15, 0xe4,
217 0xcf, 0x30, 0x0b, 0xe1, 0x1b, 0x50, 0x94, 0xc9, 0x74, 0xb0, 0xc0, 0xa6, 0xb1, 0x67, 0x1c, 0x6e,
218 0x9c, 0x3c, 0xb1, 0x16, 0xbe, 0x8b, 0x44, 0x5b, 0xc3, 0x63, 0xeb, 0x55, 0xfb, 0x07, 0xe2, 0x88,
219 0x97, 0x44, 0x60, 0x1b, 0x5e, 0x8f, 0xab, 0x2b, 0x93, 0x71, 0x15, 0x4c, 0x6d, 0x28, 0x51, 0x85,
220 0xdf, 0x80, 0x3c, 0x0f, 0x89, 0x63, 0xae, 0x2a, 0xf5, 0x67, 0xd6, 0x32, 0xaf, 0x6e, 0xc9, 0x1c,
221 0x5b, 0x21, 0x71, 0xec, 0x4d, 0x1d, 0x23, 0x2f, 0x4f, 0x48, 0x29, 0xc2, 0x37, 0x60, 0x8d, 0x0b,
222 0x2c, 0x06, 0xdc, 0xcc, 0x29, 0xed, 0xd3, 0x0f, 0xd0, 0x56, 0x7c, 0xfb, 0x9e, 0x56, 0x5f, 0x8b,
223 0xce, 0x48, 0xeb, 0xee, 0xff, 0x9e, 0x03, 0x65, 0x09, 0x3b, 0xa3, 0x41, 0xc7, 0x13, 0x1e, 0x0d,
224 0xe0, 0x53, 0x90, 0x17, 0xa3, 0x90, 0xa8, 0xb7, 0x2a, 0xd9, 0x8f, 0xe3, 0xac, 0xae, 0x46, 0x21,
225 0xb9, 0x1d, 0x57, 0xb7, 0x33, 0x60, 0x69, 0x44, 0x0a, 0x0e, 0x3f, 0x4d, 0x52, 0x5d, 0xcd, 0x10,
226 0x75, 0xc0, 0xdb, 0x71, 0xf5, 0x7e, 0x42, 0xcb, 0xe6, 0x00, 0x5d, 0x50, 0xee, 0x63, 0x2e, 0x9a,
227 0x8c, 0xb6, 0xc9, 0x95, 0xe7, 0x13, 0x7d, 0xd9, 0x8f, 0xde, 0xaf, 0x4c, 0x92, 0x61, 0xef, 0xe8,
228 0x68, 0xe5, 0x8b, 0xb4, 0x10, 0xca, 0xea, 0xc2, 0x21, 0x80, 0xd2, 0x70, 0xc5, 0x70, 0xc0, 0xa3,
229 0xfc, 0x65, 0xb4, 0xfc, 0xd2, 0xd1, 0x76, 0x75, 0x34, 0x78, 0x31, 0xa3, 0x86, 0xe6, 0x44, 0x80,
230 0x07, 0x60, 0x8d, 0x11, 0xcc, 0x69, 0x60, 0x16, 0xd4, 0xdb, 0x24, 0xc5, 0x40, 0xca, 0x8a, 0xb4,
231 0x17, 0xfe, 0x1f, 0xac, 0xfb, 0x84, 0x73, 0xec, 0x12, 0x73, 0x4d, 0x01, 0xef, 0x6b, 0xe0, 0xfa,
232 0xcb, 0xc8, 0x8c, 0x62, 0xff, 0xfe, 0x1f, 0x06, 0x28, 0xca, 0x52, 0x5c, 0x78, 0x5c, 0xc0, 0xef,
233 0x66, 0x5a, 0xdc, 0x7a, 0xbf, 0xdb, 0x48, 0xb6, 0x6a, 0xf0, 0x2d, 0x1d, 0xa8, 0x18, 0x5b, 0x52,
234 0xed, 0xfd, 0x1a, 0x14, 0x3c, 0x41, 0x7c, 0x59, 0xd8, 0xdc, 0xe1, 0xc6, 0xc9, 0xc9, 0xf2, 0x3d,
235 0x68, 0x97, 0xb5, 0x7c, 0xa1, 0x21, 0x85, 0x50, 0xa4, 0xb7, 0xff, 0xe7, 0x7a, 0x74, 0x07, 0xd9,
236 0xf0, 0xf0, 0x02, 0x94, 0x99, 0xa4, 0x32, 0xd1, 0xa4, 0x7d, 0xcf, 0x19, 0xa9, 0x26, 0x28, 0xd9,
237 0x07, 0x71, 0x61, 0x51, 0xda, 0x79, 0x7b, 0xd7, 0x80, 0xb2, 0x64, 0xe8, 0x82, 0x47, 0x82, 0x30,
238 0xdf, 0x0b, 0xb0, 0x2c, 0xc2, 0x57, 0x0c, 0x3b, 0xa4, 0x49, 0x98, 0x47, 0x3b, 0x2d, 0xe2, 0xd0,
239 0xa0, 0xc3, 0x55, 0xd1, 0x73, 0xf6, 0xe3, 0xc9, 0xb8, 0xfa, 0xe8, 0x6a, 0x11, 0x10, 0x2d, 0xd6,
240 0x81, 0xaf, 0xc0, 0x0e, 0x76, 0x84, 0x37, 0x24, 0xe7, 0x04, 0x77, 0xfa, 0x5e, 0x40, 0xe2, 0x00,
241 0x05, 0x15, 0xe0, 0x7f, 0x93, 0x71, 0x75, 0xe7, 0xc5, 0x3c, 0x00, 0x9a, 0xcf, 0x83, 0x3f, 0x1b,
242 0x60, 0x33, 0xa0, 0x1d, 0xd2, 0x22, 0x7d, 0xe2, 0x08, 0xca, 0xcc, 0x75, 0xf5, 0xea, 0xf5, 0x0f,
243 0x9b, 0x2a, 0xd6, 0x65, 0x4a, 0xea, 0xcb, 0x40, 0xb0, 0x91, 0xfd, 0x50, 0xbf, 0xe8, 0x66, 0xda,
244 0x85, 0x32, 0x31, 0xe1, 0xd7, 0x00, 0x72, 0xc2, 0x86, 0x9e, 0x43, 0x5e, 0x38, 0x0e, 0x1d, 0x04,
245 0xe2, 0x12, 0xfb, 0xc4, 0x2c, 0xaa, 0x8a, 0x24, 0xcd, 0xdf, 0x9a, 0x41, 0xa0, 0x39, 0x2c, 0x58,
246 0x07, 0xf7, 0xb2, 0x56, 0xb3, 0xa4, 0x74, 0xf6, 0xb4, 0x8e, 0x79, 0x4e, 0x42, 0x46, 0x1c, 0x39,
247 0xba, 0xb3, 0x8a, 0xe8, 0x0e, 0x0f, 0x1e, 0x81, 0xa2, 0xcc, 0x52, 0xe5, 0x02, 0x94, 0x46, 0xd2,
248 0xb6, 0x97, 0xda, 0x8e, 0x12, 0x04, 0x7c, 0x0a, 0x36, 0xba, 0x94, 0x8b, 0x4b, 0x22, 0x7e, 0xa4,
249 0xac, 0x67, 0x6e, 0xec, 0x19, 0x87, 0x45, 0xfb, 0x81, 0x26, 0x6c, 0xd4, 0xa7, 0x2e, 0x94, 0xc6,
250 0xc9, 0xdf, 0xa0, 0x3c, 0x36, 0x1b, 0xe7, 0xe6, 0xa6, 0xa2, 0x24, 0xbf, 0xc1, 0x7a, 0x64, 0x46,
251 0xb1, 0x3f, 0x86, 0x36, 0x9a, 0x67, 0x66, 0x79, 0x16, 0xda, 0x68, 0x9e, 0xa1, 0xd8, 0x2f, 0x53,
252 0x97, 0x9f, 0x81, 0x4c, 0x7d, 0x2b, 0x9b, 0x7a, 0x5d, 0xdb, 0x51, 0x82, 0x80, 0x35, 0x50, 0xe2,
253 0x83, 0x76, 0x87, 0xfa, 0xd8, 0x0b, 0xcc, 0x6d, 0x05, 0xdf, 0xd6, 0xf0, 0x52, 0x2b, 0x76, 0xa0,
254 0x29, 0x06, 0x3e, 0x07, 0x65, 0xb9, 0x06, 0x3b, 0x83, 0x3e, 0x61, 0x2a, 0xc6, 0x03, 0x45, 0x4a,
255 0xa6, 0x62, 0x2b, 0x76, 0xaa, 0x37, 0xca, 0x62, 0x77, 0xbf, 0x00, 0xdb, 0x33, 0x5d, 0x02, 0xb7,
256 0x40, 0xae, 0x47, 0x46, 0xd1, 0x12, 0x40, 0xf2, 0x13, 0x3e, 0x04, 0x85, 0x21, 0xee, 0x0f, 0x48,
257 0x34, 0xdf, 0x51, 0x74, 0xf8, 0x6c, 0xf5, 0xd4, 0xd8, 0xff, 0x2d, 0x07, 0xc0, 0x74, 0xd5, 0xc0,
258 0x27, 0xa0, 0x10, 0x76, 0x31, 0x8f, 0x37, 0x48, 0xdc, 0x2f, 0x85, 0xa6, 0x34, 0xde, 0x8e, 0xab,
259 0x25, 0x89, 0x55, 0x07, 0x14, 0x01, 0x21, 0x05, 0xc0, 0x89, 0x77, 0x43, 0x3c, 0x66, 0x9e, 0x2f,
260 0xdf, 0xf0, 0xc9, 0x7e, 0x99, 0xee, 0xeb, 0xc4, 0xc4, 0x51, 0x2a, 0x44, 0x7a, 0xd0, 0xe6, 0x16,
261 0x0f, 0xda, 0xd4, 0xec, 0xce, 0x2f, 0x9c, 0xdd, 0x07, 0x60, 0x2d, 0x2a, 0xf6, 0xdd, 0x19, 0x1f,
262 0xf5, 0x02, 0xd2, 0x5e, 0x89, 0x73, 0x30, 0x0b, 0x1b, 0x4d, 0x3d, 0xe2, 0x13, 0xdc, 0x99, 0xb2,
263 0x22, 0xed, 0x85, 0xaf, 0x41, 0x49, 0x0d, 0x34, 0xb5, 0xa2, 0xd6, 0x97, 0x5e, 0x51, 0x65, 0xd5,
264 0x2b, 0xb1, 0x00, 0x9a, 0x6a, 0xd9, 0xe8, 0xfa, 0xa6, 0xb2, 0xf2, 0xf6, 0xa6, 0xb2, 0xf2, 0xee,
265 0xa6, 0xb2, 0xf2, 0xd3, 0xa4, 0x62, 0x5c, 0x4f, 0x2a, 0xc6, 0xdb, 0x49, 0xc5, 0x78, 0x37, 0xa9,
266 0x18, 0x7f, 0x4d, 0x2a, 0xc6, 0x2f, 0x7f, 0x57, 0x56, 0xbe, 0x3d, 0x5a, 0xe6, 0x8f, 0xe7, 0x3f,
267 0x01, 0x00, 0x00, 0xff, 0xff, 0x9e, 0xd1, 0x13, 0x90, 0xa7, 0x0a, 0x00, 0x00,
268 }
269
270 func (m *Carp) Marshal() (dAtA []byte, err error) {
271 size := m.Size()
272 dAtA = make([]byte, size)
273 n, err := m.MarshalToSizedBuffer(dAtA[:size])
274 if err != nil {
275 return nil, err
276 }
277 return dAtA[:n], nil
278 }
279
280 func (m *Carp) MarshalTo(dAtA []byte) (int, error) {
281 size := m.Size()
282 return m.MarshalToSizedBuffer(dAtA[:size])
283 }
284
285 func (m *Carp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
286 i := len(dAtA)
287 _ = i
288 var l int
289 _ = l
290 {
291 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
292 if err != nil {
293 return 0, err
294 }
295 i -= size
296 i = encodeVarintGenerated(dAtA, i, uint64(size))
297 }
298 i--
299 dAtA[i] = 0x1a
300 {
301 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
302 if err != nil {
303 return 0, err
304 }
305 i -= size
306 i = encodeVarintGenerated(dAtA, i, uint64(size))
307 }
308 i--
309 dAtA[i] = 0x12
310 {
311 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
312 if err != nil {
313 return 0, err
314 }
315 i -= size
316 i = encodeVarintGenerated(dAtA, i, uint64(size))
317 }
318 i--
319 dAtA[i] = 0xa
320 return len(dAtA) - i, nil
321 }
322
323 func (m *CarpCondition) Marshal() (dAtA []byte, err error) {
324 size := m.Size()
325 dAtA = make([]byte, size)
326 n, err := m.MarshalToSizedBuffer(dAtA[:size])
327 if err != nil {
328 return nil, err
329 }
330 return dAtA[:n], nil
331 }
332
333 func (m *CarpCondition) MarshalTo(dAtA []byte) (int, error) {
334 size := m.Size()
335 return m.MarshalToSizedBuffer(dAtA[:size])
336 }
337
338 func (m *CarpCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
339 i := len(dAtA)
340 _ = i
341 var l int
342 _ = l
343 i -= len(m.Message)
344 copy(dAtA[i:], m.Message)
345 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
346 i--
347 dAtA[i] = 0x32
348 i -= len(m.Reason)
349 copy(dAtA[i:], m.Reason)
350 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
351 i--
352 dAtA[i] = 0x2a
353 {
354 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
355 if err != nil {
356 return 0, err
357 }
358 i -= size
359 i = encodeVarintGenerated(dAtA, i, uint64(size))
360 }
361 i--
362 dAtA[i] = 0x22
363 {
364 size, err := m.LastProbeTime.MarshalToSizedBuffer(dAtA[:i])
365 if err != nil {
366 return 0, err
367 }
368 i -= size
369 i = encodeVarintGenerated(dAtA, i, uint64(size))
370 }
371 i--
372 dAtA[i] = 0x1a
373 i -= len(m.Status)
374 copy(dAtA[i:], m.Status)
375 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
376 i--
377 dAtA[i] = 0x12
378 i -= len(m.Type)
379 copy(dAtA[i:], m.Type)
380 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
381 i--
382 dAtA[i] = 0xa
383 return len(dAtA) - i, nil
384 }
385
386 func (m *CarpList) Marshal() (dAtA []byte, err error) {
387 size := m.Size()
388 dAtA = make([]byte, size)
389 n, err := m.MarshalToSizedBuffer(dAtA[:size])
390 if err != nil {
391 return nil, err
392 }
393 return dAtA[:n], nil
394 }
395
396 func (m *CarpList) MarshalTo(dAtA []byte) (int, error) {
397 size := m.Size()
398 return m.MarshalToSizedBuffer(dAtA[:size])
399 }
400
401 func (m *CarpList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
402 i := len(dAtA)
403 _ = i
404 var l int
405 _ = l
406 if len(m.Items) > 0 {
407 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
408 {
409 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
410 if err != nil {
411 return 0, err
412 }
413 i -= size
414 i = encodeVarintGenerated(dAtA, i, uint64(size))
415 }
416 i--
417 dAtA[i] = 0x12
418 }
419 }
420 {
421 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
422 if err != nil {
423 return 0, err
424 }
425 i -= size
426 i = encodeVarintGenerated(dAtA, i, uint64(size))
427 }
428 i--
429 dAtA[i] = 0xa
430 return len(dAtA) - i, nil
431 }
432
433 func (m *CarpSpec) Marshal() (dAtA []byte, err error) {
434 size := m.Size()
435 dAtA = make([]byte, size)
436 n, err := m.MarshalToSizedBuffer(dAtA[:size])
437 if err != nil {
438 return nil, err
439 }
440 return dAtA[:n], nil
441 }
442
443 func (m *CarpSpec) MarshalTo(dAtA []byte) (int, error) {
444 size := m.Size()
445 return m.MarshalToSizedBuffer(dAtA[:size])
446 }
447
448 func (m *CarpSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
449 i := len(dAtA)
450 _ = i
451 var l int
452 _ = l
453 i -= len(m.SchedulerName)
454 copy(dAtA[i:], m.SchedulerName)
455 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SchedulerName)))
456 i--
457 dAtA[i] = 0x1
458 i--
459 dAtA[i] = 0x9a
460 i -= len(m.Subdomain)
461 copy(dAtA[i:], m.Subdomain)
462 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Subdomain)))
463 i--
464 dAtA[i] = 0x1
465 i--
466 dAtA[i] = 0x8a
467 i -= len(m.Hostname)
468 copy(dAtA[i:], m.Hostname)
469 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hostname)))
470 i--
471 dAtA[i] = 0x1
472 i--
473 dAtA[i] = 0x82
474 i--
475 if m.HostIPC {
476 dAtA[i] = 1
477 } else {
478 dAtA[i] = 0
479 }
480 i--
481 dAtA[i] = 0x68
482 i--
483 if m.HostPID {
484 dAtA[i] = 1
485 } else {
486 dAtA[i] = 0
487 }
488 i--
489 dAtA[i] = 0x60
490 i--
491 if m.HostNetwork {
492 dAtA[i] = 1
493 } else {
494 dAtA[i] = 0
495 }
496 i--
497 dAtA[i] = 0x58
498 i -= len(m.NodeName)
499 copy(dAtA[i:], m.NodeName)
500 i = encodeVarintGenerated(dAtA, i, uint64(len(m.NodeName)))
501 i--
502 dAtA[i] = 0x52
503 i -= len(m.DeprecatedServiceAccount)
504 copy(dAtA[i:], m.DeprecatedServiceAccount)
505 i = encodeVarintGenerated(dAtA, i, uint64(len(m.DeprecatedServiceAccount)))
506 i--
507 dAtA[i] = 0x4a
508 i -= len(m.ServiceAccountName)
509 copy(dAtA[i:], m.ServiceAccountName)
510 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceAccountName)))
511 i--
512 dAtA[i] = 0x42
513 if len(m.NodeSelector) > 0 {
514 keysForNodeSelector := make([]string, 0, len(m.NodeSelector))
515 for k := range m.NodeSelector {
516 keysForNodeSelector = append(keysForNodeSelector, string(k))
517 }
518 github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
519 for iNdEx := len(keysForNodeSelector) - 1; iNdEx >= 0; iNdEx-- {
520 v := m.NodeSelector[string(keysForNodeSelector[iNdEx])]
521 baseI := i
522 i -= len(v)
523 copy(dAtA[i:], v)
524 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
525 i--
526 dAtA[i] = 0x12
527 i -= len(keysForNodeSelector[iNdEx])
528 copy(dAtA[i:], keysForNodeSelector[iNdEx])
529 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForNodeSelector[iNdEx])))
530 i--
531 dAtA[i] = 0xa
532 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
533 i--
534 dAtA[i] = 0x3a
535 }
536 }
537 if m.ActiveDeadlineSeconds != nil {
538 i = encodeVarintGenerated(dAtA, i, uint64(*m.ActiveDeadlineSeconds))
539 i--
540 dAtA[i] = 0x28
541 }
542 if m.TerminationGracePeriodSeconds != nil {
543 i = encodeVarintGenerated(dAtA, i, uint64(*m.TerminationGracePeriodSeconds))
544 i--
545 dAtA[i] = 0x20
546 }
547 i -= len(m.RestartPolicy)
548 copy(dAtA[i:], m.RestartPolicy)
549 i = encodeVarintGenerated(dAtA, i, uint64(len(m.RestartPolicy)))
550 i--
551 dAtA[i] = 0x1a
552 return len(dAtA) - i, nil
553 }
554
555 func (m *CarpStatus) Marshal() (dAtA []byte, err error) {
556 size := m.Size()
557 dAtA = make([]byte, size)
558 n, err := m.MarshalToSizedBuffer(dAtA[:size])
559 if err != nil {
560 return nil, err
561 }
562 return dAtA[:n], nil
563 }
564
565 func (m *CarpStatus) MarshalTo(dAtA []byte) (int, error) {
566 size := m.Size()
567 return m.MarshalToSizedBuffer(dAtA[:size])
568 }
569
570 func (m *CarpStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
571 i := len(dAtA)
572 _ = i
573 var l int
574 _ = l
575 if m.StartTime != nil {
576 {
577 size, err := m.StartTime.MarshalToSizedBuffer(dAtA[:i])
578 if err != nil {
579 return 0, err
580 }
581 i -= size
582 i = encodeVarintGenerated(dAtA, i, uint64(size))
583 }
584 i--
585 dAtA[i] = 0x3a
586 }
587 i -= len(m.CarpIP)
588 copy(dAtA[i:], m.CarpIP)
589 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CarpIP)))
590 i--
591 dAtA[i] = 0x32
592 i -= len(m.HostIP)
593 copy(dAtA[i:], m.HostIP)
594 i = encodeVarintGenerated(dAtA, i, uint64(len(m.HostIP)))
595 i--
596 dAtA[i] = 0x2a
597 i -= len(m.Reason)
598 copy(dAtA[i:], m.Reason)
599 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
600 i--
601 dAtA[i] = 0x22
602 i -= len(m.Message)
603 copy(dAtA[i:], m.Message)
604 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
605 i--
606 dAtA[i] = 0x1a
607 if len(m.Conditions) > 0 {
608 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
609 {
610 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
611 if err != nil {
612 return 0, err
613 }
614 i -= size
615 i = encodeVarintGenerated(dAtA, i, uint64(size))
616 }
617 i--
618 dAtA[i] = 0x12
619 }
620 }
621 i -= len(m.Phase)
622 copy(dAtA[i:], m.Phase)
623 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Phase)))
624 i--
625 dAtA[i] = 0xa
626 return len(dAtA) - i, nil
627 }
628
629 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
630 offset -= sovGenerated(v)
631 base := offset
632 for v >= 1<<7 {
633 dAtA[offset] = uint8(v&0x7f | 0x80)
634 v >>= 7
635 offset++
636 }
637 dAtA[offset] = uint8(v)
638 return base
639 }
640 func (m *Carp) Size() (n int) {
641 if m == nil {
642 return 0
643 }
644 var l int
645 _ = l
646 l = m.ObjectMeta.Size()
647 n += 1 + l + sovGenerated(uint64(l))
648 l = m.Spec.Size()
649 n += 1 + l + sovGenerated(uint64(l))
650 l = m.Status.Size()
651 n += 1 + l + sovGenerated(uint64(l))
652 return n
653 }
654
655 func (m *CarpCondition) Size() (n int) {
656 if m == nil {
657 return 0
658 }
659 var l int
660 _ = l
661 l = len(m.Type)
662 n += 1 + l + sovGenerated(uint64(l))
663 l = len(m.Status)
664 n += 1 + l + sovGenerated(uint64(l))
665 l = m.LastProbeTime.Size()
666 n += 1 + l + sovGenerated(uint64(l))
667 l = m.LastTransitionTime.Size()
668 n += 1 + l + sovGenerated(uint64(l))
669 l = len(m.Reason)
670 n += 1 + l + sovGenerated(uint64(l))
671 l = len(m.Message)
672 n += 1 + l + sovGenerated(uint64(l))
673 return n
674 }
675
676 func (m *CarpList) Size() (n int) {
677 if m == nil {
678 return 0
679 }
680 var l int
681 _ = l
682 l = m.ListMeta.Size()
683 n += 1 + l + sovGenerated(uint64(l))
684 if len(m.Items) > 0 {
685 for _, e := range m.Items {
686 l = e.Size()
687 n += 1 + l + sovGenerated(uint64(l))
688 }
689 }
690 return n
691 }
692
693 func (m *CarpSpec) Size() (n int) {
694 if m == nil {
695 return 0
696 }
697 var l int
698 _ = l
699 l = len(m.RestartPolicy)
700 n += 1 + l + sovGenerated(uint64(l))
701 if m.TerminationGracePeriodSeconds != nil {
702 n += 1 + sovGenerated(uint64(*m.TerminationGracePeriodSeconds))
703 }
704 if m.ActiveDeadlineSeconds != nil {
705 n += 1 + sovGenerated(uint64(*m.ActiveDeadlineSeconds))
706 }
707 if len(m.NodeSelector) > 0 {
708 for k, v := range m.NodeSelector {
709 _ = k
710 _ = v
711 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
712 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
713 }
714 }
715 l = len(m.ServiceAccountName)
716 n += 1 + l + sovGenerated(uint64(l))
717 l = len(m.DeprecatedServiceAccount)
718 n += 1 + l + sovGenerated(uint64(l))
719 l = len(m.NodeName)
720 n += 1 + l + sovGenerated(uint64(l))
721 n += 2
722 n += 2
723 n += 2
724 l = len(m.Hostname)
725 n += 2 + l + sovGenerated(uint64(l))
726 l = len(m.Subdomain)
727 n += 2 + l + sovGenerated(uint64(l))
728 l = len(m.SchedulerName)
729 n += 2 + l + sovGenerated(uint64(l))
730 return n
731 }
732
733 func (m *CarpStatus) Size() (n int) {
734 if m == nil {
735 return 0
736 }
737 var l int
738 _ = l
739 l = len(m.Phase)
740 n += 1 + l + sovGenerated(uint64(l))
741 if len(m.Conditions) > 0 {
742 for _, e := range m.Conditions {
743 l = e.Size()
744 n += 1 + l + sovGenerated(uint64(l))
745 }
746 }
747 l = len(m.Message)
748 n += 1 + l + sovGenerated(uint64(l))
749 l = len(m.Reason)
750 n += 1 + l + sovGenerated(uint64(l))
751 l = len(m.HostIP)
752 n += 1 + l + sovGenerated(uint64(l))
753 l = len(m.CarpIP)
754 n += 1 + l + sovGenerated(uint64(l))
755 if m.StartTime != nil {
756 l = m.StartTime.Size()
757 n += 1 + l + sovGenerated(uint64(l))
758 }
759 return n
760 }
761
762 func sovGenerated(x uint64) (n int) {
763 return (math_bits.Len64(x|1) + 6) / 7
764 }
765 func sozGenerated(x uint64) (n int) {
766 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
767 }
768 func (this *Carp) String() string {
769 if this == nil {
770 return "nil"
771 }
772 s := strings.Join([]string{`&Carp{`,
773 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
774 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CarpSpec", "CarpSpec", 1), `&`, ``, 1) + `,`,
775 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "CarpStatus", "CarpStatus", 1), `&`, ``, 1) + `,`,
776 `}`,
777 }, "")
778 return s
779 }
780 func (this *CarpCondition) String() string {
781 if this == nil {
782 return "nil"
783 }
784 s := strings.Join([]string{`&CarpCondition{`,
785 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
786 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
787 `LastProbeTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastProbeTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
788 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
789 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
790 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
791 `}`,
792 }, "")
793 return s
794 }
795 func (this *CarpList) String() string {
796 if this == nil {
797 return "nil"
798 }
799 repeatedStringForItems := "[]Carp{"
800 for _, f := range this.Items {
801 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Carp", "Carp", 1), `&`, ``, 1) + ","
802 }
803 repeatedStringForItems += "}"
804 s := strings.Join([]string{`&CarpList{`,
805 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
806 `Items:` + repeatedStringForItems + `,`,
807 `}`,
808 }, "")
809 return s
810 }
811 func (this *CarpSpec) String() string {
812 if this == nil {
813 return "nil"
814 }
815 keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
816 for k := range this.NodeSelector {
817 keysForNodeSelector = append(keysForNodeSelector, k)
818 }
819 github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
820 mapStringForNodeSelector := "map[string]string{"
821 for _, k := range keysForNodeSelector {
822 mapStringForNodeSelector += fmt.Sprintf("%v: %v,", k, this.NodeSelector[k])
823 }
824 mapStringForNodeSelector += "}"
825 s := strings.Join([]string{`&CarpSpec{`,
826 `RestartPolicy:` + fmt.Sprintf("%v", this.RestartPolicy) + `,`,
827 `TerminationGracePeriodSeconds:` + valueToStringGenerated(this.TerminationGracePeriodSeconds) + `,`,
828 `ActiveDeadlineSeconds:` + valueToStringGenerated(this.ActiveDeadlineSeconds) + `,`,
829 `NodeSelector:` + mapStringForNodeSelector + `,`,
830 `ServiceAccountName:` + fmt.Sprintf("%v", this.ServiceAccountName) + `,`,
831 `DeprecatedServiceAccount:` + fmt.Sprintf("%v", this.DeprecatedServiceAccount) + `,`,
832 `NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
833 `HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`,
834 `HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`,
835 `HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`,
836 `Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`,
837 `Subdomain:` + fmt.Sprintf("%v", this.Subdomain) + `,`,
838 `SchedulerName:` + fmt.Sprintf("%v", this.SchedulerName) + `,`,
839 `}`,
840 }, "")
841 return s
842 }
843 func (this *CarpStatus) String() string {
844 if this == nil {
845 return "nil"
846 }
847 repeatedStringForConditions := "[]CarpCondition{"
848 for _, f := range this.Conditions {
849 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "CarpCondition", "CarpCondition", 1), `&`, ``, 1) + ","
850 }
851 repeatedStringForConditions += "}"
852 s := strings.Join([]string{`&CarpStatus{`,
853 `Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
854 `Conditions:` + repeatedStringForConditions + `,`,
855 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
856 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
857 `HostIP:` + fmt.Sprintf("%v", this.HostIP) + `,`,
858 `CarpIP:` + fmt.Sprintf("%v", this.CarpIP) + `,`,
859 `StartTime:` + strings.Replace(fmt.Sprintf("%v", this.StartTime), "Time", "v1.Time", 1) + `,`,
860 `}`,
861 }, "")
862 return s
863 }
864 func valueToStringGenerated(v interface{}) string {
865 rv := reflect.ValueOf(v)
866 if rv.IsNil() {
867 return "nil"
868 }
869 pv := reflect.Indirect(rv).Interface()
870 return fmt.Sprintf("*%v", pv)
871 }
872 func (m *Carp) Unmarshal(dAtA []byte) error {
873 l := len(dAtA)
874 iNdEx := 0
875 for iNdEx < l {
876 preIndex := iNdEx
877 var wire uint64
878 for shift := uint(0); ; shift += 7 {
879 if shift >= 64 {
880 return ErrIntOverflowGenerated
881 }
882 if iNdEx >= l {
883 return io.ErrUnexpectedEOF
884 }
885 b := dAtA[iNdEx]
886 iNdEx++
887 wire |= uint64(b&0x7F) << shift
888 if b < 0x80 {
889 break
890 }
891 }
892 fieldNum := int32(wire >> 3)
893 wireType := int(wire & 0x7)
894 if wireType == 4 {
895 return fmt.Errorf("proto: Carp: wiretype end group for non-group")
896 }
897 if fieldNum <= 0 {
898 return fmt.Errorf("proto: Carp: illegal tag %d (wire type %d)", fieldNum, wire)
899 }
900 switch fieldNum {
901 case 1:
902 if wireType != 2 {
903 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
904 }
905 var msglen int
906 for shift := uint(0); ; shift += 7 {
907 if shift >= 64 {
908 return ErrIntOverflowGenerated
909 }
910 if iNdEx >= l {
911 return io.ErrUnexpectedEOF
912 }
913 b := dAtA[iNdEx]
914 iNdEx++
915 msglen |= int(b&0x7F) << shift
916 if b < 0x80 {
917 break
918 }
919 }
920 if msglen < 0 {
921 return ErrInvalidLengthGenerated
922 }
923 postIndex := iNdEx + msglen
924 if postIndex < 0 {
925 return ErrInvalidLengthGenerated
926 }
927 if postIndex > l {
928 return io.ErrUnexpectedEOF
929 }
930 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
931 return err
932 }
933 iNdEx = postIndex
934 case 2:
935 if wireType != 2 {
936 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
937 }
938 var msglen int
939 for shift := uint(0); ; shift += 7 {
940 if shift >= 64 {
941 return ErrIntOverflowGenerated
942 }
943 if iNdEx >= l {
944 return io.ErrUnexpectedEOF
945 }
946 b := dAtA[iNdEx]
947 iNdEx++
948 msglen |= int(b&0x7F) << shift
949 if b < 0x80 {
950 break
951 }
952 }
953 if msglen < 0 {
954 return ErrInvalidLengthGenerated
955 }
956 postIndex := iNdEx + msglen
957 if postIndex < 0 {
958 return ErrInvalidLengthGenerated
959 }
960 if postIndex > l {
961 return io.ErrUnexpectedEOF
962 }
963 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
964 return err
965 }
966 iNdEx = postIndex
967 case 3:
968 if wireType != 2 {
969 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
970 }
971 var msglen int
972 for shift := uint(0); ; shift += 7 {
973 if shift >= 64 {
974 return ErrIntOverflowGenerated
975 }
976 if iNdEx >= l {
977 return io.ErrUnexpectedEOF
978 }
979 b := dAtA[iNdEx]
980 iNdEx++
981 msglen |= int(b&0x7F) << shift
982 if b < 0x80 {
983 break
984 }
985 }
986 if msglen < 0 {
987 return ErrInvalidLengthGenerated
988 }
989 postIndex := iNdEx + msglen
990 if postIndex < 0 {
991 return ErrInvalidLengthGenerated
992 }
993 if postIndex > l {
994 return io.ErrUnexpectedEOF
995 }
996 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
997 return err
998 }
999 iNdEx = postIndex
1000 default:
1001 iNdEx = preIndex
1002 skippy, err := skipGenerated(dAtA[iNdEx:])
1003 if err != nil {
1004 return err
1005 }
1006 if (skippy < 0) || (iNdEx+skippy) < 0 {
1007 return ErrInvalidLengthGenerated
1008 }
1009 if (iNdEx + skippy) > l {
1010 return io.ErrUnexpectedEOF
1011 }
1012 iNdEx += skippy
1013 }
1014 }
1015
1016 if iNdEx > l {
1017 return io.ErrUnexpectedEOF
1018 }
1019 return nil
1020 }
1021 func (m *CarpCondition) Unmarshal(dAtA []byte) error {
1022 l := len(dAtA)
1023 iNdEx := 0
1024 for iNdEx < l {
1025 preIndex := iNdEx
1026 var wire uint64
1027 for shift := uint(0); ; shift += 7 {
1028 if shift >= 64 {
1029 return ErrIntOverflowGenerated
1030 }
1031 if iNdEx >= l {
1032 return io.ErrUnexpectedEOF
1033 }
1034 b := dAtA[iNdEx]
1035 iNdEx++
1036 wire |= uint64(b&0x7F) << shift
1037 if b < 0x80 {
1038 break
1039 }
1040 }
1041 fieldNum := int32(wire >> 3)
1042 wireType := int(wire & 0x7)
1043 if wireType == 4 {
1044 return fmt.Errorf("proto: CarpCondition: wiretype end group for non-group")
1045 }
1046 if fieldNum <= 0 {
1047 return fmt.Errorf("proto: CarpCondition: illegal tag %d (wire type %d)", fieldNum, wire)
1048 }
1049 switch fieldNum {
1050 case 1:
1051 if wireType != 2 {
1052 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
1053 }
1054 var stringLen uint64
1055 for shift := uint(0); ; shift += 7 {
1056 if shift >= 64 {
1057 return ErrIntOverflowGenerated
1058 }
1059 if iNdEx >= l {
1060 return io.ErrUnexpectedEOF
1061 }
1062 b := dAtA[iNdEx]
1063 iNdEx++
1064 stringLen |= uint64(b&0x7F) << shift
1065 if b < 0x80 {
1066 break
1067 }
1068 }
1069 intStringLen := int(stringLen)
1070 if intStringLen < 0 {
1071 return ErrInvalidLengthGenerated
1072 }
1073 postIndex := iNdEx + intStringLen
1074 if postIndex < 0 {
1075 return ErrInvalidLengthGenerated
1076 }
1077 if postIndex > l {
1078 return io.ErrUnexpectedEOF
1079 }
1080 m.Type = CarpConditionType(dAtA[iNdEx:postIndex])
1081 iNdEx = postIndex
1082 case 2:
1083 if wireType != 2 {
1084 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
1085 }
1086 var stringLen uint64
1087 for shift := uint(0); ; shift += 7 {
1088 if shift >= 64 {
1089 return ErrIntOverflowGenerated
1090 }
1091 if iNdEx >= l {
1092 return io.ErrUnexpectedEOF
1093 }
1094 b := dAtA[iNdEx]
1095 iNdEx++
1096 stringLen |= uint64(b&0x7F) << shift
1097 if b < 0x80 {
1098 break
1099 }
1100 }
1101 intStringLen := int(stringLen)
1102 if intStringLen < 0 {
1103 return ErrInvalidLengthGenerated
1104 }
1105 postIndex := iNdEx + intStringLen
1106 if postIndex < 0 {
1107 return ErrInvalidLengthGenerated
1108 }
1109 if postIndex > l {
1110 return io.ErrUnexpectedEOF
1111 }
1112 m.Status = ConditionStatus(dAtA[iNdEx:postIndex])
1113 iNdEx = postIndex
1114 case 3:
1115 if wireType != 2 {
1116 return fmt.Errorf("proto: wrong wireType = %d for field LastProbeTime", wireType)
1117 }
1118 var msglen int
1119 for shift := uint(0); ; shift += 7 {
1120 if shift >= 64 {
1121 return ErrIntOverflowGenerated
1122 }
1123 if iNdEx >= l {
1124 return io.ErrUnexpectedEOF
1125 }
1126 b := dAtA[iNdEx]
1127 iNdEx++
1128 msglen |= int(b&0x7F) << shift
1129 if b < 0x80 {
1130 break
1131 }
1132 }
1133 if msglen < 0 {
1134 return ErrInvalidLengthGenerated
1135 }
1136 postIndex := iNdEx + msglen
1137 if postIndex < 0 {
1138 return ErrInvalidLengthGenerated
1139 }
1140 if postIndex > l {
1141 return io.ErrUnexpectedEOF
1142 }
1143 if err := m.LastProbeTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1144 return err
1145 }
1146 iNdEx = postIndex
1147 case 4:
1148 if wireType != 2 {
1149 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
1150 }
1151 var msglen int
1152 for shift := uint(0); ; shift += 7 {
1153 if shift >= 64 {
1154 return ErrIntOverflowGenerated
1155 }
1156 if iNdEx >= l {
1157 return io.ErrUnexpectedEOF
1158 }
1159 b := dAtA[iNdEx]
1160 iNdEx++
1161 msglen |= int(b&0x7F) << shift
1162 if b < 0x80 {
1163 break
1164 }
1165 }
1166 if msglen < 0 {
1167 return ErrInvalidLengthGenerated
1168 }
1169 postIndex := iNdEx + msglen
1170 if postIndex < 0 {
1171 return ErrInvalidLengthGenerated
1172 }
1173 if postIndex > l {
1174 return io.ErrUnexpectedEOF
1175 }
1176 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1177 return err
1178 }
1179 iNdEx = postIndex
1180 case 5:
1181 if wireType != 2 {
1182 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
1183 }
1184 var stringLen uint64
1185 for shift := uint(0); ; shift += 7 {
1186 if shift >= 64 {
1187 return ErrIntOverflowGenerated
1188 }
1189 if iNdEx >= l {
1190 return io.ErrUnexpectedEOF
1191 }
1192 b := dAtA[iNdEx]
1193 iNdEx++
1194 stringLen |= uint64(b&0x7F) << shift
1195 if b < 0x80 {
1196 break
1197 }
1198 }
1199 intStringLen := int(stringLen)
1200 if intStringLen < 0 {
1201 return ErrInvalidLengthGenerated
1202 }
1203 postIndex := iNdEx + intStringLen
1204 if postIndex < 0 {
1205 return ErrInvalidLengthGenerated
1206 }
1207 if postIndex > l {
1208 return io.ErrUnexpectedEOF
1209 }
1210 m.Reason = string(dAtA[iNdEx:postIndex])
1211 iNdEx = postIndex
1212 case 6:
1213 if wireType != 2 {
1214 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
1215 }
1216 var stringLen uint64
1217 for shift := uint(0); ; shift += 7 {
1218 if shift >= 64 {
1219 return ErrIntOverflowGenerated
1220 }
1221 if iNdEx >= l {
1222 return io.ErrUnexpectedEOF
1223 }
1224 b := dAtA[iNdEx]
1225 iNdEx++
1226 stringLen |= uint64(b&0x7F) << shift
1227 if b < 0x80 {
1228 break
1229 }
1230 }
1231 intStringLen := int(stringLen)
1232 if intStringLen < 0 {
1233 return ErrInvalidLengthGenerated
1234 }
1235 postIndex := iNdEx + intStringLen
1236 if postIndex < 0 {
1237 return ErrInvalidLengthGenerated
1238 }
1239 if postIndex > l {
1240 return io.ErrUnexpectedEOF
1241 }
1242 m.Message = string(dAtA[iNdEx:postIndex])
1243 iNdEx = postIndex
1244 default:
1245 iNdEx = preIndex
1246 skippy, err := skipGenerated(dAtA[iNdEx:])
1247 if err != nil {
1248 return err
1249 }
1250 if (skippy < 0) || (iNdEx+skippy) < 0 {
1251 return ErrInvalidLengthGenerated
1252 }
1253 if (iNdEx + skippy) > l {
1254 return io.ErrUnexpectedEOF
1255 }
1256 iNdEx += skippy
1257 }
1258 }
1259
1260 if iNdEx > l {
1261 return io.ErrUnexpectedEOF
1262 }
1263 return nil
1264 }
1265 func (m *CarpList) Unmarshal(dAtA []byte) error {
1266 l := len(dAtA)
1267 iNdEx := 0
1268 for iNdEx < l {
1269 preIndex := iNdEx
1270 var wire uint64
1271 for shift := uint(0); ; shift += 7 {
1272 if shift >= 64 {
1273 return ErrIntOverflowGenerated
1274 }
1275 if iNdEx >= l {
1276 return io.ErrUnexpectedEOF
1277 }
1278 b := dAtA[iNdEx]
1279 iNdEx++
1280 wire |= uint64(b&0x7F) << shift
1281 if b < 0x80 {
1282 break
1283 }
1284 }
1285 fieldNum := int32(wire >> 3)
1286 wireType := int(wire & 0x7)
1287 if wireType == 4 {
1288 return fmt.Errorf("proto: CarpList: wiretype end group for non-group")
1289 }
1290 if fieldNum <= 0 {
1291 return fmt.Errorf("proto: CarpList: illegal tag %d (wire type %d)", fieldNum, wire)
1292 }
1293 switch fieldNum {
1294 case 1:
1295 if wireType != 2 {
1296 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1297 }
1298 var msglen int
1299 for shift := uint(0); ; shift += 7 {
1300 if shift >= 64 {
1301 return ErrIntOverflowGenerated
1302 }
1303 if iNdEx >= l {
1304 return io.ErrUnexpectedEOF
1305 }
1306 b := dAtA[iNdEx]
1307 iNdEx++
1308 msglen |= int(b&0x7F) << shift
1309 if b < 0x80 {
1310 break
1311 }
1312 }
1313 if msglen < 0 {
1314 return ErrInvalidLengthGenerated
1315 }
1316 postIndex := iNdEx + msglen
1317 if postIndex < 0 {
1318 return ErrInvalidLengthGenerated
1319 }
1320 if postIndex > l {
1321 return io.ErrUnexpectedEOF
1322 }
1323 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1324 return err
1325 }
1326 iNdEx = postIndex
1327 case 2:
1328 if wireType != 2 {
1329 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1330 }
1331 var msglen int
1332 for shift := uint(0); ; shift += 7 {
1333 if shift >= 64 {
1334 return ErrIntOverflowGenerated
1335 }
1336 if iNdEx >= l {
1337 return io.ErrUnexpectedEOF
1338 }
1339 b := dAtA[iNdEx]
1340 iNdEx++
1341 msglen |= int(b&0x7F) << shift
1342 if b < 0x80 {
1343 break
1344 }
1345 }
1346 if msglen < 0 {
1347 return ErrInvalidLengthGenerated
1348 }
1349 postIndex := iNdEx + msglen
1350 if postIndex < 0 {
1351 return ErrInvalidLengthGenerated
1352 }
1353 if postIndex > l {
1354 return io.ErrUnexpectedEOF
1355 }
1356 m.Items = append(m.Items, Carp{})
1357 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1358 return err
1359 }
1360 iNdEx = postIndex
1361 default:
1362 iNdEx = preIndex
1363 skippy, err := skipGenerated(dAtA[iNdEx:])
1364 if err != nil {
1365 return err
1366 }
1367 if (skippy < 0) || (iNdEx+skippy) < 0 {
1368 return ErrInvalidLengthGenerated
1369 }
1370 if (iNdEx + skippy) > l {
1371 return io.ErrUnexpectedEOF
1372 }
1373 iNdEx += skippy
1374 }
1375 }
1376
1377 if iNdEx > l {
1378 return io.ErrUnexpectedEOF
1379 }
1380 return nil
1381 }
1382 func (m *CarpSpec) Unmarshal(dAtA []byte) error {
1383 l := len(dAtA)
1384 iNdEx := 0
1385 for iNdEx < l {
1386 preIndex := iNdEx
1387 var wire uint64
1388 for shift := uint(0); ; shift += 7 {
1389 if shift >= 64 {
1390 return ErrIntOverflowGenerated
1391 }
1392 if iNdEx >= l {
1393 return io.ErrUnexpectedEOF
1394 }
1395 b := dAtA[iNdEx]
1396 iNdEx++
1397 wire |= uint64(b&0x7F) << shift
1398 if b < 0x80 {
1399 break
1400 }
1401 }
1402 fieldNum := int32(wire >> 3)
1403 wireType := int(wire & 0x7)
1404 if wireType == 4 {
1405 return fmt.Errorf("proto: CarpSpec: wiretype end group for non-group")
1406 }
1407 if fieldNum <= 0 {
1408 return fmt.Errorf("proto: CarpSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1409 }
1410 switch fieldNum {
1411 case 3:
1412 if wireType != 2 {
1413 return fmt.Errorf("proto: wrong wireType = %d for field RestartPolicy", wireType)
1414 }
1415 var stringLen uint64
1416 for shift := uint(0); ; shift += 7 {
1417 if shift >= 64 {
1418 return ErrIntOverflowGenerated
1419 }
1420 if iNdEx >= l {
1421 return io.ErrUnexpectedEOF
1422 }
1423 b := dAtA[iNdEx]
1424 iNdEx++
1425 stringLen |= uint64(b&0x7F) << shift
1426 if b < 0x80 {
1427 break
1428 }
1429 }
1430 intStringLen := int(stringLen)
1431 if intStringLen < 0 {
1432 return ErrInvalidLengthGenerated
1433 }
1434 postIndex := iNdEx + intStringLen
1435 if postIndex < 0 {
1436 return ErrInvalidLengthGenerated
1437 }
1438 if postIndex > l {
1439 return io.ErrUnexpectedEOF
1440 }
1441 m.RestartPolicy = RestartPolicy(dAtA[iNdEx:postIndex])
1442 iNdEx = postIndex
1443 case 4:
1444 if wireType != 0 {
1445 return fmt.Errorf("proto: wrong wireType = %d for field TerminationGracePeriodSeconds", wireType)
1446 }
1447 var v int64
1448 for shift := uint(0); ; shift += 7 {
1449 if shift >= 64 {
1450 return ErrIntOverflowGenerated
1451 }
1452 if iNdEx >= l {
1453 return io.ErrUnexpectedEOF
1454 }
1455 b := dAtA[iNdEx]
1456 iNdEx++
1457 v |= int64(b&0x7F) << shift
1458 if b < 0x80 {
1459 break
1460 }
1461 }
1462 m.TerminationGracePeriodSeconds = &v
1463 case 5:
1464 if wireType != 0 {
1465 return fmt.Errorf("proto: wrong wireType = %d for field ActiveDeadlineSeconds", wireType)
1466 }
1467 var v int64
1468 for shift := uint(0); ; shift += 7 {
1469 if shift >= 64 {
1470 return ErrIntOverflowGenerated
1471 }
1472 if iNdEx >= l {
1473 return io.ErrUnexpectedEOF
1474 }
1475 b := dAtA[iNdEx]
1476 iNdEx++
1477 v |= int64(b&0x7F) << shift
1478 if b < 0x80 {
1479 break
1480 }
1481 }
1482 m.ActiveDeadlineSeconds = &v
1483 case 7:
1484 if wireType != 2 {
1485 return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
1486 }
1487 var msglen int
1488 for shift := uint(0); ; shift += 7 {
1489 if shift >= 64 {
1490 return ErrIntOverflowGenerated
1491 }
1492 if iNdEx >= l {
1493 return io.ErrUnexpectedEOF
1494 }
1495 b := dAtA[iNdEx]
1496 iNdEx++
1497 msglen |= int(b&0x7F) << shift
1498 if b < 0x80 {
1499 break
1500 }
1501 }
1502 if msglen < 0 {
1503 return ErrInvalidLengthGenerated
1504 }
1505 postIndex := iNdEx + msglen
1506 if postIndex < 0 {
1507 return ErrInvalidLengthGenerated
1508 }
1509 if postIndex > l {
1510 return io.ErrUnexpectedEOF
1511 }
1512 if m.NodeSelector == nil {
1513 m.NodeSelector = make(map[string]string)
1514 }
1515 var mapkey string
1516 var mapvalue string
1517 for iNdEx < postIndex {
1518 entryPreIndex := iNdEx
1519 var wire uint64
1520 for shift := uint(0); ; shift += 7 {
1521 if shift >= 64 {
1522 return ErrIntOverflowGenerated
1523 }
1524 if iNdEx >= l {
1525 return io.ErrUnexpectedEOF
1526 }
1527 b := dAtA[iNdEx]
1528 iNdEx++
1529 wire |= uint64(b&0x7F) << shift
1530 if b < 0x80 {
1531 break
1532 }
1533 }
1534 fieldNum := int32(wire >> 3)
1535 if fieldNum == 1 {
1536 var stringLenmapkey uint64
1537 for shift := uint(0); ; shift += 7 {
1538 if shift >= 64 {
1539 return ErrIntOverflowGenerated
1540 }
1541 if iNdEx >= l {
1542 return io.ErrUnexpectedEOF
1543 }
1544 b := dAtA[iNdEx]
1545 iNdEx++
1546 stringLenmapkey |= uint64(b&0x7F) << shift
1547 if b < 0x80 {
1548 break
1549 }
1550 }
1551 intStringLenmapkey := int(stringLenmapkey)
1552 if intStringLenmapkey < 0 {
1553 return ErrInvalidLengthGenerated
1554 }
1555 postStringIndexmapkey := iNdEx + intStringLenmapkey
1556 if postStringIndexmapkey < 0 {
1557 return ErrInvalidLengthGenerated
1558 }
1559 if postStringIndexmapkey > l {
1560 return io.ErrUnexpectedEOF
1561 }
1562 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1563 iNdEx = postStringIndexmapkey
1564 } else if fieldNum == 2 {
1565 var stringLenmapvalue uint64
1566 for shift := uint(0); ; shift += 7 {
1567 if shift >= 64 {
1568 return ErrIntOverflowGenerated
1569 }
1570 if iNdEx >= l {
1571 return io.ErrUnexpectedEOF
1572 }
1573 b := dAtA[iNdEx]
1574 iNdEx++
1575 stringLenmapvalue |= uint64(b&0x7F) << shift
1576 if b < 0x80 {
1577 break
1578 }
1579 }
1580 intStringLenmapvalue := int(stringLenmapvalue)
1581 if intStringLenmapvalue < 0 {
1582 return ErrInvalidLengthGenerated
1583 }
1584 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
1585 if postStringIndexmapvalue < 0 {
1586 return ErrInvalidLengthGenerated
1587 }
1588 if postStringIndexmapvalue > l {
1589 return io.ErrUnexpectedEOF
1590 }
1591 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
1592 iNdEx = postStringIndexmapvalue
1593 } else {
1594 iNdEx = entryPreIndex
1595 skippy, err := skipGenerated(dAtA[iNdEx:])
1596 if err != nil {
1597 return err
1598 }
1599 if (skippy < 0) || (iNdEx+skippy) < 0 {
1600 return ErrInvalidLengthGenerated
1601 }
1602 if (iNdEx + skippy) > postIndex {
1603 return io.ErrUnexpectedEOF
1604 }
1605 iNdEx += skippy
1606 }
1607 }
1608 m.NodeSelector[mapkey] = mapvalue
1609 iNdEx = postIndex
1610 case 8:
1611 if wireType != 2 {
1612 return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccountName", wireType)
1613 }
1614 var stringLen uint64
1615 for shift := uint(0); ; shift += 7 {
1616 if shift >= 64 {
1617 return ErrIntOverflowGenerated
1618 }
1619 if iNdEx >= l {
1620 return io.ErrUnexpectedEOF
1621 }
1622 b := dAtA[iNdEx]
1623 iNdEx++
1624 stringLen |= uint64(b&0x7F) << shift
1625 if b < 0x80 {
1626 break
1627 }
1628 }
1629 intStringLen := int(stringLen)
1630 if intStringLen < 0 {
1631 return ErrInvalidLengthGenerated
1632 }
1633 postIndex := iNdEx + intStringLen
1634 if postIndex < 0 {
1635 return ErrInvalidLengthGenerated
1636 }
1637 if postIndex > l {
1638 return io.ErrUnexpectedEOF
1639 }
1640 m.ServiceAccountName = string(dAtA[iNdEx:postIndex])
1641 iNdEx = postIndex
1642 case 9:
1643 if wireType != 2 {
1644 return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedServiceAccount", wireType)
1645 }
1646 var stringLen uint64
1647 for shift := uint(0); ; shift += 7 {
1648 if shift >= 64 {
1649 return ErrIntOverflowGenerated
1650 }
1651 if iNdEx >= l {
1652 return io.ErrUnexpectedEOF
1653 }
1654 b := dAtA[iNdEx]
1655 iNdEx++
1656 stringLen |= uint64(b&0x7F) << shift
1657 if b < 0x80 {
1658 break
1659 }
1660 }
1661 intStringLen := int(stringLen)
1662 if intStringLen < 0 {
1663 return ErrInvalidLengthGenerated
1664 }
1665 postIndex := iNdEx + intStringLen
1666 if postIndex < 0 {
1667 return ErrInvalidLengthGenerated
1668 }
1669 if postIndex > l {
1670 return io.ErrUnexpectedEOF
1671 }
1672 m.DeprecatedServiceAccount = string(dAtA[iNdEx:postIndex])
1673 iNdEx = postIndex
1674 case 10:
1675 if wireType != 2 {
1676 return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
1677 }
1678 var stringLen uint64
1679 for shift := uint(0); ; shift += 7 {
1680 if shift >= 64 {
1681 return ErrIntOverflowGenerated
1682 }
1683 if iNdEx >= l {
1684 return io.ErrUnexpectedEOF
1685 }
1686 b := dAtA[iNdEx]
1687 iNdEx++
1688 stringLen |= uint64(b&0x7F) << shift
1689 if b < 0x80 {
1690 break
1691 }
1692 }
1693 intStringLen := int(stringLen)
1694 if intStringLen < 0 {
1695 return ErrInvalidLengthGenerated
1696 }
1697 postIndex := iNdEx + intStringLen
1698 if postIndex < 0 {
1699 return ErrInvalidLengthGenerated
1700 }
1701 if postIndex > l {
1702 return io.ErrUnexpectedEOF
1703 }
1704 m.NodeName = string(dAtA[iNdEx:postIndex])
1705 iNdEx = postIndex
1706 case 11:
1707 if wireType != 0 {
1708 return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType)
1709 }
1710 var v int
1711 for shift := uint(0); ; shift += 7 {
1712 if shift >= 64 {
1713 return ErrIntOverflowGenerated
1714 }
1715 if iNdEx >= l {
1716 return io.ErrUnexpectedEOF
1717 }
1718 b := dAtA[iNdEx]
1719 iNdEx++
1720 v |= int(b&0x7F) << shift
1721 if b < 0x80 {
1722 break
1723 }
1724 }
1725 m.HostNetwork = bool(v != 0)
1726 case 12:
1727 if wireType != 0 {
1728 return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType)
1729 }
1730 var v int
1731 for shift := uint(0); ; shift += 7 {
1732 if shift >= 64 {
1733 return ErrIntOverflowGenerated
1734 }
1735 if iNdEx >= l {
1736 return io.ErrUnexpectedEOF
1737 }
1738 b := dAtA[iNdEx]
1739 iNdEx++
1740 v |= int(b&0x7F) << shift
1741 if b < 0x80 {
1742 break
1743 }
1744 }
1745 m.HostPID = bool(v != 0)
1746 case 13:
1747 if wireType != 0 {
1748 return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType)
1749 }
1750 var v int
1751 for shift := uint(0); ; shift += 7 {
1752 if shift >= 64 {
1753 return ErrIntOverflowGenerated
1754 }
1755 if iNdEx >= l {
1756 return io.ErrUnexpectedEOF
1757 }
1758 b := dAtA[iNdEx]
1759 iNdEx++
1760 v |= int(b&0x7F) << shift
1761 if b < 0x80 {
1762 break
1763 }
1764 }
1765 m.HostIPC = bool(v != 0)
1766 case 16:
1767 if wireType != 2 {
1768 return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
1769 }
1770 var stringLen uint64
1771 for shift := uint(0); ; shift += 7 {
1772 if shift >= 64 {
1773 return ErrIntOverflowGenerated
1774 }
1775 if iNdEx >= l {
1776 return io.ErrUnexpectedEOF
1777 }
1778 b := dAtA[iNdEx]
1779 iNdEx++
1780 stringLen |= uint64(b&0x7F) << shift
1781 if b < 0x80 {
1782 break
1783 }
1784 }
1785 intStringLen := int(stringLen)
1786 if intStringLen < 0 {
1787 return ErrInvalidLengthGenerated
1788 }
1789 postIndex := iNdEx + intStringLen
1790 if postIndex < 0 {
1791 return ErrInvalidLengthGenerated
1792 }
1793 if postIndex > l {
1794 return io.ErrUnexpectedEOF
1795 }
1796 m.Hostname = string(dAtA[iNdEx:postIndex])
1797 iNdEx = postIndex
1798 case 17:
1799 if wireType != 2 {
1800 return fmt.Errorf("proto: wrong wireType = %d for field Subdomain", wireType)
1801 }
1802 var stringLen uint64
1803 for shift := uint(0); ; shift += 7 {
1804 if shift >= 64 {
1805 return ErrIntOverflowGenerated
1806 }
1807 if iNdEx >= l {
1808 return io.ErrUnexpectedEOF
1809 }
1810 b := dAtA[iNdEx]
1811 iNdEx++
1812 stringLen |= uint64(b&0x7F) << shift
1813 if b < 0x80 {
1814 break
1815 }
1816 }
1817 intStringLen := int(stringLen)
1818 if intStringLen < 0 {
1819 return ErrInvalidLengthGenerated
1820 }
1821 postIndex := iNdEx + intStringLen
1822 if postIndex < 0 {
1823 return ErrInvalidLengthGenerated
1824 }
1825 if postIndex > l {
1826 return io.ErrUnexpectedEOF
1827 }
1828 m.Subdomain = string(dAtA[iNdEx:postIndex])
1829 iNdEx = postIndex
1830 case 19:
1831 if wireType != 2 {
1832 return fmt.Errorf("proto: wrong wireType = %d for field SchedulerName", wireType)
1833 }
1834 var stringLen uint64
1835 for shift := uint(0); ; shift += 7 {
1836 if shift >= 64 {
1837 return ErrIntOverflowGenerated
1838 }
1839 if iNdEx >= l {
1840 return io.ErrUnexpectedEOF
1841 }
1842 b := dAtA[iNdEx]
1843 iNdEx++
1844 stringLen |= uint64(b&0x7F) << shift
1845 if b < 0x80 {
1846 break
1847 }
1848 }
1849 intStringLen := int(stringLen)
1850 if intStringLen < 0 {
1851 return ErrInvalidLengthGenerated
1852 }
1853 postIndex := iNdEx + intStringLen
1854 if postIndex < 0 {
1855 return ErrInvalidLengthGenerated
1856 }
1857 if postIndex > l {
1858 return io.ErrUnexpectedEOF
1859 }
1860 m.SchedulerName = string(dAtA[iNdEx:postIndex])
1861 iNdEx = postIndex
1862 default:
1863 iNdEx = preIndex
1864 skippy, err := skipGenerated(dAtA[iNdEx:])
1865 if err != nil {
1866 return err
1867 }
1868 if (skippy < 0) || (iNdEx+skippy) < 0 {
1869 return ErrInvalidLengthGenerated
1870 }
1871 if (iNdEx + skippy) > l {
1872 return io.ErrUnexpectedEOF
1873 }
1874 iNdEx += skippy
1875 }
1876 }
1877
1878 if iNdEx > l {
1879 return io.ErrUnexpectedEOF
1880 }
1881 return nil
1882 }
1883 func (m *CarpStatus) Unmarshal(dAtA []byte) error {
1884 l := len(dAtA)
1885 iNdEx := 0
1886 for iNdEx < l {
1887 preIndex := iNdEx
1888 var wire uint64
1889 for shift := uint(0); ; shift += 7 {
1890 if shift >= 64 {
1891 return ErrIntOverflowGenerated
1892 }
1893 if iNdEx >= l {
1894 return io.ErrUnexpectedEOF
1895 }
1896 b := dAtA[iNdEx]
1897 iNdEx++
1898 wire |= uint64(b&0x7F) << shift
1899 if b < 0x80 {
1900 break
1901 }
1902 }
1903 fieldNum := int32(wire >> 3)
1904 wireType := int(wire & 0x7)
1905 if wireType == 4 {
1906 return fmt.Errorf("proto: CarpStatus: wiretype end group for non-group")
1907 }
1908 if fieldNum <= 0 {
1909 return fmt.Errorf("proto: CarpStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1910 }
1911 switch fieldNum {
1912 case 1:
1913 if wireType != 2 {
1914 return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
1915 }
1916 var stringLen uint64
1917 for shift := uint(0); ; shift += 7 {
1918 if shift >= 64 {
1919 return ErrIntOverflowGenerated
1920 }
1921 if iNdEx >= l {
1922 return io.ErrUnexpectedEOF
1923 }
1924 b := dAtA[iNdEx]
1925 iNdEx++
1926 stringLen |= uint64(b&0x7F) << shift
1927 if b < 0x80 {
1928 break
1929 }
1930 }
1931 intStringLen := int(stringLen)
1932 if intStringLen < 0 {
1933 return ErrInvalidLengthGenerated
1934 }
1935 postIndex := iNdEx + intStringLen
1936 if postIndex < 0 {
1937 return ErrInvalidLengthGenerated
1938 }
1939 if postIndex > l {
1940 return io.ErrUnexpectedEOF
1941 }
1942 m.Phase = CarpPhase(dAtA[iNdEx:postIndex])
1943 iNdEx = postIndex
1944 case 2:
1945 if wireType != 2 {
1946 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
1947 }
1948 var msglen int
1949 for shift := uint(0); ; shift += 7 {
1950 if shift >= 64 {
1951 return ErrIntOverflowGenerated
1952 }
1953 if iNdEx >= l {
1954 return io.ErrUnexpectedEOF
1955 }
1956 b := dAtA[iNdEx]
1957 iNdEx++
1958 msglen |= int(b&0x7F) << shift
1959 if b < 0x80 {
1960 break
1961 }
1962 }
1963 if msglen < 0 {
1964 return ErrInvalidLengthGenerated
1965 }
1966 postIndex := iNdEx + msglen
1967 if postIndex < 0 {
1968 return ErrInvalidLengthGenerated
1969 }
1970 if postIndex > l {
1971 return io.ErrUnexpectedEOF
1972 }
1973 m.Conditions = append(m.Conditions, CarpCondition{})
1974 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1975 return err
1976 }
1977 iNdEx = postIndex
1978 case 3:
1979 if wireType != 2 {
1980 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
1981 }
1982 var stringLen uint64
1983 for shift := uint(0); ; shift += 7 {
1984 if shift >= 64 {
1985 return ErrIntOverflowGenerated
1986 }
1987 if iNdEx >= l {
1988 return io.ErrUnexpectedEOF
1989 }
1990 b := dAtA[iNdEx]
1991 iNdEx++
1992 stringLen |= uint64(b&0x7F) << shift
1993 if b < 0x80 {
1994 break
1995 }
1996 }
1997 intStringLen := int(stringLen)
1998 if intStringLen < 0 {
1999 return ErrInvalidLengthGenerated
2000 }
2001 postIndex := iNdEx + intStringLen
2002 if postIndex < 0 {
2003 return ErrInvalidLengthGenerated
2004 }
2005 if postIndex > l {
2006 return io.ErrUnexpectedEOF
2007 }
2008 m.Message = string(dAtA[iNdEx:postIndex])
2009 iNdEx = postIndex
2010 case 4:
2011 if wireType != 2 {
2012 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
2013 }
2014 var stringLen uint64
2015 for shift := uint(0); ; shift += 7 {
2016 if shift >= 64 {
2017 return ErrIntOverflowGenerated
2018 }
2019 if iNdEx >= l {
2020 return io.ErrUnexpectedEOF
2021 }
2022 b := dAtA[iNdEx]
2023 iNdEx++
2024 stringLen |= uint64(b&0x7F) << shift
2025 if b < 0x80 {
2026 break
2027 }
2028 }
2029 intStringLen := int(stringLen)
2030 if intStringLen < 0 {
2031 return ErrInvalidLengthGenerated
2032 }
2033 postIndex := iNdEx + intStringLen
2034 if postIndex < 0 {
2035 return ErrInvalidLengthGenerated
2036 }
2037 if postIndex > l {
2038 return io.ErrUnexpectedEOF
2039 }
2040 m.Reason = string(dAtA[iNdEx:postIndex])
2041 iNdEx = postIndex
2042 case 5:
2043 if wireType != 2 {
2044 return fmt.Errorf("proto: wrong wireType = %d for field HostIP", wireType)
2045 }
2046 var stringLen uint64
2047 for shift := uint(0); ; shift += 7 {
2048 if shift >= 64 {
2049 return ErrIntOverflowGenerated
2050 }
2051 if iNdEx >= l {
2052 return io.ErrUnexpectedEOF
2053 }
2054 b := dAtA[iNdEx]
2055 iNdEx++
2056 stringLen |= uint64(b&0x7F) << shift
2057 if b < 0x80 {
2058 break
2059 }
2060 }
2061 intStringLen := int(stringLen)
2062 if intStringLen < 0 {
2063 return ErrInvalidLengthGenerated
2064 }
2065 postIndex := iNdEx + intStringLen
2066 if postIndex < 0 {
2067 return ErrInvalidLengthGenerated
2068 }
2069 if postIndex > l {
2070 return io.ErrUnexpectedEOF
2071 }
2072 m.HostIP = string(dAtA[iNdEx:postIndex])
2073 iNdEx = postIndex
2074 case 6:
2075 if wireType != 2 {
2076 return fmt.Errorf("proto: wrong wireType = %d for field CarpIP", wireType)
2077 }
2078 var stringLen uint64
2079 for shift := uint(0); ; shift += 7 {
2080 if shift >= 64 {
2081 return ErrIntOverflowGenerated
2082 }
2083 if iNdEx >= l {
2084 return io.ErrUnexpectedEOF
2085 }
2086 b := dAtA[iNdEx]
2087 iNdEx++
2088 stringLen |= uint64(b&0x7F) << shift
2089 if b < 0x80 {
2090 break
2091 }
2092 }
2093 intStringLen := int(stringLen)
2094 if intStringLen < 0 {
2095 return ErrInvalidLengthGenerated
2096 }
2097 postIndex := iNdEx + intStringLen
2098 if postIndex < 0 {
2099 return ErrInvalidLengthGenerated
2100 }
2101 if postIndex > l {
2102 return io.ErrUnexpectedEOF
2103 }
2104 m.CarpIP = string(dAtA[iNdEx:postIndex])
2105 iNdEx = postIndex
2106 case 7:
2107 if wireType != 2 {
2108 return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
2109 }
2110 var msglen int
2111 for shift := uint(0); ; shift += 7 {
2112 if shift >= 64 {
2113 return ErrIntOverflowGenerated
2114 }
2115 if iNdEx >= l {
2116 return io.ErrUnexpectedEOF
2117 }
2118 b := dAtA[iNdEx]
2119 iNdEx++
2120 msglen |= int(b&0x7F) << shift
2121 if b < 0x80 {
2122 break
2123 }
2124 }
2125 if msglen < 0 {
2126 return ErrInvalidLengthGenerated
2127 }
2128 postIndex := iNdEx + msglen
2129 if postIndex < 0 {
2130 return ErrInvalidLengthGenerated
2131 }
2132 if postIndex > l {
2133 return io.ErrUnexpectedEOF
2134 }
2135 if m.StartTime == nil {
2136 m.StartTime = &v1.Time{}
2137 }
2138 if err := m.StartTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2139 return err
2140 }
2141 iNdEx = postIndex
2142 default:
2143 iNdEx = preIndex
2144 skippy, err := skipGenerated(dAtA[iNdEx:])
2145 if err != nil {
2146 return err
2147 }
2148 if (skippy < 0) || (iNdEx+skippy) < 0 {
2149 return ErrInvalidLengthGenerated
2150 }
2151 if (iNdEx + skippy) > l {
2152 return io.ErrUnexpectedEOF
2153 }
2154 iNdEx += skippy
2155 }
2156 }
2157
2158 if iNdEx > l {
2159 return io.ErrUnexpectedEOF
2160 }
2161 return nil
2162 }
2163 func skipGenerated(dAtA []byte) (n int, err error) {
2164 l := len(dAtA)
2165 iNdEx := 0
2166 depth := 0
2167 for iNdEx < l {
2168 var wire uint64
2169 for shift := uint(0); ; shift += 7 {
2170 if shift >= 64 {
2171 return 0, ErrIntOverflowGenerated
2172 }
2173 if iNdEx >= l {
2174 return 0, io.ErrUnexpectedEOF
2175 }
2176 b := dAtA[iNdEx]
2177 iNdEx++
2178 wire |= (uint64(b) & 0x7F) << shift
2179 if b < 0x80 {
2180 break
2181 }
2182 }
2183 wireType := int(wire & 0x7)
2184 switch wireType {
2185 case 0:
2186 for shift := uint(0); ; shift += 7 {
2187 if shift >= 64 {
2188 return 0, ErrIntOverflowGenerated
2189 }
2190 if iNdEx >= l {
2191 return 0, io.ErrUnexpectedEOF
2192 }
2193 iNdEx++
2194 if dAtA[iNdEx-1] < 0x80 {
2195 break
2196 }
2197 }
2198 case 1:
2199 iNdEx += 8
2200 case 2:
2201 var length int
2202 for shift := uint(0); ; shift += 7 {
2203 if shift >= 64 {
2204 return 0, ErrIntOverflowGenerated
2205 }
2206 if iNdEx >= l {
2207 return 0, io.ErrUnexpectedEOF
2208 }
2209 b := dAtA[iNdEx]
2210 iNdEx++
2211 length |= (int(b) & 0x7F) << shift
2212 if b < 0x80 {
2213 break
2214 }
2215 }
2216 if length < 0 {
2217 return 0, ErrInvalidLengthGenerated
2218 }
2219 iNdEx += length
2220 case 3:
2221 depth++
2222 case 4:
2223 if depth == 0 {
2224 return 0, ErrUnexpectedEndOfGroupGenerated
2225 }
2226 depth--
2227 case 5:
2228 iNdEx += 4
2229 default:
2230 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2231 }
2232 if iNdEx < 0 {
2233 return 0, ErrInvalidLengthGenerated
2234 }
2235 if depth == 0 {
2236 return iNdEx, nil
2237 }
2238 }
2239 return 0, io.ErrUnexpectedEOF
2240 }
2241
2242 var (
2243 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
2244 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
2245 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
2246 )
2247
View as plain text