1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: binary.proto 3 4/* 5 Package wire is a generated protocol buffer package. 6 7 It is generated from these files: 8 binary.proto 9 10 It has these top-level messages: 11 SpanContext 12 Span 13 Trace 14 Field 15*/ 16package wire 17 18import proto "github.com/gogo/protobuf/proto" 19import fmt "fmt" 20import math "math" 21import _ "github.com/gogo/protobuf/gogoproto" 22import _ "github.com/gogo/protobuf/types" 23 24import time "time" 25 26import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" 27 28import io "io" 29 30// Reference imports to suppress errors if they are not otherwise used. 31var _ = proto.Marshal 32var _ = fmt.Errorf 33var _ = math.Inf 34var _ = time.Kitchen 35 36// This is a compile-time assertion to ensure that this generated file 37// is compatible with the proto package it is being compiled against. 38// A compilation error at this line likely means your copy of the 39// proto package needs to be updated. 40const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 41 42type Field_FieldType int32 43 44const ( 45 FieldTypeString Field_FieldType = 0 46 FieldTypeBool Field_FieldType = 1 47 FieldTypeInt64 Field_FieldType = 2 48 FieldTypeUint64 Field_FieldType = 3 49 FieldTypeDuration Field_FieldType = 4 50 FieldTypeFloat64 Field_FieldType = 6 51) 52 53var Field_FieldType_name = map[int32]string{ 54 0: "STRING", 55 1: "BOOL", 56 2: "INT_64", 57 3: "UINT_64", 58 4: "DURATION", 59 6: "FLOAT_64", 60} 61var Field_FieldType_value = map[string]int32{ 62 "STRING": 0, 63 "BOOL": 1, 64 "INT_64": 2, 65 "UINT_64": 3, 66 "DURATION": 4, 67 "FLOAT_64": 6, 68} 69 70func (x Field_FieldType) String() string { 71 return proto.EnumName(Field_FieldType_name, int32(x)) 72} 73func (Field_FieldType) EnumDescriptor() ([]byte, []int) { return fileDescriptorBinary, []int{3, 0} } 74 75type SpanContext struct { 76 TraceID uint64 `protobuf:"varint,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` 77 SpanID uint64 `protobuf:"varint,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"` 78} 79 80func (m *SpanContext) Reset() { *m = SpanContext{} } 81func (m *SpanContext) String() string { return proto.CompactTextString(m) } 82func (*SpanContext) ProtoMessage() {} 83func (*SpanContext) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{0} } 84 85func (m *SpanContext) GetTraceID() uint64 { 86 if m != nil { 87 return m.TraceID 88 } 89 return 0 90} 91 92func (m *SpanContext) GetSpanID() uint64 { 93 if m != nil { 94 return m.SpanID 95 } 96 return 0 97} 98 99type Span struct { 100 Context SpanContext `protobuf:"bytes,1,opt,name=context" json:"context"` 101 ParentSpanID uint64 `protobuf:"varint,2,opt,name=parent_span_id,json=parentSpanId,proto3" json:"parent_span_id,omitempty"` 102 Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` 103 Start time.Time `protobuf:"bytes,4,opt,name=start_time,json=startTime,stdtime" json:"start_time"` 104 Labels []string `protobuf:"bytes,5,rep,name=labels" json:"labels,omitempty"` 105 Fields []Field `protobuf:"bytes,6,rep,name=fields" json:"fields"` 106} 107 108func (m *Span) Reset() { *m = Span{} } 109func (m *Span) String() string { return proto.CompactTextString(m) } 110func (*Span) ProtoMessage() {} 111func (*Span) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{1} } 112 113func (m *Span) GetContext() SpanContext { 114 if m != nil { 115 return m.Context 116 } 117 return SpanContext{} 118} 119 120func (m *Span) GetParentSpanID() uint64 { 121 if m != nil { 122 return m.ParentSpanID 123 } 124 return 0 125} 126 127func (m *Span) GetName() string { 128 if m != nil { 129 return m.Name 130 } 131 return "" 132} 133 134func (m *Span) GetStart() time.Time { 135 if m != nil { 136 return m.Start 137 } 138 return time.Time{} 139} 140 141func (m *Span) GetLabels() []string { 142 if m != nil { 143 return m.Labels 144 } 145 return nil 146} 147 148func (m *Span) GetFields() []Field { 149 if m != nil { 150 return m.Fields 151 } 152 return nil 153} 154 155type Trace struct { 156 Spans []*Span `protobuf:"bytes,1,rep,name=spans" json:"spans,omitempty"` 157} 158 159func (m *Trace) Reset() { *m = Trace{} } 160func (m *Trace) String() string { return proto.CompactTextString(m) } 161func (*Trace) ProtoMessage() {} 162func (*Trace) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{2} } 163 164func (m *Trace) GetSpans() []*Span { 165 if m != nil { 166 return m.Spans 167 } 168 return nil 169} 170 171type Field struct { 172 Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 173 FieldType Field_FieldType `protobuf:"varint,2,opt,name=field_type,json=fieldType,proto3,enum=wire.Field_FieldType" json:"field_type,omitempty"` 174 // Types that are valid to be assigned to Value: 175 // *Field_NumericVal 176 // *Field_StringVal 177 Value isField_Value `protobuf_oneof:"value"` 178} 179 180func (m *Field) Reset() { *m = Field{} } 181func (m *Field) String() string { return proto.CompactTextString(m) } 182func (*Field) ProtoMessage() {} 183func (*Field) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{3} } 184 185type isField_Value interface { 186 isField_Value() 187 MarshalTo([]byte) (int, error) 188 Size() int 189} 190 191type Field_NumericVal struct { 192 NumericVal int64 `protobuf:"fixed64,3,opt,name=numeric_val,json=numericVal,proto3,oneof"` 193} 194type Field_StringVal struct { 195 StringVal string `protobuf:"bytes,4,opt,name=string_val,json=stringVal,proto3,oneof"` 196} 197 198func (*Field_NumericVal) isField_Value() {} 199func (*Field_StringVal) isField_Value() {} 200 201func (m *Field) GetValue() isField_Value { 202 if m != nil { 203 return m.Value 204 } 205 return nil 206} 207 208func (m *Field) GetKey() string { 209 if m != nil { 210 return m.Key 211 } 212 return "" 213} 214 215func (m *Field) GetFieldType() Field_FieldType { 216 if m != nil { 217 return m.FieldType 218 } 219 return FieldTypeString 220} 221 222func (m *Field) GetNumericVal() int64 { 223 if x, ok := m.GetValue().(*Field_NumericVal); ok { 224 return x.NumericVal 225 } 226 return 0 227} 228 229func (m *Field) GetStringVal() string { 230 if x, ok := m.GetValue().(*Field_StringVal); ok { 231 return x.StringVal 232 } 233 return "" 234} 235 236// XXX_OneofFuncs is for the internal use of the proto package. 237func (*Field) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { 238 return _Field_OneofMarshaler, _Field_OneofUnmarshaler, _Field_OneofSizer, []interface{}{ 239 (*Field_NumericVal)(nil), 240 (*Field_StringVal)(nil), 241 } 242} 243 244func _Field_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { 245 m := msg.(*Field) 246 // value 247 switch x := m.Value.(type) { 248 case *Field_NumericVal: 249 _ = b.EncodeVarint(3<<3 | proto.WireFixed64) 250 _ = b.EncodeFixed64(uint64(x.NumericVal)) 251 case *Field_StringVal: 252 _ = b.EncodeVarint(4<<3 | proto.WireBytes) 253 _ = b.EncodeStringBytes(x.StringVal) 254 case nil: 255 default: 256 return fmt.Errorf("Field.Value has unexpected type %T", x) 257 } 258 return nil 259} 260 261func _Field_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { 262 m := msg.(*Field) 263 switch tag { 264 case 3: // value.numeric_val 265 if wire != proto.WireFixed64 { 266 return true, proto.ErrInternalBadWireType 267 } 268 x, err := b.DecodeFixed64() 269 m.Value = &Field_NumericVal{int64(x)} 270 return true, err 271 case 4: // value.string_val 272 if wire != proto.WireBytes { 273 return true, proto.ErrInternalBadWireType 274 } 275 x, err := b.DecodeStringBytes() 276 m.Value = &Field_StringVal{x} 277 return true, err 278 default: 279 return false, nil 280 } 281} 282 283func _Field_OneofSizer(msg proto.Message) (n int) { 284 m := msg.(*Field) 285 // value 286 switch x := m.Value.(type) { 287 case *Field_NumericVal: 288 n += proto.SizeVarint(3<<3 | proto.WireFixed64) 289 n += 8 290 case *Field_StringVal: 291 n += proto.SizeVarint(4<<3 | proto.WireBytes) 292 n += proto.SizeVarint(uint64(len(x.StringVal))) 293 n += len(x.StringVal) 294 case nil: 295 default: 296 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) 297 } 298 return n 299} 300 301func init() { 302 proto.RegisterType((*SpanContext)(nil), "wire.SpanContext") 303 proto.RegisterType((*Span)(nil), "wire.Span") 304 proto.RegisterType((*Trace)(nil), "wire.Trace") 305 proto.RegisterType((*Field)(nil), "wire.Field") 306 proto.RegisterEnum("wire.Field_FieldType", Field_FieldType_name, Field_FieldType_value) 307} 308func (m *SpanContext) Marshal() (dAtA []byte, err error) { 309 size := m.Size() 310 dAtA = make([]byte, size) 311 n, err := m.MarshalTo(dAtA) 312 if err != nil { 313 return nil, err 314 } 315 return dAtA[:n], nil 316} 317 318func (m *SpanContext) MarshalTo(dAtA []byte) (int, error) { 319 var i int 320 _ = i 321 var l int 322 _ = l 323 if m.TraceID != 0 { 324 dAtA[i] = 0x8 325 i++ 326 i = encodeVarintBinary(dAtA, i, uint64(m.TraceID)) 327 } 328 if m.SpanID != 0 { 329 dAtA[i] = 0x10 330 i++ 331 i = encodeVarintBinary(dAtA, i, uint64(m.SpanID)) 332 } 333 return i, nil 334} 335 336func (m *Span) Marshal() (dAtA []byte, err error) { 337 size := m.Size() 338 dAtA = make([]byte, size) 339 n, err := m.MarshalTo(dAtA) 340 if err != nil { 341 return nil, err 342 } 343 return dAtA[:n], nil 344} 345 346func (m *Span) MarshalTo(dAtA []byte) (int, error) { 347 var i int 348 _ = i 349 var l int 350 _ = l 351 dAtA[i] = 0xa 352 i++ 353 i = encodeVarintBinary(dAtA, i, uint64(m.Context.Size())) 354 n1, err := m.Context.MarshalTo(dAtA[i:]) 355 if err != nil { 356 return 0, err 357 } 358 i += n1 359 if m.ParentSpanID != 0 { 360 dAtA[i] = 0x10 361 i++ 362 i = encodeVarintBinary(dAtA, i, uint64(m.ParentSpanID)) 363 } 364 if len(m.Name) > 0 { 365 dAtA[i] = 0x1a 366 i++ 367 i = encodeVarintBinary(dAtA, i, uint64(len(m.Name))) 368 i += copy(dAtA[i:], m.Name) 369 } 370 dAtA[i] = 0x22 371 i++ 372 i = encodeVarintBinary(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Start))) 373 n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i:]) 374 if err != nil { 375 return 0, err 376 } 377 i += n2 378 if len(m.Labels) > 0 { 379 for _, s := range m.Labels { 380 dAtA[i] = 0x2a 381 i++ 382 l = len(s) 383 for l >= 1<<7 { 384 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 385 l >>= 7 386 i++ 387 } 388 dAtA[i] = uint8(l) 389 i++ 390 i += copy(dAtA[i:], s) 391 } 392 } 393 if len(m.Fields) > 0 { 394 for _, msg := range m.Fields { 395 dAtA[i] = 0x32 396 i++ 397 i = encodeVarintBinary(dAtA, i, uint64(msg.Size())) 398 n, err := msg.MarshalTo(dAtA[i:]) 399 if err != nil { 400 return 0, err 401 } 402 i += n 403 } 404 } 405 return i, nil 406} 407 408func (m *Trace) Marshal() (dAtA []byte, err error) { 409 size := m.Size() 410 dAtA = make([]byte, size) 411 n, err := m.MarshalTo(dAtA) 412 if err != nil { 413 return nil, err 414 } 415 return dAtA[:n], nil 416} 417 418func (m *Trace) MarshalTo(dAtA []byte) (int, error) { 419 var i int 420 _ = i 421 var l int 422 _ = l 423 if len(m.Spans) > 0 { 424 for _, msg := range m.Spans { 425 dAtA[i] = 0xa 426 i++ 427 i = encodeVarintBinary(dAtA, i, uint64(msg.Size())) 428 n, err := msg.MarshalTo(dAtA[i:]) 429 if err != nil { 430 return 0, err 431 } 432 i += n 433 } 434 } 435 return i, nil 436} 437 438func (m *Field) Marshal() (dAtA []byte, err error) { 439 size := m.Size() 440 dAtA = make([]byte, size) 441 n, err := m.MarshalTo(dAtA) 442 if err != nil { 443 return nil, err 444 } 445 return dAtA[:n], nil 446} 447 448func (m *Field) MarshalTo(dAtA []byte) (int, error) { 449 var i int 450 _ = i 451 var l int 452 _ = l 453 if len(m.Key) > 0 { 454 dAtA[i] = 0xa 455 i++ 456 i = encodeVarintBinary(dAtA, i, uint64(len(m.Key))) 457 i += copy(dAtA[i:], m.Key) 458 } 459 if m.FieldType != 0 { 460 dAtA[i] = 0x10 461 i++ 462 i = encodeVarintBinary(dAtA, i, uint64(m.FieldType)) 463 } 464 if m.Value != nil { 465 nn3, err := m.Value.MarshalTo(dAtA[i:]) 466 if err != nil { 467 return 0, err 468 } 469 i += nn3 470 } 471 return i, nil 472} 473 474func (m *Field_NumericVal) MarshalTo(dAtA []byte) (int, error) { 475 i := 0 476 dAtA[i] = 0x19 477 i++ 478 i = encodeFixed64Binary(dAtA, i, uint64(m.NumericVal)) 479 return i, nil 480} 481func (m *Field_StringVal) MarshalTo(dAtA []byte) (int, error) { 482 i := 0 483 dAtA[i] = 0x22 484 i++ 485 i = encodeVarintBinary(dAtA, i, uint64(len(m.StringVal))) 486 i += copy(dAtA[i:], m.StringVal) 487 return i, nil 488} 489func encodeFixed64Binary(dAtA []byte, offset int, v uint64) int { 490 dAtA[offset] = uint8(v) 491 dAtA[offset+1] = uint8(v >> 8) 492 dAtA[offset+2] = uint8(v >> 16) 493 dAtA[offset+3] = uint8(v >> 24) 494 dAtA[offset+4] = uint8(v >> 32) 495 dAtA[offset+5] = uint8(v >> 40) 496 dAtA[offset+6] = uint8(v >> 48) 497 dAtA[offset+7] = uint8(v >> 56) 498 return offset + 8 499} 500func encodeFixed32Binary(dAtA []byte, offset int, v uint32) int { 501 dAtA[offset] = uint8(v) 502 dAtA[offset+1] = uint8(v >> 8) 503 dAtA[offset+2] = uint8(v >> 16) 504 dAtA[offset+3] = uint8(v >> 24) 505 return offset + 4 506} 507func encodeVarintBinary(dAtA []byte, offset int, v uint64) int { 508 for v >= 1<<7 { 509 dAtA[offset] = uint8(v&0x7f | 0x80) 510 v >>= 7 511 offset++ 512 } 513 dAtA[offset] = uint8(v) 514 return offset + 1 515} 516func (m *SpanContext) Size() (n int) { 517 var l int 518 _ = l 519 if m.TraceID != 0 { 520 n += 1 + sovBinary(uint64(m.TraceID)) 521 } 522 if m.SpanID != 0 { 523 n += 1 + sovBinary(uint64(m.SpanID)) 524 } 525 return n 526} 527 528func (m *Span) Size() (n int) { 529 var l int 530 _ = l 531 l = m.Context.Size() 532 n += 1 + l + sovBinary(uint64(l)) 533 if m.ParentSpanID != 0 { 534 n += 1 + sovBinary(uint64(m.ParentSpanID)) 535 } 536 l = len(m.Name) 537 if l > 0 { 538 n += 1 + l + sovBinary(uint64(l)) 539 } 540 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start) 541 n += 1 + l + sovBinary(uint64(l)) 542 if len(m.Labels) > 0 { 543 for _, s := range m.Labels { 544 l = len(s) 545 n += 1 + l + sovBinary(uint64(l)) 546 } 547 } 548 if len(m.Fields) > 0 { 549 for _, e := range m.Fields { 550 l = e.Size() 551 n += 1 + l + sovBinary(uint64(l)) 552 } 553 } 554 return n 555} 556 557func (m *Trace) Size() (n int) { 558 var l int 559 _ = l 560 if len(m.Spans) > 0 { 561 for _, e := range m.Spans { 562 l = e.Size() 563 n += 1 + l + sovBinary(uint64(l)) 564 } 565 } 566 return n 567} 568 569func (m *Field) Size() (n int) { 570 var l int 571 _ = l 572 l = len(m.Key) 573 if l > 0 { 574 n += 1 + l + sovBinary(uint64(l)) 575 } 576 if m.FieldType != 0 { 577 n += 1 + sovBinary(uint64(m.FieldType)) 578 } 579 if m.Value != nil { 580 n += m.Value.Size() 581 } 582 return n 583} 584 585func (m *Field_NumericVal) Size() (n int) { 586 var l int 587 _ = l 588 n += 9 589 return n 590} 591func (m *Field_StringVal) Size() (n int) { 592 var l int 593 _ = l 594 l = len(m.StringVal) 595 n += 1 + l + sovBinary(uint64(l)) 596 return n 597} 598 599func sovBinary(x uint64) (n int) { 600 for { 601 n++ 602 x >>= 7 603 if x == 0 { 604 break 605 } 606 } 607 return n 608} 609func sozBinary(x uint64) (n int) { 610 return sovBinary(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 611} 612func (m *SpanContext) Unmarshal(dAtA []byte) error { 613 l := len(dAtA) 614 iNdEx := 0 615 for iNdEx < l { 616 preIndex := iNdEx 617 var wire uint64 618 for shift := uint(0); ; shift += 7 { 619 if shift >= 64 { 620 return ErrIntOverflowBinary 621 } 622 if iNdEx >= l { 623 return io.ErrUnexpectedEOF 624 } 625 b := dAtA[iNdEx] 626 iNdEx++ 627 wire |= (uint64(b) & 0x7F) << shift 628 if b < 0x80 { 629 break 630 } 631 } 632 fieldNum := int32(wire >> 3) 633 wireType := int(wire & 0x7) 634 if wireType == 4 { 635 return fmt.Errorf("proto: SpanContext: wiretype end group for non-group") 636 } 637 if fieldNum <= 0 { 638 return fmt.Errorf("proto: SpanContext: illegal tag %d (wire type %d)", fieldNum, wire) 639 } 640 switch fieldNum { 641 case 1: 642 if wireType != 0 { 643 return fmt.Errorf("proto: wrong wireType = %d for field TraceID", wireType) 644 } 645 m.TraceID = 0 646 for shift := uint(0); ; shift += 7 { 647 if shift >= 64 { 648 return ErrIntOverflowBinary 649 } 650 if iNdEx >= l { 651 return io.ErrUnexpectedEOF 652 } 653 b := dAtA[iNdEx] 654 iNdEx++ 655 m.TraceID |= (uint64(b) & 0x7F) << shift 656 if b < 0x80 { 657 break 658 } 659 } 660 case 2: 661 if wireType != 0 { 662 return fmt.Errorf("proto: wrong wireType = %d for field SpanID", wireType) 663 } 664 m.SpanID = 0 665 for shift := uint(0); ; shift += 7 { 666 if shift >= 64 { 667 return ErrIntOverflowBinary 668 } 669 if iNdEx >= l { 670 return io.ErrUnexpectedEOF 671 } 672 b := dAtA[iNdEx] 673 iNdEx++ 674 m.SpanID |= (uint64(b) & 0x7F) << shift 675 if b < 0x80 { 676 break 677 } 678 } 679 default: 680 iNdEx = preIndex 681 skippy, err := skipBinary(dAtA[iNdEx:]) 682 if err != nil { 683 return err 684 } 685 if skippy < 0 { 686 return ErrInvalidLengthBinary 687 } 688 if (iNdEx + skippy) > l { 689 return io.ErrUnexpectedEOF 690 } 691 iNdEx += skippy 692 } 693 } 694 695 if iNdEx > l { 696 return io.ErrUnexpectedEOF 697 } 698 return nil 699} 700func (m *Span) Unmarshal(dAtA []byte) error { 701 l := len(dAtA) 702 iNdEx := 0 703 for iNdEx < l { 704 preIndex := iNdEx 705 var wire uint64 706 for shift := uint(0); ; shift += 7 { 707 if shift >= 64 { 708 return ErrIntOverflowBinary 709 } 710 if iNdEx >= l { 711 return io.ErrUnexpectedEOF 712 } 713 b := dAtA[iNdEx] 714 iNdEx++ 715 wire |= (uint64(b) & 0x7F) << shift 716 if b < 0x80 { 717 break 718 } 719 } 720 fieldNum := int32(wire >> 3) 721 wireType := int(wire & 0x7) 722 if wireType == 4 { 723 return fmt.Errorf("proto: Span: wiretype end group for non-group") 724 } 725 if fieldNum <= 0 { 726 return fmt.Errorf("proto: Span: illegal tag %d (wire type %d)", fieldNum, wire) 727 } 728 switch fieldNum { 729 case 1: 730 if wireType != 2 { 731 return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) 732 } 733 var msglen int 734 for shift := uint(0); ; shift += 7 { 735 if shift >= 64 { 736 return ErrIntOverflowBinary 737 } 738 if iNdEx >= l { 739 return io.ErrUnexpectedEOF 740 } 741 b := dAtA[iNdEx] 742 iNdEx++ 743 msglen |= (int(b) & 0x7F) << shift 744 if b < 0x80 { 745 break 746 } 747 } 748 if msglen < 0 { 749 return ErrInvalidLengthBinary 750 } 751 postIndex := iNdEx + msglen 752 if postIndex > l { 753 return io.ErrUnexpectedEOF 754 } 755 if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 756 return err 757 } 758 iNdEx = postIndex 759 case 2: 760 if wireType != 0 { 761 return fmt.Errorf("proto: wrong wireType = %d for field ParentSpanID", wireType) 762 } 763 m.ParentSpanID = 0 764 for shift := uint(0); ; shift += 7 { 765 if shift >= 64 { 766 return ErrIntOverflowBinary 767 } 768 if iNdEx >= l { 769 return io.ErrUnexpectedEOF 770 } 771 b := dAtA[iNdEx] 772 iNdEx++ 773 m.ParentSpanID |= (uint64(b) & 0x7F) << shift 774 if b < 0x80 { 775 break 776 } 777 } 778 case 3: 779 if wireType != 2 { 780 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 781 } 782 var stringLen uint64 783 for shift := uint(0); ; shift += 7 { 784 if shift >= 64 { 785 return ErrIntOverflowBinary 786 } 787 if iNdEx >= l { 788 return io.ErrUnexpectedEOF 789 } 790 b := dAtA[iNdEx] 791 iNdEx++ 792 stringLen |= (uint64(b) & 0x7F) << shift 793 if b < 0x80 { 794 break 795 } 796 } 797 intStringLen := int(stringLen) 798 if intStringLen < 0 { 799 return ErrInvalidLengthBinary 800 } 801 postIndex := iNdEx + intStringLen 802 if postIndex > l { 803 return io.ErrUnexpectedEOF 804 } 805 m.Name = string(dAtA[iNdEx:postIndex]) 806 iNdEx = postIndex 807 case 4: 808 if wireType != 2 { 809 return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) 810 } 811 var msglen int 812 for shift := uint(0); ; shift += 7 { 813 if shift >= 64 { 814 return ErrIntOverflowBinary 815 } 816 if iNdEx >= l { 817 return io.ErrUnexpectedEOF 818 } 819 b := dAtA[iNdEx] 820 iNdEx++ 821 msglen |= (int(b) & 0x7F) << shift 822 if b < 0x80 { 823 break 824 } 825 } 826 if msglen < 0 { 827 return ErrInvalidLengthBinary 828 } 829 postIndex := iNdEx + msglen 830 if postIndex > l { 831 return io.ErrUnexpectedEOF 832 } 833 if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil { 834 return err 835 } 836 iNdEx = postIndex 837 case 5: 838 if wireType != 2 { 839 return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) 840 } 841 var stringLen uint64 842 for shift := uint(0); ; shift += 7 { 843 if shift >= 64 { 844 return ErrIntOverflowBinary 845 } 846 if iNdEx >= l { 847 return io.ErrUnexpectedEOF 848 } 849 b := dAtA[iNdEx] 850 iNdEx++ 851 stringLen |= (uint64(b) & 0x7F) << shift 852 if b < 0x80 { 853 break 854 } 855 } 856 intStringLen := int(stringLen) 857 if intStringLen < 0 { 858 return ErrInvalidLengthBinary 859 } 860 postIndex := iNdEx + intStringLen 861 if postIndex > l { 862 return io.ErrUnexpectedEOF 863 } 864 m.Labels = append(m.Labels, string(dAtA[iNdEx:postIndex])) 865 iNdEx = postIndex 866 case 6: 867 if wireType != 2 { 868 return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType) 869 } 870 var msglen int 871 for shift := uint(0); ; shift += 7 { 872 if shift >= 64 { 873 return ErrIntOverflowBinary 874 } 875 if iNdEx >= l { 876 return io.ErrUnexpectedEOF 877 } 878 b := dAtA[iNdEx] 879 iNdEx++ 880 msglen |= (int(b) & 0x7F) << shift 881 if b < 0x80 { 882 break 883 } 884 } 885 if msglen < 0 { 886 return ErrInvalidLengthBinary 887 } 888 postIndex := iNdEx + msglen 889 if postIndex > l { 890 return io.ErrUnexpectedEOF 891 } 892 m.Fields = append(m.Fields, Field{}) 893 if err := m.Fields[len(m.Fields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 894 return err 895 } 896 iNdEx = postIndex 897 default: 898 iNdEx = preIndex 899 skippy, err := skipBinary(dAtA[iNdEx:]) 900 if err != nil { 901 return err 902 } 903 if skippy < 0 { 904 return ErrInvalidLengthBinary 905 } 906 if (iNdEx + skippy) > l { 907 return io.ErrUnexpectedEOF 908 } 909 iNdEx += skippy 910 } 911 } 912 913 if iNdEx > l { 914 return io.ErrUnexpectedEOF 915 } 916 return nil 917} 918func (m *Trace) Unmarshal(dAtA []byte) error { 919 l := len(dAtA) 920 iNdEx := 0 921 for iNdEx < l { 922 preIndex := iNdEx 923 var wire uint64 924 for shift := uint(0); ; shift += 7 { 925 if shift >= 64 { 926 return ErrIntOverflowBinary 927 } 928 if iNdEx >= l { 929 return io.ErrUnexpectedEOF 930 } 931 b := dAtA[iNdEx] 932 iNdEx++ 933 wire |= (uint64(b) & 0x7F) << shift 934 if b < 0x80 { 935 break 936 } 937 } 938 fieldNum := int32(wire >> 3) 939 wireType := int(wire & 0x7) 940 if wireType == 4 { 941 return fmt.Errorf("proto: Trace: wiretype end group for non-group") 942 } 943 if fieldNum <= 0 { 944 return fmt.Errorf("proto: Trace: illegal tag %d (wire type %d)", fieldNum, wire) 945 } 946 switch fieldNum { 947 case 1: 948 if wireType != 2 { 949 return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) 950 } 951 var msglen int 952 for shift := uint(0); ; shift += 7 { 953 if shift >= 64 { 954 return ErrIntOverflowBinary 955 } 956 if iNdEx >= l { 957 return io.ErrUnexpectedEOF 958 } 959 b := dAtA[iNdEx] 960 iNdEx++ 961 msglen |= (int(b) & 0x7F) << shift 962 if b < 0x80 { 963 break 964 } 965 } 966 if msglen < 0 { 967 return ErrInvalidLengthBinary 968 } 969 postIndex := iNdEx + msglen 970 if postIndex > l { 971 return io.ErrUnexpectedEOF 972 } 973 m.Spans = append(m.Spans, &Span{}) 974 if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 975 return err 976 } 977 iNdEx = postIndex 978 default: 979 iNdEx = preIndex 980 skippy, err := skipBinary(dAtA[iNdEx:]) 981 if err != nil { 982 return err 983 } 984 if skippy < 0 { 985 return ErrInvalidLengthBinary 986 } 987 if (iNdEx + skippy) > l { 988 return io.ErrUnexpectedEOF 989 } 990 iNdEx += skippy 991 } 992 } 993 994 if iNdEx > l { 995 return io.ErrUnexpectedEOF 996 } 997 return nil 998} 999func (m *Field) Unmarshal(dAtA []byte) error { 1000 l := len(dAtA) 1001 iNdEx := 0 1002 for iNdEx < l { 1003 preIndex := iNdEx 1004 var wire uint64 1005 for shift := uint(0); ; shift += 7 { 1006 if shift >= 64 { 1007 return ErrIntOverflowBinary 1008 } 1009 if iNdEx >= l { 1010 return io.ErrUnexpectedEOF 1011 } 1012 b := dAtA[iNdEx] 1013 iNdEx++ 1014 wire |= (uint64(b) & 0x7F) << shift 1015 if b < 0x80 { 1016 break 1017 } 1018 } 1019 fieldNum := int32(wire >> 3) 1020 wireType := int(wire & 0x7) 1021 if wireType == 4 { 1022 return fmt.Errorf("proto: Field: wiretype end group for non-group") 1023 } 1024 if fieldNum <= 0 { 1025 return fmt.Errorf("proto: Field: illegal tag %d (wire type %d)", fieldNum, wire) 1026 } 1027 switch fieldNum { 1028 case 1: 1029 if wireType != 2 { 1030 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 1031 } 1032 var stringLen uint64 1033 for shift := uint(0); ; shift += 7 { 1034 if shift >= 64 { 1035 return ErrIntOverflowBinary 1036 } 1037 if iNdEx >= l { 1038 return io.ErrUnexpectedEOF 1039 } 1040 b := dAtA[iNdEx] 1041 iNdEx++ 1042 stringLen |= (uint64(b) & 0x7F) << shift 1043 if b < 0x80 { 1044 break 1045 } 1046 } 1047 intStringLen := int(stringLen) 1048 if intStringLen < 0 { 1049 return ErrInvalidLengthBinary 1050 } 1051 postIndex := iNdEx + intStringLen 1052 if postIndex > l { 1053 return io.ErrUnexpectedEOF 1054 } 1055 m.Key = string(dAtA[iNdEx:postIndex]) 1056 iNdEx = postIndex 1057 case 2: 1058 if wireType != 0 { 1059 return fmt.Errorf("proto: wrong wireType = %d for field FieldType", wireType) 1060 } 1061 m.FieldType = 0 1062 for shift := uint(0); ; shift += 7 { 1063 if shift >= 64 { 1064 return ErrIntOverflowBinary 1065 } 1066 if iNdEx >= l { 1067 return io.ErrUnexpectedEOF 1068 } 1069 b := dAtA[iNdEx] 1070 iNdEx++ 1071 m.FieldType |= (Field_FieldType(b) & 0x7F) << shift 1072 if b < 0x80 { 1073 break 1074 } 1075 } 1076 case 3: 1077 if wireType != 1 { 1078 return fmt.Errorf("proto: wrong wireType = %d for field NumericVal", wireType) 1079 } 1080 var v int64 1081 if (iNdEx + 8) > l { 1082 return io.ErrUnexpectedEOF 1083 } 1084 iNdEx += 8 1085 v = int64(dAtA[iNdEx-8]) 1086 v |= int64(dAtA[iNdEx-7]) << 8 1087 v |= int64(dAtA[iNdEx-6]) << 16 1088 v |= int64(dAtA[iNdEx-5]) << 24 1089 v |= int64(dAtA[iNdEx-4]) << 32 1090 v |= int64(dAtA[iNdEx-3]) << 40 1091 v |= int64(dAtA[iNdEx-2]) << 48 1092 v |= int64(dAtA[iNdEx-1]) << 56 1093 m.Value = &Field_NumericVal{v} 1094 case 4: 1095 if wireType != 2 { 1096 return fmt.Errorf("proto: wrong wireType = %d for field StringVal", wireType) 1097 } 1098 var stringLen uint64 1099 for shift := uint(0); ; shift += 7 { 1100 if shift >= 64 { 1101 return ErrIntOverflowBinary 1102 } 1103 if iNdEx >= l { 1104 return io.ErrUnexpectedEOF 1105 } 1106 b := dAtA[iNdEx] 1107 iNdEx++ 1108 stringLen |= (uint64(b) & 0x7F) << shift 1109 if b < 0x80 { 1110 break 1111 } 1112 } 1113 intStringLen := int(stringLen) 1114 if intStringLen < 0 { 1115 return ErrInvalidLengthBinary 1116 } 1117 postIndex := iNdEx + intStringLen 1118 if postIndex > l { 1119 return io.ErrUnexpectedEOF 1120 } 1121 m.Value = &Field_StringVal{string(dAtA[iNdEx:postIndex])} 1122 iNdEx = postIndex 1123 default: 1124 iNdEx = preIndex 1125 skippy, err := skipBinary(dAtA[iNdEx:]) 1126 if err != nil { 1127 return err 1128 } 1129 if skippy < 0 { 1130 return ErrInvalidLengthBinary 1131 } 1132 if (iNdEx + skippy) > l { 1133 return io.ErrUnexpectedEOF 1134 } 1135 iNdEx += skippy 1136 } 1137 } 1138 1139 if iNdEx > l { 1140 return io.ErrUnexpectedEOF 1141 } 1142 return nil 1143} 1144func skipBinary(dAtA []byte) (n int, err error) { 1145 l := len(dAtA) 1146 iNdEx := 0 1147 for iNdEx < l { 1148 var wire uint64 1149 for shift := uint(0); ; shift += 7 { 1150 if shift >= 64 { 1151 return 0, ErrIntOverflowBinary 1152 } 1153 if iNdEx >= l { 1154 return 0, io.ErrUnexpectedEOF 1155 } 1156 b := dAtA[iNdEx] 1157 iNdEx++ 1158 wire |= (uint64(b) & 0x7F) << shift 1159 if b < 0x80 { 1160 break 1161 } 1162 } 1163 wireType := int(wire & 0x7) 1164 switch wireType { 1165 case 0: 1166 for shift := uint(0); ; shift += 7 { 1167 if shift >= 64 { 1168 return 0, ErrIntOverflowBinary 1169 } 1170 if iNdEx >= l { 1171 return 0, io.ErrUnexpectedEOF 1172 } 1173 iNdEx++ 1174 if dAtA[iNdEx-1] < 0x80 { 1175 break 1176 } 1177 } 1178 return iNdEx, nil 1179 case 1: 1180 iNdEx += 8 1181 return iNdEx, nil 1182 case 2: 1183 var length int 1184 for shift := uint(0); ; shift += 7 { 1185 if shift >= 64 { 1186 return 0, ErrIntOverflowBinary 1187 } 1188 if iNdEx >= l { 1189 return 0, io.ErrUnexpectedEOF 1190 } 1191 b := dAtA[iNdEx] 1192 iNdEx++ 1193 length |= (int(b) & 0x7F) << shift 1194 if b < 0x80 { 1195 break 1196 } 1197 } 1198 iNdEx += length 1199 if length < 0 { 1200 return 0, ErrInvalidLengthBinary 1201 } 1202 return iNdEx, nil 1203 case 3: 1204 for { 1205 var innerWire uint64 1206 var start int = iNdEx 1207 for shift := uint(0); ; shift += 7 { 1208 if shift >= 64 { 1209 return 0, ErrIntOverflowBinary 1210 } 1211 if iNdEx >= l { 1212 return 0, io.ErrUnexpectedEOF 1213 } 1214 b := dAtA[iNdEx] 1215 iNdEx++ 1216 innerWire |= (uint64(b) & 0x7F) << shift 1217 if b < 0x80 { 1218 break 1219 } 1220 } 1221 innerWireType := int(innerWire & 0x7) 1222 if innerWireType == 4 { 1223 break 1224 } 1225 next, err := skipBinary(dAtA[start:]) 1226 if err != nil { 1227 return 0, err 1228 } 1229 iNdEx = start + next 1230 } 1231 return iNdEx, nil 1232 case 4: 1233 return iNdEx, nil 1234 case 5: 1235 iNdEx += 4 1236 return iNdEx, nil 1237 default: 1238 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1239 } 1240 } 1241 panic("unreachable") 1242} 1243 1244var ( 1245 ErrInvalidLengthBinary = fmt.Errorf("proto: negative length found during unmarshaling") 1246 ErrIntOverflowBinary = fmt.Errorf("proto: integer overflow") 1247) 1248 1249func init() { proto.RegisterFile("binary.proto", fileDescriptorBinary) } 1250 1251var fileDescriptorBinary = []byte{ 1252 // 624 bytes of a gzipped FileDescriptorProto 1253 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x52, 0x41, 0x6f, 0xda, 0x4c, 1254 0x10, 0xc5, 0xc1, 0x98, 0x78, 0x48, 0xf8, 0xcc, 0x7e, 0x4d, 0x85, 0x5c, 0x09, 0x5b, 0x44, 0xaa, 1255 0xc8, 0xa1, 0x8e, 0x92, 0x46, 0xdc, 0xe3, 0xa0, 0xb4, 0x96, 0x22, 0xa8, 0x0c, 0xe9, 0xa1, 0x17, 1256 0xb4, 0xc0, 0x42, 0xad, 0x1a, 0xaf, 0x65, 0x2f, 0x69, 0xf9, 0x07, 0x15, 0xa7, 0x9c, 0x7a, 0xe3, 1257 0xd4, 0x43, 0xff, 0x4a, 0x8e, 0x3d, 0xf7, 0xe0, 0x56, 0xee, 0x1f, 0xa9, 0x76, 0x0d, 0x26, 0xed, 1258 0xc5, 0x9a, 0x99, 0xf7, 0xe6, 0xbd, 0x9d, 0x27, 0xc3, 0xc1, 0xc8, 0x0b, 0x70, 0xb4, 0xb4, 0xc2, 1259 0x88, 0x32, 0x8a, 0xe4, 0x8f, 0x5e, 0x44, 0xf4, 0x17, 0x33, 0x8f, 0xbd, 0x5f, 0x8c, 0xac, 0x31, 1260 0x9d, 0x9f, 0xce, 0xe8, 0x8c, 0x9e, 0x0a, 0x70, 0xb4, 0x98, 0x8a, 0x4e, 0x34, 0xa2, 0xca, 0x96, 1261 0x74, 0x63, 0x46, 0xe9, 0xcc, 0x27, 0x3b, 0x16, 0xf3, 0xe6, 0x24, 0x66, 0x78, 0x1e, 0x66, 0x84, 1262 0xe6, 0x3b, 0xa8, 0xf4, 0x43, 0x1c, 0x5c, 0xd1, 0x80, 0x91, 0x4f, 0x0c, 0x3d, 0x87, 0x7d, 0x16, 1263 0xe1, 0x31, 0x19, 0x7a, 0x93, 0xba, 0x64, 0x4a, 0x2d, 0xd9, 0xae, 0xa4, 0x89, 0x51, 0x1e, 0xf0, 1264 0x99, 0xd3, 0x71, 0xcb, 0x02, 0x74, 0x26, 0xe8, 0x18, 0xca, 0x71, 0x88, 0x03, 0x4e, 0xdb, 0x13, 1265 0x34, 0x48, 0x13, 0x43, 0xe1, 0x4a, 0x4e, 0xc7, 0x55, 0x38, 0xe4, 0x4c, 0x9a, 0x5f, 0xf6, 0x40, 1266 0xe6, 0x23, 0x74, 0x06, 0xe5, 0x71, 0x66, 0x20, 0x44, 0x2b, 0xe7, 0x35, 0x8b, 0x1f, 0x63, 0x3d, 1267 0x72, 0xb6, 0xe5, 0x87, 0xc4, 0x28, 0xb8, 0x5b, 0x1e, 0x6a, 0x43, 0x35, 0xc4, 0x11, 0x09, 0xd8, 1268 0xf0, 0x6f, 0x1f, 0x2d, 0x4d, 0x8c, 0x83, 0x37, 0x02, 0xd9, 0xb8, 0x1d, 0x84, 0xbb, 0x6e, 0x82, 1269 0x10, 0xc8, 0x01, 0x9e, 0x93, 0x7a, 0xd1, 0x94, 0x5a, 0xaa, 0x2b, 0x6a, 0x74, 0x03, 0x10, 0x33, 1270 0x1c, 0xb1, 0x21, 0x3f, 0xbe, 0x2e, 0x8b, 0x17, 0xe8, 0x56, 0x96, 0x8c, 0xb5, 0x4d, 0xc6, 0x1a, 1271 0x6c, 0x93, 0xb1, 0x6b, 0xfc, 0x29, 0x69, 0x62, 0x94, 0xfa, 0x7c, 0xeb, 0xfe, 0xa7, 0x21, 0xb9, 1272 0xaa, 0x10, 0xe0, 0x14, 0xf4, 0x14, 0x14, 0x1f, 0x8f, 0x88, 0x1f, 0xd7, 0x4b, 0x66, 0xb1, 0xa5, 1273 0xba, 0x9b, 0x0e, 0x9d, 0x80, 0x32, 0xf5, 0x88, 0x3f, 0x89, 0xeb, 0x8a, 0x59, 0x6c, 0x55, 0xce, 1274 0x2b, 0xd9, 0x8d, 0xd7, 0x7c, 0xb6, 0xb9, 0x6e, 0x43, 0x68, 0x9e, 0x40, 0x49, 0x24, 0x8a, 0x4c, 1275 0x28, 0xf1, 0xf3, 0xe2, 0xba, 0x24, 0x56, 0x60, 0x17, 0x8b, 0x9b, 0x01, 0xcd, 0x6f, 0x45, 0x28, 1276 0x09, 0x09, 0xa4, 0x41, 0xf1, 0x03, 0x59, 0x8a, 0x00, 0x55, 0x97, 0x97, 0xe8, 0x0a, 0x40, 0x08, 1277 0x0e, 0xd9, 0x32, 0x24, 0x22, 0x9f, 0xea, 0xf9, 0xd1, 0x23, 0xd7, 0xec, 0x3b, 0x58, 0x86, 0xc4, 1278 0x3e, 0x4c, 0x13, 0x43, 0xcd, 0x5b, 0x57, 0x9d, 0x6e, 0x4b, 0x74, 0x06, 0x95, 0x60, 0x31, 0x27, 1279 0x91, 0x37, 0x1e, 0xde, 0x61, 0x5f, 0xe4, 0xa6, 0xd9, 0xd5, 0x34, 0x31, 0xa0, 0x9b, 0x8d, 0xdf, 1280 0x62, 0xff, 0x75, 0xc1, 0x85, 0x20, 0xef, 0x90, 0xc5, 0xf3, 0x8c, 0xbc, 0x60, 0x26, 0x36, 0x78, 1281 0x9e, 0x6a, 0x66, 0xd0, 0x17, 0xd3, 0x6c, 0x41, 0x8d, 0xb7, 0x4d, 0xf3, 0x87, 0x04, 0x3b, 0x6f, 1282 0x64, 0x80, 0xd2, 0x1f, 0xb8, 0x4e, 0xf7, 0x95, 0x56, 0xd0, 0xff, 0x5f, 0xad, 0xcd, 0xff, 0x72, 1283 0x28, 0x5b, 0x47, 0xcf, 0x40, 0xb6, 0x7b, 0xbd, 0x1b, 0x4d, 0xd2, 0x6b, 0xab, 0xb5, 0x79, 0xb8, 1284 0x3b, 0x82, 0x52, 0x1f, 0x35, 0x40, 0x71, 0xba, 0x83, 0x61, 0xfb, 0x42, 0xdb, 0xd3, 0xd1, 0x6a, 1285 0x6d, 0x56, 0x73, 0xd8, 0x09, 0x58, 0xfb, 0x02, 0x99, 0x50, 0xbe, 0xdd, 0x10, 0x8a, 0xff, 0xc8, 1286 0xdf, 0x7a, 0x82, 0x71, 0x0c, 0xfb, 0x9d, 0x5b, 0xf7, 0x72, 0xe0, 0xf4, 0xba, 0x9a, 0xac, 0x1f, 1287 0xad, 0xd6, 0x66, 0x2d, 0xa7, 0x74, 0x16, 0x11, 0x66, 0x1e, 0x0d, 0x50, 0x13, 0xf6, 0xaf, 0x6f, 1288 0x7a, 0x97, 0x42, 0x47, 0xd1, 0x9f, 0xac, 0xd6, 0xa6, 0x96, 0x93, 0xae, 0x7d, 0x8a, 0x59, 0xfb, 1289 0x42, 0x97, 0x3f, 0x7f, 0x6d, 0x14, 0xec, 0x32, 0x94, 0xee, 0xb0, 0xbf, 0x20, 0xb6, 0xf6, 0x90, 1290 0x36, 0xa4, 0xef, 0x69, 0x43, 0xfa, 0x95, 0x36, 0xa4, 0xfb, 0xdf, 0x8d, 0xc2, 0x48, 0x11, 0xff, 1291 0xd6, 0xcb, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x10, 0xad, 0x27, 0x39, 0xc8, 0x03, 0x00, 0x00, 1292} 1293