github.com/datachainlab/burrow@v0.25.0/permission/permission.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: permission.proto 3 4 package permission 5 6 import ( 7 fmt "fmt" 8 io "io" 9 math "math" 10 11 _ "github.com/gogo/protobuf/gogoproto" 12 proto "github.com/gogo/protobuf/proto" 13 golang_proto "github.com/golang/protobuf/proto" 14 github_com_hyperledger_burrow_crypto "github.com/hyperledger/burrow/crypto" 15 ) 16 17 // Reference imports to suppress errors if they are not otherwise used. 18 var _ = proto.Marshal 19 var _ = golang_proto.Marshal 20 var _ = fmt.Errorf 21 var _ = math.Inf 22 23 // This is a compile-time assertion to ensure that this generated file 24 // is compatible with the proto package it is being compiled against. 25 // A compilation error at this line likely means your copy of the 26 // proto package needs to be updated. 27 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 28 29 type AccountPermissions struct { 30 Base BasePermissions `protobuf:"bytes,1,opt,name=Base" json:"Base"` 31 Roles []string `protobuf:"bytes,2,rep,name=Roles" json:"Roles,omitempty"` 32 XXX_unrecognized []byte `json:"-"` 33 } 34 35 func (m *AccountPermissions) Reset() { *m = AccountPermissions{} } 36 func (m *AccountPermissions) String() string { return proto.CompactTextString(m) } 37 func (*AccountPermissions) ProtoMessage() {} 38 func (*AccountPermissions) Descriptor() ([]byte, []int) { 39 return fileDescriptor_c837ef01cbda0ad8, []int{0} 40 } 41 func (m *AccountPermissions) XXX_Unmarshal(b []byte) error { 42 return m.Unmarshal(b) 43 } 44 func (m *AccountPermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 45 if deterministic { 46 return xxx_messageInfo_AccountPermissions.Marshal(b, m, deterministic) 47 } else { 48 b = b[:cap(b)] 49 n, err := m.MarshalTo(b) 50 if err != nil { 51 return nil, err 52 } 53 return b[:n], nil 54 } 55 } 56 func (m *AccountPermissions) XXX_Merge(src proto.Message) { 57 xxx_messageInfo_AccountPermissions.Merge(m, src) 58 } 59 func (m *AccountPermissions) XXX_Size() int { 60 return m.Size() 61 } 62 func (m *AccountPermissions) XXX_DiscardUnknown() { 63 xxx_messageInfo_AccountPermissions.DiscardUnknown(m) 64 } 65 66 var xxx_messageInfo_AccountPermissions proto.InternalMessageInfo 67 68 func (m *AccountPermissions) GetBase() BasePermissions { 69 if m != nil { 70 return m.Base 71 } 72 return BasePermissions{} 73 } 74 75 func (m *AccountPermissions) GetRoles() []string { 76 if m != nil { 77 return m.Roles 78 } 79 return nil 80 } 81 82 func (*AccountPermissions) XXX_MessageName() string { 83 return "permission.AccountPermissions" 84 } 85 86 type BasePermissions struct { 87 Perms PermFlag `protobuf:"varint,1,opt,name=Perms,casttype=PermFlag" json:"Perms"` 88 SetBit PermFlag `protobuf:"varint,2,opt,name=SetBit,casttype=PermFlag" json:"SetBit"` 89 XXX_unrecognized []byte `json:"-"` 90 } 91 92 func (m *BasePermissions) Reset() { *m = BasePermissions{} } 93 func (*BasePermissions) ProtoMessage() {} 94 func (*BasePermissions) Descriptor() ([]byte, []int) { 95 return fileDescriptor_c837ef01cbda0ad8, []int{1} 96 } 97 func (m *BasePermissions) XXX_Unmarshal(b []byte) error { 98 return m.Unmarshal(b) 99 } 100 func (m *BasePermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 101 if deterministic { 102 return xxx_messageInfo_BasePermissions.Marshal(b, m, deterministic) 103 } else { 104 b = b[:cap(b)] 105 n, err := m.MarshalTo(b) 106 if err != nil { 107 return nil, err 108 } 109 return b[:n], nil 110 } 111 } 112 func (m *BasePermissions) XXX_Merge(src proto.Message) { 113 xxx_messageInfo_BasePermissions.Merge(m, src) 114 } 115 func (m *BasePermissions) XXX_Size() int { 116 return m.Size() 117 } 118 func (m *BasePermissions) XXX_DiscardUnknown() { 119 xxx_messageInfo_BasePermissions.DiscardUnknown(m) 120 } 121 122 var xxx_messageInfo_BasePermissions proto.InternalMessageInfo 123 124 func (m *BasePermissions) GetPerms() PermFlag { 125 if m != nil { 126 return m.Perms 127 } 128 return 0 129 } 130 131 func (m *BasePermissions) GetSetBit() PermFlag { 132 if m != nil { 133 return m.SetBit 134 } 135 return 0 136 } 137 138 func (*BasePermissions) XXX_MessageName() string { 139 return "permission.BasePermissions" 140 } 141 142 type PermArgs struct { 143 // The permission function 144 Action PermFlag `protobuf:"varint,1,opt,name=Action,casttype=PermFlag" json:"Action"` 145 // The target of the action 146 Target *github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,2,opt,name=Target,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Target,omitempty"` 147 // Possible arguments 148 Permission *PermFlag `protobuf:"varint,3,opt,name=Permission,casttype=PermFlag" json:"Permission,omitempty"` 149 Role *string `protobuf:"bytes,4,opt,name=Role" json:"Role,omitempty"` 150 Value *bool `protobuf:"varint,5,opt,name=Value" json:"Value,omitempty"` 151 XXX_NoUnkeyedLiteral struct{} `json:"-"` 152 XXX_sizecache int32 `json:"-"` 153 } 154 155 func (m *PermArgs) Reset() { *m = PermArgs{} } 156 func (*PermArgs) ProtoMessage() {} 157 func (*PermArgs) Descriptor() ([]byte, []int) { 158 return fileDescriptor_c837ef01cbda0ad8, []int{2} 159 } 160 func (m *PermArgs) XXX_Unmarshal(b []byte) error { 161 return m.Unmarshal(b) 162 } 163 func (m *PermArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 164 if deterministic { 165 return xxx_messageInfo_PermArgs.Marshal(b, m, deterministic) 166 } else { 167 b = b[:cap(b)] 168 n, err := m.MarshalTo(b) 169 if err != nil { 170 return nil, err 171 } 172 return b[:n], nil 173 } 174 } 175 func (m *PermArgs) XXX_Merge(src proto.Message) { 176 xxx_messageInfo_PermArgs.Merge(m, src) 177 } 178 func (m *PermArgs) XXX_Size() int { 179 return m.Size() 180 } 181 func (m *PermArgs) XXX_DiscardUnknown() { 182 xxx_messageInfo_PermArgs.DiscardUnknown(m) 183 } 184 185 var xxx_messageInfo_PermArgs proto.InternalMessageInfo 186 187 func (m *PermArgs) GetAction() PermFlag { 188 if m != nil { 189 return m.Action 190 } 191 return 0 192 } 193 194 func (m *PermArgs) GetPermission() PermFlag { 195 if m != nil && m.Permission != nil { 196 return *m.Permission 197 } 198 return 0 199 } 200 201 func (m *PermArgs) GetRole() string { 202 if m != nil && m.Role != nil { 203 return *m.Role 204 } 205 return "" 206 } 207 208 func (m *PermArgs) GetValue() bool { 209 if m != nil && m.Value != nil { 210 return *m.Value 211 } 212 return false 213 } 214 215 func (*PermArgs) XXX_MessageName() string { 216 return "permission.PermArgs" 217 } 218 func init() { 219 proto.RegisterType((*AccountPermissions)(nil), "permission.AccountPermissions") 220 golang_proto.RegisterType((*AccountPermissions)(nil), "permission.AccountPermissions") 221 proto.RegisterType((*BasePermissions)(nil), "permission.BasePermissions") 222 golang_proto.RegisterType((*BasePermissions)(nil), "permission.BasePermissions") 223 proto.RegisterType((*PermArgs)(nil), "permission.PermArgs") 224 golang_proto.RegisterType((*PermArgs)(nil), "permission.PermArgs") 225 } 226 227 func init() { proto.RegisterFile("permission.proto", fileDescriptor_c837ef01cbda0ad8) } 228 func init() { golang_proto.RegisterFile("permission.proto", fileDescriptor_c837ef01cbda0ad8) } 229 230 var fileDescriptor_c837ef01cbda0ad8 = []byte{ 231 // 367 bytes of a gzipped FileDescriptorProto 232 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0x31, 0x4f, 0xc2, 0x40, 233 0x14, 0xc7, 0x7b, 0x50, 0x48, 0x39, 0x49, 0x24, 0x17, 0x87, 0x46, 0x93, 0xb6, 0x61, 0x30, 0x1d, 234 0xb0, 0x35, 0x26, 0x2e, 0x0c, 0x26, 0xed, 0x60, 0x1c, 0x4d, 0x35, 0x0e, 0x6e, 0xa5, 0x9c, 0xa5, 235 0xb1, 0x70, 0xf5, 0xee, 0x1a, 0xc3, 0xb7, 0x70, 0x64, 0x54, 0x3e, 0x89, 0x23, 0x23, 0xb3, 0x03, 236 0x21, 0xf0, 0x2d, 0x9c, 0xcc, 0x5d, 0x09, 0x54, 0x13, 0xdc, 0xee, 0xff, 0xfe, 0xff, 0xf7, 0x7e, 237 0x7d, 0xaf, 0xb0, 0x95, 0x61, 0x3a, 0x4c, 0x18, 0x4b, 0xc8, 0xc8, 0xc9, 0x28, 0xe1, 0x04, 0xc1, 238 0x5d, 0xe5, 0xf8, 0x2c, 0x4e, 0xf8, 0x20, 0xef, 0x39, 0x11, 0x19, 0xba, 0x31, 0x89, 0x89, 0x2b, 239 0x23, 0xbd, 0xfc, 0x49, 0x2a, 0x29, 0xe4, 0xab, 0x68, 0x6d, 0x3f, 0x43, 0xe4, 0x45, 0x11, 0xc9, 240 0x47, 0xfc, 0x76, 0x3b, 0x83, 0xa1, 0x4b, 0xa8, 0xfa, 0x21, 0xc3, 0x3a, 0xb0, 0x80, 0x7d, 0x70, 241 0x71, 0xe2, 0x94, 0x88, 0xa2, 0x5e, 0x8a, 0xfa, 0xea, 0x6c, 0x61, 0x2a, 0x81, 0x8c, 0xa3, 0x23, 242 0x58, 0x0b, 0x48, 0x8a, 0x99, 0x5e, 0xb1, 0xaa, 0x76, 0x23, 0x28, 0x44, 0x57, 0x7b, 0x9b, 0x9a, 243 0xca, 0x64, 0x6a, 0x2a, 0xed, 0x17, 0x78, 0xf8, 0xa7, 0x1d, 0x9d, 0xc2, 0x9a, 0x90, 0x4c, 0xa2, 244 0x54, 0xbf, 0x25, 0xa6, 0x7d, 0x2f, 0x4c, 0x4d, 0x14, 0xaf, 0xd3, 0x30, 0x0e, 0x0a, 0x1b, 0xd9, 245 0xb0, 0x7e, 0x87, 0xb9, 0x9f, 0x70, 0xbd, 0xb2, 0x27, 0xb8, 0xf1, 0xbb, 0xcd, 0xc9, 0xbb, 0xa9, 246 0x6c, 0x91, 0x4b, 0x00, 0x65, 0xc4, 0xa3, 0xb1, 0x1c, 0xe2, 0x45, 0x3c, 0x21, 0xa3, 0xbd, 0xb4, 247 0x8d, 0x8f, 0x6e, 0x60, 0xfd, 0x3e, 0xa4, 0x31, 0x2e, 0x70, 0x4d, 0xff, 0xfc, 0x6b, 0x61, 0x76, 248 0x4a, 0x97, 0x1d, 0x8c, 0x33, 0x4c, 0x53, 0xdc, 0x8f, 0x31, 0x75, 0x7b, 0x39, 0xa5, 0xe4, 0xd5, 249 0x8d, 0xe8, 0x38, 0xe3, 0xc4, 0xf1, 0xfa, 0x7d, 0x8a, 0x19, 0x0b, 0x36, 0xfd, 0xa8, 0x03, 0xe1, 250 0x6e, 0x5f, 0xbd, 0x2a, 0xb9, 0xcd, 0x5f, 0xcc, 0x92, 0x8f, 0x10, 0x54, 0xc5, 0xd1, 0x74, 0xd5, 251 0x02, 0x76, 0x23, 0x90, 0x6f, 0x71, 0xd5, 0x87, 0x30, 0xcd, 0xb1, 0x5e, 0xb3, 0x80, 0xad, 0x05, 252 0x85, 0xe8, 0x6a, 0x62, 0xcd, 0xf9, 0x87, 0xa9, 0xf8, 0x57, 0xb3, 0x95, 0x01, 0xe6, 0x2b, 0x03, 253 0x2c, 0x57, 0x06, 0xf8, 0x5c, 0x1b, 0x60, 0xb6, 0x36, 0xc0, 0xa3, 0xfd, 0xff, 0xd7, 0xee, 0xfe, 254 0xe8, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb6, 0xa6, 0x3c, 0xf5, 0x50, 0x02, 0x00, 0x00, 255 } 256 257 func (m *AccountPermissions) Marshal() (dAtA []byte, err error) { 258 size := m.Size() 259 dAtA = make([]byte, size) 260 n, err := m.MarshalTo(dAtA) 261 if err != nil { 262 return nil, err 263 } 264 return dAtA[:n], nil 265 } 266 267 func (m *AccountPermissions) MarshalTo(dAtA []byte) (int, error) { 268 var i int 269 _ = i 270 var l int 271 _ = l 272 dAtA[i] = 0xa 273 i++ 274 i = encodeVarintPermission(dAtA, i, uint64(m.Base.Size())) 275 n1, err := m.Base.MarshalTo(dAtA[i:]) 276 if err != nil { 277 return 0, err 278 } 279 i += n1 280 if len(m.Roles) > 0 { 281 for _, s := range m.Roles { 282 dAtA[i] = 0x12 283 i++ 284 l = len(s) 285 for l >= 1<<7 { 286 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 287 l >>= 7 288 i++ 289 } 290 dAtA[i] = uint8(l) 291 i++ 292 i += copy(dAtA[i:], s) 293 } 294 } 295 if m.XXX_unrecognized != nil { 296 i += copy(dAtA[i:], m.XXX_unrecognized) 297 } 298 return i, nil 299 } 300 301 func (m *BasePermissions) Marshal() (dAtA []byte, err error) { 302 size := m.Size() 303 dAtA = make([]byte, size) 304 n, err := m.MarshalTo(dAtA) 305 if err != nil { 306 return nil, err 307 } 308 return dAtA[:n], nil 309 } 310 311 func (m *BasePermissions) MarshalTo(dAtA []byte) (int, error) { 312 var i int 313 _ = i 314 var l int 315 _ = l 316 dAtA[i] = 0x8 317 i++ 318 i = encodeVarintPermission(dAtA, i, uint64(m.Perms)) 319 dAtA[i] = 0x10 320 i++ 321 i = encodeVarintPermission(dAtA, i, uint64(m.SetBit)) 322 if m.XXX_unrecognized != nil { 323 i += copy(dAtA[i:], m.XXX_unrecognized) 324 } 325 return i, nil 326 } 327 328 func (m *PermArgs) Marshal() (dAtA []byte, err error) { 329 size := m.Size() 330 dAtA = make([]byte, size) 331 n, err := m.MarshalTo(dAtA) 332 if err != nil { 333 return nil, err 334 } 335 return dAtA[:n], nil 336 } 337 338 func (m *PermArgs) MarshalTo(dAtA []byte) (int, error) { 339 var i int 340 _ = i 341 var l int 342 _ = l 343 dAtA[i] = 0x8 344 i++ 345 i = encodeVarintPermission(dAtA, i, uint64(m.Action)) 346 if m.Target != nil { 347 dAtA[i] = 0x12 348 i++ 349 i = encodeVarintPermission(dAtA, i, uint64(m.Target.Size())) 350 n2, err := m.Target.MarshalTo(dAtA[i:]) 351 if err != nil { 352 return 0, err 353 } 354 i += n2 355 } 356 if m.Permission != nil { 357 dAtA[i] = 0x18 358 i++ 359 i = encodeVarintPermission(dAtA, i, uint64(*m.Permission)) 360 } 361 if m.Role != nil { 362 dAtA[i] = 0x22 363 i++ 364 i = encodeVarintPermission(dAtA, i, uint64(len(*m.Role))) 365 i += copy(dAtA[i:], *m.Role) 366 } 367 if m.Value != nil { 368 dAtA[i] = 0x28 369 i++ 370 if *m.Value { 371 dAtA[i] = 1 372 } else { 373 dAtA[i] = 0 374 } 375 i++ 376 } 377 return i, nil 378 } 379 380 func encodeVarintPermission(dAtA []byte, offset int, v uint64) int { 381 for v >= 1<<7 { 382 dAtA[offset] = uint8(v&0x7f | 0x80) 383 v >>= 7 384 offset++ 385 } 386 dAtA[offset] = uint8(v) 387 return offset + 1 388 } 389 func (m *AccountPermissions) Size() (n int) { 390 if m == nil { 391 return 0 392 } 393 var l int 394 _ = l 395 l = m.Base.Size() 396 n += 1 + l + sovPermission(uint64(l)) 397 if len(m.Roles) > 0 { 398 for _, s := range m.Roles { 399 l = len(s) 400 n += 1 + l + sovPermission(uint64(l)) 401 } 402 } 403 if m.XXX_unrecognized != nil { 404 n += len(m.XXX_unrecognized) 405 } 406 return n 407 } 408 409 func (m *BasePermissions) Size() (n int) { 410 if m == nil { 411 return 0 412 } 413 var l int 414 _ = l 415 n += 1 + sovPermission(uint64(m.Perms)) 416 n += 1 + sovPermission(uint64(m.SetBit)) 417 if m.XXX_unrecognized != nil { 418 n += len(m.XXX_unrecognized) 419 } 420 return n 421 } 422 423 func (m *PermArgs) Size() (n int) { 424 if m == nil { 425 return 0 426 } 427 var l int 428 _ = l 429 n += 1 + sovPermission(uint64(m.Action)) 430 if m.Target != nil { 431 l = m.Target.Size() 432 n += 1 + l + sovPermission(uint64(l)) 433 } 434 if m.Permission != nil { 435 n += 1 + sovPermission(uint64(*m.Permission)) 436 } 437 if m.Role != nil { 438 l = len(*m.Role) 439 n += 1 + l + sovPermission(uint64(l)) 440 } 441 if m.Value != nil { 442 n += 2 443 } 444 return n 445 } 446 447 func sovPermission(x uint64) (n int) { 448 for { 449 n++ 450 x >>= 7 451 if x == 0 { 452 break 453 } 454 } 455 return n 456 } 457 func sozPermission(x uint64) (n int) { 458 return sovPermission(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 459 } 460 func (m *AccountPermissions) Unmarshal(dAtA []byte) error { 461 l := len(dAtA) 462 iNdEx := 0 463 for iNdEx < l { 464 preIndex := iNdEx 465 var wire uint64 466 for shift := uint(0); ; shift += 7 { 467 if shift >= 64 { 468 return ErrIntOverflowPermission 469 } 470 if iNdEx >= l { 471 return io.ErrUnexpectedEOF 472 } 473 b := dAtA[iNdEx] 474 iNdEx++ 475 wire |= uint64(b&0x7F) << shift 476 if b < 0x80 { 477 break 478 } 479 } 480 fieldNum := int32(wire >> 3) 481 wireType := int(wire & 0x7) 482 if wireType == 4 { 483 return fmt.Errorf("proto: AccountPermissions: wiretype end group for non-group") 484 } 485 if fieldNum <= 0 { 486 return fmt.Errorf("proto: AccountPermissions: illegal tag %d (wire type %d)", fieldNum, wire) 487 } 488 switch fieldNum { 489 case 1: 490 if wireType != 2 { 491 return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType) 492 } 493 var msglen int 494 for shift := uint(0); ; shift += 7 { 495 if shift >= 64 { 496 return ErrIntOverflowPermission 497 } 498 if iNdEx >= l { 499 return io.ErrUnexpectedEOF 500 } 501 b := dAtA[iNdEx] 502 iNdEx++ 503 msglen |= int(b&0x7F) << shift 504 if b < 0x80 { 505 break 506 } 507 } 508 if msglen < 0 { 509 return ErrInvalidLengthPermission 510 } 511 postIndex := iNdEx + msglen 512 if postIndex < 0 { 513 return ErrInvalidLengthPermission 514 } 515 if postIndex > l { 516 return io.ErrUnexpectedEOF 517 } 518 if err := m.Base.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 519 return err 520 } 521 iNdEx = postIndex 522 case 2: 523 if wireType != 2 { 524 return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) 525 } 526 var stringLen uint64 527 for shift := uint(0); ; shift += 7 { 528 if shift >= 64 { 529 return ErrIntOverflowPermission 530 } 531 if iNdEx >= l { 532 return io.ErrUnexpectedEOF 533 } 534 b := dAtA[iNdEx] 535 iNdEx++ 536 stringLen |= uint64(b&0x7F) << shift 537 if b < 0x80 { 538 break 539 } 540 } 541 intStringLen := int(stringLen) 542 if intStringLen < 0 { 543 return ErrInvalidLengthPermission 544 } 545 postIndex := iNdEx + intStringLen 546 if postIndex < 0 { 547 return ErrInvalidLengthPermission 548 } 549 if postIndex > l { 550 return io.ErrUnexpectedEOF 551 } 552 m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) 553 iNdEx = postIndex 554 default: 555 iNdEx = preIndex 556 skippy, err := skipPermission(dAtA[iNdEx:]) 557 if err != nil { 558 return err 559 } 560 if skippy < 0 { 561 return ErrInvalidLengthPermission 562 } 563 if (iNdEx + skippy) < 0 { 564 return ErrInvalidLengthPermission 565 } 566 if (iNdEx + skippy) > l { 567 return io.ErrUnexpectedEOF 568 } 569 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 570 iNdEx += skippy 571 } 572 } 573 574 if iNdEx > l { 575 return io.ErrUnexpectedEOF 576 } 577 return nil 578 } 579 func (m *BasePermissions) Unmarshal(dAtA []byte) error { 580 l := len(dAtA) 581 iNdEx := 0 582 for iNdEx < l { 583 preIndex := iNdEx 584 var wire uint64 585 for shift := uint(0); ; shift += 7 { 586 if shift >= 64 { 587 return ErrIntOverflowPermission 588 } 589 if iNdEx >= l { 590 return io.ErrUnexpectedEOF 591 } 592 b := dAtA[iNdEx] 593 iNdEx++ 594 wire |= uint64(b&0x7F) << shift 595 if b < 0x80 { 596 break 597 } 598 } 599 fieldNum := int32(wire >> 3) 600 wireType := int(wire & 0x7) 601 if wireType == 4 { 602 return fmt.Errorf("proto: BasePermissions: wiretype end group for non-group") 603 } 604 if fieldNum <= 0 { 605 return fmt.Errorf("proto: BasePermissions: illegal tag %d (wire type %d)", fieldNum, wire) 606 } 607 switch fieldNum { 608 case 1: 609 if wireType != 0 { 610 return fmt.Errorf("proto: wrong wireType = %d for field Perms", wireType) 611 } 612 m.Perms = 0 613 for shift := uint(0); ; shift += 7 { 614 if shift >= 64 { 615 return ErrIntOverflowPermission 616 } 617 if iNdEx >= l { 618 return io.ErrUnexpectedEOF 619 } 620 b := dAtA[iNdEx] 621 iNdEx++ 622 m.Perms |= PermFlag(b&0x7F) << shift 623 if b < 0x80 { 624 break 625 } 626 } 627 case 2: 628 if wireType != 0 { 629 return fmt.Errorf("proto: wrong wireType = %d for field SetBit", wireType) 630 } 631 m.SetBit = 0 632 for shift := uint(0); ; shift += 7 { 633 if shift >= 64 { 634 return ErrIntOverflowPermission 635 } 636 if iNdEx >= l { 637 return io.ErrUnexpectedEOF 638 } 639 b := dAtA[iNdEx] 640 iNdEx++ 641 m.SetBit |= PermFlag(b&0x7F) << shift 642 if b < 0x80 { 643 break 644 } 645 } 646 default: 647 iNdEx = preIndex 648 skippy, err := skipPermission(dAtA[iNdEx:]) 649 if err != nil { 650 return err 651 } 652 if skippy < 0 { 653 return ErrInvalidLengthPermission 654 } 655 if (iNdEx + skippy) < 0 { 656 return ErrInvalidLengthPermission 657 } 658 if (iNdEx + skippy) > l { 659 return io.ErrUnexpectedEOF 660 } 661 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 662 iNdEx += skippy 663 } 664 } 665 666 if iNdEx > l { 667 return io.ErrUnexpectedEOF 668 } 669 return nil 670 } 671 func (m *PermArgs) Unmarshal(dAtA []byte) error { 672 l := len(dAtA) 673 iNdEx := 0 674 for iNdEx < l { 675 preIndex := iNdEx 676 var wire uint64 677 for shift := uint(0); ; shift += 7 { 678 if shift >= 64 { 679 return ErrIntOverflowPermission 680 } 681 if iNdEx >= l { 682 return io.ErrUnexpectedEOF 683 } 684 b := dAtA[iNdEx] 685 iNdEx++ 686 wire |= uint64(b&0x7F) << shift 687 if b < 0x80 { 688 break 689 } 690 } 691 fieldNum := int32(wire >> 3) 692 wireType := int(wire & 0x7) 693 if wireType == 4 { 694 return fmt.Errorf("proto: PermArgs: wiretype end group for non-group") 695 } 696 if fieldNum <= 0 { 697 return fmt.Errorf("proto: PermArgs: illegal tag %d (wire type %d)", fieldNum, wire) 698 } 699 switch fieldNum { 700 case 1: 701 if wireType != 0 { 702 return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) 703 } 704 m.Action = 0 705 for shift := uint(0); ; shift += 7 { 706 if shift >= 64 { 707 return ErrIntOverflowPermission 708 } 709 if iNdEx >= l { 710 return io.ErrUnexpectedEOF 711 } 712 b := dAtA[iNdEx] 713 iNdEx++ 714 m.Action |= PermFlag(b&0x7F) << shift 715 if b < 0x80 { 716 break 717 } 718 } 719 case 2: 720 if wireType != 2 { 721 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 722 } 723 var byteLen int 724 for shift := uint(0); ; shift += 7 { 725 if shift >= 64 { 726 return ErrIntOverflowPermission 727 } 728 if iNdEx >= l { 729 return io.ErrUnexpectedEOF 730 } 731 b := dAtA[iNdEx] 732 iNdEx++ 733 byteLen |= int(b&0x7F) << shift 734 if b < 0x80 { 735 break 736 } 737 } 738 if byteLen < 0 { 739 return ErrInvalidLengthPermission 740 } 741 postIndex := iNdEx + byteLen 742 if postIndex < 0 { 743 return ErrInvalidLengthPermission 744 } 745 if postIndex > l { 746 return io.ErrUnexpectedEOF 747 } 748 var v github_com_hyperledger_burrow_crypto.Address 749 m.Target = &v 750 if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 751 return err 752 } 753 iNdEx = postIndex 754 case 3: 755 if wireType != 0 { 756 return fmt.Errorf("proto: wrong wireType = %d for field Permission", wireType) 757 } 758 var v PermFlag 759 for shift := uint(0); ; shift += 7 { 760 if shift >= 64 { 761 return ErrIntOverflowPermission 762 } 763 if iNdEx >= l { 764 return io.ErrUnexpectedEOF 765 } 766 b := dAtA[iNdEx] 767 iNdEx++ 768 v |= PermFlag(b&0x7F) << shift 769 if b < 0x80 { 770 break 771 } 772 } 773 m.Permission = &v 774 case 4: 775 if wireType != 2 { 776 return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) 777 } 778 var stringLen uint64 779 for shift := uint(0); ; shift += 7 { 780 if shift >= 64 { 781 return ErrIntOverflowPermission 782 } 783 if iNdEx >= l { 784 return io.ErrUnexpectedEOF 785 } 786 b := dAtA[iNdEx] 787 iNdEx++ 788 stringLen |= uint64(b&0x7F) << shift 789 if b < 0x80 { 790 break 791 } 792 } 793 intStringLen := int(stringLen) 794 if intStringLen < 0 { 795 return ErrInvalidLengthPermission 796 } 797 postIndex := iNdEx + intStringLen 798 if postIndex < 0 { 799 return ErrInvalidLengthPermission 800 } 801 if postIndex > l { 802 return io.ErrUnexpectedEOF 803 } 804 s := string(dAtA[iNdEx:postIndex]) 805 m.Role = &s 806 iNdEx = postIndex 807 case 5: 808 if wireType != 0 { 809 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 810 } 811 var v int 812 for shift := uint(0); ; shift += 7 { 813 if shift >= 64 { 814 return ErrIntOverflowPermission 815 } 816 if iNdEx >= l { 817 return io.ErrUnexpectedEOF 818 } 819 b := dAtA[iNdEx] 820 iNdEx++ 821 v |= int(b&0x7F) << shift 822 if b < 0x80 { 823 break 824 } 825 } 826 b := bool(v != 0) 827 m.Value = &b 828 default: 829 iNdEx = preIndex 830 skippy, err := skipPermission(dAtA[iNdEx:]) 831 if err != nil { 832 return err 833 } 834 if skippy < 0 { 835 return ErrInvalidLengthPermission 836 } 837 if (iNdEx + skippy) < 0 { 838 return ErrInvalidLengthPermission 839 } 840 if (iNdEx + skippy) > l { 841 return io.ErrUnexpectedEOF 842 } 843 iNdEx += skippy 844 } 845 } 846 847 if iNdEx > l { 848 return io.ErrUnexpectedEOF 849 } 850 return nil 851 } 852 func skipPermission(dAtA []byte) (n int, err error) { 853 l := len(dAtA) 854 iNdEx := 0 855 for iNdEx < l { 856 var wire uint64 857 for shift := uint(0); ; shift += 7 { 858 if shift >= 64 { 859 return 0, ErrIntOverflowPermission 860 } 861 if iNdEx >= l { 862 return 0, io.ErrUnexpectedEOF 863 } 864 b := dAtA[iNdEx] 865 iNdEx++ 866 wire |= (uint64(b) & 0x7F) << shift 867 if b < 0x80 { 868 break 869 } 870 } 871 wireType := int(wire & 0x7) 872 switch wireType { 873 case 0: 874 for shift := uint(0); ; shift += 7 { 875 if shift >= 64 { 876 return 0, ErrIntOverflowPermission 877 } 878 if iNdEx >= l { 879 return 0, io.ErrUnexpectedEOF 880 } 881 iNdEx++ 882 if dAtA[iNdEx-1] < 0x80 { 883 break 884 } 885 } 886 return iNdEx, nil 887 case 1: 888 iNdEx += 8 889 return iNdEx, nil 890 case 2: 891 var length int 892 for shift := uint(0); ; shift += 7 { 893 if shift >= 64 { 894 return 0, ErrIntOverflowPermission 895 } 896 if iNdEx >= l { 897 return 0, io.ErrUnexpectedEOF 898 } 899 b := dAtA[iNdEx] 900 iNdEx++ 901 length |= (int(b) & 0x7F) << shift 902 if b < 0x80 { 903 break 904 } 905 } 906 if length < 0 { 907 return 0, ErrInvalidLengthPermission 908 } 909 iNdEx += length 910 if iNdEx < 0 { 911 return 0, ErrInvalidLengthPermission 912 } 913 return iNdEx, nil 914 case 3: 915 for { 916 var innerWire uint64 917 var start int = iNdEx 918 for shift := uint(0); ; shift += 7 { 919 if shift >= 64 { 920 return 0, ErrIntOverflowPermission 921 } 922 if iNdEx >= l { 923 return 0, io.ErrUnexpectedEOF 924 } 925 b := dAtA[iNdEx] 926 iNdEx++ 927 innerWire |= (uint64(b) & 0x7F) << shift 928 if b < 0x80 { 929 break 930 } 931 } 932 innerWireType := int(innerWire & 0x7) 933 if innerWireType == 4 { 934 break 935 } 936 next, err := skipPermission(dAtA[start:]) 937 if err != nil { 938 return 0, err 939 } 940 iNdEx = start + next 941 if iNdEx < 0 { 942 return 0, ErrInvalidLengthPermission 943 } 944 } 945 return iNdEx, nil 946 case 4: 947 return iNdEx, nil 948 case 5: 949 iNdEx += 4 950 return iNdEx, nil 951 default: 952 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 953 } 954 } 955 panic("unreachable") 956 } 957 958 var ( 959 ErrInvalidLengthPermission = fmt.Errorf("proto: negative length found during unmarshaling") 960 ErrIntOverflowPermission = fmt.Errorf("proto: integer overflow") 961 )