1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto 3 4package namespaces 5 6import ( 7 context "context" 8 fmt "fmt" 9 proto "github.com/gogo/protobuf/proto" 10 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" 11 types "github.com/gogo/protobuf/types" 12 grpc "google.golang.org/grpc" 13 codes "google.golang.org/grpc/codes" 14 status "google.golang.org/grpc/status" 15 io "io" 16 math "math" 17 math_bits "math/bits" 18 reflect "reflect" 19 strings "strings" 20) 21 22// Reference imports to suppress errors if they are not otherwise used. 23var _ = proto.Marshal 24var _ = fmt.Errorf 25var _ = math.Inf 26 27// This is a compile-time assertion to ensure that this generated file 28// is compatible with the proto package it is being compiled against. 29// A compilation error at this line likely means your copy of the 30// proto package needs to be updated. 31const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 32 33type Namespace struct { 34 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 35 // Labels provides an area to include arbitrary data on namespaces. 36 // 37 // The combined size of a key/value pair cannot exceed 4096 bytes. 38 // 39 // Note that to add a new value to this field, read the existing set and 40 // include the entire result in the update call. 41 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"` 42 XXX_NoUnkeyedLiteral struct{} `json:"-"` 43 XXX_unrecognized []byte `json:"-"` 44 XXX_sizecache int32 `json:"-"` 45} 46 47func (m *Namespace) Reset() { *m = Namespace{} } 48func (*Namespace) ProtoMessage() {} 49func (*Namespace) Descriptor() ([]byte, []int) { 50 return fileDescriptor_8c41761eaeea4fd3, []int{0} 51} 52func (m *Namespace) XXX_Unmarshal(b []byte) error { 53 return m.Unmarshal(b) 54} 55func (m *Namespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 56 if deterministic { 57 return xxx_messageInfo_Namespace.Marshal(b, m, deterministic) 58 } else { 59 b = b[:cap(b)] 60 n, err := m.MarshalToSizedBuffer(b) 61 if err != nil { 62 return nil, err 63 } 64 return b[:n], nil 65 } 66} 67func (m *Namespace) XXX_Merge(src proto.Message) { 68 xxx_messageInfo_Namespace.Merge(m, src) 69} 70func (m *Namespace) XXX_Size() int { 71 return m.Size() 72} 73func (m *Namespace) XXX_DiscardUnknown() { 74 xxx_messageInfo_Namespace.DiscardUnknown(m) 75} 76 77var xxx_messageInfo_Namespace proto.InternalMessageInfo 78 79type GetNamespaceRequest struct { 80 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 81 XXX_NoUnkeyedLiteral struct{} `json:"-"` 82 XXX_unrecognized []byte `json:"-"` 83 XXX_sizecache int32 `json:"-"` 84} 85 86func (m *GetNamespaceRequest) Reset() { *m = GetNamespaceRequest{} } 87func (*GetNamespaceRequest) ProtoMessage() {} 88func (*GetNamespaceRequest) Descriptor() ([]byte, []int) { 89 return fileDescriptor_8c41761eaeea4fd3, []int{1} 90} 91func (m *GetNamespaceRequest) XXX_Unmarshal(b []byte) error { 92 return m.Unmarshal(b) 93} 94func (m *GetNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 95 if deterministic { 96 return xxx_messageInfo_GetNamespaceRequest.Marshal(b, m, deterministic) 97 } else { 98 b = b[:cap(b)] 99 n, err := m.MarshalToSizedBuffer(b) 100 if err != nil { 101 return nil, err 102 } 103 return b[:n], nil 104 } 105} 106func (m *GetNamespaceRequest) XXX_Merge(src proto.Message) { 107 xxx_messageInfo_GetNamespaceRequest.Merge(m, src) 108} 109func (m *GetNamespaceRequest) XXX_Size() int { 110 return m.Size() 111} 112func (m *GetNamespaceRequest) XXX_DiscardUnknown() { 113 xxx_messageInfo_GetNamespaceRequest.DiscardUnknown(m) 114} 115 116var xxx_messageInfo_GetNamespaceRequest proto.InternalMessageInfo 117 118type GetNamespaceResponse struct { 119 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` 120 XXX_NoUnkeyedLiteral struct{} `json:"-"` 121 XXX_unrecognized []byte `json:"-"` 122 XXX_sizecache int32 `json:"-"` 123} 124 125func (m *GetNamespaceResponse) Reset() { *m = GetNamespaceResponse{} } 126func (*GetNamespaceResponse) ProtoMessage() {} 127func (*GetNamespaceResponse) Descriptor() ([]byte, []int) { 128 return fileDescriptor_8c41761eaeea4fd3, []int{2} 129} 130func (m *GetNamespaceResponse) XXX_Unmarshal(b []byte) error { 131 return m.Unmarshal(b) 132} 133func (m *GetNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 134 if deterministic { 135 return xxx_messageInfo_GetNamespaceResponse.Marshal(b, m, deterministic) 136 } else { 137 b = b[:cap(b)] 138 n, err := m.MarshalToSizedBuffer(b) 139 if err != nil { 140 return nil, err 141 } 142 return b[:n], nil 143 } 144} 145func (m *GetNamespaceResponse) XXX_Merge(src proto.Message) { 146 xxx_messageInfo_GetNamespaceResponse.Merge(m, src) 147} 148func (m *GetNamespaceResponse) XXX_Size() int { 149 return m.Size() 150} 151func (m *GetNamespaceResponse) XXX_DiscardUnknown() { 152 xxx_messageInfo_GetNamespaceResponse.DiscardUnknown(m) 153} 154 155var xxx_messageInfo_GetNamespaceResponse proto.InternalMessageInfo 156 157type ListNamespacesRequest struct { 158 Filter string `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` 159 XXX_NoUnkeyedLiteral struct{} `json:"-"` 160 XXX_unrecognized []byte `json:"-"` 161 XXX_sizecache int32 `json:"-"` 162} 163 164func (m *ListNamespacesRequest) Reset() { *m = ListNamespacesRequest{} } 165func (*ListNamespacesRequest) ProtoMessage() {} 166func (*ListNamespacesRequest) Descriptor() ([]byte, []int) { 167 return fileDescriptor_8c41761eaeea4fd3, []int{3} 168} 169func (m *ListNamespacesRequest) XXX_Unmarshal(b []byte) error { 170 return m.Unmarshal(b) 171} 172func (m *ListNamespacesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 173 if deterministic { 174 return xxx_messageInfo_ListNamespacesRequest.Marshal(b, m, deterministic) 175 } else { 176 b = b[:cap(b)] 177 n, err := m.MarshalToSizedBuffer(b) 178 if err != nil { 179 return nil, err 180 } 181 return b[:n], nil 182 } 183} 184func (m *ListNamespacesRequest) XXX_Merge(src proto.Message) { 185 xxx_messageInfo_ListNamespacesRequest.Merge(m, src) 186} 187func (m *ListNamespacesRequest) XXX_Size() int { 188 return m.Size() 189} 190func (m *ListNamespacesRequest) XXX_DiscardUnknown() { 191 xxx_messageInfo_ListNamespacesRequest.DiscardUnknown(m) 192} 193 194var xxx_messageInfo_ListNamespacesRequest proto.InternalMessageInfo 195 196type ListNamespacesResponse struct { 197 Namespaces []Namespace `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces"` 198 XXX_NoUnkeyedLiteral struct{} `json:"-"` 199 XXX_unrecognized []byte `json:"-"` 200 XXX_sizecache int32 `json:"-"` 201} 202 203func (m *ListNamespacesResponse) Reset() { *m = ListNamespacesResponse{} } 204func (*ListNamespacesResponse) ProtoMessage() {} 205func (*ListNamespacesResponse) Descriptor() ([]byte, []int) { 206 return fileDescriptor_8c41761eaeea4fd3, []int{4} 207} 208func (m *ListNamespacesResponse) XXX_Unmarshal(b []byte) error { 209 return m.Unmarshal(b) 210} 211func (m *ListNamespacesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 212 if deterministic { 213 return xxx_messageInfo_ListNamespacesResponse.Marshal(b, m, deterministic) 214 } else { 215 b = b[:cap(b)] 216 n, err := m.MarshalToSizedBuffer(b) 217 if err != nil { 218 return nil, err 219 } 220 return b[:n], nil 221 } 222} 223func (m *ListNamespacesResponse) XXX_Merge(src proto.Message) { 224 xxx_messageInfo_ListNamespacesResponse.Merge(m, src) 225} 226func (m *ListNamespacesResponse) XXX_Size() int { 227 return m.Size() 228} 229func (m *ListNamespacesResponse) XXX_DiscardUnknown() { 230 xxx_messageInfo_ListNamespacesResponse.DiscardUnknown(m) 231} 232 233var xxx_messageInfo_ListNamespacesResponse proto.InternalMessageInfo 234 235type CreateNamespaceRequest struct { 236 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` 237 XXX_NoUnkeyedLiteral struct{} `json:"-"` 238 XXX_unrecognized []byte `json:"-"` 239 XXX_sizecache int32 `json:"-"` 240} 241 242func (m *CreateNamespaceRequest) Reset() { *m = CreateNamespaceRequest{} } 243func (*CreateNamespaceRequest) ProtoMessage() {} 244func (*CreateNamespaceRequest) Descriptor() ([]byte, []int) { 245 return fileDescriptor_8c41761eaeea4fd3, []int{5} 246} 247func (m *CreateNamespaceRequest) XXX_Unmarshal(b []byte) error { 248 return m.Unmarshal(b) 249} 250func (m *CreateNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 251 if deterministic { 252 return xxx_messageInfo_CreateNamespaceRequest.Marshal(b, m, deterministic) 253 } else { 254 b = b[:cap(b)] 255 n, err := m.MarshalToSizedBuffer(b) 256 if err != nil { 257 return nil, err 258 } 259 return b[:n], nil 260 } 261} 262func (m *CreateNamespaceRequest) XXX_Merge(src proto.Message) { 263 xxx_messageInfo_CreateNamespaceRequest.Merge(m, src) 264} 265func (m *CreateNamespaceRequest) XXX_Size() int { 266 return m.Size() 267} 268func (m *CreateNamespaceRequest) XXX_DiscardUnknown() { 269 xxx_messageInfo_CreateNamespaceRequest.DiscardUnknown(m) 270} 271 272var xxx_messageInfo_CreateNamespaceRequest proto.InternalMessageInfo 273 274type CreateNamespaceResponse struct { 275 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` 276 XXX_NoUnkeyedLiteral struct{} `json:"-"` 277 XXX_unrecognized []byte `json:"-"` 278 XXX_sizecache int32 `json:"-"` 279} 280 281func (m *CreateNamespaceResponse) Reset() { *m = CreateNamespaceResponse{} } 282func (*CreateNamespaceResponse) ProtoMessage() {} 283func (*CreateNamespaceResponse) Descriptor() ([]byte, []int) { 284 return fileDescriptor_8c41761eaeea4fd3, []int{6} 285} 286func (m *CreateNamespaceResponse) XXX_Unmarshal(b []byte) error { 287 return m.Unmarshal(b) 288} 289func (m *CreateNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 290 if deterministic { 291 return xxx_messageInfo_CreateNamespaceResponse.Marshal(b, m, deterministic) 292 } else { 293 b = b[:cap(b)] 294 n, err := m.MarshalToSizedBuffer(b) 295 if err != nil { 296 return nil, err 297 } 298 return b[:n], nil 299 } 300} 301func (m *CreateNamespaceResponse) XXX_Merge(src proto.Message) { 302 xxx_messageInfo_CreateNamespaceResponse.Merge(m, src) 303} 304func (m *CreateNamespaceResponse) XXX_Size() int { 305 return m.Size() 306} 307func (m *CreateNamespaceResponse) XXX_DiscardUnknown() { 308 xxx_messageInfo_CreateNamespaceResponse.DiscardUnknown(m) 309} 310 311var xxx_messageInfo_CreateNamespaceResponse proto.InternalMessageInfo 312 313// UpdateNamespaceRequest updates the metadata for a namespace. 314// 315// The operation should follow semantics described in 316// https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/field-mask, 317// unless otherwise qualified. 318type UpdateNamespaceRequest struct { 319 // Namespace provides the target value, as declared by the mask, for the update. 320 // 321 // The namespace field must be set. 322 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` 323 // UpdateMask specifies which fields to perform the update on. If empty, 324 // the operation applies to all fields. 325 // 326 // For the most part, this applies only to selectively updating labels on 327 // the namespace. While field masks are typically limited to ascii alphas 328 // and digits, we just take everything after the "labels." as the map key. 329 UpdateMask *types.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` 330 XXX_NoUnkeyedLiteral struct{} `json:"-"` 331 XXX_unrecognized []byte `json:"-"` 332 XXX_sizecache int32 `json:"-"` 333} 334 335func (m *UpdateNamespaceRequest) Reset() { *m = UpdateNamespaceRequest{} } 336func (*UpdateNamespaceRequest) ProtoMessage() {} 337func (*UpdateNamespaceRequest) Descriptor() ([]byte, []int) { 338 return fileDescriptor_8c41761eaeea4fd3, []int{7} 339} 340func (m *UpdateNamespaceRequest) XXX_Unmarshal(b []byte) error { 341 return m.Unmarshal(b) 342} 343func (m *UpdateNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 344 if deterministic { 345 return xxx_messageInfo_UpdateNamespaceRequest.Marshal(b, m, deterministic) 346 } else { 347 b = b[:cap(b)] 348 n, err := m.MarshalToSizedBuffer(b) 349 if err != nil { 350 return nil, err 351 } 352 return b[:n], nil 353 } 354} 355func (m *UpdateNamespaceRequest) XXX_Merge(src proto.Message) { 356 xxx_messageInfo_UpdateNamespaceRequest.Merge(m, src) 357} 358func (m *UpdateNamespaceRequest) XXX_Size() int { 359 return m.Size() 360} 361func (m *UpdateNamespaceRequest) XXX_DiscardUnknown() { 362 xxx_messageInfo_UpdateNamespaceRequest.DiscardUnknown(m) 363} 364 365var xxx_messageInfo_UpdateNamespaceRequest proto.InternalMessageInfo 366 367type UpdateNamespaceResponse struct { 368 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` 369 XXX_NoUnkeyedLiteral struct{} `json:"-"` 370 XXX_unrecognized []byte `json:"-"` 371 XXX_sizecache int32 `json:"-"` 372} 373 374func (m *UpdateNamespaceResponse) Reset() { *m = UpdateNamespaceResponse{} } 375func (*UpdateNamespaceResponse) ProtoMessage() {} 376func (*UpdateNamespaceResponse) Descriptor() ([]byte, []int) { 377 return fileDescriptor_8c41761eaeea4fd3, []int{8} 378} 379func (m *UpdateNamespaceResponse) XXX_Unmarshal(b []byte) error { 380 return m.Unmarshal(b) 381} 382func (m *UpdateNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 383 if deterministic { 384 return xxx_messageInfo_UpdateNamespaceResponse.Marshal(b, m, deterministic) 385 } else { 386 b = b[:cap(b)] 387 n, err := m.MarshalToSizedBuffer(b) 388 if err != nil { 389 return nil, err 390 } 391 return b[:n], nil 392 } 393} 394func (m *UpdateNamespaceResponse) XXX_Merge(src proto.Message) { 395 xxx_messageInfo_UpdateNamespaceResponse.Merge(m, src) 396} 397func (m *UpdateNamespaceResponse) XXX_Size() int { 398 return m.Size() 399} 400func (m *UpdateNamespaceResponse) XXX_DiscardUnknown() { 401 xxx_messageInfo_UpdateNamespaceResponse.DiscardUnknown(m) 402} 403 404var xxx_messageInfo_UpdateNamespaceResponse proto.InternalMessageInfo 405 406type DeleteNamespaceRequest struct { 407 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 408 XXX_NoUnkeyedLiteral struct{} `json:"-"` 409 XXX_unrecognized []byte `json:"-"` 410 XXX_sizecache int32 `json:"-"` 411} 412 413func (m *DeleteNamespaceRequest) Reset() { *m = DeleteNamespaceRequest{} } 414func (*DeleteNamespaceRequest) ProtoMessage() {} 415func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { 416 return fileDescriptor_8c41761eaeea4fd3, []int{9} 417} 418func (m *DeleteNamespaceRequest) XXX_Unmarshal(b []byte) error { 419 return m.Unmarshal(b) 420} 421func (m *DeleteNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 422 if deterministic { 423 return xxx_messageInfo_DeleteNamespaceRequest.Marshal(b, m, deterministic) 424 } else { 425 b = b[:cap(b)] 426 n, err := m.MarshalToSizedBuffer(b) 427 if err != nil { 428 return nil, err 429 } 430 return b[:n], nil 431 } 432} 433func (m *DeleteNamespaceRequest) XXX_Merge(src proto.Message) { 434 xxx_messageInfo_DeleteNamespaceRequest.Merge(m, src) 435} 436func (m *DeleteNamespaceRequest) XXX_Size() int { 437 return m.Size() 438} 439func (m *DeleteNamespaceRequest) XXX_DiscardUnknown() { 440 xxx_messageInfo_DeleteNamespaceRequest.DiscardUnknown(m) 441} 442 443var xxx_messageInfo_DeleteNamespaceRequest proto.InternalMessageInfo 444 445func init() { 446 proto.RegisterType((*Namespace)(nil), "containerd.services.namespaces.v1.Namespace") 447 proto.RegisterMapType((map[string]string)(nil), "containerd.services.namespaces.v1.Namespace.LabelsEntry") 448 proto.RegisterType((*GetNamespaceRequest)(nil), "containerd.services.namespaces.v1.GetNamespaceRequest") 449 proto.RegisterType((*GetNamespaceResponse)(nil), "containerd.services.namespaces.v1.GetNamespaceResponse") 450 proto.RegisterType((*ListNamespacesRequest)(nil), "containerd.services.namespaces.v1.ListNamespacesRequest") 451 proto.RegisterType((*ListNamespacesResponse)(nil), "containerd.services.namespaces.v1.ListNamespacesResponse") 452 proto.RegisterType((*CreateNamespaceRequest)(nil), "containerd.services.namespaces.v1.CreateNamespaceRequest") 453 proto.RegisterType((*CreateNamespaceResponse)(nil), "containerd.services.namespaces.v1.CreateNamespaceResponse") 454 proto.RegisterType((*UpdateNamespaceRequest)(nil), "containerd.services.namespaces.v1.UpdateNamespaceRequest") 455 proto.RegisterType((*UpdateNamespaceResponse)(nil), "containerd.services.namespaces.v1.UpdateNamespaceResponse") 456 proto.RegisterType((*DeleteNamespaceRequest)(nil), "containerd.services.namespaces.v1.DeleteNamespaceRequest") 457} 458 459func init() { 460 proto.RegisterFile("github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto", fileDescriptor_8c41761eaeea4fd3) 461} 462 463var fileDescriptor_8c41761eaeea4fd3 = []byte{ 464 // 551 bytes of a gzipped FileDescriptorProto 465 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcd, 0x6e, 0xd3, 0x4c, 466 0x14, 0xcd, 0x24, 0xf9, 0x2c, 0xe5, 0x7a, 0xf3, 0x69, 0x08, 0x26, 0x32, 0x92, 0x09, 0x5e, 0x15, 467 0xa9, 0x1a, 0xab, 0x41, 0x82, 0xfe, 0xec, 0x0a, 0x6d, 0x17, 0x14, 0x84, 0x2c, 0x21, 0x21, 0x58, 468 0x80, 0x93, 0x4c, 0x5c, 0x13, 0xc7, 0x36, 0x9e, 0xb1, 0xa5, 0x88, 0x05, 0xbc, 0x0d, 0x1b, 0x1e, 469 0x24, 0x4b, 0x96, 0xac, 0x50, 0x9b, 0x27, 0x41, 0x33, 0x76, 0xe2, 0xd0, 0x18, 0xe1, 0x06, 0xca, 470 0xee, 0x5e, 0x7b, 0xce, 0x3d, 0x67, 0xae, 0xce, 0xb1, 0xe1, 0x89, 0xeb, 0xf1, 0xb3, 0xa4, 0x4f, 471 0x06, 0xe1, 0xc4, 0x1a, 0x84, 0x01, 0x77, 0xbc, 0x80, 0xc6, 0xc3, 0xd5, 0xd2, 0x89, 0x3c, 0x8b, 472 0xd1, 0x38, 0xf5, 0x06, 0x94, 0x59, 0x81, 0x33, 0xa1, 0x2c, 0x72, 0x44, 0x99, 0xee, 0x14, 0x1d, 473 0x89, 0xe2, 0x90, 0x87, 0xf8, 0x6e, 0x01, 0x23, 0x0b, 0x08, 0x29, 0x20, 0x24, 0xdd, 0xd1, 0xdb, 474 0x6e, 0xe8, 0x86, 0xf2, 0xb4, 0x25, 0xaa, 0x0c, 0xa8, 0xdf, 0x76, 0xc3, 0xd0, 0xf5, 0xa9, 0x25, 475 0xbb, 0x7e, 0x32, 0xb2, 0xe8, 0x24, 0xe2, 0xd3, 0xfc, 0x65, 0xf7, 0xf2, 0xcb, 0x91, 0x47, 0xfd, 476 0xe1, 0x9b, 0x89, 0xc3, 0xc6, 0xd9, 0x09, 0xf3, 0x0b, 0x82, 0xd6, 0xb3, 0x05, 0x0d, 0xc6, 0xd0, 477 0x14, 0x9c, 0x1d, 0xd4, 0x45, 0x5b, 0x2d, 0x5b, 0xd6, 0xf8, 0x39, 0x28, 0xbe, 0xd3, 0xa7, 0x3e, 478 0xeb, 0xd4, 0xbb, 0x8d, 0x2d, 0xb5, 0xb7, 0x4b, 0x7e, 0x2b, 0x95, 0x2c, 0x27, 0x92, 0x53, 0x09, 479 0x3d, 0x0a, 0x78, 0x3c, 0xb5, 0xf3, 0x39, 0xfa, 0x1e, 0xa8, 0x2b, 0x8f, 0xf1, 0xff, 0xd0, 0x18, 480 0xd3, 0x69, 0xce, 0x29, 0x4a, 0xdc, 0x86, 0xff, 0x52, 0xc7, 0x4f, 0x68, 0xa7, 0x2e, 0x9f, 0x65, 481 0xcd, 0x7e, 0x7d, 0x17, 0x99, 0xf7, 0xe0, 0xc6, 0x09, 0xe5, 0xcb, 0xf1, 0x36, 0x7d, 0x9f, 0x50, 482 0xc6, 0xcb, 0x74, 0x9b, 0x67, 0xd0, 0xfe, 0xf9, 0x28, 0x8b, 0xc2, 0x80, 0x89, 0xfb, 0xb4, 0x96, 483 0x62, 0x25, 0x40, 0xed, 0x6d, 0x5f, 0xe5, 0x4a, 0x87, 0xcd, 0xd9, 0xf7, 0x3b, 0x35, 0xbb, 0x18, 484 0x62, 0x5a, 0x70, 0xf3, 0xd4, 0x63, 0x05, 0x15, 0x5b, 0xc8, 0xd2, 0x40, 0x19, 0x79, 0x3e, 0xa7, 485 0x71, 0x2e, 0x2c, 0xef, 0x4c, 0x1f, 0xb4, 0xcb, 0x80, 0x5c, 0x9c, 0x0d, 0x50, 0xd0, 0x76, 0x90, 486 0x5c, 0xf8, 0x26, 0xea, 0x56, 0xa6, 0x98, 0xef, 0x40, 0x7b, 0x14, 0x53, 0x87, 0xd3, 0xb5, 0xb5, 487 0xfd, 0xfd, 0x55, 0x8c, 0xe1, 0xd6, 0x1a, 0xd7, 0xb5, 0xed, 0xfd, 0x33, 0x02, 0xed, 0x45, 0x34, 488 0xfc, 0x27, 0x37, 0xc3, 0x07, 0xa0, 0x26, 0x92, 0x4b, 0xa6, 0x47, 0x3a, 0x53, 0xed, 0xe9, 0x24, 489 0x0b, 0x18, 0x59, 0x04, 0x8c, 0x1c, 0x8b, 0x80, 0x3d, 0x75, 0xd8, 0xd8, 0x86, 0xec, 0xb8, 0xa8, 490 0xc5, 0x5a, 0xd6, 0x84, 0x5e, 0xdb, 0x5a, 0xb6, 0x41, 0x7b, 0x4c, 0x7d, 0x5a, 0xb2, 0x95, 0x92, 491 0x98, 0xf4, 0xce, 0x9b, 0x00, 0x85, 0x11, 0x71, 0x0a, 0x8d, 0x13, 0xca, 0xf1, 0x83, 0x0a, 0x12, 492 0x4a, 0x82, 0xa8, 0x3f, 0xbc, 0x32, 0x2e, 0x5f, 0xc3, 0x07, 0x68, 0x8a, 0x48, 0xe0, 0x2a, 0x5f, 493 0x97, 0xd2, 0xb0, 0xe9, 0x7b, 0x1b, 0x20, 0x73, 0xf2, 0x8f, 0xa0, 0x64, 0xae, 0xc5, 0x55, 0x86, 494 0x94, 0x87, 0x49, 0xdf, 0xdf, 0x04, 0x5a, 0x08, 0xc8, 0xfc, 0x51, 0x49, 0x40, 0xb9, 0xe7, 0x2b, 495 0x09, 0xf8, 0x95, 0x0b, 0x5f, 0x83, 0x92, 0x79, 0xa6, 0x92, 0x80, 0x72, 0x7b, 0xe9, 0xda, 0x5a, 496 0x1a, 0x8e, 0xc4, 0xbf, 0xe8, 0xf0, 0xed, 0xec, 0xc2, 0xa8, 0x7d, 0xbb, 0x30, 0x6a, 0x9f, 0xe6, 497 0x06, 0x9a, 0xcd, 0x0d, 0xf4, 0x75, 0x6e, 0xa0, 0xf3, 0xb9, 0x81, 0x5e, 0x1d, 0xff, 0xc1, 0x2f, 498 0xf4, 0xa0, 0xe8, 0x5e, 0xd6, 0xfa, 0x8a, 0xe4, 0xbc, 0xff, 0x23, 0x00, 0x00, 0xff, 0xff, 0x4f, 499 0x4a, 0x87, 0xf3, 0x95, 0x07, 0x00, 0x00, 500} 501 502// Reference imports to suppress errors if they are not otherwise used. 503var _ context.Context 504var _ grpc.ClientConn 505 506// This is a compile-time assertion to ensure that this generated file 507// is compatible with the grpc package it is being compiled against. 508const _ = grpc.SupportPackageIsVersion4 509 510// NamespacesClient is the client API for Namespaces service. 511// 512// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 513type NamespacesClient interface { 514 Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) 515 List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) 516 Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) 517 Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) 518 Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*types.Empty, error) 519} 520 521type namespacesClient struct { 522 cc *grpc.ClientConn 523} 524 525func NewNamespacesClient(cc *grpc.ClientConn) NamespacesClient { 526 return &namespacesClient{cc} 527} 528 529func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) { 530 out := new(GetNamespaceResponse) 531 err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Get", in, out, opts...) 532 if err != nil { 533 return nil, err 534 } 535 return out, nil 536} 537 538func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) { 539 out := new(ListNamespacesResponse) 540 err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/List", in, out, opts...) 541 if err != nil { 542 return nil, err 543 } 544 return out, nil 545} 546 547func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) { 548 out := new(CreateNamespaceResponse) 549 err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Create", in, out, opts...) 550 if err != nil { 551 return nil, err 552 } 553 return out, nil 554} 555 556func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) { 557 out := new(UpdateNamespaceResponse) 558 err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Update", in, out, opts...) 559 if err != nil { 560 return nil, err 561 } 562 return out, nil 563} 564 565func (c *namespacesClient) Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*types.Empty, error) { 566 out := new(types.Empty) 567 err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Delete", in, out, opts...) 568 if err != nil { 569 return nil, err 570 } 571 return out, nil 572} 573 574// NamespacesServer is the server API for Namespaces service. 575type NamespacesServer interface { 576 Get(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error) 577 List(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error) 578 Create(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error) 579 Update(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) 580 Delete(context.Context, *DeleteNamespaceRequest) (*types.Empty, error) 581} 582 583// UnimplementedNamespacesServer can be embedded to have forward compatible implementations. 584type UnimplementedNamespacesServer struct { 585} 586 587func (*UnimplementedNamespacesServer) Get(ctx context.Context, req *GetNamespaceRequest) (*GetNamespaceResponse, error) { 588 return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") 589} 590func (*UnimplementedNamespacesServer) List(ctx context.Context, req *ListNamespacesRequest) (*ListNamespacesResponse, error) { 591 return nil, status.Errorf(codes.Unimplemented, "method List not implemented") 592} 593func (*UnimplementedNamespacesServer) Create(ctx context.Context, req *CreateNamespaceRequest) (*CreateNamespaceResponse, error) { 594 return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") 595} 596func (*UnimplementedNamespacesServer) Update(ctx context.Context, req *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) { 597 return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") 598} 599func (*UnimplementedNamespacesServer) Delete(ctx context.Context, req *DeleteNamespaceRequest) (*types.Empty, error) { 600 return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") 601} 602 603func RegisterNamespacesServer(s *grpc.Server, srv NamespacesServer) { 604 s.RegisterService(&_Namespaces_serviceDesc, srv) 605} 606 607func _Namespaces_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 608 in := new(GetNamespaceRequest) 609 if err := dec(in); err != nil { 610 return nil, err 611 } 612 if interceptor == nil { 613 return srv.(NamespacesServer).Get(ctx, in) 614 } 615 info := &grpc.UnaryServerInfo{ 616 Server: srv, 617 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Get", 618 } 619 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 620 return srv.(NamespacesServer).Get(ctx, req.(*GetNamespaceRequest)) 621 } 622 return interceptor(ctx, in, info, handler) 623} 624 625func _Namespaces_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 626 in := new(ListNamespacesRequest) 627 if err := dec(in); err != nil { 628 return nil, err 629 } 630 if interceptor == nil { 631 return srv.(NamespacesServer).List(ctx, in) 632 } 633 info := &grpc.UnaryServerInfo{ 634 Server: srv, 635 FullMethod: "/containerd.services.namespaces.v1.Namespaces/List", 636 } 637 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 638 return srv.(NamespacesServer).List(ctx, req.(*ListNamespacesRequest)) 639 } 640 return interceptor(ctx, in, info, handler) 641} 642 643func _Namespaces_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 644 in := new(CreateNamespaceRequest) 645 if err := dec(in); err != nil { 646 return nil, err 647 } 648 if interceptor == nil { 649 return srv.(NamespacesServer).Create(ctx, in) 650 } 651 info := &grpc.UnaryServerInfo{ 652 Server: srv, 653 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Create", 654 } 655 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 656 return srv.(NamespacesServer).Create(ctx, req.(*CreateNamespaceRequest)) 657 } 658 return interceptor(ctx, in, info, handler) 659} 660 661func _Namespaces_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 662 in := new(UpdateNamespaceRequest) 663 if err := dec(in); err != nil { 664 return nil, err 665 } 666 if interceptor == nil { 667 return srv.(NamespacesServer).Update(ctx, in) 668 } 669 info := &grpc.UnaryServerInfo{ 670 Server: srv, 671 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Update", 672 } 673 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 674 return srv.(NamespacesServer).Update(ctx, req.(*UpdateNamespaceRequest)) 675 } 676 return interceptor(ctx, in, info, handler) 677} 678 679func _Namespaces_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 680 in := new(DeleteNamespaceRequest) 681 if err := dec(in); err != nil { 682 return nil, err 683 } 684 if interceptor == nil { 685 return srv.(NamespacesServer).Delete(ctx, in) 686 } 687 info := &grpc.UnaryServerInfo{ 688 Server: srv, 689 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Delete", 690 } 691 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 692 return srv.(NamespacesServer).Delete(ctx, req.(*DeleteNamespaceRequest)) 693 } 694 return interceptor(ctx, in, info, handler) 695} 696 697var _Namespaces_serviceDesc = grpc.ServiceDesc{ 698 ServiceName: "containerd.services.namespaces.v1.Namespaces", 699 HandlerType: (*NamespacesServer)(nil), 700 Methods: []grpc.MethodDesc{ 701 { 702 MethodName: "Get", 703 Handler: _Namespaces_Get_Handler, 704 }, 705 { 706 MethodName: "List", 707 Handler: _Namespaces_List_Handler, 708 }, 709 { 710 MethodName: "Create", 711 Handler: _Namespaces_Create_Handler, 712 }, 713 { 714 MethodName: "Update", 715 Handler: _Namespaces_Update_Handler, 716 }, 717 { 718 MethodName: "Delete", 719 Handler: _Namespaces_Delete_Handler, 720 }, 721 }, 722 Streams: []grpc.StreamDesc{}, 723 Metadata: "github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto", 724} 725 726func (m *Namespace) Marshal() (dAtA []byte, err error) { 727 size := m.Size() 728 dAtA = make([]byte, size) 729 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 730 if err != nil { 731 return nil, err 732 } 733 return dAtA[:n], nil 734} 735 736func (m *Namespace) MarshalTo(dAtA []byte) (int, error) { 737 size := m.Size() 738 return m.MarshalToSizedBuffer(dAtA[:size]) 739} 740 741func (m *Namespace) MarshalToSizedBuffer(dAtA []byte) (int, error) { 742 i := len(dAtA) 743 _ = i 744 var l int 745 _ = l 746 if m.XXX_unrecognized != nil { 747 i -= len(m.XXX_unrecognized) 748 copy(dAtA[i:], m.XXX_unrecognized) 749 } 750 if len(m.Labels) > 0 { 751 for k := range m.Labels { 752 v := m.Labels[k] 753 baseI := i 754 i -= len(v) 755 copy(dAtA[i:], v) 756 i = encodeVarintNamespace(dAtA, i, uint64(len(v))) 757 i-- 758 dAtA[i] = 0x12 759 i -= len(k) 760 copy(dAtA[i:], k) 761 i = encodeVarintNamespace(dAtA, i, uint64(len(k))) 762 i-- 763 dAtA[i] = 0xa 764 i = encodeVarintNamespace(dAtA, i, uint64(baseI-i)) 765 i-- 766 dAtA[i] = 0x12 767 } 768 } 769 if len(m.Name) > 0 { 770 i -= len(m.Name) 771 copy(dAtA[i:], m.Name) 772 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) 773 i-- 774 dAtA[i] = 0xa 775 } 776 return len(dAtA) - i, nil 777} 778 779func (m *GetNamespaceRequest) Marshal() (dAtA []byte, err error) { 780 size := m.Size() 781 dAtA = make([]byte, size) 782 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 783 if err != nil { 784 return nil, err 785 } 786 return dAtA[:n], nil 787} 788 789func (m *GetNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 790 size := m.Size() 791 return m.MarshalToSizedBuffer(dAtA[:size]) 792} 793 794func (m *GetNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 795 i := len(dAtA) 796 _ = i 797 var l int 798 _ = l 799 if m.XXX_unrecognized != nil { 800 i -= len(m.XXX_unrecognized) 801 copy(dAtA[i:], m.XXX_unrecognized) 802 } 803 if len(m.Name) > 0 { 804 i -= len(m.Name) 805 copy(dAtA[i:], m.Name) 806 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) 807 i-- 808 dAtA[i] = 0xa 809 } 810 return len(dAtA) - i, nil 811} 812 813func (m *GetNamespaceResponse) Marshal() (dAtA []byte, err error) { 814 size := m.Size() 815 dAtA = make([]byte, size) 816 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 817 if err != nil { 818 return nil, err 819 } 820 return dAtA[:n], nil 821} 822 823func (m *GetNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { 824 size := m.Size() 825 return m.MarshalToSizedBuffer(dAtA[:size]) 826} 827 828func (m *GetNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 829 i := len(dAtA) 830 _ = i 831 var l int 832 _ = l 833 if m.XXX_unrecognized != nil { 834 i -= len(m.XXX_unrecognized) 835 copy(dAtA[i:], m.XXX_unrecognized) 836 } 837 { 838 size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) 839 if err != nil { 840 return 0, err 841 } 842 i -= size 843 i = encodeVarintNamespace(dAtA, i, uint64(size)) 844 } 845 i-- 846 dAtA[i] = 0xa 847 return len(dAtA) - i, nil 848} 849 850func (m *ListNamespacesRequest) Marshal() (dAtA []byte, err error) { 851 size := m.Size() 852 dAtA = make([]byte, size) 853 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 854 if err != nil { 855 return nil, err 856 } 857 return dAtA[:n], nil 858} 859 860func (m *ListNamespacesRequest) MarshalTo(dAtA []byte) (int, error) { 861 size := m.Size() 862 return m.MarshalToSizedBuffer(dAtA[:size]) 863} 864 865func (m *ListNamespacesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 866 i := len(dAtA) 867 _ = i 868 var l int 869 _ = l 870 if m.XXX_unrecognized != nil { 871 i -= len(m.XXX_unrecognized) 872 copy(dAtA[i:], m.XXX_unrecognized) 873 } 874 if len(m.Filter) > 0 { 875 i -= len(m.Filter) 876 copy(dAtA[i:], m.Filter) 877 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Filter))) 878 i-- 879 dAtA[i] = 0xa 880 } 881 return len(dAtA) - i, nil 882} 883 884func (m *ListNamespacesResponse) Marshal() (dAtA []byte, err error) { 885 size := m.Size() 886 dAtA = make([]byte, size) 887 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 888 if err != nil { 889 return nil, err 890 } 891 return dAtA[:n], nil 892} 893 894func (m *ListNamespacesResponse) MarshalTo(dAtA []byte) (int, error) { 895 size := m.Size() 896 return m.MarshalToSizedBuffer(dAtA[:size]) 897} 898 899func (m *ListNamespacesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 900 i := len(dAtA) 901 _ = i 902 var l int 903 _ = l 904 if m.XXX_unrecognized != nil { 905 i -= len(m.XXX_unrecognized) 906 copy(dAtA[i:], m.XXX_unrecognized) 907 } 908 if len(m.Namespaces) > 0 { 909 for iNdEx := len(m.Namespaces) - 1; iNdEx >= 0; iNdEx-- { 910 { 911 size, err := m.Namespaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 912 if err != nil { 913 return 0, err 914 } 915 i -= size 916 i = encodeVarintNamespace(dAtA, i, uint64(size)) 917 } 918 i-- 919 dAtA[i] = 0xa 920 } 921 } 922 return len(dAtA) - i, nil 923} 924 925func (m *CreateNamespaceRequest) Marshal() (dAtA []byte, err error) { 926 size := m.Size() 927 dAtA = make([]byte, size) 928 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 929 if err != nil { 930 return nil, err 931 } 932 return dAtA[:n], nil 933} 934 935func (m *CreateNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 936 size := m.Size() 937 return m.MarshalToSizedBuffer(dAtA[:size]) 938} 939 940func (m *CreateNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 941 i := len(dAtA) 942 _ = i 943 var l int 944 _ = l 945 if m.XXX_unrecognized != nil { 946 i -= len(m.XXX_unrecognized) 947 copy(dAtA[i:], m.XXX_unrecognized) 948 } 949 { 950 size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) 951 if err != nil { 952 return 0, err 953 } 954 i -= size 955 i = encodeVarintNamespace(dAtA, i, uint64(size)) 956 } 957 i-- 958 dAtA[i] = 0xa 959 return len(dAtA) - i, nil 960} 961 962func (m *CreateNamespaceResponse) Marshal() (dAtA []byte, err error) { 963 size := m.Size() 964 dAtA = make([]byte, size) 965 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 966 if err != nil { 967 return nil, err 968 } 969 return dAtA[:n], nil 970} 971 972func (m *CreateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { 973 size := m.Size() 974 return m.MarshalToSizedBuffer(dAtA[:size]) 975} 976 977func (m *CreateNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 978 i := len(dAtA) 979 _ = i 980 var l int 981 _ = l 982 if m.XXX_unrecognized != nil { 983 i -= len(m.XXX_unrecognized) 984 copy(dAtA[i:], m.XXX_unrecognized) 985 } 986 { 987 size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) 988 if err != nil { 989 return 0, err 990 } 991 i -= size 992 i = encodeVarintNamespace(dAtA, i, uint64(size)) 993 } 994 i-- 995 dAtA[i] = 0xa 996 return len(dAtA) - i, nil 997} 998 999func (m *UpdateNamespaceRequest) Marshal() (dAtA []byte, err error) { 1000 size := m.Size() 1001 dAtA = make([]byte, size) 1002 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 1003 if err != nil { 1004 return nil, err 1005 } 1006 return dAtA[:n], nil 1007} 1008 1009func (m *UpdateNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 1010 size := m.Size() 1011 return m.MarshalToSizedBuffer(dAtA[:size]) 1012} 1013 1014func (m *UpdateNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 1015 i := len(dAtA) 1016 _ = i 1017 var l int 1018 _ = l 1019 if m.XXX_unrecognized != nil { 1020 i -= len(m.XXX_unrecognized) 1021 copy(dAtA[i:], m.XXX_unrecognized) 1022 } 1023 if m.UpdateMask != nil { 1024 { 1025 size, err := m.UpdateMask.MarshalToSizedBuffer(dAtA[:i]) 1026 if err != nil { 1027 return 0, err 1028 } 1029 i -= size 1030 i = encodeVarintNamespace(dAtA, i, uint64(size)) 1031 } 1032 i-- 1033 dAtA[i] = 0x12 1034 } 1035 { 1036 size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) 1037 if err != nil { 1038 return 0, err 1039 } 1040 i -= size 1041 i = encodeVarintNamespace(dAtA, i, uint64(size)) 1042 } 1043 i-- 1044 dAtA[i] = 0xa 1045 return len(dAtA) - i, nil 1046} 1047 1048func (m *UpdateNamespaceResponse) Marshal() (dAtA []byte, err error) { 1049 size := m.Size() 1050 dAtA = make([]byte, size) 1051 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 1052 if err != nil { 1053 return nil, err 1054 } 1055 return dAtA[:n], nil 1056} 1057 1058func (m *UpdateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { 1059 size := m.Size() 1060 return m.MarshalToSizedBuffer(dAtA[:size]) 1061} 1062 1063func (m *UpdateNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 1064 i := len(dAtA) 1065 _ = i 1066 var l int 1067 _ = l 1068 if m.XXX_unrecognized != nil { 1069 i -= len(m.XXX_unrecognized) 1070 copy(dAtA[i:], m.XXX_unrecognized) 1071 } 1072 { 1073 size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) 1074 if err != nil { 1075 return 0, err 1076 } 1077 i -= size 1078 i = encodeVarintNamespace(dAtA, i, uint64(size)) 1079 } 1080 i-- 1081 dAtA[i] = 0xa 1082 return len(dAtA) - i, nil 1083} 1084 1085func (m *DeleteNamespaceRequest) Marshal() (dAtA []byte, err error) { 1086 size := m.Size() 1087 dAtA = make([]byte, size) 1088 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 1089 if err != nil { 1090 return nil, err 1091 } 1092 return dAtA[:n], nil 1093} 1094 1095func (m *DeleteNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 1096 size := m.Size() 1097 return m.MarshalToSizedBuffer(dAtA[:size]) 1098} 1099 1100func (m *DeleteNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 1101 i := len(dAtA) 1102 _ = i 1103 var l int 1104 _ = l 1105 if m.XXX_unrecognized != nil { 1106 i -= len(m.XXX_unrecognized) 1107 copy(dAtA[i:], m.XXX_unrecognized) 1108 } 1109 if len(m.Name) > 0 { 1110 i -= len(m.Name) 1111 copy(dAtA[i:], m.Name) 1112 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) 1113 i-- 1114 dAtA[i] = 0xa 1115 } 1116 return len(dAtA) - i, nil 1117} 1118 1119func encodeVarintNamespace(dAtA []byte, offset int, v uint64) int { 1120 offset -= sovNamespace(v) 1121 base := offset 1122 for v >= 1<<7 { 1123 dAtA[offset] = uint8(v&0x7f | 0x80) 1124 v >>= 7 1125 offset++ 1126 } 1127 dAtA[offset] = uint8(v) 1128 return base 1129} 1130func (m *Namespace) Size() (n int) { 1131 if m == nil { 1132 return 0 1133 } 1134 var l int 1135 _ = l 1136 l = len(m.Name) 1137 if l > 0 { 1138 n += 1 + l + sovNamespace(uint64(l)) 1139 } 1140 if len(m.Labels) > 0 { 1141 for k, v := range m.Labels { 1142 _ = k 1143 _ = v 1144 mapEntrySize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v))) 1145 n += mapEntrySize + 1 + sovNamespace(uint64(mapEntrySize)) 1146 } 1147 } 1148 if m.XXX_unrecognized != nil { 1149 n += len(m.XXX_unrecognized) 1150 } 1151 return n 1152} 1153 1154func (m *GetNamespaceRequest) Size() (n int) { 1155 if m == nil { 1156 return 0 1157 } 1158 var l int 1159 _ = l 1160 l = len(m.Name) 1161 if l > 0 { 1162 n += 1 + l + sovNamespace(uint64(l)) 1163 } 1164 if m.XXX_unrecognized != nil { 1165 n += len(m.XXX_unrecognized) 1166 } 1167 return n 1168} 1169 1170func (m *GetNamespaceResponse) Size() (n int) { 1171 if m == nil { 1172 return 0 1173 } 1174 var l int 1175 _ = l 1176 l = m.Namespace.Size() 1177 n += 1 + l + sovNamespace(uint64(l)) 1178 if m.XXX_unrecognized != nil { 1179 n += len(m.XXX_unrecognized) 1180 } 1181 return n 1182} 1183 1184func (m *ListNamespacesRequest) Size() (n int) { 1185 if m == nil { 1186 return 0 1187 } 1188 var l int 1189 _ = l 1190 l = len(m.Filter) 1191 if l > 0 { 1192 n += 1 + l + sovNamespace(uint64(l)) 1193 } 1194 if m.XXX_unrecognized != nil { 1195 n += len(m.XXX_unrecognized) 1196 } 1197 return n 1198} 1199 1200func (m *ListNamespacesResponse) Size() (n int) { 1201 if m == nil { 1202 return 0 1203 } 1204 var l int 1205 _ = l 1206 if len(m.Namespaces) > 0 { 1207 for _, e := range m.Namespaces { 1208 l = e.Size() 1209 n += 1 + l + sovNamespace(uint64(l)) 1210 } 1211 } 1212 if m.XXX_unrecognized != nil { 1213 n += len(m.XXX_unrecognized) 1214 } 1215 return n 1216} 1217 1218func (m *CreateNamespaceRequest) Size() (n int) { 1219 if m == nil { 1220 return 0 1221 } 1222 var l int 1223 _ = l 1224 l = m.Namespace.Size() 1225 n += 1 + l + sovNamespace(uint64(l)) 1226 if m.XXX_unrecognized != nil { 1227 n += len(m.XXX_unrecognized) 1228 } 1229 return n 1230} 1231 1232func (m *CreateNamespaceResponse) Size() (n int) { 1233 if m == nil { 1234 return 0 1235 } 1236 var l int 1237 _ = l 1238 l = m.Namespace.Size() 1239 n += 1 + l + sovNamespace(uint64(l)) 1240 if m.XXX_unrecognized != nil { 1241 n += len(m.XXX_unrecognized) 1242 } 1243 return n 1244} 1245 1246func (m *UpdateNamespaceRequest) Size() (n int) { 1247 if m == nil { 1248 return 0 1249 } 1250 var l int 1251 _ = l 1252 l = m.Namespace.Size() 1253 n += 1 + l + sovNamespace(uint64(l)) 1254 if m.UpdateMask != nil { 1255 l = m.UpdateMask.Size() 1256 n += 1 + l + sovNamespace(uint64(l)) 1257 } 1258 if m.XXX_unrecognized != nil { 1259 n += len(m.XXX_unrecognized) 1260 } 1261 return n 1262} 1263 1264func (m *UpdateNamespaceResponse) Size() (n int) { 1265 if m == nil { 1266 return 0 1267 } 1268 var l int 1269 _ = l 1270 l = m.Namespace.Size() 1271 n += 1 + l + sovNamespace(uint64(l)) 1272 if m.XXX_unrecognized != nil { 1273 n += len(m.XXX_unrecognized) 1274 } 1275 return n 1276} 1277 1278func (m *DeleteNamespaceRequest) Size() (n int) { 1279 if m == nil { 1280 return 0 1281 } 1282 var l int 1283 _ = l 1284 l = len(m.Name) 1285 if l > 0 { 1286 n += 1 + l + sovNamespace(uint64(l)) 1287 } 1288 if m.XXX_unrecognized != nil { 1289 n += len(m.XXX_unrecognized) 1290 } 1291 return n 1292} 1293 1294func sovNamespace(x uint64) (n int) { 1295 return (math_bits.Len64(x|1) + 6) / 7 1296} 1297func sozNamespace(x uint64) (n int) { 1298 return sovNamespace(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 1299} 1300func (this *Namespace) String() string { 1301 if this == nil { 1302 return "nil" 1303 } 1304 keysForLabels := make([]string, 0, len(this.Labels)) 1305 for k, _ := range this.Labels { 1306 keysForLabels = append(keysForLabels, k) 1307 } 1308 github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) 1309 mapStringForLabels := "map[string]string{" 1310 for _, k := range keysForLabels { 1311 mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) 1312 } 1313 mapStringForLabels += "}" 1314 s := strings.Join([]string{`&Namespace{`, 1315 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 1316 `Labels:` + mapStringForLabels + `,`, 1317 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1318 `}`, 1319 }, "") 1320 return s 1321} 1322func (this *GetNamespaceRequest) String() string { 1323 if this == nil { 1324 return "nil" 1325 } 1326 s := strings.Join([]string{`&GetNamespaceRequest{`, 1327 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 1328 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1329 `}`, 1330 }, "") 1331 return s 1332} 1333func (this *GetNamespaceResponse) String() string { 1334 if this == nil { 1335 return "nil" 1336 } 1337 s := strings.Join([]string{`&GetNamespaceResponse{`, 1338 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 1339 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1340 `}`, 1341 }, "") 1342 return s 1343} 1344func (this *ListNamespacesRequest) String() string { 1345 if this == nil { 1346 return "nil" 1347 } 1348 s := strings.Join([]string{`&ListNamespacesRequest{`, 1349 `Filter:` + fmt.Sprintf("%v", this.Filter) + `,`, 1350 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1351 `}`, 1352 }, "") 1353 return s 1354} 1355func (this *ListNamespacesResponse) String() string { 1356 if this == nil { 1357 return "nil" 1358 } 1359 repeatedStringForNamespaces := "[]Namespace{" 1360 for _, f := range this.Namespaces { 1361 repeatedStringForNamespaces += strings.Replace(strings.Replace(f.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + "," 1362 } 1363 repeatedStringForNamespaces += "}" 1364 s := strings.Join([]string{`&ListNamespacesResponse{`, 1365 `Namespaces:` + repeatedStringForNamespaces + `,`, 1366 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1367 `}`, 1368 }, "") 1369 return s 1370} 1371func (this *CreateNamespaceRequest) String() string { 1372 if this == nil { 1373 return "nil" 1374 } 1375 s := strings.Join([]string{`&CreateNamespaceRequest{`, 1376 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 1377 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1378 `}`, 1379 }, "") 1380 return s 1381} 1382func (this *CreateNamespaceResponse) String() string { 1383 if this == nil { 1384 return "nil" 1385 } 1386 s := strings.Join([]string{`&CreateNamespaceResponse{`, 1387 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 1388 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1389 `}`, 1390 }, "") 1391 return s 1392} 1393func (this *UpdateNamespaceRequest) String() string { 1394 if this == nil { 1395 return "nil" 1396 } 1397 s := strings.Join([]string{`&UpdateNamespaceRequest{`, 1398 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 1399 `UpdateMask:` + strings.Replace(fmt.Sprintf("%v", this.UpdateMask), "FieldMask", "types.FieldMask", 1) + `,`, 1400 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1401 `}`, 1402 }, "") 1403 return s 1404} 1405func (this *UpdateNamespaceResponse) String() string { 1406 if this == nil { 1407 return "nil" 1408 } 1409 s := strings.Join([]string{`&UpdateNamespaceResponse{`, 1410 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 1411 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1412 `}`, 1413 }, "") 1414 return s 1415} 1416func (this *DeleteNamespaceRequest) String() string { 1417 if this == nil { 1418 return "nil" 1419 } 1420 s := strings.Join([]string{`&DeleteNamespaceRequest{`, 1421 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 1422 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 1423 `}`, 1424 }, "") 1425 return s 1426} 1427func valueToStringNamespace(v interface{}) string { 1428 rv := reflect.ValueOf(v) 1429 if rv.IsNil() { 1430 return "nil" 1431 } 1432 pv := reflect.Indirect(rv).Interface() 1433 return fmt.Sprintf("*%v", pv) 1434} 1435func (m *Namespace) Unmarshal(dAtA []byte) error { 1436 l := len(dAtA) 1437 iNdEx := 0 1438 for iNdEx < l { 1439 preIndex := iNdEx 1440 var wire uint64 1441 for shift := uint(0); ; shift += 7 { 1442 if shift >= 64 { 1443 return ErrIntOverflowNamespace 1444 } 1445 if iNdEx >= l { 1446 return io.ErrUnexpectedEOF 1447 } 1448 b := dAtA[iNdEx] 1449 iNdEx++ 1450 wire |= uint64(b&0x7F) << shift 1451 if b < 0x80 { 1452 break 1453 } 1454 } 1455 fieldNum := int32(wire >> 3) 1456 wireType := int(wire & 0x7) 1457 if wireType == 4 { 1458 return fmt.Errorf("proto: Namespace: wiretype end group for non-group") 1459 } 1460 if fieldNum <= 0 { 1461 return fmt.Errorf("proto: Namespace: illegal tag %d (wire type %d)", fieldNum, wire) 1462 } 1463 switch fieldNum { 1464 case 1: 1465 if wireType != 2 { 1466 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 1467 } 1468 var stringLen uint64 1469 for shift := uint(0); ; shift += 7 { 1470 if shift >= 64 { 1471 return ErrIntOverflowNamespace 1472 } 1473 if iNdEx >= l { 1474 return io.ErrUnexpectedEOF 1475 } 1476 b := dAtA[iNdEx] 1477 iNdEx++ 1478 stringLen |= uint64(b&0x7F) << shift 1479 if b < 0x80 { 1480 break 1481 } 1482 } 1483 intStringLen := int(stringLen) 1484 if intStringLen < 0 { 1485 return ErrInvalidLengthNamespace 1486 } 1487 postIndex := iNdEx + intStringLen 1488 if postIndex < 0 { 1489 return ErrInvalidLengthNamespace 1490 } 1491 if postIndex > l { 1492 return io.ErrUnexpectedEOF 1493 } 1494 m.Name = string(dAtA[iNdEx:postIndex]) 1495 iNdEx = postIndex 1496 case 2: 1497 if wireType != 2 { 1498 return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) 1499 } 1500 var msglen int 1501 for shift := uint(0); ; shift += 7 { 1502 if shift >= 64 { 1503 return ErrIntOverflowNamespace 1504 } 1505 if iNdEx >= l { 1506 return io.ErrUnexpectedEOF 1507 } 1508 b := dAtA[iNdEx] 1509 iNdEx++ 1510 msglen |= int(b&0x7F) << shift 1511 if b < 0x80 { 1512 break 1513 } 1514 } 1515 if msglen < 0 { 1516 return ErrInvalidLengthNamespace 1517 } 1518 postIndex := iNdEx + msglen 1519 if postIndex < 0 { 1520 return ErrInvalidLengthNamespace 1521 } 1522 if postIndex > l { 1523 return io.ErrUnexpectedEOF 1524 } 1525 if m.Labels == nil { 1526 m.Labels = make(map[string]string) 1527 } 1528 var mapkey string 1529 var mapvalue string 1530 for iNdEx < postIndex { 1531 entryPreIndex := iNdEx 1532 var wire uint64 1533 for shift := uint(0); ; shift += 7 { 1534 if shift >= 64 { 1535 return ErrIntOverflowNamespace 1536 } 1537 if iNdEx >= l { 1538 return io.ErrUnexpectedEOF 1539 } 1540 b := dAtA[iNdEx] 1541 iNdEx++ 1542 wire |= uint64(b&0x7F) << shift 1543 if b < 0x80 { 1544 break 1545 } 1546 } 1547 fieldNum := int32(wire >> 3) 1548 if fieldNum == 1 { 1549 var stringLenmapkey uint64 1550 for shift := uint(0); ; shift += 7 { 1551 if shift >= 64 { 1552 return ErrIntOverflowNamespace 1553 } 1554 if iNdEx >= l { 1555 return io.ErrUnexpectedEOF 1556 } 1557 b := dAtA[iNdEx] 1558 iNdEx++ 1559 stringLenmapkey |= uint64(b&0x7F) << shift 1560 if b < 0x80 { 1561 break 1562 } 1563 } 1564 intStringLenmapkey := int(stringLenmapkey) 1565 if intStringLenmapkey < 0 { 1566 return ErrInvalidLengthNamespace 1567 } 1568 postStringIndexmapkey := iNdEx + intStringLenmapkey 1569 if postStringIndexmapkey < 0 { 1570 return ErrInvalidLengthNamespace 1571 } 1572 if postStringIndexmapkey > l { 1573 return io.ErrUnexpectedEOF 1574 } 1575 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 1576 iNdEx = postStringIndexmapkey 1577 } else if fieldNum == 2 { 1578 var stringLenmapvalue uint64 1579 for shift := uint(0); ; shift += 7 { 1580 if shift >= 64 { 1581 return ErrIntOverflowNamespace 1582 } 1583 if iNdEx >= l { 1584 return io.ErrUnexpectedEOF 1585 } 1586 b := dAtA[iNdEx] 1587 iNdEx++ 1588 stringLenmapvalue |= uint64(b&0x7F) << shift 1589 if b < 0x80 { 1590 break 1591 } 1592 } 1593 intStringLenmapvalue := int(stringLenmapvalue) 1594 if intStringLenmapvalue < 0 { 1595 return ErrInvalidLengthNamespace 1596 } 1597 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 1598 if postStringIndexmapvalue < 0 { 1599 return ErrInvalidLengthNamespace 1600 } 1601 if postStringIndexmapvalue > l { 1602 return io.ErrUnexpectedEOF 1603 } 1604 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 1605 iNdEx = postStringIndexmapvalue 1606 } else { 1607 iNdEx = entryPreIndex 1608 skippy, err := skipNamespace(dAtA[iNdEx:]) 1609 if err != nil { 1610 return err 1611 } 1612 if skippy < 0 { 1613 return ErrInvalidLengthNamespace 1614 } 1615 if (iNdEx + skippy) > postIndex { 1616 return io.ErrUnexpectedEOF 1617 } 1618 iNdEx += skippy 1619 } 1620 } 1621 m.Labels[mapkey] = mapvalue 1622 iNdEx = postIndex 1623 default: 1624 iNdEx = preIndex 1625 skippy, err := skipNamespace(dAtA[iNdEx:]) 1626 if err != nil { 1627 return err 1628 } 1629 if skippy < 0 { 1630 return ErrInvalidLengthNamespace 1631 } 1632 if (iNdEx + skippy) < 0 { 1633 return ErrInvalidLengthNamespace 1634 } 1635 if (iNdEx + skippy) > l { 1636 return io.ErrUnexpectedEOF 1637 } 1638 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1639 iNdEx += skippy 1640 } 1641 } 1642 1643 if iNdEx > l { 1644 return io.ErrUnexpectedEOF 1645 } 1646 return nil 1647} 1648func (m *GetNamespaceRequest) Unmarshal(dAtA []byte) error { 1649 l := len(dAtA) 1650 iNdEx := 0 1651 for iNdEx < l { 1652 preIndex := iNdEx 1653 var wire uint64 1654 for shift := uint(0); ; shift += 7 { 1655 if shift >= 64 { 1656 return ErrIntOverflowNamespace 1657 } 1658 if iNdEx >= l { 1659 return io.ErrUnexpectedEOF 1660 } 1661 b := dAtA[iNdEx] 1662 iNdEx++ 1663 wire |= uint64(b&0x7F) << shift 1664 if b < 0x80 { 1665 break 1666 } 1667 } 1668 fieldNum := int32(wire >> 3) 1669 wireType := int(wire & 0x7) 1670 if wireType == 4 { 1671 return fmt.Errorf("proto: GetNamespaceRequest: wiretype end group for non-group") 1672 } 1673 if fieldNum <= 0 { 1674 return fmt.Errorf("proto: GetNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 1675 } 1676 switch fieldNum { 1677 case 1: 1678 if wireType != 2 { 1679 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 1680 } 1681 var stringLen uint64 1682 for shift := uint(0); ; shift += 7 { 1683 if shift >= 64 { 1684 return ErrIntOverflowNamespace 1685 } 1686 if iNdEx >= l { 1687 return io.ErrUnexpectedEOF 1688 } 1689 b := dAtA[iNdEx] 1690 iNdEx++ 1691 stringLen |= uint64(b&0x7F) << shift 1692 if b < 0x80 { 1693 break 1694 } 1695 } 1696 intStringLen := int(stringLen) 1697 if intStringLen < 0 { 1698 return ErrInvalidLengthNamespace 1699 } 1700 postIndex := iNdEx + intStringLen 1701 if postIndex < 0 { 1702 return ErrInvalidLengthNamespace 1703 } 1704 if postIndex > l { 1705 return io.ErrUnexpectedEOF 1706 } 1707 m.Name = string(dAtA[iNdEx:postIndex]) 1708 iNdEx = postIndex 1709 default: 1710 iNdEx = preIndex 1711 skippy, err := skipNamespace(dAtA[iNdEx:]) 1712 if err != nil { 1713 return err 1714 } 1715 if skippy < 0 { 1716 return ErrInvalidLengthNamespace 1717 } 1718 if (iNdEx + skippy) < 0 { 1719 return ErrInvalidLengthNamespace 1720 } 1721 if (iNdEx + skippy) > l { 1722 return io.ErrUnexpectedEOF 1723 } 1724 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1725 iNdEx += skippy 1726 } 1727 } 1728 1729 if iNdEx > l { 1730 return io.ErrUnexpectedEOF 1731 } 1732 return nil 1733} 1734func (m *GetNamespaceResponse) Unmarshal(dAtA []byte) error { 1735 l := len(dAtA) 1736 iNdEx := 0 1737 for iNdEx < l { 1738 preIndex := iNdEx 1739 var wire uint64 1740 for shift := uint(0); ; shift += 7 { 1741 if shift >= 64 { 1742 return ErrIntOverflowNamespace 1743 } 1744 if iNdEx >= l { 1745 return io.ErrUnexpectedEOF 1746 } 1747 b := dAtA[iNdEx] 1748 iNdEx++ 1749 wire |= uint64(b&0x7F) << shift 1750 if b < 0x80 { 1751 break 1752 } 1753 } 1754 fieldNum := int32(wire >> 3) 1755 wireType := int(wire & 0x7) 1756 if wireType == 4 { 1757 return fmt.Errorf("proto: GetNamespaceResponse: wiretype end group for non-group") 1758 } 1759 if fieldNum <= 0 { 1760 return fmt.Errorf("proto: GetNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) 1761 } 1762 switch fieldNum { 1763 case 1: 1764 if wireType != 2 { 1765 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 1766 } 1767 var msglen int 1768 for shift := uint(0); ; shift += 7 { 1769 if shift >= 64 { 1770 return ErrIntOverflowNamespace 1771 } 1772 if iNdEx >= l { 1773 return io.ErrUnexpectedEOF 1774 } 1775 b := dAtA[iNdEx] 1776 iNdEx++ 1777 msglen |= int(b&0x7F) << shift 1778 if b < 0x80 { 1779 break 1780 } 1781 } 1782 if msglen < 0 { 1783 return ErrInvalidLengthNamespace 1784 } 1785 postIndex := iNdEx + msglen 1786 if postIndex < 0 { 1787 return ErrInvalidLengthNamespace 1788 } 1789 if postIndex > l { 1790 return io.ErrUnexpectedEOF 1791 } 1792 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1793 return err 1794 } 1795 iNdEx = postIndex 1796 default: 1797 iNdEx = preIndex 1798 skippy, err := skipNamespace(dAtA[iNdEx:]) 1799 if err != nil { 1800 return err 1801 } 1802 if skippy < 0 { 1803 return ErrInvalidLengthNamespace 1804 } 1805 if (iNdEx + skippy) < 0 { 1806 return ErrInvalidLengthNamespace 1807 } 1808 if (iNdEx + skippy) > l { 1809 return io.ErrUnexpectedEOF 1810 } 1811 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1812 iNdEx += skippy 1813 } 1814 } 1815 1816 if iNdEx > l { 1817 return io.ErrUnexpectedEOF 1818 } 1819 return nil 1820} 1821func (m *ListNamespacesRequest) Unmarshal(dAtA []byte) error { 1822 l := len(dAtA) 1823 iNdEx := 0 1824 for iNdEx < l { 1825 preIndex := iNdEx 1826 var wire uint64 1827 for shift := uint(0); ; shift += 7 { 1828 if shift >= 64 { 1829 return ErrIntOverflowNamespace 1830 } 1831 if iNdEx >= l { 1832 return io.ErrUnexpectedEOF 1833 } 1834 b := dAtA[iNdEx] 1835 iNdEx++ 1836 wire |= uint64(b&0x7F) << shift 1837 if b < 0x80 { 1838 break 1839 } 1840 } 1841 fieldNum := int32(wire >> 3) 1842 wireType := int(wire & 0x7) 1843 if wireType == 4 { 1844 return fmt.Errorf("proto: ListNamespacesRequest: wiretype end group for non-group") 1845 } 1846 if fieldNum <= 0 { 1847 return fmt.Errorf("proto: ListNamespacesRequest: illegal tag %d (wire type %d)", fieldNum, wire) 1848 } 1849 switch fieldNum { 1850 case 1: 1851 if wireType != 2 { 1852 return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType) 1853 } 1854 var stringLen uint64 1855 for shift := uint(0); ; shift += 7 { 1856 if shift >= 64 { 1857 return ErrIntOverflowNamespace 1858 } 1859 if iNdEx >= l { 1860 return io.ErrUnexpectedEOF 1861 } 1862 b := dAtA[iNdEx] 1863 iNdEx++ 1864 stringLen |= uint64(b&0x7F) << shift 1865 if b < 0x80 { 1866 break 1867 } 1868 } 1869 intStringLen := int(stringLen) 1870 if intStringLen < 0 { 1871 return ErrInvalidLengthNamespace 1872 } 1873 postIndex := iNdEx + intStringLen 1874 if postIndex < 0 { 1875 return ErrInvalidLengthNamespace 1876 } 1877 if postIndex > l { 1878 return io.ErrUnexpectedEOF 1879 } 1880 m.Filter = string(dAtA[iNdEx:postIndex]) 1881 iNdEx = postIndex 1882 default: 1883 iNdEx = preIndex 1884 skippy, err := skipNamespace(dAtA[iNdEx:]) 1885 if err != nil { 1886 return err 1887 } 1888 if skippy < 0 { 1889 return ErrInvalidLengthNamespace 1890 } 1891 if (iNdEx + skippy) < 0 { 1892 return ErrInvalidLengthNamespace 1893 } 1894 if (iNdEx + skippy) > l { 1895 return io.ErrUnexpectedEOF 1896 } 1897 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1898 iNdEx += skippy 1899 } 1900 } 1901 1902 if iNdEx > l { 1903 return io.ErrUnexpectedEOF 1904 } 1905 return nil 1906} 1907func (m *ListNamespacesResponse) Unmarshal(dAtA []byte) error { 1908 l := len(dAtA) 1909 iNdEx := 0 1910 for iNdEx < l { 1911 preIndex := iNdEx 1912 var wire uint64 1913 for shift := uint(0); ; shift += 7 { 1914 if shift >= 64 { 1915 return ErrIntOverflowNamespace 1916 } 1917 if iNdEx >= l { 1918 return io.ErrUnexpectedEOF 1919 } 1920 b := dAtA[iNdEx] 1921 iNdEx++ 1922 wire |= uint64(b&0x7F) << shift 1923 if b < 0x80 { 1924 break 1925 } 1926 } 1927 fieldNum := int32(wire >> 3) 1928 wireType := int(wire & 0x7) 1929 if wireType == 4 { 1930 return fmt.Errorf("proto: ListNamespacesResponse: wiretype end group for non-group") 1931 } 1932 if fieldNum <= 0 { 1933 return fmt.Errorf("proto: ListNamespacesResponse: illegal tag %d (wire type %d)", fieldNum, wire) 1934 } 1935 switch fieldNum { 1936 case 1: 1937 if wireType != 2 { 1938 return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType) 1939 } 1940 var msglen int 1941 for shift := uint(0); ; shift += 7 { 1942 if shift >= 64 { 1943 return ErrIntOverflowNamespace 1944 } 1945 if iNdEx >= l { 1946 return io.ErrUnexpectedEOF 1947 } 1948 b := dAtA[iNdEx] 1949 iNdEx++ 1950 msglen |= int(b&0x7F) << shift 1951 if b < 0x80 { 1952 break 1953 } 1954 } 1955 if msglen < 0 { 1956 return ErrInvalidLengthNamespace 1957 } 1958 postIndex := iNdEx + msglen 1959 if postIndex < 0 { 1960 return ErrInvalidLengthNamespace 1961 } 1962 if postIndex > l { 1963 return io.ErrUnexpectedEOF 1964 } 1965 m.Namespaces = append(m.Namespaces, Namespace{}) 1966 if err := m.Namespaces[len(m.Namespaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1967 return err 1968 } 1969 iNdEx = postIndex 1970 default: 1971 iNdEx = preIndex 1972 skippy, err := skipNamespace(dAtA[iNdEx:]) 1973 if err != nil { 1974 return err 1975 } 1976 if skippy < 0 { 1977 return ErrInvalidLengthNamespace 1978 } 1979 if (iNdEx + skippy) < 0 { 1980 return ErrInvalidLengthNamespace 1981 } 1982 if (iNdEx + skippy) > l { 1983 return io.ErrUnexpectedEOF 1984 } 1985 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1986 iNdEx += skippy 1987 } 1988 } 1989 1990 if iNdEx > l { 1991 return io.ErrUnexpectedEOF 1992 } 1993 return nil 1994} 1995func (m *CreateNamespaceRequest) Unmarshal(dAtA []byte) error { 1996 l := len(dAtA) 1997 iNdEx := 0 1998 for iNdEx < l { 1999 preIndex := iNdEx 2000 var wire uint64 2001 for shift := uint(0); ; shift += 7 { 2002 if shift >= 64 { 2003 return ErrIntOverflowNamespace 2004 } 2005 if iNdEx >= l { 2006 return io.ErrUnexpectedEOF 2007 } 2008 b := dAtA[iNdEx] 2009 iNdEx++ 2010 wire |= uint64(b&0x7F) << shift 2011 if b < 0x80 { 2012 break 2013 } 2014 } 2015 fieldNum := int32(wire >> 3) 2016 wireType := int(wire & 0x7) 2017 if wireType == 4 { 2018 return fmt.Errorf("proto: CreateNamespaceRequest: wiretype end group for non-group") 2019 } 2020 if fieldNum <= 0 { 2021 return fmt.Errorf("proto: CreateNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 2022 } 2023 switch fieldNum { 2024 case 1: 2025 if wireType != 2 { 2026 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 2027 } 2028 var msglen int 2029 for shift := uint(0); ; shift += 7 { 2030 if shift >= 64 { 2031 return ErrIntOverflowNamespace 2032 } 2033 if iNdEx >= l { 2034 return io.ErrUnexpectedEOF 2035 } 2036 b := dAtA[iNdEx] 2037 iNdEx++ 2038 msglen |= int(b&0x7F) << shift 2039 if b < 0x80 { 2040 break 2041 } 2042 } 2043 if msglen < 0 { 2044 return ErrInvalidLengthNamespace 2045 } 2046 postIndex := iNdEx + msglen 2047 if postIndex < 0 { 2048 return ErrInvalidLengthNamespace 2049 } 2050 if postIndex > l { 2051 return io.ErrUnexpectedEOF 2052 } 2053 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2054 return err 2055 } 2056 iNdEx = postIndex 2057 default: 2058 iNdEx = preIndex 2059 skippy, err := skipNamespace(dAtA[iNdEx:]) 2060 if err != nil { 2061 return err 2062 } 2063 if skippy < 0 { 2064 return ErrInvalidLengthNamespace 2065 } 2066 if (iNdEx + skippy) < 0 { 2067 return ErrInvalidLengthNamespace 2068 } 2069 if (iNdEx + skippy) > l { 2070 return io.ErrUnexpectedEOF 2071 } 2072 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2073 iNdEx += skippy 2074 } 2075 } 2076 2077 if iNdEx > l { 2078 return io.ErrUnexpectedEOF 2079 } 2080 return nil 2081} 2082func (m *CreateNamespaceResponse) Unmarshal(dAtA []byte) error { 2083 l := len(dAtA) 2084 iNdEx := 0 2085 for iNdEx < l { 2086 preIndex := iNdEx 2087 var wire uint64 2088 for shift := uint(0); ; shift += 7 { 2089 if shift >= 64 { 2090 return ErrIntOverflowNamespace 2091 } 2092 if iNdEx >= l { 2093 return io.ErrUnexpectedEOF 2094 } 2095 b := dAtA[iNdEx] 2096 iNdEx++ 2097 wire |= uint64(b&0x7F) << shift 2098 if b < 0x80 { 2099 break 2100 } 2101 } 2102 fieldNum := int32(wire >> 3) 2103 wireType := int(wire & 0x7) 2104 if wireType == 4 { 2105 return fmt.Errorf("proto: CreateNamespaceResponse: wiretype end group for non-group") 2106 } 2107 if fieldNum <= 0 { 2108 return fmt.Errorf("proto: CreateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) 2109 } 2110 switch fieldNum { 2111 case 1: 2112 if wireType != 2 { 2113 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 2114 } 2115 var msglen int 2116 for shift := uint(0); ; shift += 7 { 2117 if shift >= 64 { 2118 return ErrIntOverflowNamespace 2119 } 2120 if iNdEx >= l { 2121 return io.ErrUnexpectedEOF 2122 } 2123 b := dAtA[iNdEx] 2124 iNdEx++ 2125 msglen |= int(b&0x7F) << shift 2126 if b < 0x80 { 2127 break 2128 } 2129 } 2130 if msglen < 0 { 2131 return ErrInvalidLengthNamespace 2132 } 2133 postIndex := iNdEx + msglen 2134 if postIndex < 0 { 2135 return ErrInvalidLengthNamespace 2136 } 2137 if postIndex > l { 2138 return io.ErrUnexpectedEOF 2139 } 2140 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2141 return err 2142 } 2143 iNdEx = postIndex 2144 default: 2145 iNdEx = preIndex 2146 skippy, err := skipNamespace(dAtA[iNdEx:]) 2147 if err != nil { 2148 return err 2149 } 2150 if skippy < 0 { 2151 return ErrInvalidLengthNamespace 2152 } 2153 if (iNdEx + skippy) < 0 { 2154 return ErrInvalidLengthNamespace 2155 } 2156 if (iNdEx + skippy) > l { 2157 return io.ErrUnexpectedEOF 2158 } 2159 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2160 iNdEx += skippy 2161 } 2162 } 2163 2164 if iNdEx > l { 2165 return io.ErrUnexpectedEOF 2166 } 2167 return nil 2168} 2169func (m *UpdateNamespaceRequest) Unmarshal(dAtA []byte) error { 2170 l := len(dAtA) 2171 iNdEx := 0 2172 for iNdEx < l { 2173 preIndex := iNdEx 2174 var wire uint64 2175 for shift := uint(0); ; shift += 7 { 2176 if shift >= 64 { 2177 return ErrIntOverflowNamespace 2178 } 2179 if iNdEx >= l { 2180 return io.ErrUnexpectedEOF 2181 } 2182 b := dAtA[iNdEx] 2183 iNdEx++ 2184 wire |= uint64(b&0x7F) << shift 2185 if b < 0x80 { 2186 break 2187 } 2188 } 2189 fieldNum := int32(wire >> 3) 2190 wireType := int(wire & 0x7) 2191 if wireType == 4 { 2192 return fmt.Errorf("proto: UpdateNamespaceRequest: wiretype end group for non-group") 2193 } 2194 if fieldNum <= 0 { 2195 return fmt.Errorf("proto: UpdateNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 2196 } 2197 switch fieldNum { 2198 case 1: 2199 if wireType != 2 { 2200 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 2201 } 2202 var msglen int 2203 for shift := uint(0); ; shift += 7 { 2204 if shift >= 64 { 2205 return ErrIntOverflowNamespace 2206 } 2207 if iNdEx >= l { 2208 return io.ErrUnexpectedEOF 2209 } 2210 b := dAtA[iNdEx] 2211 iNdEx++ 2212 msglen |= int(b&0x7F) << shift 2213 if b < 0x80 { 2214 break 2215 } 2216 } 2217 if msglen < 0 { 2218 return ErrInvalidLengthNamespace 2219 } 2220 postIndex := iNdEx + msglen 2221 if postIndex < 0 { 2222 return ErrInvalidLengthNamespace 2223 } 2224 if postIndex > l { 2225 return io.ErrUnexpectedEOF 2226 } 2227 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2228 return err 2229 } 2230 iNdEx = postIndex 2231 case 2: 2232 if wireType != 2 { 2233 return fmt.Errorf("proto: wrong wireType = %d for field UpdateMask", wireType) 2234 } 2235 var msglen int 2236 for shift := uint(0); ; shift += 7 { 2237 if shift >= 64 { 2238 return ErrIntOverflowNamespace 2239 } 2240 if iNdEx >= l { 2241 return io.ErrUnexpectedEOF 2242 } 2243 b := dAtA[iNdEx] 2244 iNdEx++ 2245 msglen |= int(b&0x7F) << shift 2246 if b < 0x80 { 2247 break 2248 } 2249 } 2250 if msglen < 0 { 2251 return ErrInvalidLengthNamespace 2252 } 2253 postIndex := iNdEx + msglen 2254 if postIndex < 0 { 2255 return ErrInvalidLengthNamespace 2256 } 2257 if postIndex > l { 2258 return io.ErrUnexpectedEOF 2259 } 2260 if m.UpdateMask == nil { 2261 m.UpdateMask = &types.FieldMask{} 2262 } 2263 if err := m.UpdateMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2264 return err 2265 } 2266 iNdEx = postIndex 2267 default: 2268 iNdEx = preIndex 2269 skippy, err := skipNamespace(dAtA[iNdEx:]) 2270 if err != nil { 2271 return err 2272 } 2273 if skippy < 0 { 2274 return ErrInvalidLengthNamespace 2275 } 2276 if (iNdEx + skippy) < 0 { 2277 return ErrInvalidLengthNamespace 2278 } 2279 if (iNdEx + skippy) > l { 2280 return io.ErrUnexpectedEOF 2281 } 2282 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2283 iNdEx += skippy 2284 } 2285 } 2286 2287 if iNdEx > l { 2288 return io.ErrUnexpectedEOF 2289 } 2290 return nil 2291} 2292func (m *UpdateNamespaceResponse) Unmarshal(dAtA []byte) error { 2293 l := len(dAtA) 2294 iNdEx := 0 2295 for iNdEx < l { 2296 preIndex := iNdEx 2297 var wire uint64 2298 for shift := uint(0); ; shift += 7 { 2299 if shift >= 64 { 2300 return ErrIntOverflowNamespace 2301 } 2302 if iNdEx >= l { 2303 return io.ErrUnexpectedEOF 2304 } 2305 b := dAtA[iNdEx] 2306 iNdEx++ 2307 wire |= uint64(b&0x7F) << shift 2308 if b < 0x80 { 2309 break 2310 } 2311 } 2312 fieldNum := int32(wire >> 3) 2313 wireType := int(wire & 0x7) 2314 if wireType == 4 { 2315 return fmt.Errorf("proto: UpdateNamespaceResponse: wiretype end group for non-group") 2316 } 2317 if fieldNum <= 0 { 2318 return fmt.Errorf("proto: UpdateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) 2319 } 2320 switch fieldNum { 2321 case 1: 2322 if wireType != 2 { 2323 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 2324 } 2325 var msglen int 2326 for shift := uint(0); ; shift += 7 { 2327 if shift >= 64 { 2328 return ErrIntOverflowNamespace 2329 } 2330 if iNdEx >= l { 2331 return io.ErrUnexpectedEOF 2332 } 2333 b := dAtA[iNdEx] 2334 iNdEx++ 2335 msglen |= int(b&0x7F) << shift 2336 if b < 0x80 { 2337 break 2338 } 2339 } 2340 if msglen < 0 { 2341 return ErrInvalidLengthNamespace 2342 } 2343 postIndex := iNdEx + msglen 2344 if postIndex < 0 { 2345 return ErrInvalidLengthNamespace 2346 } 2347 if postIndex > l { 2348 return io.ErrUnexpectedEOF 2349 } 2350 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2351 return err 2352 } 2353 iNdEx = postIndex 2354 default: 2355 iNdEx = preIndex 2356 skippy, err := skipNamespace(dAtA[iNdEx:]) 2357 if err != nil { 2358 return err 2359 } 2360 if skippy < 0 { 2361 return ErrInvalidLengthNamespace 2362 } 2363 if (iNdEx + skippy) < 0 { 2364 return ErrInvalidLengthNamespace 2365 } 2366 if (iNdEx + skippy) > l { 2367 return io.ErrUnexpectedEOF 2368 } 2369 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2370 iNdEx += skippy 2371 } 2372 } 2373 2374 if iNdEx > l { 2375 return io.ErrUnexpectedEOF 2376 } 2377 return nil 2378} 2379func (m *DeleteNamespaceRequest) Unmarshal(dAtA []byte) error { 2380 l := len(dAtA) 2381 iNdEx := 0 2382 for iNdEx < l { 2383 preIndex := iNdEx 2384 var wire uint64 2385 for shift := uint(0); ; shift += 7 { 2386 if shift >= 64 { 2387 return ErrIntOverflowNamespace 2388 } 2389 if iNdEx >= l { 2390 return io.ErrUnexpectedEOF 2391 } 2392 b := dAtA[iNdEx] 2393 iNdEx++ 2394 wire |= uint64(b&0x7F) << shift 2395 if b < 0x80 { 2396 break 2397 } 2398 } 2399 fieldNum := int32(wire >> 3) 2400 wireType := int(wire & 0x7) 2401 if wireType == 4 { 2402 return fmt.Errorf("proto: DeleteNamespaceRequest: wiretype end group for non-group") 2403 } 2404 if fieldNum <= 0 { 2405 return fmt.Errorf("proto: DeleteNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 2406 } 2407 switch fieldNum { 2408 case 1: 2409 if wireType != 2 { 2410 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 2411 } 2412 var stringLen uint64 2413 for shift := uint(0); ; shift += 7 { 2414 if shift >= 64 { 2415 return ErrIntOverflowNamespace 2416 } 2417 if iNdEx >= l { 2418 return io.ErrUnexpectedEOF 2419 } 2420 b := dAtA[iNdEx] 2421 iNdEx++ 2422 stringLen |= uint64(b&0x7F) << shift 2423 if b < 0x80 { 2424 break 2425 } 2426 } 2427 intStringLen := int(stringLen) 2428 if intStringLen < 0 { 2429 return ErrInvalidLengthNamespace 2430 } 2431 postIndex := iNdEx + intStringLen 2432 if postIndex < 0 { 2433 return ErrInvalidLengthNamespace 2434 } 2435 if postIndex > l { 2436 return io.ErrUnexpectedEOF 2437 } 2438 m.Name = string(dAtA[iNdEx:postIndex]) 2439 iNdEx = postIndex 2440 default: 2441 iNdEx = preIndex 2442 skippy, err := skipNamespace(dAtA[iNdEx:]) 2443 if err != nil { 2444 return err 2445 } 2446 if skippy < 0 { 2447 return ErrInvalidLengthNamespace 2448 } 2449 if (iNdEx + skippy) < 0 { 2450 return ErrInvalidLengthNamespace 2451 } 2452 if (iNdEx + skippy) > l { 2453 return io.ErrUnexpectedEOF 2454 } 2455 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 2456 iNdEx += skippy 2457 } 2458 } 2459 2460 if iNdEx > l { 2461 return io.ErrUnexpectedEOF 2462 } 2463 return nil 2464} 2465func skipNamespace(dAtA []byte) (n int, err error) { 2466 l := len(dAtA) 2467 iNdEx := 0 2468 depth := 0 2469 for iNdEx < l { 2470 var wire uint64 2471 for shift := uint(0); ; shift += 7 { 2472 if shift >= 64 { 2473 return 0, ErrIntOverflowNamespace 2474 } 2475 if iNdEx >= l { 2476 return 0, io.ErrUnexpectedEOF 2477 } 2478 b := dAtA[iNdEx] 2479 iNdEx++ 2480 wire |= (uint64(b) & 0x7F) << shift 2481 if b < 0x80 { 2482 break 2483 } 2484 } 2485 wireType := int(wire & 0x7) 2486 switch wireType { 2487 case 0: 2488 for shift := uint(0); ; shift += 7 { 2489 if shift >= 64 { 2490 return 0, ErrIntOverflowNamespace 2491 } 2492 if iNdEx >= l { 2493 return 0, io.ErrUnexpectedEOF 2494 } 2495 iNdEx++ 2496 if dAtA[iNdEx-1] < 0x80 { 2497 break 2498 } 2499 } 2500 case 1: 2501 iNdEx += 8 2502 case 2: 2503 var length int 2504 for shift := uint(0); ; shift += 7 { 2505 if shift >= 64 { 2506 return 0, ErrIntOverflowNamespace 2507 } 2508 if iNdEx >= l { 2509 return 0, io.ErrUnexpectedEOF 2510 } 2511 b := dAtA[iNdEx] 2512 iNdEx++ 2513 length |= (int(b) & 0x7F) << shift 2514 if b < 0x80 { 2515 break 2516 } 2517 } 2518 if length < 0 { 2519 return 0, ErrInvalidLengthNamespace 2520 } 2521 iNdEx += length 2522 case 3: 2523 depth++ 2524 case 4: 2525 if depth == 0 { 2526 return 0, ErrUnexpectedEndOfGroupNamespace 2527 } 2528 depth-- 2529 case 5: 2530 iNdEx += 4 2531 default: 2532 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 2533 } 2534 if iNdEx < 0 { 2535 return 0, ErrInvalidLengthNamespace 2536 } 2537 if depth == 0 { 2538 return iNdEx, nil 2539 } 2540 } 2541 return 0, io.ErrUnexpectedEOF 2542} 2543 2544var ( 2545 ErrInvalidLengthNamespace = fmt.Errorf("proto: negative length found during unmarshaling") 2546 ErrIntOverflowNamespace = fmt.Errorf("proto: integer overflow") 2547 ErrUnexpectedEndOfGroupNamespace = fmt.Errorf("proto: unexpected end of group") 2548) 2549