k8s.io/apiserver@v0.31.1/pkg/apis/example2/v1/generated.pb.go (about)

     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/apiserver/pkg/apis/example2/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  
    29  	math "math"
    30  	math_bits "math/bits"
    31  	reflect "reflect"
    32  	strings "strings"
    33  )
    34  
    35  // Reference imports to suppress errors if they are not otherwise used.
    36  var _ = proto.Marshal
    37  var _ = fmt.Errorf
    38  var _ = math.Inf
    39  
    40  // This is a compile-time assertion to ensure that this generated file
    41  // is compatible with the proto package it is being compiled against.
    42  // A compilation error at this line likely means your copy of the
    43  // proto package needs to be updated.
    44  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    45  
    46  func (m *ReplicaSet) Reset()      { *m = ReplicaSet{} }
    47  func (*ReplicaSet) ProtoMessage() {}
    48  func (*ReplicaSet) Descriptor() ([]byte, []int) {
    49  	return fileDescriptor_c0d8f6d73eb5bf83, []int{0}
    50  }
    51  func (m *ReplicaSet) XXX_Unmarshal(b []byte) error {
    52  	return m.Unmarshal(b)
    53  }
    54  func (m *ReplicaSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    55  	b = b[:cap(b)]
    56  	n, err := m.MarshalToSizedBuffer(b)
    57  	if err != nil {
    58  		return nil, err
    59  	}
    60  	return b[:n], nil
    61  }
    62  func (m *ReplicaSet) XXX_Merge(src proto.Message) {
    63  	xxx_messageInfo_ReplicaSet.Merge(m, src)
    64  }
    65  func (m *ReplicaSet) XXX_Size() int {
    66  	return m.Size()
    67  }
    68  func (m *ReplicaSet) XXX_DiscardUnknown() {
    69  	xxx_messageInfo_ReplicaSet.DiscardUnknown(m)
    70  }
    71  
    72  var xxx_messageInfo_ReplicaSet proto.InternalMessageInfo
    73  
    74  func (m *ReplicaSetSpec) Reset()      { *m = ReplicaSetSpec{} }
    75  func (*ReplicaSetSpec) ProtoMessage() {}
    76  func (*ReplicaSetSpec) Descriptor() ([]byte, []int) {
    77  	return fileDescriptor_c0d8f6d73eb5bf83, []int{1}
    78  }
    79  func (m *ReplicaSetSpec) XXX_Unmarshal(b []byte) error {
    80  	return m.Unmarshal(b)
    81  }
    82  func (m *ReplicaSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    83  	b = b[:cap(b)]
    84  	n, err := m.MarshalToSizedBuffer(b)
    85  	if err != nil {
    86  		return nil, err
    87  	}
    88  	return b[:n], nil
    89  }
    90  func (m *ReplicaSetSpec) XXX_Merge(src proto.Message) {
    91  	xxx_messageInfo_ReplicaSetSpec.Merge(m, src)
    92  }
    93  func (m *ReplicaSetSpec) XXX_Size() int {
    94  	return m.Size()
    95  }
    96  func (m *ReplicaSetSpec) XXX_DiscardUnknown() {
    97  	xxx_messageInfo_ReplicaSetSpec.DiscardUnknown(m)
    98  }
    99  
   100  var xxx_messageInfo_ReplicaSetSpec proto.InternalMessageInfo
   101  
   102  func (m *ReplicaSetStatus) Reset()      { *m = ReplicaSetStatus{} }
   103  func (*ReplicaSetStatus) ProtoMessage() {}
   104  func (*ReplicaSetStatus) Descriptor() ([]byte, []int) {
   105  	return fileDescriptor_c0d8f6d73eb5bf83, []int{2}
   106  }
   107  func (m *ReplicaSetStatus) XXX_Unmarshal(b []byte) error {
   108  	return m.Unmarshal(b)
   109  }
   110  func (m *ReplicaSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   111  	b = b[:cap(b)]
   112  	n, err := m.MarshalToSizedBuffer(b)
   113  	if err != nil {
   114  		return nil, err
   115  	}
   116  	return b[:n], nil
   117  }
   118  func (m *ReplicaSetStatus) XXX_Merge(src proto.Message) {
   119  	xxx_messageInfo_ReplicaSetStatus.Merge(m, src)
   120  }
   121  func (m *ReplicaSetStatus) XXX_Size() int {
   122  	return m.Size()
   123  }
   124  func (m *ReplicaSetStatus) XXX_DiscardUnknown() {
   125  	xxx_messageInfo_ReplicaSetStatus.DiscardUnknown(m)
   126  }
   127  
   128  var xxx_messageInfo_ReplicaSetStatus proto.InternalMessageInfo
   129  
   130  func init() {
   131  	proto.RegisterType((*ReplicaSet)(nil), "k8s.io.apiserver.pkg.apis.example2.v1.ReplicaSet")
   132  	proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.apiserver.pkg.apis.example2.v1.ReplicaSetSpec")
   133  	proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.apiserver.pkg.apis.example2.v1.ReplicaSetStatus")
   134  }
   135  
   136  func init() {
   137  	proto.RegisterFile("k8s.io/apiserver/pkg/apis/example2/v1/generated.proto", fileDescriptor_c0d8f6d73eb5bf83)
   138  }
   139  
   140  var fileDescriptor_c0d8f6d73eb5bf83 = []byte{
   141  	// 388 bytes of a gzipped FileDescriptorProto
   142  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xc1, 0x6a, 0xe2, 0x40,
   143  	0x18, 0xc7, 0x13, 0xd7, 0x15, 0x99, 0x15, 0x91, 0x9c, 0xc4, 0xc3, 0xb8, 0x08, 0x82, 0x87, 0xdd,
   144  	0x99, 0x55, 0xd6, 0xdd, 0xd2, 0x53, 0xc9, 0xb5, 0x94, 0x42, 0x3c, 0x14, 0x7a, 0x69, 0xc7, 0xf8,
   145  	0x35, 0xa6, 0x1a, 0x33, 0x64, 0x26, 0xa1, 0xbd, 0xf5, 0x11, 0xfa, 0x18, 0x7d, 0x14, 0x8f, 0x1e,
   146  	0x3d, 0x49, 0x4d, 0x5f, 0xa4, 0x38, 0x49, 0x13, 0xaa, 0x96, 0xda, 0x5b, 0xfe, 0x93, 0xf9, 0xfd,
   147  	0xbe, 0x3f, 0x1f, 0x83, 0xfa, 0x93, 0x23, 0x41, 0x5c, 0x9f, 0x32, 0xee, 0x0a, 0x08, 0x22, 0x08,
   148  	0x28, 0x9f, 0x38, 0x2a, 0x51, 0xb8, 0x63, 0x1e, 0x9f, 0x42, 0x8f, 0x46, 0x5d, 0xea, 0xc0, 0x0c,
   149  	0x02, 0x26, 0x61, 0x44, 0x78, 0xe0, 0x4b, 0xdf, 0x68, 0x27, 0x18, 0xc9, 0x30, 0xc2, 0x27, 0x8e,
   150  	0x4a, 0xe4, 0x0d, 0x23, 0x51, 0xb7, 0xf1, 0xdb, 0x71, 0xe5, 0x38, 0x1c, 0x12, 0xdb, 0xf7, 0xa8,
   151  	0xe3, 0x3b, 0x3e, 0x55, 0xf4, 0x30, 0xbc, 0x51, 0x49, 0x05, 0xf5, 0x95, 0x58, 0x1b, 0x7f, 0xf3,
   152  	0x32, 0x1e, 0xb3, 0xc7, 0xee, 0x0c, 0x82, 0xfb, 0xbc, 0x8f, 0x07, 0x92, 0xed, 0xe9, 0xd2, 0xa0,
   153  	0x1f, 0x51, 0x41, 0x38, 0x93, 0xae, 0x07, 0x3b, 0xc0, 0xbf, 0xcf, 0x00, 0x61, 0x8f, 0xc1, 0x63,
   154  	0xdb, 0x5c, 0xeb, 0xa9, 0x80, 0x90, 0x05, 0x7c, 0xea, 0xda, 0x6c, 0x00, 0xd2, 0xb8, 0x46, 0xe5,
   155  	0x4d, 0xa5, 0x11, 0x93, 0xac, 0xae, 0xff, 0xd4, 0x3b, 0x3f, 0x7a, 0x7f, 0x48, 0xbe, 0x96, 0xcc,
   156  	0x9c, 0x6f, 0x66, 0x73, 0x9b, 0x44, 0x5d, 0x72, 0x3e, 0xbc, 0x05, 0x5b, 0x9e, 0x81, 0x64, 0xa6,
   157  	0x31, 0x5f, 0x35, 0xb5, 0x78, 0xd5, 0x44, 0xf9, 0x99, 0x95, 0x59, 0x8d, 0x0b, 0x54, 0x14, 0x1c,
   158  	0xec, 0x7a, 0x41, 0xd9, 0xfb, 0xe4, 0xa0, 0xa5, 0x93, 0xbc, 0xe2, 0x80, 0x83, 0x6d, 0x56, 0xd2,
   159  	0x11, 0xc5, 0x4d, 0xb2, 0x94, 0xd0, 0xb8, 0x42, 0x25, 0x21, 0x99, 0x0c, 0x45, 0xfd, 0x9b, 0x52,
   160  	0xff, 0xff, 0xba, 0x5a, 0xe1, 0x66, 0x35, 0x95, 0x97, 0x92, 0x6c, 0xa5, 0xda, 0xd6, 0x31, 0xaa,
   161  	0xbe, 0xaf, 0x61, 0x74, 0x50, 0x39, 0x48, 0x4e, 0x84, 0xda, 0xd6, 0x77, 0xb3, 0x12, 0xaf, 0x9a,
   162  	0xe5, 0xf4, 0x96, 0xb0, 0xb2, 0xbf, 0xad, 0x13, 0x54, 0xdb, 0x9e, 0x63, 0xfc, 0xda, 0xa1, 0x6b,
   163  	0xe9, 0xe4, 0x3d, 0x06, 0xf3, 0x74, 0xbe, 0xc6, 0xda, 0x62, 0x8d, 0xb5, 0xe5, 0x1a, 0x6b, 0x0f,
   164  	0x31, 0xd6, 0xe7, 0x31, 0xd6, 0x17, 0x31, 0xd6, 0x97, 0x31, 0xd6, 0x9f, 0x63, 0xac, 0x3f, 0xbe,
   165  	0x60, 0xed, 0xb2, 0x7d, 0xd0, 0xd3, 0x7f, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xf4, 0xd7, 0x7c, 0xa3,
   166  	0x22, 0x03, 0x00, 0x00,
   167  }
   168  
   169  func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
   170  	size := m.Size()
   171  	dAtA = make([]byte, size)
   172  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   173  	if err != nil {
   174  		return nil, err
   175  	}
   176  	return dAtA[:n], nil
   177  }
   178  
   179  func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
   180  	size := m.Size()
   181  	return m.MarshalToSizedBuffer(dAtA[:size])
   182  }
   183  
   184  func (m *ReplicaSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   185  	i := len(dAtA)
   186  	_ = i
   187  	var l int
   188  	_ = l
   189  	{
   190  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
   191  		if err != nil {
   192  			return 0, err
   193  		}
   194  		i -= size
   195  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   196  	}
   197  	i--
   198  	dAtA[i] = 0x1a
   199  	{
   200  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
   201  		if err != nil {
   202  			return 0, err
   203  		}
   204  		i -= size
   205  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   206  	}
   207  	i--
   208  	dAtA[i] = 0x12
   209  	{
   210  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   211  		if err != nil {
   212  			return 0, err
   213  		}
   214  		i -= size
   215  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   216  	}
   217  	i--
   218  	dAtA[i] = 0xa
   219  	return len(dAtA) - i, nil
   220  }
   221  
   222  func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
   223  	size := m.Size()
   224  	dAtA = make([]byte, size)
   225  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   226  	if err != nil {
   227  		return nil, err
   228  	}
   229  	return dAtA[:n], nil
   230  }
   231  
   232  func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
   233  	size := m.Size()
   234  	return m.MarshalToSizedBuffer(dAtA[:size])
   235  }
   236  
   237  func (m *ReplicaSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   238  	i := len(dAtA)
   239  	_ = i
   240  	var l int
   241  	_ = l
   242  	if m.Replicas != nil {
   243  		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
   244  		i--
   245  		dAtA[i] = 0x8
   246  	}
   247  	return len(dAtA) - i, nil
   248  }
   249  
   250  func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
   251  	size := m.Size()
   252  	dAtA = make([]byte, size)
   253  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   254  	if err != nil {
   255  		return nil, err
   256  	}
   257  	return dAtA[:n], nil
   258  }
   259  
   260  func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
   261  	size := m.Size()
   262  	return m.MarshalToSizedBuffer(dAtA[:size])
   263  }
   264  
   265  func (m *ReplicaSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   266  	i := len(dAtA)
   267  	_ = i
   268  	var l int
   269  	_ = l
   270  	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
   271  	i--
   272  	dAtA[i] = 0x8
   273  	return len(dAtA) - i, nil
   274  }
   275  
   276  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
   277  	offset -= sovGenerated(v)
   278  	base := offset
   279  	for v >= 1<<7 {
   280  		dAtA[offset] = uint8(v&0x7f | 0x80)
   281  		v >>= 7
   282  		offset++
   283  	}
   284  	dAtA[offset] = uint8(v)
   285  	return base
   286  }
   287  func (m *ReplicaSet) Size() (n int) {
   288  	if m == nil {
   289  		return 0
   290  	}
   291  	var l int
   292  	_ = l
   293  	l = m.ObjectMeta.Size()
   294  	n += 1 + l + sovGenerated(uint64(l))
   295  	l = m.Spec.Size()
   296  	n += 1 + l + sovGenerated(uint64(l))
   297  	l = m.Status.Size()
   298  	n += 1 + l + sovGenerated(uint64(l))
   299  	return n
   300  }
   301  
   302  func (m *ReplicaSetSpec) Size() (n int) {
   303  	if m == nil {
   304  		return 0
   305  	}
   306  	var l int
   307  	_ = l
   308  	if m.Replicas != nil {
   309  		n += 1 + sovGenerated(uint64(*m.Replicas))
   310  	}
   311  	return n
   312  }
   313  
   314  func (m *ReplicaSetStatus) Size() (n int) {
   315  	if m == nil {
   316  		return 0
   317  	}
   318  	var l int
   319  	_ = l
   320  	n += 1 + sovGenerated(uint64(m.Replicas))
   321  	return n
   322  }
   323  
   324  func sovGenerated(x uint64) (n int) {
   325  	return (math_bits.Len64(x|1) + 6) / 7
   326  }
   327  func sozGenerated(x uint64) (n int) {
   328  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   329  }
   330  func (this *ReplicaSet) String() string {
   331  	if this == nil {
   332  		return "nil"
   333  	}
   334  	s := strings.Join([]string{`&ReplicaSet{`,
   335  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
   336  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
   337  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
   338  		`}`,
   339  	}, "")
   340  	return s
   341  }
   342  func (this *ReplicaSetSpec) String() string {
   343  	if this == nil {
   344  		return "nil"
   345  	}
   346  	s := strings.Join([]string{`&ReplicaSetSpec{`,
   347  		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
   348  		`}`,
   349  	}, "")
   350  	return s
   351  }
   352  func (this *ReplicaSetStatus) String() string {
   353  	if this == nil {
   354  		return "nil"
   355  	}
   356  	s := strings.Join([]string{`&ReplicaSetStatus{`,
   357  		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
   358  		`}`,
   359  	}, "")
   360  	return s
   361  }
   362  func valueToStringGenerated(v interface{}) string {
   363  	rv := reflect.ValueOf(v)
   364  	if rv.IsNil() {
   365  		return "nil"
   366  	}
   367  	pv := reflect.Indirect(rv).Interface()
   368  	return fmt.Sprintf("*%v", pv)
   369  }
   370  func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
   371  	l := len(dAtA)
   372  	iNdEx := 0
   373  	for iNdEx < l {
   374  		preIndex := iNdEx
   375  		var wire uint64
   376  		for shift := uint(0); ; shift += 7 {
   377  			if shift >= 64 {
   378  				return ErrIntOverflowGenerated
   379  			}
   380  			if iNdEx >= l {
   381  				return io.ErrUnexpectedEOF
   382  			}
   383  			b := dAtA[iNdEx]
   384  			iNdEx++
   385  			wire |= uint64(b&0x7F) << shift
   386  			if b < 0x80 {
   387  				break
   388  			}
   389  		}
   390  		fieldNum := int32(wire >> 3)
   391  		wireType := int(wire & 0x7)
   392  		if wireType == 4 {
   393  			return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
   394  		}
   395  		if fieldNum <= 0 {
   396  			return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
   397  		}
   398  		switch fieldNum {
   399  		case 1:
   400  			if wireType != 2 {
   401  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
   402  			}
   403  			var msglen int
   404  			for shift := uint(0); ; shift += 7 {
   405  				if shift >= 64 {
   406  					return ErrIntOverflowGenerated
   407  				}
   408  				if iNdEx >= l {
   409  					return io.ErrUnexpectedEOF
   410  				}
   411  				b := dAtA[iNdEx]
   412  				iNdEx++
   413  				msglen |= int(b&0x7F) << shift
   414  				if b < 0x80 {
   415  					break
   416  				}
   417  			}
   418  			if msglen < 0 {
   419  				return ErrInvalidLengthGenerated
   420  			}
   421  			postIndex := iNdEx + msglen
   422  			if postIndex < 0 {
   423  				return ErrInvalidLengthGenerated
   424  			}
   425  			if postIndex > l {
   426  				return io.ErrUnexpectedEOF
   427  			}
   428  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   429  				return err
   430  			}
   431  			iNdEx = postIndex
   432  		case 2:
   433  			if wireType != 2 {
   434  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
   435  			}
   436  			var msglen int
   437  			for shift := uint(0); ; shift += 7 {
   438  				if shift >= 64 {
   439  					return ErrIntOverflowGenerated
   440  				}
   441  				if iNdEx >= l {
   442  					return io.ErrUnexpectedEOF
   443  				}
   444  				b := dAtA[iNdEx]
   445  				iNdEx++
   446  				msglen |= int(b&0x7F) << shift
   447  				if b < 0x80 {
   448  					break
   449  				}
   450  			}
   451  			if msglen < 0 {
   452  				return ErrInvalidLengthGenerated
   453  			}
   454  			postIndex := iNdEx + msglen
   455  			if postIndex < 0 {
   456  				return ErrInvalidLengthGenerated
   457  			}
   458  			if postIndex > l {
   459  				return io.ErrUnexpectedEOF
   460  			}
   461  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   462  				return err
   463  			}
   464  			iNdEx = postIndex
   465  		case 3:
   466  			if wireType != 2 {
   467  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
   468  			}
   469  			var msglen int
   470  			for shift := uint(0); ; shift += 7 {
   471  				if shift >= 64 {
   472  					return ErrIntOverflowGenerated
   473  				}
   474  				if iNdEx >= l {
   475  					return io.ErrUnexpectedEOF
   476  				}
   477  				b := dAtA[iNdEx]
   478  				iNdEx++
   479  				msglen |= int(b&0x7F) << shift
   480  				if b < 0x80 {
   481  					break
   482  				}
   483  			}
   484  			if msglen < 0 {
   485  				return ErrInvalidLengthGenerated
   486  			}
   487  			postIndex := iNdEx + msglen
   488  			if postIndex < 0 {
   489  				return ErrInvalidLengthGenerated
   490  			}
   491  			if postIndex > l {
   492  				return io.ErrUnexpectedEOF
   493  			}
   494  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   495  				return err
   496  			}
   497  			iNdEx = postIndex
   498  		default:
   499  			iNdEx = preIndex
   500  			skippy, err := skipGenerated(dAtA[iNdEx:])
   501  			if err != nil {
   502  				return err
   503  			}
   504  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   505  				return ErrInvalidLengthGenerated
   506  			}
   507  			if (iNdEx + skippy) > l {
   508  				return io.ErrUnexpectedEOF
   509  			}
   510  			iNdEx += skippy
   511  		}
   512  	}
   513  
   514  	if iNdEx > l {
   515  		return io.ErrUnexpectedEOF
   516  	}
   517  	return nil
   518  }
   519  func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
   520  	l := len(dAtA)
   521  	iNdEx := 0
   522  	for iNdEx < l {
   523  		preIndex := iNdEx
   524  		var wire uint64
   525  		for shift := uint(0); ; shift += 7 {
   526  			if shift >= 64 {
   527  				return ErrIntOverflowGenerated
   528  			}
   529  			if iNdEx >= l {
   530  				return io.ErrUnexpectedEOF
   531  			}
   532  			b := dAtA[iNdEx]
   533  			iNdEx++
   534  			wire |= uint64(b&0x7F) << shift
   535  			if b < 0x80 {
   536  				break
   537  			}
   538  		}
   539  		fieldNum := int32(wire >> 3)
   540  		wireType := int(wire & 0x7)
   541  		if wireType == 4 {
   542  			return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
   543  		}
   544  		if fieldNum <= 0 {
   545  			return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
   546  		}
   547  		switch fieldNum {
   548  		case 1:
   549  			if wireType != 0 {
   550  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
   551  			}
   552  			var v int32
   553  			for shift := uint(0); ; shift += 7 {
   554  				if shift >= 64 {
   555  					return ErrIntOverflowGenerated
   556  				}
   557  				if iNdEx >= l {
   558  					return io.ErrUnexpectedEOF
   559  				}
   560  				b := dAtA[iNdEx]
   561  				iNdEx++
   562  				v |= int32(b&0x7F) << shift
   563  				if b < 0x80 {
   564  					break
   565  				}
   566  			}
   567  			m.Replicas = &v
   568  		default:
   569  			iNdEx = preIndex
   570  			skippy, err := skipGenerated(dAtA[iNdEx:])
   571  			if err != nil {
   572  				return err
   573  			}
   574  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   575  				return ErrInvalidLengthGenerated
   576  			}
   577  			if (iNdEx + skippy) > l {
   578  				return io.ErrUnexpectedEOF
   579  			}
   580  			iNdEx += skippy
   581  		}
   582  	}
   583  
   584  	if iNdEx > l {
   585  		return io.ErrUnexpectedEOF
   586  	}
   587  	return nil
   588  }
   589  func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
   590  	l := len(dAtA)
   591  	iNdEx := 0
   592  	for iNdEx < l {
   593  		preIndex := iNdEx
   594  		var wire uint64
   595  		for shift := uint(0); ; shift += 7 {
   596  			if shift >= 64 {
   597  				return ErrIntOverflowGenerated
   598  			}
   599  			if iNdEx >= l {
   600  				return io.ErrUnexpectedEOF
   601  			}
   602  			b := dAtA[iNdEx]
   603  			iNdEx++
   604  			wire |= uint64(b&0x7F) << shift
   605  			if b < 0x80 {
   606  				break
   607  			}
   608  		}
   609  		fieldNum := int32(wire >> 3)
   610  		wireType := int(wire & 0x7)
   611  		if wireType == 4 {
   612  			return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
   613  		}
   614  		if fieldNum <= 0 {
   615  			return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
   616  		}
   617  		switch fieldNum {
   618  		case 1:
   619  			if wireType != 0 {
   620  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
   621  			}
   622  			m.Replicas = 0
   623  			for shift := uint(0); ; shift += 7 {
   624  				if shift >= 64 {
   625  					return ErrIntOverflowGenerated
   626  				}
   627  				if iNdEx >= l {
   628  					return io.ErrUnexpectedEOF
   629  				}
   630  				b := dAtA[iNdEx]
   631  				iNdEx++
   632  				m.Replicas |= int32(b&0x7F) << shift
   633  				if b < 0x80 {
   634  					break
   635  				}
   636  			}
   637  		default:
   638  			iNdEx = preIndex
   639  			skippy, err := skipGenerated(dAtA[iNdEx:])
   640  			if err != nil {
   641  				return err
   642  			}
   643  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   644  				return ErrInvalidLengthGenerated
   645  			}
   646  			if (iNdEx + skippy) > l {
   647  				return io.ErrUnexpectedEOF
   648  			}
   649  			iNdEx += skippy
   650  		}
   651  	}
   652  
   653  	if iNdEx > l {
   654  		return io.ErrUnexpectedEOF
   655  	}
   656  	return nil
   657  }
   658  func skipGenerated(dAtA []byte) (n int, err error) {
   659  	l := len(dAtA)
   660  	iNdEx := 0
   661  	depth := 0
   662  	for iNdEx < l {
   663  		var wire uint64
   664  		for shift := uint(0); ; shift += 7 {
   665  			if shift >= 64 {
   666  				return 0, ErrIntOverflowGenerated
   667  			}
   668  			if iNdEx >= l {
   669  				return 0, io.ErrUnexpectedEOF
   670  			}
   671  			b := dAtA[iNdEx]
   672  			iNdEx++
   673  			wire |= (uint64(b) & 0x7F) << shift
   674  			if b < 0x80 {
   675  				break
   676  			}
   677  		}
   678  		wireType := int(wire & 0x7)
   679  		switch wireType {
   680  		case 0:
   681  			for shift := uint(0); ; shift += 7 {
   682  				if shift >= 64 {
   683  					return 0, ErrIntOverflowGenerated
   684  				}
   685  				if iNdEx >= l {
   686  					return 0, io.ErrUnexpectedEOF
   687  				}
   688  				iNdEx++
   689  				if dAtA[iNdEx-1] < 0x80 {
   690  					break
   691  				}
   692  			}
   693  		case 1:
   694  			iNdEx += 8
   695  		case 2:
   696  			var length int
   697  			for shift := uint(0); ; shift += 7 {
   698  				if shift >= 64 {
   699  					return 0, ErrIntOverflowGenerated
   700  				}
   701  				if iNdEx >= l {
   702  					return 0, io.ErrUnexpectedEOF
   703  				}
   704  				b := dAtA[iNdEx]
   705  				iNdEx++
   706  				length |= (int(b) & 0x7F) << shift
   707  				if b < 0x80 {
   708  					break
   709  				}
   710  			}
   711  			if length < 0 {
   712  				return 0, ErrInvalidLengthGenerated
   713  			}
   714  			iNdEx += length
   715  		case 3:
   716  			depth++
   717  		case 4:
   718  			if depth == 0 {
   719  				return 0, ErrUnexpectedEndOfGroupGenerated
   720  			}
   721  			depth--
   722  		case 5:
   723  			iNdEx += 4
   724  		default:
   725  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
   726  		}
   727  		if iNdEx < 0 {
   728  			return 0, ErrInvalidLengthGenerated
   729  		}
   730  		if depth == 0 {
   731  			return iNdEx, nil
   732  		}
   733  	}
   734  	return 0, io.ErrUnexpectedEOF
   735  }
   736  
   737  var (
   738  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
   739  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
   740  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
   741  )