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

Documentation: k8s.io/apimachinery/pkg/runtime

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

View as plain text