cmd/bpa-operator/vendor/k8s.io/apimachinery/pkg/util/intstr/generated.pb.go

   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/kubernetes/vendor/k8s.io/apimachinery/pkg/util/intstr/generated.proto
  19
  20 /*
  21         Package intstr is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/util/intstr/generated.proto
  25
  26         It has these top-level messages:
  27                 IntOrString
  28 */
  29 package intstr
  30
  31 import proto "github.com/gogo/protobuf/proto"
  32 import fmt "fmt"
  33 import math "math"
  34
  35 import io "io"
  36
  37 // Reference imports to suppress errors if they are not otherwise used.
  38 var _ = proto.Marshal
  39 var _ = fmt.Errorf
  40 var _ = math.Inf
  41
  42 // This is a compile-time assertion to ensure that this generated file
  43 // is compatible with the proto package it is being compiled against.
  44 // A compilation error at this line likely means your copy of the
  45 // proto package needs to be updated.
  46 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  47
  48 func (m *IntOrString) Reset()                    { *m = IntOrString{} }
  49 func (*IntOrString) ProtoMessage()               {}
  50 func (*IntOrString) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  51
  52 func init() {
  53         proto.RegisterType((*IntOrString)(nil), "k8s.io.apimachinery.pkg.util.intstr.IntOrString")
  54 }
  55 func (m *IntOrString) Marshal() (dAtA []byte, err error) {
  56         size := m.Size()
  57         dAtA = make([]byte, size)
  58         n, err := m.MarshalTo(dAtA)
  59         if err != nil {
  60                 return nil, err
  61         }
  62         return dAtA[:n], nil
  63 }
  64
  65 func (m *IntOrString) MarshalTo(dAtA []byte) (int, error) {
  66         var i int
  67         _ = i
  68         var l int
  69         _ = l
  70         dAtA[i] = 0x8
  71         i++
  72         i = encodeVarintGenerated(dAtA, i, uint64(m.Type))
  73         dAtA[i] = 0x10
  74         i++
  75         i = encodeVarintGenerated(dAtA, i, uint64(m.IntVal))
  76         dAtA[i] = 0x1a
  77         i++
  78         i = encodeVarintGenerated(dAtA, i, uint64(len(m.StrVal)))
  79         i += copy(dAtA[i:], m.StrVal)
  80         return i, nil
  81 }
  82
  83 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
  84         for v >= 1<<7 {
  85                 dAtA[offset] = uint8(v&0x7f | 0x80)
  86                 v >>= 7
  87                 offset++
  88         }
  89         dAtA[offset] = uint8(v)
  90         return offset + 1
  91 }
  92 func (m *IntOrString) Size() (n int) {
  93         var l int
  94         _ = l
  95         n += 1 + sovGenerated(uint64(m.Type))
  96         n += 1 + sovGenerated(uint64(m.IntVal))
  97         l = len(m.StrVal)
  98         n += 1 + l + sovGenerated(uint64(l))
  99         return n
 100 }
 101
 102 func sovGenerated(x uint64) (n int) {
 103         for {
 104                 n++
 105                 x >>= 7
 106                 if x == 0 {
 107                         break
 108                 }
 109         }
 110         return n
 111 }
 112 func sozGenerated(x uint64) (n int) {
 113         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 114 }
 115 func (m *IntOrString) Unmarshal(dAtA []byte) error {
 116         l := len(dAtA)
 117         iNdEx := 0
 118         for iNdEx < l {
 119                 preIndex := iNdEx
 120                 var wire uint64
 121                 for shift := uint(0); ; shift += 7 {
 122                         if shift >= 64 {
 123                                 return ErrIntOverflowGenerated
 124                         }
 125                         if iNdEx >= l {
 126                                 return io.ErrUnexpectedEOF
 127                         }
 128                         b := dAtA[iNdEx]
 129                         iNdEx++
 130                         wire |= (uint64(b) & 0x7F) << shift
 131                         if b < 0x80 {
 132                                 break
 133                         }
 134                 }
 135                 fieldNum := int32(wire >> 3)
 136                 wireType := int(wire & 0x7)
 137                 if wireType == 4 {
 138                         return fmt.Errorf("proto: IntOrString: wiretype end group for non-group")
 139                 }
 140                 if fieldNum <= 0 {
 141                         return fmt.Errorf("proto: IntOrString: illegal tag %d (wire type %d)", fieldNum, wire)
 142                 }
 143                 switch fieldNum {
 144                 case 1:
 145                         if wireType != 0 {
 146                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
 147                         }
 148                         m.Type = 0
 149                         for shift := uint(0); ; shift += 7 {
 150                                 if shift >= 64 {
 151                                         return ErrIntOverflowGenerated
 152                                 }
 153                                 if iNdEx >= l {
 154                                         return io.ErrUnexpectedEOF
 155                                 }
 156                                 b := dAtA[iNdEx]
 157                                 iNdEx++
 158                                 m.Type |= (Type(b) & 0x7F) << shift
 159                                 if b < 0x80 {
 160                                         break
 161                                 }
 162                         }
 163                 case 2:
 164                         if wireType != 0 {
 165                                 return fmt.Errorf("proto: wrong wireType = %d for field IntVal", wireType)
 166                         }
 167                         m.IntVal = 0
 168                         for shift := uint(0); ; shift += 7 {
 169                                 if shift >= 64 {
 170                                         return ErrIntOverflowGenerated
 171                                 }
 172                                 if iNdEx >= l {
 173                                         return io.ErrUnexpectedEOF
 174                                 }
 175                                 b := dAtA[iNdEx]
 176                                 iNdEx++
 177                                 m.IntVal |= (int32(b) & 0x7F) << shift
 178                                 if b < 0x80 {
 179                                         break
 180                                 }
 181                         }
 182                 case 3:
 183                         if wireType != 2 {
 184                                 return fmt.Errorf("proto: wrong wireType = %d for field StrVal", wireType)
 185                         }
 186                         var stringLen uint64
 187                         for shift := uint(0); ; shift += 7 {
 188                                 if shift >= 64 {
 189                                         return ErrIntOverflowGenerated
 190                                 }
 191                                 if iNdEx >= l {
 192                                         return io.ErrUnexpectedEOF
 193                                 }
 194                                 b := dAtA[iNdEx]
 195                                 iNdEx++
 196                                 stringLen |= (uint64(b) & 0x7F) << shift
 197                                 if b < 0x80 {
 198                                         break
 199                                 }
 200                         }
 201                         intStringLen := int(stringLen)
 202                         if intStringLen < 0 {
 203                                 return ErrInvalidLengthGenerated
 204                         }
 205                         postIndex := iNdEx + intStringLen
 206                         if postIndex > l {
 207                                 return io.ErrUnexpectedEOF
 208                         }
 209                         m.StrVal = string(dAtA[iNdEx:postIndex])
 210                         iNdEx = postIndex
 211                 default:
 212                         iNdEx = preIndex
 213                         skippy, err := skipGenerated(dAtA[iNdEx:])
 214                         if err != nil {
 215                                 return err
 216                         }
 217                         if skippy < 0 {
 218                                 return ErrInvalidLengthGenerated
 219                         }
 220                         if (iNdEx + skippy) > l {
 221                                 return io.ErrUnexpectedEOF
 222                         }
 223                         iNdEx += skippy
 224                 }
 225         }
 226
 227         if iNdEx > l {
 228                 return io.ErrUnexpectedEOF
 229         }
 230         return nil
 231 }
 232 func skipGenerated(dAtA []byte) (n int, err error) {
 233         l := len(dAtA)
 234         iNdEx := 0
 235         for iNdEx < l {
 236                 var wire uint64
 237                 for shift := uint(0); ; shift += 7 {
 238                         if shift >= 64 {
 239                                 return 0, ErrIntOverflowGenerated
 240                         }
 241                         if iNdEx >= l {
 242                                 return 0, io.ErrUnexpectedEOF
 243                         }
 244                         b := dAtA[iNdEx]
 245                         iNdEx++
 246                         wire |= (uint64(b) & 0x7F) << shift
 247                         if b < 0x80 {
 248                                 break
 249                         }
 250                 }
 251                 wireType := int(wire & 0x7)
 252                 switch wireType {
 253                 case 0:
 254                         for shift := uint(0); ; shift += 7 {
 255                                 if shift >= 64 {
 256                                         return 0, ErrIntOverflowGenerated
 257                                 }
 258                                 if iNdEx >= l {
 259                                         return 0, io.ErrUnexpectedEOF
 260                                 }
 261                                 iNdEx++
 262                                 if dAtA[iNdEx-1] < 0x80 {
 263                                         break
 264                                 }
 265                         }
 266                         return iNdEx, nil
 267                 case 1:
 268                         iNdEx += 8
 269                         return iNdEx, nil
 270                 case 2:
 271                         var length int
 272                         for shift := uint(0); ; shift += 7 {
 273                                 if shift >= 64 {
 274                                         return 0, ErrIntOverflowGenerated
 275                                 }
 276                                 if iNdEx >= l {
 277                                         return 0, io.ErrUnexpectedEOF
 278                                 }
 279                                 b := dAtA[iNdEx]
 280                                 iNdEx++
 281                                 length |= (int(b) & 0x7F) << shift
 282                                 if b < 0x80 {
 283                                         break
 284                                 }
 285                         }
 286                         iNdEx += length
 287                         if length < 0 {
 288                                 return 0, ErrInvalidLengthGenerated
 289                         }
 290                         return iNdEx, nil
 291                 case 3:
 292                         for {
 293                                 var innerWire uint64
 294                                 var start int = iNdEx
 295                                 for shift := uint(0); ; shift += 7 {
 296                                         if shift >= 64 {
 297                                                 return 0, ErrIntOverflowGenerated
 298                                         }
 299                                         if iNdEx >= l {
 300                                                 return 0, io.ErrUnexpectedEOF
 301                                         }
 302                                         b := dAtA[iNdEx]
 303                                         iNdEx++
 304                                         innerWire |= (uint64(b) & 0x7F) << shift
 305                                         if b < 0x80 {
 306                                                 break
 307                                         }
 308                                 }
 309                                 innerWireType := int(innerWire & 0x7)
 310                                 if innerWireType == 4 {
 311                                         break
 312                                 }
 313                                 next, err := skipGenerated(dAtA[start:])
 314                                 if err != nil {
 315                                         return 0, err
 316                                 }
 317                                 iNdEx = start + next
 318                         }
 319                         return iNdEx, nil
 320                 case 4:
 321                         return iNdEx, nil
 322                 case 5:
 323                         iNdEx += 4
 324                         return iNdEx, nil
 325                 default:
 326                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 327                 }
 328         }
 329         panic("unreachable")
 330 }
 331
 332 var (
 333         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
 334         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
 335 )
 336
 337 func init() {
 338         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/util/intstr/generated.proto", fileDescriptorGenerated)
 339 }
 340
 341 var fileDescriptorGenerated = []byte{
 342         // 292 bytes of a gzipped FileDescriptorProto
 343         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x8f, 0x31, 0x4b, 0x33, 0x31,
 344         0x1c, 0xc6, 0x93, 0xb7, 0x7d, 0x8b, 0x9e, 0xe0, 0x50, 0x1c, 0x8a, 0x43, 0x7a, 0x28, 0xc8, 0x0d,
 345         0x9a, 0xac, 0xe2, 0xd8, 0xad, 0x20, 0x08, 0x57, 0x71, 0x70, 0xbb, 0x6b, 0x63, 0x1a, 0xae, 0x4d,
 346         0x42, 0xee, 0x7f, 0xc2, 0x6d, 0xfd, 0x08, 0xba, 0x39, 0xfa, 0x71, 0x6e, 0xec, 0xd8, 0x41, 0x8a,
 347         0x17, 0xbf, 0x85, 0x93, 0x5c, 0xee, 0x40, 0xa7, 0xe4, 0x79, 0x9e, 0xdf, 0x2f, 0x90, 0xe0, 0x36,
 348         0xbb, 0xce, 0xa9, 0xd4, 0x2c, 0x2b, 0x52, 0x6e, 0x15, 0x07, 0x9e, 0xb3, 0x67, 0xae, 0x16, 0xda,
 349         0xb2, 0x6e, 0x48, 0x8c, 0x5c, 0x27, 0xf3, 0xa5, 0x54, 0xdc, 0x96, 0xcc, 0x64, 0x82, 0x15, 0x20,
 350         0x57, 0x4c, 0x2a, 0xc8, 0xc1, 0x32, 0xc1, 0x15, 0xb7, 0x09, 0xf0, 0x05, 0x35, 0x56, 0x83, 0x1e,
 351         0x9e, 0xb7, 0x12, 0xfd, 0x2b, 0x51, 0x93, 0x09, 0xda, 0x48, 0xb4, 0x95, 0x4e, 0xaf, 0x84, 0x84,
 352         0x65, 0x91, 0xd2, 0xb9, 0x5e, 0x33, 0xa1, 0x85, 0x66, 0xde, 0x4d, 0x8b, 0x27, 0x9f, 0x7c, 0xf0,
 353         0xb7, 0xf6, 0xcd, 0xb3, 0x57, 0x1c, 0x1c, 0x4d, 0x15, 0xdc, 0xd9, 0x19, 0x58, 0xa9, 0xc4, 0x30,
 354         0x0a, 0xfa, 0x50, 0x1a, 0x3e, 0xc2, 0x21, 0x8e, 0x7a, 0x93, 0x93, 0x6a, 0x3f, 0x46, 0x6e, 0x3f,
 355         0xee, 0xdf, 0x97, 0x86, 0x7f, 0x77, 0x67, 0xec, 0x89, 0xe1, 0x45, 0x30, 0x90, 0x0a, 0x1e, 0x92,
 356         0xd5, 0xe8, 0x5f, 0x88, 0xa3, 0xff, 0x93, 0xe3, 0x8e, 0x1d, 0x4c, 0x7d, 0x1b, 0x77, 0x6b, 0xc3,
 357         0xe5, 0x60, 0x1b, 0xae, 0x17, 0xe2, 0xe8, 0xf0, 0x97, 0x9b, 0xf9, 0x36, 0xee, 0xd6, 0x9b, 0x83,
 358         0xb7, 0xf7, 0x31, 0xda, 0x7c, 0x84, 0x68, 0x72, 0x59, 0xd5, 0x04, 0x6d, 0x6b, 0x82, 0x76, 0x35,
 359         0x41, 0x1b, 0x47, 0x70, 0xe5, 0x08, 0xde, 0x3a, 0x82, 0x77, 0x8e, 0xe0, 0x4f, 0x47, 0xf0, 0xcb,
 360         0x17, 0x41, 0x8f, 0x83, 0xf6, 0xc3, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x52, 0xa0, 0xb5, 0xc9,
 361         0x64, 0x01, 0x00, 0x00,
 362 }