github.com/supragya/TendermintConnector@v0.0.0-20210619045051-113e32b84fb1/chains/tm34/proto/tendermint/version/types.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: tendermint/version/types.proto 3 4 package version 5 6 import ( 7 fmt "fmt" 8 _ "github.com/gogo/protobuf/gogoproto" 9 proto "github.com/gogo/protobuf/proto" 10 io "io" 11 math "math" 12 math_bits "math/bits" 13 ) 14 15 // Reference imports to suppress errors if they are not otherwise used. 16 var _ = proto.Marshal 17 var _ = fmt.Errorf 18 var _ = math.Inf 19 20 // This is a compile-time assertion to ensure that this generated file 21 // is compatible with the proto package it is being compiled against. 22 // A compilation error at this line likely means your copy of the 23 // proto package needs to be updated. 24 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 25 26 // App includes the protocol and software version for the application. 27 // This information is included in ResponseInfo. The App.Protocol can be 28 // updated in ResponseEndBlock. 29 type App struct { 30 Protocol uint64 `protobuf:"varint,1,opt,name=protocol,proto3" json:"protocol,omitempty"` 31 Software string `protobuf:"bytes,2,opt,name=software,proto3" json:"software,omitempty"` 32 } 33 34 func (m *App) Reset() { *m = App{} } 35 func (m *App) String() string { return proto.CompactTextString(m) } 36 func (*App) ProtoMessage() {} 37 func (*App) Descriptor() ([]byte, []int) { 38 return fileDescriptor_f9b42966edc5edad, []int{0} 39 } 40 func (m *App) XXX_Unmarshal(b []byte) error { 41 return m.Unmarshal(b) 42 } 43 func (m *App) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 44 if deterministic { 45 return xxx_messageInfo_App.Marshal(b, m, deterministic) 46 } else { 47 b = b[:cap(b)] 48 n, err := m.MarshalToSizedBuffer(b) 49 if err != nil { 50 return nil, err 51 } 52 return b[:n], nil 53 } 54 } 55 func (m *App) XXX_Merge(src proto.Message) { 56 xxx_messageInfo_App.Merge(m, src) 57 } 58 func (m *App) XXX_Size() int { 59 return m.Size() 60 } 61 func (m *App) XXX_DiscardUnknown() { 62 xxx_messageInfo_App.DiscardUnknown(m) 63 } 64 65 var xxx_messageInfo_App proto.InternalMessageInfo 66 67 func (m *App) GetProtocol() uint64 { 68 if m != nil { 69 return m.Protocol 70 } 71 return 0 72 } 73 74 func (m *App) GetSoftware() string { 75 if m != nil { 76 return m.Software 77 } 78 return "" 79 } 80 81 // Consensus captures the consensus rules for processing a block in the blockchain, 82 // including all blockchain data structures and the rules of the application's 83 // state transition machine. 84 type Consensus struct { 85 Block uint64 `protobuf:"varint,1,opt,name=block,proto3" json:"block,omitempty"` 86 App uint64 `protobuf:"varint,2,opt,name=app,proto3" json:"app,omitempty"` 87 } 88 89 func (m *Consensus) Reset() { *m = Consensus{} } 90 func (m *Consensus) String() string { return proto.CompactTextString(m) } 91 func (*Consensus) ProtoMessage() {} 92 func (*Consensus) Descriptor() ([]byte, []int) { 93 return fileDescriptor_f9b42966edc5edad, []int{1} 94 } 95 func (m *Consensus) XXX_Unmarshal(b []byte) error { 96 return m.Unmarshal(b) 97 } 98 func (m *Consensus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 99 if deterministic { 100 return xxx_messageInfo_Consensus.Marshal(b, m, deterministic) 101 } else { 102 b = b[:cap(b)] 103 n, err := m.MarshalToSizedBuffer(b) 104 if err != nil { 105 return nil, err 106 } 107 return b[:n], nil 108 } 109 } 110 func (m *Consensus) XXX_Merge(src proto.Message) { 111 xxx_messageInfo_Consensus.Merge(m, src) 112 } 113 func (m *Consensus) XXX_Size() int { 114 return m.Size() 115 } 116 func (m *Consensus) XXX_DiscardUnknown() { 117 xxx_messageInfo_Consensus.DiscardUnknown(m) 118 } 119 120 var xxx_messageInfo_Consensus proto.InternalMessageInfo 121 122 func (m *Consensus) GetBlock() uint64 { 123 if m != nil { 124 return m.Block 125 } 126 return 0 127 } 128 129 func (m *Consensus) GetApp() uint64 { 130 if m != nil { 131 return m.App 132 } 133 return 0 134 } 135 136 func init() { 137 proto.RegisterType((*App)(nil), "tendermint.version.App") 138 proto.RegisterType((*Consensus)(nil), "tendermint.version.Consensus") 139 } 140 141 func init() { proto.RegisterFile("tendermint/version/types.proto", fileDescriptor_f9b42966edc5edad) } 142 143 var fileDescriptor_f9b42966edc5edad = []byte{ 144 // 248 bytes of a gzipped FileDescriptorProto 145 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2b, 0x49, 0xcd, 0x4b, 146 0x49, 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0xd3, 0x2f, 147 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x42, 0xc8, 0xeb, 0x41, 148 0xe5, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xd2, 0xfa, 0x20, 0x16, 0x44, 0xa5, 0x92, 0x2d, 149 0x17, 0xb3, 0x63, 0x41, 0x81, 0x90, 0x14, 0x17, 0x07, 0x98, 0x9f, 0x9c, 0x9f, 0x23, 0xc1, 0xa8, 150 0xc0, 0xa8, 0xc1, 0x12, 0x04, 0xe7, 0x83, 0xe4, 0x8a, 0xf3, 0xd3, 0x4a, 0xca, 0x13, 0x8b, 0x52, 151 0x25, 0x98, 0x14, 0x18, 0x35, 0x38, 0x83, 0xe0, 0x7c, 0x25, 0x4b, 0x2e, 0x4e, 0xe7, 0xfc, 0xbc, 152 0xe2, 0xd4, 0xbc, 0xe2, 0xd2, 0x62, 0x21, 0x11, 0x2e, 0xd6, 0xa4, 0x9c, 0xfc, 0xe4, 0x6c, 0xa8, 153 0x09, 0x10, 0x8e, 0x90, 0x00, 0x17, 0x73, 0x62, 0x41, 0x01, 0x58, 0x27, 0x4b, 0x10, 0x88, 0x69, 154 0xc5, 0xf2, 0x62, 0x81, 0x3c, 0xa3, 0x53, 0xda, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 155 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 156 0x31, 0x44, 0xf9, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x17, 0x97, 157 0x16, 0x14, 0x25, 0xa6, 0x57, 0x26, 0xea, 0x87, 0xc0, 0x7d, 0xe4, 0x9c, 0x9f, 0x97, 0x97, 0x9a, 158 0x5c, 0x92, 0x5f, 0xa4, 0x9f, 0x9c, 0x91, 0x98, 0x99, 0x57, 0xac, 0x5f, 0x92, 0x6b, 0x6c, 0xa2, 159 0x0f, 0xf1, 0x19, 0x66, 0xb8, 0x24, 0xb1, 0x81, 0x65, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 160 0x68, 0xe1, 0x61, 0x1c, 0x34, 0x01, 0x00, 0x00, 161 } 162 163 func (this *Consensus) Equal(that interface{}) bool { 164 if that == nil { 165 return this == nil 166 } 167 168 that1, ok := that.(*Consensus) 169 if !ok { 170 that2, ok := that.(Consensus) 171 if ok { 172 that1 = &that2 173 } else { 174 return false 175 } 176 } 177 if that1 == nil { 178 return this == nil 179 } else if this == nil { 180 return false 181 } 182 if this.Block != that1.Block { 183 return false 184 } 185 if this.App != that1.App { 186 return false 187 } 188 return true 189 } 190 func (m *App) Marshal() (dAtA []byte, err error) { 191 size := m.Size() 192 dAtA = make([]byte, size) 193 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 194 if err != nil { 195 return nil, err 196 } 197 return dAtA[:n], nil 198 } 199 200 func (m *App) MarshalTo(dAtA []byte) (int, error) { 201 size := m.Size() 202 return m.MarshalToSizedBuffer(dAtA[:size]) 203 } 204 205 func (m *App) MarshalToSizedBuffer(dAtA []byte) (int, error) { 206 i := len(dAtA) 207 _ = i 208 var l int 209 _ = l 210 if len(m.Software) > 0 { 211 i -= len(m.Software) 212 copy(dAtA[i:], m.Software) 213 i = encodeVarintTypes(dAtA, i, uint64(len(m.Software))) 214 i-- 215 dAtA[i] = 0x12 216 } 217 if m.Protocol != 0 { 218 i = encodeVarintTypes(dAtA, i, uint64(m.Protocol)) 219 i-- 220 dAtA[i] = 0x8 221 } 222 return len(dAtA) - i, nil 223 } 224 225 func (m *Consensus) Marshal() (dAtA []byte, err error) { 226 size := m.Size() 227 dAtA = make([]byte, size) 228 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 229 if err != nil { 230 return nil, err 231 } 232 return dAtA[:n], nil 233 } 234 235 func (m *Consensus) MarshalTo(dAtA []byte) (int, error) { 236 size := m.Size() 237 return m.MarshalToSizedBuffer(dAtA[:size]) 238 } 239 240 func (m *Consensus) MarshalToSizedBuffer(dAtA []byte) (int, error) { 241 i := len(dAtA) 242 _ = i 243 var l int 244 _ = l 245 if m.App != 0 { 246 i = encodeVarintTypes(dAtA, i, uint64(m.App)) 247 i-- 248 dAtA[i] = 0x10 249 } 250 if m.Block != 0 { 251 i = encodeVarintTypes(dAtA, i, uint64(m.Block)) 252 i-- 253 dAtA[i] = 0x8 254 } 255 return len(dAtA) - i, nil 256 } 257 258 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { 259 offset -= sovTypes(v) 260 base := offset 261 for v >= 1<<7 { 262 dAtA[offset] = uint8(v&0x7f | 0x80) 263 v >>= 7 264 offset++ 265 } 266 dAtA[offset] = uint8(v) 267 return base 268 } 269 func (m *App) Size() (n int) { 270 if m == nil { 271 return 0 272 } 273 var l int 274 _ = l 275 if m.Protocol != 0 { 276 n += 1 + sovTypes(uint64(m.Protocol)) 277 } 278 l = len(m.Software) 279 if l > 0 { 280 n += 1 + l + sovTypes(uint64(l)) 281 } 282 return n 283 } 284 285 func (m *Consensus) Size() (n int) { 286 if m == nil { 287 return 0 288 } 289 var l int 290 _ = l 291 if m.Block != 0 { 292 n += 1 + sovTypes(uint64(m.Block)) 293 } 294 if m.App != 0 { 295 n += 1 + sovTypes(uint64(m.App)) 296 } 297 return n 298 } 299 300 func sovTypes(x uint64) (n int) { 301 return (math_bits.Len64(x|1) + 6) / 7 302 } 303 func sozTypes(x uint64) (n int) { 304 return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 305 } 306 func (m *App) Unmarshal(dAtA []byte) error { 307 l := len(dAtA) 308 iNdEx := 0 309 for iNdEx < l { 310 preIndex := iNdEx 311 var wire uint64 312 for shift := uint(0); ; shift += 7 { 313 if shift >= 64 { 314 return ErrIntOverflowTypes 315 } 316 if iNdEx >= l { 317 return io.ErrUnexpectedEOF 318 } 319 b := dAtA[iNdEx] 320 iNdEx++ 321 wire |= uint64(b&0x7F) << shift 322 if b < 0x80 { 323 break 324 } 325 } 326 fieldNum := int32(wire >> 3) 327 wireType := int(wire & 0x7) 328 if wireType == 4 { 329 return fmt.Errorf("proto: App: wiretype end group for non-group") 330 } 331 if fieldNum <= 0 { 332 return fmt.Errorf("proto: App: illegal tag %d (wire type %d)", fieldNum, wire) 333 } 334 switch fieldNum { 335 case 1: 336 if wireType != 0 { 337 return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) 338 } 339 m.Protocol = 0 340 for shift := uint(0); ; shift += 7 { 341 if shift >= 64 { 342 return ErrIntOverflowTypes 343 } 344 if iNdEx >= l { 345 return io.ErrUnexpectedEOF 346 } 347 b := dAtA[iNdEx] 348 iNdEx++ 349 m.Protocol |= uint64(b&0x7F) << shift 350 if b < 0x80 { 351 break 352 } 353 } 354 case 2: 355 if wireType != 2 { 356 return fmt.Errorf("proto: wrong wireType = %d for field Software", wireType) 357 } 358 var stringLen uint64 359 for shift := uint(0); ; shift += 7 { 360 if shift >= 64 { 361 return ErrIntOverflowTypes 362 } 363 if iNdEx >= l { 364 return io.ErrUnexpectedEOF 365 } 366 b := dAtA[iNdEx] 367 iNdEx++ 368 stringLen |= uint64(b&0x7F) << shift 369 if b < 0x80 { 370 break 371 } 372 } 373 intStringLen := int(stringLen) 374 if intStringLen < 0 { 375 return ErrInvalidLengthTypes 376 } 377 postIndex := iNdEx + intStringLen 378 if postIndex < 0 { 379 return ErrInvalidLengthTypes 380 } 381 if postIndex > l { 382 return io.ErrUnexpectedEOF 383 } 384 m.Software = string(dAtA[iNdEx:postIndex]) 385 iNdEx = postIndex 386 default: 387 iNdEx = preIndex 388 skippy, err := skipTypes(dAtA[iNdEx:]) 389 if err != nil { 390 return err 391 } 392 if (skippy < 0) || (iNdEx+skippy) < 0 { 393 return ErrInvalidLengthTypes 394 } 395 if (iNdEx + skippy) > l { 396 return io.ErrUnexpectedEOF 397 } 398 iNdEx += skippy 399 } 400 } 401 402 if iNdEx > l { 403 return io.ErrUnexpectedEOF 404 } 405 return nil 406 } 407 func (m *Consensus) Unmarshal(dAtA []byte) error { 408 l := len(dAtA) 409 iNdEx := 0 410 for iNdEx < l { 411 preIndex := iNdEx 412 var wire uint64 413 for shift := uint(0); ; shift += 7 { 414 if shift >= 64 { 415 return ErrIntOverflowTypes 416 } 417 if iNdEx >= l { 418 return io.ErrUnexpectedEOF 419 } 420 b := dAtA[iNdEx] 421 iNdEx++ 422 wire |= uint64(b&0x7F) << shift 423 if b < 0x80 { 424 break 425 } 426 } 427 fieldNum := int32(wire >> 3) 428 wireType := int(wire & 0x7) 429 if wireType == 4 { 430 return fmt.Errorf("proto: Consensus: wiretype end group for non-group") 431 } 432 if fieldNum <= 0 { 433 return fmt.Errorf("proto: Consensus: illegal tag %d (wire type %d)", fieldNum, wire) 434 } 435 switch fieldNum { 436 case 1: 437 if wireType != 0 { 438 return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) 439 } 440 m.Block = 0 441 for shift := uint(0); ; shift += 7 { 442 if shift >= 64 { 443 return ErrIntOverflowTypes 444 } 445 if iNdEx >= l { 446 return io.ErrUnexpectedEOF 447 } 448 b := dAtA[iNdEx] 449 iNdEx++ 450 m.Block |= uint64(b&0x7F) << shift 451 if b < 0x80 { 452 break 453 } 454 } 455 case 2: 456 if wireType != 0 { 457 return fmt.Errorf("proto: wrong wireType = %d for field App", wireType) 458 } 459 m.App = 0 460 for shift := uint(0); ; shift += 7 { 461 if shift >= 64 { 462 return ErrIntOverflowTypes 463 } 464 if iNdEx >= l { 465 return io.ErrUnexpectedEOF 466 } 467 b := dAtA[iNdEx] 468 iNdEx++ 469 m.App |= uint64(b&0x7F) << shift 470 if b < 0x80 { 471 break 472 } 473 } 474 default: 475 iNdEx = preIndex 476 skippy, err := skipTypes(dAtA[iNdEx:]) 477 if err != nil { 478 return err 479 } 480 if (skippy < 0) || (iNdEx+skippy) < 0 { 481 return ErrInvalidLengthTypes 482 } 483 if (iNdEx + skippy) > l { 484 return io.ErrUnexpectedEOF 485 } 486 iNdEx += skippy 487 } 488 } 489 490 if iNdEx > l { 491 return io.ErrUnexpectedEOF 492 } 493 return nil 494 } 495 func skipTypes(dAtA []byte) (n int, err error) { 496 l := len(dAtA) 497 iNdEx := 0 498 depth := 0 499 for iNdEx < l { 500 var wire uint64 501 for shift := uint(0); ; shift += 7 { 502 if shift >= 64 { 503 return 0, ErrIntOverflowTypes 504 } 505 if iNdEx >= l { 506 return 0, io.ErrUnexpectedEOF 507 } 508 b := dAtA[iNdEx] 509 iNdEx++ 510 wire |= (uint64(b) & 0x7F) << shift 511 if b < 0x80 { 512 break 513 } 514 } 515 wireType := int(wire & 0x7) 516 switch wireType { 517 case 0: 518 for shift := uint(0); ; shift += 7 { 519 if shift >= 64 { 520 return 0, ErrIntOverflowTypes 521 } 522 if iNdEx >= l { 523 return 0, io.ErrUnexpectedEOF 524 } 525 iNdEx++ 526 if dAtA[iNdEx-1] < 0x80 { 527 break 528 } 529 } 530 case 1: 531 iNdEx += 8 532 case 2: 533 var length int 534 for shift := uint(0); ; shift += 7 { 535 if shift >= 64 { 536 return 0, ErrIntOverflowTypes 537 } 538 if iNdEx >= l { 539 return 0, io.ErrUnexpectedEOF 540 } 541 b := dAtA[iNdEx] 542 iNdEx++ 543 length |= (int(b) & 0x7F) << shift 544 if b < 0x80 { 545 break 546 } 547 } 548 if length < 0 { 549 return 0, ErrInvalidLengthTypes 550 } 551 iNdEx += length 552 case 3: 553 depth++ 554 case 4: 555 if depth == 0 { 556 return 0, ErrUnexpectedEndOfGroupTypes 557 } 558 depth-- 559 case 5: 560 iNdEx += 4 561 default: 562 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 563 } 564 if iNdEx < 0 { 565 return 0, ErrInvalidLengthTypes 566 } 567 if depth == 0 { 568 return iNdEx, nil 569 } 570 } 571 return 0, io.ErrUnexpectedEOF 572 } 573 574 var ( 575 ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling") 576 ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") 577 ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group") 578 )