1// Code generated by protoc-gen-gogo. 2// source: quads.proto 3// DO NOT EDIT! 4 5/* 6 Package pquads is a generated protocol buffer package. 7 8 It is generated from these files: 9 quads.proto 10 11 It has these top-level messages: 12 Quad 13 WireQuad 14 StrictQuad 15 Value 16 Header 17*/ 18package pquads 19 20import proto "github.com/gogo/protobuf/proto" 21import fmt "fmt" 22import math "math" 23import _ "github.com/gogo/protobuf/gogoproto" 24 25import io "io" 26 27// Reference imports to suppress errors if they are not otherwise used. 28var _ = proto.Marshal 29var _ = fmt.Errorf 30var _ = math.Inf 31 32// This is a compile-time assertion to ensure that this generated file 33// is compatible with the proto package it is being compiled against. 34// A compilation error at this line likely means your copy of the 35// proto package needs to be updated. 36const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 37 38// Quad is in internal representation of quad used by Cayley. 39type Quad struct { 40 Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"` 41 Predicate string `protobuf:"bytes,2,opt,name=predicate,proto3" json:"predicate,omitempty"` 42 Object string `protobuf:"bytes,3,opt,name=object,proto3" json:"object,omitempty"` 43 Label string `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"` 44 SubjectValue *Value `protobuf:"bytes,5,opt,name=subject_value,json=subjectValue" json:"subject_value,omitempty"` 45 PredicateValue *Value `protobuf:"bytes,6,opt,name=predicate_value,json=predicateValue" json:"predicate_value,omitempty"` 46 ObjectValue *Value `protobuf:"bytes,7,opt,name=object_value,json=objectValue" json:"object_value,omitempty"` 47 LabelValue *Value `protobuf:"bytes,8,opt,name=label_value,json=labelValue" json:"label_value,omitempty"` 48} 49 50func (m *Quad) Reset() { *m = Quad{} } 51func (m *Quad) String() string { return proto.CompactTextString(m) } 52func (*Quad) ProtoMessage() {} 53func (*Quad) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{0} } 54 55func (m *Quad) GetSubjectValue() *Value { 56 if m != nil { 57 return m.SubjectValue 58 } 59 return nil 60} 61 62func (m *Quad) GetPredicateValue() *Value { 63 if m != nil { 64 return m.PredicateValue 65 } 66 return nil 67} 68 69func (m *Quad) GetObjectValue() *Value { 70 if m != nil { 71 return m.ObjectValue 72 } 73 return nil 74} 75 76func (m *Quad) GetLabelValue() *Value { 77 if m != nil { 78 return m.LabelValue 79 } 80 return nil 81} 82 83// WireQuad is a quad that allows any value for it's directions. 84type WireQuad struct { 85 Subject *Value `protobuf:"bytes,1,opt,name=subject" json:"subject,omitempty"` 86 Predicate *Value `protobuf:"bytes,2,opt,name=predicate" json:"predicate,omitempty"` 87 Object *Value `protobuf:"bytes,3,opt,name=object" json:"object,omitempty"` 88 Label *Value `protobuf:"bytes,4,opt,name=label" json:"label,omitempty"` 89} 90 91func (m *WireQuad) Reset() { *m = WireQuad{} } 92func (m *WireQuad) String() string { return proto.CompactTextString(m) } 93func (*WireQuad) ProtoMessage() {} 94func (*WireQuad) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{1} } 95 96func (m *WireQuad) GetSubject() *Value { 97 if m != nil { 98 return m.Subject 99 } 100 return nil 101} 102 103func (m *WireQuad) GetPredicate() *Value { 104 if m != nil { 105 return m.Predicate 106 } 107 return nil 108} 109 110func (m *WireQuad) GetObject() *Value { 111 if m != nil { 112 return m.Object 113 } 114 return nil 115} 116 117func (m *WireQuad) GetLabel() *Value { 118 if m != nil { 119 return m.Label 120 } 121 return nil 122} 123 124// StrictQuad is a quad as described by RDF spec. 125type StrictQuad struct { 126 Subject *StrictQuad_Ref `protobuf:"bytes,1,opt,name=subject" json:"subject,omitempty"` 127 Predicate *StrictQuad_Ref `protobuf:"bytes,2,opt,name=predicate" json:"predicate,omitempty"` 128 Object *Value `protobuf:"bytes,3,opt,name=object" json:"object,omitempty"` 129 Label *StrictQuad_Ref `protobuf:"bytes,4,opt,name=label" json:"label,omitempty"` 130} 131 132func (m *StrictQuad) Reset() { *m = StrictQuad{} } 133func (m *StrictQuad) String() string { return proto.CompactTextString(m) } 134func (*StrictQuad) ProtoMessage() {} 135func (*StrictQuad) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{2} } 136 137func (m *StrictQuad) GetSubject() *StrictQuad_Ref { 138 if m != nil { 139 return m.Subject 140 } 141 return nil 142} 143 144func (m *StrictQuad) GetPredicate() *StrictQuad_Ref { 145 if m != nil { 146 return m.Predicate 147 } 148 return nil 149} 150 151func (m *StrictQuad) GetObject() *Value { 152 if m != nil { 153 return m.Object 154 } 155 return nil 156} 157 158func (m *StrictQuad) GetLabel() *StrictQuad_Ref { 159 if m != nil { 160 return m.Label 161 } 162 return nil 163} 164 165type StrictQuad_Ref struct { 166 // Types that are valid to be assigned to Value: 167 // *StrictQuad_Ref_BnodeLabel 168 // *StrictQuad_Ref_Iri 169 Value isStrictQuad_Ref_Value `protobuf_oneof:"value"` 170} 171 172func (m *StrictQuad_Ref) Reset() { *m = StrictQuad_Ref{} } 173func (m *StrictQuad_Ref) String() string { return proto.CompactTextString(m) } 174func (*StrictQuad_Ref) ProtoMessage() {} 175func (*StrictQuad_Ref) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{2, 0} } 176 177type isStrictQuad_Ref_Value interface { 178 isStrictQuad_Ref_Value() 179 MarshalTo([]byte) (int, error) 180 ProtoSize() int 181} 182 183type StrictQuad_Ref_BnodeLabel struct { 184 BnodeLabel string `protobuf:"bytes,2,opt,name=bnode_label,json=bnodeLabel,proto3,oneof"` 185} 186type StrictQuad_Ref_Iri struct { 187 Iri string `protobuf:"bytes,3,opt,name=iri,proto3,oneof"` 188} 189 190func (*StrictQuad_Ref_BnodeLabel) isStrictQuad_Ref_Value() {} 191func (*StrictQuad_Ref_Iri) isStrictQuad_Ref_Value() {} 192 193func (m *StrictQuad_Ref) GetValue() isStrictQuad_Ref_Value { 194 if m != nil { 195 return m.Value 196 } 197 return nil 198} 199 200func (m *StrictQuad_Ref) GetBnodeLabel() string { 201 if x, ok := m.GetValue().(*StrictQuad_Ref_BnodeLabel); ok { 202 return x.BnodeLabel 203 } 204 return "" 205} 206 207func (m *StrictQuad_Ref) GetIri() string { 208 if x, ok := m.GetValue().(*StrictQuad_Ref_Iri); ok { 209 return x.Iri 210 } 211 return "" 212} 213 214// XXX_OneofFuncs is for the internal use of the proto package. 215func (*StrictQuad_Ref) 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{}) { 216 return _StrictQuad_Ref_OneofMarshaler, _StrictQuad_Ref_OneofUnmarshaler, _StrictQuad_Ref_OneofSizer, []interface{}{ 217 (*StrictQuad_Ref_BnodeLabel)(nil), 218 (*StrictQuad_Ref_Iri)(nil), 219 } 220} 221 222func _StrictQuad_Ref_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { 223 m := msg.(*StrictQuad_Ref) 224 // value 225 switch x := m.Value.(type) { 226 case *StrictQuad_Ref_BnodeLabel: 227 _ = b.EncodeVarint(2<<3 | proto.WireBytes) 228 _ = b.EncodeStringBytes(x.BnodeLabel) 229 case *StrictQuad_Ref_Iri: 230 _ = b.EncodeVarint(3<<3 | proto.WireBytes) 231 _ = b.EncodeStringBytes(x.Iri) 232 case nil: 233 default: 234 return fmt.Errorf("StrictQuad_Ref.Value has unexpected type %T", x) 235 } 236 return nil 237} 238 239func _StrictQuad_Ref_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { 240 m := msg.(*StrictQuad_Ref) 241 switch tag { 242 case 2: // value.bnode_label 243 if wire != proto.WireBytes { 244 return true, proto.ErrInternalBadWireType 245 } 246 x, err := b.DecodeStringBytes() 247 m.Value = &StrictQuad_Ref_BnodeLabel{x} 248 return true, err 249 case 3: // value.iri 250 if wire != proto.WireBytes { 251 return true, proto.ErrInternalBadWireType 252 } 253 x, err := b.DecodeStringBytes() 254 m.Value = &StrictQuad_Ref_Iri{x} 255 return true, err 256 default: 257 return false, nil 258 } 259} 260 261func _StrictQuad_Ref_OneofSizer(msg proto.Message) (n int) { 262 m := msg.(*StrictQuad_Ref) 263 // value 264 switch x := m.Value.(type) { 265 case *StrictQuad_Ref_BnodeLabel: 266 n += proto.SizeVarint(2<<3 | proto.WireBytes) 267 n += proto.SizeVarint(uint64(len(x.BnodeLabel))) 268 n += len(x.BnodeLabel) 269 case *StrictQuad_Ref_Iri: 270 n += proto.SizeVarint(3<<3 | proto.WireBytes) 271 n += proto.SizeVarint(uint64(len(x.Iri))) 272 n += len(x.Iri) 273 case nil: 274 default: 275 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) 276 } 277 return n 278} 279 280type Value struct { 281 // Types that are valid to be assigned to Value: 282 // *Value_Raw 283 // *Value_Str 284 // *Value_Iri 285 // *Value_Bnode 286 // *Value_TypedStr 287 // *Value_LangStr 288 // *Value_Int 289 // *Value_Float 290 // *Value_Boolean 291 // *Value_Time 292 Value isValue_Value `protobuf_oneof:"value"` 293} 294 295func (m *Value) Reset() { *m = Value{} } 296func (m *Value) String() string { return proto.CompactTextString(m) } 297func (*Value) ProtoMessage() {} 298func (*Value) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{3} } 299 300type isValue_Value interface { 301 isValue_Value() 302 MarshalTo([]byte) (int, error) 303 ProtoSize() int 304} 305 306type Value_Raw struct { 307 Raw []byte `protobuf:"bytes,1,opt,name=raw,proto3,oneof"` 308} 309type Value_Str struct { 310 Str string `protobuf:"bytes,2,opt,name=str,proto3,oneof"` 311} 312type Value_Iri struct { 313 Iri string `protobuf:"bytes,3,opt,name=iri,proto3,oneof"` 314} 315type Value_Bnode struct { 316 Bnode string `protobuf:"bytes,4,opt,name=bnode,proto3,oneof"` 317} 318type Value_TypedStr struct { 319 TypedStr *Value_TypedString `protobuf:"bytes,5,opt,name=typed_str,json=typedStr,oneof"` 320} 321type Value_LangStr struct { 322 LangStr *Value_LangString `protobuf:"bytes,6,opt,name=lang_str,json=langStr,oneof"` 323} 324type Value_Int struct { 325 Int int64 `protobuf:"varint,7,opt,name=int,proto3,oneof"` 326} 327type Value_Float struct { 328 Float float64 `protobuf:"fixed64,8,opt,name=float,proto3,oneof"` 329} 330type Value_Boolean struct { 331 Boolean bool `protobuf:"varint,9,opt,name=boolean,proto3,oneof"` 332} 333type Value_Time struct { 334 Time *Value_Timestamp `protobuf:"bytes,10,opt,name=time,oneof"` 335} 336 337func (*Value_Raw) isValue_Value() {} 338func (*Value_Str) isValue_Value() {} 339func (*Value_Iri) isValue_Value() {} 340func (*Value_Bnode) isValue_Value() {} 341func (*Value_TypedStr) isValue_Value() {} 342func (*Value_LangStr) isValue_Value() {} 343func (*Value_Int) isValue_Value() {} 344func (*Value_Float) isValue_Value() {} 345func (*Value_Boolean) isValue_Value() {} 346func (*Value_Time) isValue_Value() {} 347 348func (m *Value) GetValue() isValue_Value { 349 if m != nil { 350 return m.Value 351 } 352 return nil 353} 354 355func (m *Value) GetRaw() []byte { 356 if x, ok := m.GetValue().(*Value_Raw); ok { 357 return x.Raw 358 } 359 return nil 360} 361 362func (m *Value) GetStr() string { 363 if x, ok := m.GetValue().(*Value_Str); ok { 364 return x.Str 365 } 366 return "" 367} 368 369func (m *Value) GetIri() string { 370 if x, ok := m.GetValue().(*Value_Iri); ok { 371 return x.Iri 372 } 373 return "" 374} 375 376func (m *Value) GetBnode() string { 377 if x, ok := m.GetValue().(*Value_Bnode); ok { 378 return x.Bnode 379 } 380 return "" 381} 382 383func (m *Value) GetTypedStr() *Value_TypedString { 384 if x, ok := m.GetValue().(*Value_TypedStr); ok { 385 return x.TypedStr 386 } 387 return nil 388} 389 390func (m *Value) GetLangStr() *Value_LangString { 391 if x, ok := m.GetValue().(*Value_LangStr); ok { 392 return x.LangStr 393 } 394 return nil 395} 396 397func (m *Value) GetInt() int64 { 398 if x, ok := m.GetValue().(*Value_Int); ok { 399 return x.Int 400 } 401 return 0 402} 403 404func (m *Value) GetFloat() float64 { 405 if x, ok := m.GetValue().(*Value_Float); ok { 406 return x.Float 407 } 408 return 0 409} 410 411func (m *Value) GetBoolean() bool { 412 if x, ok := m.GetValue().(*Value_Boolean); ok { 413 return x.Boolean 414 } 415 return false 416} 417 418func (m *Value) GetTime() *Value_Timestamp { 419 if x, ok := m.GetValue().(*Value_Time); ok { 420 return x.Time 421 } 422 return nil 423} 424 425// XXX_OneofFuncs is for the internal use of the proto package. 426func (*Value) 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{}) { 427 return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{ 428 (*Value_Raw)(nil), 429 (*Value_Str)(nil), 430 (*Value_Iri)(nil), 431 (*Value_Bnode)(nil), 432 (*Value_TypedStr)(nil), 433 (*Value_LangStr)(nil), 434 (*Value_Int)(nil), 435 (*Value_Float)(nil), 436 (*Value_Boolean)(nil), 437 (*Value_Time)(nil), 438 } 439} 440 441func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { 442 m := msg.(*Value) 443 // value 444 switch x := m.Value.(type) { 445 case *Value_Raw: 446 _ = b.EncodeVarint(1<<3 | proto.WireBytes) 447 _ = b.EncodeRawBytes(x.Raw) 448 case *Value_Str: 449 _ = b.EncodeVarint(2<<3 | proto.WireBytes) 450 _ = b.EncodeStringBytes(x.Str) 451 case *Value_Iri: 452 _ = b.EncodeVarint(3<<3 | proto.WireBytes) 453 _ = b.EncodeStringBytes(x.Iri) 454 case *Value_Bnode: 455 _ = b.EncodeVarint(4<<3 | proto.WireBytes) 456 _ = b.EncodeStringBytes(x.Bnode) 457 case *Value_TypedStr: 458 _ = b.EncodeVarint(5<<3 | proto.WireBytes) 459 if err := b.EncodeMessage(x.TypedStr); err != nil { 460 return err 461 } 462 case *Value_LangStr: 463 _ = b.EncodeVarint(6<<3 | proto.WireBytes) 464 if err := b.EncodeMessage(x.LangStr); err != nil { 465 return err 466 } 467 case *Value_Int: 468 _ = b.EncodeVarint(7<<3 | proto.WireVarint) 469 _ = b.EncodeVarint(uint64(x.Int)) 470 case *Value_Float: 471 _ = b.EncodeVarint(8<<3 | proto.WireFixed64) 472 _ = b.EncodeFixed64(math.Float64bits(x.Float)) 473 case *Value_Boolean: 474 t := uint64(0) 475 if x.Boolean { 476 t = 1 477 } 478 _ = b.EncodeVarint(9<<3 | proto.WireVarint) 479 _ = b.EncodeVarint(t) 480 case *Value_Time: 481 _ = b.EncodeVarint(10<<3 | proto.WireBytes) 482 if err := b.EncodeMessage(x.Time); err != nil { 483 return err 484 } 485 case nil: 486 default: 487 return fmt.Errorf("Value.Value has unexpected type %T", x) 488 } 489 return nil 490} 491 492func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { 493 m := msg.(*Value) 494 switch tag { 495 case 1: // value.raw 496 if wire != proto.WireBytes { 497 return true, proto.ErrInternalBadWireType 498 } 499 x, err := b.DecodeRawBytes(true) 500 m.Value = &Value_Raw{x} 501 return true, err 502 case 2: // value.str 503 if wire != proto.WireBytes { 504 return true, proto.ErrInternalBadWireType 505 } 506 x, err := b.DecodeStringBytes() 507 m.Value = &Value_Str{x} 508 return true, err 509 case 3: // value.iri 510 if wire != proto.WireBytes { 511 return true, proto.ErrInternalBadWireType 512 } 513 x, err := b.DecodeStringBytes() 514 m.Value = &Value_Iri{x} 515 return true, err 516 case 4: // value.bnode 517 if wire != proto.WireBytes { 518 return true, proto.ErrInternalBadWireType 519 } 520 x, err := b.DecodeStringBytes() 521 m.Value = &Value_Bnode{x} 522 return true, err 523 case 5: // value.typed_str 524 if wire != proto.WireBytes { 525 return true, proto.ErrInternalBadWireType 526 } 527 msg := new(Value_TypedString) 528 err := b.DecodeMessage(msg) 529 m.Value = &Value_TypedStr{msg} 530 return true, err 531 case 6: // value.lang_str 532 if wire != proto.WireBytes { 533 return true, proto.ErrInternalBadWireType 534 } 535 msg := new(Value_LangString) 536 err := b.DecodeMessage(msg) 537 m.Value = &Value_LangStr{msg} 538 return true, err 539 case 7: // value.int 540 if wire != proto.WireVarint { 541 return true, proto.ErrInternalBadWireType 542 } 543 x, err := b.DecodeVarint() 544 m.Value = &Value_Int{int64(x)} 545 return true, err 546 case 8: // value.float 547 if wire != proto.WireFixed64 { 548 return true, proto.ErrInternalBadWireType 549 } 550 x, err := b.DecodeFixed64() 551 m.Value = &Value_Float{math.Float64frombits(x)} 552 return true, err 553 case 9: // value.boolean 554 if wire != proto.WireVarint { 555 return true, proto.ErrInternalBadWireType 556 } 557 x, err := b.DecodeVarint() 558 m.Value = &Value_Boolean{x != 0} 559 return true, err 560 case 10: // value.time 561 if wire != proto.WireBytes { 562 return true, proto.ErrInternalBadWireType 563 } 564 msg := new(Value_Timestamp) 565 err := b.DecodeMessage(msg) 566 m.Value = &Value_Time{msg} 567 return true, err 568 default: 569 return false, nil 570 } 571} 572 573func _Value_OneofSizer(msg proto.Message) (n int) { 574 m := msg.(*Value) 575 // value 576 switch x := m.Value.(type) { 577 case *Value_Raw: 578 n += proto.SizeVarint(1<<3 | proto.WireBytes) 579 n += proto.SizeVarint(uint64(len(x.Raw))) 580 n += len(x.Raw) 581 case *Value_Str: 582 n += proto.SizeVarint(2<<3 | proto.WireBytes) 583 n += proto.SizeVarint(uint64(len(x.Str))) 584 n += len(x.Str) 585 case *Value_Iri: 586 n += proto.SizeVarint(3<<3 | proto.WireBytes) 587 n += proto.SizeVarint(uint64(len(x.Iri))) 588 n += len(x.Iri) 589 case *Value_Bnode: 590 n += proto.SizeVarint(4<<3 | proto.WireBytes) 591 n += proto.SizeVarint(uint64(len(x.Bnode))) 592 n += len(x.Bnode) 593 case *Value_TypedStr: 594 s := proto.Size(x.TypedStr) 595 n += proto.SizeVarint(5<<3 | proto.WireBytes) 596 n += proto.SizeVarint(uint64(s)) 597 n += s 598 case *Value_LangStr: 599 s := proto.Size(x.LangStr) 600 n += proto.SizeVarint(6<<3 | proto.WireBytes) 601 n += proto.SizeVarint(uint64(s)) 602 n += s 603 case *Value_Int: 604 n += proto.SizeVarint(7<<3 | proto.WireVarint) 605 n += proto.SizeVarint(uint64(x.Int)) 606 case *Value_Float: 607 n += proto.SizeVarint(8<<3 | proto.WireFixed64) 608 n += 8 609 case *Value_Boolean: 610 n += proto.SizeVarint(9<<3 | proto.WireVarint) 611 n += 1 612 case *Value_Time: 613 s := proto.Size(x.Time) 614 n += proto.SizeVarint(10<<3 | proto.WireBytes) 615 n += proto.SizeVarint(uint64(s)) 616 n += s 617 case nil: 618 default: 619 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) 620 } 621 return n 622} 623 624type Value_TypedString struct { 625 Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 626 Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` 627} 628 629func (m *Value_TypedString) Reset() { *m = Value_TypedString{} } 630func (m *Value_TypedString) String() string { return proto.CompactTextString(m) } 631func (*Value_TypedString) ProtoMessage() {} 632func (*Value_TypedString) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{3, 0} } 633 634type Value_LangString struct { 635 Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 636 Lang string `protobuf:"bytes,2,opt,name=lang,proto3" json:"lang,omitempty"` 637} 638 639func (m *Value_LangString) Reset() { *m = Value_LangString{} } 640func (m *Value_LangString) String() string { return proto.CompactTextString(m) } 641func (*Value_LangString) ProtoMessage() {} 642func (*Value_LangString) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{3, 1} } 643 644// From https://github.com/golang/protobuf/blob/master/ptypes/timestamp/timestamp.proto 645type Value_Timestamp struct { 646 Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"` 647 Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"` 648} 649 650func (m *Value_Timestamp) Reset() { *m = Value_Timestamp{} } 651func (m *Value_Timestamp) String() string { return proto.CompactTextString(m) } 652func (*Value_Timestamp) ProtoMessage() {} 653func (*Value_Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{3, 2} } 654 655type Header struct { 656 // Full is set if encoder always writes every quad directions instead of 657 // skipping duplicated values on each direction (except label) for subsequent quads. 658 Full bool `protobuf:"varint,1,opt,name=full,proto3" json:"full,omitempty"` 659 // NotStrict is set if encoder emits WireQuad instead of StrictQuad messages. 660 NotStrict bool `protobuf:"varint,2,opt,name=not_strict,json=notStrict,proto3" json:"not_strict,omitempty"` 661} 662 663func (m *Header) Reset() { *m = Header{} } 664func (m *Header) String() string { return proto.CompactTextString(m) } 665func (*Header) ProtoMessage() {} 666func (*Header) Descriptor() ([]byte, []int) { return fileDescriptorQuads, []int{4} } 667 668func init() { 669 proto.RegisterType((*Quad)(nil), "pquads.Quad") 670 proto.RegisterType((*WireQuad)(nil), "pquads.WireQuad") 671 proto.RegisterType((*StrictQuad)(nil), "pquads.StrictQuad") 672 proto.RegisterType((*StrictQuad_Ref)(nil), "pquads.StrictQuad.Ref") 673 proto.RegisterType((*Value)(nil), "pquads.Value") 674 proto.RegisterType((*Value_TypedString)(nil), "pquads.Value.TypedString") 675 proto.RegisterType((*Value_LangString)(nil), "pquads.Value.LangString") 676 proto.RegisterType((*Value_Timestamp)(nil), "pquads.Value.Timestamp") 677 proto.RegisterType((*Header)(nil), "pquads.Header") 678} 679func (m *Quad) Marshal() (data []byte, err error) { 680 size := m.ProtoSize() 681 data = make([]byte, size) 682 n, err := m.MarshalTo(data) 683 if err != nil { 684 return nil, err 685 } 686 return data[:n], nil 687} 688 689func (m *Quad) MarshalTo(data []byte) (int, error) { 690 var i int 691 _ = i 692 var l int 693 _ = l 694 if len(m.Subject) > 0 { 695 data[i] = 0xa 696 i++ 697 i = encodeVarintQuads(data, i, uint64(len(m.Subject))) 698 i += copy(data[i:], m.Subject) 699 } 700 if len(m.Predicate) > 0 { 701 data[i] = 0x12 702 i++ 703 i = encodeVarintQuads(data, i, uint64(len(m.Predicate))) 704 i += copy(data[i:], m.Predicate) 705 } 706 if len(m.Object) > 0 { 707 data[i] = 0x1a 708 i++ 709 i = encodeVarintQuads(data, i, uint64(len(m.Object))) 710 i += copy(data[i:], m.Object) 711 } 712 if len(m.Label) > 0 { 713 data[i] = 0x22 714 i++ 715 i = encodeVarintQuads(data, i, uint64(len(m.Label))) 716 i += copy(data[i:], m.Label) 717 } 718 if m.SubjectValue != nil { 719 data[i] = 0x2a 720 i++ 721 i = encodeVarintQuads(data, i, uint64(m.SubjectValue.ProtoSize())) 722 n1, err := m.SubjectValue.MarshalTo(data[i:]) 723 if err != nil { 724 return 0, err 725 } 726 i += n1 727 } 728 if m.PredicateValue != nil { 729 data[i] = 0x32 730 i++ 731 i = encodeVarintQuads(data, i, uint64(m.PredicateValue.ProtoSize())) 732 n2, err := m.PredicateValue.MarshalTo(data[i:]) 733 if err != nil { 734 return 0, err 735 } 736 i += n2 737 } 738 if m.ObjectValue != nil { 739 data[i] = 0x3a 740 i++ 741 i = encodeVarintQuads(data, i, uint64(m.ObjectValue.ProtoSize())) 742 n3, err := m.ObjectValue.MarshalTo(data[i:]) 743 if err != nil { 744 return 0, err 745 } 746 i += n3 747 } 748 if m.LabelValue != nil { 749 data[i] = 0x42 750 i++ 751 i = encodeVarintQuads(data, i, uint64(m.LabelValue.ProtoSize())) 752 n4, err := m.LabelValue.MarshalTo(data[i:]) 753 if err != nil { 754 return 0, err 755 } 756 i += n4 757 } 758 return i, nil 759} 760 761func (m *WireQuad) Marshal() (data []byte, err error) { 762 size := m.ProtoSize() 763 data = make([]byte, size) 764 n, err := m.MarshalTo(data) 765 if err != nil { 766 return nil, err 767 } 768 return data[:n], nil 769} 770 771func (m *WireQuad) MarshalTo(data []byte) (int, error) { 772 var i int 773 _ = i 774 var l int 775 _ = l 776 if m.Subject != nil { 777 data[i] = 0xa 778 i++ 779 i = encodeVarintQuads(data, i, uint64(m.Subject.ProtoSize())) 780 n5, err := m.Subject.MarshalTo(data[i:]) 781 if err != nil { 782 return 0, err 783 } 784 i += n5 785 } 786 if m.Predicate != nil { 787 data[i] = 0x12 788 i++ 789 i = encodeVarintQuads(data, i, uint64(m.Predicate.ProtoSize())) 790 n6, err := m.Predicate.MarshalTo(data[i:]) 791 if err != nil { 792 return 0, err 793 } 794 i += n6 795 } 796 if m.Object != nil { 797 data[i] = 0x1a 798 i++ 799 i = encodeVarintQuads(data, i, uint64(m.Object.ProtoSize())) 800 n7, err := m.Object.MarshalTo(data[i:]) 801 if err != nil { 802 return 0, err 803 } 804 i += n7 805 } 806 if m.Label != nil { 807 data[i] = 0x22 808 i++ 809 i = encodeVarintQuads(data, i, uint64(m.Label.ProtoSize())) 810 n8, err := m.Label.MarshalTo(data[i:]) 811 if err != nil { 812 return 0, err 813 } 814 i += n8 815 } 816 return i, nil 817} 818 819func (m *StrictQuad) Marshal() (data []byte, err error) { 820 size := m.ProtoSize() 821 data = make([]byte, size) 822 n, err := m.MarshalTo(data) 823 if err != nil { 824 return nil, err 825 } 826 return data[:n], nil 827} 828 829func (m *StrictQuad) MarshalTo(data []byte) (int, error) { 830 var i int 831 _ = i 832 var l int 833 _ = l 834 if m.Subject != nil { 835 data[i] = 0xa 836 i++ 837 i = encodeVarintQuads(data, i, uint64(m.Subject.ProtoSize())) 838 n9, err := m.Subject.MarshalTo(data[i:]) 839 if err != nil { 840 return 0, err 841 } 842 i += n9 843 } 844 if m.Predicate != nil { 845 data[i] = 0x12 846 i++ 847 i = encodeVarintQuads(data, i, uint64(m.Predicate.ProtoSize())) 848 n10, err := m.Predicate.MarshalTo(data[i:]) 849 if err != nil { 850 return 0, err 851 } 852 i += n10 853 } 854 if m.Object != nil { 855 data[i] = 0x1a 856 i++ 857 i = encodeVarintQuads(data, i, uint64(m.Object.ProtoSize())) 858 n11, err := m.Object.MarshalTo(data[i:]) 859 if err != nil { 860 return 0, err 861 } 862 i += n11 863 } 864 if m.Label != nil { 865 data[i] = 0x22 866 i++ 867 i = encodeVarintQuads(data, i, uint64(m.Label.ProtoSize())) 868 n12, err := m.Label.MarshalTo(data[i:]) 869 if err != nil { 870 return 0, err 871 } 872 i += n12 873 } 874 return i, nil 875} 876 877func (m *StrictQuad_Ref) Marshal() (data []byte, err error) { 878 size := m.ProtoSize() 879 data = make([]byte, size) 880 n, err := m.MarshalTo(data) 881 if err != nil { 882 return nil, err 883 } 884 return data[:n], nil 885} 886 887func (m *StrictQuad_Ref) MarshalTo(data []byte) (int, error) { 888 var i int 889 _ = i 890 var l int 891 _ = l 892 if m.Value != nil { 893 nn13, err := m.Value.MarshalTo(data[i:]) 894 if err != nil { 895 return 0, err 896 } 897 i += nn13 898 } 899 return i, nil 900} 901 902func (m *StrictQuad_Ref_BnodeLabel) MarshalTo(data []byte) (int, error) { 903 i := 0 904 data[i] = 0x12 905 i++ 906 i = encodeVarintQuads(data, i, uint64(len(m.BnodeLabel))) 907 i += copy(data[i:], m.BnodeLabel) 908 return i, nil 909} 910func (m *StrictQuad_Ref_Iri) MarshalTo(data []byte) (int, error) { 911 i := 0 912 data[i] = 0x1a 913 i++ 914 i = encodeVarintQuads(data, i, uint64(len(m.Iri))) 915 i += copy(data[i:], m.Iri) 916 return i, nil 917} 918func (m *Value) Marshal() (data []byte, err error) { 919 size := m.ProtoSize() 920 data = make([]byte, size) 921 n, err := m.MarshalTo(data) 922 if err != nil { 923 return nil, err 924 } 925 return data[:n], nil 926} 927 928func (m *Value) MarshalTo(data []byte) (int, error) { 929 var i int 930 _ = i 931 var l int 932 _ = l 933 if m.Value != nil { 934 nn14, err := m.Value.MarshalTo(data[i:]) 935 if err != nil { 936 return 0, err 937 } 938 i += nn14 939 } 940 return i, nil 941} 942 943func (m *Value_Raw) MarshalTo(data []byte) (int, error) { 944 i := 0 945 if m.Raw != nil { 946 data[i] = 0xa 947 i++ 948 i = encodeVarintQuads(data, i, uint64(len(m.Raw))) 949 i += copy(data[i:], m.Raw) 950 } 951 return i, nil 952} 953func (m *Value_Str) MarshalTo(data []byte) (int, error) { 954 i := 0 955 data[i] = 0x12 956 i++ 957 i = encodeVarintQuads(data, i, uint64(len(m.Str))) 958 i += copy(data[i:], m.Str) 959 return i, nil 960} 961func (m *Value_Iri) MarshalTo(data []byte) (int, error) { 962 i := 0 963 data[i] = 0x1a 964 i++ 965 i = encodeVarintQuads(data, i, uint64(len(m.Iri))) 966 i += copy(data[i:], m.Iri) 967 return i, nil 968} 969func (m *Value_Bnode) MarshalTo(data []byte) (int, error) { 970 i := 0 971 data[i] = 0x22 972 i++ 973 i = encodeVarintQuads(data, i, uint64(len(m.Bnode))) 974 i += copy(data[i:], m.Bnode) 975 return i, nil 976} 977func (m *Value_TypedStr) MarshalTo(data []byte) (int, error) { 978 i := 0 979 if m.TypedStr != nil { 980 data[i] = 0x2a 981 i++ 982 i = encodeVarintQuads(data, i, uint64(m.TypedStr.ProtoSize())) 983 n15, err := m.TypedStr.MarshalTo(data[i:]) 984 if err != nil { 985 return 0, err 986 } 987 i += n15 988 } 989 return i, nil 990} 991func (m *Value_LangStr) MarshalTo(data []byte) (int, error) { 992 i := 0 993 if m.LangStr != nil { 994 data[i] = 0x32 995 i++ 996 i = encodeVarintQuads(data, i, uint64(m.LangStr.ProtoSize())) 997 n16, err := m.LangStr.MarshalTo(data[i:]) 998 if err != nil { 999 return 0, err 1000 } 1001 i += n16 1002 } 1003 return i, nil 1004} 1005func (m *Value_Int) MarshalTo(data []byte) (int, error) { 1006 i := 0 1007 data[i] = 0x38 1008 i++ 1009 i = encodeVarintQuads(data, i, uint64(m.Int)) 1010 return i, nil 1011} 1012func (m *Value_Float) MarshalTo(data []byte) (int, error) { 1013 i := 0 1014 data[i] = 0x41 1015 i++ 1016 i = encodeFixed64Quads(data, i, uint64(math.Float64bits(float64(m.Float)))) 1017 return i, nil 1018} 1019func (m *Value_Boolean) MarshalTo(data []byte) (int, error) { 1020 i := 0 1021 data[i] = 0x48 1022 i++ 1023 if m.Boolean { 1024 data[i] = 1 1025 } else { 1026 data[i] = 0 1027 } 1028 i++ 1029 return i, nil 1030} 1031func (m *Value_Time) MarshalTo(data []byte) (int, error) { 1032 i := 0 1033 if m.Time != nil { 1034 data[i] = 0x52 1035 i++ 1036 i = encodeVarintQuads(data, i, uint64(m.Time.ProtoSize())) 1037 n17, err := m.Time.MarshalTo(data[i:]) 1038 if err != nil { 1039 return 0, err 1040 } 1041 i += n17 1042 } 1043 return i, nil 1044} 1045func (m *Value_TypedString) Marshal() (data []byte, err error) { 1046 size := m.ProtoSize() 1047 data = make([]byte, size) 1048 n, err := m.MarshalTo(data) 1049 if err != nil { 1050 return nil, err 1051 } 1052 return data[:n], nil 1053} 1054 1055func (m *Value_TypedString) MarshalTo(data []byte) (int, error) { 1056 var i int 1057 _ = i 1058 var l int 1059 _ = l 1060 if len(m.Value) > 0 { 1061 data[i] = 0xa 1062 i++ 1063 i = encodeVarintQuads(data, i, uint64(len(m.Value))) 1064 i += copy(data[i:], m.Value) 1065 } 1066 if len(m.Type) > 0 { 1067 data[i] = 0x12 1068 i++ 1069 i = encodeVarintQuads(data, i, uint64(len(m.Type))) 1070 i += copy(data[i:], m.Type) 1071 } 1072 return i, nil 1073} 1074 1075func (m *Value_LangString) Marshal() (data []byte, err error) { 1076 size := m.ProtoSize() 1077 data = make([]byte, size) 1078 n, err := m.MarshalTo(data) 1079 if err != nil { 1080 return nil, err 1081 } 1082 return data[:n], nil 1083} 1084 1085func (m *Value_LangString) MarshalTo(data []byte) (int, error) { 1086 var i int 1087 _ = i 1088 var l int 1089 _ = l 1090 if len(m.Value) > 0 { 1091 data[i] = 0xa 1092 i++ 1093 i = encodeVarintQuads(data, i, uint64(len(m.Value))) 1094 i += copy(data[i:], m.Value) 1095 } 1096 if len(m.Lang) > 0 { 1097 data[i] = 0x12 1098 i++ 1099 i = encodeVarintQuads(data, i, uint64(len(m.Lang))) 1100 i += copy(data[i:], m.Lang) 1101 } 1102 return i, nil 1103} 1104 1105func (m *Value_Timestamp) Marshal() (data []byte, err error) { 1106 size := m.ProtoSize() 1107 data = make([]byte, size) 1108 n, err := m.MarshalTo(data) 1109 if err != nil { 1110 return nil, err 1111 } 1112 return data[:n], nil 1113} 1114 1115func (m *Value_Timestamp) MarshalTo(data []byte) (int, error) { 1116 var i int 1117 _ = i 1118 var l int 1119 _ = l 1120 if m.Seconds != 0 { 1121 data[i] = 0x8 1122 i++ 1123 i = encodeVarintQuads(data, i, uint64(m.Seconds)) 1124 } 1125 if m.Nanos != 0 { 1126 data[i] = 0x10 1127 i++ 1128 i = encodeVarintQuads(data, i, uint64(m.Nanos)) 1129 } 1130 return i, nil 1131} 1132 1133func (m *Header) Marshal() (data []byte, err error) { 1134 size := m.ProtoSize() 1135 data = make([]byte, size) 1136 n, err := m.MarshalTo(data) 1137 if err != nil { 1138 return nil, err 1139 } 1140 return data[:n], nil 1141} 1142 1143func (m *Header) MarshalTo(data []byte) (int, error) { 1144 var i int 1145 _ = i 1146 var l int 1147 _ = l 1148 if m.Full { 1149 data[i] = 0x8 1150 i++ 1151 if m.Full { 1152 data[i] = 1 1153 } else { 1154 data[i] = 0 1155 } 1156 i++ 1157 } 1158 if m.NotStrict { 1159 data[i] = 0x10 1160 i++ 1161 if m.NotStrict { 1162 data[i] = 1 1163 } else { 1164 data[i] = 0 1165 } 1166 i++ 1167 } 1168 return i, nil 1169} 1170 1171func encodeFixed64Quads(data []byte, offset int, v uint64) int { 1172 data[offset] = uint8(v) 1173 data[offset+1] = uint8(v >> 8) 1174 data[offset+2] = uint8(v >> 16) 1175 data[offset+3] = uint8(v >> 24) 1176 data[offset+4] = uint8(v >> 32) 1177 data[offset+5] = uint8(v >> 40) 1178 data[offset+6] = uint8(v >> 48) 1179 data[offset+7] = uint8(v >> 56) 1180 return offset + 8 1181} 1182func encodeFixed32Quads(data []byte, offset int, v uint32) int { 1183 data[offset] = uint8(v) 1184 data[offset+1] = uint8(v >> 8) 1185 data[offset+2] = uint8(v >> 16) 1186 data[offset+3] = uint8(v >> 24) 1187 return offset + 4 1188} 1189func encodeVarintQuads(data []byte, offset int, v uint64) int { 1190 for v >= 1<<7 { 1191 data[offset] = uint8(v&0x7f | 0x80) 1192 v >>= 7 1193 offset++ 1194 } 1195 data[offset] = uint8(v) 1196 return offset + 1 1197} 1198func (m *Quad) ProtoSize() (n int) { 1199 var l int 1200 _ = l 1201 l = len(m.Subject) 1202 if l > 0 { 1203 n += 1 + l + sovQuads(uint64(l)) 1204 } 1205 l = len(m.Predicate) 1206 if l > 0 { 1207 n += 1 + l + sovQuads(uint64(l)) 1208 } 1209 l = len(m.Object) 1210 if l > 0 { 1211 n += 1 + l + sovQuads(uint64(l)) 1212 } 1213 l = len(m.Label) 1214 if l > 0 { 1215 n += 1 + l + sovQuads(uint64(l)) 1216 } 1217 if m.SubjectValue != nil { 1218 l = m.SubjectValue.ProtoSize() 1219 n += 1 + l + sovQuads(uint64(l)) 1220 } 1221 if m.PredicateValue != nil { 1222 l = m.PredicateValue.ProtoSize() 1223 n += 1 + l + sovQuads(uint64(l)) 1224 } 1225 if m.ObjectValue != nil { 1226 l = m.ObjectValue.ProtoSize() 1227 n += 1 + l + sovQuads(uint64(l)) 1228 } 1229 if m.LabelValue != nil { 1230 l = m.LabelValue.ProtoSize() 1231 n += 1 + l + sovQuads(uint64(l)) 1232 } 1233 return n 1234} 1235 1236func (m *WireQuad) ProtoSize() (n int) { 1237 var l int 1238 _ = l 1239 if m.Subject != nil { 1240 l = m.Subject.ProtoSize() 1241 n += 1 + l + sovQuads(uint64(l)) 1242 } 1243 if m.Predicate != nil { 1244 l = m.Predicate.ProtoSize() 1245 n += 1 + l + sovQuads(uint64(l)) 1246 } 1247 if m.Object != nil { 1248 l = m.Object.ProtoSize() 1249 n += 1 + l + sovQuads(uint64(l)) 1250 } 1251 if m.Label != nil { 1252 l = m.Label.ProtoSize() 1253 n += 1 + l + sovQuads(uint64(l)) 1254 } 1255 return n 1256} 1257 1258func (m *StrictQuad) ProtoSize() (n int) { 1259 var l int 1260 _ = l 1261 if m.Subject != nil { 1262 l = m.Subject.ProtoSize() 1263 n += 1 + l + sovQuads(uint64(l)) 1264 } 1265 if m.Predicate != nil { 1266 l = m.Predicate.ProtoSize() 1267 n += 1 + l + sovQuads(uint64(l)) 1268 } 1269 if m.Object != nil { 1270 l = m.Object.ProtoSize() 1271 n += 1 + l + sovQuads(uint64(l)) 1272 } 1273 if m.Label != nil { 1274 l = m.Label.ProtoSize() 1275 n += 1 + l + sovQuads(uint64(l)) 1276 } 1277 return n 1278} 1279 1280func (m *StrictQuad_Ref) ProtoSize() (n int) { 1281 var l int 1282 _ = l 1283 if m.Value != nil { 1284 n += m.Value.ProtoSize() 1285 } 1286 return n 1287} 1288 1289func (m *StrictQuad_Ref_BnodeLabel) ProtoSize() (n int) { 1290 var l int 1291 _ = l 1292 l = len(m.BnodeLabel) 1293 n += 1 + l + sovQuads(uint64(l)) 1294 return n 1295} 1296func (m *StrictQuad_Ref_Iri) ProtoSize() (n int) { 1297 var l int 1298 _ = l 1299 l = len(m.Iri) 1300 n += 1 + l + sovQuads(uint64(l)) 1301 return n 1302} 1303func (m *Value) ProtoSize() (n int) { 1304 var l int 1305 _ = l 1306 if m.Value != nil { 1307 n += m.Value.ProtoSize() 1308 } 1309 return n 1310} 1311 1312func (m *Value_Raw) ProtoSize() (n int) { 1313 var l int 1314 _ = l 1315 if m.Raw != nil { 1316 l = len(m.Raw) 1317 n += 1 + l + sovQuads(uint64(l)) 1318 } 1319 return n 1320} 1321func (m *Value_Str) ProtoSize() (n int) { 1322 var l int 1323 _ = l 1324 l = len(m.Str) 1325 n += 1 + l + sovQuads(uint64(l)) 1326 return n 1327} 1328func (m *Value_Iri) ProtoSize() (n int) { 1329 var l int 1330 _ = l 1331 l = len(m.Iri) 1332 n += 1 + l + sovQuads(uint64(l)) 1333 return n 1334} 1335func (m *Value_Bnode) ProtoSize() (n int) { 1336 var l int 1337 _ = l 1338 l = len(m.Bnode) 1339 n += 1 + l + sovQuads(uint64(l)) 1340 return n 1341} 1342func (m *Value_TypedStr) ProtoSize() (n int) { 1343 var l int 1344 _ = l 1345 if m.TypedStr != nil { 1346 l = m.TypedStr.ProtoSize() 1347 n += 1 + l + sovQuads(uint64(l)) 1348 } 1349 return n 1350} 1351func (m *Value_LangStr) ProtoSize() (n int) { 1352 var l int 1353 _ = l 1354 if m.LangStr != nil { 1355 l = m.LangStr.ProtoSize() 1356 n += 1 + l + sovQuads(uint64(l)) 1357 } 1358 return n 1359} 1360func (m *Value_Int) ProtoSize() (n int) { 1361 var l int 1362 _ = l 1363 n += 1 + sovQuads(uint64(m.Int)) 1364 return n 1365} 1366func (m *Value_Float) ProtoSize() (n int) { 1367 var l int 1368 _ = l 1369 n += 9 1370 return n 1371} 1372func (m *Value_Boolean) ProtoSize() (n int) { 1373 var l int 1374 _ = l 1375 n += 2 1376 return n 1377} 1378func (m *Value_Time) ProtoSize() (n int) { 1379 var l int 1380 _ = l 1381 if m.Time != nil { 1382 l = m.Time.ProtoSize() 1383 n += 1 + l + sovQuads(uint64(l)) 1384 } 1385 return n 1386} 1387func (m *Value_TypedString) ProtoSize() (n int) { 1388 var l int 1389 _ = l 1390 l = len(m.Value) 1391 if l > 0 { 1392 n += 1 + l + sovQuads(uint64(l)) 1393 } 1394 l = len(m.Type) 1395 if l > 0 { 1396 n += 1 + l + sovQuads(uint64(l)) 1397 } 1398 return n 1399} 1400 1401func (m *Value_LangString) ProtoSize() (n int) { 1402 var l int 1403 _ = l 1404 l = len(m.Value) 1405 if l > 0 { 1406 n += 1 + l + sovQuads(uint64(l)) 1407 } 1408 l = len(m.Lang) 1409 if l > 0 { 1410 n += 1 + l + sovQuads(uint64(l)) 1411 } 1412 return n 1413} 1414 1415func (m *Value_Timestamp) ProtoSize() (n int) { 1416 var l int 1417 _ = l 1418 if m.Seconds != 0 { 1419 n += 1 + sovQuads(uint64(m.Seconds)) 1420 } 1421 if m.Nanos != 0 { 1422 n += 1 + sovQuads(uint64(m.Nanos)) 1423 } 1424 return n 1425} 1426 1427func (m *Header) ProtoSize() (n int) { 1428 var l int 1429 _ = l 1430 if m.Full { 1431 n += 2 1432 } 1433 if m.NotStrict { 1434 n += 2 1435 } 1436 return n 1437} 1438 1439func sovQuads(x uint64) (n int) { 1440 for { 1441 n++ 1442 x >>= 7 1443 if x == 0 { 1444 break 1445 } 1446 } 1447 return n 1448} 1449func sozQuads(x uint64) (n int) { 1450 return sovQuads(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 1451} 1452func (m *Quad) Unmarshal(data []byte) error { 1453 l := len(data) 1454 iNdEx := 0 1455 for iNdEx < l { 1456 preIndex := iNdEx 1457 var wire uint64 1458 for shift := uint(0); ; shift += 7 { 1459 if shift >= 64 { 1460 return ErrIntOverflowQuads 1461 } 1462 if iNdEx >= l { 1463 return io.ErrUnexpectedEOF 1464 } 1465 b := data[iNdEx] 1466 iNdEx++ 1467 wire |= (uint64(b) & 0x7F) << shift 1468 if b < 0x80 { 1469 break 1470 } 1471 } 1472 fieldNum := int32(wire >> 3) 1473 wireType := int(wire & 0x7) 1474 if wireType == 4 { 1475 return fmt.Errorf("proto: Quad: wiretype end group for non-group") 1476 } 1477 if fieldNum <= 0 { 1478 return fmt.Errorf("proto: Quad: illegal tag %d (wire type %d)", fieldNum, wire) 1479 } 1480 switch fieldNum { 1481 case 1: 1482 if wireType != 2 { 1483 return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType) 1484 } 1485 var stringLen uint64 1486 for shift := uint(0); ; shift += 7 { 1487 if shift >= 64 { 1488 return ErrIntOverflowQuads 1489 } 1490 if iNdEx >= l { 1491 return io.ErrUnexpectedEOF 1492 } 1493 b := data[iNdEx] 1494 iNdEx++ 1495 stringLen |= (uint64(b) & 0x7F) << shift 1496 if b < 0x80 { 1497 break 1498 } 1499 } 1500 intStringLen := int(stringLen) 1501 if intStringLen < 0 { 1502 return ErrInvalidLengthQuads 1503 } 1504 postIndex := iNdEx + intStringLen 1505 if postIndex > l { 1506 return io.ErrUnexpectedEOF 1507 } 1508 m.Subject = string(data[iNdEx:postIndex]) 1509 iNdEx = postIndex 1510 case 2: 1511 if wireType != 2 { 1512 return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType) 1513 } 1514 var stringLen uint64 1515 for shift := uint(0); ; shift += 7 { 1516 if shift >= 64 { 1517 return ErrIntOverflowQuads 1518 } 1519 if iNdEx >= l { 1520 return io.ErrUnexpectedEOF 1521 } 1522 b := data[iNdEx] 1523 iNdEx++ 1524 stringLen |= (uint64(b) & 0x7F) << shift 1525 if b < 0x80 { 1526 break 1527 } 1528 } 1529 intStringLen := int(stringLen) 1530 if intStringLen < 0 { 1531 return ErrInvalidLengthQuads 1532 } 1533 postIndex := iNdEx + intStringLen 1534 if postIndex > l { 1535 return io.ErrUnexpectedEOF 1536 } 1537 m.Predicate = string(data[iNdEx:postIndex]) 1538 iNdEx = postIndex 1539 case 3: 1540 if wireType != 2 { 1541 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) 1542 } 1543 var stringLen uint64 1544 for shift := uint(0); ; shift += 7 { 1545 if shift >= 64 { 1546 return ErrIntOverflowQuads 1547 } 1548 if iNdEx >= l { 1549 return io.ErrUnexpectedEOF 1550 } 1551 b := data[iNdEx] 1552 iNdEx++ 1553 stringLen |= (uint64(b) & 0x7F) << shift 1554 if b < 0x80 { 1555 break 1556 } 1557 } 1558 intStringLen := int(stringLen) 1559 if intStringLen < 0 { 1560 return ErrInvalidLengthQuads 1561 } 1562 postIndex := iNdEx + intStringLen 1563 if postIndex > l { 1564 return io.ErrUnexpectedEOF 1565 } 1566 m.Object = string(data[iNdEx:postIndex]) 1567 iNdEx = postIndex 1568 case 4: 1569 if wireType != 2 { 1570 return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) 1571 } 1572 var stringLen uint64 1573 for shift := uint(0); ; shift += 7 { 1574 if shift >= 64 { 1575 return ErrIntOverflowQuads 1576 } 1577 if iNdEx >= l { 1578 return io.ErrUnexpectedEOF 1579 } 1580 b := data[iNdEx] 1581 iNdEx++ 1582 stringLen |= (uint64(b) & 0x7F) << shift 1583 if b < 0x80 { 1584 break 1585 } 1586 } 1587 intStringLen := int(stringLen) 1588 if intStringLen < 0 { 1589 return ErrInvalidLengthQuads 1590 } 1591 postIndex := iNdEx + intStringLen 1592 if postIndex > l { 1593 return io.ErrUnexpectedEOF 1594 } 1595 m.Label = string(data[iNdEx:postIndex]) 1596 iNdEx = postIndex 1597 case 5: 1598 if wireType != 2 { 1599 return fmt.Errorf("proto: wrong wireType = %d for field SubjectValue", wireType) 1600 } 1601 var msglen int 1602 for shift := uint(0); ; shift += 7 { 1603 if shift >= 64 { 1604 return ErrIntOverflowQuads 1605 } 1606 if iNdEx >= l { 1607 return io.ErrUnexpectedEOF 1608 } 1609 b := data[iNdEx] 1610 iNdEx++ 1611 msglen |= (int(b) & 0x7F) << shift 1612 if b < 0x80 { 1613 break 1614 } 1615 } 1616 if msglen < 0 { 1617 return ErrInvalidLengthQuads 1618 } 1619 postIndex := iNdEx + msglen 1620 if postIndex > l { 1621 return io.ErrUnexpectedEOF 1622 } 1623 if m.SubjectValue == nil { 1624 m.SubjectValue = &Value{} 1625 } 1626 if err := m.SubjectValue.Unmarshal(data[iNdEx:postIndex]); err != nil { 1627 return err 1628 } 1629 iNdEx = postIndex 1630 case 6: 1631 if wireType != 2 { 1632 return fmt.Errorf("proto: wrong wireType = %d for field PredicateValue", wireType) 1633 } 1634 var msglen int 1635 for shift := uint(0); ; shift += 7 { 1636 if shift >= 64 { 1637 return ErrIntOverflowQuads 1638 } 1639 if iNdEx >= l { 1640 return io.ErrUnexpectedEOF 1641 } 1642 b := data[iNdEx] 1643 iNdEx++ 1644 msglen |= (int(b) & 0x7F) << shift 1645 if b < 0x80 { 1646 break 1647 } 1648 } 1649 if msglen < 0 { 1650 return ErrInvalidLengthQuads 1651 } 1652 postIndex := iNdEx + msglen 1653 if postIndex > l { 1654 return io.ErrUnexpectedEOF 1655 } 1656 if m.PredicateValue == nil { 1657 m.PredicateValue = &Value{} 1658 } 1659 if err := m.PredicateValue.Unmarshal(data[iNdEx:postIndex]); err != nil { 1660 return err 1661 } 1662 iNdEx = postIndex 1663 case 7: 1664 if wireType != 2 { 1665 return fmt.Errorf("proto: wrong wireType = %d for field ObjectValue", wireType) 1666 } 1667 var msglen int 1668 for shift := uint(0); ; shift += 7 { 1669 if shift >= 64 { 1670 return ErrIntOverflowQuads 1671 } 1672 if iNdEx >= l { 1673 return io.ErrUnexpectedEOF 1674 } 1675 b := data[iNdEx] 1676 iNdEx++ 1677 msglen |= (int(b) & 0x7F) << shift 1678 if b < 0x80 { 1679 break 1680 } 1681 } 1682 if msglen < 0 { 1683 return ErrInvalidLengthQuads 1684 } 1685 postIndex := iNdEx + msglen 1686 if postIndex > l { 1687 return io.ErrUnexpectedEOF 1688 } 1689 if m.ObjectValue == nil { 1690 m.ObjectValue = &Value{} 1691 } 1692 if err := m.ObjectValue.Unmarshal(data[iNdEx:postIndex]); err != nil { 1693 return err 1694 } 1695 iNdEx = postIndex 1696 case 8: 1697 if wireType != 2 { 1698 return fmt.Errorf("proto: wrong wireType = %d for field LabelValue", wireType) 1699 } 1700 var msglen int 1701 for shift := uint(0); ; shift += 7 { 1702 if shift >= 64 { 1703 return ErrIntOverflowQuads 1704 } 1705 if iNdEx >= l { 1706 return io.ErrUnexpectedEOF 1707 } 1708 b := data[iNdEx] 1709 iNdEx++ 1710 msglen |= (int(b) & 0x7F) << shift 1711 if b < 0x80 { 1712 break 1713 } 1714 } 1715 if msglen < 0 { 1716 return ErrInvalidLengthQuads 1717 } 1718 postIndex := iNdEx + msglen 1719 if postIndex > l { 1720 return io.ErrUnexpectedEOF 1721 } 1722 if m.LabelValue == nil { 1723 m.LabelValue = &Value{} 1724 } 1725 if err := m.LabelValue.Unmarshal(data[iNdEx:postIndex]); err != nil { 1726 return err 1727 } 1728 iNdEx = postIndex 1729 default: 1730 iNdEx = preIndex 1731 skippy, err := skipQuads(data[iNdEx:]) 1732 if err != nil { 1733 return err 1734 } 1735 if skippy < 0 { 1736 return ErrInvalidLengthQuads 1737 } 1738 if (iNdEx + skippy) > l { 1739 return io.ErrUnexpectedEOF 1740 } 1741 iNdEx += skippy 1742 } 1743 } 1744 1745 if iNdEx > l { 1746 return io.ErrUnexpectedEOF 1747 } 1748 return nil 1749} 1750func (m *WireQuad) Unmarshal(data []byte) error { 1751 l := len(data) 1752 iNdEx := 0 1753 for iNdEx < l { 1754 preIndex := iNdEx 1755 var wire uint64 1756 for shift := uint(0); ; shift += 7 { 1757 if shift >= 64 { 1758 return ErrIntOverflowQuads 1759 } 1760 if iNdEx >= l { 1761 return io.ErrUnexpectedEOF 1762 } 1763 b := data[iNdEx] 1764 iNdEx++ 1765 wire |= (uint64(b) & 0x7F) << shift 1766 if b < 0x80 { 1767 break 1768 } 1769 } 1770 fieldNum := int32(wire >> 3) 1771 wireType := int(wire & 0x7) 1772 if wireType == 4 { 1773 return fmt.Errorf("proto: WireQuad: wiretype end group for non-group") 1774 } 1775 if fieldNum <= 0 { 1776 return fmt.Errorf("proto: WireQuad: illegal tag %d (wire type %d)", fieldNum, wire) 1777 } 1778 switch fieldNum { 1779 case 1: 1780 if wireType != 2 { 1781 return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType) 1782 } 1783 var msglen int 1784 for shift := uint(0); ; shift += 7 { 1785 if shift >= 64 { 1786 return ErrIntOverflowQuads 1787 } 1788 if iNdEx >= l { 1789 return io.ErrUnexpectedEOF 1790 } 1791 b := data[iNdEx] 1792 iNdEx++ 1793 msglen |= (int(b) & 0x7F) << shift 1794 if b < 0x80 { 1795 break 1796 } 1797 } 1798 if msglen < 0 { 1799 return ErrInvalidLengthQuads 1800 } 1801 postIndex := iNdEx + msglen 1802 if postIndex > l { 1803 return io.ErrUnexpectedEOF 1804 } 1805 if m.Subject == nil { 1806 m.Subject = &Value{} 1807 } 1808 if err := m.Subject.Unmarshal(data[iNdEx:postIndex]); err != nil { 1809 return err 1810 } 1811 iNdEx = postIndex 1812 case 2: 1813 if wireType != 2 { 1814 return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType) 1815 } 1816 var msglen int 1817 for shift := uint(0); ; shift += 7 { 1818 if shift >= 64 { 1819 return ErrIntOverflowQuads 1820 } 1821 if iNdEx >= l { 1822 return io.ErrUnexpectedEOF 1823 } 1824 b := data[iNdEx] 1825 iNdEx++ 1826 msglen |= (int(b) & 0x7F) << shift 1827 if b < 0x80 { 1828 break 1829 } 1830 } 1831 if msglen < 0 { 1832 return ErrInvalidLengthQuads 1833 } 1834 postIndex := iNdEx + msglen 1835 if postIndex > l { 1836 return io.ErrUnexpectedEOF 1837 } 1838 if m.Predicate == nil { 1839 m.Predicate = &Value{} 1840 } 1841 if err := m.Predicate.Unmarshal(data[iNdEx:postIndex]); err != nil { 1842 return err 1843 } 1844 iNdEx = postIndex 1845 case 3: 1846 if wireType != 2 { 1847 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) 1848 } 1849 var msglen int 1850 for shift := uint(0); ; shift += 7 { 1851 if shift >= 64 { 1852 return ErrIntOverflowQuads 1853 } 1854 if iNdEx >= l { 1855 return io.ErrUnexpectedEOF 1856 } 1857 b := data[iNdEx] 1858 iNdEx++ 1859 msglen |= (int(b) & 0x7F) << shift 1860 if b < 0x80 { 1861 break 1862 } 1863 } 1864 if msglen < 0 { 1865 return ErrInvalidLengthQuads 1866 } 1867 postIndex := iNdEx + msglen 1868 if postIndex > l { 1869 return io.ErrUnexpectedEOF 1870 } 1871 if m.Object == nil { 1872 m.Object = &Value{} 1873 } 1874 if err := m.Object.Unmarshal(data[iNdEx:postIndex]); err != nil { 1875 return err 1876 } 1877 iNdEx = postIndex 1878 case 4: 1879 if wireType != 2 { 1880 return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) 1881 } 1882 var msglen int 1883 for shift := uint(0); ; shift += 7 { 1884 if shift >= 64 { 1885 return ErrIntOverflowQuads 1886 } 1887 if iNdEx >= l { 1888 return io.ErrUnexpectedEOF 1889 } 1890 b := data[iNdEx] 1891 iNdEx++ 1892 msglen |= (int(b) & 0x7F) << shift 1893 if b < 0x80 { 1894 break 1895 } 1896 } 1897 if msglen < 0 { 1898 return ErrInvalidLengthQuads 1899 } 1900 postIndex := iNdEx + msglen 1901 if postIndex > l { 1902 return io.ErrUnexpectedEOF 1903 } 1904 if m.Label == nil { 1905 m.Label = &Value{} 1906 } 1907 if err := m.Label.Unmarshal(data[iNdEx:postIndex]); err != nil { 1908 return err 1909 } 1910 iNdEx = postIndex 1911 default: 1912 iNdEx = preIndex 1913 skippy, err := skipQuads(data[iNdEx:]) 1914 if err != nil { 1915 return err 1916 } 1917 if skippy < 0 { 1918 return ErrInvalidLengthQuads 1919 } 1920 if (iNdEx + skippy) > l { 1921 return io.ErrUnexpectedEOF 1922 } 1923 iNdEx += skippy 1924 } 1925 } 1926 1927 if iNdEx > l { 1928 return io.ErrUnexpectedEOF 1929 } 1930 return nil 1931} 1932func (m *StrictQuad) Unmarshal(data []byte) error { 1933 l := len(data) 1934 iNdEx := 0 1935 for iNdEx < l { 1936 preIndex := iNdEx 1937 var wire uint64 1938 for shift := uint(0); ; shift += 7 { 1939 if shift >= 64 { 1940 return ErrIntOverflowQuads 1941 } 1942 if iNdEx >= l { 1943 return io.ErrUnexpectedEOF 1944 } 1945 b := data[iNdEx] 1946 iNdEx++ 1947 wire |= (uint64(b) & 0x7F) << shift 1948 if b < 0x80 { 1949 break 1950 } 1951 } 1952 fieldNum := int32(wire >> 3) 1953 wireType := int(wire & 0x7) 1954 if wireType == 4 { 1955 return fmt.Errorf("proto: StrictQuad: wiretype end group for non-group") 1956 } 1957 if fieldNum <= 0 { 1958 return fmt.Errorf("proto: StrictQuad: illegal tag %d (wire type %d)", fieldNum, wire) 1959 } 1960 switch fieldNum { 1961 case 1: 1962 if wireType != 2 { 1963 return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType) 1964 } 1965 var msglen int 1966 for shift := uint(0); ; shift += 7 { 1967 if shift >= 64 { 1968 return ErrIntOverflowQuads 1969 } 1970 if iNdEx >= l { 1971 return io.ErrUnexpectedEOF 1972 } 1973 b := data[iNdEx] 1974 iNdEx++ 1975 msglen |= (int(b) & 0x7F) << shift 1976 if b < 0x80 { 1977 break 1978 } 1979 } 1980 if msglen < 0 { 1981 return ErrInvalidLengthQuads 1982 } 1983 postIndex := iNdEx + msglen 1984 if postIndex > l { 1985 return io.ErrUnexpectedEOF 1986 } 1987 if m.Subject == nil { 1988 m.Subject = &StrictQuad_Ref{} 1989 } 1990 if err := m.Subject.Unmarshal(data[iNdEx:postIndex]); err != nil { 1991 return err 1992 } 1993 iNdEx = postIndex 1994 case 2: 1995 if wireType != 2 { 1996 return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType) 1997 } 1998 var msglen int 1999 for shift := uint(0); ; shift += 7 { 2000 if shift >= 64 { 2001 return ErrIntOverflowQuads 2002 } 2003 if iNdEx >= l { 2004 return io.ErrUnexpectedEOF 2005 } 2006 b := data[iNdEx] 2007 iNdEx++ 2008 msglen |= (int(b) & 0x7F) << shift 2009 if b < 0x80 { 2010 break 2011 } 2012 } 2013 if msglen < 0 { 2014 return ErrInvalidLengthQuads 2015 } 2016 postIndex := iNdEx + msglen 2017 if postIndex > l { 2018 return io.ErrUnexpectedEOF 2019 } 2020 if m.Predicate == nil { 2021 m.Predicate = &StrictQuad_Ref{} 2022 } 2023 if err := m.Predicate.Unmarshal(data[iNdEx:postIndex]); err != nil { 2024 return err 2025 } 2026 iNdEx = postIndex 2027 case 3: 2028 if wireType != 2 { 2029 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) 2030 } 2031 var msglen int 2032 for shift := uint(0); ; shift += 7 { 2033 if shift >= 64 { 2034 return ErrIntOverflowQuads 2035 } 2036 if iNdEx >= l { 2037 return io.ErrUnexpectedEOF 2038 } 2039 b := data[iNdEx] 2040 iNdEx++ 2041 msglen |= (int(b) & 0x7F) << shift 2042 if b < 0x80 { 2043 break 2044 } 2045 } 2046 if msglen < 0 { 2047 return ErrInvalidLengthQuads 2048 } 2049 postIndex := iNdEx + msglen 2050 if postIndex > l { 2051 return io.ErrUnexpectedEOF 2052 } 2053 if m.Object == nil { 2054 m.Object = &Value{} 2055 } 2056 if err := m.Object.Unmarshal(data[iNdEx:postIndex]); err != nil { 2057 return err 2058 } 2059 iNdEx = postIndex 2060 case 4: 2061 if wireType != 2 { 2062 return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) 2063 } 2064 var msglen int 2065 for shift := uint(0); ; shift += 7 { 2066 if shift >= 64 { 2067 return ErrIntOverflowQuads 2068 } 2069 if iNdEx >= l { 2070 return io.ErrUnexpectedEOF 2071 } 2072 b := data[iNdEx] 2073 iNdEx++ 2074 msglen |= (int(b) & 0x7F) << shift 2075 if b < 0x80 { 2076 break 2077 } 2078 } 2079 if msglen < 0 { 2080 return ErrInvalidLengthQuads 2081 } 2082 postIndex := iNdEx + msglen 2083 if postIndex > l { 2084 return io.ErrUnexpectedEOF 2085 } 2086 if m.Label == nil { 2087 m.Label = &StrictQuad_Ref{} 2088 } 2089 if err := m.Label.Unmarshal(data[iNdEx:postIndex]); err != nil { 2090 return err 2091 } 2092 iNdEx = postIndex 2093 default: 2094 iNdEx = preIndex 2095 skippy, err := skipQuads(data[iNdEx:]) 2096 if err != nil { 2097 return err 2098 } 2099 if skippy < 0 { 2100 return ErrInvalidLengthQuads 2101 } 2102 if (iNdEx + skippy) > l { 2103 return io.ErrUnexpectedEOF 2104 } 2105 iNdEx += skippy 2106 } 2107 } 2108 2109 if iNdEx > l { 2110 return io.ErrUnexpectedEOF 2111 } 2112 return nil 2113} 2114func (m *StrictQuad_Ref) Unmarshal(data []byte) error { 2115 l := len(data) 2116 iNdEx := 0 2117 for iNdEx < l { 2118 preIndex := iNdEx 2119 var wire uint64 2120 for shift := uint(0); ; shift += 7 { 2121 if shift >= 64 { 2122 return ErrIntOverflowQuads 2123 } 2124 if iNdEx >= l { 2125 return io.ErrUnexpectedEOF 2126 } 2127 b := data[iNdEx] 2128 iNdEx++ 2129 wire |= (uint64(b) & 0x7F) << shift 2130 if b < 0x80 { 2131 break 2132 } 2133 } 2134 fieldNum := int32(wire >> 3) 2135 wireType := int(wire & 0x7) 2136 if wireType == 4 { 2137 return fmt.Errorf("proto: Ref: wiretype end group for non-group") 2138 } 2139 if fieldNum <= 0 { 2140 return fmt.Errorf("proto: Ref: illegal tag %d (wire type %d)", fieldNum, wire) 2141 } 2142 switch fieldNum { 2143 case 2: 2144 if wireType != 2 { 2145 return fmt.Errorf("proto: wrong wireType = %d for field BnodeLabel", wireType) 2146 } 2147 var stringLen uint64 2148 for shift := uint(0); ; shift += 7 { 2149 if shift >= 64 { 2150 return ErrIntOverflowQuads 2151 } 2152 if iNdEx >= l { 2153 return io.ErrUnexpectedEOF 2154 } 2155 b := data[iNdEx] 2156 iNdEx++ 2157 stringLen |= (uint64(b) & 0x7F) << shift 2158 if b < 0x80 { 2159 break 2160 } 2161 } 2162 intStringLen := int(stringLen) 2163 if intStringLen < 0 { 2164 return ErrInvalidLengthQuads 2165 } 2166 postIndex := iNdEx + intStringLen 2167 if postIndex > l { 2168 return io.ErrUnexpectedEOF 2169 } 2170 m.Value = &StrictQuad_Ref_BnodeLabel{string(data[iNdEx:postIndex])} 2171 iNdEx = postIndex 2172 case 3: 2173 if wireType != 2 { 2174 return fmt.Errorf("proto: wrong wireType = %d for field Iri", wireType) 2175 } 2176 var stringLen uint64 2177 for shift := uint(0); ; shift += 7 { 2178 if shift >= 64 { 2179 return ErrIntOverflowQuads 2180 } 2181 if iNdEx >= l { 2182 return io.ErrUnexpectedEOF 2183 } 2184 b := data[iNdEx] 2185 iNdEx++ 2186 stringLen |= (uint64(b) & 0x7F) << shift 2187 if b < 0x80 { 2188 break 2189 } 2190 } 2191 intStringLen := int(stringLen) 2192 if intStringLen < 0 { 2193 return ErrInvalidLengthQuads 2194 } 2195 postIndex := iNdEx + intStringLen 2196 if postIndex > l { 2197 return io.ErrUnexpectedEOF 2198 } 2199 m.Value = &StrictQuad_Ref_Iri{string(data[iNdEx:postIndex])} 2200 iNdEx = postIndex 2201 default: 2202 iNdEx = preIndex 2203 skippy, err := skipQuads(data[iNdEx:]) 2204 if err != nil { 2205 return err 2206 } 2207 if skippy < 0 { 2208 return ErrInvalidLengthQuads 2209 } 2210 if (iNdEx + skippy) > l { 2211 return io.ErrUnexpectedEOF 2212 } 2213 iNdEx += skippy 2214 } 2215 } 2216 2217 if iNdEx > l { 2218 return io.ErrUnexpectedEOF 2219 } 2220 return nil 2221} 2222func (m *Value) Unmarshal(data []byte) error { 2223 l := len(data) 2224 iNdEx := 0 2225 for iNdEx < l { 2226 preIndex := iNdEx 2227 var wire uint64 2228 for shift := uint(0); ; shift += 7 { 2229 if shift >= 64 { 2230 return ErrIntOverflowQuads 2231 } 2232 if iNdEx >= l { 2233 return io.ErrUnexpectedEOF 2234 } 2235 b := data[iNdEx] 2236 iNdEx++ 2237 wire |= (uint64(b) & 0x7F) << shift 2238 if b < 0x80 { 2239 break 2240 } 2241 } 2242 fieldNum := int32(wire >> 3) 2243 wireType := int(wire & 0x7) 2244 if wireType == 4 { 2245 return fmt.Errorf("proto: Value: wiretype end group for non-group") 2246 } 2247 if fieldNum <= 0 { 2248 return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire) 2249 } 2250 switch fieldNum { 2251 case 1: 2252 if wireType != 2 { 2253 return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType) 2254 } 2255 var byteLen int 2256 for shift := uint(0); ; shift += 7 { 2257 if shift >= 64 { 2258 return ErrIntOverflowQuads 2259 } 2260 if iNdEx >= l { 2261 return io.ErrUnexpectedEOF 2262 } 2263 b := data[iNdEx] 2264 iNdEx++ 2265 byteLen |= (int(b) & 0x7F) << shift 2266 if b < 0x80 { 2267 break 2268 } 2269 } 2270 if byteLen < 0 { 2271 return ErrInvalidLengthQuads 2272 } 2273 postIndex := iNdEx + byteLen 2274 if postIndex > l { 2275 return io.ErrUnexpectedEOF 2276 } 2277 v := make([]byte, postIndex-iNdEx) 2278 copy(v, data[iNdEx:postIndex]) 2279 m.Value = &Value_Raw{v} 2280 iNdEx = postIndex 2281 case 2: 2282 if wireType != 2 { 2283 return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType) 2284 } 2285 var stringLen uint64 2286 for shift := uint(0); ; shift += 7 { 2287 if shift >= 64 { 2288 return ErrIntOverflowQuads 2289 } 2290 if iNdEx >= l { 2291 return io.ErrUnexpectedEOF 2292 } 2293 b := data[iNdEx] 2294 iNdEx++ 2295 stringLen |= (uint64(b) & 0x7F) << shift 2296 if b < 0x80 { 2297 break 2298 } 2299 } 2300 intStringLen := int(stringLen) 2301 if intStringLen < 0 { 2302 return ErrInvalidLengthQuads 2303 } 2304 postIndex := iNdEx + intStringLen 2305 if postIndex > l { 2306 return io.ErrUnexpectedEOF 2307 } 2308 m.Value = &Value_Str{string(data[iNdEx:postIndex])} 2309 iNdEx = postIndex 2310 case 3: 2311 if wireType != 2 { 2312 return fmt.Errorf("proto: wrong wireType = %d for field Iri", wireType) 2313 } 2314 var stringLen uint64 2315 for shift := uint(0); ; shift += 7 { 2316 if shift >= 64 { 2317 return ErrIntOverflowQuads 2318 } 2319 if iNdEx >= l { 2320 return io.ErrUnexpectedEOF 2321 } 2322 b := data[iNdEx] 2323 iNdEx++ 2324 stringLen |= (uint64(b) & 0x7F) << shift 2325 if b < 0x80 { 2326 break 2327 } 2328 } 2329 intStringLen := int(stringLen) 2330 if intStringLen < 0 { 2331 return ErrInvalidLengthQuads 2332 } 2333 postIndex := iNdEx + intStringLen 2334 if postIndex > l { 2335 return io.ErrUnexpectedEOF 2336 } 2337 m.Value = &Value_Iri{string(data[iNdEx:postIndex])} 2338 iNdEx = postIndex 2339 case 4: 2340 if wireType != 2 { 2341 return fmt.Errorf("proto: wrong wireType = %d for field Bnode", wireType) 2342 } 2343 var stringLen uint64 2344 for shift := uint(0); ; shift += 7 { 2345 if shift >= 64 { 2346 return ErrIntOverflowQuads 2347 } 2348 if iNdEx >= l { 2349 return io.ErrUnexpectedEOF 2350 } 2351 b := data[iNdEx] 2352 iNdEx++ 2353 stringLen |= (uint64(b) & 0x7F) << shift 2354 if b < 0x80 { 2355 break 2356 } 2357 } 2358 intStringLen := int(stringLen) 2359 if intStringLen < 0 { 2360 return ErrInvalidLengthQuads 2361 } 2362 postIndex := iNdEx + intStringLen 2363 if postIndex > l { 2364 return io.ErrUnexpectedEOF 2365 } 2366 m.Value = &Value_Bnode{string(data[iNdEx:postIndex])} 2367 iNdEx = postIndex 2368 case 5: 2369 if wireType != 2 { 2370 return fmt.Errorf("proto: wrong wireType = %d for field TypedStr", wireType) 2371 } 2372 var msglen int 2373 for shift := uint(0); ; shift += 7 { 2374 if shift >= 64 { 2375 return ErrIntOverflowQuads 2376 } 2377 if iNdEx >= l { 2378 return io.ErrUnexpectedEOF 2379 } 2380 b := data[iNdEx] 2381 iNdEx++ 2382 msglen |= (int(b) & 0x7F) << shift 2383 if b < 0x80 { 2384 break 2385 } 2386 } 2387 if msglen < 0 { 2388 return ErrInvalidLengthQuads 2389 } 2390 postIndex := iNdEx + msglen 2391 if postIndex > l { 2392 return io.ErrUnexpectedEOF 2393 } 2394 v := &Value_TypedString{} 2395 if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { 2396 return err 2397 } 2398 m.Value = &Value_TypedStr{v} 2399 iNdEx = postIndex 2400 case 6: 2401 if wireType != 2 { 2402 return fmt.Errorf("proto: wrong wireType = %d for field LangStr", wireType) 2403 } 2404 var msglen int 2405 for shift := uint(0); ; shift += 7 { 2406 if shift >= 64 { 2407 return ErrIntOverflowQuads 2408 } 2409 if iNdEx >= l { 2410 return io.ErrUnexpectedEOF 2411 } 2412 b := data[iNdEx] 2413 iNdEx++ 2414 msglen |= (int(b) & 0x7F) << shift 2415 if b < 0x80 { 2416 break 2417 } 2418 } 2419 if msglen < 0 { 2420 return ErrInvalidLengthQuads 2421 } 2422 postIndex := iNdEx + msglen 2423 if postIndex > l { 2424 return io.ErrUnexpectedEOF 2425 } 2426 v := &Value_LangString{} 2427 if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { 2428 return err 2429 } 2430 m.Value = &Value_LangStr{v} 2431 iNdEx = postIndex 2432 case 7: 2433 if wireType != 0 { 2434 return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType) 2435 } 2436 var v int64 2437 for shift := uint(0); ; shift += 7 { 2438 if shift >= 64 { 2439 return ErrIntOverflowQuads 2440 } 2441 if iNdEx >= l { 2442 return io.ErrUnexpectedEOF 2443 } 2444 b := data[iNdEx] 2445 iNdEx++ 2446 v |= (int64(b) & 0x7F) << shift 2447 if b < 0x80 { 2448 break 2449 } 2450 } 2451 m.Value = &Value_Int{v} 2452 case 8: 2453 if wireType != 1 { 2454 return fmt.Errorf("proto: wrong wireType = %d for field Float", wireType) 2455 } 2456 var v uint64 2457 if (iNdEx + 8) > l { 2458 return io.ErrUnexpectedEOF 2459 } 2460 iNdEx += 8 2461 v = uint64(data[iNdEx-8]) 2462 v |= uint64(data[iNdEx-7]) << 8 2463 v |= uint64(data[iNdEx-6]) << 16 2464 v |= uint64(data[iNdEx-5]) << 24 2465 v |= uint64(data[iNdEx-4]) << 32 2466 v |= uint64(data[iNdEx-3]) << 40 2467 v |= uint64(data[iNdEx-2]) << 48 2468 v |= uint64(data[iNdEx-1]) << 56 2469 m.Value = &Value_Float{float64(math.Float64frombits(v))} 2470 case 9: 2471 if wireType != 0 { 2472 return fmt.Errorf("proto: wrong wireType = %d for field Boolean", wireType) 2473 } 2474 var v int 2475 for shift := uint(0); ; shift += 7 { 2476 if shift >= 64 { 2477 return ErrIntOverflowQuads 2478 } 2479 if iNdEx >= l { 2480 return io.ErrUnexpectedEOF 2481 } 2482 b := data[iNdEx] 2483 iNdEx++ 2484 v |= (int(b) & 0x7F) << shift 2485 if b < 0x80 { 2486 break 2487 } 2488 } 2489 b := bool(v != 0) 2490 m.Value = &Value_Boolean{b} 2491 case 10: 2492 if wireType != 2 { 2493 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) 2494 } 2495 var msglen int 2496 for shift := uint(0); ; shift += 7 { 2497 if shift >= 64 { 2498 return ErrIntOverflowQuads 2499 } 2500 if iNdEx >= l { 2501 return io.ErrUnexpectedEOF 2502 } 2503 b := data[iNdEx] 2504 iNdEx++ 2505 msglen |= (int(b) & 0x7F) << shift 2506 if b < 0x80 { 2507 break 2508 } 2509 } 2510 if msglen < 0 { 2511 return ErrInvalidLengthQuads 2512 } 2513 postIndex := iNdEx + msglen 2514 if postIndex > l { 2515 return io.ErrUnexpectedEOF 2516 } 2517 v := &Value_Timestamp{} 2518 if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { 2519 return err 2520 } 2521 m.Value = &Value_Time{v} 2522 iNdEx = postIndex 2523 default: 2524 iNdEx = preIndex 2525 skippy, err := skipQuads(data[iNdEx:]) 2526 if err != nil { 2527 return err 2528 } 2529 if skippy < 0 { 2530 return ErrInvalidLengthQuads 2531 } 2532 if (iNdEx + skippy) > l { 2533 return io.ErrUnexpectedEOF 2534 } 2535 iNdEx += skippy 2536 } 2537 } 2538 2539 if iNdEx > l { 2540 return io.ErrUnexpectedEOF 2541 } 2542 return nil 2543} 2544func (m *Value_TypedString) Unmarshal(data []byte) error { 2545 l := len(data) 2546 iNdEx := 0 2547 for iNdEx < l { 2548 preIndex := iNdEx 2549 var wire uint64 2550 for shift := uint(0); ; shift += 7 { 2551 if shift >= 64 { 2552 return ErrIntOverflowQuads 2553 } 2554 if iNdEx >= l { 2555 return io.ErrUnexpectedEOF 2556 } 2557 b := data[iNdEx] 2558 iNdEx++ 2559 wire |= (uint64(b) & 0x7F) << shift 2560 if b < 0x80 { 2561 break 2562 } 2563 } 2564 fieldNum := int32(wire >> 3) 2565 wireType := int(wire & 0x7) 2566 if wireType == 4 { 2567 return fmt.Errorf("proto: TypedString: wiretype end group for non-group") 2568 } 2569 if fieldNum <= 0 { 2570 return fmt.Errorf("proto: TypedString: illegal tag %d (wire type %d)", fieldNum, wire) 2571 } 2572 switch fieldNum { 2573 case 1: 2574 if wireType != 2 { 2575 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2576 } 2577 var stringLen uint64 2578 for shift := uint(0); ; shift += 7 { 2579 if shift >= 64 { 2580 return ErrIntOverflowQuads 2581 } 2582 if iNdEx >= l { 2583 return io.ErrUnexpectedEOF 2584 } 2585 b := data[iNdEx] 2586 iNdEx++ 2587 stringLen |= (uint64(b) & 0x7F) << shift 2588 if b < 0x80 { 2589 break 2590 } 2591 } 2592 intStringLen := int(stringLen) 2593 if intStringLen < 0 { 2594 return ErrInvalidLengthQuads 2595 } 2596 postIndex := iNdEx + intStringLen 2597 if postIndex > l { 2598 return io.ErrUnexpectedEOF 2599 } 2600 m.Value = string(data[iNdEx:postIndex]) 2601 iNdEx = postIndex 2602 case 2: 2603 if wireType != 2 { 2604 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 2605 } 2606 var stringLen uint64 2607 for shift := uint(0); ; shift += 7 { 2608 if shift >= 64 { 2609 return ErrIntOverflowQuads 2610 } 2611 if iNdEx >= l { 2612 return io.ErrUnexpectedEOF 2613 } 2614 b := data[iNdEx] 2615 iNdEx++ 2616 stringLen |= (uint64(b) & 0x7F) << shift 2617 if b < 0x80 { 2618 break 2619 } 2620 } 2621 intStringLen := int(stringLen) 2622 if intStringLen < 0 { 2623 return ErrInvalidLengthQuads 2624 } 2625 postIndex := iNdEx + intStringLen 2626 if postIndex > l { 2627 return io.ErrUnexpectedEOF 2628 } 2629 m.Type = string(data[iNdEx:postIndex]) 2630 iNdEx = postIndex 2631 default: 2632 iNdEx = preIndex 2633 skippy, err := skipQuads(data[iNdEx:]) 2634 if err != nil { 2635 return err 2636 } 2637 if skippy < 0 { 2638 return ErrInvalidLengthQuads 2639 } 2640 if (iNdEx + skippy) > l { 2641 return io.ErrUnexpectedEOF 2642 } 2643 iNdEx += skippy 2644 } 2645 } 2646 2647 if iNdEx > l { 2648 return io.ErrUnexpectedEOF 2649 } 2650 return nil 2651} 2652func (m *Value_LangString) Unmarshal(data []byte) error { 2653 l := len(data) 2654 iNdEx := 0 2655 for iNdEx < l { 2656 preIndex := iNdEx 2657 var wire uint64 2658 for shift := uint(0); ; shift += 7 { 2659 if shift >= 64 { 2660 return ErrIntOverflowQuads 2661 } 2662 if iNdEx >= l { 2663 return io.ErrUnexpectedEOF 2664 } 2665 b := data[iNdEx] 2666 iNdEx++ 2667 wire |= (uint64(b) & 0x7F) << shift 2668 if b < 0x80 { 2669 break 2670 } 2671 } 2672 fieldNum := int32(wire >> 3) 2673 wireType := int(wire & 0x7) 2674 if wireType == 4 { 2675 return fmt.Errorf("proto: LangString: wiretype end group for non-group") 2676 } 2677 if fieldNum <= 0 { 2678 return fmt.Errorf("proto: LangString: illegal tag %d (wire type %d)", fieldNum, wire) 2679 } 2680 switch fieldNum { 2681 case 1: 2682 if wireType != 2 { 2683 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 2684 } 2685 var stringLen uint64 2686 for shift := uint(0); ; shift += 7 { 2687 if shift >= 64 { 2688 return ErrIntOverflowQuads 2689 } 2690 if iNdEx >= l { 2691 return io.ErrUnexpectedEOF 2692 } 2693 b := data[iNdEx] 2694 iNdEx++ 2695 stringLen |= (uint64(b) & 0x7F) << shift 2696 if b < 0x80 { 2697 break 2698 } 2699 } 2700 intStringLen := int(stringLen) 2701 if intStringLen < 0 { 2702 return ErrInvalidLengthQuads 2703 } 2704 postIndex := iNdEx + intStringLen 2705 if postIndex > l { 2706 return io.ErrUnexpectedEOF 2707 } 2708 m.Value = string(data[iNdEx:postIndex]) 2709 iNdEx = postIndex 2710 case 2: 2711 if wireType != 2 { 2712 return fmt.Errorf("proto: wrong wireType = %d for field Lang", wireType) 2713 } 2714 var stringLen uint64 2715 for shift := uint(0); ; shift += 7 { 2716 if shift >= 64 { 2717 return ErrIntOverflowQuads 2718 } 2719 if iNdEx >= l { 2720 return io.ErrUnexpectedEOF 2721 } 2722 b := data[iNdEx] 2723 iNdEx++ 2724 stringLen |= (uint64(b) & 0x7F) << shift 2725 if b < 0x80 { 2726 break 2727 } 2728 } 2729 intStringLen := int(stringLen) 2730 if intStringLen < 0 { 2731 return ErrInvalidLengthQuads 2732 } 2733 postIndex := iNdEx + intStringLen 2734 if postIndex > l { 2735 return io.ErrUnexpectedEOF 2736 } 2737 m.Lang = string(data[iNdEx:postIndex]) 2738 iNdEx = postIndex 2739 default: 2740 iNdEx = preIndex 2741 skippy, err := skipQuads(data[iNdEx:]) 2742 if err != nil { 2743 return err 2744 } 2745 if skippy < 0 { 2746 return ErrInvalidLengthQuads 2747 } 2748 if (iNdEx + skippy) > l { 2749 return io.ErrUnexpectedEOF 2750 } 2751 iNdEx += skippy 2752 } 2753 } 2754 2755 if iNdEx > l { 2756 return io.ErrUnexpectedEOF 2757 } 2758 return nil 2759} 2760func (m *Value_Timestamp) Unmarshal(data []byte) error { 2761 l := len(data) 2762 iNdEx := 0 2763 for iNdEx < l { 2764 preIndex := iNdEx 2765 var wire uint64 2766 for shift := uint(0); ; shift += 7 { 2767 if shift >= 64 { 2768 return ErrIntOverflowQuads 2769 } 2770 if iNdEx >= l { 2771 return io.ErrUnexpectedEOF 2772 } 2773 b := data[iNdEx] 2774 iNdEx++ 2775 wire |= (uint64(b) & 0x7F) << shift 2776 if b < 0x80 { 2777 break 2778 } 2779 } 2780 fieldNum := int32(wire >> 3) 2781 wireType := int(wire & 0x7) 2782 if wireType == 4 { 2783 return fmt.Errorf("proto: Timestamp: wiretype end group for non-group") 2784 } 2785 if fieldNum <= 0 { 2786 return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire) 2787 } 2788 switch fieldNum { 2789 case 1: 2790 if wireType != 0 { 2791 return fmt.Errorf("proto: wrong wireType = %d for field Seconds", wireType) 2792 } 2793 m.Seconds = 0 2794 for shift := uint(0); ; shift += 7 { 2795 if shift >= 64 { 2796 return ErrIntOverflowQuads 2797 } 2798 if iNdEx >= l { 2799 return io.ErrUnexpectedEOF 2800 } 2801 b := data[iNdEx] 2802 iNdEx++ 2803 m.Seconds |= (int64(b) & 0x7F) << shift 2804 if b < 0x80 { 2805 break 2806 } 2807 } 2808 case 2: 2809 if wireType != 0 { 2810 return fmt.Errorf("proto: wrong wireType = %d for field Nanos", wireType) 2811 } 2812 m.Nanos = 0 2813 for shift := uint(0); ; shift += 7 { 2814 if shift >= 64 { 2815 return ErrIntOverflowQuads 2816 } 2817 if iNdEx >= l { 2818 return io.ErrUnexpectedEOF 2819 } 2820 b := data[iNdEx] 2821 iNdEx++ 2822 m.Nanos |= (int32(b) & 0x7F) << shift 2823 if b < 0x80 { 2824 break 2825 } 2826 } 2827 default: 2828 iNdEx = preIndex 2829 skippy, err := skipQuads(data[iNdEx:]) 2830 if err != nil { 2831 return err 2832 } 2833 if skippy < 0 { 2834 return ErrInvalidLengthQuads 2835 } 2836 if (iNdEx + skippy) > l { 2837 return io.ErrUnexpectedEOF 2838 } 2839 iNdEx += skippy 2840 } 2841 } 2842 2843 if iNdEx > l { 2844 return io.ErrUnexpectedEOF 2845 } 2846 return nil 2847} 2848func (m *Header) Unmarshal(data []byte) error { 2849 l := len(data) 2850 iNdEx := 0 2851 for iNdEx < l { 2852 preIndex := iNdEx 2853 var wire uint64 2854 for shift := uint(0); ; shift += 7 { 2855 if shift >= 64 { 2856 return ErrIntOverflowQuads 2857 } 2858 if iNdEx >= l { 2859 return io.ErrUnexpectedEOF 2860 } 2861 b := data[iNdEx] 2862 iNdEx++ 2863 wire |= (uint64(b) & 0x7F) << shift 2864 if b < 0x80 { 2865 break 2866 } 2867 } 2868 fieldNum := int32(wire >> 3) 2869 wireType := int(wire & 0x7) 2870 if wireType == 4 { 2871 return fmt.Errorf("proto: Header: wiretype end group for non-group") 2872 } 2873 if fieldNum <= 0 { 2874 return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) 2875 } 2876 switch fieldNum { 2877 case 1: 2878 if wireType != 0 { 2879 return fmt.Errorf("proto: wrong wireType = %d for field Full", wireType) 2880 } 2881 var v int 2882 for shift := uint(0); ; shift += 7 { 2883 if shift >= 64 { 2884 return ErrIntOverflowQuads 2885 } 2886 if iNdEx >= l { 2887 return io.ErrUnexpectedEOF 2888 } 2889 b := data[iNdEx] 2890 iNdEx++ 2891 v |= (int(b) & 0x7F) << shift 2892 if b < 0x80 { 2893 break 2894 } 2895 } 2896 m.Full = bool(v != 0) 2897 case 2: 2898 if wireType != 0 { 2899 return fmt.Errorf("proto: wrong wireType = %d for field NotStrict", wireType) 2900 } 2901 var v int 2902 for shift := uint(0); ; shift += 7 { 2903 if shift >= 64 { 2904 return ErrIntOverflowQuads 2905 } 2906 if iNdEx >= l { 2907 return io.ErrUnexpectedEOF 2908 } 2909 b := data[iNdEx] 2910 iNdEx++ 2911 v |= (int(b) & 0x7F) << shift 2912 if b < 0x80 { 2913 break 2914 } 2915 } 2916 m.NotStrict = bool(v != 0) 2917 default: 2918 iNdEx = preIndex 2919 skippy, err := skipQuads(data[iNdEx:]) 2920 if err != nil { 2921 return err 2922 } 2923 if skippy < 0 { 2924 return ErrInvalidLengthQuads 2925 } 2926 if (iNdEx + skippy) > l { 2927 return io.ErrUnexpectedEOF 2928 } 2929 iNdEx += skippy 2930 } 2931 } 2932 2933 if iNdEx > l { 2934 return io.ErrUnexpectedEOF 2935 } 2936 return nil 2937} 2938func skipQuads(data []byte) (n int, err error) { 2939 l := len(data) 2940 iNdEx := 0 2941 for iNdEx < l { 2942 var wire uint64 2943 for shift := uint(0); ; shift += 7 { 2944 if shift >= 64 { 2945 return 0, ErrIntOverflowQuads 2946 } 2947 if iNdEx >= l { 2948 return 0, io.ErrUnexpectedEOF 2949 } 2950 b := data[iNdEx] 2951 iNdEx++ 2952 wire |= (uint64(b) & 0x7F) << shift 2953 if b < 0x80 { 2954 break 2955 } 2956 } 2957 wireType := int(wire & 0x7) 2958 switch wireType { 2959 case 0: 2960 for shift := uint(0); ; shift += 7 { 2961 if shift >= 64 { 2962 return 0, ErrIntOverflowQuads 2963 } 2964 if iNdEx >= l { 2965 return 0, io.ErrUnexpectedEOF 2966 } 2967 iNdEx++ 2968 if data[iNdEx-1] < 0x80 { 2969 break 2970 } 2971 } 2972 return iNdEx, nil 2973 case 1: 2974 iNdEx += 8 2975 return iNdEx, nil 2976 case 2: 2977 var length int 2978 for shift := uint(0); ; shift += 7 { 2979 if shift >= 64 { 2980 return 0, ErrIntOverflowQuads 2981 } 2982 if iNdEx >= l { 2983 return 0, io.ErrUnexpectedEOF 2984 } 2985 b := data[iNdEx] 2986 iNdEx++ 2987 length |= (int(b) & 0x7F) << shift 2988 if b < 0x80 { 2989 break 2990 } 2991 } 2992 iNdEx += length 2993 if length < 0 { 2994 return 0, ErrInvalidLengthQuads 2995 } 2996 return iNdEx, nil 2997 case 3: 2998 for { 2999 var innerWire uint64 3000 var start int = iNdEx 3001 for shift := uint(0); ; shift += 7 { 3002 if shift >= 64 { 3003 return 0, ErrIntOverflowQuads 3004 } 3005 if iNdEx >= l { 3006 return 0, io.ErrUnexpectedEOF 3007 } 3008 b := data[iNdEx] 3009 iNdEx++ 3010 innerWire |= (uint64(b) & 0x7F) << shift 3011 if b < 0x80 { 3012 break 3013 } 3014 } 3015 innerWireType := int(innerWire & 0x7) 3016 if innerWireType == 4 { 3017 break 3018 } 3019 next, err := skipQuads(data[start:]) 3020 if err != nil { 3021 return 0, err 3022 } 3023 iNdEx = start + next 3024 } 3025 return iNdEx, nil 3026 case 4: 3027 return iNdEx, nil 3028 case 5: 3029 iNdEx += 4 3030 return iNdEx, nil 3031 default: 3032 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 3033 } 3034 } 3035 panic("unreachable") 3036} 3037 3038var ( 3039 ErrInvalidLengthQuads = fmt.Errorf("proto: negative length found during unmarshaling") 3040 ErrIntOverflowQuads = fmt.Errorf("proto: integer overflow") 3041) 3042 3043func init() { proto.RegisterFile("quads.proto", fileDescriptorQuads) } 3044 3045var fileDescriptorQuads = []byte{ 3046 // 620 bytes of a gzipped FileDescriptorProto 3047 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x54, 0xcd, 0x6e, 0xd3, 0x40, 3048 0x10, 0xc6, 0xb1, 0x9d, 0xd8, 0xe3, 0x14, 0xd0, 0x0a, 0x15, 0x63, 0x41, 0x05, 0x41, 0x08, 0x24, 3049 0xa8, 0x5b, 0x15, 0x28, 0x48, 0xbd, 0xf5, 0x54, 0x41, 0x2f, 0x18, 0x04, 0xc7, 0x6a, 0x1d, 0x6f, 3050 0x82, 0x91, 0xb3, 0x1b, 0xec, 0x35, 0x88, 0x17, 0xe1, 0xcc, 0x03, 0xf0, 0x04, 0x3c, 0x01, 0x47, 3051 0x9e, 0x01, 0xde, 0x82, 0x13, 0xbb, 0xb3, 0x8e, 0xf3, 0x7f, 0xe0, 0x10, 0x69, 0xbf, 0x99, 0xf9, 3052 0x66, 0xbf, 0x99, 0x7c, 0x5e, 0x08, 0x3e, 0xd6, 0x34, 0xab, 0xe2, 0x69, 0x29, 0xa4, 0x20, 0xdd, 3053 0x29, 0xa2, 0x68, 0x7f, 0x9c, 0xcb, 0xf7, 0x75, 0x1a, 0x0f, 0xc5, 0xe4, 0x60, 0x2c, 0xc6, 0xe2, 3054 0x00, 0xd3, 0x69, 0x3d, 0x42, 0x84, 0x00, 0x4f, 0x86, 0x36, 0xf8, 0xd1, 0x01, 0xe7, 0x95, 0x22, 3055 0x92, 0x10, 0x7a, 0x55, 0x9d, 0x7e, 0x60, 0x43, 0x19, 0x5a, 0xb7, 0xad, 0x07, 0x7e, 0x32, 0x83, 3056 0xe4, 0x26, 0xf8, 0xd3, 0x92, 0x65, 0xf9, 0x90, 0x4a, 0x16, 0x76, 0x30, 0x37, 0x0f, 0x90, 0x5d, 3057 0xe8, 0x0a, 0x43, 0xb3, 0x31, 0xd5, 0x20, 0x72, 0x0d, 0xdc, 0x82, 0xa6, 0xac, 0x08, 0x1d, 0x0c, 3058 0x1b, 0x40, 0x8e, 0x60, 0xa7, 0x69, 0x7b, 0xf1, 0x89, 0x16, 0x35, 0x0b, 0x5d, 0x95, 0x0d, 0x8e, 3059 0x76, 0x62, 0xa3, 0x3e, 0x7e, 0xab, 0x83, 0x49, 0xbf, 0xa9, 0x41, 0x44, 0x8e, 0xe1, 0x4a, 0x7b, 3060 0x5d, 0xc3, 0xea, 0x6e, 0x62, 0x5d, 0x6e, 0xab, 0x0c, 0xef, 0x10, 0xfa, 0x62, 0xf1, 0xaa, 0xde, 3061 0x26, 0x52, 0x20, 0x16, 0x6e, 0x8a, 0x21, 0x40, 0x99, 0x0d, 0xc1, 0xdb, 0x44, 0x00, 0xac, 0xc0, 3062 0xf3, 0xe0, 0xbb, 0x05, 0xde, 0xbb, 0xbc, 0x64, 0xb8, 0xc0, 0xfb, 0xcb, 0x0b, 0x5c, 0x23, 0xb6, 3063 0xfb, 0x7c, 0xb8, 0xba, 0xcf, 0xb5, 0xd2, 0x85, 0xf5, 0xde, 0x5b, 0x5a, 0xef, 0x5a, 0xe5, 0x6c, 3064 0xdb, 0x77, 0x17, 0xb7, 0xbd, 0x56, 0x65, 0x72, 0x83, 0xaf, 0x1d, 0x80, 0xd7, 0xb2, 0xcc, 0x87, 3065 0x12, 0x05, 0x1f, 0xae, 0x0a, 0xde, 0x9d, 0xb1, 0xe6, 0x45, 0x71, 0xc2, 0x46, 0x73, 0xe5, 0x4f, 3066 0xd6, 0x95, 0x6f, 0xe3, 0xfc, 0xff, 0x08, 0x8f, 0x96, 0x47, 0xd8, 0xd6, 0xd8, 0x14, 0x45, 0x2f, 3067 0xc1, 0x56, 0x88, 0xdc, 0x81, 0x20, 0xe5, 0x22, 0x63, 0x17, 0x86, 0x8a, 0xee, 0x3c, 0xbb, 0x94, 3068 0x00, 0x06, 0xcf, 0xd1, 0x72, 0x04, 0xec, 0xbc, 0xcc, 0x8d, 0x3b, 0x55, 0x4a, 0x83, 0xd3, 0x1e, 3069 0xb8, 0xf8, 0x17, 0xbf, 0x70, 0x3c, 0xeb, 0x6a, 0x67, 0xf0, 0xd7, 0x06, 0xd7, 0x38, 0x40, 0x15, 3070 0x97, 0xf4, 0x33, 0xee, 0xa3, 0xaf, 0x8b, 0x15, 0xd0, 0xb1, 0x4a, 0x96, 0x6d, 0x6f, 0x0d, 0x36, 3071 0x35, 0x55, 0x5f, 0x82, 0x8b, 0xd7, 0x1a, 0xc7, 0xab, 0xa8, 0x81, 0xe4, 0x39, 0xf8, 0xf2, 0xcb, 3072 0x94, 0x65, 0x17, 0xba, 0x8b, 0xf1, 0xfb, 0x8d, 0xa5, 0x15, 0xc4, 0x6f, 0x74, 0x5a, 0xcf, 0xc9, 3073 0xc7, 0x8a, 0xe6, 0xc9, 0x06, 0x92, 0xa7, 0xe0, 0x15, 0x94, 0x8f, 0x91, 0x68, 0x2c, 0x1f, 0x2e, 3074 0x13, 0xcf, 0x55, 0xb6, 0xe5, 0xf5, 0x0a, 0x83, 0x50, 0x1c, 0x97, 0xe8, 0x77, 0x1b, 0xc5, 0x71, 3075 0xa9, 0xc5, 0x8d, 0x0a, 0x41, 0x25, 0x9a, 0xda, 0xd2, 0xe2, 0x10, 0x92, 0x08, 0x7a, 0xa9, 0x10, 3076 0x05, 0xa3, 0x3c, 0xf4, 0x55, 0xc6, 0xd3, 0x7d, 0x9a, 0x00, 0xd9, 0x07, 0x47, 0xe6, 0x13, 0x16, 3077 0x02, 0x5e, 0x7d, 0x7d, 0x45, 0xb3, 0xca, 0x54, 0x92, 0x4e, 0xa6, 0x8a, 0x81, 0x65, 0xd1, 0x33, 3078 0x08, 0x16, 0x06, 0xd1, 0x0f, 0x80, 0xf9, 0x8c, 0xcc, 0x73, 0x62, 0x80, 0xd2, 0xe6, 0xe8, 0xf1, 3079 0x9a, 0x77, 0x04, 0xcf, 0xd1, 0x31, 0xc0, 0x7c, 0x90, 0xed, 0x3c, 0x3d, 0xde, 0x8c, 0xa7, 0xcf, 3080 0xd1, 0x09, 0xf8, 0xad, 0x0a, 0x7c, 0xbf, 0xd8, 0x50, 0xf0, 0xac, 0x42, 0xa2, 0x9d, 0xcc, 0xa0, 3081 0x6e, 0xc8, 0x29, 0x17, 0x15, 0x72, 0xdd, 0xc4, 0x80, 0xd6, 0x02, 0x83, 0x13, 0xe8, 0x9e, 0x31, 3082 0x9a, 0x31, 0xbd, 0x37, 0x67, 0x54, 0x17, 0x05, 0xf2, 0xbd, 0x04, 0xcf, 0xe4, 0x16, 0x00, 0x17, 3083 0x52, 0xff, 0x03, 0xca, 0x84, 0xd8, 0xc1, 0x4b, 0x7c, 0x15, 0x31, 0xae, 0x3c, 0xed, 0xff, 0xfc, 3084 0xbd, 0x67, 0xfd, 0x52, 0xbf, 0x6f, 0x7f, 0xf6, 0xac, 0xb4, 0x8b, 0x6f, 0xea, 0xe3, 0x7f, 0x01, 3085 0x00, 0x00, 0xff, 0xff, 0xd8, 0x36, 0x01, 0x85, 0x99, 0x05, 0x00, 0x00, 3086} 3087