github.com/Tri-stone/burrow@v0.25.0/rpc/rpc.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: rpc.proto 3 4 package rpc 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 validator "github.com/hyperledger/burrow/acm/validator" 15 bcm "github.com/hyperledger/burrow/bcm" 16 github_com_hyperledger_burrow_binary "github.com/hyperledger/burrow/binary" 17 tendermint "github.com/hyperledger/burrow/consensus/tendermint" 18 ) 19 20 // Reference imports to suppress errors if they are not otherwise used. 21 var _ = proto.Marshal 22 var _ = golang_proto.Marshal 23 var _ = fmt.Errorf 24 var _ = math.Inf 25 26 // This is a compile-time assertion to ensure that this generated file 27 // is compatible with the proto package it is being compiled against. 28 // A compilation error at this line likely means your copy of the 29 // proto package needs to be updated. 30 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 31 32 type ResultStatus struct { 33 ChainID string `protobuf:"bytes,1,opt,name=ChainID,proto3" json:"ChainID,omitempty"` 34 RunID string `protobuf:"bytes,2,opt,name=RunID,proto3" json:"RunID,omitempty"` 35 BurrowVersion string `protobuf:"bytes,3,opt,name=BurrowVersion,proto3" json:"BurrowVersion,omitempty"` 36 GenesisHash github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,4,opt,name=GenesisHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"GenesisHash"` 37 NodeInfo *tendermint.NodeInfo `protobuf:"bytes,5,opt,name=NodeInfo,proto3" json:"NodeInfo,omitempty"` 38 SyncInfo *bcm.SyncInfo `protobuf:"bytes,6,opt,name=SyncInfo,proto3" json:"SyncInfo,omitempty"` 39 // When catching up in fast sync 40 CatchingUp bool `protobuf:"varint,8,opt,name=CatchingUp,proto3" json:""` 41 ValidatorInfo *validator.Validator `protobuf:"bytes,7,opt,name=ValidatorInfo,proto3" json:"ValidatorInfo,omitempty"` 42 XXX_NoUnkeyedLiteral struct{} `json:"-"` 43 XXX_unrecognized []byte `json:"-"` 44 XXX_sizecache int32 `json:"-"` 45 } 46 47 func (m *ResultStatus) Reset() { *m = ResultStatus{} } 48 func (m *ResultStatus) String() string { return proto.CompactTextString(m) } 49 func (*ResultStatus) ProtoMessage() {} 50 func (*ResultStatus) Descriptor() ([]byte, []int) { 51 return fileDescriptor_77a6da22d6a3feb1, []int{0} 52 } 53 func (m *ResultStatus) XXX_Unmarshal(b []byte) error { 54 return m.Unmarshal(b) 55 } 56 func (m *ResultStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 57 if deterministic { 58 return xxx_messageInfo_ResultStatus.Marshal(b, m, deterministic) 59 } else { 60 b = b[:cap(b)] 61 n, err := m.MarshalTo(b) 62 if err != nil { 63 return nil, err 64 } 65 return b[:n], nil 66 } 67 } 68 func (m *ResultStatus) XXX_Merge(src proto.Message) { 69 xxx_messageInfo_ResultStatus.Merge(m, src) 70 } 71 func (m *ResultStatus) XXX_Size() int { 72 return m.Size() 73 } 74 func (m *ResultStatus) XXX_DiscardUnknown() { 75 xxx_messageInfo_ResultStatus.DiscardUnknown(m) 76 } 77 78 var xxx_messageInfo_ResultStatus proto.InternalMessageInfo 79 80 func (m *ResultStatus) GetChainID() string { 81 if m != nil { 82 return m.ChainID 83 } 84 return "" 85 } 86 87 func (m *ResultStatus) GetRunID() string { 88 if m != nil { 89 return m.RunID 90 } 91 return "" 92 } 93 94 func (m *ResultStatus) GetBurrowVersion() string { 95 if m != nil { 96 return m.BurrowVersion 97 } 98 return "" 99 } 100 101 func (m *ResultStatus) GetNodeInfo() *tendermint.NodeInfo { 102 if m != nil { 103 return m.NodeInfo 104 } 105 return nil 106 } 107 108 func (m *ResultStatus) GetSyncInfo() *bcm.SyncInfo { 109 if m != nil { 110 return m.SyncInfo 111 } 112 return nil 113 } 114 115 func (m *ResultStatus) GetCatchingUp() bool { 116 if m != nil { 117 return m.CatchingUp 118 } 119 return false 120 } 121 122 func (m *ResultStatus) GetValidatorInfo() *validator.Validator { 123 if m != nil { 124 return m.ValidatorInfo 125 } 126 return nil 127 } 128 129 func (*ResultStatus) XXX_MessageName() string { 130 return "rpc.ResultStatus" 131 } 132 func init() { 133 proto.RegisterType((*ResultStatus)(nil), "rpc.ResultStatus") 134 golang_proto.RegisterType((*ResultStatus)(nil), "rpc.ResultStatus") 135 } 136 137 func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) } 138 func init() { golang_proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) } 139 140 var fileDescriptor_77a6da22d6a3feb1 = []byte{ 141 // 368 bytes of a gzipped FileDescriptorProto 142 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0x3f, 0x6f, 0xda, 0x40, 143 0x18, 0xc6, 0x39, 0xfe, 0x9a, 0x03, 0xd4, 0xea, 0xc4, 0x60, 0x31, 0x18, 0xb7, 0x62, 0x70, 0x87, 144 0xda, 0x55, 0xab, 0xaa, 0x52, 0x47, 0x13, 0x29, 0xb0, 0x64, 0x38, 0x14, 0x22, 0x65, 0xf3, 0x9f, 145 0xc3, 0x3e, 0x09, 0xee, 0xac, 0xf3, 0x39, 0x89, 0xbf, 0x5d, 0x46, 0xc6, 0xcc, 0x19, 0x50, 0x04, 146 0x5b, 0x3e, 0x43, 0x86, 0x88, 0x03, 0x13, 0xb3, 0x64, 0x7b, 0x9f, 0xdf, 0xf3, 0xbe, 0x8f, 0xec, 147 0xe7, 0x60, 0x5b, 0x24, 0x81, 0x9d, 0x08, 0x2e, 0x39, 0xaa, 0x89, 0x24, 0x18, 0xfc, 0x8c, 0xa8, 148 0x8c, 0x33, 0xdf, 0x0e, 0xf8, 0xca, 0x89, 0x78, 0xc4, 0x1d, 0xe5, 0xf9, 0xd9, 0x42, 0x29, 0x25, 149 0xd4, 0x74, 0xb8, 0x19, 0x7c, 0x95, 0x84, 0x85, 0x44, 0xac, 0x28, 0x93, 0x47, 0xf2, 0xe5, 0xce, 150 0x5b, 0xd2, 0xd0, 0x93, 0x5c, 0x1c, 0x41, 0xdb, 0x0f, 0x56, 0x87, 0xf1, 0xfb, 0x5b, 0x15, 0x76, 151 0x31, 0x49, 0xb3, 0xa5, 0x9c, 0x49, 0x4f, 0x66, 0x29, 0xd2, 0x61, 0x6b, 0x1c, 0x7b, 0x94, 0x4d, 152 0x2f, 0x74, 0x60, 0x02, 0xab, 0x8d, 0x0b, 0x89, 0xfa, 0xb0, 0x81, 0xb3, 0x3d, 0xaf, 0x2a, 0x7e, 153 0x10, 0x68, 0x04, 0x7b, 0x6e, 0x26, 0x04, 0xbf, 0x9f, 0x13, 0x91, 0x52, 0xce, 0xf4, 0x9a, 0x72, 154 0xcf, 0x21, 0xba, 0x81, 0x9d, 0x4b, 0xc2, 0x48, 0x4a, 0xd3, 0x89, 0x97, 0xc6, 0x7a, 0xdd, 0x04, 155 0x56, 0xd7, 0xfd, 0xbb, 0xde, 0x0c, 0x2b, 0xcf, 0x9b, 0x61, 0xf9, 0x07, 0xe3, 0x3c, 0x21, 0x62, 156 0x49, 0xc2, 0x88, 0x08, 0xc7, 0x57, 0x11, 0x8e, 0x4f, 0x99, 0x27, 0x72, 0x7b, 0x42, 0x1e, 0xdc, 157 0x5c, 0x92, 0x14, 0x97, 0x93, 0xd0, 0x2f, 0xa8, 0x5d, 0xf1, 0x90, 0x4c, 0xd9, 0x82, 0xeb, 0x0d, 158 0x13, 0x58, 0x9d, 0xdf, 0x7d, 0xbb, 0x54, 0x40, 0xe1, 0xe1, 0xd3, 0x16, 0xfa, 0x01, 0xb5, 0x59, 159 0xce, 0x02, 0x75, 0xd1, 0x54, 0x17, 0x3d, 0x7b, 0xdf, 0x47, 0x01, 0xf1, 0xc9, 0x46, 0x23, 0x08, 160 0xc7, 0x9e, 0x0c, 0x62, 0xca, 0xa2, 0xeb, 0x44, 0xd7, 0x4c, 0x60, 0x69, 0x6e, 0xfd, 0x75, 0x33, 161 0xac, 0xe0, 0x12, 0x47, 0xff, 0x61, 0x6f, 0x5e, 0x14, 0xac, 0x52, 0x5b, 0xc7, 0xef, 0xf8, 0xa8, 162 0xfd, 0xe4, 0xe3, 0xf3, 0x55, 0xf7, 0xdf, 0x7a, 0x6b, 0x80, 0xa7, 0xad, 0x01, 0x5e, 0xb6, 0x06, 163 0x78, 0xdc, 0x19, 0x60, 0xbd, 0x33, 0xc0, 0xed, 0xb7, 0xcf, 0x0b, 0x11, 0x49, 0xe0, 0x37, 0xd5, 164 0xf3, 0xfd, 0x79, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x85, 0xc2, 0xfd, 0xda, 0x2d, 0x02, 0x00, 0x00, 165 } 166 167 func (m *ResultStatus) Marshal() (dAtA []byte, err error) { 168 size := m.Size() 169 dAtA = make([]byte, size) 170 n, err := m.MarshalTo(dAtA) 171 if err != nil { 172 return nil, err 173 } 174 return dAtA[:n], nil 175 } 176 177 func (m *ResultStatus) MarshalTo(dAtA []byte) (int, error) { 178 var i int 179 _ = i 180 var l int 181 _ = l 182 if len(m.ChainID) > 0 { 183 dAtA[i] = 0xa 184 i++ 185 i = encodeVarintRpc(dAtA, i, uint64(len(m.ChainID))) 186 i += copy(dAtA[i:], m.ChainID) 187 } 188 if len(m.RunID) > 0 { 189 dAtA[i] = 0x12 190 i++ 191 i = encodeVarintRpc(dAtA, i, uint64(len(m.RunID))) 192 i += copy(dAtA[i:], m.RunID) 193 } 194 if len(m.BurrowVersion) > 0 { 195 dAtA[i] = 0x1a 196 i++ 197 i = encodeVarintRpc(dAtA, i, uint64(len(m.BurrowVersion))) 198 i += copy(dAtA[i:], m.BurrowVersion) 199 } 200 dAtA[i] = 0x22 201 i++ 202 i = encodeVarintRpc(dAtA, i, uint64(m.GenesisHash.Size())) 203 n1, err := m.GenesisHash.MarshalTo(dAtA[i:]) 204 if err != nil { 205 return 0, err 206 } 207 i += n1 208 if m.NodeInfo != nil { 209 dAtA[i] = 0x2a 210 i++ 211 i = encodeVarintRpc(dAtA, i, uint64(m.NodeInfo.Size())) 212 n2, err := m.NodeInfo.MarshalTo(dAtA[i:]) 213 if err != nil { 214 return 0, err 215 } 216 i += n2 217 } 218 if m.SyncInfo != nil { 219 dAtA[i] = 0x32 220 i++ 221 i = encodeVarintRpc(dAtA, i, uint64(m.SyncInfo.Size())) 222 n3, err := m.SyncInfo.MarshalTo(dAtA[i:]) 223 if err != nil { 224 return 0, err 225 } 226 i += n3 227 } 228 if m.ValidatorInfo != nil { 229 dAtA[i] = 0x3a 230 i++ 231 i = encodeVarintRpc(dAtA, i, uint64(m.ValidatorInfo.Size())) 232 n4, err := m.ValidatorInfo.MarshalTo(dAtA[i:]) 233 if err != nil { 234 return 0, err 235 } 236 i += n4 237 } 238 if m.CatchingUp { 239 dAtA[i] = 0x40 240 i++ 241 if m.CatchingUp { 242 dAtA[i] = 1 243 } else { 244 dAtA[i] = 0 245 } 246 i++ 247 } 248 if m.XXX_unrecognized != nil { 249 i += copy(dAtA[i:], m.XXX_unrecognized) 250 } 251 return i, nil 252 } 253 254 func encodeVarintRpc(dAtA []byte, offset int, v uint64) int { 255 for v >= 1<<7 { 256 dAtA[offset] = uint8(v&0x7f | 0x80) 257 v >>= 7 258 offset++ 259 } 260 dAtA[offset] = uint8(v) 261 return offset + 1 262 } 263 func (m *ResultStatus) Size() (n int) { 264 if m == nil { 265 return 0 266 } 267 var l int 268 _ = l 269 l = len(m.ChainID) 270 if l > 0 { 271 n += 1 + l + sovRpc(uint64(l)) 272 } 273 l = len(m.RunID) 274 if l > 0 { 275 n += 1 + l + sovRpc(uint64(l)) 276 } 277 l = len(m.BurrowVersion) 278 if l > 0 { 279 n += 1 + l + sovRpc(uint64(l)) 280 } 281 l = m.GenesisHash.Size() 282 n += 1 + l + sovRpc(uint64(l)) 283 if m.NodeInfo != nil { 284 l = m.NodeInfo.Size() 285 n += 1 + l + sovRpc(uint64(l)) 286 } 287 if m.SyncInfo != nil { 288 l = m.SyncInfo.Size() 289 n += 1 + l + sovRpc(uint64(l)) 290 } 291 if m.ValidatorInfo != nil { 292 l = m.ValidatorInfo.Size() 293 n += 1 + l + sovRpc(uint64(l)) 294 } 295 if m.CatchingUp { 296 n += 2 297 } 298 if m.XXX_unrecognized != nil { 299 n += len(m.XXX_unrecognized) 300 } 301 return n 302 } 303 304 func sovRpc(x uint64) (n int) { 305 for { 306 n++ 307 x >>= 7 308 if x == 0 { 309 break 310 } 311 } 312 return n 313 } 314 func sozRpc(x uint64) (n int) { 315 return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 316 } 317 func (m *ResultStatus) Unmarshal(dAtA []byte) error { 318 l := len(dAtA) 319 iNdEx := 0 320 for iNdEx < l { 321 preIndex := iNdEx 322 var wire uint64 323 for shift := uint(0); ; shift += 7 { 324 if shift >= 64 { 325 return ErrIntOverflowRpc 326 } 327 if iNdEx >= l { 328 return io.ErrUnexpectedEOF 329 } 330 b := dAtA[iNdEx] 331 iNdEx++ 332 wire |= uint64(b&0x7F) << shift 333 if b < 0x80 { 334 break 335 } 336 } 337 fieldNum := int32(wire >> 3) 338 wireType := int(wire & 0x7) 339 if wireType == 4 { 340 return fmt.Errorf("proto: ResultStatus: wiretype end group for non-group") 341 } 342 if fieldNum <= 0 { 343 return fmt.Errorf("proto: ResultStatus: illegal tag %d (wire type %d)", fieldNum, wire) 344 } 345 switch fieldNum { 346 case 1: 347 if wireType != 2 { 348 return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) 349 } 350 var stringLen uint64 351 for shift := uint(0); ; shift += 7 { 352 if shift >= 64 { 353 return ErrIntOverflowRpc 354 } 355 if iNdEx >= l { 356 return io.ErrUnexpectedEOF 357 } 358 b := dAtA[iNdEx] 359 iNdEx++ 360 stringLen |= uint64(b&0x7F) << shift 361 if b < 0x80 { 362 break 363 } 364 } 365 intStringLen := int(stringLen) 366 if intStringLen < 0 { 367 return ErrInvalidLengthRpc 368 } 369 postIndex := iNdEx + intStringLen 370 if postIndex < 0 { 371 return ErrInvalidLengthRpc 372 } 373 if postIndex > l { 374 return io.ErrUnexpectedEOF 375 } 376 m.ChainID = string(dAtA[iNdEx:postIndex]) 377 iNdEx = postIndex 378 case 2: 379 if wireType != 2 { 380 return fmt.Errorf("proto: wrong wireType = %d for field RunID", wireType) 381 } 382 var stringLen uint64 383 for shift := uint(0); ; shift += 7 { 384 if shift >= 64 { 385 return ErrIntOverflowRpc 386 } 387 if iNdEx >= l { 388 return io.ErrUnexpectedEOF 389 } 390 b := dAtA[iNdEx] 391 iNdEx++ 392 stringLen |= uint64(b&0x7F) << shift 393 if b < 0x80 { 394 break 395 } 396 } 397 intStringLen := int(stringLen) 398 if intStringLen < 0 { 399 return ErrInvalidLengthRpc 400 } 401 postIndex := iNdEx + intStringLen 402 if postIndex < 0 { 403 return ErrInvalidLengthRpc 404 } 405 if postIndex > l { 406 return io.ErrUnexpectedEOF 407 } 408 m.RunID = string(dAtA[iNdEx:postIndex]) 409 iNdEx = postIndex 410 case 3: 411 if wireType != 2 { 412 return fmt.Errorf("proto: wrong wireType = %d for field BurrowVersion", wireType) 413 } 414 var stringLen uint64 415 for shift := uint(0); ; shift += 7 { 416 if shift >= 64 { 417 return ErrIntOverflowRpc 418 } 419 if iNdEx >= l { 420 return io.ErrUnexpectedEOF 421 } 422 b := dAtA[iNdEx] 423 iNdEx++ 424 stringLen |= uint64(b&0x7F) << shift 425 if b < 0x80 { 426 break 427 } 428 } 429 intStringLen := int(stringLen) 430 if intStringLen < 0 { 431 return ErrInvalidLengthRpc 432 } 433 postIndex := iNdEx + intStringLen 434 if postIndex < 0 { 435 return ErrInvalidLengthRpc 436 } 437 if postIndex > l { 438 return io.ErrUnexpectedEOF 439 } 440 m.BurrowVersion = string(dAtA[iNdEx:postIndex]) 441 iNdEx = postIndex 442 case 4: 443 if wireType != 2 { 444 return fmt.Errorf("proto: wrong wireType = %d for field GenesisHash", wireType) 445 } 446 var byteLen int 447 for shift := uint(0); ; shift += 7 { 448 if shift >= 64 { 449 return ErrIntOverflowRpc 450 } 451 if iNdEx >= l { 452 return io.ErrUnexpectedEOF 453 } 454 b := dAtA[iNdEx] 455 iNdEx++ 456 byteLen |= int(b&0x7F) << shift 457 if b < 0x80 { 458 break 459 } 460 } 461 if byteLen < 0 { 462 return ErrInvalidLengthRpc 463 } 464 postIndex := iNdEx + byteLen 465 if postIndex < 0 { 466 return ErrInvalidLengthRpc 467 } 468 if postIndex > l { 469 return io.ErrUnexpectedEOF 470 } 471 if err := m.GenesisHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 472 return err 473 } 474 iNdEx = postIndex 475 case 5: 476 if wireType != 2 { 477 return fmt.Errorf("proto: wrong wireType = %d for field NodeInfo", wireType) 478 } 479 var msglen int 480 for shift := uint(0); ; shift += 7 { 481 if shift >= 64 { 482 return ErrIntOverflowRpc 483 } 484 if iNdEx >= l { 485 return io.ErrUnexpectedEOF 486 } 487 b := dAtA[iNdEx] 488 iNdEx++ 489 msglen |= int(b&0x7F) << shift 490 if b < 0x80 { 491 break 492 } 493 } 494 if msglen < 0 { 495 return ErrInvalidLengthRpc 496 } 497 postIndex := iNdEx + msglen 498 if postIndex < 0 { 499 return ErrInvalidLengthRpc 500 } 501 if postIndex > l { 502 return io.ErrUnexpectedEOF 503 } 504 if m.NodeInfo == nil { 505 m.NodeInfo = &tendermint.NodeInfo{} 506 } 507 if err := m.NodeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 508 return err 509 } 510 iNdEx = postIndex 511 case 6: 512 if wireType != 2 { 513 return fmt.Errorf("proto: wrong wireType = %d for field SyncInfo", wireType) 514 } 515 var msglen int 516 for shift := uint(0); ; shift += 7 { 517 if shift >= 64 { 518 return ErrIntOverflowRpc 519 } 520 if iNdEx >= l { 521 return io.ErrUnexpectedEOF 522 } 523 b := dAtA[iNdEx] 524 iNdEx++ 525 msglen |= int(b&0x7F) << shift 526 if b < 0x80 { 527 break 528 } 529 } 530 if msglen < 0 { 531 return ErrInvalidLengthRpc 532 } 533 postIndex := iNdEx + msglen 534 if postIndex < 0 { 535 return ErrInvalidLengthRpc 536 } 537 if postIndex > l { 538 return io.ErrUnexpectedEOF 539 } 540 if m.SyncInfo == nil { 541 m.SyncInfo = &bcm.SyncInfo{} 542 } 543 if err := m.SyncInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 544 return err 545 } 546 iNdEx = postIndex 547 case 7: 548 if wireType != 2 { 549 return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType) 550 } 551 var msglen int 552 for shift := uint(0); ; shift += 7 { 553 if shift >= 64 { 554 return ErrIntOverflowRpc 555 } 556 if iNdEx >= l { 557 return io.ErrUnexpectedEOF 558 } 559 b := dAtA[iNdEx] 560 iNdEx++ 561 msglen |= int(b&0x7F) << shift 562 if b < 0x80 { 563 break 564 } 565 } 566 if msglen < 0 { 567 return ErrInvalidLengthRpc 568 } 569 postIndex := iNdEx + msglen 570 if postIndex < 0 { 571 return ErrInvalidLengthRpc 572 } 573 if postIndex > l { 574 return io.ErrUnexpectedEOF 575 } 576 if m.ValidatorInfo == nil { 577 m.ValidatorInfo = &validator.Validator{} 578 } 579 if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 580 return err 581 } 582 iNdEx = postIndex 583 case 8: 584 if wireType != 0 { 585 return fmt.Errorf("proto: wrong wireType = %d for field CatchingUp", wireType) 586 } 587 var v int 588 for shift := uint(0); ; shift += 7 { 589 if shift >= 64 { 590 return ErrIntOverflowRpc 591 } 592 if iNdEx >= l { 593 return io.ErrUnexpectedEOF 594 } 595 b := dAtA[iNdEx] 596 iNdEx++ 597 v |= int(b&0x7F) << shift 598 if b < 0x80 { 599 break 600 } 601 } 602 m.CatchingUp = bool(v != 0) 603 default: 604 iNdEx = preIndex 605 skippy, err := skipRpc(dAtA[iNdEx:]) 606 if err != nil { 607 return err 608 } 609 if skippy < 0 { 610 return ErrInvalidLengthRpc 611 } 612 if (iNdEx + skippy) < 0 { 613 return ErrInvalidLengthRpc 614 } 615 if (iNdEx + skippy) > l { 616 return io.ErrUnexpectedEOF 617 } 618 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 619 iNdEx += skippy 620 } 621 } 622 623 if iNdEx > l { 624 return io.ErrUnexpectedEOF 625 } 626 return nil 627 } 628 func skipRpc(dAtA []byte) (n int, err error) { 629 l := len(dAtA) 630 iNdEx := 0 631 for iNdEx < l { 632 var wire uint64 633 for shift := uint(0); ; shift += 7 { 634 if shift >= 64 { 635 return 0, ErrIntOverflowRpc 636 } 637 if iNdEx >= l { 638 return 0, io.ErrUnexpectedEOF 639 } 640 b := dAtA[iNdEx] 641 iNdEx++ 642 wire |= (uint64(b) & 0x7F) << shift 643 if b < 0x80 { 644 break 645 } 646 } 647 wireType := int(wire & 0x7) 648 switch wireType { 649 case 0: 650 for shift := uint(0); ; shift += 7 { 651 if shift >= 64 { 652 return 0, ErrIntOverflowRpc 653 } 654 if iNdEx >= l { 655 return 0, io.ErrUnexpectedEOF 656 } 657 iNdEx++ 658 if dAtA[iNdEx-1] < 0x80 { 659 break 660 } 661 } 662 return iNdEx, nil 663 case 1: 664 iNdEx += 8 665 return iNdEx, nil 666 case 2: 667 var length int 668 for shift := uint(0); ; shift += 7 { 669 if shift >= 64 { 670 return 0, ErrIntOverflowRpc 671 } 672 if iNdEx >= l { 673 return 0, io.ErrUnexpectedEOF 674 } 675 b := dAtA[iNdEx] 676 iNdEx++ 677 length |= (int(b) & 0x7F) << shift 678 if b < 0x80 { 679 break 680 } 681 } 682 if length < 0 { 683 return 0, ErrInvalidLengthRpc 684 } 685 iNdEx += length 686 if iNdEx < 0 { 687 return 0, ErrInvalidLengthRpc 688 } 689 return iNdEx, nil 690 case 3: 691 for { 692 var innerWire uint64 693 var start int = iNdEx 694 for shift := uint(0); ; shift += 7 { 695 if shift >= 64 { 696 return 0, ErrIntOverflowRpc 697 } 698 if iNdEx >= l { 699 return 0, io.ErrUnexpectedEOF 700 } 701 b := dAtA[iNdEx] 702 iNdEx++ 703 innerWire |= (uint64(b) & 0x7F) << shift 704 if b < 0x80 { 705 break 706 } 707 } 708 innerWireType := int(innerWire & 0x7) 709 if innerWireType == 4 { 710 break 711 } 712 next, err := skipRpc(dAtA[start:]) 713 if err != nil { 714 return 0, err 715 } 716 iNdEx = start + next 717 if iNdEx < 0 { 718 return 0, ErrInvalidLengthRpc 719 } 720 } 721 return iNdEx, nil 722 case 4: 723 return iNdEx, nil 724 case 5: 725 iNdEx += 4 726 return iNdEx, nil 727 default: 728 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 729 } 730 } 731 panic("unreachable") 732 } 733 734 var ( 735 ErrInvalidLengthRpc = fmt.Errorf("proto: negative length found during unmarshaling") 736 ErrIntOverflowRpc = fmt.Errorf("proto: integer overflow") 737 )