Source file src/github.com/openshift/api/user/v1/generated.pb.go

Documentation: github.com/openshift/api/user/v1

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: github.com/openshift/api/user/v1/generated.proto
     3  
     4  package v1
     5  
     6  import (
     7  	fmt "fmt"
     8  
     9  	io "io"
    10  
    11  	proto "github.com/gogo/protobuf/proto"
    12  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    13  
    14  	math "math"
    15  	math_bits "math/bits"
    16  	reflect "reflect"
    17  	strings "strings"
    18  )
    19  
    20  // Reference imports to suppress errors if they are not otherwise used.
    21  var _ = proto.Marshal
    22  var _ = fmt.Errorf
    23  var _ = math.Inf
    24  
    25  // This is a compile-time assertion to ensure that this generated file
    26  // is compatible with the proto package it is being compiled against.
    27  // A compilation error at this line likely means your copy of the
    28  // proto package needs to be updated.
    29  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    30  
    31  func (m *Group) Reset()      { *m = Group{} }
    32  func (*Group) ProtoMessage() {}
    33  func (*Group) Descriptor() ([]byte, []int) {
    34  	return fileDescriptor_ea159b02d89a1362, []int{0}
    35  }
    36  func (m *Group) XXX_Unmarshal(b []byte) error {
    37  	return m.Unmarshal(b)
    38  }
    39  func (m *Group) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    40  	b = b[:cap(b)]
    41  	n, err := m.MarshalToSizedBuffer(b)
    42  	if err != nil {
    43  		return nil, err
    44  	}
    45  	return b[:n], nil
    46  }
    47  func (m *Group) XXX_Merge(src proto.Message) {
    48  	xxx_messageInfo_Group.Merge(m, src)
    49  }
    50  func (m *Group) XXX_Size() int {
    51  	return m.Size()
    52  }
    53  func (m *Group) XXX_DiscardUnknown() {
    54  	xxx_messageInfo_Group.DiscardUnknown(m)
    55  }
    56  
    57  var xxx_messageInfo_Group proto.InternalMessageInfo
    58  
    59  func (m *GroupList) Reset()      { *m = GroupList{} }
    60  func (*GroupList) ProtoMessage() {}
    61  func (*GroupList) Descriptor() ([]byte, []int) {
    62  	return fileDescriptor_ea159b02d89a1362, []int{1}
    63  }
    64  func (m *GroupList) XXX_Unmarshal(b []byte) error {
    65  	return m.Unmarshal(b)
    66  }
    67  func (m *GroupList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    68  	b = b[:cap(b)]
    69  	n, err := m.MarshalToSizedBuffer(b)
    70  	if err != nil {
    71  		return nil, err
    72  	}
    73  	return b[:n], nil
    74  }
    75  func (m *GroupList) XXX_Merge(src proto.Message) {
    76  	xxx_messageInfo_GroupList.Merge(m, src)
    77  }
    78  func (m *GroupList) XXX_Size() int {
    79  	return m.Size()
    80  }
    81  func (m *GroupList) XXX_DiscardUnknown() {
    82  	xxx_messageInfo_GroupList.DiscardUnknown(m)
    83  }
    84  
    85  var xxx_messageInfo_GroupList proto.InternalMessageInfo
    86  
    87  func (m *Identity) Reset()      { *m = Identity{} }
    88  func (*Identity) ProtoMessage() {}
    89  func (*Identity) Descriptor() ([]byte, []int) {
    90  	return fileDescriptor_ea159b02d89a1362, []int{2}
    91  }
    92  func (m *Identity) XXX_Unmarshal(b []byte) error {
    93  	return m.Unmarshal(b)
    94  }
    95  func (m *Identity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    96  	b = b[:cap(b)]
    97  	n, err := m.MarshalToSizedBuffer(b)
    98  	if err != nil {
    99  		return nil, err
   100  	}
   101  	return b[:n], nil
   102  }
   103  func (m *Identity) XXX_Merge(src proto.Message) {
   104  	xxx_messageInfo_Identity.Merge(m, src)
   105  }
   106  func (m *Identity) XXX_Size() int {
   107  	return m.Size()
   108  }
   109  func (m *Identity) XXX_DiscardUnknown() {
   110  	xxx_messageInfo_Identity.DiscardUnknown(m)
   111  }
   112  
   113  var xxx_messageInfo_Identity proto.InternalMessageInfo
   114  
   115  func (m *IdentityList) Reset()      { *m = IdentityList{} }
   116  func (*IdentityList) ProtoMessage() {}
   117  func (*IdentityList) Descriptor() ([]byte, []int) {
   118  	return fileDescriptor_ea159b02d89a1362, []int{3}
   119  }
   120  func (m *IdentityList) XXX_Unmarshal(b []byte) error {
   121  	return m.Unmarshal(b)
   122  }
   123  func (m *IdentityList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   124  	b = b[:cap(b)]
   125  	n, err := m.MarshalToSizedBuffer(b)
   126  	if err != nil {
   127  		return nil, err
   128  	}
   129  	return b[:n], nil
   130  }
   131  func (m *IdentityList) XXX_Merge(src proto.Message) {
   132  	xxx_messageInfo_IdentityList.Merge(m, src)
   133  }
   134  func (m *IdentityList) XXX_Size() int {
   135  	return m.Size()
   136  }
   137  func (m *IdentityList) XXX_DiscardUnknown() {
   138  	xxx_messageInfo_IdentityList.DiscardUnknown(m)
   139  }
   140  
   141  var xxx_messageInfo_IdentityList proto.InternalMessageInfo
   142  
   143  func (m *OptionalNames) Reset()      { *m = OptionalNames{} }
   144  func (*OptionalNames) ProtoMessage() {}
   145  func (*OptionalNames) Descriptor() ([]byte, []int) {
   146  	return fileDescriptor_ea159b02d89a1362, []int{4}
   147  }
   148  func (m *OptionalNames) XXX_Unmarshal(b []byte) error {
   149  	return m.Unmarshal(b)
   150  }
   151  func (m *OptionalNames) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   152  	b = b[:cap(b)]
   153  	n, err := m.MarshalToSizedBuffer(b)
   154  	if err != nil {
   155  		return nil, err
   156  	}
   157  	return b[:n], nil
   158  }
   159  func (m *OptionalNames) XXX_Merge(src proto.Message) {
   160  	xxx_messageInfo_OptionalNames.Merge(m, src)
   161  }
   162  func (m *OptionalNames) XXX_Size() int {
   163  	return m.Size()
   164  }
   165  func (m *OptionalNames) XXX_DiscardUnknown() {
   166  	xxx_messageInfo_OptionalNames.DiscardUnknown(m)
   167  }
   168  
   169  var xxx_messageInfo_OptionalNames proto.InternalMessageInfo
   170  
   171  func (m *User) Reset()      { *m = User{} }
   172  func (*User) ProtoMessage() {}
   173  func (*User) Descriptor() ([]byte, []int) {
   174  	return fileDescriptor_ea159b02d89a1362, []int{5}
   175  }
   176  func (m *User) XXX_Unmarshal(b []byte) error {
   177  	return m.Unmarshal(b)
   178  }
   179  func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   180  	b = b[:cap(b)]
   181  	n, err := m.MarshalToSizedBuffer(b)
   182  	if err != nil {
   183  		return nil, err
   184  	}
   185  	return b[:n], nil
   186  }
   187  func (m *User) XXX_Merge(src proto.Message) {
   188  	xxx_messageInfo_User.Merge(m, src)
   189  }
   190  func (m *User) XXX_Size() int {
   191  	return m.Size()
   192  }
   193  func (m *User) XXX_DiscardUnknown() {
   194  	xxx_messageInfo_User.DiscardUnknown(m)
   195  }
   196  
   197  var xxx_messageInfo_User proto.InternalMessageInfo
   198  
   199  func (m *UserIdentityMapping) Reset()      { *m = UserIdentityMapping{} }
   200  func (*UserIdentityMapping) ProtoMessage() {}
   201  func (*UserIdentityMapping) Descriptor() ([]byte, []int) {
   202  	return fileDescriptor_ea159b02d89a1362, []int{6}
   203  }
   204  func (m *UserIdentityMapping) XXX_Unmarshal(b []byte) error {
   205  	return m.Unmarshal(b)
   206  }
   207  func (m *UserIdentityMapping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   208  	b = b[:cap(b)]
   209  	n, err := m.MarshalToSizedBuffer(b)
   210  	if err != nil {
   211  		return nil, err
   212  	}
   213  	return b[:n], nil
   214  }
   215  func (m *UserIdentityMapping) XXX_Merge(src proto.Message) {
   216  	xxx_messageInfo_UserIdentityMapping.Merge(m, src)
   217  }
   218  func (m *UserIdentityMapping) XXX_Size() int {
   219  	return m.Size()
   220  }
   221  func (m *UserIdentityMapping) XXX_DiscardUnknown() {
   222  	xxx_messageInfo_UserIdentityMapping.DiscardUnknown(m)
   223  }
   224  
   225  var xxx_messageInfo_UserIdentityMapping proto.InternalMessageInfo
   226  
   227  func (m *UserList) Reset()      { *m = UserList{} }
   228  func (*UserList) ProtoMessage() {}
   229  func (*UserList) Descriptor() ([]byte, []int) {
   230  	return fileDescriptor_ea159b02d89a1362, []int{7}
   231  }
   232  func (m *UserList) XXX_Unmarshal(b []byte) error {
   233  	return m.Unmarshal(b)
   234  }
   235  func (m *UserList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   236  	b = b[:cap(b)]
   237  	n, err := m.MarshalToSizedBuffer(b)
   238  	if err != nil {
   239  		return nil, err
   240  	}
   241  	return b[:n], nil
   242  }
   243  func (m *UserList) XXX_Merge(src proto.Message) {
   244  	xxx_messageInfo_UserList.Merge(m, src)
   245  }
   246  func (m *UserList) XXX_Size() int {
   247  	return m.Size()
   248  }
   249  func (m *UserList) XXX_DiscardUnknown() {
   250  	xxx_messageInfo_UserList.DiscardUnknown(m)
   251  }
   252  
   253  var xxx_messageInfo_UserList proto.InternalMessageInfo
   254  
   255  func init() {
   256  	proto.RegisterType((*Group)(nil), "github.com.openshift.api.user.v1.Group")
   257  	proto.RegisterType((*GroupList)(nil), "github.com.openshift.api.user.v1.GroupList")
   258  	proto.RegisterType((*Identity)(nil), "github.com.openshift.api.user.v1.Identity")
   259  	proto.RegisterMapType((map[string]string)(nil), "github.com.openshift.api.user.v1.Identity.ExtraEntry")
   260  	proto.RegisterType((*IdentityList)(nil), "github.com.openshift.api.user.v1.IdentityList")
   261  	proto.RegisterType((*OptionalNames)(nil), "github.com.openshift.api.user.v1.OptionalNames")
   262  	proto.RegisterType((*User)(nil), "github.com.openshift.api.user.v1.User")
   263  	proto.RegisterType((*UserIdentityMapping)(nil), "github.com.openshift.api.user.v1.UserIdentityMapping")
   264  	proto.RegisterType((*UserList)(nil), "github.com.openshift.api.user.v1.UserList")
   265  }
   266  
   267  func init() {
   268  	proto.RegisterFile("github.com/openshift/api/user/v1/generated.proto", fileDescriptor_ea159b02d89a1362)
   269  }
   270  
   271  var fileDescriptor_ea159b02d89a1362 = []byte{
   272  	// 726 bytes of a gzipped FileDescriptorProto
   273  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x3d, 0x6f, 0x13, 0x4b,
   274  	0x14, 0xf5, 0xc4, 0xde, 0xc8, 0x9e, 0x38, 0x4f, 0xd6, 0xbe, 0x14, 0x2b, 0x17, 0x6b, 0x6b, 0x9f,
   275  	0xf4, 0x88, 0x10, 0xcc, 0x26, 0x11, 0x20, 0x2b, 0xa5, 0x45, 0x82, 0x22, 0x12, 0x12, 0x46, 0xa2,
   276  	0x89, 0x28, 0x98, 0xd8, 0xe3, 0xf5, 0x60, 0xef, 0x87, 0x76, 0x67, 0x2d, 0xdc, 0xe5, 0x27, 0x40,
   277  	0x47, 0xc9, 0x9f, 0x40, 0x14, 0x88, 0x3e, 0x74, 0x29, 0x53, 0x20, 0x8b, 0x2c, 0x1d, 0xbf, 0x02,
   278  	0xcd, 0xec, 0x87, 0xd7, 0xf9, 0x90, 0x23, 0x21, 0xb9, 0xdb, 0xb9, 0x73, 0xcf, 0x99, 0x73, 0xcf,
   279  	0xbd, 0xd7, 0x32, 0xdc, 0xb0, 0x18, 0xef, 0x87, 0x27, 0xa8, 0xe3, 0xda, 0xa6, 0xeb, 0x51, 0x27,
   280  	0xe8, 0xb3, 0x1e, 0x37, 0x89, 0xc7, 0xcc, 0x30, 0xa0, 0xbe, 0x39, 0xda, 0x34, 0x2d, 0xea, 0x50,
   281  	0x9f, 0x70, 0xda, 0x45, 0x9e, 0xef, 0x72, 0x57, 0x6d, 0x4e, 0x11, 0x28, 0x43, 0x20, 0xe2, 0x31,
   282  	0x24, 0x10, 0x68, 0xb4, 0x59, 0x7f, 0x98, 0xe3, 0xb4, 0x5c, 0xcb, 0x35, 0x25, 0xf0, 0x24, 0xec,
   283  	0xc9, 0x93, 0x3c, 0xc8, 0xaf, 0x98, 0xb0, 0x6e, 0x0c, 0x5a, 0x01, 0x62, 0xae, 0x7c, 0xb4, 0xe3,
   284  	0xfa, 0xf4, 0x86, 0x47, 0xeb, 0x8f, 0xa6, 0x39, 0x36, 0xe9, 0xf4, 0x99, 0x43, 0xfd, 0xb1, 0xe9,
   285  	0x0d, 0x2c, 0x11, 0x08, 0x4c, 0x9b, 0x72, 0x72, 0x13, 0xea, 0xc9, 0x6d, 0x28, 0x3f, 0x74, 0x38,
   286  	0xb3, 0xa9, 0x19, 0x74, 0xfa, 0xd4, 0x26, 0x57, 0x71, 0xc6, 0x57, 0x00, 0x95, 0x67, 0xbe, 0x1b,
   287  	0x7a, 0xea, 0x1b, 0x58, 0x16, 0xe4, 0x5d, 0xc2, 0x89, 0x06, 0x9a, 0x60, 0x7d, 0x65, 0x6b, 0x03,
   288  	0xc5, 0xa4, 0x28, 0x4f, 0x8a, 0xbc, 0x81, 0x25, 0x02, 0x01, 0x12, 0xd9, 0x68, 0xb4, 0x89, 0x0e,
   289  	0x4f, 0xde, 0xd2, 0x0e, 0x3f, 0xa0, 0x9c, 0xb4, 0xd5, 0xb3, 0x49, 0xa3, 0x10, 0x4d, 0x1a, 0x70,
   290  	0x1a, 0xc3, 0x19, 0xab, 0x7a, 0x04, 0x15, 0xe1, 0x5b, 0xa0, 0x2d, 0x49, 0x7a, 0x13, 0xcd, 0xb3,
   291  	0x17, 0x1d, 0x7a, 0x9c, 0xb9, 0x0e, 0x19, 0xbe, 0x20, 0x36, 0x0d, 0xda, 0x95, 0x68, 0xd2, 0x50,
   292  	0x5e, 0x09, 0x06, 0x1c, 0x13, 0x19, 0x5f, 0x00, 0xac, 0x48, 0xf5, 0xfb, 0x2c, 0xe0, 0xea, 0xeb,
   293  	0x6b, 0x15, 0xa0, 0xbb, 0x55, 0x20, 0xd0, 0x52, 0x7f, 0x2d, 0xd1, 0x5f, 0x4e, 0x23, 0x39, 0xf5,
   294  	0xfb, 0x50, 0x61, 0x9c, 0xda, 0x42, 0x7d, 0x71, 0x7d, 0x65, 0xeb, 0xde, 0x7c, 0xf5, 0x52, 0x59,
   295  	0x7b, 0x35, 0xe1, 0x54, 0xf6, 0x04, 0x1a, 0xc7, 0x24, 0xc6, 0xf7, 0x22, 0x2c, 0xef, 0x75, 0xa9,
   296  	0xc3, 0x19, 0x1f, 0x2f, 0xc0, 0xfa, 0x16, 0xac, 0x7a, 0xbe, 0x3b, 0x62, 0x5d, 0xea, 0x0b, 0x2f,
   297  	0x65, 0x07, 0x2a, 0xed, 0xb5, 0x04, 0x53, 0x3d, 0xca, 0xdd, 0xe1, 0x99, 0x4c, 0xf5, 0x29, 0xac,
   298  	0xa5, 0x67, 0x61, 0xbd, 0x44, 0x17, 0x25, 0x5a, 0x4b, 0xd0, 0xb5, 0xa3, 0x2b, 0xf7, 0xf8, 0x1a,
   299  	0x42, 0xdd, 0x81, 0x25, 0xe1, 0x8a, 0x56, 0x92, 0xd5, 0xfd, 0x97, 0xab, 0x0e, 0x89, 0x3d, 0x98,
   300  	0xd6, 0x82, 0x69, 0x8f, 0xfa, 0xd4, 0xe9, 0xd0, 0x76, 0x35, 0xa1, 0x2f, 0x09, 0x12, 0x2c, 0xe1,
   301  	0xea, 0x31, 0x54, 0xe8, 0x3b, 0xee, 0x13, 0x4d, 0x91, 0x3d, 0x78, 0x3c, 0xbf, 0x07, 0xa9, 0xc7,
   302  	0x68, 0x47, 0xe0, 0x76, 0x1c, 0xee, 0x8f, 0xa7, 0x1d, 0x91, 0x31, 0x1c, 0x53, 0xd6, 0x5b, 0x10,
   303  	0x4e, 0x73, 0xd4, 0x1a, 0x2c, 0x0e, 0xe8, 0x58, 0x76, 0xa3, 0x82, 0xc5, 0xa7, 0xba, 0x06, 0x95,
   304  	0x11, 0x19, 0x86, 0x89, 0x77, 0x38, 0x3e, 0x6c, 0x2f, 0xb5, 0x80, 0xf1, 0x0d, 0xc0, 0x6a, 0xfa,
   305  	0xce, 0x02, 0x06, 0xf1, 0x70, 0x76, 0x10, 0xef, 0xdf, 0xdd, 0x84, 0x5b, 0x66, 0x71, 0x1b, 0xae,
   306  	0xce, 0x2c, 0x9a, 0xda, 0x48, 0x5f, 0x00, 0xcd, 0xe2, 0x7a, 0x25, 0xde, 0xbb, 0x3c, 0x62, 0xbb,
   307  	0xfc, 0xf1, 0x53, 0xa3, 0x70, 0xfa, 0xa3, 0x59, 0x30, 0x7e, 0x03, 0x28, 0x1b, 0xb4, 0x80, 0x19,
   308  	0x7e, 0x00, 0xcb, 0xbd, 0x70, 0x38, 0xcc, 0xcd, 0x6f, 0xe6, 0xd2, 0x6e, 0x12, 0xc7, 0x59, 0x86,
   309  	0x8a, 0x20, 0x64, 0x71, 0xd9, 0x8c, 0x06, 0x5a, 0x51, 0x16, 0xf2, 0x8f, 0xe0, 0xde, 0xcb, 0xa2,
   310  	0x38, 0x97, 0xa1, 0x1a, 0x70, 0xd9, 0x12, 0xfb, 0x1a, 0x68, 0x25, 0x99, 0x0b, 0xa3, 0x49, 0x63,
   311  	0x59, 0x6e, 0x70, 0x80, 0x93, 0x1b, 0xe3, 0xc3, 0x12, 0xfc, 0x57, 0x14, 0x9b, 0xfa, 0x79, 0x40,
   312  	0x3c, 0x8f, 0x39, 0xd6, 0x02, 0x6a, 0x7f, 0x09, 0xcb, 0x89, 0xd6, 0x71, 0xf2, 0xeb, 0x79, 0xa7,
   313  	0x1d, 0xca, 0x0c, 0x4a, 0x15, 0xe3, 0x8c, 0x26, 0x5b, 0xc9, 0xe2, 0x5f, 0xad, 0xa4, 0xf1, 0x19,
   314  	0xc0, 0xb2, 0x38, 0x2e, 0x60, 0xf0, 0x9f, 0xcf, 0x0e, 0xfe, 0xff, 0xf3, 0x07, 0x5f, 0x08, 0xbb,
   315  	0x79, 0xe8, 0xdb, 0xbb, 0x67, 0x97, 0x7a, 0xe1, 0xfc, 0x52, 0x2f, 0x5c, 0x5c, 0xea, 0x85, 0xd3,
   316  	0x48, 0x07, 0x67, 0x91, 0x0e, 0xce, 0x23, 0x1d, 0x5c, 0x44, 0x3a, 0xf8, 0x19, 0xe9, 0xe0, 0xfd,
   317  	0x2f, 0xbd, 0x70, 0xdc, 0x9c, 0xf7, 0x9f, 0xe1, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x45, 0x85,
   318  	0x81, 0x86, 0x56, 0x08, 0x00, 0x00,
   319  }
   320  
   321  func (m *Group) Marshal() (dAtA []byte, err error) {
   322  	size := m.Size()
   323  	dAtA = make([]byte, size)
   324  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   325  	if err != nil {
   326  		return nil, err
   327  	}
   328  	return dAtA[:n], nil
   329  }
   330  
   331  func (m *Group) MarshalTo(dAtA []byte) (int, error) {
   332  	size := m.Size()
   333  	return m.MarshalToSizedBuffer(dAtA[:size])
   334  }
   335  
   336  func (m *Group) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   337  	i := len(dAtA)
   338  	_ = i
   339  	var l int
   340  	_ = l
   341  	if m.Users != nil {
   342  		{
   343  			size, err := m.Users.MarshalToSizedBuffer(dAtA[:i])
   344  			if err != nil {
   345  				return 0, err
   346  			}
   347  			i -= size
   348  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   349  		}
   350  		i--
   351  		dAtA[i] = 0x12
   352  	}
   353  	{
   354  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   355  		if err != nil {
   356  			return 0, err
   357  		}
   358  		i -= size
   359  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   360  	}
   361  	i--
   362  	dAtA[i] = 0xa
   363  	return len(dAtA) - i, nil
   364  }
   365  
   366  func (m *GroupList) Marshal() (dAtA []byte, err error) {
   367  	size := m.Size()
   368  	dAtA = make([]byte, size)
   369  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   370  	if err != nil {
   371  		return nil, err
   372  	}
   373  	return dAtA[:n], nil
   374  }
   375  
   376  func (m *GroupList) MarshalTo(dAtA []byte) (int, error) {
   377  	size := m.Size()
   378  	return m.MarshalToSizedBuffer(dAtA[:size])
   379  }
   380  
   381  func (m *GroupList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   382  	i := len(dAtA)
   383  	_ = i
   384  	var l int
   385  	_ = l
   386  	if len(m.Items) > 0 {
   387  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   388  			{
   389  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   390  				if err != nil {
   391  					return 0, err
   392  				}
   393  				i -= size
   394  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   395  			}
   396  			i--
   397  			dAtA[i] = 0x12
   398  		}
   399  	}
   400  	{
   401  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   402  		if err != nil {
   403  			return 0, err
   404  		}
   405  		i -= size
   406  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   407  	}
   408  	i--
   409  	dAtA[i] = 0xa
   410  	return len(dAtA) - i, nil
   411  }
   412  
   413  func (m *Identity) Marshal() (dAtA []byte, err error) {
   414  	size := m.Size()
   415  	dAtA = make([]byte, size)
   416  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   417  	if err != nil {
   418  		return nil, err
   419  	}
   420  	return dAtA[:n], nil
   421  }
   422  
   423  func (m *Identity) MarshalTo(dAtA []byte) (int, error) {
   424  	size := m.Size()
   425  	return m.MarshalToSizedBuffer(dAtA[:size])
   426  }
   427  
   428  func (m *Identity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   429  	i := len(dAtA)
   430  	_ = i
   431  	var l int
   432  	_ = l
   433  	if len(m.Extra) > 0 {
   434  		keysForExtra := make([]string, 0, len(m.Extra))
   435  		for k := range m.Extra {
   436  			keysForExtra = append(keysForExtra, string(k))
   437  		}
   438  		github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
   439  		for iNdEx := len(keysForExtra) - 1; iNdEx >= 0; iNdEx-- {
   440  			v := m.Extra[string(keysForExtra[iNdEx])]
   441  			baseI := i
   442  			i -= len(v)
   443  			copy(dAtA[i:], v)
   444  			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
   445  			i--
   446  			dAtA[i] = 0x12
   447  			i -= len(keysForExtra[iNdEx])
   448  			copy(dAtA[i:], keysForExtra[iNdEx])
   449  			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForExtra[iNdEx])))
   450  			i--
   451  			dAtA[i] = 0xa
   452  			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
   453  			i--
   454  			dAtA[i] = 0x2a
   455  		}
   456  	}
   457  	{
   458  		size, err := m.User.MarshalToSizedBuffer(dAtA[:i])
   459  		if err != nil {
   460  			return 0, err
   461  		}
   462  		i -= size
   463  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   464  	}
   465  	i--
   466  	dAtA[i] = 0x22
   467  	i -= len(m.ProviderUserName)
   468  	copy(dAtA[i:], m.ProviderUserName)
   469  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ProviderUserName)))
   470  	i--
   471  	dAtA[i] = 0x1a
   472  	i -= len(m.ProviderName)
   473  	copy(dAtA[i:], m.ProviderName)
   474  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ProviderName)))
   475  	i--
   476  	dAtA[i] = 0x12
   477  	{
   478  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   479  		if err != nil {
   480  			return 0, err
   481  		}
   482  		i -= size
   483  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   484  	}
   485  	i--
   486  	dAtA[i] = 0xa
   487  	return len(dAtA) - i, nil
   488  }
   489  
   490  func (m *IdentityList) Marshal() (dAtA []byte, err error) {
   491  	size := m.Size()
   492  	dAtA = make([]byte, size)
   493  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   494  	if err != nil {
   495  		return nil, err
   496  	}
   497  	return dAtA[:n], nil
   498  }
   499  
   500  func (m *IdentityList) MarshalTo(dAtA []byte) (int, error) {
   501  	size := m.Size()
   502  	return m.MarshalToSizedBuffer(dAtA[:size])
   503  }
   504  
   505  func (m *IdentityList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   506  	i := len(dAtA)
   507  	_ = i
   508  	var l int
   509  	_ = l
   510  	if len(m.Items) > 0 {
   511  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   512  			{
   513  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   514  				if err != nil {
   515  					return 0, err
   516  				}
   517  				i -= size
   518  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   519  			}
   520  			i--
   521  			dAtA[i] = 0x12
   522  		}
   523  	}
   524  	{
   525  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   526  		if err != nil {
   527  			return 0, err
   528  		}
   529  		i -= size
   530  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   531  	}
   532  	i--
   533  	dAtA[i] = 0xa
   534  	return len(dAtA) - i, nil
   535  }
   536  
   537  func (m OptionalNames) Marshal() (dAtA []byte, err error) {
   538  	size := m.Size()
   539  	dAtA = make([]byte, size)
   540  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   541  	if err != nil {
   542  		return nil, err
   543  	}
   544  	return dAtA[:n], nil
   545  }
   546  
   547  func (m OptionalNames) MarshalTo(dAtA []byte) (int, error) {
   548  	size := m.Size()
   549  	return m.MarshalToSizedBuffer(dAtA[:size])
   550  }
   551  
   552  func (m OptionalNames) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   553  	i := len(dAtA)
   554  	_ = i
   555  	var l int
   556  	_ = l
   557  	if len(m) > 0 {
   558  		for iNdEx := len(m) - 1; iNdEx >= 0; iNdEx-- {
   559  			i -= len(m[iNdEx])
   560  			copy(dAtA[i:], m[iNdEx])
   561  			i = encodeVarintGenerated(dAtA, i, uint64(len(m[iNdEx])))
   562  			i--
   563  			dAtA[i] = 0xa
   564  		}
   565  	}
   566  	return len(dAtA) - i, nil
   567  }
   568  
   569  func (m *User) Marshal() (dAtA []byte, err error) {
   570  	size := m.Size()
   571  	dAtA = make([]byte, size)
   572  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   573  	if err != nil {
   574  		return nil, err
   575  	}
   576  	return dAtA[:n], nil
   577  }
   578  
   579  func (m *User) MarshalTo(dAtA []byte) (int, error) {
   580  	size := m.Size()
   581  	return m.MarshalToSizedBuffer(dAtA[:size])
   582  }
   583  
   584  func (m *User) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   585  	i := len(dAtA)
   586  	_ = i
   587  	var l int
   588  	_ = l
   589  	if len(m.Groups) > 0 {
   590  		for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
   591  			i -= len(m.Groups[iNdEx])
   592  			copy(dAtA[i:], m.Groups[iNdEx])
   593  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Groups[iNdEx])))
   594  			i--
   595  			dAtA[i] = 0x22
   596  		}
   597  	}
   598  	if len(m.Identities) > 0 {
   599  		for iNdEx := len(m.Identities) - 1; iNdEx >= 0; iNdEx-- {
   600  			i -= len(m.Identities[iNdEx])
   601  			copy(dAtA[i:], m.Identities[iNdEx])
   602  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Identities[iNdEx])))
   603  			i--
   604  			dAtA[i] = 0x1a
   605  		}
   606  	}
   607  	i -= len(m.FullName)
   608  	copy(dAtA[i:], m.FullName)
   609  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FullName)))
   610  	i--
   611  	dAtA[i] = 0x12
   612  	{
   613  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   614  		if err != nil {
   615  			return 0, err
   616  		}
   617  		i -= size
   618  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   619  	}
   620  	i--
   621  	dAtA[i] = 0xa
   622  	return len(dAtA) - i, nil
   623  }
   624  
   625  func (m *UserIdentityMapping) Marshal() (dAtA []byte, err error) {
   626  	size := m.Size()
   627  	dAtA = make([]byte, size)
   628  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   629  	if err != nil {
   630  		return nil, err
   631  	}
   632  	return dAtA[:n], nil
   633  }
   634  
   635  func (m *UserIdentityMapping) MarshalTo(dAtA []byte) (int, error) {
   636  	size := m.Size()
   637  	return m.MarshalToSizedBuffer(dAtA[:size])
   638  }
   639  
   640  func (m *UserIdentityMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   641  	i := len(dAtA)
   642  	_ = i
   643  	var l int
   644  	_ = l
   645  	{
   646  		size, err := m.User.MarshalToSizedBuffer(dAtA[:i])
   647  		if err != nil {
   648  			return 0, err
   649  		}
   650  		i -= size
   651  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   652  	}
   653  	i--
   654  	dAtA[i] = 0x1a
   655  	{
   656  		size, err := m.Identity.MarshalToSizedBuffer(dAtA[:i])
   657  		if err != nil {
   658  			return 0, err
   659  		}
   660  		i -= size
   661  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   662  	}
   663  	i--
   664  	dAtA[i] = 0x12
   665  	{
   666  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   667  		if err != nil {
   668  			return 0, err
   669  		}
   670  		i -= size
   671  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   672  	}
   673  	i--
   674  	dAtA[i] = 0xa
   675  	return len(dAtA) - i, nil
   676  }
   677  
   678  func (m *UserList) Marshal() (dAtA []byte, err error) {
   679  	size := m.Size()
   680  	dAtA = make([]byte, size)
   681  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   682  	if err != nil {
   683  		return nil, err
   684  	}
   685  	return dAtA[:n], nil
   686  }
   687  
   688  func (m *UserList) MarshalTo(dAtA []byte) (int, error) {
   689  	size := m.Size()
   690  	return m.MarshalToSizedBuffer(dAtA[:size])
   691  }
   692  
   693  func (m *UserList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   694  	i := len(dAtA)
   695  	_ = i
   696  	var l int
   697  	_ = l
   698  	if len(m.Items) > 0 {
   699  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   700  			{
   701  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   702  				if err != nil {
   703  					return 0, err
   704  				}
   705  				i -= size
   706  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   707  			}
   708  			i--
   709  			dAtA[i] = 0x12
   710  		}
   711  	}
   712  	{
   713  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   714  		if err != nil {
   715  			return 0, err
   716  		}
   717  		i -= size
   718  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   719  	}
   720  	i--
   721  	dAtA[i] = 0xa
   722  	return len(dAtA) - i, nil
   723  }
   724  
   725  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
   726  	offset -= sovGenerated(v)
   727  	base := offset
   728  	for v >= 1<<7 {
   729  		dAtA[offset] = uint8(v&0x7f | 0x80)
   730  		v >>= 7
   731  		offset++
   732  	}
   733  	dAtA[offset] = uint8(v)
   734  	return base
   735  }
   736  func (m *Group) Size() (n int) {
   737  	if m == nil {
   738  		return 0
   739  	}
   740  	var l int
   741  	_ = l
   742  	l = m.ObjectMeta.Size()
   743  	n += 1 + l + sovGenerated(uint64(l))
   744  	if m.Users != nil {
   745  		l = m.Users.Size()
   746  		n += 1 + l + sovGenerated(uint64(l))
   747  	}
   748  	return n
   749  }
   750  
   751  func (m *GroupList) Size() (n int) {
   752  	if m == nil {
   753  		return 0
   754  	}
   755  	var l int
   756  	_ = l
   757  	l = m.ListMeta.Size()
   758  	n += 1 + l + sovGenerated(uint64(l))
   759  	if len(m.Items) > 0 {
   760  		for _, e := range m.Items {
   761  			l = e.Size()
   762  			n += 1 + l + sovGenerated(uint64(l))
   763  		}
   764  	}
   765  	return n
   766  }
   767  
   768  func (m *Identity) Size() (n int) {
   769  	if m == nil {
   770  		return 0
   771  	}
   772  	var l int
   773  	_ = l
   774  	l = m.ObjectMeta.Size()
   775  	n += 1 + l + sovGenerated(uint64(l))
   776  	l = len(m.ProviderName)
   777  	n += 1 + l + sovGenerated(uint64(l))
   778  	l = len(m.ProviderUserName)
   779  	n += 1 + l + sovGenerated(uint64(l))
   780  	l = m.User.Size()
   781  	n += 1 + l + sovGenerated(uint64(l))
   782  	if len(m.Extra) > 0 {
   783  		for k, v := range m.Extra {
   784  			_ = k
   785  			_ = v
   786  			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
   787  			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
   788  		}
   789  	}
   790  	return n
   791  }
   792  
   793  func (m *IdentityList) Size() (n int) {
   794  	if m == nil {
   795  		return 0
   796  	}
   797  	var l int
   798  	_ = l
   799  	l = m.ListMeta.Size()
   800  	n += 1 + l + sovGenerated(uint64(l))
   801  	if len(m.Items) > 0 {
   802  		for _, e := range m.Items {
   803  			l = e.Size()
   804  			n += 1 + l + sovGenerated(uint64(l))
   805  		}
   806  	}
   807  	return n
   808  }
   809  
   810  func (m OptionalNames) Size() (n int) {
   811  	if m == nil {
   812  		return 0
   813  	}
   814  	var l int
   815  	_ = l
   816  	if len(m) > 0 {
   817  		for _, s := range m {
   818  			l = len(s)
   819  			n += 1 + l + sovGenerated(uint64(l))
   820  		}
   821  	}
   822  	return n
   823  }
   824  
   825  func (m *User) Size() (n int) {
   826  	if m == nil {
   827  		return 0
   828  	}
   829  	var l int
   830  	_ = l
   831  	l = m.ObjectMeta.Size()
   832  	n += 1 + l + sovGenerated(uint64(l))
   833  	l = len(m.FullName)
   834  	n += 1 + l + sovGenerated(uint64(l))
   835  	if len(m.Identities) > 0 {
   836  		for _, s := range m.Identities {
   837  			l = len(s)
   838  			n += 1 + l + sovGenerated(uint64(l))
   839  		}
   840  	}
   841  	if len(m.Groups) > 0 {
   842  		for _, s := range m.Groups {
   843  			l = len(s)
   844  			n += 1 + l + sovGenerated(uint64(l))
   845  		}
   846  	}
   847  	return n
   848  }
   849  
   850  func (m *UserIdentityMapping) Size() (n int) {
   851  	if m == nil {
   852  		return 0
   853  	}
   854  	var l int
   855  	_ = l
   856  	l = m.ObjectMeta.Size()
   857  	n += 1 + l + sovGenerated(uint64(l))
   858  	l = m.Identity.Size()
   859  	n += 1 + l + sovGenerated(uint64(l))
   860  	l = m.User.Size()
   861  	n += 1 + l + sovGenerated(uint64(l))
   862  	return n
   863  }
   864  
   865  func (m *UserList) Size() (n int) {
   866  	if m == nil {
   867  		return 0
   868  	}
   869  	var l int
   870  	_ = l
   871  	l = m.ListMeta.Size()
   872  	n += 1 + l + sovGenerated(uint64(l))
   873  	if len(m.Items) > 0 {
   874  		for _, e := range m.Items {
   875  			l = e.Size()
   876  			n += 1 + l + sovGenerated(uint64(l))
   877  		}
   878  	}
   879  	return n
   880  }
   881  
   882  func sovGenerated(x uint64) (n int) {
   883  	return (math_bits.Len64(x|1) + 6) / 7
   884  }
   885  func sozGenerated(x uint64) (n int) {
   886  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   887  }
   888  func (this *Group) String() string {
   889  	if this == nil {
   890  		return "nil"
   891  	}
   892  	s := strings.Join([]string{`&Group{`,
   893  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
   894  		`Users:` + strings.Replace(fmt.Sprintf("%v", this.Users), "OptionalNames", "OptionalNames", 1) + `,`,
   895  		`}`,
   896  	}, "")
   897  	return s
   898  }
   899  func (this *GroupList) String() string {
   900  	if this == nil {
   901  		return "nil"
   902  	}
   903  	repeatedStringForItems := "[]Group{"
   904  	for _, f := range this.Items {
   905  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Group", "Group", 1), `&`, ``, 1) + ","
   906  	}
   907  	repeatedStringForItems += "}"
   908  	s := strings.Join([]string{`&GroupList{`,
   909  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
   910  		`Items:` + repeatedStringForItems + `,`,
   911  		`}`,
   912  	}, "")
   913  	return s
   914  }
   915  func (this *Identity) String() string {
   916  	if this == nil {
   917  		return "nil"
   918  	}
   919  	keysForExtra := make([]string, 0, len(this.Extra))
   920  	for k := range this.Extra {
   921  		keysForExtra = append(keysForExtra, k)
   922  	}
   923  	github_com_gogo_protobuf_sortkeys.Strings(keysForExtra)
   924  	mapStringForExtra := "map[string]string{"
   925  	for _, k := range keysForExtra {
   926  		mapStringForExtra += fmt.Sprintf("%v: %v,", k, this.Extra[k])
   927  	}
   928  	mapStringForExtra += "}"
   929  	s := strings.Join([]string{`&Identity{`,
   930  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
   931  		`ProviderName:` + fmt.Sprintf("%v", this.ProviderName) + `,`,
   932  		`ProviderUserName:` + fmt.Sprintf("%v", this.ProviderUserName) + `,`,
   933  		`User:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.User), "ObjectReference", "v11.ObjectReference", 1), `&`, ``, 1) + `,`,
   934  		`Extra:` + mapStringForExtra + `,`,
   935  		`}`,
   936  	}, "")
   937  	return s
   938  }
   939  func (this *IdentityList) String() string {
   940  	if this == nil {
   941  		return "nil"
   942  	}
   943  	repeatedStringForItems := "[]Identity{"
   944  	for _, f := range this.Items {
   945  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Identity", "Identity", 1), `&`, ``, 1) + ","
   946  	}
   947  	repeatedStringForItems += "}"
   948  	s := strings.Join([]string{`&IdentityList{`,
   949  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
   950  		`Items:` + repeatedStringForItems + `,`,
   951  		`}`,
   952  	}, "")
   953  	return s
   954  }
   955  func (this *User) String() string {
   956  	if this == nil {
   957  		return "nil"
   958  	}
   959  	s := strings.Join([]string{`&User{`,
   960  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
   961  		`FullName:` + fmt.Sprintf("%v", this.FullName) + `,`,
   962  		`Identities:` + fmt.Sprintf("%v", this.Identities) + `,`,
   963  		`Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
   964  		`}`,
   965  	}, "")
   966  	return s
   967  }
   968  func (this *UserIdentityMapping) String() string {
   969  	if this == nil {
   970  		return "nil"
   971  	}
   972  	s := strings.Join([]string{`&UserIdentityMapping{`,
   973  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
   974  		`Identity:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Identity), "ObjectReference", "v11.ObjectReference", 1), `&`, ``, 1) + `,`,
   975  		`User:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.User), "ObjectReference", "v11.ObjectReference", 1), `&`, ``, 1) + `,`,
   976  		`}`,
   977  	}, "")
   978  	return s
   979  }
   980  func (this *UserList) String() string {
   981  	if this == nil {
   982  		return "nil"
   983  	}
   984  	repeatedStringForItems := "[]User{"
   985  	for _, f := range this.Items {
   986  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "User", "User", 1), `&`, ``, 1) + ","
   987  	}
   988  	repeatedStringForItems += "}"
   989  	s := strings.Join([]string{`&UserList{`,
   990  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
   991  		`Items:` + repeatedStringForItems + `,`,
   992  		`}`,
   993  	}, "")
   994  	return s
   995  }
   996  func valueToStringGenerated(v interface{}) string {
   997  	rv := reflect.ValueOf(v)
   998  	if rv.IsNil() {
   999  		return "nil"
  1000  	}
  1001  	pv := reflect.Indirect(rv).Interface()
  1002  	return fmt.Sprintf("*%v", pv)
  1003  }
  1004  func (m *Group) Unmarshal(dAtA []byte) error {
  1005  	l := len(dAtA)
  1006  	iNdEx := 0
  1007  	for iNdEx < l {
  1008  		preIndex := iNdEx
  1009  		var wire uint64
  1010  		for shift := uint(0); ; shift += 7 {
  1011  			if shift >= 64 {
  1012  				return ErrIntOverflowGenerated
  1013  			}
  1014  			if iNdEx >= l {
  1015  				return io.ErrUnexpectedEOF
  1016  			}
  1017  			b := dAtA[iNdEx]
  1018  			iNdEx++
  1019  			wire |= uint64(b&0x7F) << shift
  1020  			if b < 0x80 {
  1021  				break
  1022  			}
  1023  		}
  1024  		fieldNum := int32(wire >> 3)
  1025  		wireType := int(wire & 0x7)
  1026  		if wireType == 4 {
  1027  			return fmt.Errorf("proto: Group: wiretype end group for non-group")
  1028  		}
  1029  		if fieldNum <= 0 {
  1030  			return fmt.Errorf("proto: Group: illegal tag %d (wire type %d)", fieldNum, wire)
  1031  		}
  1032  		switch fieldNum {
  1033  		case 1:
  1034  			if wireType != 2 {
  1035  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1036  			}
  1037  			var msglen int
  1038  			for shift := uint(0); ; shift += 7 {
  1039  				if shift >= 64 {
  1040  					return ErrIntOverflowGenerated
  1041  				}
  1042  				if iNdEx >= l {
  1043  					return io.ErrUnexpectedEOF
  1044  				}
  1045  				b := dAtA[iNdEx]
  1046  				iNdEx++
  1047  				msglen |= int(b&0x7F) << shift
  1048  				if b < 0x80 {
  1049  					break
  1050  				}
  1051  			}
  1052  			if msglen < 0 {
  1053  				return ErrInvalidLengthGenerated
  1054  			}
  1055  			postIndex := iNdEx + msglen
  1056  			if postIndex < 0 {
  1057  				return ErrInvalidLengthGenerated
  1058  			}
  1059  			if postIndex > l {
  1060  				return io.ErrUnexpectedEOF
  1061  			}
  1062  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1063  				return err
  1064  			}
  1065  			iNdEx = postIndex
  1066  		case 2:
  1067  			if wireType != 2 {
  1068  				return fmt.Errorf("proto: wrong wireType = %d for field Users", wireType)
  1069  			}
  1070  			var msglen int
  1071  			for shift := uint(0); ; shift += 7 {
  1072  				if shift >= 64 {
  1073  					return ErrIntOverflowGenerated
  1074  				}
  1075  				if iNdEx >= l {
  1076  					return io.ErrUnexpectedEOF
  1077  				}
  1078  				b := dAtA[iNdEx]
  1079  				iNdEx++
  1080  				msglen |= int(b&0x7F) << shift
  1081  				if b < 0x80 {
  1082  					break
  1083  				}
  1084  			}
  1085  			if msglen < 0 {
  1086  				return ErrInvalidLengthGenerated
  1087  			}
  1088  			postIndex := iNdEx + msglen
  1089  			if postIndex < 0 {
  1090  				return ErrInvalidLengthGenerated
  1091  			}
  1092  			if postIndex > l {
  1093  				return io.ErrUnexpectedEOF
  1094  			}
  1095  			if m.Users == nil {
  1096  				m.Users = OptionalNames{}
  1097  			}
  1098  			if err := m.Users.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1099  				return err
  1100  			}
  1101  			iNdEx = postIndex
  1102  		default:
  1103  			iNdEx = preIndex
  1104  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1105  			if err != nil {
  1106  				return err
  1107  			}
  1108  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1109  				return ErrInvalidLengthGenerated
  1110  			}
  1111  			if (iNdEx + skippy) > l {
  1112  				return io.ErrUnexpectedEOF
  1113  			}
  1114  			iNdEx += skippy
  1115  		}
  1116  	}
  1117  
  1118  	if iNdEx > l {
  1119  		return io.ErrUnexpectedEOF
  1120  	}
  1121  	return nil
  1122  }
  1123  func (m *GroupList) Unmarshal(dAtA []byte) error {
  1124  	l := len(dAtA)
  1125  	iNdEx := 0
  1126  	for iNdEx < l {
  1127  		preIndex := iNdEx
  1128  		var wire uint64
  1129  		for shift := uint(0); ; shift += 7 {
  1130  			if shift >= 64 {
  1131  				return ErrIntOverflowGenerated
  1132  			}
  1133  			if iNdEx >= l {
  1134  				return io.ErrUnexpectedEOF
  1135  			}
  1136  			b := dAtA[iNdEx]
  1137  			iNdEx++
  1138  			wire |= uint64(b&0x7F) << shift
  1139  			if b < 0x80 {
  1140  				break
  1141  			}
  1142  		}
  1143  		fieldNum := int32(wire >> 3)
  1144  		wireType := int(wire & 0x7)
  1145  		if wireType == 4 {
  1146  			return fmt.Errorf("proto: GroupList: wiretype end group for non-group")
  1147  		}
  1148  		if fieldNum <= 0 {
  1149  			return fmt.Errorf("proto: GroupList: illegal tag %d (wire type %d)", fieldNum, wire)
  1150  		}
  1151  		switch fieldNum {
  1152  		case 1:
  1153  			if wireType != 2 {
  1154  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1155  			}
  1156  			var msglen int
  1157  			for shift := uint(0); ; shift += 7 {
  1158  				if shift >= 64 {
  1159  					return ErrIntOverflowGenerated
  1160  				}
  1161  				if iNdEx >= l {
  1162  					return io.ErrUnexpectedEOF
  1163  				}
  1164  				b := dAtA[iNdEx]
  1165  				iNdEx++
  1166  				msglen |= int(b&0x7F) << shift
  1167  				if b < 0x80 {
  1168  					break
  1169  				}
  1170  			}
  1171  			if msglen < 0 {
  1172  				return ErrInvalidLengthGenerated
  1173  			}
  1174  			postIndex := iNdEx + msglen
  1175  			if postIndex < 0 {
  1176  				return ErrInvalidLengthGenerated
  1177  			}
  1178  			if postIndex > l {
  1179  				return io.ErrUnexpectedEOF
  1180  			}
  1181  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1182  				return err
  1183  			}
  1184  			iNdEx = postIndex
  1185  		case 2:
  1186  			if wireType != 2 {
  1187  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1188  			}
  1189  			var msglen int
  1190  			for shift := uint(0); ; shift += 7 {
  1191  				if shift >= 64 {
  1192  					return ErrIntOverflowGenerated
  1193  				}
  1194  				if iNdEx >= l {
  1195  					return io.ErrUnexpectedEOF
  1196  				}
  1197  				b := dAtA[iNdEx]
  1198  				iNdEx++
  1199  				msglen |= int(b&0x7F) << shift
  1200  				if b < 0x80 {
  1201  					break
  1202  				}
  1203  			}
  1204  			if msglen < 0 {
  1205  				return ErrInvalidLengthGenerated
  1206  			}
  1207  			postIndex := iNdEx + msglen
  1208  			if postIndex < 0 {
  1209  				return ErrInvalidLengthGenerated
  1210  			}
  1211  			if postIndex > l {
  1212  				return io.ErrUnexpectedEOF
  1213  			}
  1214  			m.Items = append(m.Items, Group{})
  1215  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1216  				return err
  1217  			}
  1218  			iNdEx = postIndex
  1219  		default:
  1220  			iNdEx = preIndex
  1221  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1222  			if err != nil {
  1223  				return err
  1224  			}
  1225  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1226  				return ErrInvalidLengthGenerated
  1227  			}
  1228  			if (iNdEx + skippy) > l {
  1229  				return io.ErrUnexpectedEOF
  1230  			}
  1231  			iNdEx += skippy
  1232  		}
  1233  	}
  1234  
  1235  	if iNdEx > l {
  1236  		return io.ErrUnexpectedEOF
  1237  	}
  1238  	return nil
  1239  }
  1240  func (m *Identity) Unmarshal(dAtA []byte) error {
  1241  	l := len(dAtA)
  1242  	iNdEx := 0
  1243  	for iNdEx < l {
  1244  		preIndex := iNdEx
  1245  		var wire uint64
  1246  		for shift := uint(0); ; shift += 7 {
  1247  			if shift >= 64 {
  1248  				return ErrIntOverflowGenerated
  1249  			}
  1250  			if iNdEx >= l {
  1251  				return io.ErrUnexpectedEOF
  1252  			}
  1253  			b := dAtA[iNdEx]
  1254  			iNdEx++
  1255  			wire |= uint64(b&0x7F) << shift
  1256  			if b < 0x80 {
  1257  				break
  1258  			}
  1259  		}
  1260  		fieldNum := int32(wire >> 3)
  1261  		wireType := int(wire & 0x7)
  1262  		if wireType == 4 {
  1263  			return fmt.Errorf("proto: Identity: wiretype end group for non-group")
  1264  		}
  1265  		if fieldNum <= 0 {
  1266  			return fmt.Errorf("proto: Identity: illegal tag %d (wire type %d)", fieldNum, wire)
  1267  		}
  1268  		switch fieldNum {
  1269  		case 1:
  1270  			if wireType != 2 {
  1271  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1272  			}
  1273  			var msglen int
  1274  			for shift := uint(0); ; shift += 7 {
  1275  				if shift >= 64 {
  1276  					return ErrIntOverflowGenerated
  1277  				}
  1278  				if iNdEx >= l {
  1279  					return io.ErrUnexpectedEOF
  1280  				}
  1281  				b := dAtA[iNdEx]
  1282  				iNdEx++
  1283  				msglen |= int(b&0x7F) << shift
  1284  				if b < 0x80 {
  1285  					break
  1286  				}
  1287  			}
  1288  			if msglen < 0 {
  1289  				return ErrInvalidLengthGenerated
  1290  			}
  1291  			postIndex := iNdEx + msglen
  1292  			if postIndex < 0 {
  1293  				return ErrInvalidLengthGenerated
  1294  			}
  1295  			if postIndex > l {
  1296  				return io.ErrUnexpectedEOF
  1297  			}
  1298  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1299  				return err
  1300  			}
  1301  			iNdEx = postIndex
  1302  		case 2:
  1303  			if wireType != 2 {
  1304  				return fmt.Errorf("proto: wrong wireType = %d for field ProviderName", wireType)
  1305  			}
  1306  			var stringLen uint64
  1307  			for shift := uint(0); ; shift += 7 {
  1308  				if shift >= 64 {
  1309  					return ErrIntOverflowGenerated
  1310  				}
  1311  				if iNdEx >= l {
  1312  					return io.ErrUnexpectedEOF
  1313  				}
  1314  				b := dAtA[iNdEx]
  1315  				iNdEx++
  1316  				stringLen |= uint64(b&0x7F) << shift
  1317  				if b < 0x80 {
  1318  					break
  1319  				}
  1320  			}
  1321  			intStringLen := int(stringLen)
  1322  			if intStringLen < 0 {
  1323  				return ErrInvalidLengthGenerated
  1324  			}
  1325  			postIndex := iNdEx + intStringLen
  1326  			if postIndex < 0 {
  1327  				return ErrInvalidLengthGenerated
  1328  			}
  1329  			if postIndex > l {
  1330  				return io.ErrUnexpectedEOF
  1331  			}
  1332  			m.ProviderName = string(dAtA[iNdEx:postIndex])
  1333  			iNdEx = postIndex
  1334  		case 3:
  1335  			if wireType != 2 {
  1336  				return fmt.Errorf("proto: wrong wireType = %d for field ProviderUserName", wireType)
  1337  			}
  1338  			var stringLen uint64
  1339  			for shift := uint(0); ; shift += 7 {
  1340  				if shift >= 64 {
  1341  					return ErrIntOverflowGenerated
  1342  				}
  1343  				if iNdEx >= l {
  1344  					return io.ErrUnexpectedEOF
  1345  				}
  1346  				b := dAtA[iNdEx]
  1347  				iNdEx++
  1348  				stringLen |= uint64(b&0x7F) << shift
  1349  				if b < 0x80 {
  1350  					break
  1351  				}
  1352  			}
  1353  			intStringLen := int(stringLen)
  1354  			if intStringLen < 0 {
  1355  				return ErrInvalidLengthGenerated
  1356  			}
  1357  			postIndex := iNdEx + intStringLen
  1358  			if postIndex < 0 {
  1359  				return ErrInvalidLengthGenerated
  1360  			}
  1361  			if postIndex > l {
  1362  				return io.ErrUnexpectedEOF
  1363  			}
  1364  			m.ProviderUserName = string(dAtA[iNdEx:postIndex])
  1365  			iNdEx = postIndex
  1366  		case 4:
  1367  			if wireType != 2 {
  1368  				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
  1369  			}
  1370  			var msglen int
  1371  			for shift := uint(0); ; shift += 7 {
  1372  				if shift >= 64 {
  1373  					return ErrIntOverflowGenerated
  1374  				}
  1375  				if iNdEx >= l {
  1376  					return io.ErrUnexpectedEOF
  1377  				}
  1378  				b := dAtA[iNdEx]
  1379  				iNdEx++
  1380  				msglen |= int(b&0x7F) << shift
  1381  				if b < 0x80 {
  1382  					break
  1383  				}
  1384  			}
  1385  			if msglen < 0 {
  1386  				return ErrInvalidLengthGenerated
  1387  			}
  1388  			postIndex := iNdEx + msglen
  1389  			if postIndex < 0 {
  1390  				return ErrInvalidLengthGenerated
  1391  			}
  1392  			if postIndex > l {
  1393  				return io.ErrUnexpectedEOF
  1394  			}
  1395  			if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1396  				return err
  1397  			}
  1398  			iNdEx = postIndex
  1399  		case 5:
  1400  			if wireType != 2 {
  1401  				return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
  1402  			}
  1403  			var msglen int
  1404  			for shift := uint(0); ; shift += 7 {
  1405  				if shift >= 64 {
  1406  					return ErrIntOverflowGenerated
  1407  				}
  1408  				if iNdEx >= l {
  1409  					return io.ErrUnexpectedEOF
  1410  				}
  1411  				b := dAtA[iNdEx]
  1412  				iNdEx++
  1413  				msglen |= int(b&0x7F) << shift
  1414  				if b < 0x80 {
  1415  					break
  1416  				}
  1417  			}
  1418  			if msglen < 0 {
  1419  				return ErrInvalidLengthGenerated
  1420  			}
  1421  			postIndex := iNdEx + msglen
  1422  			if postIndex < 0 {
  1423  				return ErrInvalidLengthGenerated
  1424  			}
  1425  			if postIndex > l {
  1426  				return io.ErrUnexpectedEOF
  1427  			}
  1428  			if m.Extra == nil {
  1429  				m.Extra = make(map[string]string)
  1430  			}
  1431  			var mapkey string
  1432  			var mapvalue string
  1433  			for iNdEx < postIndex {
  1434  				entryPreIndex := iNdEx
  1435  				var wire uint64
  1436  				for shift := uint(0); ; shift += 7 {
  1437  					if shift >= 64 {
  1438  						return ErrIntOverflowGenerated
  1439  					}
  1440  					if iNdEx >= l {
  1441  						return io.ErrUnexpectedEOF
  1442  					}
  1443  					b := dAtA[iNdEx]
  1444  					iNdEx++
  1445  					wire |= uint64(b&0x7F) << shift
  1446  					if b < 0x80 {
  1447  						break
  1448  					}
  1449  				}
  1450  				fieldNum := int32(wire >> 3)
  1451  				if fieldNum == 1 {
  1452  					var stringLenmapkey uint64
  1453  					for shift := uint(0); ; shift += 7 {
  1454  						if shift >= 64 {
  1455  							return ErrIntOverflowGenerated
  1456  						}
  1457  						if iNdEx >= l {
  1458  							return io.ErrUnexpectedEOF
  1459  						}
  1460  						b := dAtA[iNdEx]
  1461  						iNdEx++
  1462  						stringLenmapkey |= uint64(b&0x7F) << shift
  1463  						if b < 0x80 {
  1464  							break
  1465  						}
  1466  					}
  1467  					intStringLenmapkey := int(stringLenmapkey)
  1468  					if intStringLenmapkey < 0 {
  1469  						return ErrInvalidLengthGenerated
  1470  					}
  1471  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  1472  					if postStringIndexmapkey < 0 {
  1473  						return ErrInvalidLengthGenerated
  1474  					}
  1475  					if postStringIndexmapkey > l {
  1476  						return io.ErrUnexpectedEOF
  1477  					}
  1478  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  1479  					iNdEx = postStringIndexmapkey
  1480  				} else if fieldNum == 2 {
  1481  					var stringLenmapvalue uint64
  1482  					for shift := uint(0); ; shift += 7 {
  1483  						if shift >= 64 {
  1484  							return ErrIntOverflowGenerated
  1485  						}
  1486  						if iNdEx >= l {
  1487  							return io.ErrUnexpectedEOF
  1488  						}
  1489  						b := dAtA[iNdEx]
  1490  						iNdEx++
  1491  						stringLenmapvalue |= uint64(b&0x7F) << shift
  1492  						if b < 0x80 {
  1493  							break
  1494  						}
  1495  					}
  1496  					intStringLenmapvalue := int(stringLenmapvalue)
  1497  					if intStringLenmapvalue < 0 {
  1498  						return ErrInvalidLengthGenerated
  1499  					}
  1500  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  1501  					if postStringIndexmapvalue < 0 {
  1502  						return ErrInvalidLengthGenerated
  1503  					}
  1504  					if postStringIndexmapvalue > l {
  1505  						return io.ErrUnexpectedEOF
  1506  					}
  1507  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  1508  					iNdEx = postStringIndexmapvalue
  1509  				} else {
  1510  					iNdEx = entryPreIndex
  1511  					skippy, err := skipGenerated(dAtA[iNdEx:])
  1512  					if err != nil {
  1513  						return err
  1514  					}
  1515  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  1516  						return ErrInvalidLengthGenerated
  1517  					}
  1518  					if (iNdEx + skippy) > postIndex {
  1519  						return io.ErrUnexpectedEOF
  1520  					}
  1521  					iNdEx += skippy
  1522  				}
  1523  			}
  1524  			m.Extra[mapkey] = mapvalue
  1525  			iNdEx = postIndex
  1526  		default:
  1527  			iNdEx = preIndex
  1528  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1529  			if err != nil {
  1530  				return err
  1531  			}
  1532  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1533  				return ErrInvalidLengthGenerated
  1534  			}
  1535  			if (iNdEx + skippy) > l {
  1536  				return io.ErrUnexpectedEOF
  1537  			}
  1538  			iNdEx += skippy
  1539  		}
  1540  	}
  1541  
  1542  	if iNdEx > l {
  1543  		return io.ErrUnexpectedEOF
  1544  	}
  1545  	return nil
  1546  }
  1547  func (m *IdentityList) Unmarshal(dAtA []byte) error {
  1548  	l := len(dAtA)
  1549  	iNdEx := 0
  1550  	for iNdEx < l {
  1551  		preIndex := iNdEx
  1552  		var wire uint64
  1553  		for shift := uint(0); ; shift += 7 {
  1554  			if shift >= 64 {
  1555  				return ErrIntOverflowGenerated
  1556  			}
  1557  			if iNdEx >= l {
  1558  				return io.ErrUnexpectedEOF
  1559  			}
  1560  			b := dAtA[iNdEx]
  1561  			iNdEx++
  1562  			wire |= uint64(b&0x7F) << shift
  1563  			if b < 0x80 {
  1564  				break
  1565  			}
  1566  		}
  1567  		fieldNum := int32(wire >> 3)
  1568  		wireType := int(wire & 0x7)
  1569  		if wireType == 4 {
  1570  			return fmt.Errorf("proto: IdentityList: wiretype end group for non-group")
  1571  		}
  1572  		if fieldNum <= 0 {
  1573  			return fmt.Errorf("proto: IdentityList: illegal tag %d (wire type %d)", fieldNum, wire)
  1574  		}
  1575  		switch fieldNum {
  1576  		case 1:
  1577  			if wireType != 2 {
  1578  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1579  			}
  1580  			var msglen int
  1581  			for shift := uint(0); ; shift += 7 {
  1582  				if shift >= 64 {
  1583  					return ErrIntOverflowGenerated
  1584  				}
  1585  				if iNdEx >= l {
  1586  					return io.ErrUnexpectedEOF
  1587  				}
  1588  				b := dAtA[iNdEx]
  1589  				iNdEx++
  1590  				msglen |= int(b&0x7F) << shift
  1591  				if b < 0x80 {
  1592  					break
  1593  				}
  1594  			}
  1595  			if msglen < 0 {
  1596  				return ErrInvalidLengthGenerated
  1597  			}
  1598  			postIndex := iNdEx + msglen
  1599  			if postIndex < 0 {
  1600  				return ErrInvalidLengthGenerated
  1601  			}
  1602  			if postIndex > l {
  1603  				return io.ErrUnexpectedEOF
  1604  			}
  1605  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1606  				return err
  1607  			}
  1608  			iNdEx = postIndex
  1609  		case 2:
  1610  			if wireType != 2 {
  1611  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1612  			}
  1613  			var msglen int
  1614  			for shift := uint(0); ; shift += 7 {
  1615  				if shift >= 64 {
  1616  					return ErrIntOverflowGenerated
  1617  				}
  1618  				if iNdEx >= l {
  1619  					return io.ErrUnexpectedEOF
  1620  				}
  1621  				b := dAtA[iNdEx]
  1622  				iNdEx++
  1623  				msglen |= int(b&0x7F) << shift
  1624  				if b < 0x80 {
  1625  					break
  1626  				}
  1627  			}
  1628  			if msglen < 0 {
  1629  				return ErrInvalidLengthGenerated
  1630  			}
  1631  			postIndex := iNdEx + msglen
  1632  			if postIndex < 0 {
  1633  				return ErrInvalidLengthGenerated
  1634  			}
  1635  			if postIndex > l {
  1636  				return io.ErrUnexpectedEOF
  1637  			}
  1638  			m.Items = append(m.Items, Identity{})
  1639  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1640  				return err
  1641  			}
  1642  			iNdEx = postIndex
  1643  		default:
  1644  			iNdEx = preIndex
  1645  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1646  			if err != nil {
  1647  				return err
  1648  			}
  1649  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1650  				return ErrInvalidLengthGenerated
  1651  			}
  1652  			if (iNdEx + skippy) > l {
  1653  				return io.ErrUnexpectedEOF
  1654  			}
  1655  			iNdEx += skippy
  1656  		}
  1657  	}
  1658  
  1659  	if iNdEx > l {
  1660  		return io.ErrUnexpectedEOF
  1661  	}
  1662  	return nil
  1663  }
  1664  func (m *OptionalNames) Unmarshal(dAtA []byte) error {
  1665  	l := len(dAtA)
  1666  	iNdEx := 0
  1667  	for iNdEx < l {
  1668  		preIndex := iNdEx
  1669  		var wire uint64
  1670  		for shift := uint(0); ; shift += 7 {
  1671  			if shift >= 64 {
  1672  				return ErrIntOverflowGenerated
  1673  			}
  1674  			if iNdEx >= l {
  1675  				return io.ErrUnexpectedEOF
  1676  			}
  1677  			b := dAtA[iNdEx]
  1678  			iNdEx++
  1679  			wire |= uint64(b&0x7F) << shift
  1680  			if b < 0x80 {
  1681  				break
  1682  			}
  1683  		}
  1684  		fieldNum := int32(wire >> 3)
  1685  		wireType := int(wire & 0x7)
  1686  		if wireType == 4 {
  1687  			return fmt.Errorf("proto: OptionalNames: wiretype end group for non-group")
  1688  		}
  1689  		if fieldNum <= 0 {
  1690  			return fmt.Errorf("proto: OptionalNames: illegal tag %d (wire type %d)", fieldNum, wire)
  1691  		}
  1692  		switch fieldNum {
  1693  		case 1:
  1694  			if wireType != 2 {
  1695  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1696  			}
  1697  			var stringLen uint64
  1698  			for shift := uint(0); ; shift += 7 {
  1699  				if shift >= 64 {
  1700  					return ErrIntOverflowGenerated
  1701  				}
  1702  				if iNdEx >= l {
  1703  					return io.ErrUnexpectedEOF
  1704  				}
  1705  				b := dAtA[iNdEx]
  1706  				iNdEx++
  1707  				stringLen |= uint64(b&0x7F) << shift
  1708  				if b < 0x80 {
  1709  					break
  1710  				}
  1711  			}
  1712  			intStringLen := int(stringLen)
  1713  			if intStringLen < 0 {
  1714  				return ErrInvalidLengthGenerated
  1715  			}
  1716  			postIndex := iNdEx + intStringLen
  1717  			if postIndex < 0 {
  1718  				return ErrInvalidLengthGenerated
  1719  			}
  1720  			if postIndex > l {
  1721  				return io.ErrUnexpectedEOF
  1722  			}
  1723  			*m = append(*m, string(dAtA[iNdEx:postIndex]))
  1724  			iNdEx = postIndex
  1725  		default:
  1726  			iNdEx = preIndex
  1727  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1728  			if err != nil {
  1729  				return err
  1730  			}
  1731  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1732  				return ErrInvalidLengthGenerated
  1733  			}
  1734  			if (iNdEx + skippy) > l {
  1735  				return io.ErrUnexpectedEOF
  1736  			}
  1737  			iNdEx += skippy
  1738  		}
  1739  	}
  1740  
  1741  	if iNdEx > l {
  1742  		return io.ErrUnexpectedEOF
  1743  	}
  1744  	return nil
  1745  }
  1746  func (m *User) Unmarshal(dAtA []byte) error {
  1747  	l := len(dAtA)
  1748  	iNdEx := 0
  1749  	for iNdEx < l {
  1750  		preIndex := iNdEx
  1751  		var wire uint64
  1752  		for shift := uint(0); ; shift += 7 {
  1753  			if shift >= 64 {
  1754  				return ErrIntOverflowGenerated
  1755  			}
  1756  			if iNdEx >= l {
  1757  				return io.ErrUnexpectedEOF
  1758  			}
  1759  			b := dAtA[iNdEx]
  1760  			iNdEx++
  1761  			wire |= uint64(b&0x7F) << shift
  1762  			if b < 0x80 {
  1763  				break
  1764  			}
  1765  		}
  1766  		fieldNum := int32(wire >> 3)
  1767  		wireType := int(wire & 0x7)
  1768  		if wireType == 4 {
  1769  			return fmt.Errorf("proto: User: wiretype end group for non-group")
  1770  		}
  1771  		if fieldNum <= 0 {
  1772  			return fmt.Errorf("proto: User: illegal tag %d (wire type %d)", fieldNum, wire)
  1773  		}
  1774  		switch fieldNum {
  1775  		case 1:
  1776  			if wireType != 2 {
  1777  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1778  			}
  1779  			var msglen int
  1780  			for shift := uint(0); ; shift += 7 {
  1781  				if shift >= 64 {
  1782  					return ErrIntOverflowGenerated
  1783  				}
  1784  				if iNdEx >= l {
  1785  					return io.ErrUnexpectedEOF
  1786  				}
  1787  				b := dAtA[iNdEx]
  1788  				iNdEx++
  1789  				msglen |= int(b&0x7F) << shift
  1790  				if b < 0x80 {
  1791  					break
  1792  				}
  1793  			}
  1794  			if msglen < 0 {
  1795  				return ErrInvalidLengthGenerated
  1796  			}
  1797  			postIndex := iNdEx + msglen
  1798  			if postIndex < 0 {
  1799  				return ErrInvalidLengthGenerated
  1800  			}
  1801  			if postIndex > l {
  1802  				return io.ErrUnexpectedEOF
  1803  			}
  1804  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1805  				return err
  1806  			}
  1807  			iNdEx = postIndex
  1808  		case 2:
  1809  			if wireType != 2 {
  1810  				return fmt.Errorf("proto: wrong wireType = %d for field FullName", wireType)
  1811  			}
  1812  			var stringLen uint64
  1813  			for shift := uint(0); ; shift += 7 {
  1814  				if shift >= 64 {
  1815  					return ErrIntOverflowGenerated
  1816  				}
  1817  				if iNdEx >= l {
  1818  					return io.ErrUnexpectedEOF
  1819  				}
  1820  				b := dAtA[iNdEx]
  1821  				iNdEx++
  1822  				stringLen |= uint64(b&0x7F) << shift
  1823  				if b < 0x80 {
  1824  					break
  1825  				}
  1826  			}
  1827  			intStringLen := int(stringLen)
  1828  			if intStringLen < 0 {
  1829  				return ErrInvalidLengthGenerated
  1830  			}
  1831  			postIndex := iNdEx + intStringLen
  1832  			if postIndex < 0 {
  1833  				return ErrInvalidLengthGenerated
  1834  			}
  1835  			if postIndex > l {
  1836  				return io.ErrUnexpectedEOF
  1837  			}
  1838  			m.FullName = string(dAtA[iNdEx:postIndex])
  1839  			iNdEx = postIndex
  1840  		case 3:
  1841  			if wireType != 2 {
  1842  				return fmt.Errorf("proto: wrong wireType = %d for field Identities", wireType)
  1843  			}
  1844  			var stringLen uint64
  1845  			for shift := uint(0); ; shift += 7 {
  1846  				if shift >= 64 {
  1847  					return ErrIntOverflowGenerated
  1848  				}
  1849  				if iNdEx >= l {
  1850  					return io.ErrUnexpectedEOF
  1851  				}
  1852  				b := dAtA[iNdEx]
  1853  				iNdEx++
  1854  				stringLen |= uint64(b&0x7F) << shift
  1855  				if b < 0x80 {
  1856  					break
  1857  				}
  1858  			}
  1859  			intStringLen := int(stringLen)
  1860  			if intStringLen < 0 {
  1861  				return ErrInvalidLengthGenerated
  1862  			}
  1863  			postIndex := iNdEx + intStringLen
  1864  			if postIndex < 0 {
  1865  				return ErrInvalidLengthGenerated
  1866  			}
  1867  			if postIndex > l {
  1868  				return io.ErrUnexpectedEOF
  1869  			}
  1870  			m.Identities = append(m.Identities, string(dAtA[iNdEx:postIndex]))
  1871  			iNdEx = postIndex
  1872  		case 4:
  1873  			if wireType != 2 {
  1874  				return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
  1875  			}
  1876  			var stringLen uint64
  1877  			for shift := uint(0); ; shift += 7 {
  1878  				if shift >= 64 {
  1879  					return ErrIntOverflowGenerated
  1880  				}
  1881  				if iNdEx >= l {
  1882  					return io.ErrUnexpectedEOF
  1883  				}
  1884  				b := dAtA[iNdEx]
  1885  				iNdEx++
  1886  				stringLen |= uint64(b&0x7F) << shift
  1887  				if b < 0x80 {
  1888  					break
  1889  				}
  1890  			}
  1891  			intStringLen := int(stringLen)
  1892  			if intStringLen < 0 {
  1893  				return ErrInvalidLengthGenerated
  1894  			}
  1895  			postIndex := iNdEx + intStringLen
  1896  			if postIndex < 0 {
  1897  				return ErrInvalidLengthGenerated
  1898  			}
  1899  			if postIndex > l {
  1900  				return io.ErrUnexpectedEOF
  1901  			}
  1902  			m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
  1903  			iNdEx = postIndex
  1904  		default:
  1905  			iNdEx = preIndex
  1906  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1907  			if err != nil {
  1908  				return err
  1909  			}
  1910  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1911  				return ErrInvalidLengthGenerated
  1912  			}
  1913  			if (iNdEx + skippy) > l {
  1914  				return io.ErrUnexpectedEOF
  1915  			}
  1916  			iNdEx += skippy
  1917  		}
  1918  	}
  1919  
  1920  	if iNdEx > l {
  1921  		return io.ErrUnexpectedEOF
  1922  	}
  1923  	return nil
  1924  }
  1925  func (m *UserIdentityMapping) Unmarshal(dAtA []byte) error {
  1926  	l := len(dAtA)
  1927  	iNdEx := 0
  1928  	for iNdEx < l {
  1929  		preIndex := iNdEx
  1930  		var wire uint64
  1931  		for shift := uint(0); ; shift += 7 {
  1932  			if shift >= 64 {
  1933  				return ErrIntOverflowGenerated
  1934  			}
  1935  			if iNdEx >= l {
  1936  				return io.ErrUnexpectedEOF
  1937  			}
  1938  			b := dAtA[iNdEx]
  1939  			iNdEx++
  1940  			wire |= uint64(b&0x7F) << shift
  1941  			if b < 0x80 {
  1942  				break
  1943  			}
  1944  		}
  1945  		fieldNum := int32(wire >> 3)
  1946  		wireType := int(wire & 0x7)
  1947  		if wireType == 4 {
  1948  			return fmt.Errorf("proto: UserIdentityMapping: wiretype end group for non-group")
  1949  		}
  1950  		if fieldNum <= 0 {
  1951  			return fmt.Errorf("proto: UserIdentityMapping: illegal tag %d (wire type %d)", fieldNum, wire)
  1952  		}
  1953  		switch fieldNum {
  1954  		case 1:
  1955  			if wireType != 2 {
  1956  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1957  			}
  1958  			var msglen int
  1959  			for shift := uint(0); ; shift += 7 {
  1960  				if shift >= 64 {
  1961  					return ErrIntOverflowGenerated
  1962  				}
  1963  				if iNdEx >= l {
  1964  					return io.ErrUnexpectedEOF
  1965  				}
  1966  				b := dAtA[iNdEx]
  1967  				iNdEx++
  1968  				msglen |= int(b&0x7F) << shift
  1969  				if b < 0x80 {
  1970  					break
  1971  				}
  1972  			}
  1973  			if msglen < 0 {
  1974  				return ErrInvalidLengthGenerated
  1975  			}
  1976  			postIndex := iNdEx + msglen
  1977  			if postIndex < 0 {
  1978  				return ErrInvalidLengthGenerated
  1979  			}
  1980  			if postIndex > l {
  1981  				return io.ErrUnexpectedEOF
  1982  			}
  1983  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1984  				return err
  1985  			}
  1986  			iNdEx = postIndex
  1987  		case 2:
  1988  			if wireType != 2 {
  1989  				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
  1990  			}
  1991  			var msglen int
  1992  			for shift := uint(0); ; shift += 7 {
  1993  				if shift >= 64 {
  1994  					return ErrIntOverflowGenerated
  1995  				}
  1996  				if iNdEx >= l {
  1997  					return io.ErrUnexpectedEOF
  1998  				}
  1999  				b := dAtA[iNdEx]
  2000  				iNdEx++
  2001  				msglen |= int(b&0x7F) << shift
  2002  				if b < 0x80 {
  2003  					break
  2004  				}
  2005  			}
  2006  			if msglen < 0 {
  2007  				return ErrInvalidLengthGenerated
  2008  			}
  2009  			postIndex := iNdEx + msglen
  2010  			if postIndex < 0 {
  2011  				return ErrInvalidLengthGenerated
  2012  			}
  2013  			if postIndex > l {
  2014  				return io.ErrUnexpectedEOF
  2015  			}
  2016  			if err := m.Identity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2017  				return err
  2018  			}
  2019  			iNdEx = postIndex
  2020  		case 3:
  2021  			if wireType != 2 {
  2022  				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
  2023  			}
  2024  			var msglen int
  2025  			for shift := uint(0); ; shift += 7 {
  2026  				if shift >= 64 {
  2027  					return ErrIntOverflowGenerated
  2028  				}
  2029  				if iNdEx >= l {
  2030  					return io.ErrUnexpectedEOF
  2031  				}
  2032  				b := dAtA[iNdEx]
  2033  				iNdEx++
  2034  				msglen |= int(b&0x7F) << shift
  2035  				if b < 0x80 {
  2036  					break
  2037  				}
  2038  			}
  2039  			if msglen < 0 {
  2040  				return ErrInvalidLengthGenerated
  2041  			}
  2042  			postIndex := iNdEx + msglen
  2043  			if postIndex < 0 {
  2044  				return ErrInvalidLengthGenerated
  2045  			}
  2046  			if postIndex > l {
  2047  				return io.ErrUnexpectedEOF
  2048  			}
  2049  			if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2050  				return err
  2051  			}
  2052  			iNdEx = postIndex
  2053  		default:
  2054  			iNdEx = preIndex
  2055  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2056  			if err != nil {
  2057  				return err
  2058  			}
  2059  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2060  				return ErrInvalidLengthGenerated
  2061  			}
  2062  			if (iNdEx + skippy) > l {
  2063  				return io.ErrUnexpectedEOF
  2064  			}
  2065  			iNdEx += skippy
  2066  		}
  2067  	}
  2068  
  2069  	if iNdEx > l {
  2070  		return io.ErrUnexpectedEOF
  2071  	}
  2072  	return nil
  2073  }
  2074  func (m *UserList) Unmarshal(dAtA []byte) error {
  2075  	l := len(dAtA)
  2076  	iNdEx := 0
  2077  	for iNdEx < l {
  2078  		preIndex := iNdEx
  2079  		var wire uint64
  2080  		for shift := uint(0); ; shift += 7 {
  2081  			if shift >= 64 {
  2082  				return ErrIntOverflowGenerated
  2083  			}
  2084  			if iNdEx >= l {
  2085  				return io.ErrUnexpectedEOF
  2086  			}
  2087  			b := dAtA[iNdEx]
  2088  			iNdEx++
  2089  			wire |= uint64(b&0x7F) << shift
  2090  			if b < 0x80 {
  2091  				break
  2092  			}
  2093  		}
  2094  		fieldNum := int32(wire >> 3)
  2095  		wireType := int(wire & 0x7)
  2096  		if wireType == 4 {
  2097  			return fmt.Errorf("proto: UserList: wiretype end group for non-group")
  2098  		}
  2099  		if fieldNum <= 0 {
  2100  			return fmt.Errorf("proto: UserList: illegal tag %d (wire type %d)", fieldNum, wire)
  2101  		}
  2102  		switch fieldNum {
  2103  		case 1:
  2104  			if wireType != 2 {
  2105  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  2106  			}
  2107  			var msglen int
  2108  			for shift := uint(0); ; shift += 7 {
  2109  				if shift >= 64 {
  2110  					return ErrIntOverflowGenerated
  2111  				}
  2112  				if iNdEx >= l {
  2113  					return io.ErrUnexpectedEOF
  2114  				}
  2115  				b := dAtA[iNdEx]
  2116  				iNdEx++
  2117  				msglen |= int(b&0x7F) << shift
  2118  				if b < 0x80 {
  2119  					break
  2120  				}
  2121  			}
  2122  			if msglen < 0 {
  2123  				return ErrInvalidLengthGenerated
  2124  			}
  2125  			postIndex := iNdEx + msglen
  2126  			if postIndex < 0 {
  2127  				return ErrInvalidLengthGenerated
  2128  			}
  2129  			if postIndex > l {
  2130  				return io.ErrUnexpectedEOF
  2131  			}
  2132  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2133  				return err
  2134  			}
  2135  			iNdEx = postIndex
  2136  		case 2:
  2137  			if wireType != 2 {
  2138  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  2139  			}
  2140  			var msglen int
  2141  			for shift := uint(0); ; shift += 7 {
  2142  				if shift >= 64 {
  2143  					return ErrIntOverflowGenerated
  2144  				}
  2145  				if iNdEx >= l {
  2146  					return io.ErrUnexpectedEOF
  2147  				}
  2148  				b := dAtA[iNdEx]
  2149  				iNdEx++
  2150  				msglen |= int(b&0x7F) << shift
  2151  				if b < 0x80 {
  2152  					break
  2153  				}
  2154  			}
  2155  			if msglen < 0 {
  2156  				return ErrInvalidLengthGenerated
  2157  			}
  2158  			postIndex := iNdEx + msglen
  2159  			if postIndex < 0 {
  2160  				return ErrInvalidLengthGenerated
  2161  			}
  2162  			if postIndex > l {
  2163  				return io.ErrUnexpectedEOF
  2164  			}
  2165  			m.Items = append(m.Items, User{})
  2166  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2167  				return err
  2168  			}
  2169  			iNdEx = postIndex
  2170  		default:
  2171  			iNdEx = preIndex
  2172  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2173  			if err != nil {
  2174  				return err
  2175  			}
  2176  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2177  				return ErrInvalidLengthGenerated
  2178  			}
  2179  			if (iNdEx + skippy) > l {
  2180  				return io.ErrUnexpectedEOF
  2181  			}
  2182  			iNdEx += skippy
  2183  		}
  2184  	}
  2185  
  2186  	if iNdEx > l {
  2187  		return io.ErrUnexpectedEOF
  2188  	}
  2189  	return nil
  2190  }
  2191  func skipGenerated(dAtA []byte) (n int, err error) {
  2192  	l := len(dAtA)
  2193  	iNdEx := 0
  2194  	depth := 0
  2195  	for iNdEx < l {
  2196  		var wire uint64
  2197  		for shift := uint(0); ; shift += 7 {
  2198  			if shift >= 64 {
  2199  				return 0, ErrIntOverflowGenerated
  2200  			}
  2201  			if iNdEx >= l {
  2202  				return 0, io.ErrUnexpectedEOF
  2203  			}
  2204  			b := dAtA[iNdEx]
  2205  			iNdEx++
  2206  			wire |= (uint64(b) & 0x7F) << shift
  2207  			if b < 0x80 {
  2208  				break
  2209  			}
  2210  		}
  2211  		wireType := int(wire & 0x7)
  2212  		switch wireType {
  2213  		case 0:
  2214  			for shift := uint(0); ; shift += 7 {
  2215  				if shift >= 64 {
  2216  					return 0, ErrIntOverflowGenerated
  2217  				}
  2218  				if iNdEx >= l {
  2219  					return 0, io.ErrUnexpectedEOF
  2220  				}
  2221  				iNdEx++
  2222  				if dAtA[iNdEx-1] < 0x80 {
  2223  					break
  2224  				}
  2225  			}
  2226  		case 1:
  2227  			iNdEx += 8
  2228  		case 2:
  2229  			var length int
  2230  			for shift := uint(0); ; shift += 7 {
  2231  				if shift >= 64 {
  2232  					return 0, ErrIntOverflowGenerated
  2233  				}
  2234  				if iNdEx >= l {
  2235  					return 0, io.ErrUnexpectedEOF
  2236  				}
  2237  				b := dAtA[iNdEx]
  2238  				iNdEx++
  2239  				length |= (int(b) & 0x7F) << shift
  2240  				if b < 0x80 {
  2241  					break
  2242  				}
  2243  			}
  2244  			if length < 0 {
  2245  				return 0, ErrInvalidLengthGenerated
  2246  			}
  2247  			iNdEx += length
  2248  		case 3:
  2249  			depth++
  2250  		case 4:
  2251  			if depth == 0 {
  2252  				return 0, ErrUnexpectedEndOfGroupGenerated
  2253  			}
  2254  			depth--
  2255  		case 5:
  2256  			iNdEx += 4
  2257  		default:
  2258  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  2259  		}
  2260  		if iNdEx < 0 {
  2261  			return 0, ErrInvalidLengthGenerated
  2262  		}
  2263  		if depth == 0 {
  2264  			return iNdEx, nil
  2265  		}
  2266  	}
  2267  	return 0, io.ErrUnexpectedEOF
  2268  }
  2269  
  2270  var (
  2271  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  2272  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  2273  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  2274  )
  2275  

View as plain text