go.etcd.io/etcd@v3.3.27+incompatible/wal/walpb/record.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: record.proto 3 4 package walpb 5 6 import ( 7 fmt "fmt" 8 io "io" 9 math "math" 10 math_bits "math/bits" 11 12 _ "github.com/gogo/protobuf/gogoproto" 13 proto "github.com/golang/protobuf/proto" 14 ) 15 16 // Reference imports to suppress errors if they are not otherwise used. 17 var _ = proto.Marshal 18 var _ = fmt.Errorf 19 var _ = math.Inf 20 21 // This is a compile-time assertion to ensure that this generated file 22 // is compatible with the proto package it is being compiled against. 23 // A compilation error at this line likely means your copy of the 24 // proto package needs to be updated. 25 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 26 27 type Record struct { 28 Type int64 `protobuf:"varint,1,opt,name=type" json:"type"` 29 Crc uint32 `protobuf:"varint,2,opt,name=crc" json:"crc"` 30 Data []byte `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"` 31 XXX_NoUnkeyedLiteral struct{} `json:"-"` 32 XXX_unrecognized []byte `json:"-"` 33 XXX_sizecache int32 `json:"-"` 34 } 35 36 func (m *Record) Reset() { *m = Record{} } 37 func (m *Record) String() string { return proto.CompactTextString(m) } 38 func (*Record) ProtoMessage() {} 39 func (*Record) Descriptor() ([]byte, []int) { 40 return fileDescriptor_bf94fd919e302a1d, []int{0} 41 } 42 func (m *Record) XXX_Unmarshal(b []byte) error { 43 return m.Unmarshal(b) 44 } 45 func (m *Record) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 46 if deterministic { 47 return xxx_messageInfo_Record.Marshal(b, m, deterministic) 48 } else { 49 b = b[:cap(b)] 50 n, err := m.MarshalToSizedBuffer(b) 51 if err != nil { 52 return nil, err 53 } 54 return b[:n], nil 55 } 56 } 57 func (m *Record) XXX_Merge(src proto.Message) { 58 xxx_messageInfo_Record.Merge(m, src) 59 } 60 func (m *Record) XXX_Size() int { 61 return m.Size() 62 } 63 func (m *Record) XXX_DiscardUnknown() { 64 xxx_messageInfo_Record.DiscardUnknown(m) 65 } 66 67 var xxx_messageInfo_Record proto.InternalMessageInfo 68 69 type Snapshot struct { 70 Index uint64 `protobuf:"varint,1,opt,name=index" json:"index"` 71 Term uint64 `protobuf:"varint,2,opt,name=term" json:"term"` 72 XXX_NoUnkeyedLiteral struct{} `json:"-"` 73 XXX_unrecognized []byte `json:"-"` 74 XXX_sizecache int32 `json:"-"` 75 } 76 77 func (m *Snapshot) Reset() { *m = Snapshot{} } 78 func (m *Snapshot) String() string { return proto.CompactTextString(m) } 79 func (*Snapshot) ProtoMessage() {} 80 func (*Snapshot) Descriptor() ([]byte, []int) { 81 return fileDescriptor_bf94fd919e302a1d, []int{1} 82 } 83 func (m *Snapshot) XXX_Unmarshal(b []byte) error { 84 return m.Unmarshal(b) 85 } 86 func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 87 if deterministic { 88 return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic) 89 } else { 90 b = b[:cap(b)] 91 n, err := m.MarshalToSizedBuffer(b) 92 if err != nil { 93 return nil, err 94 } 95 return b[:n], nil 96 } 97 } 98 func (m *Snapshot) XXX_Merge(src proto.Message) { 99 xxx_messageInfo_Snapshot.Merge(m, src) 100 } 101 func (m *Snapshot) XXX_Size() int { 102 return m.Size() 103 } 104 func (m *Snapshot) XXX_DiscardUnknown() { 105 xxx_messageInfo_Snapshot.DiscardUnknown(m) 106 } 107 108 var xxx_messageInfo_Snapshot proto.InternalMessageInfo 109 110 func init() { 111 proto.RegisterType((*Record)(nil), "walpb.Record") 112 proto.RegisterType((*Snapshot)(nil), "walpb.Snapshot") 113 } 114 115 func init() { proto.RegisterFile("record.proto", fileDescriptor_bf94fd919e302a1d) } 116 117 var fileDescriptor_bf94fd919e302a1d = []byte{ 118 // 186 bytes of a gzipped FileDescriptorProto 119 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x4a, 0x4d, 0xce, 120 0x2f, 0x4a, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2d, 0x4f, 0xcc, 0x29, 0x48, 0x92, 121 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x8b, 0xe8, 0x83, 0x58, 0x10, 0x49, 0x25, 0x3f, 0x2e, 0xb6, 122 0x20, 0xb0, 0x62, 0x21, 0x09, 0x2e, 0x96, 0x92, 0xca, 0x82, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, 123 0x66, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xc0, 0x22, 0x42, 0x62, 0x5c, 0xcc, 0xc9, 0x45, 124 0xc9, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xbc, 0x50, 0x09, 0x90, 0x80, 0x90, 0x10, 0x17, 0x4b, 0x4a, 125 0x62, 0x49, 0xa2, 0x04, 0xb3, 0x02, 0xa3, 0x06, 0x4f, 0x10, 0x98, 0xad, 0xe4, 0xc0, 0xc5, 0x11, 126 0x9c, 0x97, 0x58, 0x50, 0x9c, 0x91, 0x5f, 0x22, 0x24, 0xc5, 0xc5, 0x9a, 0x99, 0x97, 0x92, 0x5a, 127 0x01, 0x36, 0x92, 0x05, 0xaa, 0x13, 0x22, 0x04, 0xb6, 0x2d, 0xb5, 0x28, 0x17, 0x6c, 0x28, 0x0b, 128 0xdc, 0xb6, 0xd4, 0xa2, 0x5c, 0x27, 0x91, 0x13, 0x0f, 0xe5, 0x18, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 129 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x19, 0x8f, 0xe5, 0x18, 0x00, 0x01, 0x00, 0x00, 130 0xff, 0xff, 0x7f, 0x5e, 0x5c, 0x46, 0xd3, 0x00, 0x00, 0x00, 131 } 132 133 func (m *Record) Marshal() (dAtA []byte, err error) { 134 size := m.Size() 135 dAtA = make([]byte, size) 136 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 137 if err != nil { 138 return nil, err 139 } 140 return dAtA[:n], nil 141 } 142 143 func (m *Record) MarshalTo(dAtA []byte) (int, error) { 144 size := m.Size() 145 return m.MarshalToSizedBuffer(dAtA[:size]) 146 } 147 148 func (m *Record) MarshalToSizedBuffer(dAtA []byte) (int, error) { 149 i := len(dAtA) 150 _ = i 151 var l int 152 _ = l 153 if m.XXX_unrecognized != nil { 154 i -= len(m.XXX_unrecognized) 155 copy(dAtA[i:], m.XXX_unrecognized) 156 } 157 if m.Data != nil { 158 i -= len(m.Data) 159 copy(dAtA[i:], m.Data) 160 i = encodeVarintRecord(dAtA, i, uint64(len(m.Data))) 161 i-- 162 dAtA[i] = 0x1a 163 } 164 i = encodeVarintRecord(dAtA, i, uint64(m.Crc)) 165 i-- 166 dAtA[i] = 0x10 167 i = encodeVarintRecord(dAtA, i, uint64(m.Type)) 168 i-- 169 dAtA[i] = 0x8 170 return len(dAtA) - i, nil 171 } 172 173 func (m *Snapshot) Marshal() (dAtA []byte, err error) { 174 size := m.Size() 175 dAtA = make([]byte, size) 176 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 177 if err != nil { 178 return nil, err 179 } 180 return dAtA[:n], nil 181 } 182 183 func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) { 184 size := m.Size() 185 return m.MarshalToSizedBuffer(dAtA[:size]) 186 } 187 188 func (m *Snapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { 189 i := len(dAtA) 190 _ = i 191 var l int 192 _ = l 193 if m.XXX_unrecognized != nil { 194 i -= len(m.XXX_unrecognized) 195 copy(dAtA[i:], m.XXX_unrecognized) 196 } 197 i = encodeVarintRecord(dAtA, i, uint64(m.Term)) 198 i-- 199 dAtA[i] = 0x10 200 i = encodeVarintRecord(dAtA, i, uint64(m.Index)) 201 i-- 202 dAtA[i] = 0x8 203 return len(dAtA) - i, nil 204 } 205 206 func encodeVarintRecord(dAtA []byte, offset int, v uint64) int { 207 offset -= sovRecord(v) 208 base := offset 209 for v >= 1<<7 { 210 dAtA[offset] = uint8(v&0x7f | 0x80) 211 v >>= 7 212 offset++ 213 } 214 dAtA[offset] = uint8(v) 215 return base 216 } 217 func (m *Record) Size() (n int) { 218 if m == nil { 219 return 0 220 } 221 var l int 222 _ = l 223 n += 1 + sovRecord(uint64(m.Type)) 224 n += 1 + sovRecord(uint64(m.Crc)) 225 if m.Data != nil { 226 l = len(m.Data) 227 n += 1 + l + sovRecord(uint64(l)) 228 } 229 if m.XXX_unrecognized != nil { 230 n += len(m.XXX_unrecognized) 231 } 232 return n 233 } 234 235 func (m *Snapshot) Size() (n int) { 236 if m == nil { 237 return 0 238 } 239 var l int 240 _ = l 241 n += 1 + sovRecord(uint64(m.Index)) 242 n += 1 + sovRecord(uint64(m.Term)) 243 if m.XXX_unrecognized != nil { 244 n += len(m.XXX_unrecognized) 245 } 246 return n 247 } 248 249 func sovRecord(x uint64) (n int) { 250 return (math_bits.Len64(x|1) + 6) / 7 251 } 252 func sozRecord(x uint64) (n int) { 253 return sovRecord(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 254 } 255 func (m *Record) Unmarshal(dAtA []byte) error { 256 l := len(dAtA) 257 iNdEx := 0 258 for iNdEx < l { 259 preIndex := iNdEx 260 var wire uint64 261 for shift := uint(0); ; shift += 7 { 262 if shift >= 64 { 263 return ErrIntOverflowRecord 264 } 265 if iNdEx >= l { 266 return io.ErrUnexpectedEOF 267 } 268 b := dAtA[iNdEx] 269 iNdEx++ 270 wire |= uint64(b&0x7F) << shift 271 if b < 0x80 { 272 break 273 } 274 } 275 fieldNum := int32(wire >> 3) 276 wireType := int(wire & 0x7) 277 if wireType == 4 { 278 return fmt.Errorf("proto: Record: wiretype end group for non-group") 279 } 280 if fieldNum <= 0 { 281 return fmt.Errorf("proto: Record: illegal tag %d (wire type %d)", fieldNum, wire) 282 } 283 switch fieldNum { 284 case 1: 285 if wireType != 0 { 286 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 287 } 288 m.Type = 0 289 for shift := uint(0); ; shift += 7 { 290 if shift >= 64 { 291 return ErrIntOverflowRecord 292 } 293 if iNdEx >= l { 294 return io.ErrUnexpectedEOF 295 } 296 b := dAtA[iNdEx] 297 iNdEx++ 298 m.Type |= int64(b&0x7F) << shift 299 if b < 0x80 { 300 break 301 } 302 } 303 case 2: 304 if wireType != 0 { 305 return fmt.Errorf("proto: wrong wireType = %d for field Crc", wireType) 306 } 307 m.Crc = 0 308 for shift := uint(0); ; shift += 7 { 309 if shift >= 64 { 310 return ErrIntOverflowRecord 311 } 312 if iNdEx >= l { 313 return io.ErrUnexpectedEOF 314 } 315 b := dAtA[iNdEx] 316 iNdEx++ 317 m.Crc |= uint32(b&0x7F) << shift 318 if b < 0x80 { 319 break 320 } 321 } 322 case 3: 323 if wireType != 2 { 324 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 325 } 326 var byteLen int 327 for shift := uint(0); ; shift += 7 { 328 if shift >= 64 { 329 return ErrIntOverflowRecord 330 } 331 if iNdEx >= l { 332 return io.ErrUnexpectedEOF 333 } 334 b := dAtA[iNdEx] 335 iNdEx++ 336 byteLen |= int(b&0x7F) << shift 337 if b < 0x80 { 338 break 339 } 340 } 341 if byteLen < 0 { 342 return ErrInvalidLengthRecord 343 } 344 postIndex := iNdEx + byteLen 345 if postIndex < 0 { 346 return ErrInvalidLengthRecord 347 } 348 if postIndex > l { 349 return io.ErrUnexpectedEOF 350 } 351 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 352 if m.Data == nil { 353 m.Data = []byte{} 354 } 355 iNdEx = postIndex 356 default: 357 iNdEx = preIndex 358 skippy, err := skipRecord(dAtA[iNdEx:]) 359 if err != nil { 360 return err 361 } 362 if skippy < 0 { 363 return ErrInvalidLengthRecord 364 } 365 if (iNdEx + skippy) < 0 { 366 return ErrInvalidLengthRecord 367 } 368 if (iNdEx + skippy) > l { 369 return io.ErrUnexpectedEOF 370 } 371 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 372 iNdEx += skippy 373 } 374 } 375 376 if iNdEx > l { 377 return io.ErrUnexpectedEOF 378 } 379 return nil 380 } 381 func (m *Snapshot) Unmarshal(dAtA []byte) error { 382 l := len(dAtA) 383 iNdEx := 0 384 for iNdEx < l { 385 preIndex := iNdEx 386 var wire uint64 387 for shift := uint(0); ; shift += 7 { 388 if shift >= 64 { 389 return ErrIntOverflowRecord 390 } 391 if iNdEx >= l { 392 return io.ErrUnexpectedEOF 393 } 394 b := dAtA[iNdEx] 395 iNdEx++ 396 wire |= uint64(b&0x7F) << shift 397 if b < 0x80 { 398 break 399 } 400 } 401 fieldNum := int32(wire >> 3) 402 wireType := int(wire & 0x7) 403 if wireType == 4 { 404 return fmt.Errorf("proto: Snapshot: wiretype end group for non-group") 405 } 406 if fieldNum <= 0 { 407 return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire) 408 } 409 switch fieldNum { 410 case 1: 411 if wireType != 0 { 412 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 413 } 414 m.Index = 0 415 for shift := uint(0); ; shift += 7 { 416 if shift >= 64 { 417 return ErrIntOverflowRecord 418 } 419 if iNdEx >= l { 420 return io.ErrUnexpectedEOF 421 } 422 b := dAtA[iNdEx] 423 iNdEx++ 424 m.Index |= uint64(b&0x7F) << shift 425 if b < 0x80 { 426 break 427 } 428 } 429 case 2: 430 if wireType != 0 { 431 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) 432 } 433 m.Term = 0 434 for shift := uint(0); ; shift += 7 { 435 if shift >= 64 { 436 return ErrIntOverflowRecord 437 } 438 if iNdEx >= l { 439 return io.ErrUnexpectedEOF 440 } 441 b := dAtA[iNdEx] 442 iNdEx++ 443 m.Term |= uint64(b&0x7F) << shift 444 if b < 0x80 { 445 break 446 } 447 } 448 default: 449 iNdEx = preIndex 450 skippy, err := skipRecord(dAtA[iNdEx:]) 451 if err != nil { 452 return err 453 } 454 if skippy < 0 { 455 return ErrInvalidLengthRecord 456 } 457 if (iNdEx + skippy) < 0 { 458 return ErrInvalidLengthRecord 459 } 460 if (iNdEx + skippy) > l { 461 return io.ErrUnexpectedEOF 462 } 463 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 464 iNdEx += skippy 465 } 466 } 467 468 if iNdEx > l { 469 return io.ErrUnexpectedEOF 470 } 471 return nil 472 } 473 func skipRecord(dAtA []byte) (n int, err error) { 474 l := len(dAtA) 475 iNdEx := 0 476 for iNdEx < l { 477 var wire uint64 478 for shift := uint(0); ; shift += 7 { 479 if shift >= 64 { 480 return 0, ErrIntOverflowRecord 481 } 482 if iNdEx >= l { 483 return 0, io.ErrUnexpectedEOF 484 } 485 b := dAtA[iNdEx] 486 iNdEx++ 487 wire |= (uint64(b) & 0x7F) << shift 488 if b < 0x80 { 489 break 490 } 491 } 492 wireType := int(wire & 0x7) 493 switch wireType { 494 case 0: 495 for shift := uint(0); ; shift += 7 { 496 if shift >= 64 { 497 return 0, ErrIntOverflowRecord 498 } 499 if iNdEx >= l { 500 return 0, io.ErrUnexpectedEOF 501 } 502 iNdEx++ 503 if dAtA[iNdEx-1] < 0x80 { 504 break 505 } 506 } 507 return iNdEx, nil 508 case 1: 509 iNdEx += 8 510 return iNdEx, nil 511 case 2: 512 var length int 513 for shift := uint(0); ; shift += 7 { 514 if shift >= 64 { 515 return 0, ErrIntOverflowRecord 516 } 517 if iNdEx >= l { 518 return 0, io.ErrUnexpectedEOF 519 } 520 b := dAtA[iNdEx] 521 iNdEx++ 522 length |= (int(b) & 0x7F) << shift 523 if b < 0x80 { 524 break 525 } 526 } 527 if length < 0 { 528 return 0, ErrInvalidLengthRecord 529 } 530 iNdEx += length 531 if iNdEx < 0 { 532 return 0, ErrInvalidLengthRecord 533 } 534 return iNdEx, nil 535 case 3: 536 for { 537 var innerWire uint64 538 var start int = iNdEx 539 for shift := uint(0); ; shift += 7 { 540 if shift >= 64 { 541 return 0, ErrIntOverflowRecord 542 } 543 if iNdEx >= l { 544 return 0, io.ErrUnexpectedEOF 545 } 546 b := dAtA[iNdEx] 547 iNdEx++ 548 innerWire |= (uint64(b) & 0x7F) << shift 549 if b < 0x80 { 550 break 551 } 552 } 553 innerWireType := int(innerWire & 0x7) 554 if innerWireType == 4 { 555 break 556 } 557 next, err := skipRecord(dAtA[start:]) 558 if err != nil { 559 return 0, err 560 } 561 iNdEx = start + next 562 if iNdEx < 0 { 563 return 0, ErrInvalidLengthRecord 564 } 565 } 566 return iNdEx, nil 567 case 4: 568 return iNdEx, nil 569 case 5: 570 iNdEx += 4 571 return iNdEx, nil 572 default: 573 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 574 } 575 } 576 panic("unreachable") 577 } 578 579 var ( 580 ErrInvalidLengthRecord = fmt.Errorf("proto: negative length found during unmarshaling") 581 ErrIntOverflowRecord = fmt.Errorf("proto: integer overflow") 582 )