1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto 3 4/* 5 Package namespaces is a generated protocol buffer package. 6 7 It is generated from these files: 8 github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto 9 10 It has these top-level messages: 11 Namespace 12 GetNamespaceRequest 13 GetNamespaceResponse 14 ListNamespacesRequest 15 ListNamespacesResponse 16 CreateNamespaceRequest 17 CreateNamespaceResponse 18 UpdateNamespaceRequest 19 UpdateNamespaceResponse 20 DeleteNamespaceRequest 21*/ 22package namespaces 23 24import proto "github.com/gogo/protobuf/proto" 25import fmt "fmt" 26import math "math" 27 28// skipping weak import gogoproto "github.com/gogo/protobuf/gogoproto" 29import google_protobuf1 "github.com/gogo/protobuf/types" 30import google_protobuf2 "github.com/gogo/protobuf/types" 31 32import context "golang.org/x/net/context" 33import grpc "google.golang.org/grpc" 34 35import strings "strings" 36import reflect "reflect" 37import sortkeys "github.com/gogo/protobuf/sortkeys" 38 39import io "io" 40 41// Reference imports to suppress errors if they are not otherwise used. 42var _ = proto.Marshal 43var _ = fmt.Errorf 44var _ = math.Inf 45 46// This is a compile-time assertion to ensure that this generated file 47// is compatible with the proto package it is being compiled against. 48// A compilation error at this line likely means your copy of the 49// proto package needs to be updated. 50const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 51 52type Namespace struct { 53 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 54 // Labels provides an area to include arbitrary data on namespaces. 55 // 56 // The combined size of a key/value pair cannot exceed 4096 bytes. 57 // 58 // Note that to add a new value to this field, read the existing set and 59 // include the entire result in the update call. 60 Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` 61} 62 63func (m *Namespace) Reset() { *m = Namespace{} } 64func (*Namespace) ProtoMessage() {} 65func (*Namespace) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{0} } 66 67type GetNamespaceRequest struct { 68 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 69} 70 71func (m *GetNamespaceRequest) Reset() { *m = GetNamespaceRequest{} } 72func (*GetNamespaceRequest) ProtoMessage() {} 73func (*GetNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{1} } 74 75type GetNamespaceResponse struct { 76 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace" json:"namespace"` 77} 78 79func (m *GetNamespaceResponse) Reset() { *m = GetNamespaceResponse{} } 80func (*GetNamespaceResponse) ProtoMessage() {} 81func (*GetNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{2} } 82 83type ListNamespacesRequest struct { 84 Filter string `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` 85} 86 87func (m *ListNamespacesRequest) Reset() { *m = ListNamespacesRequest{} } 88func (*ListNamespacesRequest) ProtoMessage() {} 89func (*ListNamespacesRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{3} } 90 91type ListNamespacesResponse struct { 92 Namespaces []Namespace `protobuf:"bytes,1,rep,name=namespaces" json:"namespaces"` 93} 94 95func (m *ListNamespacesResponse) Reset() { *m = ListNamespacesResponse{} } 96func (*ListNamespacesResponse) ProtoMessage() {} 97func (*ListNamespacesResponse) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{4} } 98 99type CreateNamespaceRequest struct { 100 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace" json:"namespace"` 101} 102 103func (m *CreateNamespaceRequest) Reset() { *m = CreateNamespaceRequest{} } 104func (*CreateNamespaceRequest) ProtoMessage() {} 105func (*CreateNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{5} } 106 107type CreateNamespaceResponse struct { 108 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace" json:"namespace"` 109} 110 111func (m *CreateNamespaceResponse) Reset() { *m = CreateNamespaceResponse{} } 112func (*CreateNamespaceResponse) ProtoMessage() {} 113func (*CreateNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{6} } 114 115// UpdateNamespaceRequest updates the metadata for a namespace. 116// 117// The operation should follow semantics described in 118// https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/field-mask, 119// unless otherwise qualified. 120type UpdateNamespaceRequest struct { 121 // Namespace provides the target value, as declared by the mask, for the update. 122 // 123 // The namespace field must be set. 124 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace" json:"namespace"` 125 // UpdateMask specifies which fields to perform the update on. If empty, 126 // the operation applies to all fields. 127 // 128 // For the most part, this applies only to selectively updating labels on 129 // the namespace. While field masks are typically limited to ascii alphas 130 // and digits, we just take everything after the "labels." as the map key. 131 UpdateMask *google_protobuf2.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask" json:"update_mask,omitempty"` 132} 133 134func (m *UpdateNamespaceRequest) Reset() { *m = UpdateNamespaceRequest{} } 135func (*UpdateNamespaceRequest) ProtoMessage() {} 136func (*UpdateNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{7} } 137 138type UpdateNamespaceResponse struct { 139 Namespace Namespace `protobuf:"bytes,1,opt,name=namespace" json:"namespace"` 140} 141 142func (m *UpdateNamespaceResponse) Reset() { *m = UpdateNamespaceResponse{} } 143func (*UpdateNamespaceResponse) ProtoMessage() {} 144func (*UpdateNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{8} } 145 146type DeleteNamespaceRequest struct { 147 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 148} 149 150func (m *DeleteNamespaceRequest) Reset() { *m = DeleteNamespaceRequest{} } 151func (*DeleteNamespaceRequest) ProtoMessage() {} 152func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorNamespace, []int{9} } 153 154func init() { 155 proto.RegisterType((*Namespace)(nil), "containerd.services.namespaces.v1.Namespace") 156 proto.RegisterType((*GetNamespaceRequest)(nil), "containerd.services.namespaces.v1.GetNamespaceRequest") 157 proto.RegisterType((*GetNamespaceResponse)(nil), "containerd.services.namespaces.v1.GetNamespaceResponse") 158 proto.RegisterType((*ListNamespacesRequest)(nil), "containerd.services.namespaces.v1.ListNamespacesRequest") 159 proto.RegisterType((*ListNamespacesResponse)(nil), "containerd.services.namespaces.v1.ListNamespacesResponse") 160 proto.RegisterType((*CreateNamespaceRequest)(nil), "containerd.services.namespaces.v1.CreateNamespaceRequest") 161 proto.RegisterType((*CreateNamespaceResponse)(nil), "containerd.services.namespaces.v1.CreateNamespaceResponse") 162 proto.RegisterType((*UpdateNamespaceRequest)(nil), "containerd.services.namespaces.v1.UpdateNamespaceRequest") 163 proto.RegisterType((*UpdateNamespaceResponse)(nil), "containerd.services.namespaces.v1.UpdateNamespaceResponse") 164 proto.RegisterType((*DeleteNamespaceRequest)(nil), "containerd.services.namespaces.v1.DeleteNamespaceRequest") 165} 166 167// Reference imports to suppress errors if they are not otherwise used. 168var _ context.Context 169var _ grpc.ClientConn 170 171// This is a compile-time assertion to ensure that this generated file 172// is compatible with the grpc package it is being compiled against. 173const _ = grpc.SupportPackageIsVersion4 174 175// Client API for Namespaces service 176 177type NamespacesClient interface { 178 Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) 179 List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) 180 Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) 181 Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) 182 Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) 183} 184 185type namespacesClient struct { 186 cc *grpc.ClientConn 187} 188 189func NewNamespacesClient(cc *grpc.ClientConn) NamespacesClient { 190 return &namespacesClient{cc} 191} 192 193func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) { 194 out := new(GetNamespaceResponse) 195 err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Get", in, out, c.cc, opts...) 196 if err != nil { 197 return nil, err 198 } 199 return out, nil 200} 201 202func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) { 203 out := new(ListNamespacesResponse) 204 err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/List", in, out, c.cc, opts...) 205 if err != nil { 206 return nil, err 207 } 208 return out, nil 209} 210 211func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) { 212 out := new(CreateNamespaceResponse) 213 err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Create", in, out, c.cc, opts...) 214 if err != nil { 215 return nil, err 216 } 217 return out, nil 218} 219 220func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) { 221 out := new(UpdateNamespaceResponse) 222 err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Update", in, out, c.cc, opts...) 223 if err != nil { 224 return nil, err 225 } 226 return out, nil 227} 228 229func (c *namespacesClient) Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) { 230 out := new(google_protobuf1.Empty) 231 err := grpc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Delete", in, out, c.cc, opts...) 232 if err != nil { 233 return nil, err 234 } 235 return out, nil 236} 237 238// Server API for Namespaces service 239 240type NamespacesServer interface { 241 Get(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error) 242 List(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error) 243 Create(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error) 244 Update(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) 245 Delete(context.Context, *DeleteNamespaceRequest) (*google_protobuf1.Empty, error) 246} 247 248func RegisterNamespacesServer(s *grpc.Server, srv NamespacesServer) { 249 s.RegisterService(&_Namespaces_serviceDesc, srv) 250} 251 252func _Namespaces_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 253 in := new(GetNamespaceRequest) 254 if err := dec(in); err != nil { 255 return nil, err 256 } 257 if interceptor == nil { 258 return srv.(NamespacesServer).Get(ctx, in) 259 } 260 info := &grpc.UnaryServerInfo{ 261 Server: srv, 262 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Get", 263 } 264 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 265 return srv.(NamespacesServer).Get(ctx, req.(*GetNamespaceRequest)) 266 } 267 return interceptor(ctx, in, info, handler) 268} 269 270func _Namespaces_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 271 in := new(ListNamespacesRequest) 272 if err := dec(in); err != nil { 273 return nil, err 274 } 275 if interceptor == nil { 276 return srv.(NamespacesServer).List(ctx, in) 277 } 278 info := &grpc.UnaryServerInfo{ 279 Server: srv, 280 FullMethod: "/containerd.services.namespaces.v1.Namespaces/List", 281 } 282 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 283 return srv.(NamespacesServer).List(ctx, req.(*ListNamespacesRequest)) 284 } 285 return interceptor(ctx, in, info, handler) 286} 287 288func _Namespaces_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 289 in := new(CreateNamespaceRequest) 290 if err := dec(in); err != nil { 291 return nil, err 292 } 293 if interceptor == nil { 294 return srv.(NamespacesServer).Create(ctx, in) 295 } 296 info := &grpc.UnaryServerInfo{ 297 Server: srv, 298 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Create", 299 } 300 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 301 return srv.(NamespacesServer).Create(ctx, req.(*CreateNamespaceRequest)) 302 } 303 return interceptor(ctx, in, info, handler) 304} 305 306func _Namespaces_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 307 in := new(UpdateNamespaceRequest) 308 if err := dec(in); err != nil { 309 return nil, err 310 } 311 if interceptor == nil { 312 return srv.(NamespacesServer).Update(ctx, in) 313 } 314 info := &grpc.UnaryServerInfo{ 315 Server: srv, 316 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Update", 317 } 318 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 319 return srv.(NamespacesServer).Update(ctx, req.(*UpdateNamespaceRequest)) 320 } 321 return interceptor(ctx, in, info, handler) 322} 323 324func _Namespaces_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 325 in := new(DeleteNamespaceRequest) 326 if err := dec(in); err != nil { 327 return nil, err 328 } 329 if interceptor == nil { 330 return srv.(NamespacesServer).Delete(ctx, in) 331 } 332 info := &grpc.UnaryServerInfo{ 333 Server: srv, 334 FullMethod: "/containerd.services.namespaces.v1.Namespaces/Delete", 335 } 336 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 337 return srv.(NamespacesServer).Delete(ctx, req.(*DeleteNamespaceRequest)) 338 } 339 return interceptor(ctx, in, info, handler) 340} 341 342var _Namespaces_serviceDesc = grpc.ServiceDesc{ 343 ServiceName: "containerd.services.namespaces.v1.Namespaces", 344 HandlerType: (*NamespacesServer)(nil), 345 Methods: []grpc.MethodDesc{ 346 { 347 MethodName: "Get", 348 Handler: _Namespaces_Get_Handler, 349 }, 350 { 351 MethodName: "List", 352 Handler: _Namespaces_List_Handler, 353 }, 354 { 355 MethodName: "Create", 356 Handler: _Namespaces_Create_Handler, 357 }, 358 { 359 MethodName: "Update", 360 Handler: _Namespaces_Update_Handler, 361 }, 362 { 363 MethodName: "Delete", 364 Handler: _Namespaces_Delete_Handler, 365 }, 366 }, 367 Streams: []grpc.StreamDesc{}, 368 Metadata: "github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto", 369} 370 371func (m *Namespace) Marshal() (dAtA []byte, err error) { 372 size := m.Size() 373 dAtA = make([]byte, size) 374 n, err := m.MarshalTo(dAtA) 375 if err != nil { 376 return nil, err 377 } 378 return dAtA[:n], nil 379} 380 381func (m *Namespace) MarshalTo(dAtA []byte) (int, error) { 382 var i int 383 _ = i 384 var l int 385 _ = l 386 if len(m.Name) > 0 { 387 dAtA[i] = 0xa 388 i++ 389 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) 390 i += copy(dAtA[i:], m.Name) 391 } 392 if len(m.Labels) > 0 { 393 for k, _ := range m.Labels { 394 dAtA[i] = 0x12 395 i++ 396 v := m.Labels[k] 397 mapSize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v))) 398 i = encodeVarintNamespace(dAtA, i, uint64(mapSize)) 399 dAtA[i] = 0xa 400 i++ 401 i = encodeVarintNamespace(dAtA, i, uint64(len(k))) 402 i += copy(dAtA[i:], k) 403 dAtA[i] = 0x12 404 i++ 405 i = encodeVarintNamespace(dAtA, i, uint64(len(v))) 406 i += copy(dAtA[i:], v) 407 } 408 } 409 return i, nil 410} 411 412func (m *GetNamespaceRequest) Marshal() (dAtA []byte, err error) { 413 size := m.Size() 414 dAtA = make([]byte, size) 415 n, err := m.MarshalTo(dAtA) 416 if err != nil { 417 return nil, err 418 } 419 return dAtA[:n], nil 420} 421 422func (m *GetNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 423 var i int 424 _ = i 425 var l int 426 _ = l 427 if len(m.Name) > 0 { 428 dAtA[i] = 0xa 429 i++ 430 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) 431 i += copy(dAtA[i:], m.Name) 432 } 433 return i, nil 434} 435 436func (m *GetNamespaceResponse) Marshal() (dAtA []byte, err error) { 437 size := m.Size() 438 dAtA = make([]byte, size) 439 n, err := m.MarshalTo(dAtA) 440 if err != nil { 441 return nil, err 442 } 443 return dAtA[:n], nil 444} 445 446func (m *GetNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { 447 var i int 448 _ = i 449 var l int 450 _ = l 451 dAtA[i] = 0xa 452 i++ 453 i = encodeVarintNamespace(dAtA, i, uint64(m.Namespace.Size())) 454 n1, err := m.Namespace.MarshalTo(dAtA[i:]) 455 if err != nil { 456 return 0, err 457 } 458 i += n1 459 return i, nil 460} 461 462func (m *ListNamespacesRequest) Marshal() (dAtA []byte, err error) { 463 size := m.Size() 464 dAtA = make([]byte, size) 465 n, err := m.MarshalTo(dAtA) 466 if err != nil { 467 return nil, err 468 } 469 return dAtA[:n], nil 470} 471 472func (m *ListNamespacesRequest) MarshalTo(dAtA []byte) (int, error) { 473 var i int 474 _ = i 475 var l int 476 _ = l 477 if len(m.Filter) > 0 { 478 dAtA[i] = 0xa 479 i++ 480 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Filter))) 481 i += copy(dAtA[i:], m.Filter) 482 } 483 return i, nil 484} 485 486func (m *ListNamespacesResponse) Marshal() (dAtA []byte, err error) { 487 size := m.Size() 488 dAtA = make([]byte, size) 489 n, err := m.MarshalTo(dAtA) 490 if err != nil { 491 return nil, err 492 } 493 return dAtA[:n], nil 494} 495 496func (m *ListNamespacesResponse) MarshalTo(dAtA []byte) (int, error) { 497 var i int 498 _ = i 499 var l int 500 _ = l 501 if len(m.Namespaces) > 0 { 502 for _, msg := range m.Namespaces { 503 dAtA[i] = 0xa 504 i++ 505 i = encodeVarintNamespace(dAtA, i, uint64(msg.Size())) 506 n, err := msg.MarshalTo(dAtA[i:]) 507 if err != nil { 508 return 0, err 509 } 510 i += n 511 } 512 } 513 return i, nil 514} 515 516func (m *CreateNamespaceRequest) Marshal() (dAtA []byte, err error) { 517 size := m.Size() 518 dAtA = make([]byte, size) 519 n, err := m.MarshalTo(dAtA) 520 if err != nil { 521 return nil, err 522 } 523 return dAtA[:n], nil 524} 525 526func (m *CreateNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 527 var i int 528 _ = i 529 var l int 530 _ = l 531 dAtA[i] = 0xa 532 i++ 533 i = encodeVarintNamespace(dAtA, i, uint64(m.Namespace.Size())) 534 n2, err := m.Namespace.MarshalTo(dAtA[i:]) 535 if err != nil { 536 return 0, err 537 } 538 i += n2 539 return i, nil 540} 541 542func (m *CreateNamespaceResponse) Marshal() (dAtA []byte, err error) { 543 size := m.Size() 544 dAtA = make([]byte, size) 545 n, err := m.MarshalTo(dAtA) 546 if err != nil { 547 return nil, err 548 } 549 return dAtA[:n], nil 550} 551 552func (m *CreateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { 553 var i int 554 _ = i 555 var l int 556 _ = l 557 dAtA[i] = 0xa 558 i++ 559 i = encodeVarintNamespace(dAtA, i, uint64(m.Namespace.Size())) 560 n3, err := m.Namespace.MarshalTo(dAtA[i:]) 561 if err != nil { 562 return 0, err 563 } 564 i += n3 565 return i, nil 566} 567 568func (m *UpdateNamespaceRequest) Marshal() (dAtA []byte, err error) { 569 size := m.Size() 570 dAtA = make([]byte, size) 571 n, err := m.MarshalTo(dAtA) 572 if err != nil { 573 return nil, err 574 } 575 return dAtA[:n], nil 576} 577 578func (m *UpdateNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 579 var i int 580 _ = i 581 var l int 582 _ = l 583 dAtA[i] = 0xa 584 i++ 585 i = encodeVarintNamespace(dAtA, i, uint64(m.Namespace.Size())) 586 n4, err := m.Namespace.MarshalTo(dAtA[i:]) 587 if err != nil { 588 return 0, err 589 } 590 i += n4 591 if m.UpdateMask != nil { 592 dAtA[i] = 0x12 593 i++ 594 i = encodeVarintNamespace(dAtA, i, uint64(m.UpdateMask.Size())) 595 n5, err := m.UpdateMask.MarshalTo(dAtA[i:]) 596 if err != nil { 597 return 0, err 598 } 599 i += n5 600 } 601 return i, nil 602} 603 604func (m *UpdateNamespaceResponse) Marshal() (dAtA []byte, err error) { 605 size := m.Size() 606 dAtA = make([]byte, size) 607 n, err := m.MarshalTo(dAtA) 608 if err != nil { 609 return nil, err 610 } 611 return dAtA[:n], nil 612} 613 614func (m *UpdateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { 615 var i int 616 _ = i 617 var l int 618 _ = l 619 dAtA[i] = 0xa 620 i++ 621 i = encodeVarintNamespace(dAtA, i, uint64(m.Namespace.Size())) 622 n6, err := m.Namespace.MarshalTo(dAtA[i:]) 623 if err != nil { 624 return 0, err 625 } 626 i += n6 627 return i, nil 628} 629 630func (m *DeleteNamespaceRequest) Marshal() (dAtA []byte, err error) { 631 size := m.Size() 632 dAtA = make([]byte, size) 633 n, err := m.MarshalTo(dAtA) 634 if err != nil { 635 return nil, err 636 } 637 return dAtA[:n], nil 638} 639 640func (m *DeleteNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { 641 var i int 642 _ = i 643 var l int 644 _ = l 645 if len(m.Name) > 0 { 646 dAtA[i] = 0xa 647 i++ 648 i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) 649 i += copy(dAtA[i:], m.Name) 650 } 651 return i, nil 652} 653 654func encodeVarintNamespace(dAtA []byte, offset int, v uint64) int { 655 for v >= 1<<7 { 656 dAtA[offset] = uint8(v&0x7f | 0x80) 657 v >>= 7 658 offset++ 659 } 660 dAtA[offset] = uint8(v) 661 return offset + 1 662} 663func (m *Namespace) Size() (n int) { 664 var l int 665 _ = l 666 l = len(m.Name) 667 if l > 0 { 668 n += 1 + l + sovNamespace(uint64(l)) 669 } 670 if len(m.Labels) > 0 { 671 for k, v := range m.Labels { 672 _ = k 673 _ = v 674 mapEntrySize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v))) 675 n += mapEntrySize + 1 + sovNamespace(uint64(mapEntrySize)) 676 } 677 } 678 return n 679} 680 681func (m *GetNamespaceRequest) Size() (n int) { 682 var l int 683 _ = l 684 l = len(m.Name) 685 if l > 0 { 686 n += 1 + l + sovNamespace(uint64(l)) 687 } 688 return n 689} 690 691func (m *GetNamespaceResponse) Size() (n int) { 692 var l int 693 _ = l 694 l = m.Namespace.Size() 695 n += 1 + l + sovNamespace(uint64(l)) 696 return n 697} 698 699func (m *ListNamespacesRequest) Size() (n int) { 700 var l int 701 _ = l 702 l = len(m.Filter) 703 if l > 0 { 704 n += 1 + l + sovNamespace(uint64(l)) 705 } 706 return n 707} 708 709func (m *ListNamespacesResponse) Size() (n int) { 710 var l int 711 _ = l 712 if len(m.Namespaces) > 0 { 713 for _, e := range m.Namespaces { 714 l = e.Size() 715 n += 1 + l + sovNamespace(uint64(l)) 716 } 717 } 718 return n 719} 720 721func (m *CreateNamespaceRequest) Size() (n int) { 722 var l int 723 _ = l 724 l = m.Namespace.Size() 725 n += 1 + l + sovNamespace(uint64(l)) 726 return n 727} 728 729func (m *CreateNamespaceResponse) Size() (n int) { 730 var l int 731 _ = l 732 l = m.Namespace.Size() 733 n += 1 + l + sovNamespace(uint64(l)) 734 return n 735} 736 737func (m *UpdateNamespaceRequest) Size() (n int) { 738 var l int 739 _ = l 740 l = m.Namespace.Size() 741 n += 1 + l + sovNamespace(uint64(l)) 742 if m.UpdateMask != nil { 743 l = m.UpdateMask.Size() 744 n += 1 + l + sovNamespace(uint64(l)) 745 } 746 return n 747} 748 749func (m *UpdateNamespaceResponse) Size() (n int) { 750 var l int 751 _ = l 752 l = m.Namespace.Size() 753 n += 1 + l + sovNamespace(uint64(l)) 754 return n 755} 756 757func (m *DeleteNamespaceRequest) Size() (n int) { 758 var l int 759 _ = l 760 l = len(m.Name) 761 if l > 0 { 762 n += 1 + l + sovNamespace(uint64(l)) 763 } 764 return n 765} 766 767func sovNamespace(x uint64) (n int) { 768 for { 769 n++ 770 x >>= 7 771 if x == 0 { 772 break 773 } 774 } 775 return n 776} 777func sozNamespace(x uint64) (n int) { 778 return sovNamespace(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 779} 780func (this *Namespace) String() string { 781 if this == nil { 782 return "nil" 783 } 784 keysForLabels := make([]string, 0, len(this.Labels)) 785 for k, _ := range this.Labels { 786 keysForLabels = append(keysForLabels, k) 787 } 788 sortkeys.Strings(keysForLabels) 789 mapStringForLabels := "map[string]string{" 790 for _, k := range keysForLabels { 791 mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) 792 } 793 mapStringForLabels += "}" 794 s := strings.Join([]string{`&Namespace{`, 795 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 796 `Labels:` + mapStringForLabels + `,`, 797 `}`, 798 }, "") 799 return s 800} 801func (this *GetNamespaceRequest) String() string { 802 if this == nil { 803 return "nil" 804 } 805 s := strings.Join([]string{`&GetNamespaceRequest{`, 806 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 807 `}`, 808 }, "") 809 return s 810} 811func (this *GetNamespaceResponse) String() string { 812 if this == nil { 813 return "nil" 814 } 815 s := strings.Join([]string{`&GetNamespaceResponse{`, 816 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 817 `}`, 818 }, "") 819 return s 820} 821func (this *ListNamespacesRequest) String() string { 822 if this == nil { 823 return "nil" 824 } 825 s := strings.Join([]string{`&ListNamespacesRequest{`, 826 `Filter:` + fmt.Sprintf("%v", this.Filter) + `,`, 827 `}`, 828 }, "") 829 return s 830} 831func (this *ListNamespacesResponse) String() string { 832 if this == nil { 833 return "nil" 834 } 835 s := strings.Join([]string{`&ListNamespacesResponse{`, 836 `Namespaces:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Namespaces), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 837 `}`, 838 }, "") 839 return s 840} 841func (this *CreateNamespaceRequest) String() string { 842 if this == nil { 843 return "nil" 844 } 845 s := strings.Join([]string{`&CreateNamespaceRequest{`, 846 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 847 `}`, 848 }, "") 849 return s 850} 851func (this *CreateNamespaceResponse) String() string { 852 if this == nil { 853 return "nil" 854 } 855 s := strings.Join([]string{`&CreateNamespaceResponse{`, 856 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 857 `}`, 858 }, "") 859 return s 860} 861func (this *UpdateNamespaceRequest) String() string { 862 if this == nil { 863 return "nil" 864 } 865 s := strings.Join([]string{`&UpdateNamespaceRequest{`, 866 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 867 `UpdateMask:` + strings.Replace(fmt.Sprintf("%v", this.UpdateMask), "FieldMask", "google_protobuf2.FieldMask", 1) + `,`, 868 `}`, 869 }, "") 870 return s 871} 872func (this *UpdateNamespaceResponse) String() string { 873 if this == nil { 874 return "nil" 875 } 876 s := strings.Join([]string{`&UpdateNamespaceResponse{`, 877 `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, 878 `}`, 879 }, "") 880 return s 881} 882func (this *DeleteNamespaceRequest) String() string { 883 if this == nil { 884 return "nil" 885 } 886 s := strings.Join([]string{`&DeleteNamespaceRequest{`, 887 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 888 `}`, 889 }, "") 890 return s 891} 892func valueToStringNamespace(v interface{}) string { 893 rv := reflect.ValueOf(v) 894 if rv.IsNil() { 895 return "nil" 896 } 897 pv := reflect.Indirect(rv).Interface() 898 return fmt.Sprintf("*%v", pv) 899} 900func (m *Namespace) Unmarshal(dAtA []byte) error { 901 l := len(dAtA) 902 iNdEx := 0 903 for iNdEx < l { 904 preIndex := iNdEx 905 var wire uint64 906 for shift := uint(0); ; shift += 7 { 907 if shift >= 64 { 908 return ErrIntOverflowNamespace 909 } 910 if iNdEx >= l { 911 return io.ErrUnexpectedEOF 912 } 913 b := dAtA[iNdEx] 914 iNdEx++ 915 wire |= (uint64(b) & 0x7F) << shift 916 if b < 0x80 { 917 break 918 } 919 } 920 fieldNum := int32(wire >> 3) 921 wireType := int(wire & 0x7) 922 if wireType == 4 { 923 return fmt.Errorf("proto: Namespace: wiretype end group for non-group") 924 } 925 if fieldNum <= 0 { 926 return fmt.Errorf("proto: Namespace: illegal tag %d (wire type %d)", fieldNum, wire) 927 } 928 switch fieldNum { 929 case 1: 930 if wireType != 2 { 931 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 932 } 933 var stringLen uint64 934 for shift := uint(0); ; shift += 7 { 935 if shift >= 64 { 936 return ErrIntOverflowNamespace 937 } 938 if iNdEx >= l { 939 return io.ErrUnexpectedEOF 940 } 941 b := dAtA[iNdEx] 942 iNdEx++ 943 stringLen |= (uint64(b) & 0x7F) << shift 944 if b < 0x80 { 945 break 946 } 947 } 948 intStringLen := int(stringLen) 949 if intStringLen < 0 { 950 return ErrInvalidLengthNamespace 951 } 952 postIndex := iNdEx + intStringLen 953 if postIndex > l { 954 return io.ErrUnexpectedEOF 955 } 956 m.Name = string(dAtA[iNdEx:postIndex]) 957 iNdEx = postIndex 958 case 2: 959 if wireType != 2 { 960 return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) 961 } 962 var msglen int 963 for shift := uint(0); ; shift += 7 { 964 if shift >= 64 { 965 return ErrIntOverflowNamespace 966 } 967 if iNdEx >= l { 968 return io.ErrUnexpectedEOF 969 } 970 b := dAtA[iNdEx] 971 iNdEx++ 972 msglen |= (int(b) & 0x7F) << shift 973 if b < 0x80 { 974 break 975 } 976 } 977 if msglen < 0 { 978 return ErrInvalidLengthNamespace 979 } 980 postIndex := iNdEx + msglen 981 if postIndex > l { 982 return io.ErrUnexpectedEOF 983 } 984 if m.Labels == nil { 985 m.Labels = make(map[string]string) 986 } 987 var mapkey string 988 var mapvalue string 989 for iNdEx < postIndex { 990 entryPreIndex := iNdEx 991 var wire uint64 992 for shift := uint(0); ; shift += 7 { 993 if shift >= 64 { 994 return ErrIntOverflowNamespace 995 } 996 if iNdEx >= l { 997 return io.ErrUnexpectedEOF 998 } 999 b := dAtA[iNdEx] 1000 iNdEx++ 1001 wire |= (uint64(b) & 0x7F) << shift 1002 if b < 0x80 { 1003 break 1004 } 1005 } 1006 fieldNum := int32(wire >> 3) 1007 if fieldNum == 1 { 1008 var stringLenmapkey uint64 1009 for shift := uint(0); ; shift += 7 { 1010 if shift >= 64 { 1011 return ErrIntOverflowNamespace 1012 } 1013 if iNdEx >= l { 1014 return io.ErrUnexpectedEOF 1015 } 1016 b := dAtA[iNdEx] 1017 iNdEx++ 1018 stringLenmapkey |= (uint64(b) & 0x7F) << shift 1019 if b < 0x80 { 1020 break 1021 } 1022 } 1023 intStringLenmapkey := int(stringLenmapkey) 1024 if intStringLenmapkey < 0 { 1025 return ErrInvalidLengthNamespace 1026 } 1027 postStringIndexmapkey := iNdEx + intStringLenmapkey 1028 if postStringIndexmapkey > l { 1029 return io.ErrUnexpectedEOF 1030 } 1031 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 1032 iNdEx = postStringIndexmapkey 1033 } else if fieldNum == 2 { 1034 var stringLenmapvalue uint64 1035 for shift := uint(0); ; shift += 7 { 1036 if shift >= 64 { 1037 return ErrIntOverflowNamespace 1038 } 1039 if iNdEx >= l { 1040 return io.ErrUnexpectedEOF 1041 } 1042 b := dAtA[iNdEx] 1043 iNdEx++ 1044 stringLenmapvalue |= (uint64(b) & 0x7F) << shift 1045 if b < 0x80 { 1046 break 1047 } 1048 } 1049 intStringLenmapvalue := int(stringLenmapvalue) 1050 if intStringLenmapvalue < 0 { 1051 return ErrInvalidLengthNamespace 1052 } 1053 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 1054 if postStringIndexmapvalue > l { 1055 return io.ErrUnexpectedEOF 1056 } 1057 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 1058 iNdEx = postStringIndexmapvalue 1059 } else { 1060 iNdEx = entryPreIndex 1061 skippy, err := skipNamespace(dAtA[iNdEx:]) 1062 if err != nil { 1063 return err 1064 } 1065 if skippy < 0 { 1066 return ErrInvalidLengthNamespace 1067 } 1068 if (iNdEx + skippy) > postIndex { 1069 return io.ErrUnexpectedEOF 1070 } 1071 iNdEx += skippy 1072 } 1073 } 1074 m.Labels[mapkey] = mapvalue 1075 iNdEx = postIndex 1076 default: 1077 iNdEx = preIndex 1078 skippy, err := skipNamespace(dAtA[iNdEx:]) 1079 if err != nil { 1080 return err 1081 } 1082 if skippy < 0 { 1083 return ErrInvalidLengthNamespace 1084 } 1085 if (iNdEx + skippy) > l { 1086 return io.ErrUnexpectedEOF 1087 } 1088 iNdEx += skippy 1089 } 1090 } 1091 1092 if iNdEx > l { 1093 return io.ErrUnexpectedEOF 1094 } 1095 return nil 1096} 1097func (m *GetNamespaceRequest) Unmarshal(dAtA []byte) error { 1098 l := len(dAtA) 1099 iNdEx := 0 1100 for iNdEx < l { 1101 preIndex := iNdEx 1102 var wire uint64 1103 for shift := uint(0); ; shift += 7 { 1104 if shift >= 64 { 1105 return ErrIntOverflowNamespace 1106 } 1107 if iNdEx >= l { 1108 return io.ErrUnexpectedEOF 1109 } 1110 b := dAtA[iNdEx] 1111 iNdEx++ 1112 wire |= (uint64(b) & 0x7F) << shift 1113 if b < 0x80 { 1114 break 1115 } 1116 } 1117 fieldNum := int32(wire >> 3) 1118 wireType := int(wire & 0x7) 1119 if wireType == 4 { 1120 return fmt.Errorf("proto: GetNamespaceRequest: wiretype end group for non-group") 1121 } 1122 if fieldNum <= 0 { 1123 return fmt.Errorf("proto: GetNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 1124 } 1125 switch fieldNum { 1126 case 1: 1127 if wireType != 2 { 1128 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 1129 } 1130 var stringLen uint64 1131 for shift := uint(0); ; shift += 7 { 1132 if shift >= 64 { 1133 return ErrIntOverflowNamespace 1134 } 1135 if iNdEx >= l { 1136 return io.ErrUnexpectedEOF 1137 } 1138 b := dAtA[iNdEx] 1139 iNdEx++ 1140 stringLen |= (uint64(b) & 0x7F) << shift 1141 if b < 0x80 { 1142 break 1143 } 1144 } 1145 intStringLen := int(stringLen) 1146 if intStringLen < 0 { 1147 return ErrInvalidLengthNamespace 1148 } 1149 postIndex := iNdEx + intStringLen 1150 if postIndex > l { 1151 return io.ErrUnexpectedEOF 1152 } 1153 m.Name = string(dAtA[iNdEx:postIndex]) 1154 iNdEx = postIndex 1155 default: 1156 iNdEx = preIndex 1157 skippy, err := skipNamespace(dAtA[iNdEx:]) 1158 if err != nil { 1159 return err 1160 } 1161 if skippy < 0 { 1162 return ErrInvalidLengthNamespace 1163 } 1164 if (iNdEx + skippy) > l { 1165 return io.ErrUnexpectedEOF 1166 } 1167 iNdEx += skippy 1168 } 1169 } 1170 1171 if iNdEx > l { 1172 return io.ErrUnexpectedEOF 1173 } 1174 return nil 1175} 1176func (m *GetNamespaceResponse) Unmarshal(dAtA []byte) error { 1177 l := len(dAtA) 1178 iNdEx := 0 1179 for iNdEx < l { 1180 preIndex := iNdEx 1181 var wire uint64 1182 for shift := uint(0); ; shift += 7 { 1183 if shift >= 64 { 1184 return ErrIntOverflowNamespace 1185 } 1186 if iNdEx >= l { 1187 return io.ErrUnexpectedEOF 1188 } 1189 b := dAtA[iNdEx] 1190 iNdEx++ 1191 wire |= (uint64(b) & 0x7F) << shift 1192 if b < 0x80 { 1193 break 1194 } 1195 } 1196 fieldNum := int32(wire >> 3) 1197 wireType := int(wire & 0x7) 1198 if wireType == 4 { 1199 return fmt.Errorf("proto: GetNamespaceResponse: wiretype end group for non-group") 1200 } 1201 if fieldNum <= 0 { 1202 return fmt.Errorf("proto: GetNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) 1203 } 1204 switch fieldNum { 1205 case 1: 1206 if wireType != 2 { 1207 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 1208 } 1209 var msglen int 1210 for shift := uint(0); ; shift += 7 { 1211 if shift >= 64 { 1212 return ErrIntOverflowNamespace 1213 } 1214 if iNdEx >= l { 1215 return io.ErrUnexpectedEOF 1216 } 1217 b := dAtA[iNdEx] 1218 iNdEx++ 1219 msglen |= (int(b) & 0x7F) << shift 1220 if b < 0x80 { 1221 break 1222 } 1223 } 1224 if msglen < 0 { 1225 return ErrInvalidLengthNamespace 1226 } 1227 postIndex := iNdEx + msglen 1228 if postIndex > l { 1229 return io.ErrUnexpectedEOF 1230 } 1231 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1232 return err 1233 } 1234 iNdEx = postIndex 1235 default: 1236 iNdEx = preIndex 1237 skippy, err := skipNamespace(dAtA[iNdEx:]) 1238 if err != nil { 1239 return err 1240 } 1241 if skippy < 0 { 1242 return ErrInvalidLengthNamespace 1243 } 1244 if (iNdEx + skippy) > l { 1245 return io.ErrUnexpectedEOF 1246 } 1247 iNdEx += skippy 1248 } 1249 } 1250 1251 if iNdEx > l { 1252 return io.ErrUnexpectedEOF 1253 } 1254 return nil 1255} 1256func (m *ListNamespacesRequest) Unmarshal(dAtA []byte) error { 1257 l := len(dAtA) 1258 iNdEx := 0 1259 for iNdEx < l { 1260 preIndex := iNdEx 1261 var wire uint64 1262 for shift := uint(0); ; shift += 7 { 1263 if shift >= 64 { 1264 return ErrIntOverflowNamespace 1265 } 1266 if iNdEx >= l { 1267 return io.ErrUnexpectedEOF 1268 } 1269 b := dAtA[iNdEx] 1270 iNdEx++ 1271 wire |= (uint64(b) & 0x7F) << shift 1272 if b < 0x80 { 1273 break 1274 } 1275 } 1276 fieldNum := int32(wire >> 3) 1277 wireType := int(wire & 0x7) 1278 if wireType == 4 { 1279 return fmt.Errorf("proto: ListNamespacesRequest: wiretype end group for non-group") 1280 } 1281 if fieldNum <= 0 { 1282 return fmt.Errorf("proto: ListNamespacesRequest: illegal tag %d (wire type %d)", fieldNum, wire) 1283 } 1284 switch fieldNum { 1285 case 1: 1286 if wireType != 2 { 1287 return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType) 1288 } 1289 var stringLen uint64 1290 for shift := uint(0); ; shift += 7 { 1291 if shift >= 64 { 1292 return ErrIntOverflowNamespace 1293 } 1294 if iNdEx >= l { 1295 return io.ErrUnexpectedEOF 1296 } 1297 b := dAtA[iNdEx] 1298 iNdEx++ 1299 stringLen |= (uint64(b) & 0x7F) << shift 1300 if b < 0x80 { 1301 break 1302 } 1303 } 1304 intStringLen := int(stringLen) 1305 if intStringLen < 0 { 1306 return ErrInvalidLengthNamespace 1307 } 1308 postIndex := iNdEx + intStringLen 1309 if postIndex > l { 1310 return io.ErrUnexpectedEOF 1311 } 1312 m.Filter = string(dAtA[iNdEx:postIndex]) 1313 iNdEx = postIndex 1314 default: 1315 iNdEx = preIndex 1316 skippy, err := skipNamespace(dAtA[iNdEx:]) 1317 if err != nil { 1318 return err 1319 } 1320 if skippy < 0 { 1321 return ErrInvalidLengthNamespace 1322 } 1323 if (iNdEx + skippy) > l { 1324 return io.ErrUnexpectedEOF 1325 } 1326 iNdEx += skippy 1327 } 1328 } 1329 1330 if iNdEx > l { 1331 return io.ErrUnexpectedEOF 1332 } 1333 return nil 1334} 1335func (m *ListNamespacesResponse) Unmarshal(dAtA []byte) error { 1336 l := len(dAtA) 1337 iNdEx := 0 1338 for iNdEx < l { 1339 preIndex := iNdEx 1340 var wire uint64 1341 for shift := uint(0); ; shift += 7 { 1342 if shift >= 64 { 1343 return ErrIntOverflowNamespace 1344 } 1345 if iNdEx >= l { 1346 return io.ErrUnexpectedEOF 1347 } 1348 b := dAtA[iNdEx] 1349 iNdEx++ 1350 wire |= (uint64(b) & 0x7F) << shift 1351 if b < 0x80 { 1352 break 1353 } 1354 } 1355 fieldNum := int32(wire >> 3) 1356 wireType := int(wire & 0x7) 1357 if wireType == 4 { 1358 return fmt.Errorf("proto: ListNamespacesResponse: wiretype end group for non-group") 1359 } 1360 if fieldNum <= 0 { 1361 return fmt.Errorf("proto: ListNamespacesResponse: illegal tag %d (wire type %d)", fieldNum, wire) 1362 } 1363 switch fieldNum { 1364 case 1: 1365 if wireType != 2 { 1366 return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType) 1367 } 1368 var msglen int 1369 for shift := uint(0); ; shift += 7 { 1370 if shift >= 64 { 1371 return ErrIntOverflowNamespace 1372 } 1373 if iNdEx >= l { 1374 return io.ErrUnexpectedEOF 1375 } 1376 b := dAtA[iNdEx] 1377 iNdEx++ 1378 msglen |= (int(b) & 0x7F) << shift 1379 if b < 0x80 { 1380 break 1381 } 1382 } 1383 if msglen < 0 { 1384 return ErrInvalidLengthNamespace 1385 } 1386 postIndex := iNdEx + msglen 1387 if postIndex > l { 1388 return io.ErrUnexpectedEOF 1389 } 1390 m.Namespaces = append(m.Namespaces, Namespace{}) 1391 if err := m.Namespaces[len(m.Namespaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1392 return err 1393 } 1394 iNdEx = postIndex 1395 default: 1396 iNdEx = preIndex 1397 skippy, err := skipNamespace(dAtA[iNdEx:]) 1398 if err != nil { 1399 return err 1400 } 1401 if skippy < 0 { 1402 return ErrInvalidLengthNamespace 1403 } 1404 if (iNdEx + skippy) > l { 1405 return io.ErrUnexpectedEOF 1406 } 1407 iNdEx += skippy 1408 } 1409 } 1410 1411 if iNdEx > l { 1412 return io.ErrUnexpectedEOF 1413 } 1414 return nil 1415} 1416func (m *CreateNamespaceRequest) Unmarshal(dAtA []byte) error { 1417 l := len(dAtA) 1418 iNdEx := 0 1419 for iNdEx < l { 1420 preIndex := iNdEx 1421 var wire uint64 1422 for shift := uint(0); ; shift += 7 { 1423 if shift >= 64 { 1424 return ErrIntOverflowNamespace 1425 } 1426 if iNdEx >= l { 1427 return io.ErrUnexpectedEOF 1428 } 1429 b := dAtA[iNdEx] 1430 iNdEx++ 1431 wire |= (uint64(b) & 0x7F) << shift 1432 if b < 0x80 { 1433 break 1434 } 1435 } 1436 fieldNum := int32(wire >> 3) 1437 wireType := int(wire & 0x7) 1438 if wireType == 4 { 1439 return fmt.Errorf("proto: CreateNamespaceRequest: wiretype end group for non-group") 1440 } 1441 if fieldNum <= 0 { 1442 return fmt.Errorf("proto: CreateNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 1443 } 1444 switch fieldNum { 1445 case 1: 1446 if wireType != 2 { 1447 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 1448 } 1449 var msglen int 1450 for shift := uint(0); ; shift += 7 { 1451 if shift >= 64 { 1452 return ErrIntOverflowNamespace 1453 } 1454 if iNdEx >= l { 1455 return io.ErrUnexpectedEOF 1456 } 1457 b := dAtA[iNdEx] 1458 iNdEx++ 1459 msglen |= (int(b) & 0x7F) << shift 1460 if b < 0x80 { 1461 break 1462 } 1463 } 1464 if msglen < 0 { 1465 return ErrInvalidLengthNamespace 1466 } 1467 postIndex := iNdEx + msglen 1468 if postIndex > l { 1469 return io.ErrUnexpectedEOF 1470 } 1471 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1472 return err 1473 } 1474 iNdEx = postIndex 1475 default: 1476 iNdEx = preIndex 1477 skippy, err := skipNamespace(dAtA[iNdEx:]) 1478 if err != nil { 1479 return err 1480 } 1481 if skippy < 0 { 1482 return ErrInvalidLengthNamespace 1483 } 1484 if (iNdEx + skippy) > l { 1485 return io.ErrUnexpectedEOF 1486 } 1487 iNdEx += skippy 1488 } 1489 } 1490 1491 if iNdEx > l { 1492 return io.ErrUnexpectedEOF 1493 } 1494 return nil 1495} 1496func (m *CreateNamespaceResponse) Unmarshal(dAtA []byte) error { 1497 l := len(dAtA) 1498 iNdEx := 0 1499 for iNdEx < l { 1500 preIndex := iNdEx 1501 var wire uint64 1502 for shift := uint(0); ; shift += 7 { 1503 if shift >= 64 { 1504 return ErrIntOverflowNamespace 1505 } 1506 if iNdEx >= l { 1507 return io.ErrUnexpectedEOF 1508 } 1509 b := dAtA[iNdEx] 1510 iNdEx++ 1511 wire |= (uint64(b) & 0x7F) << shift 1512 if b < 0x80 { 1513 break 1514 } 1515 } 1516 fieldNum := int32(wire >> 3) 1517 wireType := int(wire & 0x7) 1518 if wireType == 4 { 1519 return fmt.Errorf("proto: CreateNamespaceResponse: wiretype end group for non-group") 1520 } 1521 if fieldNum <= 0 { 1522 return fmt.Errorf("proto: CreateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) 1523 } 1524 switch fieldNum { 1525 case 1: 1526 if wireType != 2 { 1527 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 1528 } 1529 var msglen int 1530 for shift := uint(0); ; shift += 7 { 1531 if shift >= 64 { 1532 return ErrIntOverflowNamespace 1533 } 1534 if iNdEx >= l { 1535 return io.ErrUnexpectedEOF 1536 } 1537 b := dAtA[iNdEx] 1538 iNdEx++ 1539 msglen |= (int(b) & 0x7F) << shift 1540 if b < 0x80 { 1541 break 1542 } 1543 } 1544 if msglen < 0 { 1545 return ErrInvalidLengthNamespace 1546 } 1547 postIndex := iNdEx + msglen 1548 if postIndex > l { 1549 return io.ErrUnexpectedEOF 1550 } 1551 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1552 return err 1553 } 1554 iNdEx = postIndex 1555 default: 1556 iNdEx = preIndex 1557 skippy, err := skipNamespace(dAtA[iNdEx:]) 1558 if err != nil { 1559 return err 1560 } 1561 if skippy < 0 { 1562 return ErrInvalidLengthNamespace 1563 } 1564 if (iNdEx + skippy) > l { 1565 return io.ErrUnexpectedEOF 1566 } 1567 iNdEx += skippy 1568 } 1569 } 1570 1571 if iNdEx > l { 1572 return io.ErrUnexpectedEOF 1573 } 1574 return nil 1575} 1576func (m *UpdateNamespaceRequest) Unmarshal(dAtA []byte) error { 1577 l := len(dAtA) 1578 iNdEx := 0 1579 for iNdEx < l { 1580 preIndex := iNdEx 1581 var wire uint64 1582 for shift := uint(0); ; shift += 7 { 1583 if shift >= 64 { 1584 return ErrIntOverflowNamespace 1585 } 1586 if iNdEx >= l { 1587 return io.ErrUnexpectedEOF 1588 } 1589 b := dAtA[iNdEx] 1590 iNdEx++ 1591 wire |= (uint64(b) & 0x7F) << shift 1592 if b < 0x80 { 1593 break 1594 } 1595 } 1596 fieldNum := int32(wire >> 3) 1597 wireType := int(wire & 0x7) 1598 if wireType == 4 { 1599 return fmt.Errorf("proto: UpdateNamespaceRequest: wiretype end group for non-group") 1600 } 1601 if fieldNum <= 0 { 1602 return fmt.Errorf("proto: UpdateNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 1603 } 1604 switch fieldNum { 1605 case 1: 1606 if wireType != 2 { 1607 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 1608 } 1609 var msglen int 1610 for shift := uint(0); ; shift += 7 { 1611 if shift >= 64 { 1612 return ErrIntOverflowNamespace 1613 } 1614 if iNdEx >= l { 1615 return io.ErrUnexpectedEOF 1616 } 1617 b := dAtA[iNdEx] 1618 iNdEx++ 1619 msglen |= (int(b) & 0x7F) << shift 1620 if b < 0x80 { 1621 break 1622 } 1623 } 1624 if msglen < 0 { 1625 return ErrInvalidLengthNamespace 1626 } 1627 postIndex := iNdEx + msglen 1628 if postIndex > l { 1629 return io.ErrUnexpectedEOF 1630 } 1631 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1632 return err 1633 } 1634 iNdEx = postIndex 1635 case 2: 1636 if wireType != 2 { 1637 return fmt.Errorf("proto: wrong wireType = %d for field UpdateMask", wireType) 1638 } 1639 var msglen int 1640 for shift := uint(0); ; shift += 7 { 1641 if shift >= 64 { 1642 return ErrIntOverflowNamespace 1643 } 1644 if iNdEx >= l { 1645 return io.ErrUnexpectedEOF 1646 } 1647 b := dAtA[iNdEx] 1648 iNdEx++ 1649 msglen |= (int(b) & 0x7F) << shift 1650 if b < 0x80 { 1651 break 1652 } 1653 } 1654 if msglen < 0 { 1655 return ErrInvalidLengthNamespace 1656 } 1657 postIndex := iNdEx + msglen 1658 if postIndex > l { 1659 return io.ErrUnexpectedEOF 1660 } 1661 if m.UpdateMask == nil { 1662 m.UpdateMask = &google_protobuf2.FieldMask{} 1663 } 1664 if err := m.UpdateMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1665 return err 1666 } 1667 iNdEx = postIndex 1668 default: 1669 iNdEx = preIndex 1670 skippy, err := skipNamespace(dAtA[iNdEx:]) 1671 if err != nil { 1672 return err 1673 } 1674 if skippy < 0 { 1675 return ErrInvalidLengthNamespace 1676 } 1677 if (iNdEx + skippy) > l { 1678 return io.ErrUnexpectedEOF 1679 } 1680 iNdEx += skippy 1681 } 1682 } 1683 1684 if iNdEx > l { 1685 return io.ErrUnexpectedEOF 1686 } 1687 return nil 1688} 1689func (m *UpdateNamespaceResponse) Unmarshal(dAtA []byte) error { 1690 l := len(dAtA) 1691 iNdEx := 0 1692 for iNdEx < l { 1693 preIndex := iNdEx 1694 var wire uint64 1695 for shift := uint(0); ; shift += 7 { 1696 if shift >= 64 { 1697 return ErrIntOverflowNamespace 1698 } 1699 if iNdEx >= l { 1700 return io.ErrUnexpectedEOF 1701 } 1702 b := dAtA[iNdEx] 1703 iNdEx++ 1704 wire |= (uint64(b) & 0x7F) << shift 1705 if b < 0x80 { 1706 break 1707 } 1708 } 1709 fieldNum := int32(wire >> 3) 1710 wireType := int(wire & 0x7) 1711 if wireType == 4 { 1712 return fmt.Errorf("proto: UpdateNamespaceResponse: wiretype end group for non-group") 1713 } 1714 if fieldNum <= 0 { 1715 return fmt.Errorf("proto: UpdateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) 1716 } 1717 switch fieldNum { 1718 case 1: 1719 if wireType != 2 { 1720 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) 1721 } 1722 var msglen int 1723 for shift := uint(0); ; shift += 7 { 1724 if shift >= 64 { 1725 return ErrIntOverflowNamespace 1726 } 1727 if iNdEx >= l { 1728 return io.ErrUnexpectedEOF 1729 } 1730 b := dAtA[iNdEx] 1731 iNdEx++ 1732 msglen |= (int(b) & 0x7F) << shift 1733 if b < 0x80 { 1734 break 1735 } 1736 } 1737 if msglen < 0 { 1738 return ErrInvalidLengthNamespace 1739 } 1740 postIndex := iNdEx + msglen 1741 if postIndex > l { 1742 return io.ErrUnexpectedEOF 1743 } 1744 if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1745 return err 1746 } 1747 iNdEx = postIndex 1748 default: 1749 iNdEx = preIndex 1750 skippy, err := skipNamespace(dAtA[iNdEx:]) 1751 if err != nil { 1752 return err 1753 } 1754 if skippy < 0 { 1755 return ErrInvalidLengthNamespace 1756 } 1757 if (iNdEx + skippy) > l { 1758 return io.ErrUnexpectedEOF 1759 } 1760 iNdEx += skippy 1761 } 1762 } 1763 1764 if iNdEx > l { 1765 return io.ErrUnexpectedEOF 1766 } 1767 return nil 1768} 1769func (m *DeleteNamespaceRequest) Unmarshal(dAtA []byte) error { 1770 l := len(dAtA) 1771 iNdEx := 0 1772 for iNdEx < l { 1773 preIndex := iNdEx 1774 var wire uint64 1775 for shift := uint(0); ; shift += 7 { 1776 if shift >= 64 { 1777 return ErrIntOverflowNamespace 1778 } 1779 if iNdEx >= l { 1780 return io.ErrUnexpectedEOF 1781 } 1782 b := dAtA[iNdEx] 1783 iNdEx++ 1784 wire |= (uint64(b) & 0x7F) << shift 1785 if b < 0x80 { 1786 break 1787 } 1788 } 1789 fieldNum := int32(wire >> 3) 1790 wireType := int(wire & 0x7) 1791 if wireType == 4 { 1792 return fmt.Errorf("proto: DeleteNamespaceRequest: wiretype end group for non-group") 1793 } 1794 if fieldNum <= 0 { 1795 return fmt.Errorf("proto: DeleteNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) 1796 } 1797 switch fieldNum { 1798 case 1: 1799 if wireType != 2 { 1800 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 1801 } 1802 var stringLen uint64 1803 for shift := uint(0); ; shift += 7 { 1804 if shift >= 64 { 1805 return ErrIntOverflowNamespace 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 ErrInvalidLengthNamespace 1820 } 1821 postIndex := iNdEx + intStringLen 1822 if postIndex > l { 1823 return io.ErrUnexpectedEOF 1824 } 1825 m.Name = string(dAtA[iNdEx:postIndex]) 1826 iNdEx = postIndex 1827 default: 1828 iNdEx = preIndex 1829 skippy, err := skipNamespace(dAtA[iNdEx:]) 1830 if err != nil { 1831 return err 1832 } 1833 if skippy < 0 { 1834 return ErrInvalidLengthNamespace 1835 } 1836 if (iNdEx + skippy) > l { 1837 return io.ErrUnexpectedEOF 1838 } 1839 iNdEx += skippy 1840 } 1841 } 1842 1843 if iNdEx > l { 1844 return io.ErrUnexpectedEOF 1845 } 1846 return nil 1847} 1848func skipNamespace(dAtA []byte) (n int, err error) { 1849 l := len(dAtA) 1850 iNdEx := 0 1851 for iNdEx < l { 1852 var wire uint64 1853 for shift := uint(0); ; shift += 7 { 1854 if shift >= 64 { 1855 return 0, ErrIntOverflowNamespace 1856 } 1857 if iNdEx >= l { 1858 return 0, io.ErrUnexpectedEOF 1859 } 1860 b := dAtA[iNdEx] 1861 iNdEx++ 1862 wire |= (uint64(b) & 0x7F) << shift 1863 if b < 0x80 { 1864 break 1865 } 1866 } 1867 wireType := int(wire & 0x7) 1868 switch wireType { 1869 case 0: 1870 for shift := uint(0); ; shift += 7 { 1871 if shift >= 64 { 1872 return 0, ErrIntOverflowNamespace 1873 } 1874 if iNdEx >= l { 1875 return 0, io.ErrUnexpectedEOF 1876 } 1877 iNdEx++ 1878 if dAtA[iNdEx-1] < 0x80 { 1879 break 1880 } 1881 } 1882 return iNdEx, nil 1883 case 1: 1884 iNdEx += 8 1885 return iNdEx, nil 1886 case 2: 1887 var length int 1888 for shift := uint(0); ; shift += 7 { 1889 if shift >= 64 { 1890 return 0, ErrIntOverflowNamespace 1891 } 1892 if iNdEx >= l { 1893 return 0, io.ErrUnexpectedEOF 1894 } 1895 b := dAtA[iNdEx] 1896 iNdEx++ 1897 length |= (int(b) & 0x7F) << shift 1898 if b < 0x80 { 1899 break 1900 } 1901 } 1902 iNdEx += length 1903 if length < 0 { 1904 return 0, ErrInvalidLengthNamespace 1905 } 1906 return iNdEx, nil 1907 case 3: 1908 for { 1909 var innerWire uint64 1910 var start int = iNdEx 1911 for shift := uint(0); ; shift += 7 { 1912 if shift >= 64 { 1913 return 0, ErrIntOverflowNamespace 1914 } 1915 if iNdEx >= l { 1916 return 0, io.ErrUnexpectedEOF 1917 } 1918 b := dAtA[iNdEx] 1919 iNdEx++ 1920 innerWire |= (uint64(b) & 0x7F) << shift 1921 if b < 0x80 { 1922 break 1923 } 1924 } 1925 innerWireType := int(innerWire & 0x7) 1926 if innerWireType == 4 { 1927 break 1928 } 1929 next, err := skipNamespace(dAtA[start:]) 1930 if err != nil { 1931 return 0, err 1932 } 1933 iNdEx = start + next 1934 } 1935 return iNdEx, nil 1936 case 4: 1937 return iNdEx, nil 1938 case 5: 1939 iNdEx += 4 1940 return iNdEx, nil 1941 default: 1942 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1943 } 1944 } 1945 panic("unreachable") 1946} 1947 1948var ( 1949 ErrInvalidLengthNamespace = fmt.Errorf("proto: negative length found during unmarshaling") 1950 ErrIntOverflowNamespace = fmt.Errorf("proto: integer overflow") 1951) 1952 1953func init() { 1954 proto.RegisterFile("github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto", fileDescriptorNamespace) 1955} 1956 1957var fileDescriptorNamespace = []byte{ 1958 // 551 bytes of a gzipped FileDescriptorProto 1959 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcd, 0x6e, 0xd3, 0x4c, 1960 0x14, 0xcd, 0x24, 0xf9, 0x2c, 0xe5, 0x7a, 0xf3, 0x69, 0x08, 0x26, 0x32, 0x92, 0x09, 0x5e, 0x15, 1961 0xa9, 0x1a, 0xab, 0x41, 0x82, 0xfe, 0xec, 0x0a, 0x6d, 0x17, 0x14, 0x84, 0x2c, 0x21, 0x21, 0x58, 1962 0x80, 0x93, 0x4c, 0x5c, 0x13, 0xc7, 0x36, 0x9e, 0xb1, 0xa5, 0x88, 0x05, 0xbc, 0x0d, 0x1b, 0x1e, 1963 0x24, 0x4b, 0x96, 0xac, 0x50, 0x9b, 0x27, 0x41, 0x33, 0x76, 0xe2, 0xd0, 0x18, 0xe1, 0x06, 0xca, 1964 0xee, 0x5e, 0x7b, 0xce, 0x3d, 0x67, 0xae, 0xce, 0xb1, 0xe1, 0x89, 0xeb, 0xf1, 0xb3, 0xa4, 0x4f, 1965 0x06, 0xe1, 0xc4, 0x1a, 0x84, 0x01, 0x77, 0xbc, 0x80, 0xc6, 0xc3, 0xd5, 0xd2, 0x89, 0x3c, 0x8b, 1966 0xd1, 0x38, 0xf5, 0x06, 0x94, 0x59, 0x81, 0x33, 0xa1, 0x2c, 0x72, 0x44, 0x99, 0xee, 0x14, 0x1d, 1967 0x89, 0xe2, 0x90, 0x87, 0xf8, 0x6e, 0x01, 0x23, 0x0b, 0x08, 0x29, 0x20, 0x24, 0xdd, 0xd1, 0xdb, 1968 0x6e, 0xe8, 0x86, 0xf2, 0xb4, 0x25, 0xaa, 0x0c, 0xa8, 0xdf, 0x76, 0xc3, 0xd0, 0xf5, 0xa9, 0x25, 1969 0xbb, 0x7e, 0x32, 0xb2, 0xe8, 0x24, 0xe2, 0xd3, 0xfc, 0x65, 0xf7, 0xf2, 0xcb, 0x91, 0x47, 0xfd, 1970 0xe1, 0x9b, 0x89, 0xc3, 0xc6, 0xd9, 0x09, 0xf3, 0x0b, 0x82, 0xd6, 0xb3, 0x05, 0x0d, 0xc6, 0xd0, 1971 0x14, 0x9c, 0x1d, 0xd4, 0x45, 0x5b, 0x2d, 0x5b, 0xd6, 0xf8, 0x39, 0x28, 0xbe, 0xd3, 0xa7, 0x3e, 1972 0xeb, 0xd4, 0xbb, 0x8d, 0x2d, 0xb5, 0xb7, 0x4b, 0x7e, 0x2b, 0x95, 0x2c, 0x27, 0x92, 0x53, 0x09, 1973 0x3d, 0x0a, 0x78, 0x3c, 0xb5, 0xf3, 0x39, 0xfa, 0x1e, 0xa8, 0x2b, 0x8f, 0xf1, 0xff, 0xd0, 0x18, 1974 0xd3, 0x69, 0xce, 0x29, 0x4a, 0xdc, 0x86, 0xff, 0x52, 0xc7, 0x4f, 0x68, 0xa7, 0x2e, 0x9f, 0x65, 1975 0xcd, 0x7e, 0x7d, 0x17, 0x99, 0xf7, 0xe0, 0xc6, 0x09, 0xe5, 0xcb, 0xf1, 0x36, 0x7d, 0x9f, 0x50, 1976 0xc6, 0xcb, 0x74, 0x9b, 0x67, 0xd0, 0xfe, 0xf9, 0x28, 0x8b, 0xc2, 0x80, 0x89, 0xfb, 0xb4, 0x96, 1977 0x62, 0x25, 0x40, 0xed, 0x6d, 0x5f, 0xe5, 0x4a, 0x87, 0xcd, 0xd9, 0xf7, 0x3b, 0x35, 0xbb, 0x18, 1978 0x62, 0x5a, 0x70, 0xf3, 0xd4, 0x63, 0x05, 0x15, 0x5b, 0xc8, 0xd2, 0x40, 0x19, 0x79, 0x3e, 0xa7, 1979 0x71, 0x2e, 0x2c, 0xef, 0x4c, 0x1f, 0xb4, 0xcb, 0x80, 0x5c, 0x9c, 0x0d, 0x50, 0xd0, 0x76, 0x90, 1980 0x5c, 0xf8, 0x26, 0xea, 0x56, 0xa6, 0x98, 0xef, 0x40, 0x7b, 0x14, 0x53, 0x87, 0xd3, 0xb5, 0xb5, 1981 0xfd, 0xfd, 0x55, 0x8c, 0xe1, 0xd6, 0x1a, 0xd7, 0xb5, 0xed, 0xfd, 0x33, 0x02, 0xed, 0x45, 0x34, 1982 0xfc, 0x27, 0x37, 0xc3, 0x07, 0xa0, 0x26, 0x92, 0x4b, 0xa6, 0x47, 0x3a, 0x53, 0xed, 0xe9, 0x24, 1983 0x0b, 0x18, 0x59, 0x04, 0x8c, 0x1c, 0x8b, 0x80, 0x3d, 0x75, 0xd8, 0xd8, 0x86, 0xec, 0xb8, 0xa8, 1984 0xc5, 0x5a, 0xd6, 0x84, 0x5e, 0xdb, 0x5a, 0xb6, 0x41, 0x7b, 0x4c, 0x7d, 0x5a, 0xb2, 0x95, 0x92, 1985 0x98, 0xf4, 0xce, 0x9b, 0x00, 0x85, 0x11, 0x71, 0x0a, 0x8d, 0x13, 0xca, 0xf1, 0x83, 0x0a, 0x12, 1986 0x4a, 0x82, 0xa8, 0x3f, 0xbc, 0x32, 0x2e, 0x5f, 0xc3, 0x07, 0x68, 0x8a, 0x48, 0xe0, 0x2a, 0x5f, 1987 0x97, 0xd2, 0xb0, 0xe9, 0x7b, 0x1b, 0x20, 0x73, 0xf2, 0x8f, 0xa0, 0x64, 0xae, 0xc5, 0x55, 0x86, 1988 0x94, 0x87, 0x49, 0xdf, 0xdf, 0x04, 0x5a, 0x08, 0xc8, 0xfc, 0x51, 0x49, 0x40, 0xb9, 0xe7, 0x2b, 1989 0x09, 0xf8, 0x95, 0x0b, 0x5f, 0x83, 0x92, 0x79, 0xa6, 0x92, 0x80, 0x72, 0x7b, 0xe9, 0xda, 0x5a, 1990 0x1a, 0x8e, 0xc4, 0xbf, 0xe8, 0xf0, 0xed, 0xec, 0xc2, 0xa8, 0x7d, 0xbb, 0x30, 0x6a, 0x9f, 0xe6, 1991 0x06, 0x9a, 0xcd, 0x0d, 0xf4, 0x75, 0x6e, 0xa0, 0xf3, 0xb9, 0x81, 0x5e, 0x1d, 0xff, 0xc1, 0x2f, 1992 0xf4, 0xa0, 0xe8, 0x5e, 0xd6, 0xfa, 0x8a, 0xe4, 0xbc, 0xff, 0x23, 0x00, 0x00, 0xff, 0xff, 0x4f, 1993 0x4a, 0x87, 0xf3, 0x95, 0x07, 0x00, 0x00, 1994} 1995