Source file src/k8s.io/api/imagepolicy/v1alpha1/generated.pb.go

Documentation: k8s.io/api/imagepolicy/v1alpha1

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

View as plain text