Source file src/k8s.io/apimachinery/pkg/util/intstr/generated.pb.go

Documentation: k8s.io/apimachinery/pkg/util/intstr

     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/apimachinery/pkg/util/intstr/generated.proto
    19  
    20  package intstr
    21  
    22  import (
    23  	fmt "fmt"
    24  
    25  	io "io"
    26  	math "math"
    27  	math_bits "math/bits"
    28  
    29  	proto "github.com/gogo/protobuf/proto"
    30  )
    31  
    32  // Reference imports to suppress errors if they are not otherwise used.
    33  var _ = proto.Marshal
    34  var _ = fmt.Errorf
    35  var _ = math.Inf
    36  
    37  // This is a compile-time assertion to ensure that this generated file
    38  // is compatible with the proto package it is being compiled against.
    39  // A compilation error at this line likely means your copy of the
    40  // proto package needs to be updated.
    41  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    42  
    43  func (m *IntOrString) Reset()      { *m = IntOrString{} }
    44  func (*IntOrString) ProtoMessage() {}
    45  func (*IntOrString) Descriptor() ([]byte, []int) {
    46  	return fileDescriptor_771bacc35a5ec189, []int{0}
    47  }
    48  func (m *IntOrString) XXX_Unmarshal(b []byte) error {
    49  	return m.Unmarshal(b)
    50  }
    51  func (m *IntOrString) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    52  	b = b[:cap(b)]
    53  	n, err := m.MarshalToSizedBuffer(b)
    54  	if err != nil {
    55  		return nil, err
    56  	}
    57  	return b[:n], nil
    58  }
    59  func (m *IntOrString) XXX_Merge(src proto.Message) {
    60  	xxx_messageInfo_IntOrString.Merge(m, src)
    61  }
    62  func (m *IntOrString) XXX_Size() int {
    63  	return m.Size()
    64  }
    65  func (m *IntOrString) XXX_DiscardUnknown() {
    66  	xxx_messageInfo_IntOrString.DiscardUnknown(m)
    67  }
    68  
    69  var xxx_messageInfo_IntOrString proto.InternalMessageInfo
    70  
    71  func init() {
    72  	proto.RegisterType((*IntOrString)(nil), "k8s.io.apimachinery.pkg.util.intstr.IntOrString")
    73  }
    74  
    75  func init() {
    76  	proto.RegisterFile("k8s.io/apimachinery/pkg/util/intstr/generated.proto", fileDescriptor_771bacc35a5ec189)
    77  }
    78  
    79  var fileDescriptor_771bacc35a5ec189 = []byte{
    80  	// 277 bytes of a gzipped FileDescriptorProto
    81  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0xce, 0xb6, 0x28, 0xd6,
    82  	0xcb, 0xcc, 0xd7, 0x4f, 0x2c, 0xc8, 0xcc, 0x4d, 0x4c, 0xce, 0xc8, 0xcc, 0x4b, 0x2d, 0xaa, 0xd4,
    83  	0x2f, 0xc8, 0x4e, 0xd7, 0x2f, 0x2d, 0xc9, 0xcc, 0xd1, 0xcf, 0xcc, 0x2b, 0x29, 0x2e, 0x29, 0xd2,
    84  	0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0x4a, 0x2c, 0x49, 0x4d, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
    85  	0x52, 0x86, 0x68, 0xd2, 0x43, 0xd6, 0xa4, 0x57, 0x90, 0x9d, 0xae, 0x07, 0xd2, 0xa4, 0x07, 0xd1,
    86  	0x24, 0xa5, 0x9b, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f, 0x9e, 0x9f,
    87  	0x9e, 0xaf, 0x0f, 0xd6, 0x9b, 0x54, 0x9a, 0x06, 0xe6, 0x81, 0x39, 0x60, 0x16, 0xc4, 0x4c, 0xa5,
    88  	0x89, 0x8c, 0x5c, 0xdc, 0x9e, 0x79, 0x25, 0xfe, 0x45, 0xc1, 0x25, 0x45, 0x99, 0x79, 0xe9, 0x42,
    89  	0x1a, 0x5c, 0x2c, 0x25, 0x95, 0x05, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x4e, 0x22, 0x27,
    90  	0xee, 0xc9, 0x33, 0x3c, 0xba, 0x27, 0xcf, 0x12, 0x52, 0x59, 0x90, 0xfa, 0x0b, 0x4a, 0x07, 0x81,
    91  	0x55, 0x08, 0xa9, 0x71, 0xb1, 0x65, 0xe6, 0x95, 0x84, 0x25, 0xe6, 0x48, 0x30, 0x29, 0x30, 0x6a,
    92  	0xb0, 0x3a, 0xf1, 0x41, 0xd5, 0xb2, 0x79, 0x82, 0x45, 0x83, 0xa0, 0xb2, 0x20, 0x75, 0xc5, 0x25,
    93  	0x45, 0x20, 0x75, 0xcc, 0x0a, 0x8c, 0x1a, 0x9c, 0x08, 0x75, 0xc1, 0x60, 0xd1, 0x20, 0xa8, 0xac,
    94  	0x15, 0xc7, 0x8c, 0x05, 0xf2, 0x0c, 0x0d, 0x77, 0x14, 0x18, 0x9c, 0x3c, 0x4f, 0x3c, 0x94, 0x63,
    95  	0xb8, 0xf0, 0x50, 0x8e, 0xe1, 0xc6, 0x43, 0x39, 0x86, 0x86, 0x47, 0x72, 0x8c, 0x27, 0x1e, 0xc9,
    96  	0x31, 0x5e, 0x78, 0x24, 0xc7, 0x78, 0xe3, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e,
    97  	0xcb, 0x31, 0x44, 0x29, 0x13, 0x11, 0x84, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x63, 0xa1, 0x0b,
    98  	0x1e, 0x68, 0x01, 0x00, 0x00,
    99  }
   100  
   101  func (m *IntOrString) Marshal() (dAtA []byte, err error) {
   102  	size := m.Size()
   103  	dAtA = make([]byte, size)
   104  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   105  	if err != nil {
   106  		return nil, err
   107  	}
   108  	return dAtA[:n], nil
   109  }
   110  
   111  func (m *IntOrString) MarshalTo(dAtA []byte) (int, error) {
   112  	size := m.Size()
   113  	return m.MarshalToSizedBuffer(dAtA[:size])
   114  }
   115  
   116  func (m *IntOrString) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   117  	i := len(dAtA)
   118  	_ = i
   119  	var l int
   120  	_ = l
   121  	i -= len(m.StrVal)
   122  	copy(dAtA[i:], m.StrVal)
   123  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StrVal)))
   124  	i--
   125  	dAtA[i] = 0x1a
   126  	i = encodeVarintGenerated(dAtA, i, uint64(m.IntVal))
   127  	i--
   128  	dAtA[i] = 0x10
   129  	i = encodeVarintGenerated(dAtA, i, uint64(m.Type))
   130  	i--
   131  	dAtA[i] = 0x8
   132  	return len(dAtA) - i, nil
   133  }
   134  
   135  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
   136  	offset -= sovGenerated(v)
   137  	base := offset
   138  	for v >= 1<<7 {
   139  		dAtA[offset] = uint8(v&0x7f | 0x80)
   140  		v >>= 7
   141  		offset++
   142  	}
   143  	dAtA[offset] = uint8(v)
   144  	return base
   145  }
   146  func (m *IntOrString) Size() (n int) {
   147  	if m == nil {
   148  		return 0
   149  	}
   150  	var l int
   151  	_ = l
   152  	n += 1 + sovGenerated(uint64(m.Type))
   153  	n += 1 + sovGenerated(uint64(m.IntVal))
   154  	l = len(m.StrVal)
   155  	n += 1 + l + sovGenerated(uint64(l))
   156  	return n
   157  }
   158  
   159  func sovGenerated(x uint64) (n int) {
   160  	return (math_bits.Len64(x|1) + 6) / 7
   161  }
   162  func sozGenerated(x uint64) (n int) {
   163  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   164  }
   165  func (m *IntOrString) Unmarshal(dAtA []byte) error {
   166  	l := len(dAtA)
   167  	iNdEx := 0
   168  	for iNdEx < l {
   169  		preIndex := iNdEx
   170  		var wire uint64
   171  		for shift := uint(0); ; shift += 7 {
   172  			if shift >= 64 {
   173  				return ErrIntOverflowGenerated
   174  			}
   175  			if iNdEx >= l {
   176  				return io.ErrUnexpectedEOF
   177  			}
   178  			b := dAtA[iNdEx]
   179  			iNdEx++
   180  			wire |= uint64(b&0x7F) << shift
   181  			if b < 0x80 {
   182  				break
   183  			}
   184  		}
   185  		fieldNum := int32(wire >> 3)
   186  		wireType := int(wire & 0x7)
   187  		if wireType == 4 {
   188  			return fmt.Errorf("proto: IntOrString: wiretype end group for non-group")
   189  		}
   190  		if fieldNum <= 0 {
   191  			return fmt.Errorf("proto: IntOrString: illegal tag %d (wire type %d)", fieldNum, wire)
   192  		}
   193  		switch fieldNum {
   194  		case 1:
   195  			if wireType != 0 {
   196  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
   197  			}
   198  			m.Type = 0
   199  			for shift := uint(0); ; shift += 7 {
   200  				if shift >= 64 {
   201  					return ErrIntOverflowGenerated
   202  				}
   203  				if iNdEx >= l {
   204  					return io.ErrUnexpectedEOF
   205  				}
   206  				b := dAtA[iNdEx]
   207  				iNdEx++
   208  				m.Type |= Type(b&0x7F) << shift
   209  				if b < 0x80 {
   210  					break
   211  				}
   212  			}
   213  		case 2:
   214  			if wireType != 0 {
   215  				return fmt.Errorf("proto: wrong wireType = %d for field IntVal", wireType)
   216  			}
   217  			m.IntVal = 0
   218  			for shift := uint(0); ; shift += 7 {
   219  				if shift >= 64 {
   220  					return ErrIntOverflowGenerated
   221  				}
   222  				if iNdEx >= l {
   223  					return io.ErrUnexpectedEOF
   224  				}
   225  				b := dAtA[iNdEx]
   226  				iNdEx++
   227  				m.IntVal |= int32(b&0x7F) << shift
   228  				if b < 0x80 {
   229  					break
   230  				}
   231  			}
   232  		case 3:
   233  			if wireType != 2 {
   234  				return fmt.Errorf("proto: wrong wireType = %d for field StrVal", wireType)
   235  			}
   236  			var stringLen uint64
   237  			for shift := uint(0); ; shift += 7 {
   238  				if shift >= 64 {
   239  					return ErrIntOverflowGenerated
   240  				}
   241  				if iNdEx >= l {
   242  					return io.ErrUnexpectedEOF
   243  				}
   244  				b := dAtA[iNdEx]
   245  				iNdEx++
   246  				stringLen |= uint64(b&0x7F) << shift
   247  				if b < 0x80 {
   248  					break
   249  				}
   250  			}
   251  			intStringLen := int(stringLen)
   252  			if intStringLen < 0 {
   253  				return ErrInvalidLengthGenerated
   254  			}
   255  			postIndex := iNdEx + intStringLen
   256  			if postIndex < 0 {
   257  				return ErrInvalidLengthGenerated
   258  			}
   259  			if postIndex > l {
   260  				return io.ErrUnexpectedEOF
   261  			}
   262  			m.StrVal = string(dAtA[iNdEx:postIndex])
   263  			iNdEx = postIndex
   264  		default:
   265  			iNdEx = preIndex
   266  			skippy, err := skipGenerated(dAtA[iNdEx:])
   267  			if err != nil {
   268  				return err
   269  			}
   270  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   271  				return ErrInvalidLengthGenerated
   272  			}
   273  			if (iNdEx + skippy) > l {
   274  				return io.ErrUnexpectedEOF
   275  			}
   276  			iNdEx += skippy
   277  		}
   278  	}
   279  
   280  	if iNdEx > l {
   281  		return io.ErrUnexpectedEOF
   282  	}
   283  	return nil
   284  }
   285  func skipGenerated(dAtA []byte) (n int, err error) {
   286  	l := len(dAtA)
   287  	iNdEx := 0
   288  	depth := 0
   289  	for iNdEx < l {
   290  		var wire uint64
   291  		for shift := uint(0); ; shift += 7 {
   292  			if shift >= 64 {
   293  				return 0, ErrIntOverflowGenerated
   294  			}
   295  			if iNdEx >= l {
   296  				return 0, io.ErrUnexpectedEOF
   297  			}
   298  			b := dAtA[iNdEx]
   299  			iNdEx++
   300  			wire |= (uint64(b) & 0x7F) << shift
   301  			if b < 0x80 {
   302  				break
   303  			}
   304  		}
   305  		wireType := int(wire & 0x7)
   306  		switch wireType {
   307  		case 0:
   308  			for shift := uint(0); ; shift += 7 {
   309  				if shift >= 64 {
   310  					return 0, ErrIntOverflowGenerated
   311  				}
   312  				if iNdEx >= l {
   313  					return 0, io.ErrUnexpectedEOF
   314  				}
   315  				iNdEx++
   316  				if dAtA[iNdEx-1] < 0x80 {
   317  					break
   318  				}
   319  			}
   320  		case 1:
   321  			iNdEx += 8
   322  		case 2:
   323  			var length int
   324  			for shift := uint(0); ; shift += 7 {
   325  				if shift >= 64 {
   326  					return 0, ErrIntOverflowGenerated
   327  				}
   328  				if iNdEx >= l {
   329  					return 0, io.ErrUnexpectedEOF
   330  				}
   331  				b := dAtA[iNdEx]
   332  				iNdEx++
   333  				length |= (int(b) & 0x7F) << shift
   334  				if b < 0x80 {
   335  					break
   336  				}
   337  			}
   338  			if length < 0 {
   339  				return 0, ErrInvalidLengthGenerated
   340  			}
   341  			iNdEx += length
   342  		case 3:
   343  			depth++
   344  		case 4:
   345  			if depth == 0 {
   346  				return 0, ErrUnexpectedEndOfGroupGenerated
   347  			}
   348  			depth--
   349  		case 5:
   350  			iNdEx += 4
   351  		default:
   352  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
   353  		}
   354  		if iNdEx < 0 {
   355  			return 0, ErrInvalidLengthGenerated
   356  		}
   357  		if depth == 0 {
   358  			return iNdEx, nil
   359  		}
   360  	}
   361  	return 0, io.ErrUnexpectedEOF
   362  }
   363  
   364  var (
   365  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
   366  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
   367  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
   368  )
   369  

View as plain text