Source file src/k8s.io/api/node/v1/generated.pb.go

Documentation: k8s.io/api/node/v1

     1  /*
     2  Copyright The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  // Code generated by protoc-gen-gogo. DO NOT EDIT.
    18  // source: k8s.io/api/node/v1/generated.proto
    19  
    20  package v1
    21  
    22  import (
    23  	fmt "fmt"
    24  
    25  	io "io"
    26  
    27  	proto "github.com/gogo/protobuf/proto"
    28  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    29  	k8s_io_api_core_v1 "k8s.io/api/core/v1"
    30  	v11 "k8s.io/api/core/v1"
    31  	k8s_io_apimachinery_pkg_api_resource "k8s.io/apimachinery/pkg/api/resource"
    32  	resource "k8s.io/apimachinery/pkg/api/resource"
    33  
    34  	math "math"
    35  	math_bits "math/bits"
    36  	reflect "reflect"
    37  	strings "strings"
    38  )
    39  
    40  // Reference imports to suppress errors if they are not otherwise used.
    41  var _ = proto.Marshal
    42  var _ = fmt.Errorf
    43  var _ = math.Inf
    44  
    45  // This is a compile-time assertion to ensure that this generated file
    46  // is compatible with the proto package it is being compiled against.
    47  // A compilation error at this line likely means your copy of the
    48  // proto package needs to be updated.
    49  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    50  
    51  func (m *Overhead) Reset()      { *m = Overhead{} }
    52  func (*Overhead) ProtoMessage() {}
    53  func (*Overhead) Descriptor() ([]byte, []int) {
    54  	return fileDescriptor_9007436710e7565b, []int{0}
    55  }
    56  func (m *Overhead) XXX_Unmarshal(b []byte) error {
    57  	return m.Unmarshal(b)
    58  }
    59  func (m *Overhead) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    60  	b = b[:cap(b)]
    61  	n, err := m.MarshalToSizedBuffer(b)
    62  	if err != nil {
    63  		return nil, err
    64  	}
    65  	return b[:n], nil
    66  }
    67  func (m *Overhead) XXX_Merge(src proto.Message) {
    68  	xxx_messageInfo_Overhead.Merge(m, src)
    69  }
    70  func (m *Overhead) XXX_Size() int {
    71  	return m.Size()
    72  }
    73  func (m *Overhead) XXX_DiscardUnknown() {
    74  	xxx_messageInfo_Overhead.DiscardUnknown(m)
    75  }
    76  
    77  var xxx_messageInfo_Overhead proto.InternalMessageInfo
    78  
    79  func (m *RuntimeClass) Reset()      { *m = RuntimeClass{} }
    80  func (*RuntimeClass) ProtoMessage() {}
    81  func (*RuntimeClass) Descriptor() ([]byte, []int) {
    82  	return fileDescriptor_9007436710e7565b, []int{1}
    83  }
    84  func (m *RuntimeClass) XXX_Unmarshal(b []byte) error {
    85  	return m.Unmarshal(b)
    86  }
    87  func (m *RuntimeClass) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    88  	b = b[:cap(b)]
    89  	n, err := m.MarshalToSizedBuffer(b)
    90  	if err != nil {
    91  		return nil, err
    92  	}
    93  	return b[:n], nil
    94  }
    95  func (m *RuntimeClass) XXX_Merge(src proto.Message) {
    96  	xxx_messageInfo_RuntimeClass.Merge(m, src)
    97  }
    98  func (m *RuntimeClass) XXX_Size() int {
    99  	return m.Size()
   100  }
   101  func (m *RuntimeClass) XXX_DiscardUnknown() {
   102  	xxx_messageInfo_RuntimeClass.DiscardUnknown(m)
   103  }
   104  
   105  var xxx_messageInfo_RuntimeClass proto.InternalMessageInfo
   106  
   107  func (m *RuntimeClassList) Reset()      { *m = RuntimeClassList{} }
   108  func (*RuntimeClassList) ProtoMessage() {}
   109  func (*RuntimeClassList) Descriptor() ([]byte, []int) {
   110  	return fileDescriptor_9007436710e7565b, []int{2}
   111  }
   112  func (m *RuntimeClassList) XXX_Unmarshal(b []byte) error {
   113  	return m.Unmarshal(b)
   114  }
   115  func (m *RuntimeClassList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   116  	b = b[:cap(b)]
   117  	n, err := m.MarshalToSizedBuffer(b)
   118  	if err != nil {
   119  		return nil, err
   120  	}
   121  	return b[:n], nil
   122  }
   123  func (m *RuntimeClassList) XXX_Merge(src proto.Message) {
   124  	xxx_messageInfo_RuntimeClassList.Merge(m, src)
   125  }
   126  func (m *RuntimeClassList) XXX_Size() int {
   127  	return m.Size()
   128  }
   129  func (m *RuntimeClassList) XXX_DiscardUnknown() {
   130  	xxx_messageInfo_RuntimeClassList.DiscardUnknown(m)
   131  }
   132  
   133  var xxx_messageInfo_RuntimeClassList proto.InternalMessageInfo
   134  
   135  func (m *Scheduling) Reset()      { *m = Scheduling{} }
   136  func (*Scheduling) ProtoMessage() {}
   137  func (*Scheduling) Descriptor() ([]byte, []int) {
   138  	return fileDescriptor_9007436710e7565b, []int{3}
   139  }
   140  func (m *Scheduling) XXX_Unmarshal(b []byte) error {
   141  	return m.Unmarshal(b)
   142  }
   143  func (m *Scheduling) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   144  	b = b[:cap(b)]
   145  	n, err := m.MarshalToSizedBuffer(b)
   146  	if err != nil {
   147  		return nil, err
   148  	}
   149  	return b[:n], nil
   150  }
   151  func (m *Scheduling) XXX_Merge(src proto.Message) {
   152  	xxx_messageInfo_Scheduling.Merge(m, src)
   153  }
   154  func (m *Scheduling) XXX_Size() int {
   155  	return m.Size()
   156  }
   157  func (m *Scheduling) XXX_DiscardUnknown() {
   158  	xxx_messageInfo_Scheduling.DiscardUnknown(m)
   159  }
   160  
   161  var xxx_messageInfo_Scheduling proto.InternalMessageInfo
   162  
   163  func init() {
   164  	proto.RegisterType((*Overhead)(nil), "k8s.io.api.node.v1.Overhead")
   165  	proto.RegisterMapType((k8s_io_api_core_v1.ResourceList)(nil), "k8s.io.api.node.v1.Overhead.PodFixedEntry")
   166  	proto.RegisterType((*RuntimeClass)(nil), "k8s.io.api.node.v1.RuntimeClass")
   167  	proto.RegisterType((*RuntimeClassList)(nil), "k8s.io.api.node.v1.RuntimeClassList")
   168  	proto.RegisterType((*Scheduling)(nil), "k8s.io.api.node.v1.Scheduling")
   169  	proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.node.v1.Scheduling.NodeSelectorEntry")
   170  }
   171  
   172  func init() {
   173  	proto.RegisterFile("k8s.io/api/node/v1/generated.proto", fileDescriptor_9007436710e7565b)
   174  }
   175  
   176  var fileDescriptor_9007436710e7565b = []byte{
   177  	// 643 bytes of a gzipped FileDescriptorProto
   178  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x4f, 0x6f, 0xd3, 0x4e,
   179  	0x10, 0xcd, 0xa6, 0xbf, 0xaa, 0xe9, 0x26, 0xfd, 0x51, 0x96, 0x1e, 0xa2, 0x08, 0x39, 0x51, 0x4e,
   180  	0x05, 0xa9, 0xeb, 0xb6, 0x42, 0xa8, 0xe2, 0x82, 0x64, 0x68, 0x05, 0x12, 0x14, 0x70, 0xe1, 0x82,
   181  	0x38, 0xb0, 0xb5, 0x17, 0x67, 0x9b, 0xd8, 0x1b, 0xd9, 0xeb, 0x88, 0xdc, 0x10, 0x17, 0x24, 0x4e,
   182  	0xfd, 0x2e, 0x1c, 0xf8, 0x0a, 0x15, 0xa7, 0x1e, 0x7b, 0x6a, 0xa9, 0xf9, 0x16, 0x9c, 0xd0, 0xae,
   183  	0xff, 0x64, 0x83, 0x43, 0x28, 0x37, 0xef, 0xec, 0x7b, 0x6f, 0x66, 0xde, 0xec, 0x18, 0x76, 0xfb,
   184  	0x3b, 0x11, 0x66, 0xdc, 0x24, 0x43, 0x66, 0x06, 0xdc, 0xa5, 0xe6, 0x68, 0xcb, 0xf4, 0x68, 0x40,
   185  	0x43, 0x22, 0xa8, 0x8b, 0x87, 0x21, 0x17, 0x1c, 0xa1, 0x14, 0x83, 0xc9, 0x90, 0x61, 0x89, 0xc1,
   186  	0xa3, 0xad, 0xd6, 0x86, 0xc7, 0x44, 0x2f, 0x3e, 0xc4, 0x0e, 0xf7, 0x4d, 0x8f, 0x7b, 0xdc, 0x54,
   187  	0xd0, 0xc3, 0xf8, 0x9d, 0x3a, 0xa9, 0x83, 0xfa, 0x4a, 0x25, 0x5a, 0x7a, 0x1a, 0x87, 0x87, 0xb3,
   188  	0xd2, 0xb4, 0xee, 0x4c, 0x30, 0x3e, 0x71, 0x7a, 0x2c, 0xa0, 0xe1, 0xd8, 0x1c, 0xf6, 0x3d, 0x45,
   189  	0x0a, 0x69, 0xc4, 0xe3, 0xd0, 0xa1, 0xff, 0xc4, 0x8a, 0x4c, 0x9f, 0x0a, 0x32, 0x2b, 0x97, 0xf9,
   190  	0x27, 0x56, 0x18, 0x07, 0x82, 0xf9, 0xe5, 0x34, 0x77, 0xff, 0x46, 0x88, 0x9c, 0x1e, 0xf5, 0xc9,
   191  	0xef, 0xbc, 0xee, 0xb7, 0x2a, 0xac, 0x3d, 0x1b, 0xd1, 0xb0, 0x47, 0x89, 0x8b, 0x4e, 0x01, 0xac,
   192  	0x0d, 0xb9, 0xbb, 0xc7, 0xde, 0x53, 0xb7, 0x09, 0x3a, 0x0b, 0xeb, 0xf5, 0xed, 0xdb, 0xb8, 0x6c,
   193  	0x2e, 0xce, 0x09, 0xf8, 0x79, 0x06, 0xde, 0x0d, 0x44, 0x38, 0xb6, 0x3e, 0x81, 0x93, 0xf3, 0x76,
   194  	0x25, 0x39, 0x6f, 0xd7, 0xf2, 0xf8, 0xcf, 0xf3, 0x76, 0xbb, 0xec, 0x2c, 0xb6, 0x33, 0xb3, 0x9e,
   195  	0xb0, 0x48, 0x7c, 0xbc, 0x98, 0x0b, 0xd9, 0x27, 0x3e, 0xfd, 0x7c, 0xd1, 0xde, 0xb8, 0x8a, 0xf7,
   196  	0xf8, 0x45, 0x4c, 0x02, 0xc1, 0xc4, 0xd8, 0x2e, 0xba, 0x68, 0xf5, 0xe1, 0xca, 0x54, 0x91, 0x68,
   197  	0x15, 0x2e, 0xf4, 0xe9, 0xb8, 0x09, 0x3a, 0x60, 0x7d, 0xd9, 0x96, 0x9f, 0xe8, 0x21, 0x5c, 0x1c,
   198  	0x91, 0x41, 0x4c, 0x9b, 0xd5, 0x0e, 0x58, 0xaf, 0x6f, 0x63, 0xad, 0xe3, 0x22, 0x17, 0x1e, 0xf6,
   199  	0x3d, 0x65, 0x41, 0x39, 0x57, 0x4a, 0xbe, 0x57, 0xdd, 0x01, 0xdd, 0x2f, 0x55, 0xd8, 0xb0, 0x53,
   200  	0xbf, 0x1f, 0x0c, 0x48, 0x14, 0xa1, 0xb7, 0xb0, 0x26, 0x27, 0xec, 0x12, 0x41, 0x54, 0xc6, 0xfa,
   201  	0xf6, 0xe6, 0x3c, 0xf5, 0x08, 0x4b, 0xb4, 0x72, 0xf8, 0xf0, 0x88, 0x3a, 0xe2, 0x29, 0x15, 0xc4,
   202  	0x42, 0x99, 0xa9, 0x70, 0x12, 0xb3, 0x0b, 0x55, 0x74, 0x0b, 0x2e, 0xf5, 0x48, 0xe0, 0x0e, 0x68,
   203  	0xa8, 0xca, 0x5f, 0xb6, 0xae, 0x65, 0xf0, 0xa5, 0x47, 0x69, 0xd8, 0xce, 0xef, 0xd1, 0x1e, 0xac,
   204  	0xf1, 0x6c, 0x70, 0xcd, 0x05, 0x55, 0xcc, 0xcd, 0x79, 0xc3, 0xb5, 0x1a, 0x72, 0x92, 0xf9, 0xc9,
   205  	0x2e, 0xb8, 0x68, 0x1f, 0x42, 0xf9, 0x98, 0xdc, 0x78, 0xc0, 0x02, 0xaf, 0xf9, 0x9f, 0x52, 0x32,
   206  	0x66, 0x29, 0x1d, 0x14, 0x28, 0xeb, 0x7f, 0xd9, 0xc0, 0xe4, 0x6c, 0x6b, 0x0a, 0xdd, 0xaf, 0x00,
   207  	0xae, 0xea, 0xae, 0xc9, 0x57, 0x81, 0xde, 0x94, 0x9c, 0xc3, 0x57, 0x73, 0x4e, 0xb2, 0x95, 0x6f,
   208  	0xab, 0xf9, 0x63, 0xcc, 0x23, 0x9a, 0x6b, 0xbb, 0x70, 0x91, 0x09, 0xea, 0x47, 0xcd, 0xaa, 0x7a,
   209  	0xe4, 0x9d, 0x59, 0xd5, 0xeb, 0x25, 0x59, 0x2b, 0x99, 0xd8, 0xe2, 0x63, 0x49, 0xb3, 0x53, 0x76,
   210  	0xf7, 0xb8, 0x0a, 0xb5, 0xa6, 0xd0, 0x11, 0x6c, 0x48, 0xf2, 0x01, 0x1d, 0x50, 0x47, 0xf0, 0x30,
   211  	0xdb, 0xa0, 0xcd, 0xf9, 0xd6, 0xe0, 0x7d, 0x8d, 0x92, 0xee, 0xd1, 0x5a, 0x96, 0xac, 0xa1, 0x5f,
   212  	0xd9, 0x53, 0xda, 0xe8, 0x15, 0xac, 0x0b, 0x3e, 0x90, 0xab, 0xcc, 0x78, 0x90, 0xf7, 0x31, 0x35,
   213  	0x05, 0xb9, 0x49, 0x32, 0xd5, 0xcb, 0x02, 0x66, 0xdd, 0xc8, 0x84, 0xeb, 0x93, 0x58, 0x64, 0xeb,
   214  	0x3a, 0xad, 0xfb, 0xf0, 0x7a, 0xa9, 0x9e, 0x19, 0x2b, 0xb3, 0xa6, 0xaf, 0xcc, 0xb2, 0xb6, 0x02,
   215  	0xd6, 0xce, 0xc9, 0xa5, 0x51, 0x39, 0xbd, 0x34, 0x2a, 0x67, 0x97, 0x46, 0xe5, 0x43, 0x62, 0x80,
   216  	0x93, 0xc4, 0x00, 0xa7, 0x89, 0x01, 0xce, 0x12, 0x03, 0x7c, 0x4f, 0x0c, 0x70, 0xfc, 0xc3, 0xa8,
   217  	0xbc, 0x46, 0xe5, 0xbf, 0xfa, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd3, 0x3f, 0x9c, 0xd0, 0xea,
   218  	0x05, 0x00, 0x00,
   219  }
   220  
   221  func (m *Overhead) Marshal() (dAtA []byte, err error) {
   222  	size := m.Size()
   223  	dAtA = make([]byte, size)
   224  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   225  	if err != nil {
   226  		return nil, err
   227  	}
   228  	return dAtA[:n], nil
   229  }
   230  
   231  func (m *Overhead) MarshalTo(dAtA []byte) (int, error) {
   232  	size := m.Size()
   233  	return m.MarshalToSizedBuffer(dAtA[:size])
   234  }
   235  
   236  func (m *Overhead) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   237  	i := len(dAtA)
   238  	_ = i
   239  	var l int
   240  	_ = l
   241  	if len(m.PodFixed) > 0 {
   242  		keysForPodFixed := make([]string, 0, len(m.PodFixed))
   243  		for k := range m.PodFixed {
   244  			keysForPodFixed = append(keysForPodFixed, string(k))
   245  		}
   246  		github_com_gogo_protobuf_sortkeys.Strings(keysForPodFixed)
   247  		for iNdEx := len(keysForPodFixed) - 1; iNdEx >= 0; iNdEx-- {
   248  			v := m.PodFixed[k8s_io_api_core_v1.ResourceName(keysForPodFixed[iNdEx])]
   249  			baseI := i
   250  			{
   251  				size, err := ((*resource.Quantity)(&v)).MarshalToSizedBuffer(dAtA[:i])
   252  				if err != nil {
   253  					return 0, err
   254  				}
   255  				i -= size
   256  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   257  			}
   258  			i--
   259  			dAtA[i] = 0x12
   260  			i -= len(keysForPodFixed[iNdEx])
   261  			copy(dAtA[i:], keysForPodFixed[iNdEx])
   262  			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForPodFixed[iNdEx])))
   263  			i--
   264  			dAtA[i] = 0xa
   265  			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
   266  			i--
   267  			dAtA[i] = 0xa
   268  		}
   269  	}
   270  	return len(dAtA) - i, nil
   271  }
   272  
   273  func (m *RuntimeClass) Marshal() (dAtA []byte, err error) {
   274  	size := m.Size()
   275  	dAtA = make([]byte, size)
   276  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   277  	if err != nil {
   278  		return nil, err
   279  	}
   280  	return dAtA[:n], nil
   281  }
   282  
   283  func (m *RuntimeClass) MarshalTo(dAtA []byte) (int, error) {
   284  	size := m.Size()
   285  	return m.MarshalToSizedBuffer(dAtA[:size])
   286  }
   287  
   288  func (m *RuntimeClass) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   289  	i := len(dAtA)
   290  	_ = i
   291  	var l int
   292  	_ = l
   293  	if m.Scheduling != nil {
   294  		{
   295  			size, err := m.Scheduling.MarshalToSizedBuffer(dAtA[:i])
   296  			if err != nil {
   297  				return 0, err
   298  			}
   299  			i -= size
   300  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   301  		}
   302  		i--
   303  		dAtA[i] = 0x22
   304  	}
   305  	if m.Overhead != nil {
   306  		{
   307  			size, err := m.Overhead.MarshalToSizedBuffer(dAtA[:i])
   308  			if err != nil {
   309  				return 0, err
   310  			}
   311  			i -= size
   312  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   313  		}
   314  		i--
   315  		dAtA[i] = 0x1a
   316  	}
   317  	i -= len(m.Handler)
   318  	copy(dAtA[i:], m.Handler)
   319  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Handler)))
   320  	i--
   321  	dAtA[i] = 0x12
   322  	{
   323  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   324  		if err != nil {
   325  			return 0, err
   326  		}
   327  		i -= size
   328  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   329  	}
   330  	i--
   331  	dAtA[i] = 0xa
   332  	return len(dAtA) - i, nil
   333  }
   334  
   335  func (m *RuntimeClassList) Marshal() (dAtA []byte, err error) {
   336  	size := m.Size()
   337  	dAtA = make([]byte, size)
   338  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   339  	if err != nil {
   340  		return nil, err
   341  	}
   342  	return dAtA[:n], nil
   343  }
   344  
   345  func (m *RuntimeClassList) MarshalTo(dAtA []byte) (int, error) {
   346  	size := m.Size()
   347  	return m.MarshalToSizedBuffer(dAtA[:size])
   348  }
   349  
   350  func (m *RuntimeClassList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   351  	i := len(dAtA)
   352  	_ = i
   353  	var l int
   354  	_ = l
   355  	if len(m.Items) > 0 {
   356  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   357  			{
   358  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   359  				if err != nil {
   360  					return 0, err
   361  				}
   362  				i -= size
   363  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   364  			}
   365  			i--
   366  			dAtA[i] = 0x12
   367  		}
   368  	}
   369  	{
   370  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   371  		if err != nil {
   372  			return 0, err
   373  		}
   374  		i -= size
   375  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   376  	}
   377  	i--
   378  	dAtA[i] = 0xa
   379  	return len(dAtA) - i, nil
   380  }
   381  
   382  func (m *Scheduling) Marshal() (dAtA []byte, err error) {
   383  	size := m.Size()
   384  	dAtA = make([]byte, size)
   385  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   386  	if err != nil {
   387  		return nil, err
   388  	}
   389  	return dAtA[:n], nil
   390  }
   391  
   392  func (m *Scheduling) MarshalTo(dAtA []byte) (int, error) {
   393  	size := m.Size()
   394  	return m.MarshalToSizedBuffer(dAtA[:size])
   395  }
   396  
   397  func (m *Scheduling) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   398  	i := len(dAtA)
   399  	_ = i
   400  	var l int
   401  	_ = l
   402  	if len(m.Tolerations) > 0 {
   403  		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
   404  			{
   405  				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   406  				if err != nil {
   407  					return 0, err
   408  				}
   409  				i -= size
   410  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   411  			}
   412  			i--
   413  			dAtA[i] = 0x12
   414  		}
   415  	}
   416  	if len(m.NodeSelector) > 0 {
   417  		keysForNodeSelector := make([]string, 0, len(m.NodeSelector))
   418  		for k := range m.NodeSelector {
   419  			keysForNodeSelector = append(keysForNodeSelector, string(k))
   420  		}
   421  		github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
   422  		for iNdEx := len(keysForNodeSelector) - 1; iNdEx >= 0; iNdEx-- {
   423  			v := m.NodeSelector[string(keysForNodeSelector[iNdEx])]
   424  			baseI := i
   425  			i -= len(v)
   426  			copy(dAtA[i:], v)
   427  			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
   428  			i--
   429  			dAtA[i] = 0x12
   430  			i -= len(keysForNodeSelector[iNdEx])
   431  			copy(dAtA[i:], keysForNodeSelector[iNdEx])
   432  			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForNodeSelector[iNdEx])))
   433  			i--
   434  			dAtA[i] = 0xa
   435  			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
   436  			i--
   437  			dAtA[i] = 0xa
   438  		}
   439  	}
   440  	return len(dAtA) - i, nil
   441  }
   442  
   443  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
   444  	offset -= sovGenerated(v)
   445  	base := offset
   446  	for v >= 1<<7 {
   447  		dAtA[offset] = uint8(v&0x7f | 0x80)
   448  		v >>= 7
   449  		offset++
   450  	}
   451  	dAtA[offset] = uint8(v)
   452  	return base
   453  }
   454  func (m *Overhead) Size() (n int) {
   455  	if m == nil {
   456  		return 0
   457  	}
   458  	var l int
   459  	_ = l
   460  	if len(m.PodFixed) > 0 {
   461  		for k, v := range m.PodFixed {
   462  			_ = k
   463  			_ = v
   464  			l = ((*resource.Quantity)(&v)).Size()
   465  			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
   466  			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
   467  		}
   468  	}
   469  	return n
   470  }
   471  
   472  func (m *RuntimeClass) Size() (n int) {
   473  	if m == nil {
   474  		return 0
   475  	}
   476  	var l int
   477  	_ = l
   478  	l = m.ObjectMeta.Size()
   479  	n += 1 + l + sovGenerated(uint64(l))
   480  	l = len(m.Handler)
   481  	n += 1 + l + sovGenerated(uint64(l))
   482  	if m.Overhead != nil {
   483  		l = m.Overhead.Size()
   484  		n += 1 + l + sovGenerated(uint64(l))
   485  	}
   486  	if m.Scheduling != nil {
   487  		l = m.Scheduling.Size()
   488  		n += 1 + l + sovGenerated(uint64(l))
   489  	}
   490  	return n
   491  }
   492  
   493  func (m *RuntimeClassList) Size() (n int) {
   494  	if m == nil {
   495  		return 0
   496  	}
   497  	var l int
   498  	_ = l
   499  	l = m.ListMeta.Size()
   500  	n += 1 + l + sovGenerated(uint64(l))
   501  	if len(m.Items) > 0 {
   502  		for _, e := range m.Items {
   503  			l = e.Size()
   504  			n += 1 + l + sovGenerated(uint64(l))
   505  		}
   506  	}
   507  	return n
   508  }
   509  
   510  func (m *Scheduling) Size() (n int) {
   511  	if m == nil {
   512  		return 0
   513  	}
   514  	var l int
   515  	_ = l
   516  	if len(m.NodeSelector) > 0 {
   517  		for k, v := range m.NodeSelector {
   518  			_ = k
   519  			_ = v
   520  			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
   521  			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
   522  		}
   523  	}
   524  	if len(m.Tolerations) > 0 {
   525  		for _, e := range m.Tolerations {
   526  			l = e.Size()
   527  			n += 1 + l + sovGenerated(uint64(l))
   528  		}
   529  	}
   530  	return n
   531  }
   532  
   533  func sovGenerated(x uint64) (n int) {
   534  	return (math_bits.Len64(x|1) + 6) / 7
   535  }
   536  func sozGenerated(x uint64) (n int) {
   537  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   538  }
   539  func (this *Overhead) String() string {
   540  	if this == nil {
   541  		return "nil"
   542  	}
   543  	keysForPodFixed := make([]string, 0, len(this.PodFixed))
   544  	for k := range this.PodFixed {
   545  		keysForPodFixed = append(keysForPodFixed, string(k))
   546  	}
   547  	github_com_gogo_protobuf_sortkeys.Strings(keysForPodFixed)
   548  	mapStringForPodFixed := "k8s_io_api_core_v1.ResourceList{"
   549  	for _, k := range keysForPodFixed {
   550  		mapStringForPodFixed += fmt.Sprintf("%v: %v,", k, this.PodFixed[k8s_io_api_core_v1.ResourceName(k)])
   551  	}
   552  	mapStringForPodFixed += "}"
   553  	s := strings.Join([]string{`&Overhead{`,
   554  		`PodFixed:` + mapStringForPodFixed + `,`,
   555  		`}`,
   556  	}, "")
   557  	return s
   558  }
   559  func (this *RuntimeClass) String() string {
   560  	if this == nil {
   561  		return "nil"
   562  	}
   563  	s := strings.Join([]string{`&RuntimeClass{`,
   564  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
   565  		`Handler:` + fmt.Sprintf("%v", this.Handler) + `,`,
   566  		`Overhead:` + strings.Replace(this.Overhead.String(), "Overhead", "Overhead", 1) + `,`,
   567  		`Scheduling:` + strings.Replace(this.Scheduling.String(), "Scheduling", "Scheduling", 1) + `,`,
   568  		`}`,
   569  	}, "")
   570  	return s
   571  }
   572  func (this *RuntimeClassList) String() string {
   573  	if this == nil {
   574  		return "nil"
   575  	}
   576  	repeatedStringForItems := "[]RuntimeClass{"
   577  	for _, f := range this.Items {
   578  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "RuntimeClass", "RuntimeClass", 1), `&`, ``, 1) + ","
   579  	}
   580  	repeatedStringForItems += "}"
   581  	s := strings.Join([]string{`&RuntimeClassList{`,
   582  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
   583  		`Items:` + repeatedStringForItems + `,`,
   584  		`}`,
   585  	}, "")
   586  	return s
   587  }
   588  func (this *Scheduling) String() string {
   589  	if this == nil {
   590  		return "nil"
   591  	}
   592  	repeatedStringForTolerations := "[]Toleration{"
   593  	for _, f := range this.Tolerations {
   594  		repeatedStringForTolerations += fmt.Sprintf("%v", f) + ","
   595  	}
   596  	repeatedStringForTolerations += "}"
   597  	keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
   598  	for k := range this.NodeSelector {
   599  		keysForNodeSelector = append(keysForNodeSelector, k)
   600  	}
   601  	github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
   602  	mapStringForNodeSelector := "map[string]string{"
   603  	for _, k := range keysForNodeSelector {
   604  		mapStringForNodeSelector += fmt.Sprintf("%v: %v,", k, this.NodeSelector[k])
   605  	}
   606  	mapStringForNodeSelector += "}"
   607  	s := strings.Join([]string{`&Scheduling{`,
   608  		`NodeSelector:` + mapStringForNodeSelector + `,`,
   609  		`Tolerations:` + repeatedStringForTolerations + `,`,
   610  		`}`,
   611  	}, "")
   612  	return s
   613  }
   614  func valueToStringGenerated(v interface{}) string {
   615  	rv := reflect.ValueOf(v)
   616  	if rv.IsNil() {
   617  		return "nil"
   618  	}
   619  	pv := reflect.Indirect(rv).Interface()
   620  	return fmt.Sprintf("*%v", pv)
   621  }
   622  func (m *Overhead) Unmarshal(dAtA []byte) error {
   623  	l := len(dAtA)
   624  	iNdEx := 0
   625  	for iNdEx < l {
   626  		preIndex := iNdEx
   627  		var wire uint64
   628  		for shift := uint(0); ; shift += 7 {
   629  			if shift >= 64 {
   630  				return ErrIntOverflowGenerated
   631  			}
   632  			if iNdEx >= l {
   633  				return io.ErrUnexpectedEOF
   634  			}
   635  			b := dAtA[iNdEx]
   636  			iNdEx++
   637  			wire |= uint64(b&0x7F) << shift
   638  			if b < 0x80 {
   639  				break
   640  			}
   641  		}
   642  		fieldNum := int32(wire >> 3)
   643  		wireType := int(wire & 0x7)
   644  		if wireType == 4 {
   645  			return fmt.Errorf("proto: Overhead: wiretype end group for non-group")
   646  		}
   647  		if fieldNum <= 0 {
   648  			return fmt.Errorf("proto: Overhead: illegal tag %d (wire type %d)", fieldNum, wire)
   649  		}
   650  		switch fieldNum {
   651  		case 1:
   652  			if wireType != 2 {
   653  				return fmt.Errorf("proto: wrong wireType = %d for field PodFixed", wireType)
   654  			}
   655  			var msglen int
   656  			for shift := uint(0); ; shift += 7 {
   657  				if shift >= 64 {
   658  					return ErrIntOverflowGenerated
   659  				}
   660  				if iNdEx >= l {
   661  					return io.ErrUnexpectedEOF
   662  				}
   663  				b := dAtA[iNdEx]
   664  				iNdEx++
   665  				msglen |= int(b&0x7F) << shift
   666  				if b < 0x80 {
   667  					break
   668  				}
   669  			}
   670  			if msglen < 0 {
   671  				return ErrInvalidLengthGenerated
   672  			}
   673  			postIndex := iNdEx + msglen
   674  			if postIndex < 0 {
   675  				return ErrInvalidLengthGenerated
   676  			}
   677  			if postIndex > l {
   678  				return io.ErrUnexpectedEOF
   679  			}
   680  			if m.PodFixed == nil {
   681  				m.PodFixed = make(k8s_io_api_core_v1.ResourceList)
   682  			}
   683  			var mapkey k8s_io_api_core_v1.ResourceName
   684  			mapvalue := &resource.Quantity{}
   685  			for iNdEx < postIndex {
   686  				entryPreIndex := iNdEx
   687  				var wire uint64
   688  				for shift := uint(0); ; shift += 7 {
   689  					if shift >= 64 {
   690  						return ErrIntOverflowGenerated
   691  					}
   692  					if iNdEx >= l {
   693  						return io.ErrUnexpectedEOF
   694  					}
   695  					b := dAtA[iNdEx]
   696  					iNdEx++
   697  					wire |= uint64(b&0x7F) << shift
   698  					if b < 0x80 {
   699  						break
   700  					}
   701  				}
   702  				fieldNum := int32(wire >> 3)
   703  				if fieldNum == 1 {
   704  					var stringLenmapkey uint64
   705  					for shift := uint(0); ; shift += 7 {
   706  						if shift >= 64 {
   707  							return ErrIntOverflowGenerated
   708  						}
   709  						if iNdEx >= l {
   710  							return io.ErrUnexpectedEOF
   711  						}
   712  						b := dAtA[iNdEx]
   713  						iNdEx++
   714  						stringLenmapkey |= uint64(b&0x7F) << shift
   715  						if b < 0x80 {
   716  							break
   717  						}
   718  					}
   719  					intStringLenmapkey := int(stringLenmapkey)
   720  					if intStringLenmapkey < 0 {
   721  						return ErrInvalidLengthGenerated
   722  					}
   723  					postStringIndexmapkey := iNdEx + intStringLenmapkey
   724  					if postStringIndexmapkey < 0 {
   725  						return ErrInvalidLengthGenerated
   726  					}
   727  					if postStringIndexmapkey > l {
   728  						return io.ErrUnexpectedEOF
   729  					}
   730  					mapkey = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
   731  					iNdEx = postStringIndexmapkey
   732  				} else if fieldNum == 2 {
   733  					var mapmsglen int
   734  					for shift := uint(0); ; shift += 7 {
   735  						if shift >= 64 {
   736  							return ErrIntOverflowGenerated
   737  						}
   738  						if iNdEx >= l {
   739  							return io.ErrUnexpectedEOF
   740  						}
   741  						b := dAtA[iNdEx]
   742  						iNdEx++
   743  						mapmsglen |= int(b&0x7F) << shift
   744  						if b < 0x80 {
   745  							break
   746  						}
   747  					}
   748  					if mapmsglen < 0 {
   749  						return ErrInvalidLengthGenerated
   750  					}
   751  					postmsgIndex := iNdEx + mapmsglen
   752  					if postmsgIndex < 0 {
   753  						return ErrInvalidLengthGenerated
   754  					}
   755  					if postmsgIndex > l {
   756  						return io.ErrUnexpectedEOF
   757  					}
   758  					mapvalue = &resource.Quantity{}
   759  					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
   760  						return err
   761  					}
   762  					iNdEx = postmsgIndex
   763  				} else {
   764  					iNdEx = entryPreIndex
   765  					skippy, err := skipGenerated(dAtA[iNdEx:])
   766  					if err != nil {
   767  						return err
   768  					}
   769  					if (skippy < 0) || (iNdEx+skippy) < 0 {
   770  						return ErrInvalidLengthGenerated
   771  					}
   772  					if (iNdEx + skippy) > postIndex {
   773  						return io.ErrUnexpectedEOF
   774  					}
   775  					iNdEx += skippy
   776  				}
   777  			}
   778  			m.PodFixed[k8s_io_api_core_v1.ResourceName(mapkey)] = ((k8s_io_apimachinery_pkg_api_resource.Quantity)(*mapvalue))
   779  			iNdEx = postIndex
   780  		default:
   781  			iNdEx = preIndex
   782  			skippy, err := skipGenerated(dAtA[iNdEx:])
   783  			if err != nil {
   784  				return err
   785  			}
   786  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   787  				return ErrInvalidLengthGenerated
   788  			}
   789  			if (iNdEx + skippy) > l {
   790  				return io.ErrUnexpectedEOF
   791  			}
   792  			iNdEx += skippy
   793  		}
   794  	}
   795  
   796  	if iNdEx > l {
   797  		return io.ErrUnexpectedEOF
   798  	}
   799  	return nil
   800  }
   801  func (m *RuntimeClass) Unmarshal(dAtA []byte) error {
   802  	l := len(dAtA)
   803  	iNdEx := 0
   804  	for iNdEx < l {
   805  		preIndex := iNdEx
   806  		var wire uint64
   807  		for shift := uint(0); ; shift += 7 {
   808  			if shift >= 64 {
   809  				return ErrIntOverflowGenerated
   810  			}
   811  			if iNdEx >= l {
   812  				return io.ErrUnexpectedEOF
   813  			}
   814  			b := dAtA[iNdEx]
   815  			iNdEx++
   816  			wire |= uint64(b&0x7F) << shift
   817  			if b < 0x80 {
   818  				break
   819  			}
   820  		}
   821  		fieldNum := int32(wire >> 3)
   822  		wireType := int(wire & 0x7)
   823  		if wireType == 4 {
   824  			return fmt.Errorf("proto: RuntimeClass: wiretype end group for non-group")
   825  		}
   826  		if fieldNum <= 0 {
   827  			return fmt.Errorf("proto: RuntimeClass: illegal tag %d (wire type %d)", fieldNum, wire)
   828  		}
   829  		switch fieldNum {
   830  		case 1:
   831  			if wireType != 2 {
   832  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
   833  			}
   834  			var msglen int
   835  			for shift := uint(0); ; shift += 7 {
   836  				if shift >= 64 {
   837  					return ErrIntOverflowGenerated
   838  				}
   839  				if iNdEx >= l {
   840  					return io.ErrUnexpectedEOF
   841  				}
   842  				b := dAtA[iNdEx]
   843  				iNdEx++
   844  				msglen |= int(b&0x7F) << shift
   845  				if b < 0x80 {
   846  					break
   847  				}
   848  			}
   849  			if msglen < 0 {
   850  				return ErrInvalidLengthGenerated
   851  			}
   852  			postIndex := iNdEx + msglen
   853  			if postIndex < 0 {
   854  				return ErrInvalidLengthGenerated
   855  			}
   856  			if postIndex > l {
   857  				return io.ErrUnexpectedEOF
   858  			}
   859  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   860  				return err
   861  			}
   862  			iNdEx = postIndex
   863  		case 2:
   864  			if wireType != 2 {
   865  				return fmt.Errorf("proto: wrong wireType = %d for field Handler", wireType)
   866  			}
   867  			var stringLen uint64
   868  			for shift := uint(0); ; shift += 7 {
   869  				if shift >= 64 {
   870  					return ErrIntOverflowGenerated
   871  				}
   872  				if iNdEx >= l {
   873  					return io.ErrUnexpectedEOF
   874  				}
   875  				b := dAtA[iNdEx]
   876  				iNdEx++
   877  				stringLen |= uint64(b&0x7F) << shift
   878  				if b < 0x80 {
   879  					break
   880  				}
   881  			}
   882  			intStringLen := int(stringLen)
   883  			if intStringLen < 0 {
   884  				return ErrInvalidLengthGenerated
   885  			}
   886  			postIndex := iNdEx + intStringLen
   887  			if postIndex < 0 {
   888  				return ErrInvalidLengthGenerated
   889  			}
   890  			if postIndex > l {
   891  				return io.ErrUnexpectedEOF
   892  			}
   893  			m.Handler = string(dAtA[iNdEx:postIndex])
   894  			iNdEx = postIndex
   895  		case 3:
   896  			if wireType != 2 {
   897  				return fmt.Errorf("proto: wrong wireType = %d for field Overhead", wireType)
   898  			}
   899  			var msglen int
   900  			for shift := uint(0); ; shift += 7 {
   901  				if shift >= 64 {
   902  					return ErrIntOverflowGenerated
   903  				}
   904  				if iNdEx >= l {
   905  					return io.ErrUnexpectedEOF
   906  				}
   907  				b := dAtA[iNdEx]
   908  				iNdEx++
   909  				msglen |= int(b&0x7F) << shift
   910  				if b < 0x80 {
   911  					break
   912  				}
   913  			}
   914  			if msglen < 0 {
   915  				return ErrInvalidLengthGenerated
   916  			}
   917  			postIndex := iNdEx + msglen
   918  			if postIndex < 0 {
   919  				return ErrInvalidLengthGenerated
   920  			}
   921  			if postIndex > l {
   922  				return io.ErrUnexpectedEOF
   923  			}
   924  			if m.Overhead == nil {
   925  				m.Overhead = &Overhead{}
   926  			}
   927  			if err := m.Overhead.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   928  				return err
   929  			}
   930  			iNdEx = postIndex
   931  		case 4:
   932  			if wireType != 2 {
   933  				return fmt.Errorf("proto: wrong wireType = %d for field Scheduling", wireType)
   934  			}
   935  			var msglen int
   936  			for shift := uint(0); ; shift += 7 {
   937  				if shift >= 64 {
   938  					return ErrIntOverflowGenerated
   939  				}
   940  				if iNdEx >= l {
   941  					return io.ErrUnexpectedEOF
   942  				}
   943  				b := dAtA[iNdEx]
   944  				iNdEx++
   945  				msglen |= int(b&0x7F) << shift
   946  				if b < 0x80 {
   947  					break
   948  				}
   949  			}
   950  			if msglen < 0 {
   951  				return ErrInvalidLengthGenerated
   952  			}
   953  			postIndex := iNdEx + msglen
   954  			if postIndex < 0 {
   955  				return ErrInvalidLengthGenerated
   956  			}
   957  			if postIndex > l {
   958  				return io.ErrUnexpectedEOF
   959  			}
   960  			if m.Scheduling == nil {
   961  				m.Scheduling = &Scheduling{}
   962  			}
   963  			if err := m.Scheduling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   964  				return err
   965  			}
   966  			iNdEx = postIndex
   967  		default:
   968  			iNdEx = preIndex
   969  			skippy, err := skipGenerated(dAtA[iNdEx:])
   970  			if err != nil {
   971  				return err
   972  			}
   973  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   974  				return ErrInvalidLengthGenerated
   975  			}
   976  			if (iNdEx + skippy) > l {
   977  				return io.ErrUnexpectedEOF
   978  			}
   979  			iNdEx += skippy
   980  		}
   981  	}
   982  
   983  	if iNdEx > l {
   984  		return io.ErrUnexpectedEOF
   985  	}
   986  	return nil
   987  }
   988  func (m *RuntimeClassList) Unmarshal(dAtA []byte) error {
   989  	l := len(dAtA)
   990  	iNdEx := 0
   991  	for iNdEx < l {
   992  		preIndex := iNdEx
   993  		var wire uint64
   994  		for shift := uint(0); ; shift += 7 {
   995  			if shift >= 64 {
   996  				return ErrIntOverflowGenerated
   997  			}
   998  			if iNdEx >= l {
   999  				return io.ErrUnexpectedEOF
  1000  			}
  1001  			b := dAtA[iNdEx]
  1002  			iNdEx++
  1003  			wire |= uint64(b&0x7F) << shift
  1004  			if b < 0x80 {
  1005  				break
  1006  			}
  1007  		}
  1008  		fieldNum := int32(wire >> 3)
  1009  		wireType := int(wire & 0x7)
  1010  		if wireType == 4 {
  1011  			return fmt.Errorf("proto: RuntimeClassList: wiretype end group for non-group")
  1012  		}
  1013  		if fieldNum <= 0 {
  1014  			return fmt.Errorf("proto: RuntimeClassList: illegal tag %d (wire type %d)", fieldNum, wire)
  1015  		}
  1016  		switch fieldNum {
  1017  		case 1:
  1018  			if wireType != 2 {
  1019  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1020  			}
  1021  			var msglen int
  1022  			for shift := uint(0); ; shift += 7 {
  1023  				if shift >= 64 {
  1024  					return ErrIntOverflowGenerated
  1025  				}
  1026  				if iNdEx >= l {
  1027  					return io.ErrUnexpectedEOF
  1028  				}
  1029  				b := dAtA[iNdEx]
  1030  				iNdEx++
  1031  				msglen |= int(b&0x7F) << shift
  1032  				if b < 0x80 {
  1033  					break
  1034  				}
  1035  			}
  1036  			if msglen < 0 {
  1037  				return ErrInvalidLengthGenerated
  1038  			}
  1039  			postIndex := iNdEx + msglen
  1040  			if postIndex < 0 {
  1041  				return ErrInvalidLengthGenerated
  1042  			}
  1043  			if postIndex > l {
  1044  				return io.ErrUnexpectedEOF
  1045  			}
  1046  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1047  				return err
  1048  			}
  1049  			iNdEx = postIndex
  1050  		case 2:
  1051  			if wireType != 2 {
  1052  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1053  			}
  1054  			var msglen int
  1055  			for shift := uint(0); ; shift += 7 {
  1056  				if shift >= 64 {
  1057  					return ErrIntOverflowGenerated
  1058  				}
  1059  				if iNdEx >= l {
  1060  					return io.ErrUnexpectedEOF
  1061  				}
  1062  				b := dAtA[iNdEx]
  1063  				iNdEx++
  1064  				msglen |= int(b&0x7F) << shift
  1065  				if b < 0x80 {
  1066  					break
  1067  				}
  1068  			}
  1069  			if msglen < 0 {
  1070  				return ErrInvalidLengthGenerated
  1071  			}
  1072  			postIndex := iNdEx + msglen
  1073  			if postIndex < 0 {
  1074  				return ErrInvalidLengthGenerated
  1075  			}
  1076  			if postIndex > l {
  1077  				return io.ErrUnexpectedEOF
  1078  			}
  1079  			m.Items = append(m.Items, RuntimeClass{})
  1080  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1081  				return err
  1082  			}
  1083  			iNdEx = postIndex
  1084  		default:
  1085  			iNdEx = preIndex
  1086  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1087  			if err != nil {
  1088  				return err
  1089  			}
  1090  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1091  				return ErrInvalidLengthGenerated
  1092  			}
  1093  			if (iNdEx + skippy) > l {
  1094  				return io.ErrUnexpectedEOF
  1095  			}
  1096  			iNdEx += skippy
  1097  		}
  1098  	}
  1099  
  1100  	if iNdEx > l {
  1101  		return io.ErrUnexpectedEOF
  1102  	}
  1103  	return nil
  1104  }
  1105  func (m *Scheduling) Unmarshal(dAtA []byte) error {
  1106  	l := len(dAtA)
  1107  	iNdEx := 0
  1108  	for iNdEx < l {
  1109  		preIndex := iNdEx
  1110  		var wire uint64
  1111  		for shift := uint(0); ; shift += 7 {
  1112  			if shift >= 64 {
  1113  				return ErrIntOverflowGenerated
  1114  			}
  1115  			if iNdEx >= l {
  1116  				return io.ErrUnexpectedEOF
  1117  			}
  1118  			b := dAtA[iNdEx]
  1119  			iNdEx++
  1120  			wire |= uint64(b&0x7F) << shift
  1121  			if b < 0x80 {
  1122  				break
  1123  			}
  1124  		}
  1125  		fieldNum := int32(wire >> 3)
  1126  		wireType := int(wire & 0x7)
  1127  		if wireType == 4 {
  1128  			return fmt.Errorf("proto: Scheduling: wiretype end group for non-group")
  1129  		}
  1130  		if fieldNum <= 0 {
  1131  			return fmt.Errorf("proto: Scheduling: illegal tag %d (wire type %d)", fieldNum, wire)
  1132  		}
  1133  		switch fieldNum {
  1134  		case 1:
  1135  			if wireType != 2 {
  1136  				return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
  1137  			}
  1138  			var msglen int
  1139  			for shift := uint(0); ; shift += 7 {
  1140  				if shift >= 64 {
  1141  					return ErrIntOverflowGenerated
  1142  				}
  1143  				if iNdEx >= l {
  1144  					return io.ErrUnexpectedEOF
  1145  				}
  1146  				b := dAtA[iNdEx]
  1147  				iNdEx++
  1148  				msglen |= int(b&0x7F) << shift
  1149  				if b < 0x80 {
  1150  					break
  1151  				}
  1152  			}
  1153  			if msglen < 0 {
  1154  				return ErrInvalidLengthGenerated
  1155  			}
  1156  			postIndex := iNdEx + msglen
  1157  			if postIndex < 0 {
  1158  				return ErrInvalidLengthGenerated
  1159  			}
  1160  			if postIndex > l {
  1161  				return io.ErrUnexpectedEOF
  1162  			}
  1163  			if m.NodeSelector == nil {
  1164  				m.NodeSelector = make(map[string]string)
  1165  			}
  1166  			var mapkey string
  1167  			var mapvalue string
  1168  			for iNdEx < postIndex {
  1169  				entryPreIndex := iNdEx
  1170  				var wire uint64
  1171  				for shift := uint(0); ; shift += 7 {
  1172  					if shift >= 64 {
  1173  						return ErrIntOverflowGenerated
  1174  					}
  1175  					if iNdEx >= l {
  1176  						return io.ErrUnexpectedEOF
  1177  					}
  1178  					b := dAtA[iNdEx]
  1179  					iNdEx++
  1180  					wire |= uint64(b&0x7F) << shift
  1181  					if b < 0x80 {
  1182  						break
  1183  					}
  1184  				}
  1185  				fieldNum := int32(wire >> 3)
  1186  				if fieldNum == 1 {
  1187  					var stringLenmapkey uint64
  1188  					for shift := uint(0); ; shift += 7 {
  1189  						if shift >= 64 {
  1190  							return ErrIntOverflowGenerated
  1191  						}
  1192  						if iNdEx >= l {
  1193  							return io.ErrUnexpectedEOF
  1194  						}
  1195  						b := dAtA[iNdEx]
  1196  						iNdEx++
  1197  						stringLenmapkey |= uint64(b&0x7F) << shift
  1198  						if b < 0x80 {
  1199  							break
  1200  						}
  1201  					}
  1202  					intStringLenmapkey := int(stringLenmapkey)
  1203  					if intStringLenmapkey < 0 {
  1204  						return ErrInvalidLengthGenerated
  1205  					}
  1206  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  1207  					if postStringIndexmapkey < 0 {
  1208  						return ErrInvalidLengthGenerated
  1209  					}
  1210  					if postStringIndexmapkey > l {
  1211  						return io.ErrUnexpectedEOF
  1212  					}
  1213  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  1214  					iNdEx = postStringIndexmapkey
  1215  				} else if fieldNum == 2 {
  1216  					var stringLenmapvalue uint64
  1217  					for shift := uint(0); ; shift += 7 {
  1218  						if shift >= 64 {
  1219  							return ErrIntOverflowGenerated
  1220  						}
  1221  						if iNdEx >= l {
  1222  							return io.ErrUnexpectedEOF
  1223  						}
  1224  						b := dAtA[iNdEx]
  1225  						iNdEx++
  1226  						stringLenmapvalue |= uint64(b&0x7F) << shift
  1227  						if b < 0x80 {
  1228  							break
  1229  						}
  1230  					}
  1231  					intStringLenmapvalue := int(stringLenmapvalue)
  1232  					if intStringLenmapvalue < 0 {
  1233  						return ErrInvalidLengthGenerated
  1234  					}
  1235  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  1236  					if postStringIndexmapvalue < 0 {
  1237  						return ErrInvalidLengthGenerated
  1238  					}
  1239  					if postStringIndexmapvalue > l {
  1240  						return io.ErrUnexpectedEOF
  1241  					}
  1242  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  1243  					iNdEx = postStringIndexmapvalue
  1244  				} else {
  1245  					iNdEx = entryPreIndex
  1246  					skippy, err := skipGenerated(dAtA[iNdEx:])
  1247  					if err != nil {
  1248  						return err
  1249  					}
  1250  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  1251  						return ErrInvalidLengthGenerated
  1252  					}
  1253  					if (iNdEx + skippy) > postIndex {
  1254  						return io.ErrUnexpectedEOF
  1255  					}
  1256  					iNdEx += skippy
  1257  				}
  1258  			}
  1259  			m.NodeSelector[mapkey] = mapvalue
  1260  			iNdEx = postIndex
  1261  		case 2:
  1262  			if wireType != 2 {
  1263  				return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
  1264  			}
  1265  			var msglen int
  1266  			for shift := uint(0); ; shift += 7 {
  1267  				if shift >= 64 {
  1268  					return ErrIntOverflowGenerated
  1269  				}
  1270  				if iNdEx >= l {
  1271  					return io.ErrUnexpectedEOF
  1272  				}
  1273  				b := dAtA[iNdEx]
  1274  				iNdEx++
  1275  				msglen |= int(b&0x7F) << shift
  1276  				if b < 0x80 {
  1277  					break
  1278  				}
  1279  			}
  1280  			if msglen < 0 {
  1281  				return ErrInvalidLengthGenerated
  1282  			}
  1283  			postIndex := iNdEx + msglen
  1284  			if postIndex < 0 {
  1285  				return ErrInvalidLengthGenerated
  1286  			}
  1287  			if postIndex > l {
  1288  				return io.ErrUnexpectedEOF
  1289  			}
  1290  			m.Tolerations = append(m.Tolerations, v11.Toleration{})
  1291  			if err := m.Tolerations[len(m.Tolerations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1292  				return err
  1293  			}
  1294  			iNdEx = postIndex
  1295  		default:
  1296  			iNdEx = preIndex
  1297  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1298  			if err != nil {
  1299  				return err
  1300  			}
  1301  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1302  				return ErrInvalidLengthGenerated
  1303  			}
  1304  			if (iNdEx + skippy) > l {
  1305  				return io.ErrUnexpectedEOF
  1306  			}
  1307  			iNdEx += skippy
  1308  		}
  1309  	}
  1310  
  1311  	if iNdEx > l {
  1312  		return io.ErrUnexpectedEOF
  1313  	}
  1314  	return nil
  1315  }
  1316  func skipGenerated(dAtA []byte) (n int, err error) {
  1317  	l := len(dAtA)
  1318  	iNdEx := 0
  1319  	depth := 0
  1320  	for iNdEx < l {
  1321  		var wire uint64
  1322  		for shift := uint(0); ; shift += 7 {
  1323  			if shift >= 64 {
  1324  				return 0, ErrIntOverflowGenerated
  1325  			}
  1326  			if iNdEx >= l {
  1327  				return 0, io.ErrUnexpectedEOF
  1328  			}
  1329  			b := dAtA[iNdEx]
  1330  			iNdEx++
  1331  			wire |= (uint64(b) & 0x7F) << shift
  1332  			if b < 0x80 {
  1333  				break
  1334  			}
  1335  		}
  1336  		wireType := int(wire & 0x7)
  1337  		switch wireType {
  1338  		case 0:
  1339  			for shift := uint(0); ; shift += 7 {
  1340  				if shift >= 64 {
  1341  					return 0, ErrIntOverflowGenerated
  1342  				}
  1343  				if iNdEx >= l {
  1344  					return 0, io.ErrUnexpectedEOF
  1345  				}
  1346  				iNdEx++
  1347  				if dAtA[iNdEx-1] < 0x80 {
  1348  					break
  1349  				}
  1350  			}
  1351  		case 1:
  1352  			iNdEx += 8
  1353  		case 2:
  1354  			var length int
  1355  			for shift := uint(0); ; shift += 7 {
  1356  				if shift >= 64 {
  1357  					return 0, ErrIntOverflowGenerated
  1358  				}
  1359  				if iNdEx >= l {
  1360  					return 0, io.ErrUnexpectedEOF
  1361  				}
  1362  				b := dAtA[iNdEx]
  1363  				iNdEx++
  1364  				length |= (int(b) & 0x7F) << shift
  1365  				if b < 0x80 {
  1366  					break
  1367  				}
  1368  			}
  1369  			if length < 0 {
  1370  				return 0, ErrInvalidLengthGenerated
  1371  			}
  1372  			iNdEx += length
  1373  		case 3:
  1374  			depth++
  1375  		case 4:
  1376  			if depth == 0 {
  1377  				return 0, ErrUnexpectedEndOfGroupGenerated
  1378  			}
  1379  			depth--
  1380  		case 5:
  1381  			iNdEx += 4
  1382  		default:
  1383  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1384  		}
  1385  		if iNdEx < 0 {
  1386  			return 0, ErrInvalidLengthGenerated
  1387  		}
  1388  		if depth == 0 {
  1389  			return iNdEx, nil
  1390  		}
  1391  	}
  1392  	return 0, io.ErrUnexpectedEOF
  1393  }
  1394  
  1395  var (
  1396  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  1397  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  1398  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  1399  )
  1400  

View as plain text