1// 2package streams 3 4import ( 5 "github.com/writeas/activity/vocab" 6 "net/url" 7 "time" 8) 9 10// Indicates that the actor accepts the object. The target property can be used in certain circumstances to indicate the context into which the object has been accepted. This is a convenience wrapper of a type with the same name in the vocab package. Accessing it with the Raw function allows direct manipulaton of the object, and does not provide the same integrity guarantees as this package. 11type Accept struct { 12 // The raw type from the vocab package 13 raw *vocab.Accept 14} 15 16func NewAccept() *Accept { 17 return &Accept{raw: &vocab.Accept{}} 18} 19 20// Raw returns the vocab type for manaual manipulation. Note that manipulating the underlying type to be in an inconsistent state may cause this convenience type's methods to later fail. 21func (t *Accept) Raw() (n *vocab.Accept) { 22 return t.raw 23 24} 25 26// Serialize turns this object into a map[string]interface{}. 27func (t *Accept) Serialize() (m map[string]interface{}, err error) { 28 return t.raw.Serialize() 29 30} 31 32// LenActor returns the number of values this property contains. Each index be used with HasActor to determine if GetActor is safe to call or if raw handling would be needed. 33func (t *Accept) LenActor() (idx int) { 34 return t.raw.ActorLen() 35 36} 37 38// GetActor attempts to get this 'actor' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 39func (t *Accept) GetActor(idx int) (r Resolution, k *url.URL) { 40 r = Unresolved 41 handled := false 42 if t.raw.IsActorIRI(idx) { 43 k = t.raw.GetActorIRI(idx) 44 if handled { 45 r = Resolved 46 } 47 } else if t.raw.IsActorObject(idx) { 48 r = RawResolutionNeeded 49 } else if t.raw.IsActorLink(idx) { 50 r = RawResolutionNeeded 51 } 52 return 53 54} 55 56// AppendActor appends the value for property 'actor'. 57func (t *Accept) AppendActor(k *url.URL) { 58 t.raw.AppendActorIRI(k) 59 60} 61 62// PrependActor prepends the value for property 'actor'. 63func (t *Accept) PrependActor(k *url.URL) { 64 t.raw.PrependActorIRI(k) 65 66} 67 68// RemoveActor deletes the value from the specified index for property 'actor'. 69func (t *Accept) RemoveActor(idx int) { 70 t.raw.RemoveActorIRI(idx) 71 72} 73 74// HasActor returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 75func (t *Accept) HasActor(idx int) (p Presence) { 76 p = NoPresence 77 if t.raw.IsActorIRI(idx) { 78 p = ConvenientPresence 79 } else if t.raw.IsActorLink(idx) { 80 p = RawPresence 81 } else if t.raw.IsActorIRI(idx) { 82 p = RawPresence 83 } 84 return 85 86} 87 88// LenObject returns the number of values this property contains. Each index be used with HasObject to determine if ResolveObject is safe to call or if raw handling would be needed. 89func (t *Accept) LenObject() (idx int) { 90 return t.raw.ObjectLen() 91 92} 93 94// ResolveObject passes the actual concrete type to the resolver for handing property object. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 95func (t *Accept) ResolveObject(r *Resolver, idx int) (s Resolution, err error) { 96 s = Unresolved 97 handled := false 98 if t.raw.IsObject(idx) { 99 handled, err = r.dispatch(t.raw.GetObject(idx)) 100 if handled { 101 s = Resolved 102 } 103 } else if t.raw.IsObjectIRI(idx) { 104 s = RawResolutionNeeded 105 } 106 return 107 108} 109 110// AppendObject appends the value for property 'object'. 111func (t *Accept) AppendObject(i vocab.ObjectType) { 112 t.raw.AppendObject(i) 113 114} 115 116// PrependObject prepends the value for property 'object'. 117func (t *Accept) PrependObject(i vocab.ObjectType) { 118 t.raw.PrependObject(i) 119 120} 121 122// RemoveObject deletes the value from the specified index for property 'object'. 123func (t *Accept) RemoveObject(idx int) { 124 t.raw.RemoveObject(idx) 125 126} 127 128// HasObject returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 129func (t *Accept) HasObject(idx int) (p Presence) { 130 p = NoPresence 131 if t.raw.IsObject(idx) { 132 p = ConvenientPresence 133 } else if t.raw.IsObjectIRI(idx) { 134 p = RawPresence 135 } 136 return 137 138} 139 140// LenTarget returns the number of values this property contains. Each index be used with HasTarget to determine if GetTarget is safe to call or if raw handling would be needed. 141func (t *Accept) LenTarget() (idx int) { 142 return t.raw.TargetLen() 143 144} 145 146// GetTarget attempts to get this 'target' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 147func (t *Accept) GetTarget(idx int) (r Resolution, k *url.URL) { 148 r = Unresolved 149 handled := false 150 if t.raw.IsTargetIRI(idx) { 151 k = t.raw.GetTargetIRI(idx) 152 if handled { 153 r = Resolved 154 } 155 } else if t.raw.IsTargetObject(idx) { 156 r = RawResolutionNeeded 157 } else if t.raw.IsTargetLink(idx) { 158 r = RawResolutionNeeded 159 } 160 return 161 162} 163 164// AppendTarget appends the value for property 'target'. 165func (t *Accept) AppendTarget(k *url.URL) { 166 t.raw.AppendTargetIRI(k) 167 168} 169 170// PrependTarget prepends the value for property 'target'. 171func (t *Accept) PrependTarget(k *url.URL) { 172 t.raw.PrependTargetIRI(k) 173 174} 175 176// RemoveTarget deletes the value from the specified index for property 'target'. 177func (t *Accept) RemoveTarget(idx int) { 178 t.raw.RemoveTargetIRI(idx) 179 180} 181 182// HasTarget returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 183func (t *Accept) HasTarget(idx int) (p Presence) { 184 p = NoPresence 185 if t.raw.IsTargetIRI(idx) { 186 p = ConvenientPresence 187 } else if t.raw.IsTargetLink(idx) { 188 p = RawPresence 189 } else if t.raw.IsTargetIRI(idx) { 190 p = RawPresence 191 } 192 return 193 194} 195 196// LenResult returns the number of values this property contains. Each index be used with HasResult to determine if ResolveResult is safe to call or if raw handling would be needed. 197func (t *Accept) LenResult() (idx int) { 198 return t.raw.ResultLen() 199 200} 201 202// ResolveResult passes the actual concrete type to the resolver for handing property result. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 203func (t *Accept) ResolveResult(r *Resolver, idx int) (s Resolution, err error) { 204 s = Unresolved 205 handled := false 206 if t.raw.IsResultObject(idx) { 207 handled, err = r.dispatch(t.raw.GetResultObject(idx)) 208 if handled { 209 s = Resolved 210 } 211 } else if t.raw.IsResultLink(idx) { 212 handled, err = r.dispatch(t.raw.GetResultLink(idx)) 213 if handled { 214 s = Resolved 215 } 216 } else if t.raw.IsResultIRI(idx) { 217 s = RawResolutionNeeded 218 } 219 return 220 221} 222 223// HasResult returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 224func (t *Accept) HasResult(idx int) (p Presence) { 225 p = NoPresence 226 if t.raw.IsResultObject(idx) { 227 p = ConvenientPresence 228 } else if t.raw.IsResultLink(idx) { 229 p = ConvenientPresence 230 } else if t.raw.IsResultIRI(idx) { 231 p = RawPresence 232 } 233 return 234 235} 236 237// AppendResult appends an 'Object' typed value. 238func (t *Accept) AppendResult(i vocab.ObjectType) { 239 t.raw.AppendResultObject(i) 240 241} 242 243// PrependResult prepends an 'Object' typed value. 244func (t *Accept) PrependResult(i vocab.ObjectType) { 245 t.raw.PrependResultObject(i) 246 247} 248 249// AppendResultLink appends a 'Link' typed value. 250func (t *Accept) AppendResultLink(i vocab.LinkType) { 251 t.raw.AppendResultLink(i) 252 253} 254 255// PrependResultLink prepends a 'Link' typed value. 256func (t *Accept) PrependResultLink(i vocab.LinkType) { 257 t.raw.PrependResultLink(i) 258 259} 260 261// LenOrigin returns the number of values this property contains. Each index be used with HasOrigin to determine if ResolveOrigin is safe to call or if raw handling would be needed. 262func (t *Accept) LenOrigin() (idx int) { 263 return t.raw.OriginLen() 264 265} 266 267// ResolveOrigin passes the actual concrete type to the resolver for handing property origin. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 268func (t *Accept) ResolveOrigin(r *Resolver, idx int) (s Resolution, err error) { 269 s = Unresolved 270 handled := false 271 if t.raw.IsOriginObject(idx) { 272 handled, err = r.dispatch(t.raw.GetOriginObject(idx)) 273 if handled { 274 s = Resolved 275 } 276 } else if t.raw.IsOriginLink(idx) { 277 handled, err = r.dispatch(t.raw.GetOriginLink(idx)) 278 if handled { 279 s = Resolved 280 } 281 } else if t.raw.IsOriginIRI(idx) { 282 s = RawResolutionNeeded 283 } 284 return 285 286} 287 288// HasOrigin returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 289func (t *Accept) HasOrigin(idx int) (p Presence) { 290 p = NoPresence 291 if t.raw.IsOriginObject(idx) { 292 p = ConvenientPresence 293 } else if t.raw.IsOriginLink(idx) { 294 p = ConvenientPresence 295 } else if t.raw.IsOriginIRI(idx) { 296 p = RawPresence 297 } 298 return 299 300} 301 302// AppendOrigin appends an 'Object' typed value. 303func (t *Accept) AppendOrigin(i vocab.ObjectType) { 304 t.raw.AppendOriginObject(i) 305 306} 307 308// PrependOrigin prepends an 'Object' typed value. 309func (t *Accept) PrependOrigin(i vocab.ObjectType) { 310 t.raw.PrependOriginObject(i) 311 312} 313 314// AppendOriginLink appends a 'Link' typed value. 315func (t *Accept) AppendOriginLink(i vocab.LinkType) { 316 t.raw.AppendOriginLink(i) 317 318} 319 320// PrependOriginLink prepends a 'Link' typed value. 321func (t *Accept) PrependOriginLink(i vocab.LinkType) { 322 t.raw.PrependOriginLink(i) 323 324} 325 326// LenInstrument returns the number of values this property contains. Each index be used with HasInstrument to determine if ResolveInstrument is safe to call or if raw handling would be needed. 327func (t *Accept) LenInstrument() (idx int) { 328 return t.raw.InstrumentLen() 329 330} 331 332// ResolveInstrument passes the actual concrete type to the resolver for handing property instrument. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 333func (t *Accept) ResolveInstrument(r *Resolver, idx int) (s Resolution, err error) { 334 s = Unresolved 335 handled := false 336 if t.raw.IsInstrumentObject(idx) { 337 handled, err = r.dispatch(t.raw.GetInstrumentObject(idx)) 338 if handled { 339 s = Resolved 340 } 341 } else if t.raw.IsInstrumentLink(idx) { 342 handled, err = r.dispatch(t.raw.GetInstrumentLink(idx)) 343 if handled { 344 s = Resolved 345 } 346 } else if t.raw.IsInstrumentIRI(idx) { 347 s = RawResolutionNeeded 348 } 349 return 350 351} 352 353// HasInstrument returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 354func (t *Accept) HasInstrument(idx int) (p Presence) { 355 p = NoPresence 356 if t.raw.IsInstrumentObject(idx) { 357 p = ConvenientPresence 358 } else if t.raw.IsInstrumentLink(idx) { 359 p = ConvenientPresence 360 } else if t.raw.IsInstrumentIRI(idx) { 361 p = RawPresence 362 } 363 return 364 365} 366 367// AppendInstrument appends an 'Object' typed value. 368func (t *Accept) AppendInstrument(i vocab.ObjectType) { 369 t.raw.AppendInstrumentObject(i) 370 371} 372 373// PrependInstrument prepends an 'Object' typed value. 374func (t *Accept) PrependInstrument(i vocab.ObjectType) { 375 t.raw.PrependInstrumentObject(i) 376 377} 378 379// AppendInstrumentLink appends a 'Link' typed value. 380func (t *Accept) AppendInstrumentLink(i vocab.LinkType) { 381 t.raw.AppendInstrumentLink(i) 382 383} 384 385// PrependInstrumentLink prepends a 'Link' typed value. 386func (t *Accept) PrependInstrumentLink(i vocab.LinkType) { 387 t.raw.PrependInstrumentLink(i) 388 389} 390 391// GetAltitude attempts to get this 'altitude' property as a float64. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 392func (t *Accept) GetAltitude() (r Resolution, k float64) { 393 r = Unresolved 394 handled := false 395 if t.raw.IsAltitude() { 396 k = t.raw.GetAltitude() 397 if handled { 398 r = Resolved 399 } 400 } else if t.raw.IsAltitudeIRI() { 401 r = RawResolutionNeeded 402 } 403 return 404 405} 406 407// HasAltitude returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 408func (t *Accept) HasAltitude() (p Presence) { 409 p = NoPresence 410 if t.raw.IsAltitude() { 411 p = ConvenientPresence 412 } else if t.raw.IsAltitudeIRI() { 413 p = RawPresence 414 } 415 return 416 417} 418 419// SetAltitude sets the value for property 'altitude'. 420func (t *Accept) SetAltitude(k float64) { 421 t.raw.SetAltitude(k) 422 423} 424 425// LenAttachment returns the number of values this property contains. Each index be used with HasAttachment to determine if ResolveAttachment is safe to call or if raw handling would be needed. 426func (t *Accept) LenAttachment() (idx int) { 427 return t.raw.AttachmentLen() 428 429} 430 431// ResolveAttachment passes the actual concrete type to the resolver for handing property attachment. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 432func (t *Accept) ResolveAttachment(r *Resolver, idx int) (s Resolution, err error) { 433 s = Unresolved 434 handled := false 435 if t.raw.IsAttachmentObject(idx) { 436 handled, err = r.dispatch(t.raw.GetAttachmentObject(idx)) 437 if handled { 438 s = Resolved 439 } 440 } else if t.raw.IsAttachmentLink(idx) { 441 handled, err = r.dispatch(t.raw.GetAttachmentLink(idx)) 442 if handled { 443 s = Resolved 444 } 445 } else if t.raw.IsAttachmentIRI(idx) { 446 s = RawResolutionNeeded 447 } 448 return 449 450} 451 452// HasAttachment returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 453func (t *Accept) HasAttachment(idx int) (p Presence) { 454 p = NoPresence 455 if t.raw.IsAttachmentObject(idx) { 456 p = ConvenientPresence 457 } else if t.raw.IsAttachmentLink(idx) { 458 p = ConvenientPresence 459 } else if t.raw.IsAttachmentIRI(idx) { 460 p = RawPresence 461 } 462 return 463 464} 465 466// AppendAttachment appends an 'Object' typed value. 467func (t *Accept) AppendAttachment(i vocab.ObjectType) { 468 t.raw.AppendAttachmentObject(i) 469 470} 471 472// PrependAttachment prepends an 'Object' typed value. 473func (t *Accept) PrependAttachment(i vocab.ObjectType) { 474 t.raw.PrependAttachmentObject(i) 475 476} 477 478// AppendAttachmentLink appends a 'Link' typed value. 479func (t *Accept) AppendAttachmentLink(i vocab.LinkType) { 480 t.raw.AppendAttachmentLink(i) 481 482} 483 484// PrependAttachmentLink prepends a 'Link' typed value. 485func (t *Accept) PrependAttachmentLink(i vocab.LinkType) { 486 t.raw.PrependAttachmentLink(i) 487 488} 489 490// LenAttributedTo returns the number of values this property contains. Each index be used with HasAttributedTo to determine if GetAttributedTo is safe to call or if raw handling would be needed. 491func (t *Accept) LenAttributedTo() (idx int) { 492 return t.raw.AttributedToLen() 493 494} 495 496// GetAttributedTo attempts to get this 'attributedTo' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 497func (t *Accept) GetAttributedTo(idx int) (r Resolution, k *url.URL) { 498 r = Unresolved 499 handled := false 500 if t.raw.IsAttributedToIRI(idx) { 501 k = t.raw.GetAttributedToIRI(idx) 502 if handled { 503 r = Resolved 504 } 505 } else if t.raw.IsAttributedToObject(idx) { 506 r = RawResolutionNeeded 507 } else if t.raw.IsAttributedToLink(idx) { 508 r = RawResolutionNeeded 509 } 510 return 511 512} 513 514// AppendAttributedTo appends the value for property 'attributedTo'. 515func (t *Accept) AppendAttributedTo(k *url.URL) { 516 t.raw.AppendAttributedToIRI(k) 517 518} 519 520// PrependAttributedTo prepends the value for property 'attributedTo'. 521func (t *Accept) PrependAttributedTo(k *url.URL) { 522 t.raw.PrependAttributedToIRI(k) 523 524} 525 526// RemoveAttributedTo deletes the value from the specified index for property 'attributedTo'. 527func (t *Accept) RemoveAttributedTo(idx int) { 528 t.raw.RemoveAttributedToIRI(idx) 529 530} 531 532// HasAttributedTo returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 533func (t *Accept) HasAttributedTo(idx int) (p Presence) { 534 p = NoPresence 535 if t.raw.IsAttributedToIRI(idx) { 536 p = ConvenientPresence 537 } else if t.raw.IsAttributedToLink(idx) { 538 p = RawPresence 539 } else if t.raw.IsAttributedToIRI(idx) { 540 p = RawPresence 541 } 542 return 543 544} 545 546// LenAudience returns the number of values this property contains. Each index be used with HasAudience to determine if GetAudience is safe to call or if raw handling would be needed. 547func (t *Accept) LenAudience() (idx int) { 548 return t.raw.AudienceLen() 549 550} 551 552// GetAudience attempts to get this 'audience' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 553func (t *Accept) GetAudience(idx int) (r Resolution, k *url.URL) { 554 r = Unresolved 555 handled := false 556 if t.raw.IsAudienceIRI(idx) { 557 k = t.raw.GetAudienceIRI(idx) 558 if handled { 559 r = Resolved 560 } 561 } else if t.raw.IsAudienceObject(idx) { 562 r = RawResolutionNeeded 563 } else if t.raw.IsAudienceLink(idx) { 564 r = RawResolutionNeeded 565 } 566 return 567 568} 569 570// AppendAudience appends the value for property 'audience'. 571func (t *Accept) AppendAudience(k *url.URL) { 572 t.raw.AppendAudienceIRI(k) 573 574} 575 576// PrependAudience prepends the value for property 'audience'. 577func (t *Accept) PrependAudience(k *url.URL) { 578 t.raw.PrependAudienceIRI(k) 579 580} 581 582// RemoveAudience deletes the value from the specified index for property 'audience'. 583func (t *Accept) RemoveAudience(idx int) { 584 t.raw.RemoveAudienceIRI(idx) 585 586} 587 588// HasAudience returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 589func (t *Accept) HasAudience(idx int) (p Presence) { 590 p = NoPresence 591 if t.raw.IsAudienceIRI(idx) { 592 p = ConvenientPresence 593 } else if t.raw.IsAudienceLink(idx) { 594 p = RawPresence 595 } else if t.raw.IsAudienceIRI(idx) { 596 p = RawPresence 597 } 598 return 599 600} 601 602// LenContent returns the number of values this property contains. Each index be used with HasContent to determine if GetContent is safe to call or if raw handling would be needed. 603func (t *Accept) LenContent() (idx int) { 604 return t.raw.ContentLen() 605 606} 607 608// GetContent attempts to get this 'content' property as a string. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 609func (t *Accept) GetContent(idx int) (r Resolution, k string) { 610 r = Unresolved 611 handled := false 612 if t.raw.IsContentString(idx) { 613 k = t.raw.GetContentString(idx) 614 if handled { 615 r = Resolved 616 } 617 } else if t.raw.IsContentLangString(idx) { 618 r = RawResolutionNeeded 619 } else if t.raw.IsContentIRI(idx) { 620 r = RawResolutionNeeded 621 } 622 return 623 624} 625 626// AppendContent appends the value for property 'content'. 627func (t *Accept) AppendContent(k string) { 628 t.raw.AppendContentString(k) 629 630} 631 632// PrependContent prepends the value for property 'content'. 633func (t *Accept) PrependContent(k string) { 634 t.raw.PrependContentString(k) 635 636} 637 638// RemoveContent deletes the value from the specified index for property 'content'. 639func (t *Accept) RemoveContent(idx int) { 640 t.raw.RemoveContentString(idx) 641 642} 643 644// HasContent returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 645func (t *Accept) HasContent(idx int) (p Presence) { 646 p = NoPresence 647 if t.raw.IsContentString(idx) { 648 p = ConvenientPresence 649 } else if t.raw.IsContentLangString(idx) { 650 p = RawPresence 651 } else if t.raw.IsContentIRI(idx) { 652 p = RawPresence 653 } 654 return 655 656} 657 658// ContentLanguages returns all languages for this property's language mapping, or nil if there are none. 659func (t *Accept) ContentLanguages() (l []string) { 660 return t.raw.ContentMapLanguages() 661 662} 663 664// GetContentMap retrieves the value of 'content' for the specified language, or an empty string if it does not exist 665func (t *Accept) GetContentForLanguage(l string) (v string) { 666 return t.raw.GetContentMap(l) 667 668} 669 670// SetContentForLanguage sets the value of 'content' for the specified language 671func (t *Accept) SetContentForLanguage(l string, v string) { 672 t.raw.SetContentMap(l, v) 673 674} 675 676// LenContext returns the number of values this property contains. Each index be used with HasContext to determine if ResolveContext is safe to call or if raw handling would be needed. 677func (t *Accept) LenContext() (idx int) { 678 return t.raw.ContextLen() 679 680} 681 682// ResolveContext passes the actual concrete type to the resolver for handing property context. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 683func (t *Accept) ResolveContext(r *Resolver, idx int) (s Resolution, err error) { 684 s = Unresolved 685 handled := false 686 if t.raw.IsContextObject(idx) { 687 handled, err = r.dispatch(t.raw.GetContextObject(idx)) 688 if handled { 689 s = Resolved 690 } 691 } else if t.raw.IsContextLink(idx) { 692 handled, err = r.dispatch(t.raw.GetContextLink(idx)) 693 if handled { 694 s = Resolved 695 } 696 } else if t.raw.IsContextIRI(idx) { 697 s = RawResolutionNeeded 698 } 699 return 700 701} 702 703// HasContext returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 704func (t *Accept) HasContext(idx int) (p Presence) { 705 p = NoPresence 706 if t.raw.IsContextObject(idx) { 707 p = ConvenientPresence 708 } else if t.raw.IsContextLink(idx) { 709 p = ConvenientPresence 710 } else if t.raw.IsContextIRI(idx) { 711 p = RawPresence 712 } 713 return 714 715} 716 717// AppendContext appends an 'Object' typed value. 718func (t *Accept) AppendContext(i vocab.ObjectType) { 719 t.raw.AppendContextObject(i) 720 721} 722 723// PrependContext prepends an 'Object' typed value. 724func (t *Accept) PrependContext(i vocab.ObjectType) { 725 t.raw.PrependContextObject(i) 726 727} 728 729// AppendContextLink appends a 'Link' typed value. 730func (t *Accept) AppendContextLink(i vocab.LinkType) { 731 t.raw.AppendContextLink(i) 732 733} 734 735// PrependContextLink prepends a 'Link' typed value. 736func (t *Accept) PrependContextLink(i vocab.LinkType) { 737 t.raw.PrependContextLink(i) 738 739} 740 741// LenName returns the number of values this property contains. Each index be used with HasName to determine if GetName is safe to call or if raw handling would be needed. 742func (t *Accept) LenName() (idx int) { 743 return t.raw.NameLen() 744 745} 746 747// GetName attempts to get this 'name' property as a string. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 748func (t *Accept) GetName(idx int) (r Resolution, k string) { 749 r = Unresolved 750 handled := false 751 if t.raw.IsNameString(idx) { 752 k = t.raw.GetNameString(idx) 753 if handled { 754 r = Resolved 755 } 756 } else if t.raw.IsNameLangString(idx) { 757 r = RawResolutionNeeded 758 } else if t.raw.IsNameIRI(idx) { 759 r = RawResolutionNeeded 760 } 761 return 762 763} 764 765// AppendName appends the value for property 'name'. 766func (t *Accept) AppendName(k string) { 767 t.raw.AppendNameString(k) 768 769} 770 771// PrependName prepends the value for property 'name'. 772func (t *Accept) PrependName(k string) { 773 t.raw.PrependNameString(k) 774 775} 776 777// RemoveName deletes the value from the specified index for property 'name'. 778func (t *Accept) RemoveName(idx int) { 779 t.raw.RemoveNameString(idx) 780 781} 782 783// HasName returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 784func (t *Accept) HasName(idx int) (p Presence) { 785 p = NoPresence 786 if t.raw.IsNameString(idx) { 787 p = ConvenientPresence 788 } else if t.raw.IsNameLangString(idx) { 789 p = RawPresence 790 } else if t.raw.IsNameIRI(idx) { 791 p = RawPresence 792 } 793 return 794 795} 796 797// NameLanguages returns all languages for this property's language mapping, or nil if there are none. 798func (t *Accept) NameLanguages() (l []string) { 799 return t.raw.NameMapLanguages() 800 801} 802 803// GetNameMap retrieves the value of 'name' for the specified language, or an empty string if it does not exist 804func (t *Accept) GetNameForLanguage(l string) (v string) { 805 return t.raw.GetNameMap(l) 806 807} 808 809// SetNameForLanguage sets the value of 'name' for the specified language 810func (t *Accept) SetNameForLanguage(l string, v string) { 811 t.raw.SetNameMap(l, v) 812 813} 814 815// GetEndTime attempts to get this 'endTime' property as a time.Time. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 816func (t *Accept) GetEndTime() (r Resolution, k time.Time) { 817 r = Unresolved 818 handled := false 819 if t.raw.IsEndTime() { 820 k = t.raw.GetEndTime() 821 if handled { 822 r = Resolved 823 } 824 } else if t.raw.IsEndTimeIRI() { 825 r = RawResolutionNeeded 826 } 827 return 828 829} 830 831// HasEndTime returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 832func (t *Accept) HasEndTime() (p Presence) { 833 p = NoPresence 834 if t.raw.IsEndTime() { 835 p = ConvenientPresence 836 } else if t.raw.IsEndTimeIRI() { 837 p = RawPresence 838 } 839 return 840 841} 842 843// SetEndTime sets the value for property 'endTime'. 844func (t *Accept) SetEndTime(k time.Time) { 845 t.raw.SetEndTime(k) 846 847} 848 849// LenGenerator returns the number of values this property contains. Each index be used with HasGenerator to determine if ResolveGenerator is safe to call or if raw handling would be needed. 850func (t *Accept) LenGenerator() (idx int) { 851 return t.raw.GeneratorLen() 852 853} 854 855// ResolveGenerator passes the actual concrete type to the resolver for handing property generator. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 856func (t *Accept) ResolveGenerator(r *Resolver, idx int) (s Resolution, err error) { 857 s = Unresolved 858 handled := false 859 if t.raw.IsGeneratorObject(idx) { 860 handled, err = r.dispatch(t.raw.GetGeneratorObject(idx)) 861 if handled { 862 s = Resolved 863 } 864 } else if t.raw.IsGeneratorLink(idx) { 865 handled, err = r.dispatch(t.raw.GetGeneratorLink(idx)) 866 if handled { 867 s = Resolved 868 } 869 } else if t.raw.IsGeneratorIRI(idx) { 870 s = RawResolutionNeeded 871 } 872 return 873 874} 875 876// HasGenerator returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 877func (t *Accept) HasGenerator(idx int) (p Presence) { 878 p = NoPresence 879 if t.raw.IsGeneratorObject(idx) { 880 p = ConvenientPresence 881 } else if t.raw.IsGeneratorLink(idx) { 882 p = ConvenientPresence 883 } else if t.raw.IsGeneratorIRI(idx) { 884 p = RawPresence 885 } 886 return 887 888} 889 890// AppendGenerator appends an 'Object' typed value. 891func (t *Accept) AppendGenerator(i vocab.ObjectType) { 892 t.raw.AppendGeneratorObject(i) 893 894} 895 896// PrependGenerator prepends an 'Object' typed value. 897func (t *Accept) PrependGenerator(i vocab.ObjectType) { 898 t.raw.PrependGeneratorObject(i) 899 900} 901 902// AppendGeneratorLink appends a 'Link' typed value. 903func (t *Accept) AppendGeneratorLink(i vocab.LinkType) { 904 t.raw.AppendGeneratorLink(i) 905 906} 907 908// PrependGeneratorLink prepends a 'Link' typed value. 909func (t *Accept) PrependGeneratorLink(i vocab.LinkType) { 910 t.raw.PrependGeneratorLink(i) 911 912} 913 914// LenIcon returns the number of values this property contains. Each index be used with HasIcon to determine if ResolveIcon is safe to call or if raw handling would be needed. 915func (t *Accept) LenIcon() (idx int) { 916 return t.raw.IconLen() 917 918} 919 920// ResolveIcon passes the actual concrete type to the resolver for handing property icon. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 921func (t *Accept) ResolveIcon(r *Resolver, idx int) (s Resolution, err error) { 922 s = Unresolved 923 handled := false 924 if t.raw.IsIconImage(idx) { 925 handled, err = r.dispatch(t.raw.GetIconImage(idx)) 926 if handled { 927 s = Resolved 928 } 929 } else if t.raw.IsIconLink(idx) { 930 s = RawResolutionNeeded 931 } else if t.raw.IsIconIRI(idx) { 932 s = RawResolutionNeeded 933 } 934 return 935 936} 937 938// AppendIcon appends the value for property 'icon'. 939func (t *Accept) AppendIcon(i vocab.ImageType) { 940 t.raw.AppendIconImage(i) 941 942} 943 944// PrependIcon prepends the value for property 'icon'. 945func (t *Accept) PrependIcon(i vocab.ImageType) { 946 t.raw.PrependIconImage(i) 947 948} 949 950// RemoveIcon deletes the value from the specified index for property 'icon'. 951func (t *Accept) RemoveIcon(idx int) { 952 t.raw.RemoveIconImage(idx) 953 954} 955 956// HasIcon returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 957func (t *Accept) HasIcon(idx int) (p Presence) { 958 p = NoPresence 959 if t.raw.IsIconImage(idx) { 960 p = ConvenientPresence 961 } else if t.raw.IsIconLink(idx) { 962 p = RawPresence 963 } else if t.raw.IsIconIRI(idx) { 964 p = RawPresence 965 } 966 return 967 968} 969 970// GetId attempts to get this 'id' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 971func (t *Accept) GetId() (r Resolution, k *url.URL) { 972 r = Unresolved 973 handled := false 974 if t.raw.HasId() { 975 k = t.raw.GetId() 976 if handled { 977 r = Resolved 978 } 979 } 980 return 981 982} 983 984// HasId returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 985func (t *Accept) HasId() (p Presence) { 986 p = NoPresence 987 if t.raw.HasId() { 988 p = ConvenientPresence 989 } 990 return 991 992} 993 994// SetId sets the value for property 'id'. 995func (t *Accept) SetId(k *url.URL) { 996 t.raw.SetId(k) 997 998} 999 1000// LenImage returns the number of values this property contains. Each index be used with HasImage to determine if ResolveImage is safe to call or if raw handling would be needed. 1001func (t *Accept) LenImage() (idx int) { 1002 return t.raw.ImageLen() 1003 1004} 1005 1006// ResolveImage passes the actual concrete type to the resolver for handing property image. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1007func (t *Accept) ResolveImage(r *Resolver, idx int) (s Resolution, err error) { 1008 s = Unresolved 1009 handled := false 1010 if t.raw.IsImageImage(idx) { 1011 handled, err = r.dispatch(t.raw.GetImageImage(idx)) 1012 if handled { 1013 s = Resolved 1014 } 1015 } else if t.raw.IsImageLink(idx) { 1016 s = RawResolutionNeeded 1017 } else if t.raw.IsImageIRI(idx) { 1018 s = RawResolutionNeeded 1019 } 1020 return 1021 1022} 1023 1024// AppendImage appends the value for property 'image'. 1025func (t *Accept) AppendImage(i vocab.ImageType) { 1026 t.raw.AppendImageImage(i) 1027 1028} 1029 1030// PrependImage prepends the value for property 'image'. 1031func (t *Accept) PrependImage(i vocab.ImageType) { 1032 t.raw.PrependImageImage(i) 1033 1034} 1035 1036// RemoveImage deletes the value from the specified index for property 'image'. 1037func (t *Accept) RemoveImage(idx int) { 1038 t.raw.RemoveImageImage(idx) 1039 1040} 1041 1042// HasImage returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1043func (t *Accept) HasImage(idx int) (p Presence) { 1044 p = NoPresence 1045 if t.raw.IsImageImage(idx) { 1046 p = ConvenientPresence 1047 } else if t.raw.IsImageLink(idx) { 1048 p = RawPresence 1049 } else if t.raw.IsImageIRI(idx) { 1050 p = RawPresence 1051 } 1052 return 1053 1054} 1055 1056// LenInReplyTo returns the number of values this property contains. Each index be used with HasInReplyTo to determine if GetInReplyTo is safe to call or if raw handling would be needed. 1057func (t *Accept) LenInReplyTo() (idx int) { 1058 return t.raw.InReplyToLen() 1059 1060} 1061 1062// GetInReplyTo attempts to get this 'inReplyTo' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1063func (t *Accept) GetInReplyTo(idx int) (r Resolution, k *url.URL) { 1064 r = Unresolved 1065 handled := false 1066 if t.raw.IsInReplyToIRI(idx) { 1067 k = t.raw.GetInReplyToIRI(idx) 1068 if handled { 1069 r = Resolved 1070 } 1071 } else if t.raw.IsInReplyToObject(idx) { 1072 r = RawResolutionNeeded 1073 } else if t.raw.IsInReplyToLink(idx) { 1074 r = RawResolutionNeeded 1075 } 1076 return 1077 1078} 1079 1080// AppendInReplyTo appends the value for property 'inReplyTo'. 1081func (t *Accept) AppendInReplyTo(k *url.URL) { 1082 t.raw.AppendInReplyToIRI(k) 1083 1084} 1085 1086// PrependInReplyTo prepends the value for property 'inReplyTo'. 1087func (t *Accept) PrependInReplyTo(k *url.URL) { 1088 t.raw.PrependInReplyToIRI(k) 1089 1090} 1091 1092// RemoveInReplyTo deletes the value from the specified index for property 'inReplyTo'. 1093func (t *Accept) RemoveInReplyTo(idx int) { 1094 t.raw.RemoveInReplyToIRI(idx) 1095 1096} 1097 1098// HasInReplyTo returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1099func (t *Accept) HasInReplyTo(idx int) (p Presence) { 1100 p = NoPresence 1101 if t.raw.IsInReplyToIRI(idx) { 1102 p = ConvenientPresence 1103 } else if t.raw.IsInReplyToLink(idx) { 1104 p = RawPresence 1105 } else if t.raw.IsInReplyToIRI(idx) { 1106 p = RawPresence 1107 } 1108 return 1109 1110} 1111 1112// LenLocation returns the number of values this property contains. Each index be used with HasLocation to determine if ResolveLocation is safe to call or if raw handling would be needed. 1113func (t *Accept) LenLocation() (idx int) { 1114 return t.raw.LocationLen() 1115 1116} 1117 1118// ResolveLocation passes the actual concrete type to the resolver for handing property location. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1119func (t *Accept) ResolveLocation(r *Resolver, idx int) (s Resolution, err error) { 1120 s = Unresolved 1121 handled := false 1122 if t.raw.IsLocationObject(idx) { 1123 handled, err = r.dispatch(t.raw.GetLocationObject(idx)) 1124 if handled { 1125 s = Resolved 1126 } 1127 } else if t.raw.IsLocationLink(idx) { 1128 handled, err = r.dispatch(t.raw.GetLocationLink(idx)) 1129 if handled { 1130 s = Resolved 1131 } 1132 } else if t.raw.IsLocationIRI(idx) { 1133 s = RawResolutionNeeded 1134 } 1135 return 1136 1137} 1138 1139// HasLocation returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1140func (t *Accept) HasLocation(idx int) (p Presence) { 1141 p = NoPresence 1142 if t.raw.IsLocationObject(idx) { 1143 p = ConvenientPresence 1144 } else if t.raw.IsLocationLink(idx) { 1145 p = ConvenientPresence 1146 } else if t.raw.IsLocationIRI(idx) { 1147 p = RawPresence 1148 } 1149 return 1150 1151} 1152 1153// AppendLocation appends an 'Object' typed value. 1154func (t *Accept) AppendLocation(i vocab.ObjectType) { 1155 t.raw.AppendLocationObject(i) 1156 1157} 1158 1159// PrependLocation prepends an 'Object' typed value. 1160func (t *Accept) PrependLocation(i vocab.ObjectType) { 1161 t.raw.PrependLocationObject(i) 1162 1163} 1164 1165// AppendLocationLink appends a 'Link' typed value. 1166func (t *Accept) AppendLocationLink(i vocab.LinkType) { 1167 t.raw.AppendLocationLink(i) 1168 1169} 1170 1171// PrependLocationLink prepends a 'Link' typed value. 1172func (t *Accept) PrependLocationLink(i vocab.LinkType) { 1173 t.raw.PrependLocationLink(i) 1174 1175} 1176 1177// LenPreview returns the number of values this property contains. Each index be used with HasPreview to determine if ResolvePreview is safe to call or if raw handling would be needed. 1178func (t *Accept) LenPreview() (idx int) { 1179 return t.raw.PreviewLen() 1180 1181} 1182 1183// ResolvePreview passes the actual concrete type to the resolver for handing property preview. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1184func (t *Accept) ResolvePreview(r *Resolver, idx int) (s Resolution, err error) { 1185 s = Unresolved 1186 handled := false 1187 if t.raw.IsPreviewObject(idx) { 1188 handled, err = r.dispatch(t.raw.GetPreviewObject(idx)) 1189 if handled { 1190 s = Resolved 1191 } 1192 } else if t.raw.IsPreviewLink(idx) { 1193 handled, err = r.dispatch(t.raw.GetPreviewLink(idx)) 1194 if handled { 1195 s = Resolved 1196 } 1197 } else if t.raw.IsPreviewIRI(idx) { 1198 s = RawResolutionNeeded 1199 } 1200 return 1201 1202} 1203 1204// HasPreview returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1205func (t *Accept) HasPreview(idx int) (p Presence) { 1206 p = NoPresence 1207 if t.raw.IsPreviewObject(idx) { 1208 p = ConvenientPresence 1209 } else if t.raw.IsPreviewLink(idx) { 1210 p = ConvenientPresence 1211 } else if t.raw.IsPreviewIRI(idx) { 1212 p = RawPresence 1213 } 1214 return 1215 1216} 1217 1218// AppendPreview appends an 'Object' typed value. 1219func (t *Accept) AppendPreview(i vocab.ObjectType) { 1220 t.raw.AppendPreviewObject(i) 1221 1222} 1223 1224// PrependPreview prepends an 'Object' typed value. 1225func (t *Accept) PrependPreview(i vocab.ObjectType) { 1226 t.raw.PrependPreviewObject(i) 1227 1228} 1229 1230// AppendPreviewLink appends a 'Link' typed value. 1231func (t *Accept) AppendPreviewLink(i vocab.LinkType) { 1232 t.raw.AppendPreviewLink(i) 1233 1234} 1235 1236// PrependPreviewLink prepends a 'Link' typed value. 1237func (t *Accept) PrependPreviewLink(i vocab.LinkType) { 1238 t.raw.PrependPreviewLink(i) 1239 1240} 1241 1242// GetPublished attempts to get this 'published' property as a time.Time. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1243func (t *Accept) GetPublished() (r Resolution, k time.Time) { 1244 r = Unresolved 1245 handled := false 1246 if t.raw.IsPublished() { 1247 k = t.raw.GetPublished() 1248 if handled { 1249 r = Resolved 1250 } 1251 } else if t.raw.IsPublishedIRI() { 1252 r = RawResolutionNeeded 1253 } 1254 return 1255 1256} 1257 1258// HasPublished returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1259func (t *Accept) HasPublished() (p Presence) { 1260 p = NoPresence 1261 if t.raw.IsPublished() { 1262 p = ConvenientPresence 1263 } else if t.raw.IsPublishedIRI() { 1264 p = RawPresence 1265 } 1266 return 1267 1268} 1269 1270// SetPublished sets the value for property 'published'. 1271func (t *Accept) SetPublished(k time.Time) { 1272 t.raw.SetPublished(k) 1273 1274} 1275 1276// ResolveReplies passes the actual concrete type to the resolver for handing property replies. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1277func (t *Accept) ResolveReplies(r *Resolver) (s Resolution, err error) { 1278 s = Unresolved 1279 handled := false 1280 if t.raw.IsReplies() { 1281 handled, err = r.dispatch(t.raw.GetReplies()) 1282 if handled { 1283 s = Resolved 1284 } 1285 } else if t.raw.IsRepliesIRI() { 1286 s = RawResolutionNeeded 1287 } 1288 return 1289 1290} 1291 1292// HasReplies returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1293func (t *Accept) HasReplies() (p Presence) { 1294 p = NoPresence 1295 if t.raw.IsReplies() { 1296 p = ConvenientPresence 1297 } else if t.raw.IsRepliesIRI() { 1298 p = RawPresence 1299 } 1300 return 1301 1302} 1303 1304// SetReplies sets this value to be a 'Collection' type. 1305func (t *Accept) SetReplies(i vocab.CollectionType) { 1306 t.raw.SetReplies(i) 1307 1308} 1309 1310// GetStartTime attempts to get this 'startTime' property as a time.Time. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1311func (t *Accept) GetStartTime() (r Resolution, k time.Time) { 1312 r = Unresolved 1313 handled := false 1314 if t.raw.IsStartTime() { 1315 k = t.raw.GetStartTime() 1316 if handled { 1317 r = Resolved 1318 } 1319 } else if t.raw.IsStartTimeIRI() { 1320 r = RawResolutionNeeded 1321 } 1322 return 1323 1324} 1325 1326// HasStartTime returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1327func (t *Accept) HasStartTime() (p Presence) { 1328 p = NoPresence 1329 if t.raw.IsStartTime() { 1330 p = ConvenientPresence 1331 } else if t.raw.IsStartTimeIRI() { 1332 p = RawPresence 1333 } 1334 return 1335 1336} 1337 1338// SetStartTime sets the value for property 'startTime'. 1339func (t *Accept) SetStartTime(k time.Time) { 1340 t.raw.SetStartTime(k) 1341 1342} 1343 1344// LenSummary returns the number of values this property contains. Each index be used with HasSummary to determine if GetSummary is safe to call or if raw handling would be needed. 1345func (t *Accept) LenSummary() (idx int) { 1346 return t.raw.SummaryLen() 1347 1348} 1349 1350// GetSummary attempts to get this 'summary' property as a string. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1351func (t *Accept) GetSummary(idx int) (r Resolution, k string) { 1352 r = Unresolved 1353 handled := false 1354 if t.raw.IsSummaryString(idx) { 1355 k = t.raw.GetSummaryString(idx) 1356 if handled { 1357 r = Resolved 1358 } 1359 } else if t.raw.IsSummaryLangString(idx) { 1360 r = RawResolutionNeeded 1361 } else if t.raw.IsSummaryIRI(idx) { 1362 r = RawResolutionNeeded 1363 } 1364 return 1365 1366} 1367 1368// AppendSummary appends the value for property 'summary'. 1369func (t *Accept) AppendSummary(k string) { 1370 t.raw.AppendSummaryString(k) 1371 1372} 1373 1374// PrependSummary prepends the value for property 'summary'. 1375func (t *Accept) PrependSummary(k string) { 1376 t.raw.PrependSummaryString(k) 1377 1378} 1379 1380// RemoveSummary deletes the value from the specified index for property 'summary'. 1381func (t *Accept) RemoveSummary(idx int) { 1382 t.raw.RemoveSummaryString(idx) 1383 1384} 1385 1386// HasSummary returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1387func (t *Accept) HasSummary(idx int) (p Presence) { 1388 p = NoPresence 1389 if t.raw.IsSummaryString(idx) { 1390 p = ConvenientPresence 1391 } else if t.raw.IsSummaryLangString(idx) { 1392 p = RawPresence 1393 } else if t.raw.IsSummaryIRI(idx) { 1394 p = RawPresence 1395 } 1396 return 1397 1398} 1399 1400// SummaryLanguages returns all languages for this property's language mapping, or nil if there are none. 1401func (t *Accept) SummaryLanguages() (l []string) { 1402 return t.raw.SummaryMapLanguages() 1403 1404} 1405 1406// GetSummaryMap retrieves the value of 'summary' for the specified language, or an empty string if it does not exist 1407func (t *Accept) GetSummaryForLanguage(l string) (v string) { 1408 return t.raw.GetSummaryMap(l) 1409 1410} 1411 1412// SetSummaryForLanguage sets the value of 'summary' for the specified language 1413func (t *Accept) SetSummaryForLanguage(l string, v string) { 1414 t.raw.SetSummaryMap(l, v) 1415 1416} 1417 1418// LenTag returns the number of values this property contains. Each index be used with HasTag to determine if ResolveTag is safe to call or if raw handling would be needed. 1419func (t *Accept) LenTag() (idx int) { 1420 return t.raw.TagLen() 1421 1422} 1423 1424// ResolveTag passes the actual concrete type to the resolver for handing property tag. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1425func (t *Accept) ResolveTag(r *Resolver, idx int) (s Resolution, err error) { 1426 s = Unresolved 1427 handled := false 1428 if t.raw.IsTagObject(idx) { 1429 handled, err = r.dispatch(t.raw.GetTagObject(idx)) 1430 if handled { 1431 s = Resolved 1432 } 1433 } else if t.raw.IsTagLink(idx) { 1434 handled, err = r.dispatch(t.raw.GetTagLink(idx)) 1435 if handled { 1436 s = Resolved 1437 } 1438 } else if t.raw.IsTagIRI(idx) { 1439 s = RawResolutionNeeded 1440 } 1441 return 1442 1443} 1444 1445// HasTag returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1446func (t *Accept) HasTag(idx int) (p Presence) { 1447 p = NoPresence 1448 if t.raw.IsTagObject(idx) { 1449 p = ConvenientPresence 1450 } else if t.raw.IsTagLink(idx) { 1451 p = ConvenientPresence 1452 } else if t.raw.IsTagIRI(idx) { 1453 p = RawPresence 1454 } 1455 return 1456 1457} 1458 1459// AppendTag appends an 'Object' typed value. 1460func (t *Accept) AppendTag(i vocab.ObjectType) { 1461 t.raw.AppendTagObject(i) 1462 1463} 1464 1465// PrependTag prepends an 'Object' typed value. 1466func (t *Accept) PrependTag(i vocab.ObjectType) { 1467 t.raw.PrependTagObject(i) 1468 1469} 1470 1471// AppendTagLink appends a 'Link' typed value. 1472func (t *Accept) AppendTagLink(i vocab.LinkType) { 1473 t.raw.AppendTagLink(i) 1474 1475} 1476 1477// PrependTagLink prepends a 'Link' typed value. 1478func (t *Accept) PrependTagLink(i vocab.LinkType) { 1479 t.raw.PrependTagLink(i) 1480 1481} 1482 1483// LenType returns the number of values this property contains. Each index be used with HasType to determine if GetType is safe to call or if raw handling would be needed. 1484func (t *Accept) LenType() (idx int) { 1485 return t.raw.TypeLen() 1486 1487} 1488 1489// GetType attempts to get this 'type' property as a string. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1490func (t *Accept) GetType(idx int) (r Resolution, s string) { 1491 r = Unresolved 1492 if tmp := t.raw.GetType(idx); tmp != nil { 1493 ok := false 1494 if s, ok = tmp.(string); ok { 1495 r = Resolved 1496 } else { 1497 r = RawResolutionNeeded 1498 } 1499 } 1500 return 1501 1502} 1503 1504// AppendType appends the value for property 'type'. 1505func (t *Accept) AppendType(i interface{}) { 1506 t.raw.AppendType(i) 1507 1508} 1509 1510// PrependType prepends the value for property 'type'. 1511func (t *Accept) PrependType(i interface{}) { 1512 t.raw.PrependType(i) 1513 1514} 1515 1516// RemoveType deletes the value from the specified index for property 'type'. 1517func (t *Accept) RemoveType(idx int) { 1518 t.raw.RemoveType(idx) 1519 1520} 1521 1522// GetUpdated attempts to get this 'updated' property as a time.Time. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1523func (t *Accept) GetUpdated() (r Resolution, k time.Time) { 1524 r = Unresolved 1525 handled := false 1526 if t.raw.IsUpdated() { 1527 k = t.raw.GetUpdated() 1528 if handled { 1529 r = Resolved 1530 } 1531 } else if t.raw.IsUpdatedIRI() { 1532 r = RawResolutionNeeded 1533 } 1534 return 1535 1536} 1537 1538// HasUpdated returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1539func (t *Accept) HasUpdated() (p Presence) { 1540 p = NoPresence 1541 if t.raw.IsUpdated() { 1542 p = ConvenientPresence 1543 } else if t.raw.IsUpdatedIRI() { 1544 p = RawPresence 1545 } 1546 return 1547 1548} 1549 1550// SetUpdated sets the value for property 'updated'. 1551func (t *Accept) SetUpdated(k time.Time) { 1552 t.raw.SetUpdated(k) 1553 1554} 1555 1556// LenUrl returns the number of values this property contains. Each index be used with HasUrl to determine if GetUrl is safe to call or if raw handling would be needed. 1557func (t *Accept) LenUrl() (idx int) { 1558 return t.raw.UrlLen() 1559 1560} 1561 1562// GetUrl attempts to get this 'url' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1563func (t *Accept) GetUrl(idx int) (r Resolution, k *url.URL) { 1564 r = Unresolved 1565 handled := false 1566 if t.raw.IsUrlAnyURI(idx) { 1567 k = t.raw.GetUrlAnyURI(idx) 1568 if handled { 1569 r = Resolved 1570 } 1571 } else if t.raw.IsUrlLink(idx) { 1572 r = RawResolutionNeeded 1573 } 1574 return 1575 1576} 1577 1578// AppendUrl appends the value for property 'url'. 1579func (t *Accept) AppendUrl(k *url.URL) { 1580 t.raw.AppendUrlAnyURI(k) 1581 1582} 1583 1584// PrependUrl prepends the value for property 'url'. 1585func (t *Accept) PrependUrl(k *url.URL) { 1586 t.raw.PrependUrlAnyURI(k) 1587 1588} 1589 1590// RemoveUrl deletes the value from the specified index for property 'url'. 1591func (t *Accept) RemoveUrl(idx int) { 1592 t.raw.RemoveUrlAnyURI(idx) 1593 1594} 1595 1596// HasUrl returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1597func (t *Accept) HasUrl(idx int) (p Presence) { 1598 p = NoPresence 1599 if t.raw.IsUrlAnyURI(idx) { 1600 p = ConvenientPresence 1601 } else if t.raw.IsUrlLink(idx) { 1602 p = RawPresence 1603 } 1604 return 1605 1606} 1607 1608// LenTo returns the number of values this property contains. Each index be used with HasTo to determine if GetTo is safe to call or if raw handling would be needed. 1609func (t *Accept) LenTo() (idx int) { 1610 return t.raw.ToLen() 1611 1612} 1613 1614// GetTo attempts to get this 'to' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1615func (t *Accept) GetTo(idx int) (r Resolution, k *url.URL) { 1616 r = Unresolved 1617 handled := false 1618 if t.raw.IsToIRI(idx) { 1619 k = t.raw.GetToIRI(idx) 1620 if handled { 1621 r = Resolved 1622 } 1623 } else if t.raw.IsToObject(idx) { 1624 r = RawResolutionNeeded 1625 } else if t.raw.IsToLink(idx) { 1626 r = RawResolutionNeeded 1627 } 1628 return 1629 1630} 1631 1632// AppendTo appends the value for property 'to'. 1633func (t *Accept) AppendTo(k *url.URL) { 1634 t.raw.AppendToIRI(k) 1635 1636} 1637 1638// PrependTo prepends the value for property 'to'. 1639func (t *Accept) PrependTo(k *url.URL) { 1640 t.raw.PrependToIRI(k) 1641 1642} 1643 1644// RemoveTo deletes the value from the specified index for property 'to'. 1645func (t *Accept) RemoveTo(idx int) { 1646 t.raw.RemoveToIRI(idx) 1647 1648} 1649 1650// HasTo returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1651func (t *Accept) HasTo(idx int) (p Presence) { 1652 p = NoPresence 1653 if t.raw.IsToIRI(idx) { 1654 p = ConvenientPresence 1655 } else if t.raw.IsToLink(idx) { 1656 p = RawPresence 1657 } else if t.raw.IsToIRI(idx) { 1658 p = RawPresence 1659 } 1660 return 1661 1662} 1663 1664// LenBto returns the number of values this property contains. Each index be used with HasBto to determine if GetBto is safe to call or if raw handling would be needed. 1665func (t *Accept) LenBto() (idx int) { 1666 return t.raw.BtoLen() 1667 1668} 1669 1670// GetBto attempts to get this 'bto' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1671func (t *Accept) GetBto(idx int) (r Resolution, k *url.URL) { 1672 r = Unresolved 1673 handled := false 1674 if t.raw.IsBtoIRI(idx) { 1675 k = t.raw.GetBtoIRI(idx) 1676 if handled { 1677 r = Resolved 1678 } 1679 } else if t.raw.IsBtoObject(idx) { 1680 r = RawResolutionNeeded 1681 } else if t.raw.IsBtoLink(idx) { 1682 r = RawResolutionNeeded 1683 } 1684 return 1685 1686} 1687 1688// AppendBto appends the value for property 'bto'. 1689func (t *Accept) AppendBto(k *url.URL) { 1690 t.raw.AppendBtoIRI(k) 1691 1692} 1693 1694// PrependBto prepends the value for property 'bto'. 1695func (t *Accept) PrependBto(k *url.URL) { 1696 t.raw.PrependBtoIRI(k) 1697 1698} 1699 1700// RemoveBto deletes the value from the specified index for property 'bto'. 1701func (t *Accept) RemoveBto(idx int) { 1702 t.raw.RemoveBtoIRI(idx) 1703 1704} 1705 1706// HasBto returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1707func (t *Accept) HasBto(idx int) (p Presence) { 1708 p = NoPresence 1709 if t.raw.IsBtoIRI(idx) { 1710 p = ConvenientPresence 1711 } else if t.raw.IsBtoLink(idx) { 1712 p = RawPresence 1713 } else if t.raw.IsBtoIRI(idx) { 1714 p = RawPresence 1715 } 1716 return 1717 1718} 1719 1720// LenCc returns the number of values this property contains. Each index be used with HasCc to determine if GetCc is safe to call or if raw handling would be needed. 1721func (t *Accept) LenCc() (idx int) { 1722 return t.raw.CcLen() 1723 1724} 1725 1726// GetCc attempts to get this 'cc' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1727func (t *Accept) GetCc(idx int) (r Resolution, k *url.URL) { 1728 r = Unresolved 1729 handled := false 1730 if t.raw.IsCcIRI(idx) { 1731 k = t.raw.GetCcIRI(idx) 1732 if handled { 1733 r = Resolved 1734 } 1735 } else if t.raw.IsCcObject(idx) { 1736 r = RawResolutionNeeded 1737 } else if t.raw.IsCcLink(idx) { 1738 r = RawResolutionNeeded 1739 } 1740 return 1741 1742} 1743 1744// AppendCc appends the value for property 'cc'. 1745func (t *Accept) AppendCc(k *url.URL) { 1746 t.raw.AppendCcIRI(k) 1747 1748} 1749 1750// PrependCc prepends the value for property 'cc'. 1751func (t *Accept) PrependCc(k *url.URL) { 1752 t.raw.PrependCcIRI(k) 1753 1754} 1755 1756// RemoveCc deletes the value from the specified index for property 'cc'. 1757func (t *Accept) RemoveCc(idx int) { 1758 t.raw.RemoveCcIRI(idx) 1759 1760} 1761 1762// HasCc returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1763func (t *Accept) HasCc(idx int) (p Presence) { 1764 p = NoPresence 1765 if t.raw.IsCcIRI(idx) { 1766 p = ConvenientPresence 1767 } else if t.raw.IsCcLink(idx) { 1768 p = RawPresence 1769 } else if t.raw.IsCcIRI(idx) { 1770 p = RawPresence 1771 } 1772 return 1773 1774} 1775 1776// LenBcc returns the number of values this property contains. Each index be used with HasBcc to determine if GetBcc is safe to call or if raw handling would be needed. 1777func (t *Accept) LenBcc() (idx int) { 1778 return t.raw.BccLen() 1779 1780} 1781 1782// GetBcc attempts to get this 'bcc' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1783func (t *Accept) GetBcc(idx int) (r Resolution, k *url.URL) { 1784 r = Unresolved 1785 handled := false 1786 if t.raw.IsBccIRI(idx) { 1787 k = t.raw.GetBccIRI(idx) 1788 if handled { 1789 r = Resolved 1790 } 1791 } else if t.raw.IsBccObject(idx) { 1792 r = RawResolutionNeeded 1793 } else if t.raw.IsBccLink(idx) { 1794 r = RawResolutionNeeded 1795 } 1796 return 1797 1798} 1799 1800// AppendBcc appends the value for property 'bcc'. 1801func (t *Accept) AppendBcc(k *url.URL) { 1802 t.raw.AppendBccIRI(k) 1803 1804} 1805 1806// PrependBcc prepends the value for property 'bcc'. 1807func (t *Accept) PrependBcc(k *url.URL) { 1808 t.raw.PrependBccIRI(k) 1809 1810} 1811 1812// RemoveBcc deletes the value from the specified index for property 'bcc'. 1813func (t *Accept) RemoveBcc(idx int) { 1814 t.raw.RemoveBccIRI(idx) 1815 1816} 1817 1818// HasBcc returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1819func (t *Accept) HasBcc(idx int) (p Presence) { 1820 p = NoPresence 1821 if t.raw.IsBccIRI(idx) { 1822 p = ConvenientPresence 1823 } else if t.raw.IsBccLink(idx) { 1824 p = RawPresence 1825 } else if t.raw.IsBccIRI(idx) { 1826 p = RawPresence 1827 } 1828 return 1829 1830} 1831 1832// GetMediaType attempts to get this 'mediaType' property as a string. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1833func (t *Accept) GetMediaType() (r Resolution, k string) { 1834 r = Unresolved 1835 handled := false 1836 if t.raw.IsMediaType() { 1837 k = t.raw.GetMediaType() 1838 if handled { 1839 r = Resolved 1840 } 1841 } else if t.raw.IsMediaTypeIRI() { 1842 r = RawResolutionNeeded 1843 } 1844 return 1845 1846} 1847 1848// HasMediaType returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1849func (t *Accept) HasMediaType() (p Presence) { 1850 p = NoPresence 1851 if t.raw.IsMediaType() { 1852 p = ConvenientPresence 1853 } else if t.raw.IsMediaTypeIRI() { 1854 p = RawPresence 1855 } 1856 return 1857 1858} 1859 1860// SetMediaType sets the value for property 'mediaType'. 1861func (t *Accept) SetMediaType(k string) { 1862 t.raw.SetMediaType(k) 1863 1864} 1865 1866// GetDuration attempts to get this 'duration' property as a time.Duration. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 1867func (t *Accept) GetDuration() (r Resolution, k time.Duration) { 1868 r = Unresolved 1869 handled := false 1870 if t.raw.IsDuration() { 1871 k = t.raw.GetDuration() 1872 if handled { 1873 r = Resolved 1874 } 1875 } else if t.raw.IsDurationIRI() { 1876 r = RawResolutionNeeded 1877 } 1878 return 1879 1880} 1881 1882// HasDuration returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1883func (t *Accept) HasDuration() (p Presence) { 1884 p = NoPresence 1885 if t.raw.IsDuration() { 1886 p = ConvenientPresence 1887 } else if t.raw.IsDurationIRI() { 1888 p = RawPresence 1889 } 1890 return 1891 1892} 1893 1894// SetDuration sets the value for property 'duration'. 1895func (t *Accept) SetDuration(k time.Duration) { 1896 t.raw.SetDuration(k) 1897 1898} 1899 1900// ResolveSource passes the actual concrete type to the resolver for handing property source. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1901func (t *Accept) ResolveSource(r *Resolver) (s Resolution, err error) { 1902 s = Unresolved 1903 handled := false 1904 if t.raw.IsSource() { 1905 handled, err = r.dispatch(t.raw.GetSource()) 1906 if handled { 1907 s = Resolved 1908 } 1909 } else if t.raw.IsSourceIRI() { 1910 s = RawResolutionNeeded 1911 } 1912 return 1913 1914} 1915 1916// HasSource returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1917func (t *Accept) HasSource() (p Presence) { 1918 p = NoPresence 1919 if t.raw.IsSource() { 1920 p = ConvenientPresence 1921 } else if t.raw.IsSourceIRI() { 1922 p = RawPresence 1923 } 1924 return 1925 1926} 1927 1928// SetSource sets this value to be a 'Object' type. 1929func (t *Accept) SetSource(i vocab.ObjectType) { 1930 t.raw.SetSource(i) 1931 1932} 1933 1934// ResolveInbox passes the actual concrete type to the resolver for handing property inbox. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1935func (t *Accept) ResolveInbox(r *Resolver) (s Resolution, err error) { 1936 s = Unresolved 1937 handled := false 1938 if t.raw.IsInboxOrderedCollection() { 1939 handled, err = r.dispatch(t.raw.GetInboxOrderedCollection()) 1940 if handled { 1941 s = Resolved 1942 } 1943 } else if t.raw.IsInboxAnyURI() { 1944 s = RawResolutionNeeded 1945 } 1946 return 1947 1948} 1949 1950// HasInbox returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1951func (t *Accept) HasInbox() (p Presence) { 1952 p = NoPresence 1953 if t.raw.IsInboxOrderedCollection() { 1954 p = ConvenientPresence 1955 } else if t.raw.IsInboxAnyURI() { 1956 p = RawPresence 1957 } 1958 return 1959 1960} 1961 1962// SetInbox sets this value to be a 'OrderedCollection' type. 1963func (t *Accept) SetInbox(i vocab.OrderedCollectionType) { 1964 t.raw.SetInboxOrderedCollection(i) 1965 1966} 1967 1968// ResolveOutbox passes the actual concrete type to the resolver for handing property outbox. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1969func (t *Accept) ResolveOutbox(r *Resolver) (s Resolution, err error) { 1970 s = Unresolved 1971 handled := false 1972 if t.raw.IsOutboxOrderedCollection() { 1973 handled, err = r.dispatch(t.raw.GetOutboxOrderedCollection()) 1974 if handled { 1975 s = Resolved 1976 } 1977 } else if t.raw.IsOutboxAnyURI() { 1978 s = RawResolutionNeeded 1979 } 1980 return 1981 1982} 1983 1984// HasOutbox returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 1985func (t *Accept) HasOutbox() (p Presence) { 1986 p = NoPresence 1987 if t.raw.IsOutboxOrderedCollection() { 1988 p = ConvenientPresence 1989 } else if t.raw.IsOutboxAnyURI() { 1990 p = RawPresence 1991 } 1992 return 1993 1994} 1995 1996// SetOutbox sets this value to be a 'OrderedCollection' type. 1997func (t *Accept) SetOutbox(i vocab.OrderedCollectionType) { 1998 t.raw.SetOutboxOrderedCollection(i) 1999 2000} 2001 2002// ResolveFollowing passes the actual concrete type to the resolver for handing property following. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2003func (t *Accept) ResolveFollowing(r *Resolver) (s Resolution, err error) { 2004 s = Unresolved 2005 handled := false 2006 if t.raw.IsFollowingCollection() { 2007 handled, err = r.dispatch(t.raw.GetFollowingCollection()) 2008 if handled { 2009 s = Resolved 2010 } 2011 } else if t.raw.IsFollowingOrderedCollection() { 2012 s = RawResolutionNeeded 2013 } else if t.raw.IsFollowingAnyURI() { 2014 s = RawResolutionNeeded 2015 } 2016 return 2017 2018} 2019 2020// HasFollowing returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2021func (t *Accept) HasFollowing() (p Presence) { 2022 p = NoPresence 2023 if t.raw.IsFollowingCollection() { 2024 p = ConvenientPresence 2025 } else if t.raw.IsFollowingOrderedCollection() { 2026 p = RawPresence 2027 } else if t.raw.IsFollowingAnyURI() { 2028 p = RawPresence 2029 } 2030 return 2031 2032} 2033 2034// SetFollowing sets this value to be a 'Collection' type. 2035func (t *Accept) SetFollowing(i vocab.CollectionType) { 2036 t.raw.SetFollowingCollection(i) 2037 2038} 2039 2040// ResolveFollowers passes the actual concrete type to the resolver for handing property followers. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2041func (t *Accept) ResolveFollowers(r *Resolver) (s Resolution, err error) { 2042 s = Unresolved 2043 handled := false 2044 if t.raw.IsFollowersCollection() { 2045 handled, err = r.dispatch(t.raw.GetFollowersCollection()) 2046 if handled { 2047 s = Resolved 2048 } 2049 } else if t.raw.IsFollowersOrderedCollection() { 2050 s = RawResolutionNeeded 2051 } else if t.raw.IsFollowersAnyURI() { 2052 s = RawResolutionNeeded 2053 } 2054 return 2055 2056} 2057 2058// HasFollowers returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2059func (t *Accept) HasFollowers() (p Presence) { 2060 p = NoPresence 2061 if t.raw.IsFollowersCollection() { 2062 p = ConvenientPresence 2063 } else if t.raw.IsFollowersOrderedCollection() { 2064 p = RawPresence 2065 } else if t.raw.IsFollowersAnyURI() { 2066 p = RawPresence 2067 } 2068 return 2069 2070} 2071 2072// SetFollowers sets this value to be a 'Collection' type. 2073func (t *Accept) SetFollowers(i vocab.CollectionType) { 2074 t.raw.SetFollowersCollection(i) 2075 2076} 2077 2078// ResolveLiked passes the actual concrete type to the resolver for handing property liked. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2079func (t *Accept) ResolveLiked(r *Resolver) (s Resolution, err error) { 2080 s = Unresolved 2081 handled := false 2082 if t.raw.IsLikedCollection() { 2083 handled, err = r.dispatch(t.raw.GetLikedCollection()) 2084 if handled { 2085 s = Resolved 2086 } 2087 } else if t.raw.IsLikedOrderedCollection() { 2088 s = RawResolutionNeeded 2089 } else if t.raw.IsLikedAnyURI() { 2090 s = RawResolutionNeeded 2091 } 2092 return 2093 2094} 2095 2096// HasLiked returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2097func (t *Accept) HasLiked() (p Presence) { 2098 p = NoPresence 2099 if t.raw.IsLikedCollection() { 2100 p = ConvenientPresence 2101 } else if t.raw.IsLikedOrderedCollection() { 2102 p = RawPresence 2103 } else if t.raw.IsLikedAnyURI() { 2104 p = RawPresence 2105 } 2106 return 2107 2108} 2109 2110// SetLiked sets this value to be a 'Collection' type. 2111func (t *Accept) SetLiked(i vocab.CollectionType) { 2112 t.raw.SetLikedCollection(i) 2113 2114} 2115 2116// ResolveLikes passes the actual concrete type to the resolver for handing property likes. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2117func (t *Accept) ResolveLikes(r *Resolver) (s Resolution, err error) { 2118 s = Unresolved 2119 handled := false 2120 if t.raw.IsLikesCollection() { 2121 handled, err = r.dispatch(t.raw.GetLikesCollection()) 2122 if handled { 2123 s = Resolved 2124 } 2125 } else if t.raw.IsLikesOrderedCollection() { 2126 s = RawResolutionNeeded 2127 } else if t.raw.IsLikesAnyURI() { 2128 s = RawResolutionNeeded 2129 } 2130 return 2131 2132} 2133 2134// HasLikes returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2135func (t *Accept) HasLikes() (p Presence) { 2136 p = NoPresence 2137 if t.raw.IsLikesCollection() { 2138 p = ConvenientPresence 2139 } else if t.raw.IsLikesOrderedCollection() { 2140 p = RawPresence 2141 } else if t.raw.IsLikesAnyURI() { 2142 p = RawPresence 2143 } 2144 return 2145 2146} 2147 2148// SetLikes sets this value to be a 'Collection' type. 2149func (t *Accept) SetLikes(i vocab.CollectionType) { 2150 t.raw.SetLikesCollection(i) 2151 2152} 2153 2154// LenStreams returns the number of values this property contains. Each index be used with HasStreams to determine if GetStreams is safe to call or if raw handling would be needed. 2155func (t *Accept) LenStreams() (idx int) { 2156 return t.raw.StreamsLen() 2157 2158} 2159 2160// GetStreams attempts to get this 'streams' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2161func (t *Accept) GetStreams(idx int) (r Resolution, k *url.URL) { 2162 r = Unresolved 2163 handled := false 2164 if /*t.raw.HasStreams(idx)*/ true { 2165 k = t.raw.GetStreams(idx) 2166 if handled { 2167 r = Resolved 2168 } 2169 } 2170 return 2171 2172} 2173 2174// AppendStreams appends the value for property 'streams'. 2175func (t *Accept) AppendStreams(k *url.URL) { 2176 t.raw.AppendStreams(k) 2177 2178} 2179 2180// PrependStreams prepends the value for property 'streams'. 2181func (t *Accept) PrependStreams(k *url.URL) { 2182 t.raw.PrependStreams(k) 2183 2184} 2185 2186// RemoveStreams deletes the value from the specified index for property 'streams'. 2187func (t *Accept) RemoveStreams(idx int) { 2188 t.raw.RemoveStreams(idx) 2189 2190} 2191 2192// GetPreferredUsername attempts to get this 'preferredUsername' property as a string. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2193func (t *Accept) GetPreferredUsername() (r Resolution, k string) { 2194 r = Unresolved 2195 handled := false 2196 if t.raw.IsPreferredUsername() { 2197 k = t.raw.GetPreferredUsername() 2198 if handled { 2199 r = Resolved 2200 } 2201 } else if t.raw.IsPreferredUsernameIRI() { 2202 r = RawResolutionNeeded 2203 } 2204 return 2205 2206} 2207 2208// HasPreferredUsername returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2209func (t *Accept) HasPreferredUsername() (p Presence) { 2210 p = NoPresence 2211 if t.raw.IsPreferredUsername() { 2212 p = ConvenientPresence 2213 } else if t.raw.IsPreferredUsernameIRI() { 2214 p = RawPresence 2215 } 2216 return 2217 2218} 2219 2220// SetPreferredUsername sets the value for property 'preferredUsername'. 2221func (t *Accept) SetPreferredUsername(k string) { 2222 t.raw.SetPreferredUsername(k) 2223 2224} 2225 2226// PreferredUsernameLanguages returns all languages for this property's language mapping, or nil if there are none. 2227func (t *Accept) PreferredUsernameLanguages() (l []string) { 2228 return t.raw.PreferredUsernameMapLanguages() 2229 2230} 2231 2232// GetPreferredUsernameMap retrieves the value of 'preferredUsername' for the specified language, or an empty string if it does not exist 2233func (t *Accept) GetPreferredUsernameForLanguage(l string) (v string) { 2234 return t.raw.GetPreferredUsernameMap(l) 2235 2236} 2237 2238// SetPreferredUsernameForLanguage sets the value of 'preferredUsername' for the specified language 2239func (t *Accept) SetPreferredUsernameForLanguage(l string, v string) { 2240 t.raw.SetPreferredUsernameMap(l, v) 2241 2242} 2243 2244// ResolveEndpoints passes the actual concrete type to the resolver for handing property endpoints. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2245func (t *Accept) ResolveEndpoints(r *Resolver) (s Resolution, err error) { 2246 s = Unresolved 2247 handled := false 2248 if t.raw.IsEndpoints() { 2249 handled, err = r.dispatch(t.raw.GetEndpoints()) 2250 if handled { 2251 s = Resolved 2252 } 2253 } else if t.raw.IsEndpointsIRI() { 2254 s = RawResolutionNeeded 2255 } 2256 return 2257 2258} 2259 2260// HasEndpoints returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2261func (t *Accept) HasEndpoints() (p Presence) { 2262 p = NoPresence 2263 if t.raw.IsEndpoints() { 2264 p = ConvenientPresence 2265 } else if t.raw.IsEndpointsIRI() { 2266 p = RawPresence 2267 } 2268 return 2269 2270} 2271 2272// SetEndpoints sets this value to be a 'Object' type. 2273func (t *Accept) SetEndpoints(i vocab.ObjectType) { 2274 t.raw.SetEndpoints(i) 2275 2276} 2277 2278// GetProxyUrl attempts to get this 'proxyUrl' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2279func (t *Accept) GetProxyUrl() (r Resolution, k *url.URL) { 2280 r = Unresolved 2281 handled := false 2282 if t.raw.HasProxyUrl() { 2283 k = t.raw.GetProxyUrl() 2284 if handled { 2285 r = Resolved 2286 } 2287 } 2288 return 2289 2290} 2291 2292// HasProxyUrl returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2293func (t *Accept) HasProxyUrl() (p Presence) { 2294 p = NoPresence 2295 if t.raw.HasProxyUrl() { 2296 p = ConvenientPresence 2297 } 2298 return 2299 2300} 2301 2302// SetProxyUrl sets the value for property 'proxyUrl'. 2303func (t *Accept) SetProxyUrl(k *url.URL) { 2304 t.raw.SetProxyUrl(k) 2305 2306} 2307 2308// GetOauthAuthorizationEndpoint attempts to get this 'oauthAuthorizationEndpoint' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2309func (t *Accept) GetOauthAuthorizationEndpoint() (r Resolution, k *url.URL) { 2310 r = Unresolved 2311 handled := false 2312 if t.raw.HasOauthAuthorizationEndpoint() { 2313 k = t.raw.GetOauthAuthorizationEndpoint() 2314 if handled { 2315 r = Resolved 2316 } 2317 } 2318 return 2319 2320} 2321 2322// HasOauthAuthorizationEndpoint returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2323func (t *Accept) HasOauthAuthorizationEndpoint() (p Presence) { 2324 p = NoPresence 2325 if t.raw.HasOauthAuthorizationEndpoint() { 2326 p = ConvenientPresence 2327 } 2328 return 2329 2330} 2331 2332// SetOauthAuthorizationEndpoint sets the value for property 'oauthAuthorizationEndpoint'. 2333func (t *Accept) SetOauthAuthorizationEndpoint(k *url.URL) { 2334 t.raw.SetOauthAuthorizationEndpoint(k) 2335 2336} 2337 2338// GetOauthTokenEndpoint attempts to get this 'oauthTokenEndpoint' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2339func (t *Accept) GetOauthTokenEndpoint() (r Resolution, k *url.URL) { 2340 r = Unresolved 2341 handled := false 2342 if t.raw.HasOauthTokenEndpoint() { 2343 k = t.raw.GetOauthTokenEndpoint() 2344 if handled { 2345 r = Resolved 2346 } 2347 } 2348 return 2349 2350} 2351 2352// HasOauthTokenEndpoint returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2353func (t *Accept) HasOauthTokenEndpoint() (p Presence) { 2354 p = NoPresence 2355 if t.raw.HasOauthTokenEndpoint() { 2356 p = ConvenientPresence 2357 } 2358 return 2359 2360} 2361 2362// SetOauthTokenEndpoint sets the value for property 'oauthTokenEndpoint'. 2363func (t *Accept) SetOauthTokenEndpoint(k *url.URL) { 2364 t.raw.SetOauthTokenEndpoint(k) 2365 2366} 2367 2368// GetProvideClientKey attempts to get this 'provideClientKey' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2369func (t *Accept) GetProvideClientKey() (r Resolution, k *url.URL) { 2370 r = Unresolved 2371 handled := false 2372 if t.raw.HasProvideClientKey() { 2373 k = t.raw.GetProvideClientKey() 2374 if handled { 2375 r = Resolved 2376 } 2377 } 2378 return 2379 2380} 2381 2382// HasProvideClientKey returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2383func (t *Accept) HasProvideClientKey() (p Presence) { 2384 p = NoPresence 2385 if t.raw.HasProvideClientKey() { 2386 p = ConvenientPresence 2387 } 2388 return 2389 2390} 2391 2392// SetProvideClientKey sets the value for property 'provideClientKey'. 2393func (t *Accept) SetProvideClientKey(k *url.URL) { 2394 t.raw.SetProvideClientKey(k) 2395 2396} 2397 2398// GetSignClientKey attempts to get this 'signClientKey' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2399func (t *Accept) GetSignClientKey() (r Resolution, k *url.URL) { 2400 r = Unresolved 2401 handled := false 2402 if t.raw.HasSignClientKey() { 2403 k = t.raw.GetSignClientKey() 2404 if handled { 2405 r = Resolved 2406 } 2407 } 2408 return 2409 2410} 2411 2412// HasSignClientKey returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2413func (t *Accept) HasSignClientKey() (p Presence) { 2414 p = NoPresence 2415 if t.raw.HasSignClientKey() { 2416 p = ConvenientPresence 2417 } 2418 return 2419 2420} 2421 2422// SetSignClientKey sets the value for property 'signClientKey'. 2423func (t *Accept) SetSignClientKey(k *url.URL) { 2424 t.raw.SetSignClientKey(k) 2425 2426} 2427 2428// GetSharedInbox attempts to get this 'sharedInbox' property as a *url.URL. It returns a Resolution appropriate for clients to determine whether it would be necessary to do raw handling. 2429func (t *Accept) GetSharedInbox() (r Resolution, k *url.URL) { 2430 r = Unresolved 2431 handled := false 2432 if t.raw.HasSharedInbox() { 2433 k = t.raw.GetSharedInbox() 2434 if handled { 2435 r = Resolved 2436 } 2437 } 2438 return 2439 2440} 2441 2442// HasSharedInbox returns a Presence appropriate for clients to determine whether it would be necessary to do raw handling, if desired. 2443func (t *Accept) HasSharedInbox() (p Presence) { 2444 p = NoPresence 2445 if t.raw.HasSharedInbox() { 2446 p = ConvenientPresence 2447 } 2448 return 2449 2450} 2451 2452// SetSharedInbox sets the value for property 'sharedInbox'. 2453func (t *Accept) SetSharedInbox(k *url.URL) { 2454 t.raw.SetSharedInbox(k) 2455 2456} 2457