11931 行
332 KiB
Go
11931 行
332 KiB
Go
//
|
|
package vocab
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
// JoinType is an interface for accepting types that extend from 'Join'.
|
|
type JoinType interface {
|
|
Serializer
|
|
Deserializer
|
|
ActorLen() (l int)
|
|
IsActorObject(index int) (ok bool)
|
|
GetActorObject(index int) (v ObjectType)
|
|
AppendActorObject(v ObjectType)
|
|
PrependActorObject(v ObjectType)
|
|
RemoveActorObject(index int)
|
|
IsActorLink(index int) (ok bool)
|
|
GetActorLink(index int) (v LinkType)
|
|
AppendActorLink(v LinkType)
|
|
PrependActorLink(v LinkType)
|
|
RemoveActorLink(index int)
|
|
IsActorIRI(index int) (ok bool)
|
|
GetActorIRI(index int) (v *url.URL)
|
|
AppendActorIRI(v *url.URL)
|
|
PrependActorIRI(v *url.URL)
|
|
RemoveActorIRI(index int)
|
|
ObjectLen() (l int)
|
|
IsObject(index int) (ok bool)
|
|
GetObject(index int) (v ObjectType)
|
|
AppendObject(v ObjectType)
|
|
PrependObject(v ObjectType)
|
|
RemoveObject(index int)
|
|
IsObjectIRI(index int) (ok bool)
|
|
GetObjectIRI(index int) (v *url.URL)
|
|
AppendObjectIRI(v *url.URL)
|
|
PrependObjectIRI(v *url.URL)
|
|
RemoveObjectIRI(index int)
|
|
TargetLen() (l int)
|
|
IsTargetObject(index int) (ok bool)
|
|
GetTargetObject(index int) (v ObjectType)
|
|
AppendTargetObject(v ObjectType)
|
|
PrependTargetObject(v ObjectType)
|
|
RemoveTargetObject(index int)
|
|
IsTargetLink(index int) (ok bool)
|
|
GetTargetLink(index int) (v LinkType)
|
|
AppendTargetLink(v LinkType)
|
|
PrependTargetLink(v LinkType)
|
|
RemoveTargetLink(index int)
|
|
IsTargetIRI(index int) (ok bool)
|
|
GetTargetIRI(index int) (v *url.URL)
|
|
AppendTargetIRI(v *url.URL)
|
|
PrependTargetIRI(v *url.URL)
|
|
RemoveTargetIRI(index int)
|
|
ResultLen() (l int)
|
|
IsResultObject(index int) (ok bool)
|
|
GetResultObject(index int) (v ObjectType)
|
|
AppendResultObject(v ObjectType)
|
|
PrependResultObject(v ObjectType)
|
|
RemoveResultObject(index int)
|
|
IsResultLink(index int) (ok bool)
|
|
GetResultLink(index int) (v LinkType)
|
|
AppendResultLink(v LinkType)
|
|
PrependResultLink(v LinkType)
|
|
RemoveResultLink(index int)
|
|
IsResultIRI(index int) (ok bool)
|
|
GetResultIRI(index int) (v *url.URL)
|
|
AppendResultIRI(v *url.URL)
|
|
PrependResultIRI(v *url.URL)
|
|
RemoveResultIRI(index int)
|
|
OriginLen() (l int)
|
|
IsOriginObject(index int) (ok bool)
|
|
GetOriginObject(index int) (v ObjectType)
|
|
AppendOriginObject(v ObjectType)
|
|
PrependOriginObject(v ObjectType)
|
|
RemoveOriginObject(index int)
|
|
IsOriginLink(index int) (ok bool)
|
|
GetOriginLink(index int) (v LinkType)
|
|
AppendOriginLink(v LinkType)
|
|
PrependOriginLink(v LinkType)
|
|
RemoveOriginLink(index int)
|
|
IsOriginIRI(index int) (ok bool)
|
|
GetOriginIRI(index int) (v *url.URL)
|
|
AppendOriginIRI(v *url.URL)
|
|
PrependOriginIRI(v *url.URL)
|
|
RemoveOriginIRI(index int)
|
|
InstrumentLen() (l int)
|
|
IsInstrumentObject(index int) (ok bool)
|
|
GetInstrumentObject(index int) (v ObjectType)
|
|
AppendInstrumentObject(v ObjectType)
|
|
PrependInstrumentObject(v ObjectType)
|
|
RemoveInstrumentObject(index int)
|
|
IsInstrumentLink(index int) (ok bool)
|
|
GetInstrumentLink(index int) (v LinkType)
|
|
AppendInstrumentLink(v LinkType)
|
|
PrependInstrumentLink(v LinkType)
|
|
RemoveInstrumentLink(index int)
|
|
IsInstrumentIRI(index int) (ok bool)
|
|
GetInstrumentIRI(index int) (v *url.URL)
|
|
AppendInstrumentIRI(v *url.URL)
|
|
PrependInstrumentIRI(v *url.URL)
|
|
RemoveInstrumentIRI(index int)
|
|
IsAltitude() (ok bool)
|
|
GetAltitude() (v float64)
|
|
SetAltitude(v float64)
|
|
IsAltitudeIRI() (ok bool)
|
|
GetAltitudeIRI() (v *url.URL)
|
|
SetAltitudeIRI(v *url.URL)
|
|
AttachmentLen() (l int)
|
|
IsAttachmentObject(index int) (ok bool)
|
|
GetAttachmentObject(index int) (v ObjectType)
|
|
AppendAttachmentObject(v ObjectType)
|
|
PrependAttachmentObject(v ObjectType)
|
|
RemoveAttachmentObject(index int)
|
|
IsAttachmentLink(index int) (ok bool)
|
|
GetAttachmentLink(index int) (v LinkType)
|
|
AppendAttachmentLink(v LinkType)
|
|
PrependAttachmentLink(v LinkType)
|
|
RemoveAttachmentLink(index int)
|
|
IsAttachmentIRI(index int) (ok bool)
|
|
GetAttachmentIRI(index int) (v *url.URL)
|
|
AppendAttachmentIRI(v *url.URL)
|
|
PrependAttachmentIRI(v *url.URL)
|
|
RemoveAttachmentIRI(index int)
|
|
AttributedToLen() (l int)
|
|
IsAttributedToObject(index int) (ok bool)
|
|
GetAttributedToObject(index int) (v ObjectType)
|
|
AppendAttributedToObject(v ObjectType)
|
|
PrependAttributedToObject(v ObjectType)
|
|
RemoveAttributedToObject(index int)
|
|
IsAttributedToLink(index int) (ok bool)
|
|
GetAttributedToLink(index int) (v LinkType)
|
|
AppendAttributedToLink(v LinkType)
|
|
PrependAttributedToLink(v LinkType)
|
|
RemoveAttributedToLink(index int)
|
|
IsAttributedToIRI(index int) (ok bool)
|
|
GetAttributedToIRI(index int) (v *url.URL)
|
|
AppendAttributedToIRI(v *url.URL)
|
|
PrependAttributedToIRI(v *url.URL)
|
|
RemoveAttributedToIRI(index int)
|
|
AudienceLen() (l int)
|
|
IsAudienceObject(index int) (ok bool)
|
|
GetAudienceObject(index int) (v ObjectType)
|
|
AppendAudienceObject(v ObjectType)
|
|
PrependAudienceObject(v ObjectType)
|
|
RemoveAudienceObject(index int)
|
|
IsAudienceLink(index int) (ok bool)
|
|
GetAudienceLink(index int) (v LinkType)
|
|
AppendAudienceLink(v LinkType)
|
|
PrependAudienceLink(v LinkType)
|
|
RemoveAudienceLink(index int)
|
|
IsAudienceIRI(index int) (ok bool)
|
|
GetAudienceIRI(index int) (v *url.URL)
|
|
AppendAudienceIRI(v *url.URL)
|
|
PrependAudienceIRI(v *url.URL)
|
|
RemoveAudienceIRI(index int)
|
|
ContentLen() (l int)
|
|
IsContentString(index int) (ok bool)
|
|
GetContentString(index int) (v string)
|
|
AppendContentString(v string)
|
|
PrependContentString(v string)
|
|
RemoveContentString(index int)
|
|
IsContentLangString(index int) (ok bool)
|
|
GetContentLangString(index int) (v string)
|
|
AppendContentLangString(v string)
|
|
PrependContentLangString(v string)
|
|
RemoveContentLangString(index int)
|
|
IsContentIRI(index int) (ok bool)
|
|
GetContentIRI(index int) (v *url.URL)
|
|
AppendContentIRI(v *url.URL)
|
|
PrependContentIRI(v *url.URL)
|
|
RemoveContentIRI(index int)
|
|
ContentMapLanguages() (l []string)
|
|
GetContentMap(l string) (v string)
|
|
SetContentMap(l string, v string)
|
|
ContextLen() (l int)
|
|
IsContextObject(index int) (ok bool)
|
|
GetContextObject(index int) (v ObjectType)
|
|
AppendContextObject(v ObjectType)
|
|
PrependContextObject(v ObjectType)
|
|
RemoveContextObject(index int)
|
|
IsContextLink(index int) (ok bool)
|
|
GetContextLink(index int) (v LinkType)
|
|
AppendContextLink(v LinkType)
|
|
PrependContextLink(v LinkType)
|
|
RemoveContextLink(index int)
|
|
IsContextIRI(index int) (ok bool)
|
|
GetContextIRI(index int) (v *url.URL)
|
|
AppendContextIRI(v *url.URL)
|
|
PrependContextIRI(v *url.URL)
|
|
RemoveContextIRI(index int)
|
|
NameLen() (l int)
|
|
IsNameString(index int) (ok bool)
|
|
GetNameString(index int) (v string)
|
|
AppendNameString(v string)
|
|
PrependNameString(v string)
|
|
RemoveNameString(index int)
|
|
IsNameLangString(index int) (ok bool)
|
|
GetNameLangString(index int) (v string)
|
|
AppendNameLangString(v string)
|
|
PrependNameLangString(v string)
|
|
RemoveNameLangString(index int)
|
|
IsNameIRI(index int) (ok bool)
|
|
GetNameIRI(index int) (v *url.URL)
|
|
AppendNameIRI(v *url.URL)
|
|
PrependNameIRI(v *url.URL)
|
|
RemoveNameIRI(index int)
|
|
NameMapLanguages() (l []string)
|
|
GetNameMap(l string) (v string)
|
|
SetNameMap(l string, v string)
|
|
IsEndTime() (ok bool)
|
|
GetEndTime() (v time.Time)
|
|
SetEndTime(v time.Time)
|
|
IsEndTimeIRI() (ok bool)
|
|
GetEndTimeIRI() (v *url.URL)
|
|
SetEndTimeIRI(v *url.URL)
|
|
GeneratorLen() (l int)
|
|
IsGeneratorObject(index int) (ok bool)
|
|
GetGeneratorObject(index int) (v ObjectType)
|
|
AppendGeneratorObject(v ObjectType)
|
|
PrependGeneratorObject(v ObjectType)
|
|
RemoveGeneratorObject(index int)
|
|
IsGeneratorLink(index int) (ok bool)
|
|
GetGeneratorLink(index int) (v LinkType)
|
|
AppendGeneratorLink(v LinkType)
|
|
PrependGeneratorLink(v LinkType)
|
|
RemoveGeneratorLink(index int)
|
|
IsGeneratorIRI(index int) (ok bool)
|
|
GetGeneratorIRI(index int) (v *url.URL)
|
|
AppendGeneratorIRI(v *url.URL)
|
|
PrependGeneratorIRI(v *url.URL)
|
|
RemoveGeneratorIRI(index int)
|
|
IconLen() (l int)
|
|
IsIconImage(index int) (ok bool)
|
|
GetIconImage(index int) (v ImageType)
|
|
AppendIconImage(v ImageType)
|
|
PrependIconImage(v ImageType)
|
|
RemoveIconImage(index int)
|
|
IsIconLink(index int) (ok bool)
|
|
GetIconLink(index int) (v LinkType)
|
|
AppendIconLink(v LinkType)
|
|
PrependIconLink(v LinkType)
|
|
RemoveIconLink(index int)
|
|
IsIconIRI(index int) (ok bool)
|
|
GetIconIRI(index int) (v *url.URL)
|
|
AppendIconIRI(v *url.URL)
|
|
PrependIconIRI(v *url.URL)
|
|
RemoveIconIRI(index int)
|
|
HasId() (ok bool)
|
|
GetId() (v *url.URL)
|
|
SetId(v *url.URL)
|
|
HasUnknownId() (ok bool)
|
|
GetUnknownId() (v interface{})
|
|
SetUnknownId(i interface{})
|
|
ImageLen() (l int)
|
|
IsImageImage(index int) (ok bool)
|
|
GetImageImage(index int) (v ImageType)
|
|
AppendImageImage(v ImageType)
|
|
PrependImageImage(v ImageType)
|
|
RemoveImageImage(index int)
|
|
IsImageLink(index int) (ok bool)
|
|
GetImageLink(index int) (v LinkType)
|
|
AppendImageLink(v LinkType)
|
|
PrependImageLink(v LinkType)
|
|
RemoveImageLink(index int)
|
|
IsImageIRI(index int) (ok bool)
|
|
GetImageIRI(index int) (v *url.URL)
|
|
AppendImageIRI(v *url.URL)
|
|
PrependImageIRI(v *url.URL)
|
|
RemoveImageIRI(index int)
|
|
InReplyToLen() (l int)
|
|
IsInReplyToObject(index int) (ok bool)
|
|
GetInReplyToObject(index int) (v ObjectType)
|
|
AppendInReplyToObject(v ObjectType)
|
|
PrependInReplyToObject(v ObjectType)
|
|
RemoveInReplyToObject(index int)
|
|
IsInReplyToLink(index int) (ok bool)
|
|
GetInReplyToLink(index int) (v LinkType)
|
|
AppendInReplyToLink(v LinkType)
|
|
PrependInReplyToLink(v LinkType)
|
|
RemoveInReplyToLink(index int)
|
|
IsInReplyToIRI(index int) (ok bool)
|
|
GetInReplyToIRI(index int) (v *url.URL)
|
|
AppendInReplyToIRI(v *url.URL)
|
|
PrependInReplyToIRI(v *url.URL)
|
|
RemoveInReplyToIRI(index int)
|
|
LocationLen() (l int)
|
|
IsLocationObject(index int) (ok bool)
|
|
GetLocationObject(index int) (v ObjectType)
|
|
AppendLocationObject(v ObjectType)
|
|
PrependLocationObject(v ObjectType)
|
|
RemoveLocationObject(index int)
|
|
IsLocationLink(index int) (ok bool)
|
|
GetLocationLink(index int) (v LinkType)
|
|
AppendLocationLink(v LinkType)
|
|
PrependLocationLink(v LinkType)
|
|
RemoveLocationLink(index int)
|
|
IsLocationIRI(index int) (ok bool)
|
|
GetLocationIRI(index int) (v *url.URL)
|
|
AppendLocationIRI(v *url.URL)
|
|
PrependLocationIRI(v *url.URL)
|
|
RemoveLocationIRI(index int)
|
|
PreviewLen() (l int)
|
|
IsPreviewObject(index int) (ok bool)
|
|
GetPreviewObject(index int) (v ObjectType)
|
|
AppendPreviewObject(v ObjectType)
|
|
PrependPreviewObject(v ObjectType)
|
|
RemovePreviewObject(index int)
|
|
IsPreviewLink(index int) (ok bool)
|
|
GetPreviewLink(index int) (v LinkType)
|
|
AppendPreviewLink(v LinkType)
|
|
PrependPreviewLink(v LinkType)
|
|
RemovePreviewLink(index int)
|
|
IsPreviewIRI(index int) (ok bool)
|
|
GetPreviewIRI(index int) (v *url.URL)
|
|
AppendPreviewIRI(v *url.URL)
|
|
PrependPreviewIRI(v *url.URL)
|
|
RemovePreviewIRI(index int)
|
|
IsPublished() (ok bool)
|
|
GetPublished() (v time.Time)
|
|
SetPublished(v time.Time)
|
|
IsPublishedIRI() (ok bool)
|
|
GetPublishedIRI() (v *url.URL)
|
|
SetPublishedIRI(v *url.URL)
|
|
IsReplies() (ok bool)
|
|
GetReplies() (v CollectionType)
|
|
SetReplies(v CollectionType)
|
|
IsRepliesIRI() (ok bool)
|
|
GetRepliesIRI() (v *url.URL)
|
|
SetRepliesIRI(v *url.URL)
|
|
IsStartTime() (ok bool)
|
|
GetStartTime() (v time.Time)
|
|
SetStartTime(v time.Time)
|
|
IsStartTimeIRI() (ok bool)
|
|
GetStartTimeIRI() (v *url.URL)
|
|
SetStartTimeIRI(v *url.URL)
|
|
SummaryLen() (l int)
|
|
IsSummaryString(index int) (ok bool)
|
|
GetSummaryString(index int) (v string)
|
|
AppendSummaryString(v string)
|
|
PrependSummaryString(v string)
|
|
RemoveSummaryString(index int)
|
|
IsSummaryLangString(index int) (ok bool)
|
|
GetSummaryLangString(index int) (v string)
|
|
AppendSummaryLangString(v string)
|
|
PrependSummaryLangString(v string)
|
|
RemoveSummaryLangString(index int)
|
|
IsSummaryIRI(index int) (ok bool)
|
|
GetSummaryIRI(index int) (v *url.URL)
|
|
AppendSummaryIRI(v *url.URL)
|
|
PrependSummaryIRI(v *url.URL)
|
|
RemoveSummaryIRI(index int)
|
|
SummaryMapLanguages() (l []string)
|
|
GetSummaryMap(l string) (v string)
|
|
SetSummaryMap(l string, v string)
|
|
TagLen() (l int)
|
|
IsTagObject(index int) (ok bool)
|
|
GetTagObject(index int) (v ObjectType)
|
|
AppendTagObject(v ObjectType)
|
|
PrependTagObject(v ObjectType)
|
|
RemoveTagObject(index int)
|
|
IsTagLink(index int) (ok bool)
|
|
GetTagLink(index int) (v LinkType)
|
|
AppendTagLink(v LinkType)
|
|
PrependTagLink(v LinkType)
|
|
RemoveTagLink(index int)
|
|
IsTagIRI(index int) (ok bool)
|
|
GetTagIRI(index int) (v *url.URL)
|
|
AppendTagIRI(v *url.URL)
|
|
PrependTagIRI(v *url.URL)
|
|
RemoveTagIRI(index int)
|
|
TypeLen() (l int)
|
|
GetType(index int) (v interface{})
|
|
AppendType(v interface{})
|
|
PrependType(v interface{})
|
|
RemoveType(index int)
|
|
IsUpdated() (ok bool)
|
|
GetUpdated() (v time.Time)
|
|
SetUpdated(v time.Time)
|
|
IsUpdatedIRI() (ok bool)
|
|
GetUpdatedIRI() (v *url.URL)
|
|
SetUpdatedIRI(v *url.URL)
|
|
UrlLen() (l int)
|
|
IsUrlAnyURI(index int) (ok bool)
|
|
GetUrlAnyURI(index int) (v *url.URL)
|
|
AppendUrlAnyURI(v *url.URL)
|
|
PrependUrlAnyURI(v *url.URL)
|
|
RemoveUrlAnyURI(index int)
|
|
IsUrlLink(index int) (ok bool)
|
|
GetUrlLink(index int) (v LinkType)
|
|
AppendUrlLink(v LinkType)
|
|
PrependUrlLink(v LinkType)
|
|
RemoveUrlLink(index int)
|
|
ToLen() (l int)
|
|
IsToObject(index int) (ok bool)
|
|
GetToObject(index int) (v ObjectType)
|
|
AppendToObject(v ObjectType)
|
|
PrependToObject(v ObjectType)
|
|
RemoveToObject(index int)
|
|
IsToLink(index int) (ok bool)
|
|
GetToLink(index int) (v LinkType)
|
|
AppendToLink(v LinkType)
|
|
PrependToLink(v LinkType)
|
|
RemoveToLink(index int)
|
|
IsToIRI(index int) (ok bool)
|
|
GetToIRI(index int) (v *url.URL)
|
|
AppendToIRI(v *url.URL)
|
|
PrependToIRI(v *url.URL)
|
|
RemoveToIRI(index int)
|
|
BtoLen() (l int)
|
|
IsBtoObject(index int) (ok bool)
|
|
GetBtoObject(index int) (v ObjectType)
|
|
AppendBtoObject(v ObjectType)
|
|
PrependBtoObject(v ObjectType)
|
|
RemoveBtoObject(index int)
|
|
IsBtoLink(index int) (ok bool)
|
|
GetBtoLink(index int) (v LinkType)
|
|
AppendBtoLink(v LinkType)
|
|
PrependBtoLink(v LinkType)
|
|
RemoveBtoLink(index int)
|
|
IsBtoIRI(index int) (ok bool)
|
|
GetBtoIRI(index int) (v *url.URL)
|
|
AppendBtoIRI(v *url.URL)
|
|
PrependBtoIRI(v *url.URL)
|
|
RemoveBtoIRI(index int)
|
|
CcLen() (l int)
|
|
IsCcObject(index int) (ok bool)
|
|
GetCcObject(index int) (v ObjectType)
|
|
AppendCcObject(v ObjectType)
|
|
PrependCcObject(v ObjectType)
|
|
RemoveCcObject(index int)
|
|
IsCcLink(index int) (ok bool)
|
|
GetCcLink(index int) (v LinkType)
|
|
AppendCcLink(v LinkType)
|
|
PrependCcLink(v LinkType)
|
|
RemoveCcLink(index int)
|
|
IsCcIRI(index int) (ok bool)
|
|
GetCcIRI(index int) (v *url.URL)
|
|
AppendCcIRI(v *url.URL)
|
|
PrependCcIRI(v *url.URL)
|
|
RemoveCcIRI(index int)
|
|
BccLen() (l int)
|
|
IsBccObject(index int) (ok bool)
|
|
GetBccObject(index int) (v ObjectType)
|
|
AppendBccObject(v ObjectType)
|
|
PrependBccObject(v ObjectType)
|
|
RemoveBccObject(index int)
|
|
IsBccLink(index int) (ok bool)
|
|
GetBccLink(index int) (v LinkType)
|
|
AppendBccLink(v LinkType)
|
|
PrependBccLink(v LinkType)
|
|
RemoveBccLink(index int)
|
|
IsBccIRI(index int) (ok bool)
|
|
GetBccIRI(index int) (v *url.URL)
|
|
AppendBccIRI(v *url.URL)
|
|
PrependBccIRI(v *url.URL)
|
|
RemoveBccIRI(index int)
|
|
IsMediaType() (ok bool)
|
|
GetMediaType() (v string)
|
|
SetMediaType(v string)
|
|
IsMediaTypeIRI() (ok bool)
|
|
GetMediaTypeIRI() (v *url.URL)
|
|
SetMediaTypeIRI(v *url.URL)
|
|
IsDuration() (ok bool)
|
|
GetDuration() (v time.Duration)
|
|
SetDuration(v time.Duration)
|
|
IsDurationIRI() (ok bool)
|
|
GetDurationIRI() (v *url.URL)
|
|
SetDurationIRI(v *url.URL)
|
|
IsSource() (ok bool)
|
|
GetSource() (v ObjectType)
|
|
SetSource(v ObjectType)
|
|
IsSourceIRI() (ok bool)
|
|
GetSourceIRI() (v *url.URL)
|
|
SetSourceIRI(v *url.URL)
|
|
IsInboxOrderedCollection() (ok bool)
|
|
GetInboxOrderedCollection() (v OrderedCollectionType)
|
|
SetInboxOrderedCollection(v OrderedCollectionType)
|
|
IsInboxAnyURI() (ok bool)
|
|
GetInboxAnyURI() (v *url.URL)
|
|
SetInboxAnyURI(v *url.URL)
|
|
IsOutboxOrderedCollection() (ok bool)
|
|
GetOutboxOrderedCollection() (v OrderedCollectionType)
|
|
SetOutboxOrderedCollection(v OrderedCollectionType)
|
|
IsOutboxAnyURI() (ok bool)
|
|
GetOutboxAnyURI() (v *url.URL)
|
|
SetOutboxAnyURI(v *url.URL)
|
|
IsFollowingCollection() (ok bool)
|
|
GetFollowingCollection() (v CollectionType)
|
|
SetFollowingCollection(v CollectionType)
|
|
IsFollowingOrderedCollection() (ok bool)
|
|
GetFollowingOrderedCollection() (v OrderedCollectionType)
|
|
SetFollowingOrderedCollection(v OrderedCollectionType)
|
|
IsFollowingAnyURI() (ok bool)
|
|
GetFollowingAnyURI() (v *url.URL)
|
|
SetFollowingAnyURI(v *url.URL)
|
|
IsFollowersCollection() (ok bool)
|
|
GetFollowersCollection() (v CollectionType)
|
|
SetFollowersCollection(v CollectionType)
|
|
IsFollowersOrderedCollection() (ok bool)
|
|
GetFollowersOrderedCollection() (v OrderedCollectionType)
|
|
SetFollowersOrderedCollection(v OrderedCollectionType)
|
|
IsFollowersAnyURI() (ok bool)
|
|
GetFollowersAnyURI() (v *url.URL)
|
|
SetFollowersAnyURI(v *url.URL)
|
|
IsLikedCollection() (ok bool)
|
|
GetLikedCollection() (v CollectionType)
|
|
SetLikedCollection(v CollectionType)
|
|
IsLikedOrderedCollection() (ok bool)
|
|
GetLikedOrderedCollection() (v OrderedCollectionType)
|
|
SetLikedOrderedCollection(v OrderedCollectionType)
|
|
IsLikedAnyURI() (ok bool)
|
|
GetLikedAnyURI() (v *url.URL)
|
|
SetLikedAnyURI(v *url.URL)
|
|
IsLikesCollection() (ok bool)
|
|
GetLikesCollection() (v CollectionType)
|
|
SetLikesCollection(v CollectionType)
|
|
IsLikesOrderedCollection() (ok bool)
|
|
GetLikesOrderedCollection() (v OrderedCollectionType)
|
|
SetLikesOrderedCollection(v OrderedCollectionType)
|
|
IsLikesAnyURI() (ok bool)
|
|
GetLikesAnyURI() (v *url.URL)
|
|
SetLikesAnyURI(v *url.URL)
|
|
StreamsLen() (l int)
|
|
GetStreams(index int) (v *url.URL)
|
|
AppendStreams(v *url.URL)
|
|
PrependStreams(v *url.URL)
|
|
RemoveStreams(index int)
|
|
HasUnknownStreams() (ok bool)
|
|
GetUnknownStreams() (v interface{})
|
|
SetUnknownStreams(i interface{})
|
|
IsPreferredUsername() (ok bool)
|
|
GetPreferredUsername() (v string)
|
|
SetPreferredUsername(v string)
|
|
IsPreferredUsernameIRI() (ok bool)
|
|
GetPreferredUsernameIRI() (v *url.URL)
|
|
SetPreferredUsernameIRI(v *url.URL)
|
|
PreferredUsernameMapLanguages() (l []string)
|
|
GetPreferredUsernameMap(l string) (v string)
|
|
SetPreferredUsernameMap(l string, v string)
|
|
IsEndpoints() (ok bool)
|
|
GetEndpoints() (v ObjectType)
|
|
SetEndpoints(v ObjectType)
|
|
IsEndpointsIRI() (ok bool)
|
|
GetEndpointsIRI() (v *url.URL)
|
|
SetEndpointsIRI(v *url.URL)
|
|
HasProxyUrl() (ok bool)
|
|
GetProxyUrl() (v *url.URL)
|
|
SetProxyUrl(v *url.URL)
|
|
HasUnknownProxyUrl() (ok bool)
|
|
GetUnknownProxyUrl() (v interface{})
|
|
SetUnknownProxyUrl(i interface{})
|
|
HasOauthAuthorizationEndpoint() (ok bool)
|
|
GetOauthAuthorizationEndpoint() (v *url.URL)
|
|
SetOauthAuthorizationEndpoint(v *url.URL)
|
|
HasUnknownOauthAuthorizationEndpoint() (ok bool)
|
|
GetUnknownOauthAuthorizationEndpoint() (v interface{})
|
|
SetUnknownOauthAuthorizationEndpoint(i interface{})
|
|
HasOauthTokenEndpoint() (ok bool)
|
|
GetOauthTokenEndpoint() (v *url.URL)
|
|
SetOauthTokenEndpoint(v *url.URL)
|
|
HasUnknownOauthTokenEndpoint() (ok bool)
|
|
GetUnknownOauthTokenEndpoint() (v interface{})
|
|
SetUnknownOauthTokenEndpoint(i interface{})
|
|
HasProvideClientKey() (ok bool)
|
|
GetProvideClientKey() (v *url.URL)
|
|
SetProvideClientKey(v *url.URL)
|
|
HasUnknownProvideClientKey() (ok bool)
|
|
GetUnknownProvideClientKey() (v interface{})
|
|
SetUnknownProvideClientKey(i interface{})
|
|
HasSignClientKey() (ok bool)
|
|
GetSignClientKey() (v *url.URL)
|
|
SetSignClientKey(v *url.URL)
|
|
HasUnknownSignClientKey() (ok bool)
|
|
GetUnknownSignClientKey() (v interface{})
|
|
SetUnknownSignClientKey(i interface{})
|
|
HasSharedInbox() (ok bool)
|
|
GetSharedInbox() (v *url.URL)
|
|
SetSharedInbox(v *url.URL)
|
|
HasUnknownSharedInbox() (ok bool)
|
|
GetUnknownSharedInbox() (v interface{})
|
|
SetUnknownSharedInbox(i interface{})
|
|
}
|
|
|
|
// Indicates that the actor has joined the object. The target and origin typically have no defined meaning.
|
|
type Join struct {
|
|
// An unknown value.
|
|
unknown_ map[string]interface{}
|
|
// The 'actor' value could have multiple types and values
|
|
actor []*actorJoinIntermediateType
|
|
// The 'object' value could have multiple types and values
|
|
object []*objectJoinIntermediateType
|
|
// The 'target' value could have multiple types and values
|
|
target []*targetJoinIntermediateType
|
|
// The 'result' value could have multiple types and values
|
|
result []*resultJoinIntermediateType
|
|
// The 'origin' value could have multiple types and values
|
|
origin []*originJoinIntermediateType
|
|
// The 'instrument' value could have multiple types and values
|
|
instrument []*instrumentJoinIntermediateType
|
|
// The functional 'altitude' value could have multiple types, but only a single value
|
|
altitude *altitudeJoinIntermediateType
|
|
// The 'attachment' value could have multiple types and values
|
|
attachment []*attachmentJoinIntermediateType
|
|
// The 'attributedTo' value could have multiple types and values
|
|
attributedTo []*attributedToJoinIntermediateType
|
|
// The 'audience' value could have multiple types and values
|
|
audience []*audienceJoinIntermediateType
|
|
// The 'content' value could have multiple types and values
|
|
content []*contentJoinIntermediateType
|
|
// The 'contentMap' value holds language-specific values for property 'content'
|
|
contentMap map[string]string
|
|
// The 'context' value could have multiple types and values
|
|
context []*contextJoinIntermediateType
|
|
// The 'name' value could have multiple types and values
|
|
name []*nameJoinIntermediateType
|
|
// The 'nameMap' value holds language-specific values for property 'name'
|
|
nameMap map[string]string
|
|
// The functional 'endTime' value could have multiple types, but only a single value
|
|
endTime *endTimeJoinIntermediateType
|
|
// The 'generator' value could have multiple types and values
|
|
generator []*generatorJoinIntermediateType
|
|
// The 'icon' value could have multiple types and values
|
|
icon []*iconJoinIntermediateType
|
|
// The functional 'id' value holds a single type and a single value
|
|
id *url.URL
|
|
// The 'image' value could have multiple types and values
|
|
image []*imageJoinIntermediateType
|
|
// The 'inReplyTo' value could have multiple types and values
|
|
inReplyTo []*inReplyToJoinIntermediateType
|
|
// The 'location' value could have multiple types and values
|
|
location []*locationJoinIntermediateType
|
|
// The 'preview' value could have multiple types and values
|
|
preview []*previewJoinIntermediateType
|
|
// The functional 'published' value could have multiple types, but only a single value
|
|
published *publishedJoinIntermediateType
|
|
// The functional 'replies' value could have multiple types, but only a single value
|
|
replies *repliesJoinIntermediateType
|
|
// The functional 'startTime' value could have multiple types, but only a single value
|
|
startTime *startTimeJoinIntermediateType
|
|
// The 'summary' value could have multiple types and values
|
|
summary []*summaryJoinIntermediateType
|
|
// The 'summaryMap' value holds language-specific values for property 'summary'
|
|
summaryMap map[string]string
|
|
// The 'tag' value could have multiple types and values
|
|
tag []*tagJoinIntermediateType
|
|
// The 'type' value can hold any type and any number of values
|
|
typeName []interface{}
|
|
// The functional 'updated' value could have multiple types, but only a single value
|
|
updated *updatedJoinIntermediateType
|
|
// The 'url' value could have multiple types and values
|
|
url []*urlJoinIntermediateType
|
|
// The 'to' value could have multiple types and values
|
|
to []*toJoinIntermediateType
|
|
// The 'bto' value could have multiple types and values
|
|
bto []*btoJoinIntermediateType
|
|
// The 'cc' value could have multiple types and values
|
|
cc []*ccJoinIntermediateType
|
|
// The 'bcc' value could have multiple types and values
|
|
bcc []*bccJoinIntermediateType
|
|
// The functional 'mediaType' value could have multiple types, but only a single value
|
|
mediaType *mediaTypeJoinIntermediateType
|
|
// The functional 'duration' value could have multiple types, but only a single value
|
|
duration *durationJoinIntermediateType
|
|
// The functional 'source' value could have multiple types, but only a single value
|
|
source *sourceJoinIntermediateType
|
|
// The functional 'inbox' value could have multiple types, but only a single value
|
|
inbox *inboxJoinIntermediateType
|
|
// The functional 'outbox' value could have multiple types, but only a single value
|
|
outbox *outboxJoinIntermediateType
|
|
// The functional 'following' value could have multiple types, but only a single value
|
|
following *followingJoinIntermediateType
|
|
// The functional 'followers' value could have multiple types, but only a single value
|
|
followers *followersJoinIntermediateType
|
|
// The functional 'liked' value could have multiple types, but only a single value
|
|
liked *likedJoinIntermediateType
|
|
// The functional 'likes' value could have multiple types, but only a single value
|
|
likes *likesJoinIntermediateType
|
|
// The 'streams' value holds a single type and any number of values
|
|
streams []*url.URL
|
|
// The functional 'preferredUsername' value could have multiple types, but only a single value
|
|
preferredUsername *preferredUsernameJoinIntermediateType
|
|
// The 'preferredUsernameMap' value holds language-specific values for property 'preferredUsername'
|
|
preferredUsernameMap map[string]string
|
|
// The functional 'endpoints' value could have multiple types, but only a single value
|
|
endpoints *endpointsJoinIntermediateType
|
|
// The functional 'proxyUrl' value holds a single type and a single value
|
|
proxyUrl *url.URL
|
|
// The functional 'oauthAuthorizationEndpoint' value holds a single type and a single value
|
|
oauthAuthorizationEndpoint *url.URL
|
|
// The functional 'oauthTokenEndpoint' value holds a single type and a single value
|
|
oauthTokenEndpoint *url.URL
|
|
// The functional 'provideClientKey' value holds a single type and a single value
|
|
provideClientKey *url.URL
|
|
// The functional 'signClientKey' value holds a single type and a single value
|
|
signClientKey *url.URL
|
|
// The functional 'sharedInbox' value holds a single type and a single value
|
|
sharedInbox *url.URL
|
|
}
|
|
|
|
// ActorLen determines the number of elements able to be used for the IsActorObject, GetActorObject, and RemoveActorObject functions
|
|
func (t *Join) ActorLen() (l int) {
|
|
return len(t.actor)
|
|
|
|
}
|
|
|
|
// IsActorObject determines whether the call to GetActorObject is safe for the specified index
|
|
func (t *Join) IsActorObject(index int) (ok bool) {
|
|
return t.actor[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetActorObject returns the value safely if IsActorObject returned true for the specified index
|
|
func (t *Join) GetActorObject(index int) (v ObjectType) {
|
|
return t.actor[index].Object
|
|
|
|
}
|
|
|
|
// AppendActorObject adds to the back of actor a ObjectType type
|
|
func (t *Join) AppendActorObject(v ObjectType) {
|
|
t.actor = append(t.actor, &actorJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependActorObject adds to the front of actor a ObjectType type
|
|
func (t *Join) PrependActorObject(v ObjectType) {
|
|
t.actor = append([]*actorJoinIntermediateType{&actorJoinIntermediateType{Object: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorObject deletes the value from the specified index
|
|
func (t *Join) RemoveActorObject(index int) {
|
|
copy(t.actor[index:], t.actor[index+1:])
|
|
t.actor[len(t.actor)-1] = nil
|
|
t.actor = t.actor[:len(t.actor)-1]
|
|
|
|
}
|
|
|
|
// IsActorLink determines whether the call to GetActorLink is safe for the specified index
|
|
func (t *Join) IsActorLink(index int) (ok bool) {
|
|
return t.actor[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetActorLink returns the value safely if IsActorLink returned true for the specified index
|
|
func (t *Join) GetActorLink(index int) (v LinkType) {
|
|
return t.actor[index].Link
|
|
|
|
}
|
|
|
|
// AppendActorLink adds to the back of actor a LinkType type
|
|
func (t *Join) AppendActorLink(v LinkType) {
|
|
t.actor = append(t.actor, &actorJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependActorLink adds to the front of actor a LinkType type
|
|
func (t *Join) PrependActorLink(v LinkType) {
|
|
t.actor = append([]*actorJoinIntermediateType{&actorJoinIntermediateType{Link: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorLink deletes the value from the specified index
|
|
func (t *Join) RemoveActorLink(index int) {
|
|
copy(t.actor[index:], t.actor[index+1:])
|
|
t.actor[len(t.actor)-1] = nil
|
|
t.actor = t.actor[:len(t.actor)-1]
|
|
|
|
}
|
|
|
|
// IsActorIRI determines whether the call to GetActorIRI is safe for the specified index
|
|
func (t *Join) IsActorIRI(index int) (ok bool) {
|
|
return t.actor[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetActorIRI returns the value safely if IsActorIRI returned true for the specified index
|
|
func (t *Join) GetActorIRI(index int) (v *url.URL) {
|
|
return t.actor[index].IRI
|
|
|
|
}
|
|
|
|
// AppendActorIRI adds to the back of actor a *url.URL type
|
|
func (t *Join) AppendActorIRI(v *url.URL) {
|
|
t.actor = append(t.actor, &actorJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependActorIRI adds to the front of actor a *url.URL type
|
|
func (t *Join) PrependActorIRI(v *url.URL) {
|
|
t.actor = append([]*actorJoinIntermediateType{&actorJoinIntermediateType{IRI: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorIRI deletes the value from the specified index
|
|
func (t *Join) RemoveActorIRI(index int) {
|
|
copy(t.actor[index:], t.actor[index+1:])
|
|
t.actor[len(t.actor)-1] = nil
|
|
t.actor = t.actor[:len(t.actor)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownActor determines whether the call to GetUnknownActor is safe
|
|
func (t *Join) HasUnknownActor() (ok bool) {
|
|
return t.actor != nil && t.actor[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownActor returns the unknown value for actor
|
|
func (t *Join) GetUnknownActor() (v interface{}) {
|
|
return t.actor[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownActor sets the unknown value of actor
|
|
func (t *Join) SetUnknownActor(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &actorJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.actor = append(t.actor, tmp)
|
|
|
|
}
|
|
|
|
// ObjectLen determines the number of elements able to be used for the IsObject, GetObject, and RemoveObject functions
|
|
func (t *Join) ObjectLen() (l int) {
|
|
return len(t.object)
|
|
|
|
}
|
|
|
|
// IsObject determines whether the call to GetObject is safe for the specified index
|
|
func (t *Join) IsObject(index int) (ok bool) {
|
|
return t.object[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetObject returns the value safely if IsObject returned true for the specified index
|
|
func (t *Join) GetObject(index int) (v ObjectType) {
|
|
return t.object[index].Object
|
|
|
|
}
|
|
|
|
// AppendObject adds to the back of object a ObjectType type
|
|
func (t *Join) AppendObject(v ObjectType) {
|
|
t.object = append(t.object, &objectJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependObject adds to the front of object a ObjectType type
|
|
func (t *Join) PrependObject(v ObjectType) {
|
|
t.object = append([]*objectJoinIntermediateType{&objectJoinIntermediateType{Object: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObject deletes the value from the specified index
|
|
func (t *Join) RemoveObject(index int) {
|
|
copy(t.object[index:], t.object[index+1:])
|
|
t.object[len(t.object)-1] = nil
|
|
t.object = t.object[:len(t.object)-1]
|
|
|
|
}
|
|
|
|
// IsObjectIRI determines whether the call to GetObjectIRI is safe for the specified index
|
|
func (t *Join) IsObjectIRI(index int) (ok bool) {
|
|
return t.object[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetObjectIRI returns the value safely if IsObjectIRI returned true for the specified index
|
|
func (t *Join) GetObjectIRI(index int) (v *url.URL) {
|
|
return t.object[index].IRI
|
|
|
|
}
|
|
|
|
// AppendObjectIRI adds to the back of object a *url.URL type
|
|
func (t *Join) AppendObjectIRI(v *url.URL) {
|
|
t.object = append(t.object, &objectJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependObjectIRI adds to the front of object a *url.URL type
|
|
func (t *Join) PrependObjectIRI(v *url.URL) {
|
|
t.object = append([]*objectJoinIntermediateType{&objectJoinIntermediateType{IRI: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObjectIRI deletes the value from the specified index
|
|
func (t *Join) RemoveObjectIRI(index int) {
|
|
copy(t.object[index:], t.object[index+1:])
|
|
t.object[len(t.object)-1] = nil
|
|
t.object = t.object[:len(t.object)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownObject determines whether the call to GetUnknownObject is safe
|
|
func (t *Join) HasUnknownObject() (ok bool) {
|
|
return t.object != nil && t.object[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownObject returns the unknown value for object
|
|
func (t *Join) GetUnknownObject() (v interface{}) {
|
|
return t.object[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownObject sets the unknown value of object
|
|
func (t *Join) SetUnknownObject(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &objectJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.object = append(t.object, tmp)
|
|
|
|
}
|
|
|
|
// TargetLen determines the number of elements able to be used for the IsTargetObject, GetTargetObject, and RemoveTargetObject functions
|
|
func (t *Join) TargetLen() (l int) {
|
|
return len(t.target)
|
|
|
|
}
|
|
|
|
// IsTargetObject determines whether the call to GetTargetObject is safe for the specified index
|
|
func (t *Join) IsTargetObject(index int) (ok bool) {
|
|
return t.target[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetTargetObject returns the value safely if IsTargetObject returned true for the specified index
|
|
func (t *Join) GetTargetObject(index int) (v ObjectType) {
|
|
return t.target[index].Object
|
|
|
|
}
|
|
|
|
// AppendTargetObject adds to the back of target a ObjectType type
|
|
func (t *Join) AppendTargetObject(v ObjectType) {
|
|
t.target = append(t.target, &targetJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTargetObject adds to the front of target a ObjectType type
|
|
func (t *Join) PrependTargetObject(v ObjectType) {
|
|
t.target = append([]*targetJoinIntermediateType{&targetJoinIntermediateType{Object: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetObject deletes the value from the specified index
|
|
func (t *Join) RemoveTargetObject(index int) {
|
|
copy(t.target[index:], t.target[index+1:])
|
|
t.target[len(t.target)-1] = nil
|
|
t.target = t.target[:len(t.target)-1]
|
|
|
|
}
|
|
|
|
// IsTargetLink determines whether the call to GetTargetLink is safe for the specified index
|
|
func (t *Join) IsTargetLink(index int) (ok bool) {
|
|
return t.target[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetTargetLink returns the value safely if IsTargetLink returned true for the specified index
|
|
func (t *Join) GetTargetLink(index int) (v LinkType) {
|
|
return t.target[index].Link
|
|
|
|
}
|
|
|
|
// AppendTargetLink adds to the back of target a LinkType type
|
|
func (t *Join) AppendTargetLink(v LinkType) {
|
|
t.target = append(t.target, &targetJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTargetLink adds to the front of target a LinkType type
|
|
func (t *Join) PrependTargetLink(v LinkType) {
|
|
t.target = append([]*targetJoinIntermediateType{&targetJoinIntermediateType{Link: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetLink deletes the value from the specified index
|
|
func (t *Join) RemoveTargetLink(index int) {
|
|
copy(t.target[index:], t.target[index+1:])
|
|
t.target[len(t.target)-1] = nil
|
|
t.target = t.target[:len(t.target)-1]
|
|
|
|
}
|
|
|
|
// IsTargetIRI determines whether the call to GetTargetIRI is safe for the specified index
|
|
func (t *Join) IsTargetIRI(index int) (ok bool) {
|
|
return t.target[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetTargetIRI returns the value safely if IsTargetIRI returned true for the specified index
|
|
func (t *Join) GetTargetIRI(index int) (v *url.URL) {
|
|
return t.target[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTargetIRI adds to the back of target a *url.URL type
|
|
func (t *Join) AppendTargetIRI(v *url.URL) {
|
|
t.target = append(t.target, &targetJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTargetIRI adds to the front of target a *url.URL type
|
|
func (t *Join) PrependTargetIRI(v *url.URL) {
|
|
t.target = append([]*targetJoinIntermediateType{&targetJoinIntermediateType{IRI: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetIRI deletes the value from the specified index
|
|
func (t *Join) RemoveTargetIRI(index int) {
|
|
copy(t.target[index:], t.target[index+1:])
|
|
t.target[len(t.target)-1] = nil
|
|
t.target = t.target[:len(t.target)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownTarget determines whether the call to GetUnknownTarget is safe
|
|
func (t *Join) HasUnknownTarget() (ok bool) {
|
|
return t.target != nil && t.target[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTarget returns the unknown value for target
|
|
func (t *Join) GetUnknownTarget() (v interface{}) {
|
|
return t.target[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTarget sets the unknown value of target
|
|
func (t *Join) SetUnknownTarget(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &targetJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.target = append(t.target, tmp)
|
|
|
|
}
|
|
|
|
// ResultLen determines the number of elements able to be used for the IsResultObject, GetResultObject, and RemoveResultObject functions
|
|
func (t *Join) ResultLen() (l int) {
|
|
return len(t.result)
|
|
|
|
}
|
|
|
|
// IsResultObject determines whether the call to GetResultObject is safe for the specified index
|
|
func (t *Join) IsResultObject(index int) (ok bool) {
|
|
return t.result[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetResultObject returns the value safely if IsResultObject returned true for the specified index
|
|
func (t *Join) GetResultObject(index int) (v ObjectType) {
|
|
return t.result[index].Object
|
|
|
|
}
|
|
|
|
// AppendResultObject adds to the back of result a ObjectType type
|
|
func (t *Join) AppendResultObject(v ObjectType) {
|
|
t.result = append(t.result, &resultJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependResultObject adds to the front of result a ObjectType type
|
|
func (t *Join) PrependResultObject(v ObjectType) {
|
|
t.result = append([]*resultJoinIntermediateType{&resultJoinIntermediateType{Object: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultObject deletes the value from the specified index
|
|
func (t *Join) RemoveResultObject(index int) {
|
|
copy(t.result[index:], t.result[index+1:])
|
|
t.result[len(t.result)-1] = nil
|
|
t.result = t.result[:len(t.result)-1]
|
|
|
|
}
|
|
|
|
// IsResultLink determines whether the call to GetResultLink is safe for the specified index
|
|
func (t *Join) IsResultLink(index int) (ok bool) {
|
|
return t.result[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetResultLink returns the value safely if IsResultLink returned true for the specified index
|
|
func (t *Join) GetResultLink(index int) (v LinkType) {
|
|
return t.result[index].Link
|
|
|
|
}
|
|
|
|
// AppendResultLink adds to the back of result a LinkType type
|
|
func (t *Join) AppendResultLink(v LinkType) {
|
|
t.result = append(t.result, &resultJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependResultLink adds to the front of result a LinkType type
|
|
func (t *Join) PrependResultLink(v LinkType) {
|
|
t.result = append([]*resultJoinIntermediateType{&resultJoinIntermediateType{Link: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultLink deletes the value from the specified index
|
|
func (t *Join) RemoveResultLink(index int) {
|
|
copy(t.result[index:], t.result[index+1:])
|
|
t.result[len(t.result)-1] = nil
|
|
t.result = t.result[:len(t.result)-1]
|
|
|
|
}
|
|
|
|
// IsResultIRI determines whether the call to GetResultIRI is safe for the specified index
|
|
func (t *Join) IsResultIRI(index int) (ok bool) {
|
|
return t.result[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetResultIRI returns the value safely if IsResultIRI returned true for the specified index
|
|
func (t *Join) GetResultIRI(index int) (v *url.URL) {
|
|
return t.result[index].IRI
|
|
|
|
}
|
|
|
|
// AppendResultIRI adds to the back of result a *url.URL type
|
|
func (t *Join) AppendResultIRI(v *url.URL) {
|
|
t.result = append(t.result, &resultJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependResultIRI adds to the front of result a *url.URL type
|
|
func (t *Join) PrependResultIRI(v *url.URL) {
|
|
t.result = append([]*resultJoinIntermediateType{&resultJoinIntermediateType{IRI: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultIRI deletes the value from the specified index
|
|
func (t *Join) RemoveResultIRI(index int) {
|
|
copy(t.result[index:], t.result[index+1:])
|
|
t.result[len(t.result)-1] = nil
|
|
t.result = t.result[:len(t.result)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownResult determines whether the call to GetUnknownResult is safe
|
|
func (t *Join) HasUnknownResult() (ok bool) {
|
|
return t.result != nil && t.result[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownResult returns the unknown value for result
|
|
func (t *Join) GetUnknownResult() (v interface{}) {
|
|
return t.result[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownResult sets the unknown value of result
|
|
func (t *Join) SetUnknownResult(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &resultJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.result = append(t.result, tmp)
|
|
|
|
}
|
|
|
|
// OriginLen determines the number of elements able to be used for the IsOriginObject, GetOriginObject, and RemoveOriginObject functions
|
|
func (t *Join) OriginLen() (l int) {
|
|
return len(t.origin)
|
|
|
|
}
|
|
|
|
// IsOriginObject determines whether the call to GetOriginObject is safe for the specified index
|
|
func (t *Join) IsOriginObject(index int) (ok bool) {
|
|
return t.origin[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetOriginObject returns the value safely if IsOriginObject returned true for the specified index
|
|
func (t *Join) GetOriginObject(index int) (v ObjectType) {
|
|
return t.origin[index].Object
|
|
|
|
}
|
|
|
|
// AppendOriginObject adds to the back of origin a ObjectType type
|
|
func (t *Join) AppendOriginObject(v ObjectType) {
|
|
t.origin = append(t.origin, &originJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependOriginObject adds to the front of origin a ObjectType type
|
|
func (t *Join) PrependOriginObject(v ObjectType) {
|
|
t.origin = append([]*originJoinIntermediateType{&originJoinIntermediateType{Object: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginObject deletes the value from the specified index
|
|
func (t *Join) RemoveOriginObject(index int) {
|
|
copy(t.origin[index:], t.origin[index+1:])
|
|
t.origin[len(t.origin)-1] = nil
|
|
t.origin = t.origin[:len(t.origin)-1]
|
|
|
|
}
|
|
|
|
// IsOriginLink determines whether the call to GetOriginLink is safe for the specified index
|
|
func (t *Join) IsOriginLink(index int) (ok bool) {
|
|
return t.origin[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetOriginLink returns the value safely if IsOriginLink returned true for the specified index
|
|
func (t *Join) GetOriginLink(index int) (v LinkType) {
|
|
return t.origin[index].Link
|
|
|
|
}
|
|
|
|
// AppendOriginLink adds to the back of origin a LinkType type
|
|
func (t *Join) AppendOriginLink(v LinkType) {
|
|
t.origin = append(t.origin, &originJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependOriginLink adds to the front of origin a LinkType type
|
|
func (t *Join) PrependOriginLink(v LinkType) {
|
|
t.origin = append([]*originJoinIntermediateType{&originJoinIntermediateType{Link: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginLink deletes the value from the specified index
|
|
func (t *Join) RemoveOriginLink(index int) {
|
|
copy(t.origin[index:], t.origin[index+1:])
|
|
t.origin[len(t.origin)-1] = nil
|
|
t.origin = t.origin[:len(t.origin)-1]
|
|
|
|
}
|
|
|
|
// IsOriginIRI determines whether the call to GetOriginIRI is safe for the specified index
|
|
func (t *Join) IsOriginIRI(index int) (ok bool) {
|
|
return t.origin[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetOriginIRI returns the value safely if IsOriginIRI returned true for the specified index
|
|
func (t *Join) GetOriginIRI(index int) (v *url.URL) {
|
|
return t.origin[index].IRI
|
|
|
|
}
|
|
|
|
// AppendOriginIRI adds to the back of origin a *url.URL type
|
|
func (t *Join) AppendOriginIRI(v *url.URL) {
|
|
t.origin = append(t.origin, &originJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependOriginIRI adds to the front of origin a *url.URL type
|
|
func (t *Join) PrependOriginIRI(v *url.URL) {
|
|
t.origin = append([]*originJoinIntermediateType{&originJoinIntermediateType{IRI: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginIRI deletes the value from the specified index
|
|
func (t *Join) RemoveOriginIRI(index int) {
|
|
copy(t.origin[index:], t.origin[index+1:])
|
|
t.origin[len(t.origin)-1] = nil
|
|
t.origin = t.origin[:len(t.origin)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownOrigin determines whether the call to GetUnknownOrigin is safe
|
|
func (t *Join) HasUnknownOrigin() (ok bool) {
|
|
return t.origin != nil && t.origin[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOrigin returns the unknown value for origin
|
|
func (t *Join) GetUnknownOrigin() (v interface{}) {
|
|
return t.origin[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOrigin sets the unknown value of origin
|
|
func (t *Join) SetUnknownOrigin(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &originJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.origin = append(t.origin, tmp)
|
|
|
|
}
|
|
|
|
// InstrumentLen determines the number of elements able to be used for the IsInstrumentObject, GetInstrumentObject, and RemoveInstrumentObject functions
|
|
func (t *Join) InstrumentLen() (l int) {
|
|
return len(t.instrument)
|
|
|
|
}
|
|
|
|
// IsInstrumentObject determines whether the call to GetInstrumentObject is safe for the specified index
|
|
func (t *Join) IsInstrumentObject(index int) (ok bool) {
|
|
return t.instrument[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetInstrumentObject returns the value safely if IsInstrumentObject returned true for the specified index
|
|
func (t *Join) GetInstrumentObject(index int) (v ObjectType) {
|
|
return t.instrument[index].Object
|
|
|
|
}
|
|
|
|
// AppendInstrumentObject adds to the back of instrument a ObjectType type
|
|
func (t *Join) AppendInstrumentObject(v ObjectType) {
|
|
t.instrument = append(t.instrument, &instrumentJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentObject adds to the front of instrument a ObjectType type
|
|
func (t *Join) PrependInstrumentObject(v ObjectType) {
|
|
t.instrument = append([]*instrumentJoinIntermediateType{&instrumentJoinIntermediateType{Object: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentObject deletes the value from the specified index
|
|
func (t *Join) RemoveInstrumentObject(index int) {
|
|
copy(t.instrument[index:], t.instrument[index+1:])
|
|
t.instrument[len(t.instrument)-1] = nil
|
|
t.instrument = t.instrument[:len(t.instrument)-1]
|
|
|
|
}
|
|
|
|
// IsInstrumentLink determines whether the call to GetInstrumentLink is safe for the specified index
|
|
func (t *Join) IsInstrumentLink(index int) (ok bool) {
|
|
return t.instrument[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetInstrumentLink returns the value safely if IsInstrumentLink returned true for the specified index
|
|
func (t *Join) GetInstrumentLink(index int) (v LinkType) {
|
|
return t.instrument[index].Link
|
|
|
|
}
|
|
|
|
// AppendInstrumentLink adds to the back of instrument a LinkType type
|
|
func (t *Join) AppendInstrumentLink(v LinkType) {
|
|
t.instrument = append(t.instrument, &instrumentJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentLink adds to the front of instrument a LinkType type
|
|
func (t *Join) PrependInstrumentLink(v LinkType) {
|
|
t.instrument = append([]*instrumentJoinIntermediateType{&instrumentJoinIntermediateType{Link: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentLink deletes the value from the specified index
|
|
func (t *Join) RemoveInstrumentLink(index int) {
|
|
copy(t.instrument[index:], t.instrument[index+1:])
|
|
t.instrument[len(t.instrument)-1] = nil
|
|
t.instrument = t.instrument[:len(t.instrument)-1]
|
|
|
|
}
|
|
|
|
// IsInstrumentIRI determines whether the call to GetInstrumentIRI is safe for the specified index
|
|
func (t *Join) IsInstrumentIRI(index int) (ok bool) {
|
|
return t.instrument[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetInstrumentIRI returns the value safely if IsInstrumentIRI returned true for the specified index
|
|
func (t *Join) GetInstrumentIRI(index int) (v *url.URL) {
|
|
return t.instrument[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInstrumentIRI adds to the back of instrument a *url.URL type
|
|
func (t *Join) AppendInstrumentIRI(v *url.URL) {
|
|
t.instrument = append(t.instrument, &instrumentJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentIRI adds to the front of instrument a *url.URL type
|
|
func (t *Join) PrependInstrumentIRI(v *url.URL) {
|
|
t.instrument = append([]*instrumentJoinIntermediateType{&instrumentJoinIntermediateType{IRI: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentIRI deletes the value from the specified index
|
|
func (t *Join) RemoveInstrumentIRI(index int) {
|
|
copy(t.instrument[index:], t.instrument[index+1:])
|
|
t.instrument[len(t.instrument)-1] = nil
|
|
t.instrument = t.instrument[:len(t.instrument)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownInstrument determines whether the call to GetUnknownInstrument is safe
|
|
func (t *Join) HasUnknownInstrument() (ok bool) {
|
|
return t.instrument != nil && t.instrument[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInstrument returns the unknown value for instrument
|
|
func (t *Join) GetUnknownInstrument() (v interface{}) {
|
|
return t.instrument[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInstrument sets the unknown value of instrument
|
|
func (t *Join) SetUnknownInstrument(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &instrumentJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.instrument = append(t.instrument, tmp)
|
|
|
|
}
|
|
|
|
// IsAltitude determines whether the call to GetAltitude is safe
|
|
func (t *Join) IsAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.float != nil
|
|
|
|
}
|
|
|
|
// GetAltitude returns the value safely if IsAltitude returned true
|
|
func (t *Join) GetAltitude() (v float64) {
|
|
return *t.altitude.float
|
|
|
|
}
|
|
|
|
// SetAltitude sets the value of altitude to be of float64 type
|
|
func (t *Join) SetAltitude(v float64) {
|
|
t.altitude = &altitudeJoinIntermediateType{float: &v}
|
|
|
|
}
|
|
|
|
// IsAltitudeIRI determines whether the call to GetAltitudeIRI is safe
|
|
func (t *Join) IsAltitudeIRI() (ok bool) {
|
|
return t.altitude != nil && t.altitude.IRI != nil
|
|
|
|
}
|
|
|
|
// GetAltitudeIRI returns the value safely if IsAltitudeIRI returned true
|
|
func (t *Join) GetAltitudeIRI() (v *url.URL) {
|
|
return t.altitude.IRI
|
|
|
|
}
|
|
|
|
// SetAltitudeIRI sets the value of altitude to be of *url.URL type
|
|
func (t *Join) SetAltitudeIRI(v *url.URL) {
|
|
t.altitude = &altitudeJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownAltitude determines whether the call to GetUnknownAltitude is safe
|
|
func (t *Join) HasUnknownAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAltitude returns the unknown value for altitude
|
|
func (t *Join) GetUnknownAltitude() (v interface{}) {
|
|
return t.altitude.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAltitude sets the unknown value of altitude
|
|
func (t *Join) SetUnknownAltitude(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &altitudeJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.altitude = tmp
|
|
|
|
}
|
|
|
|
// AttachmentLen determines the number of elements able to be used for the IsAttachmentObject, GetAttachmentObject, and RemoveAttachmentObject functions
|
|
func (t *Join) AttachmentLen() (l int) {
|
|
return len(t.attachment)
|
|
|
|
}
|
|
|
|
// IsAttachmentObject determines whether the call to GetAttachmentObject is safe for the specified index
|
|
func (t *Join) IsAttachmentObject(index int) (ok bool) {
|
|
return t.attachment[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetAttachmentObject returns the value safely if IsAttachmentObject returned true for the specified index
|
|
func (t *Join) GetAttachmentObject(index int) (v ObjectType) {
|
|
return t.attachment[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttachmentObject adds to the back of attachment a ObjectType type
|
|
func (t *Join) AppendAttachmentObject(v ObjectType) {
|
|
t.attachment = append(t.attachment, &attachmentJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentObject adds to the front of attachment a ObjectType type
|
|
func (t *Join) PrependAttachmentObject(v ObjectType) {
|
|
t.attachment = append([]*attachmentJoinIntermediateType{&attachmentJoinIntermediateType{Object: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentObject deletes the value from the specified index
|
|
func (t *Join) RemoveAttachmentObject(index int) {
|
|
copy(t.attachment[index:], t.attachment[index+1:])
|
|
t.attachment[len(t.attachment)-1] = nil
|
|
t.attachment = t.attachment[:len(t.attachment)-1]
|
|
|
|
}
|
|
|
|
// IsAttachmentLink determines whether the call to GetAttachmentLink is safe for the specified index
|
|
func (t *Join) IsAttachmentLink(index int) (ok bool) {
|
|
return t.attachment[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetAttachmentLink returns the value safely if IsAttachmentLink returned true for the specified index
|
|
func (t *Join) GetAttachmentLink(index int) (v LinkType) {
|
|
return t.attachment[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttachmentLink adds to the back of attachment a LinkType type
|
|
func (t *Join) AppendAttachmentLink(v LinkType) {
|
|
t.attachment = append(t.attachment, &attachmentJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentLink adds to the front of attachment a LinkType type
|
|
func (t *Join) PrependAttachmentLink(v LinkType) {
|
|
t.attachment = append([]*attachmentJoinIntermediateType{&attachmentJoinIntermediateType{Link: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentLink deletes the value from the specified index
|
|
func (t *Join) RemoveAttachmentLink(index int) {
|
|
copy(t.attachment[index:], t.attachment[index+1:])
|
|
t.attachment[len(t.attachment)-1] = nil
|
|
t.attachment = t.attachment[:len(t.attachment)-1]
|
|
|
|
}
|
|
|
|
// IsAttachmentIRI determines whether the call to GetAttachmentIRI is safe for the specified index
|
|
func (t *Join) IsAttachmentIRI(index int) (ok bool) {
|
|
return t.attachment[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetAttachmentIRI returns the value safely if IsAttachmentIRI returned true for the specified index
|
|
func (t *Join) GetAttachmentIRI(index int) (v *url.URL) {
|
|
return t.attachment[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttachmentIRI adds to the back of attachment a *url.URL type
|
|
func (t *Join) AppendAttachmentIRI(v *url.URL) {
|
|
t.attachment = append(t.attachment, &attachmentJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentIRI adds to the front of attachment a *url.URL type
|
|
func (t *Join) PrependAttachmentIRI(v *url.URL) {
|
|
t.attachment = append([]*attachmentJoinIntermediateType{&attachmentJoinIntermediateType{IRI: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentIRI deletes the value from the specified index
|
|
func (t *Join) RemoveAttachmentIRI(index int) {
|
|
copy(t.attachment[index:], t.attachment[index+1:])
|
|
t.attachment[len(t.attachment)-1] = nil
|
|
t.attachment = t.attachment[:len(t.attachment)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownAttachment determines whether the call to GetUnknownAttachment is safe
|
|
func (t *Join) HasUnknownAttachment() (ok bool) {
|
|
return t.attachment != nil && t.attachment[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttachment returns the unknown value for attachment
|
|
func (t *Join) GetUnknownAttachment() (v interface{}) {
|
|
return t.attachment[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttachment sets the unknown value of attachment
|
|
func (t *Join) SetUnknownAttachment(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attachmentJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.attachment = append(t.attachment, tmp)
|
|
|
|
}
|
|
|
|
// AttributedToLen determines the number of elements able to be used for the IsAttributedToObject, GetAttributedToObject, and RemoveAttributedToObject functions
|
|
func (t *Join) AttributedToLen() (l int) {
|
|
return len(t.attributedTo)
|
|
|
|
}
|
|
|
|
// IsAttributedToObject determines whether the call to GetAttributedToObject is safe for the specified index
|
|
func (t *Join) IsAttributedToObject(index int) (ok bool) {
|
|
return t.attributedTo[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetAttributedToObject returns the value safely if IsAttributedToObject returned true for the specified index
|
|
func (t *Join) GetAttributedToObject(index int) (v ObjectType) {
|
|
return t.attributedTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttributedToObject adds to the back of attributedTo a ObjectType type
|
|
func (t *Join) AppendAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToObject adds to the front of attributedTo a ObjectType type
|
|
func (t *Join) PrependAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append([]*attributedToJoinIntermediateType{&attributedToJoinIntermediateType{Object: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToObject deletes the value from the specified index
|
|
func (t *Join) RemoveAttributedToObject(index int) {
|
|
copy(t.attributedTo[index:], t.attributedTo[index+1:])
|
|
t.attributedTo[len(t.attributedTo)-1] = nil
|
|
t.attributedTo = t.attributedTo[:len(t.attributedTo)-1]
|
|
|
|
}
|
|
|
|
// IsAttributedToLink determines whether the call to GetAttributedToLink is safe for the specified index
|
|
func (t *Join) IsAttributedToLink(index int) (ok bool) {
|
|
return t.attributedTo[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetAttributedToLink returns the value safely if IsAttributedToLink returned true for the specified index
|
|
func (t *Join) GetAttributedToLink(index int) (v LinkType) {
|
|
return t.attributedTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttributedToLink adds to the back of attributedTo a LinkType type
|
|
func (t *Join) AppendAttributedToLink(v LinkType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToLink adds to the front of attributedTo a LinkType type
|
|
func (t *Join) PrependAttributedToLink(v LinkType) {
|
|
t.attributedTo = append([]*attributedToJoinIntermediateType{&attributedToJoinIntermediateType{Link: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToLink deletes the value from the specified index
|
|
func (t *Join) RemoveAttributedToLink(index int) {
|
|
copy(t.attributedTo[index:], t.attributedTo[index+1:])
|
|
t.attributedTo[len(t.attributedTo)-1] = nil
|
|
t.attributedTo = t.attributedTo[:len(t.attributedTo)-1]
|
|
|
|
}
|
|
|
|
// IsAttributedToIRI determines whether the call to GetAttributedToIRI is safe for the specified index
|
|
func (t *Join) IsAttributedToIRI(index int) (ok bool) {
|
|
return t.attributedTo[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetAttributedToIRI returns the value safely if IsAttributedToIRI returned true for the specified index
|
|
func (t *Join) GetAttributedToIRI(index int) (v *url.URL) {
|
|
return t.attributedTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttributedToIRI adds to the back of attributedTo a *url.URL type
|
|
func (t *Join) AppendAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToIRI adds to the front of attributedTo a *url.URL type
|
|
func (t *Join) PrependAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append([]*attributedToJoinIntermediateType{&attributedToJoinIntermediateType{IRI: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToIRI deletes the value from the specified index
|
|
func (t *Join) RemoveAttributedToIRI(index int) {
|
|
copy(t.attributedTo[index:], t.attributedTo[index+1:])
|
|
t.attributedTo[len(t.attributedTo)-1] = nil
|
|
t.attributedTo = t.attributedTo[:len(t.attributedTo)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownAttributedTo determines whether the call to GetUnknownAttributedTo is safe
|
|
func (t *Join) HasUnknownAttributedTo() (ok bool) {
|
|
return t.attributedTo != nil && t.attributedTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttributedTo returns the unknown value for attributedTo
|
|
func (t *Join) GetUnknownAttributedTo() (v interface{}) {
|
|
return t.attributedTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttributedTo sets the unknown value of attributedTo
|
|
func (t *Join) SetUnknownAttributedTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attributedToJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.attributedTo = append(t.attributedTo, tmp)
|
|
|
|
}
|
|
|
|
// AudienceLen determines the number of elements able to be used for the IsAudienceObject, GetAudienceObject, and RemoveAudienceObject functions
|
|
func (t *Join) AudienceLen() (l int) {
|
|
return len(t.audience)
|
|
|
|
}
|
|
|
|
// IsAudienceObject determines whether the call to GetAudienceObject is safe for the specified index
|
|
func (t *Join) IsAudienceObject(index int) (ok bool) {
|
|
return t.audience[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetAudienceObject returns the value safely if IsAudienceObject returned true for the specified index
|
|
func (t *Join) GetAudienceObject(index int) (v ObjectType) {
|
|
return t.audience[index].Object
|
|
|
|
}
|
|
|
|
// AppendAudienceObject adds to the back of audience a ObjectType type
|
|
func (t *Join) AppendAudienceObject(v ObjectType) {
|
|
t.audience = append(t.audience, &audienceJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceObject adds to the front of audience a ObjectType type
|
|
func (t *Join) PrependAudienceObject(v ObjectType) {
|
|
t.audience = append([]*audienceJoinIntermediateType{&audienceJoinIntermediateType{Object: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceObject deletes the value from the specified index
|
|
func (t *Join) RemoveAudienceObject(index int) {
|
|
copy(t.audience[index:], t.audience[index+1:])
|
|
t.audience[len(t.audience)-1] = nil
|
|
t.audience = t.audience[:len(t.audience)-1]
|
|
|
|
}
|
|
|
|
// IsAudienceLink determines whether the call to GetAudienceLink is safe for the specified index
|
|
func (t *Join) IsAudienceLink(index int) (ok bool) {
|
|
return t.audience[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetAudienceLink returns the value safely if IsAudienceLink returned true for the specified index
|
|
func (t *Join) GetAudienceLink(index int) (v LinkType) {
|
|
return t.audience[index].Link
|
|
|
|
}
|
|
|
|
// AppendAudienceLink adds to the back of audience a LinkType type
|
|
func (t *Join) AppendAudienceLink(v LinkType) {
|
|
t.audience = append(t.audience, &audienceJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceLink adds to the front of audience a LinkType type
|
|
func (t *Join) PrependAudienceLink(v LinkType) {
|
|
t.audience = append([]*audienceJoinIntermediateType{&audienceJoinIntermediateType{Link: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceLink deletes the value from the specified index
|
|
func (t *Join) RemoveAudienceLink(index int) {
|
|
copy(t.audience[index:], t.audience[index+1:])
|
|
t.audience[len(t.audience)-1] = nil
|
|
t.audience = t.audience[:len(t.audience)-1]
|
|
|
|
}
|
|
|
|
// IsAudienceIRI determines whether the call to GetAudienceIRI is safe for the specified index
|
|
func (t *Join) IsAudienceIRI(index int) (ok bool) {
|
|
return t.audience[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetAudienceIRI returns the value safely if IsAudienceIRI returned true for the specified index
|
|
func (t *Join) GetAudienceIRI(index int) (v *url.URL) {
|
|
return t.audience[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAudienceIRI adds to the back of audience a *url.URL type
|
|
func (t *Join) AppendAudienceIRI(v *url.URL) {
|
|
t.audience = append(t.audience, &audienceJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceIRI adds to the front of audience a *url.URL type
|
|
func (t *Join) PrependAudienceIRI(v *url.URL) {
|
|
t.audience = append([]*audienceJoinIntermediateType{&audienceJoinIntermediateType{IRI: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceIRI deletes the value from the specified index
|
|
func (t *Join) RemoveAudienceIRI(index int) {
|
|
copy(t.audience[index:], t.audience[index+1:])
|
|
t.audience[len(t.audience)-1] = nil
|
|
t.audience = t.audience[:len(t.audience)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownAudience determines whether the call to GetUnknownAudience is safe
|
|
func (t *Join) HasUnknownAudience() (ok bool) {
|
|
return t.audience != nil && t.audience[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAudience returns the unknown value for audience
|
|
func (t *Join) GetUnknownAudience() (v interface{}) {
|
|
return t.audience[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAudience sets the unknown value of audience
|
|
func (t *Join) SetUnknownAudience(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &audienceJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.audience = append(t.audience, tmp)
|
|
|
|
}
|
|
|
|
// ContentLen determines the number of elements able to be used for the IsContentString, GetContentString, and RemoveContentString functions
|
|
func (t *Join) ContentLen() (l int) {
|
|
return len(t.content)
|
|
|
|
}
|
|
|
|
// IsContentString determines whether the call to GetContentString is safe for the specified index
|
|
func (t *Join) IsContentString(index int) (ok bool) {
|
|
return t.content[index].stringName != nil
|
|
|
|
}
|
|
|
|
// GetContentString returns the value safely if IsContentString returned true for the specified index
|
|
func (t *Join) GetContentString(index int) (v string) {
|
|
return *t.content[index].stringName
|
|
|
|
}
|
|
|
|
// AppendContentString adds to the back of content a string type
|
|
func (t *Join) AppendContentString(v string) {
|
|
t.content = append(t.content, &contentJoinIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependContentString adds to the front of content a string type
|
|
func (t *Join) PrependContentString(v string) {
|
|
t.content = append([]*contentJoinIntermediateType{&contentJoinIntermediateType{stringName: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentString deletes the value from the specified index
|
|
func (t *Join) RemoveContentString(index int) {
|
|
copy(t.content[index:], t.content[index+1:])
|
|
t.content[len(t.content)-1] = nil
|
|
t.content = t.content[:len(t.content)-1]
|
|
|
|
}
|
|
|
|
// IsContentLangString determines whether the call to GetContentLangString is safe for the specified index
|
|
func (t *Join) IsContentLangString(index int) (ok bool) {
|
|
return t.content[index].langString != nil
|
|
|
|
}
|
|
|
|
// GetContentLangString returns the value safely if IsContentLangString returned true for the specified index
|
|
func (t *Join) GetContentLangString(index int) (v string) {
|
|
return *t.content[index].langString
|
|
|
|
}
|
|
|
|
// AppendContentLangString adds to the back of content a string type
|
|
func (t *Join) AppendContentLangString(v string) {
|
|
t.content = append(t.content, &contentJoinIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependContentLangString adds to the front of content a string type
|
|
func (t *Join) PrependContentLangString(v string) {
|
|
t.content = append([]*contentJoinIntermediateType{&contentJoinIntermediateType{langString: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentLangString deletes the value from the specified index
|
|
func (t *Join) RemoveContentLangString(index int) {
|
|
copy(t.content[index:], t.content[index+1:])
|
|
t.content[len(t.content)-1] = nil
|
|
t.content = t.content[:len(t.content)-1]
|
|
|
|
}
|
|
|
|
// IsContentIRI determines whether the call to GetContentIRI is safe for the specified index
|
|
func (t *Join) IsContentIRI(index int) (ok bool) {
|
|
return t.content[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetContentIRI returns the value safely if IsContentIRI returned true for the specified index
|
|
func (t *Join) GetContentIRI(index int) (v *url.URL) {
|
|
return t.content[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContentIRI adds to the back of content a *url.URL type
|
|
func (t *Join) AppendContentIRI(v *url.URL) {
|
|
t.content = append(t.content, &contentJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContentIRI adds to the front of content a *url.URL type
|
|
func (t *Join) PrependContentIRI(v *url.URL) {
|
|
t.content = append([]*contentJoinIntermediateType{&contentJoinIntermediateType{IRI: v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentIRI deletes the value from the specified index
|
|
func (t *Join) RemoveContentIRI(index int) {
|
|
copy(t.content[index:], t.content[index+1:])
|
|
t.content[len(t.content)-1] = nil
|
|
t.content = t.content[:len(t.content)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownContent determines whether the call to GetUnknownContent is safe
|
|
func (t *Join) HasUnknownContent() (ok bool) {
|
|
return t.content != nil && t.content[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContent returns the unknown value for content
|
|
func (t *Join) GetUnknownContent() (v interface{}) {
|
|
return t.content[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContent sets the unknown value of content
|
|
func (t *Join) SetUnknownContent(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contentJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.content = append(t.content, tmp)
|
|
|
|
}
|
|
|
|
// ContentMapLanguages returns all languages for this property's language mapping, or nil if there are none.
|
|
func (t *Join) ContentMapLanguages() (l []string) {
|
|
if t.contentMap == nil || len(t.contentMap) == 0 {
|
|
return nil
|
|
}
|
|
for k := range t.contentMap {
|
|
l = append(l, k)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// GetContentMap retrieves the value of the property for the specified language, or an empty string if it does not exist
|
|
func (t *Join) GetContentMap(l string) (v string) {
|
|
if t.contentMap == nil {
|
|
return ""
|
|
}
|
|
ok := false
|
|
v, ok = t.contentMap[l]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
return v
|
|
|
|
}
|
|
|
|
// SetContentMap sets the value of the property for the specified language
|
|
func (t *Join) SetContentMap(l string, v string) {
|
|
if t.contentMap == nil {
|
|
t.contentMap = make(map[string]string)
|
|
}
|
|
t.contentMap[l] = v
|
|
|
|
}
|
|
|
|
// ContextLen determines the number of elements able to be used for the IsContextObject, GetContextObject, and RemoveContextObject functions
|
|
func (t *Join) ContextLen() (l int) {
|
|
return len(t.context)
|
|
|
|
}
|
|
|
|
// IsContextObject determines whether the call to GetContextObject is safe for the specified index
|
|
func (t *Join) IsContextObject(index int) (ok bool) {
|
|
return t.context[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetContextObject returns the value safely if IsContextObject returned true for the specified index
|
|
func (t *Join) GetContextObject(index int) (v ObjectType) {
|
|
return t.context[index].Object
|
|
|
|
}
|
|
|
|
// AppendContextObject adds to the back of context a ObjectType type
|
|
func (t *Join) AppendContextObject(v ObjectType) {
|
|
t.context = append(t.context, &contextJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependContextObject adds to the front of context a ObjectType type
|
|
func (t *Join) PrependContextObject(v ObjectType) {
|
|
t.context = append([]*contextJoinIntermediateType{&contextJoinIntermediateType{Object: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextObject deletes the value from the specified index
|
|
func (t *Join) RemoveContextObject(index int) {
|
|
copy(t.context[index:], t.context[index+1:])
|
|
t.context[len(t.context)-1] = nil
|
|
t.context = t.context[:len(t.context)-1]
|
|
|
|
}
|
|
|
|
// IsContextLink determines whether the call to GetContextLink is safe for the specified index
|
|
func (t *Join) IsContextLink(index int) (ok bool) {
|
|
return t.context[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetContextLink returns the value safely if IsContextLink returned true for the specified index
|
|
func (t *Join) GetContextLink(index int) (v LinkType) {
|
|
return t.context[index].Link
|
|
|
|
}
|
|
|
|
// AppendContextLink adds to the back of context a LinkType type
|
|
func (t *Join) AppendContextLink(v LinkType) {
|
|
t.context = append(t.context, &contextJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependContextLink adds to the front of context a LinkType type
|
|
func (t *Join) PrependContextLink(v LinkType) {
|
|
t.context = append([]*contextJoinIntermediateType{&contextJoinIntermediateType{Link: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextLink deletes the value from the specified index
|
|
func (t *Join) RemoveContextLink(index int) {
|
|
copy(t.context[index:], t.context[index+1:])
|
|
t.context[len(t.context)-1] = nil
|
|
t.context = t.context[:len(t.context)-1]
|
|
|
|
}
|
|
|
|
// IsContextIRI determines whether the call to GetContextIRI is safe for the specified index
|
|
func (t *Join) IsContextIRI(index int) (ok bool) {
|
|
return t.context[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetContextIRI returns the value safely if IsContextIRI returned true for the specified index
|
|
func (t *Join) GetContextIRI(index int) (v *url.URL) {
|
|
return t.context[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContextIRI adds to the back of context a *url.URL type
|
|
func (t *Join) AppendContextIRI(v *url.URL) {
|
|
t.context = append(t.context, &contextJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContextIRI adds to the front of context a *url.URL type
|
|
func (t *Join) PrependContextIRI(v *url.URL) {
|
|
t.context = append([]*contextJoinIntermediateType{&contextJoinIntermediateType{IRI: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextIRI deletes the value from the specified index
|
|
func (t *Join) RemoveContextIRI(index int) {
|
|
copy(t.context[index:], t.context[index+1:])
|
|
t.context[len(t.context)-1] = nil
|
|
t.context = t.context[:len(t.context)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownContext determines whether the call to GetUnknownContext is safe
|
|
func (t *Join) HasUnknownContext() (ok bool) {
|
|
return t.context != nil && t.context[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContext returns the unknown value for context
|
|
func (t *Join) GetUnknownContext() (v interface{}) {
|
|
return t.context[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContext sets the unknown value of context
|
|
func (t *Join) SetUnknownContext(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contextJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.context = append(t.context, tmp)
|
|
|
|
}
|
|
|
|
// NameLen determines the number of elements able to be used for the IsNameString, GetNameString, and RemoveNameString functions
|
|
func (t *Join) NameLen() (l int) {
|
|
return len(t.name)
|
|
|
|
}
|
|
|
|
// IsNameString determines whether the call to GetNameString is safe for the specified index
|
|
func (t *Join) IsNameString(index int) (ok bool) {
|
|
return t.name[index].stringName != nil
|
|
|
|
}
|
|
|
|
// GetNameString returns the value safely if IsNameString returned true for the specified index
|
|
func (t *Join) GetNameString(index int) (v string) {
|
|
return *t.name[index].stringName
|
|
|
|
}
|
|
|
|
// AppendNameString adds to the back of name a string type
|
|
func (t *Join) AppendNameString(v string) {
|
|
t.name = append(t.name, &nameJoinIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependNameString adds to the front of name a string type
|
|
func (t *Join) PrependNameString(v string) {
|
|
t.name = append([]*nameJoinIntermediateType{&nameJoinIntermediateType{stringName: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameString deletes the value from the specified index
|
|
func (t *Join) RemoveNameString(index int) {
|
|
copy(t.name[index:], t.name[index+1:])
|
|
t.name[len(t.name)-1] = nil
|
|
t.name = t.name[:len(t.name)-1]
|
|
|
|
}
|
|
|
|
// IsNameLangString determines whether the call to GetNameLangString is safe for the specified index
|
|
func (t *Join) IsNameLangString(index int) (ok bool) {
|
|
return t.name[index].langString != nil
|
|
|
|
}
|
|
|
|
// GetNameLangString returns the value safely if IsNameLangString returned true for the specified index
|
|
func (t *Join) GetNameLangString(index int) (v string) {
|
|
return *t.name[index].langString
|
|
|
|
}
|
|
|
|
// AppendNameLangString adds to the back of name a string type
|
|
func (t *Join) AppendNameLangString(v string) {
|
|
t.name = append(t.name, &nameJoinIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependNameLangString adds to the front of name a string type
|
|
func (t *Join) PrependNameLangString(v string) {
|
|
t.name = append([]*nameJoinIntermediateType{&nameJoinIntermediateType{langString: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameLangString deletes the value from the specified index
|
|
func (t *Join) RemoveNameLangString(index int) {
|
|
copy(t.name[index:], t.name[index+1:])
|
|
t.name[len(t.name)-1] = nil
|
|
t.name = t.name[:len(t.name)-1]
|
|
|
|
}
|
|
|
|
// IsNameIRI determines whether the call to GetNameIRI is safe for the specified index
|
|
func (t *Join) IsNameIRI(index int) (ok bool) {
|
|
return t.name[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetNameIRI returns the value safely if IsNameIRI returned true for the specified index
|
|
func (t *Join) GetNameIRI(index int) (v *url.URL) {
|
|
return t.name[index].IRI
|
|
|
|
}
|
|
|
|
// AppendNameIRI adds to the back of name a *url.URL type
|
|
func (t *Join) AppendNameIRI(v *url.URL) {
|
|
t.name = append(t.name, &nameJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependNameIRI adds to the front of name a *url.URL type
|
|
func (t *Join) PrependNameIRI(v *url.URL) {
|
|
t.name = append([]*nameJoinIntermediateType{&nameJoinIntermediateType{IRI: v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameIRI deletes the value from the specified index
|
|
func (t *Join) RemoveNameIRI(index int) {
|
|
copy(t.name[index:], t.name[index+1:])
|
|
t.name[len(t.name)-1] = nil
|
|
t.name = t.name[:len(t.name)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownName determines whether the call to GetUnknownName is safe
|
|
func (t *Join) HasUnknownName() (ok bool) {
|
|
return t.name != nil && t.name[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownName returns the unknown value for name
|
|
func (t *Join) GetUnknownName() (v interface{}) {
|
|
return t.name[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownName sets the unknown value of name
|
|
func (t *Join) SetUnknownName(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &nameJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.name = append(t.name, tmp)
|
|
|
|
}
|
|
|
|
// NameMapLanguages returns all languages for this property's language mapping, or nil if there are none.
|
|
func (t *Join) NameMapLanguages() (l []string) {
|
|
if t.nameMap == nil || len(t.nameMap) == 0 {
|
|
return nil
|
|
}
|
|
for k := range t.nameMap {
|
|
l = append(l, k)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// GetNameMap retrieves the value of the property for the specified language, or an empty string if it does not exist
|
|
func (t *Join) GetNameMap(l string) (v string) {
|
|
if t.nameMap == nil {
|
|
return ""
|
|
}
|
|
ok := false
|
|
v, ok = t.nameMap[l]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
return v
|
|
|
|
}
|
|
|
|
// SetNameMap sets the value of the property for the specified language
|
|
func (t *Join) SetNameMap(l string, v string) {
|
|
if t.nameMap == nil {
|
|
t.nameMap = make(map[string]string)
|
|
}
|
|
t.nameMap[l] = v
|
|
|
|
}
|
|
|
|
// IsEndTime determines whether the call to GetEndTime is safe
|
|
func (t *Join) IsEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetEndTime returns the value safely if IsEndTime returned true
|
|
func (t *Join) GetEndTime() (v time.Time) {
|
|
return *t.endTime.dateTime
|
|
|
|
}
|
|
|
|
// SetEndTime sets the value of endTime to be of time.Time type
|
|
func (t *Join) SetEndTime(v time.Time) {
|
|
t.endTime = &endTimeJoinIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsEndTimeIRI determines whether the call to GetEndTimeIRI is safe
|
|
func (t *Join) IsEndTimeIRI() (ok bool) {
|
|
return t.endTime != nil && t.endTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndTimeIRI returns the value safely if IsEndTimeIRI returned true
|
|
func (t *Join) GetEndTimeIRI() (v *url.URL) {
|
|
return t.endTime.IRI
|
|
|
|
}
|
|
|
|
// SetEndTimeIRI sets the value of endTime to be of *url.URL type
|
|
func (t *Join) SetEndTimeIRI(v *url.URL) {
|
|
t.endTime = &endTimeJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndTime determines whether the call to GetUnknownEndTime is safe
|
|
func (t *Join) HasUnknownEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndTime returns the unknown value for endTime
|
|
func (t *Join) GetUnknownEndTime() (v interface{}) {
|
|
return t.endTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndTime sets the unknown value of endTime
|
|
func (t *Join) SetUnknownEndTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endTimeJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.endTime = tmp
|
|
|
|
}
|
|
|
|
// GeneratorLen determines the number of elements able to be used for the IsGeneratorObject, GetGeneratorObject, and RemoveGeneratorObject functions
|
|
func (t *Join) GeneratorLen() (l int) {
|
|
return len(t.generator)
|
|
|
|
}
|
|
|
|
// IsGeneratorObject determines whether the call to GetGeneratorObject is safe for the specified index
|
|
func (t *Join) IsGeneratorObject(index int) (ok bool) {
|
|
return t.generator[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetGeneratorObject returns the value safely if IsGeneratorObject returned true for the specified index
|
|
func (t *Join) GetGeneratorObject(index int) (v ObjectType) {
|
|
return t.generator[index].Object
|
|
|
|
}
|
|
|
|
// AppendGeneratorObject adds to the back of generator a ObjectType type
|
|
func (t *Join) AppendGeneratorObject(v ObjectType) {
|
|
t.generator = append(t.generator, &generatorJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorObject adds to the front of generator a ObjectType type
|
|
func (t *Join) PrependGeneratorObject(v ObjectType) {
|
|
t.generator = append([]*generatorJoinIntermediateType{&generatorJoinIntermediateType{Object: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorObject deletes the value from the specified index
|
|
func (t *Join) RemoveGeneratorObject(index int) {
|
|
copy(t.generator[index:], t.generator[index+1:])
|
|
t.generator[len(t.generator)-1] = nil
|
|
t.generator = t.generator[:len(t.generator)-1]
|
|
|
|
}
|
|
|
|
// IsGeneratorLink determines whether the call to GetGeneratorLink is safe for the specified index
|
|
func (t *Join) IsGeneratorLink(index int) (ok bool) {
|
|
return t.generator[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetGeneratorLink returns the value safely if IsGeneratorLink returned true for the specified index
|
|
func (t *Join) GetGeneratorLink(index int) (v LinkType) {
|
|
return t.generator[index].Link
|
|
|
|
}
|
|
|
|
// AppendGeneratorLink adds to the back of generator a LinkType type
|
|
func (t *Join) AppendGeneratorLink(v LinkType) {
|
|
t.generator = append(t.generator, &generatorJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorLink adds to the front of generator a LinkType type
|
|
func (t *Join) PrependGeneratorLink(v LinkType) {
|
|
t.generator = append([]*generatorJoinIntermediateType{&generatorJoinIntermediateType{Link: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorLink deletes the value from the specified index
|
|
func (t *Join) RemoveGeneratorLink(index int) {
|
|
copy(t.generator[index:], t.generator[index+1:])
|
|
t.generator[len(t.generator)-1] = nil
|
|
t.generator = t.generator[:len(t.generator)-1]
|
|
|
|
}
|
|
|
|
// IsGeneratorIRI determines whether the call to GetGeneratorIRI is safe for the specified index
|
|
func (t *Join) IsGeneratorIRI(index int) (ok bool) {
|
|
return t.generator[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetGeneratorIRI returns the value safely if IsGeneratorIRI returned true for the specified index
|
|
func (t *Join) GetGeneratorIRI(index int) (v *url.URL) {
|
|
return t.generator[index].IRI
|
|
|
|
}
|
|
|
|
// AppendGeneratorIRI adds to the back of generator a *url.URL type
|
|
func (t *Join) AppendGeneratorIRI(v *url.URL) {
|
|
t.generator = append(t.generator, &generatorJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorIRI adds to the front of generator a *url.URL type
|
|
func (t *Join) PrependGeneratorIRI(v *url.URL) {
|
|
t.generator = append([]*generatorJoinIntermediateType{&generatorJoinIntermediateType{IRI: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorIRI deletes the value from the specified index
|
|
func (t *Join) RemoveGeneratorIRI(index int) {
|
|
copy(t.generator[index:], t.generator[index+1:])
|
|
t.generator[len(t.generator)-1] = nil
|
|
t.generator = t.generator[:len(t.generator)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownGenerator determines whether the call to GetUnknownGenerator is safe
|
|
func (t *Join) HasUnknownGenerator() (ok bool) {
|
|
return t.generator != nil && t.generator[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownGenerator returns the unknown value for generator
|
|
func (t *Join) GetUnknownGenerator() (v interface{}) {
|
|
return t.generator[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownGenerator sets the unknown value of generator
|
|
func (t *Join) SetUnknownGenerator(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &generatorJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.generator = append(t.generator, tmp)
|
|
|
|
}
|
|
|
|
// IconLen determines the number of elements able to be used for the IsIconImage, GetIconImage, and RemoveIconImage functions
|
|
func (t *Join) IconLen() (l int) {
|
|
return len(t.icon)
|
|
|
|
}
|
|
|
|
// IsIconImage determines whether the call to GetIconImage is safe for the specified index
|
|
func (t *Join) IsIconImage(index int) (ok bool) {
|
|
return t.icon[index].Image != nil
|
|
|
|
}
|
|
|
|
// GetIconImage returns the value safely if IsIconImage returned true for the specified index
|
|
func (t *Join) GetIconImage(index int) (v ImageType) {
|
|
return t.icon[index].Image
|
|
|
|
}
|
|
|
|
// AppendIconImage adds to the back of icon a ImageType type
|
|
func (t *Join) AppendIconImage(v ImageType) {
|
|
t.icon = append(t.icon, &iconJoinIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependIconImage adds to the front of icon a ImageType type
|
|
func (t *Join) PrependIconImage(v ImageType) {
|
|
t.icon = append([]*iconJoinIntermediateType{&iconJoinIntermediateType{Image: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconImage deletes the value from the specified index
|
|
func (t *Join) RemoveIconImage(index int) {
|
|
copy(t.icon[index:], t.icon[index+1:])
|
|
t.icon[len(t.icon)-1] = nil
|
|
t.icon = t.icon[:len(t.icon)-1]
|
|
|
|
}
|
|
|
|
// IsIconLink determines whether the call to GetIconLink is safe for the specified index
|
|
func (t *Join) IsIconLink(index int) (ok bool) {
|
|
return t.icon[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetIconLink returns the value safely if IsIconLink returned true for the specified index
|
|
func (t *Join) GetIconLink(index int) (v LinkType) {
|
|
return t.icon[index].Link
|
|
|
|
}
|
|
|
|
// AppendIconLink adds to the back of icon a LinkType type
|
|
func (t *Join) AppendIconLink(v LinkType) {
|
|
t.icon = append(t.icon, &iconJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependIconLink adds to the front of icon a LinkType type
|
|
func (t *Join) PrependIconLink(v LinkType) {
|
|
t.icon = append([]*iconJoinIntermediateType{&iconJoinIntermediateType{Link: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconLink deletes the value from the specified index
|
|
func (t *Join) RemoveIconLink(index int) {
|
|
copy(t.icon[index:], t.icon[index+1:])
|
|
t.icon[len(t.icon)-1] = nil
|
|
t.icon = t.icon[:len(t.icon)-1]
|
|
|
|
}
|
|
|
|
// IsIconIRI determines whether the call to GetIconIRI is safe for the specified index
|
|
func (t *Join) IsIconIRI(index int) (ok bool) {
|
|
return t.icon[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetIconIRI returns the value safely if IsIconIRI returned true for the specified index
|
|
func (t *Join) GetIconIRI(index int) (v *url.URL) {
|
|
return t.icon[index].IRI
|
|
|
|
}
|
|
|
|
// AppendIconIRI adds to the back of icon a *url.URL type
|
|
func (t *Join) AppendIconIRI(v *url.URL) {
|
|
t.icon = append(t.icon, &iconJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependIconIRI adds to the front of icon a *url.URL type
|
|
func (t *Join) PrependIconIRI(v *url.URL) {
|
|
t.icon = append([]*iconJoinIntermediateType{&iconJoinIntermediateType{IRI: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconIRI deletes the value from the specified index
|
|
func (t *Join) RemoveIconIRI(index int) {
|
|
copy(t.icon[index:], t.icon[index+1:])
|
|
t.icon[len(t.icon)-1] = nil
|
|
t.icon = t.icon[:len(t.icon)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownIcon determines whether the call to GetUnknownIcon is safe
|
|
func (t *Join) HasUnknownIcon() (ok bool) {
|
|
return t.icon != nil && t.icon[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownIcon returns the unknown value for icon
|
|
func (t *Join) GetUnknownIcon() (v interface{}) {
|
|
return t.icon[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownIcon sets the unknown value of icon
|
|
func (t *Join) SetUnknownIcon(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &iconJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.icon = append(t.icon, tmp)
|
|
|
|
}
|
|
|
|
// HasId determines whether the call to GetId is safe
|
|
func (t *Join) HasId() (ok bool) {
|
|
return t.id != nil
|
|
|
|
}
|
|
|
|
// GetId returns the value for id
|
|
func (t *Join) GetId() (v *url.URL) {
|
|
return t.id
|
|
|
|
}
|
|
|
|
// SetId sets the value of id
|
|
func (t *Join) SetId(v *url.URL) {
|
|
t.id = v
|
|
|
|
}
|
|
|
|
// HasUnknownId determines whether the call to GetUnknownId is safe
|
|
func (t *Join) HasUnknownId() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["id"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownId returns the unknown value for id
|
|
func (t *Join) GetUnknownId() (v interface{}) {
|
|
return t.unknown_["id"]
|
|
|
|
}
|
|
|
|
// SetUnknownId sets the unknown value of id
|
|
func (t *Join) SetUnknownId(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["id"] = i
|
|
|
|
}
|
|
|
|
// ImageLen determines the number of elements able to be used for the IsImageImage, GetImageImage, and RemoveImageImage functions
|
|
func (t *Join) ImageLen() (l int) {
|
|
return len(t.image)
|
|
|
|
}
|
|
|
|
// IsImageImage determines whether the call to GetImageImage is safe for the specified index
|
|
func (t *Join) IsImageImage(index int) (ok bool) {
|
|
return t.image[index].Image != nil
|
|
|
|
}
|
|
|
|
// GetImageImage returns the value safely if IsImageImage returned true for the specified index
|
|
func (t *Join) GetImageImage(index int) (v ImageType) {
|
|
return t.image[index].Image
|
|
|
|
}
|
|
|
|
// AppendImageImage adds to the back of image a ImageType type
|
|
func (t *Join) AppendImageImage(v ImageType) {
|
|
t.image = append(t.image, &imageJoinIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependImageImage adds to the front of image a ImageType type
|
|
func (t *Join) PrependImageImage(v ImageType) {
|
|
t.image = append([]*imageJoinIntermediateType{&imageJoinIntermediateType{Image: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageImage deletes the value from the specified index
|
|
func (t *Join) RemoveImageImage(index int) {
|
|
copy(t.image[index:], t.image[index+1:])
|
|
t.image[len(t.image)-1] = nil
|
|
t.image = t.image[:len(t.image)-1]
|
|
|
|
}
|
|
|
|
// IsImageLink determines whether the call to GetImageLink is safe for the specified index
|
|
func (t *Join) IsImageLink(index int) (ok bool) {
|
|
return t.image[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetImageLink returns the value safely if IsImageLink returned true for the specified index
|
|
func (t *Join) GetImageLink(index int) (v LinkType) {
|
|
return t.image[index].Link
|
|
|
|
}
|
|
|
|
// AppendImageLink adds to the back of image a LinkType type
|
|
func (t *Join) AppendImageLink(v LinkType) {
|
|
t.image = append(t.image, &imageJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependImageLink adds to the front of image a LinkType type
|
|
func (t *Join) PrependImageLink(v LinkType) {
|
|
t.image = append([]*imageJoinIntermediateType{&imageJoinIntermediateType{Link: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageLink deletes the value from the specified index
|
|
func (t *Join) RemoveImageLink(index int) {
|
|
copy(t.image[index:], t.image[index+1:])
|
|
t.image[len(t.image)-1] = nil
|
|
t.image = t.image[:len(t.image)-1]
|
|
|
|
}
|
|
|
|
// IsImageIRI determines whether the call to GetImageIRI is safe for the specified index
|
|
func (t *Join) IsImageIRI(index int) (ok bool) {
|
|
return t.image[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetImageIRI returns the value safely if IsImageIRI returned true for the specified index
|
|
func (t *Join) GetImageIRI(index int) (v *url.URL) {
|
|
return t.image[index].IRI
|
|
|
|
}
|
|
|
|
// AppendImageIRI adds to the back of image a *url.URL type
|
|
func (t *Join) AppendImageIRI(v *url.URL) {
|
|
t.image = append(t.image, &imageJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependImageIRI adds to the front of image a *url.URL type
|
|
func (t *Join) PrependImageIRI(v *url.URL) {
|
|
t.image = append([]*imageJoinIntermediateType{&imageJoinIntermediateType{IRI: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageIRI deletes the value from the specified index
|
|
func (t *Join) RemoveImageIRI(index int) {
|
|
copy(t.image[index:], t.image[index+1:])
|
|
t.image[len(t.image)-1] = nil
|
|
t.image = t.image[:len(t.image)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownImage determines whether the call to GetUnknownImage is safe
|
|
func (t *Join) HasUnknownImage() (ok bool) {
|
|
return t.image != nil && t.image[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownImage returns the unknown value for image
|
|
func (t *Join) GetUnknownImage() (v interface{}) {
|
|
return t.image[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownImage sets the unknown value of image
|
|
func (t *Join) SetUnknownImage(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &imageJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.image = append(t.image, tmp)
|
|
|
|
}
|
|
|
|
// InReplyToLen determines the number of elements able to be used for the IsInReplyToObject, GetInReplyToObject, and RemoveInReplyToObject functions
|
|
func (t *Join) InReplyToLen() (l int) {
|
|
return len(t.inReplyTo)
|
|
|
|
}
|
|
|
|
// IsInReplyToObject determines whether the call to GetInReplyToObject is safe for the specified index
|
|
func (t *Join) IsInReplyToObject(index int) (ok bool) {
|
|
return t.inReplyTo[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetInReplyToObject returns the value safely if IsInReplyToObject returned true for the specified index
|
|
func (t *Join) GetInReplyToObject(index int) (v ObjectType) {
|
|
return t.inReplyTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendInReplyToObject adds to the back of inReplyTo a ObjectType type
|
|
func (t *Join) AppendInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToObject adds to the front of inReplyTo a ObjectType type
|
|
func (t *Join) PrependInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append([]*inReplyToJoinIntermediateType{&inReplyToJoinIntermediateType{Object: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToObject deletes the value from the specified index
|
|
func (t *Join) RemoveInReplyToObject(index int) {
|
|
copy(t.inReplyTo[index:], t.inReplyTo[index+1:])
|
|
t.inReplyTo[len(t.inReplyTo)-1] = nil
|
|
t.inReplyTo = t.inReplyTo[:len(t.inReplyTo)-1]
|
|
|
|
}
|
|
|
|
// IsInReplyToLink determines whether the call to GetInReplyToLink is safe for the specified index
|
|
func (t *Join) IsInReplyToLink(index int) (ok bool) {
|
|
return t.inReplyTo[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetInReplyToLink returns the value safely if IsInReplyToLink returned true for the specified index
|
|
func (t *Join) GetInReplyToLink(index int) (v LinkType) {
|
|
return t.inReplyTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendInReplyToLink adds to the back of inReplyTo a LinkType type
|
|
func (t *Join) AppendInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToLink adds to the front of inReplyTo a LinkType type
|
|
func (t *Join) PrependInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append([]*inReplyToJoinIntermediateType{&inReplyToJoinIntermediateType{Link: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToLink deletes the value from the specified index
|
|
func (t *Join) RemoveInReplyToLink(index int) {
|
|
copy(t.inReplyTo[index:], t.inReplyTo[index+1:])
|
|
t.inReplyTo[len(t.inReplyTo)-1] = nil
|
|
t.inReplyTo = t.inReplyTo[:len(t.inReplyTo)-1]
|
|
|
|
}
|
|
|
|
// IsInReplyToIRI determines whether the call to GetInReplyToIRI is safe for the specified index
|
|
func (t *Join) IsInReplyToIRI(index int) (ok bool) {
|
|
return t.inReplyTo[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetInReplyToIRI returns the value safely if IsInReplyToIRI returned true for the specified index
|
|
func (t *Join) GetInReplyToIRI(index int) (v *url.URL) {
|
|
return t.inReplyTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInReplyToIRI adds to the back of inReplyTo a *url.URL type
|
|
func (t *Join) AppendInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToIRI adds to the front of inReplyTo a *url.URL type
|
|
func (t *Join) PrependInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append([]*inReplyToJoinIntermediateType{&inReplyToJoinIntermediateType{IRI: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToIRI deletes the value from the specified index
|
|
func (t *Join) RemoveInReplyToIRI(index int) {
|
|
copy(t.inReplyTo[index:], t.inReplyTo[index+1:])
|
|
t.inReplyTo[len(t.inReplyTo)-1] = nil
|
|
t.inReplyTo = t.inReplyTo[:len(t.inReplyTo)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownInReplyTo determines whether the call to GetUnknownInReplyTo is safe
|
|
func (t *Join) HasUnknownInReplyTo() (ok bool) {
|
|
return t.inReplyTo != nil && t.inReplyTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInReplyTo returns the unknown value for inReplyTo
|
|
func (t *Join) GetUnknownInReplyTo() (v interface{}) {
|
|
return t.inReplyTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInReplyTo sets the unknown value of inReplyTo
|
|
func (t *Join) SetUnknownInReplyTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inReplyToJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.inReplyTo = append(t.inReplyTo, tmp)
|
|
|
|
}
|
|
|
|
// LocationLen determines the number of elements able to be used for the IsLocationObject, GetLocationObject, and RemoveLocationObject functions
|
|
func (t *Join) LocationLen() (l int) {
|
|
return len(t.location)
|
|
|
|
}
|
|
|
|
// IsLocationObject determines whether the call to GetLocationObject is safe for the specified index
|
|
func (t *Join) IsLocationObject(index int) (ok bool) {
|
|
return t.location[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetLocationObject returns the value safely if IsLocationObject returned true for the specified index
|
|
func (t *Join) GetLocationObject(index int) (v ObjectType) {
|
|
return t.location[index].Object
|
|
|
|
}
|
|
|
|
// AppendLocationObject adds to the back of location a ObjectType type
|
|
func (t *Join) AppendLocationObject(v ObjectType) {
|
|
t.location = append(t.location, &locationJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependLocationObject adds to the front of location a ObjectType type
|
|
func (t *Join) PrependLocationObject(v ObjectType) {
|
|
t.location = append([]*locationJoinIntermediateType{&locationJoinIntermediateType{Object: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationObject deletes the value from the specified index
|
|
func (t *Join) RemoveLocationObject(index int) {
|
|
copy(t.location[index:], t.location[index+1:])
|
|
t.location[len(t.location)-1] = nil
|
|
t.location = t.location[:len(t.location)-1]
|
|
|
|
}
|
|
|
|
// IsLocationLink determines whether the call to GetLocationLink is safe for the specified index
|
|
func (t *Join) IsLocationLink(index int) (ok bool) {
|
|
return t.location[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetLocationLink returns the value safely if IsLocationLink returned true for the specified index
|
|
func (t *Join) GetLocationLink(index int) (v LinkType) {
|
|
return t.location[index].Link
|
|
|
|
}
|
|
|
|
// AppendLocationLink adds to the back of location a LinkType type
|
|
func (t *Join) AppendLocationLink(v LinkType) {
|
|
t.location = append(t.location, &locationJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependLocationLink adds to the front of location a LinkType type
|
|
func (t *Join) PrependLocationLink(v LinkType) {
|
|
t.location = append([]*locationJoinIntermediateType{&locationJoinIntermediateType{Link: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationLink deletes the value from the specified index
|
|
func (t *Join) RemoveLocationLink(index int) {
|
|
copy(t.location[index:], t.location[index+1:])
|
|
t.location[len(t.location)-1] = nil
|
|
t.location = t.location[:len(t.location)-1]
|
|
|
|
}
|
|
|
|
// IsLocationIRI determines whether the call to GetLocationIRI is safe for the specified index
|
|
func (t *Join) IsLocationIRI(index int) (ok bool) {
|
|
return t.location[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetLocationIRI returns the value safely if IsLocationIRI returned true for the specified index
|
|
func (t *Join) GetLocationIRI(index int) (v *url.URL) {
|
|
return t.location[index].IRI
|
|
|
|
}
|
|
|
|
// AppendLocationIRI adds to the back of location a *url.URL type
|
|
func (t *Join) AppendLocationIRI(v *url.URL) {
|
|
t.location = append(t.location, &locationJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependLocationIRI adds to the front of location a *url.URL type
|
|
func (t *Join) PrependLocationIRI(v *url.URL) {
|
|
t.location = append([]*locationJoinIntermediateType{&locationJoinIntermediateType{IRI: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationIRI deletes the value from the specified index
|
|
func (t *Join) RemoveLocationIRI(index int) {
|
|
copy(t.location[index:], t.location[index+1:])
|
|
t.location[len(t.location)-1] = nil
|
|
t.location = t.location[:len(t.location)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownLocation determines whether the call to GetUnknownLocation is safe
|
|
func (t *Join) HasUnknownLocation() (ok bool) {
|
|
return t.location != nil && t.location[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLocation returns the unknown value for location
|
|
func (t *Join) GetUnknownLocation() (v interface{}) {
|
|
return t.location[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLocation sets the unknown value of location
|
|
func (t *Join) SetUnknownLocation(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &locationJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.location = append(t.location, tmp)
|
|
|
|
}
|
|
|
|
// PreviewLen determines the number of elements able to be used for the IsPreviewObject, GetPreviewObject, and RemovePreviewObject functions
|
|
func (t *Join) PreviewLen() (l int) {
|
|
return len(t.preview)
|
|
|
|
}
|
|
|
|
// IsPreviewObject determines whether the call to GetPreviewObject is safe for the specified index
|
|
func (t *Join) IsPreviewObject(index int) (ok bool) {
|
|
return t.preview[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetPreviewObject returns the value safely if IsPreviewObject returned true for the specified index
|
|
func (t *Join) GetPreviewObject(index int) (v ObjectType) {
|
|
return t.preview[index].Object
|
|
|
|
}
|
|
|
|
// AppendPreviewObject adds to the back of preview a ObjectType type
|
|
func (t *Join) AppendPreviewObject(v ObjectType) {
|
|
t.preview = append(t.preview, &previewJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewObject adds to the front of preview a ObjectType type
|
|
func (t *Join) PrependPreviewObject(v ObjectType) {
|
|
t.preview = append([]*previewJoinIntermediateType{&previewJoinIntermediateType{Object: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewObject deletes the value from the specified index
|
|
func (t *Join) RemovePreviewObject(index int) {
|
|
copy(t.preview[index:], t.preview[index+1:])
|
|
t.preview[len(t.preview)-1] = nil
|
|
t.preview = t.preview[:len(t.preview)-1]
|
|
|
|
}
|
|
|
|
// IsPreviewLink determines whether the call to GetPreviewLink is safe for the specified index
|
|
func (t *Join) IsPreviewLink(index int) (ok bool) {
|
|
return t.preview[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetPreviewLink returns the value safely if IsPreviewLink returned true for the specified index
|
|
func (t *Join) GetPreviewLink(index int) (v LinkType) {
|
|
return t.preview[index].Link
|
|
|
|
}
|
|
|
|
// AppendPreviewLink adds to the back of preview a LinkType type
|
|
func (t *Join) AppendPreviewLink(v LinkType) {
|
|
t.preview = append(t.preview, &previewJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewLink adds to the front of preview a LinkType type
|
|
func (t *Join) PrependPreviewLink(v LinkType) {
|
|
t.preview = append([]*previewJoinIntermediateType{&previewJoinIntermediateType{Link: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewLink deletes the value from the specified index
|
|
func (t *Join) RemovePreviewLink(index int) {
|
|
copy(t.preview[index:], t.preview[index+1:])
|
|
t.preview[len(t.preview)-1] = nil
|
|
t.preview = t.preview[:len(t.preview)-1]
|
|
|
|
}
|
|
|
|
// IsPreviewIRI determines whether the call to GetPreviewIRI is safe for the specified index
|
|
func (t *Join) IsPreviewIRI(index int) (ok bool) {
|
|
return t.preview[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetPreviewIRI returns the value safely if IsPreviewIRI returned true for the specified index
|
|
func (t *Join) GetPreviewIRI(index int) (v *url.URL) {
|
|
return t.preview[index].IRI
|
|
|
|
}
|
|
|
|
// AppendPreviewIRI adds to the back of preview a *url.URL type
|
|
func (t *Join) AppendPreviewIRI(v *url.URL) {
|
|
t.preview = append(t.preview, &previewJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewIRI adds to the front of preview a *url.URL type
|
|
func (t *Join) PrependPreviewIRI(v *url.URL) {
|
|
t.preview = append([]*previewJoinIntermediateType{&previewJoinIntermediateType{IRI: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewIRI deletes the value from the specified index
|
|
func (t *Join) RemovePreviewIRI(index int) {
|
|
copy(t.preview[index:], t.preview[index+1:])
|
|
t.preview[len(t.preview)-1] = nil
|
|
t.preview = t.preview[:len(t.preview)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownPreview determines whether the call to GetUnknownPreview is safe
|
|
func (t *Join) HasUnknownPreview() (ok bool) {
|
|
return t.preview != nil && t.preview[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreview returns the unknown value for preview
|
|
func (t *Join) GetUnknownPreview() (v interface{}) {
|
|
return t.preview[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreview sets the unknown value of preview
|
|
func (t *Join) SetUnknownPreview(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &previewJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preview = append(t.preview, tmp)
|
|
|
|
}
|
|
|
|
// IsPublished determines whether the call to GetPublished is safe
|
|
func (t *Join) IsPublished() (ok bool) {
|
|
return t.published != nil && t.published.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetPublished returns the value safely if IsPublished returned true
|
|
func (t *Join) GetPublished() (v time.Time) {
|
|
return *t.published.dateTime
|
|
|
|
}
|
|
|
|
// SetPublished sets the value of published to be of time.Time type
|
|
func (t *Join) SetPublished(v time.Time) {
|
|
t.published = &publishedJoinIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsPublishedIRI determines whether the call to GetPublishedIRI is safe
|
|
func (t *Join) IsPublishedIRI() (ok bool) {
|
|
return t.published != nil && t.published.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPublishedIRI returns the value safely if IsPublishedIRI returned true
|
|
func (t *Join) GetPublishedIRI() (v *url.URL) {
|
|
return t.published.IRI
|
|
|
|
}
|
|
|
|
// SetPublishedIRI sets the value of published to be of *url.URL type
|
|
func (t *Join) SetPublishedIRI(v *url.URL) {
|
|
t.published = &publishedJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPublished determines whether the call to GetUnknownPublished is safe
|
|
func (t *Join) HasUnknownPublished() (ok bool) {
|
|
return t.published != nil && t.published.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPublished returns the unknown value for published
|
|
func (t *Join) GetUnknownPublished() (v interface{}) {
|
|
return t.published.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPublished sets the unknown value of published
|
|
func (t *Join) SetUnknownPublished(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &publishedJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.published = tmp
|
|
|
|
}
|
|
|
|
// IsReplies determines whether the call to GetReplies is safe
|
|
func (t *Join) IsReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.Collection != nil
|
|
|
|
}
|
|
|
|
// GetReplies returns the value safely if IsReplies returned true
|
|
func (t *Join) GetReplies() (v CollectionType) {
|
|
return t.replies.Collection
|
|
|
|
}
|
|
|
|
// SetReplies sets the value of replies to be of CollectionType type
|
|
func (t *Join) SetReplies(v CollectionType) {
|
|
t.replies = &repliesJoinIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsRepliesIRI determines whether the call to GetRepliesIRI is safe
|
|
func (t *Join) IsRepliesIRI() (ok bool) {
|
|
return t.replies != nil && t.replies.IRI != nil
|
|
|
|
}
|
|
|
|
// GetRepliesIRI returns the value safely if IsRepliesIRI returned true
|
|
func (t *Join) GetRepliesIRI() (v *url.URL) {
|
|
return t.replies.IRI
|
|
|
|
}
|
|
|
|
// SetRepliesIRI sets the value of replies to be of *url.URL type
|
|
func (t *Join) SetRepliesIRI(v *url.URL) {
|
|
t.replies = &repliesJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownReplies determines whether the call to GetUnknownReplies is safe
|
|
func (t *Join) HasUnknownReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownReplies returns the unknown value for replies
|
|
func (t *Join) GetUnknownReplies() (v interface{}) {
|
|
return t.replies.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownReplies sets the unknown value of replies
|
|
func (t *Join) SetUnknownReplies(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &repliesJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.replies = tmp
|
|
|
|
}
|
|
|
|
// IsStartTime determines whether the call to GetStartTime is safe
|
|
func (t *Join) IsStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetStartTime returns the value safely if IsStartTime returned true
|
|
func (t *Join) GetStartTime() (v time.Time) {
|
|
return *t.startTime.dateTime
|
|
|
|
}
|
|
|
|
// SetStartTime sets the value of startTime to be of time.Time type
|
|
func (t *Join) SetStartTime(v time.Time) {
|
|
t.startTime = &startTimeJoinIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsStartTimeIRI determines whether the call to GetStartTimeIRI is safe
|
|
func (t *Join) IsStartTimeIRI() (ok bool) {
|
|
return t.startTime != nil && t.startTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetStartTimeIRI returns the value safely if IsStartTimeIRI returned true
|
|
func (t *Join) GetStartTimeIRI() (v *url.URL) {
|
|
return t.startTime.IRI
|
|
|
|
}
|
|
|
|
// SetStartTimeIRI sets the value of startTime to be of *url.URL type
|
|
func (t *Join) SetStartTimeIRI(v *url.URL) {
|
|
t.startTime = &startTimeJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownStartTime determines whether the call to GetUnknownStartTime is safe
|
|
func (t *Join) HasUnknownStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStartTime returns the unknown value for startTime
|
|
func (t *Join) GetUnknownStartTime() (v interface{}) {
|
|
return t.startTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownStartTime sets the unknown value of startTime
|
|
func (t *Join) SetUnknownStartTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &startTimeJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.startTime = tmp
|
|
|
|
}
|
|
|
|
// SummaryLen determines the number of elements able to be used for the IsSummaryString, GetSummaryString, and RemoveSummaryString functions
|
|
func (t *Join) SummaryLen() (l int) {
|
|
return len(t.summary)
|
|
|
|
}
|
|
|
|
// IsSummaryString determines whether the call to GetSummaryString is safe for the specified index
|
|
func (t *Join) IsSummaryString(index int) (ok bool) {
|
|
return t.summary[index].stringName != nil
|
|
|
|
}
|
|
|
|
// GetSummaryString returns the value safely if IsSummaryString returned true for the specified index
|
|
func (t *Join) GetSummaryString(index int) (v string) {
|
|
return *t.summary[index].stringName
|
|
|
|
}
|
|
|
|
// AppendSummaryString adds to the back of summary a string type
|
|
func (t *Join) AppendSummaryString(v string) {
|
|
t.summary = append(t.summary, &summaryJoinIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryString adds to the front of summary a string type
|
|
func (t *Join) PrependSummaryString(v string) {
|
|
t.summary = append([]*summaryJoinIntermediateType{&summaryJoinIntermediateType{stringName: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryString deletes the value from the specified index
|
|
func (t *Join) RemoveSummaryString(index int) {
|
|
copy(t.summary[index:], t.summary[index+1:])
|
|
t.summary[len(t.summary)-1] = nil
|
|
t.summary = t.summary[:len(t.summary)-1]
|
|
|
|
}
|
|
|
|
// IsSummaryLangString determines whether the call to GetSummaryLangString is safe for the specified index
|
|
func (t *Join) IsSummaryLangString(index int) (ok bool) {
|
|
return t.summary[index].langString != nil
|
|
|
|
}
|
|
|
|
// GetSummaryLangString returns the value safely if IsSummaryLangString returned true for the specified index
|
|
func (t *Join) GetSummaryLangString(index int) (v string) {
|
|
return *t.summary[index].langString
|
|
|
|
}
|
|
|
|
// AppendSummaryLangString adds to the back of summary a string type
|
|
func (t *Join) AppendSummaryLangString(v string) {
|
|
t.summary = append(t.summary, &summaryJoinIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryLangString adds to the front of summary a string type
|
|
func (t *Join) PrependSummaryLangString(v string) {
|
|
t.summary = append([]*summaryJoinIntermediateType{&summaryJoinIntermediateType{langString: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryLangString deletes the value from the specified index
|
|
func (t *Join) RemoveSummaryLangString(index int) {
|
|
copy(t.summary[index:], t.summary[index+1:])
|
|
t.summary[len(t.summary)-1] = nil
|
|
t.summary = t.summary[:len(t.summary)-1]
|
|
|
|
}
|
|
|
|
// IsSummaryIRI determines whether the call to GetSummaryIRI is safe for the specified index
|
|
func (t *Join) IsSummaryIRI(index int) (ok bool) {
|
|
return t.summary[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetSummaryIRI returns the value safely if IsSummaryIRI returned true for the specified index
|
|
func (t *Join) GetSummaryIRI(index int) (v *url.URL) {
|
|
return t.summary[index].IRI
|
|
|
|
}
|
|
|
|
// AppendSummaryIRI adds to the back of summary a *url.URL type
|
|
func (t *Join) AppendSummaryIRI(v *url.URL) {
|
|
t.summary = append(t.summary, &summaryJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependSummaryIRI adds to the front of summary a *url.URL type
|
|
func (t *Join) PrependSummaryIRI(v *url.URL) {
|
|
t.summary = append([]*summaryJoinIntermediateType{&summaryJoinIntermediateType{IRI: v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryIRI deletes the value from the specified index
|
|
func (t *Join) RemoveSummaryIRI(index int) {
|
|
copy(t.summary[index:], t.summary[index+1:])
|
|
t.summary[len(t.summary)-1] = nil
|
|
t.summary = t.summary[:len(t.summary)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownSummary determines whether the call to GetUnknownSummary is safe
|
|
func (t *Join) HasUnknownSummary() (ok bool) {
|
|
return t.summary != nil && t.summary[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSummary returns the unknown value for summary
|
|
func (t *Join) GetUnknownSummary() (v interface{}) {
|
|
return t.summary[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSummary sets the unknown value of summary
|
|
func (t *Join) SetUnknownSummary(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &summaryJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.summary = append(t.summary, tmp)
|
|
|
|
}
|
|
|
|
// SummaryMapLanguages returns all languages for this property's language mapping, or nil if there are none.
|
|
func (t *Join) SummaryMapLanguages() (l []string) {
|
|
if t.summaryMap == nil || len(t.summaryMap) == 0 {
|
|
return nil
|
|
}
|
|
for k := range t.summaryMap {
|
|
l = append(l, k)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// GetSummaryMap retrieves the value of the property for the specified language, or an empty string if it does not exist
|
|
func (t *Join) GetSummaryMap(l string) (v string) {
|
|
if t.summaryMap == nil {
|
|
return ""
|
|
}
|
|
ok := false
|
|
v, ok = t.summaryMap[l]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
return v
|
|
|
|
}
|
|
|
|
// SetSummaryMap sets the value of the property for the specified language
|
|
func (t *Join) SetSummaryMap(l string, v string) {
|
|
if t.summaryMap == nil {
|
|
t.summaryMap = make(map[string]string)
|
|
}
|
|
t.summaryMap[l] = v
|
|
|
|
}
|
|
|
|
// TagLen determines the number of elements able to be used for the IsTagObject, GetTagObject, and RemoveTagObject functions
|
|
func (t *Join) TagLen() (l int) {
|
|
return len(t.tag)
|
|
|
|
}
|
|
|
|
// IsTagObject determines whether the call to GetTagObject is safe for the specified index
|
|
func (t *Join) IsTagObject(index int) (ok bool) {
|
|
return t.tag[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetTagObject returns the value safely if IsTagObject returned true for the specified index
|
|
func (t *Join) GetTagObject(index int) (v ObjectType) {
|
|
return t.tag[index].Object
|
|
|
|
}
|
|
|
|
// AppendTagObject adds to the back of tag a ObjectType type
|
|
func (t *Join) AppendTagObject(v ObjectType) {
|
|
t.tag = append(t.tag, &tagJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTagObject adds to the front of tag a ObjectType type
|
|
func (t *Join) PrependTagObject(v ObjectType) {
|
|
t.tag = append([]*tagJoinIntermediateType{&tagJoinIntermediateType{Object: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagObject deletes the value from the specified index
|
|
func (t *Join) RemoveTagObject(index int) {
|
|
copy(t.tag[index:], t.tag[index+1:])
|
|
t.tag[len(t.tag)-1] = nil
|
|
t.tag = t.tag[:len(t.tag)-1]
|
|
|
|
}
|
|
|
|
// IsTagLink determines whether the call to GetTagLink is safe for the specified index
|
|
func (t *Join) IsTagLink(index int) (ok bool) {
|
|
return t.tag[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetTagLink returns the value safely if IsTagLink returned true for the specified index
|
|
func (t *Join) GetTagLink(index int) (v LinkType) {
|
|
return t.tag[index].Link
|
|
|
|
}
|
|
|
|
// AppendTagLink adds to the back of tag a LinkType type
|
|
func (t *Join) AppendTagLink(v LinkType) {
|
|
t.tag = append(t.tag, &tagJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTagLink adds to the front of tag a LinkType type
|
|
func (t *Join) PrependTagLink(v LinkType) {
|
|
t.tag = append([]*tagJoinIntermediateType{&tagJoinIntermediateType{Link: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagLink deletes the value from the specified index
|
|
func (t *Join) RemoveTagLink(index int) {
|
|
copy(t.tag[index:], t.tag[index+1:])
|
|
t.tag[len(t.tag)-1] = nil
|
|
t.tag = t.tag[:len(t.tag)-1]
|
|
|
|
}
|
|
|
|
// IsTagIRI determines whether the call to GetTagIRI is safe for the specified index
|
|
func (t *Join) IsTagIRI(index int) (ok bool) {
|
|
return t.tag[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetTagIRI returns the value safely if IsTagIRI returned true for the specified index
|
|
func (t *Join) GetTagIRI(index int) (v *url.URL) {
|
|
return t.tag[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTagIRI adds to the back of tag a *url.URL type
|
|
func (t *Join) AppendTagIRI(v *url.URL) {
|
|
t.tag = append(t.tag, &tagJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTagIRI adds to the front of tag a *url.URL type
|
|
func (t *Join) PrependTagIRI(v *url.URL) {
|
|
t.tag = append([]*tagJoinIntermediateType{&tagJoinIntermediateType{IRI: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagIRI deletes the value from the specified index
|
|
func (t *Join) RemoveTagIRI(index int) {
|
|
copy(t.tag[index:], t.tag[index+1:])
|
|
t.tag[len(t.tag)-1] = nil
|
|
t.tag = t.tag[:len(t.tag)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownTag determines whether the call to GetUnknownTag is safe
|
|
func (t *Join) HasUnknownTag() (ok bool) {
|
|
return t.tag != nil && t.tag[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTag returns the unknown value for tag
|
|
func (t *Join) GetUnknownTag() (v interface{}) {
|
|
return t.tag[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTag sets the unknown value of tag
|
|
func (t *Join) SetUnknownTag(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &tagJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.tag = append(t.tag, tmp)
|
|
|
|
}
|
|
|
|
// TypeLen determines the number of elements able to be used for the GetType and RemoveType functions
|
|
func (t *Join) TypeLen() (l int) {
|
|
return len(t.typeName)
|
|
|
|
}
|
|
|
|
// GetType returns the value for the specified index
|
|
func (t *Join) GetType(index int) (v interface{}) {
|
|
return t.typeName[index]
|
|
|
|
}
|
|
|
|
// AppendType adds a value to the back of type
|
|
func (t *Join) AppendType(v interface{}) {
|
|
t.typeName = append(t.typeName, v)
|
|
|
|
}
|
|
|
|
// PrependType adds a value to the front of type
|
|
func (t *Join) PrependType(v interface{}) {
|
|
t.typeName = append([]interface{}{v}, t.typeName...)
|
|
|
|
}
|
|
|
|
// RemoveType deletes the value from the specified index
|
|
func (t *Join) RemoveType(index int) {
|
|
copy(t.typeName[index:], t.typeName[index+1:])
|
|
t.typeName[len(t.typeName)-1] = nil
|
|
t.typeName = t.typeName[:len(t.typeName)-1]
|
|
|
|
}
|
|
|
|
// IsUpdated determines whether the call to GetUpdated is safe
|
|
func (t *Join) IsUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetUpdated returns the value safely if IsUpdated returned true
|
|
func (t *Join) GetUpdated() (v time.Time) {
|
|
return *t.updated.dateTime
|
|
|
|
}
|
|
|
|
// SetUpdated sets the value of updated to be of time.Time type
|
|
func (t *Join) SetUpdated(v time.Time) {
|
|
t.updated = &updatedJoinIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsUpdatedIRI determines whether the call to GetUpdatedIRI is safe
|
|
func (t *Join) IsUpdatedIRI() (ok bool) {
|
|
return t.updated != nil && t.updated.IRI != nil
|
|
|
|
}
|
|
|
|
// GetUpdatedIRI returns the value safely if IsUpdatedIRI returned true
|
|
func (t *Join) GetUpdatedIRI() (v *url.URL) {
|
|
return t.updated.IRI
|
|
|
|
}
|
|
|
|
// SetUpdatedIRI sets the value of updated to be of *url.URL type
|
|
func (t *Join) SetUpdatedIRI(v *url.URL) {
|
|
t.updated = &updatedJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownUpdated determines whether the call to GetUnknownUpdated is safe
|
|
func (t *Join) HasUnknownUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUpdated returns the unknown value for updated
|
|
func (t *Join) GetUnknownUpdated() (v interface{}) {
|
|
return t.updated.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUpdated sets the unknown value of updated
|
|
func (t *Join) SetUnknownUpdated(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &updatedJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.updated = tmp
|
|
|
|
}
|
|
|
|
// UrlLen determines the number of elements able to be used for the IsUrlAnyURI, GetUrlAnyURI, and RemoveUrlAnyURI functions
|
|
func (t *Join) UrlLen() (l int) {
|
|
return len(t.url)
|
|
|
|
}
|
|
|
|
// IsUrlAnyURI determines whether the call to GetUrlAnyURI is safe for the specified index
|
|
func (t *Join) IsUrlAnyURI(index int) (ok bool) {
|
|
return t.url[index].anyURI != nil
|
|
|
|
}
|
|
|
|
// GetUrlAnyURI returns the value safely if IsUrlAnyURI returned true for the specified index
|
|
func (t *Join) GetUrlAnyURI(index int) (v *url.URL) {
|
|
return t.url[index].anyURI
|
|
|
|
}
|
|
|
|
// AppendUrlAnyURI adds to the back of url a *url.URL type
|
|
func (t *Join) AppendUrlAnyURI(v *url.URL) {
|
|
t.url = append(t.url, &urlJoinIntermediateType{anyURI: v})
|
|
|
|
}
|
|
|
|
// PrependUrlAnyURI adds to the front of url a *url.URL type
|
|
func (t *Join) PrependUrlAnyURI(v *url.URL) {
|
|
t.url = append([]*urlJoinIntermediateType{&urlJoinIntermediateType{anyURI: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlAnyURI deletes the value from the specified index
|
|
func (t *Join) RemoveUrlAnyURI(index int) {
|
|
copy(t.url[index:], t.url[index+1:])
|
|
t.url[len(t.url)-1] = nil
|
|
t.url = t.url[:len(t.url)-1]
|
|
|
|
}
|
|
|
|
// IsUrlLink determines whether the call to GetUrlLink is safe for the specified index
|
|
func (t *Join) IsUrlLink(index int) (ok bool) {
|
|
return t.url[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetUrlLink returns the value safely if IsUrlLink returned true for the specified index
|
|
func (t *Join) GetUrlLink(index int) (v LinkType) {
|
|
return t.url[index].Link
|
|
|
|
}
|
|
|
|
// AppendUrlLink adds to the back of url a LinkType type
|
|
func (t *Join) AppendUrlLink(v LinkType) {
|
|
t.url = append(t.url, &urlJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependUrlLink adds to the front of url a LinkType type
|
|
func (t *Join) PrependUrlLink(v LinkType) {
|
|
t.url = append([]*urlJoinIntermediateType{&urlJoinIntermediateType{Link: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlLink deletes the value from the specified index
|
|
func (t *Join) RemoveUrlLink(index int) {
|
|
copy(t.url[index:], t.url[index+1:])
|
|
t.url[len(t.url)-1] = nil
|
|
t.url = t.url[:len(t.url)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownUrl determines whether the call to GetUnknownUrl is safe
|
|
func (t *Join) HasUnknownUrl() (ok bool) {
|
|
return t.url != nil && t.url[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUrl returns the unknown value for url
|
|
func (t *Join) GetUnknownUrl() (v interface{}) {
|
|
return t.url[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUrl sets the unknown value of url
|
|
func (t *Join) SetUnknownUrl(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &urlJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.url = append(t.url, tmp)
|
|
|
|
}
|
|
|
|
// ToLen determines the number of elements able to be used for the IsToObject, GetToObject, and RemoveToObject functions
|
|
func (t *Join) ToLen() (l int) {
|
|
return len(t.to)
|
|
|
|
}
|
|
|
|
// IsToObject determines whether the call to GetToObject is safe for the specified index
|
|
func (t *Join) IsToObject(index int) (ok bool) {
|
|
return t.to[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetToObject returns the value safely if IsToObject returned true for the specified index
|
|
func (t *Join) GetToObject(index int) (v ObjectType) {
|
|
return t.to[index].Object
|
|
|
|
}
|
|
|
|
// AppendToObject adds to the back of to a ObjectType type
|
|
func (t *Join) AppendToObject(v ObjectType) {
|
|
t.to = append(t.to, &toJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependToObject adds to the front of to a ObjectType type
|
|
func (t *Join) PrependToObject(v ObjectType) {
|
|
t.to = append([]*toJoinIntermediateType{&toJoinIntermediateType{Object: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToObject deletes the value from the specified index
|
|
func (t *Join) RemoveToObject(index int) {
|
|
copy(t.to[index:], t.to[index+1:])
|
|
t.to[len(t.to)-1] = nil
|
|
t.to = t.to[:len(t.to)-1]
|
|
|
|
}
|
|
|
|
// IsToLink determines whether the call to GetToLink is safe for the specified index
|
|
func (t *Join) IsToLink(index int) (ok bool) {
|
|
return t.to[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetToLink returns the value safely if IsToLink returned true for the specified index
|
|
func (t *Join) GetToLink(index int) (v LinkType) {
|
|
return t.to[index].Link
|
|
|
|
}
|
|
|
|
// AppendToLink adds to the back of to a LinkType type
|
|
func (t *Join) AppendToLink(v LinkType) {
|
|
t.to = append(t.to, &toJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependToLink adds to the front of to a LinkType type
|
|
func (t *Join) PrependToLink(v LinkType) {
|
|
t.to = append([]*toJoinIntermediateType{&toJoinIntermediateType{Link: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToLink deletes the value from the specified index
|
|
func (t *Join) RemoveToLink(index int) {
|
|
copy(t.to[index:], t.to[index+1:])
|
|
t.to[len(t.to)-1] = nil
|
|
t.to = t.to[:len(t.to)-1]
|
|
|
|
}
|
|
|
|
// IsToIRI determines whether the call to GetToIRI is safe for the specified index
|
|
func (t *Join) IsToIRI(index int) (ok bool) {
|
|
return t.to[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetToIRI returns the value safely if IsToIRI returned true for the specified index
|
|
func (t *Join) GetToIRI(index int) (v *url.URL) {
|
|
return t.to[index].IRI
|
|
|
|
}
|
|
|
|
// AppendToIRI adds to the back of to a *url.URL type
|
|
func (t *Join) AppendToIRI(v *url.URL) {
|
|
t.to = append(t.to, &toJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependToIRI adds to the front of to a *url.URL type
|
|
func (t *Join) PrependToIRI(v *url.URL) {
|
|
t.to = append([]*toJoinIntermediateType{&toJoinIntermediateType{IRI: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToIRI deletes the value from the specified index
|
|
func (t *Join) RemoveToIRI(index int) {
|
|
copy(t.to[index:], t.to[index+1:])
|
|
t.to[len(t.to)-1] = nil
|
|
t.to = t.to[:len(t.to)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownTo determines whether the call to GetUnknownTo is safe
|
|
func (t *Join) HasUnknownTo() (ok bool) {
|
|
return t.to != nil && t.to[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTo returns the unknown value for to
|
|
func (t *Join) GetUnknownTo() (v interface{}) {
|
|
return t.to[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTo sets the unknown value of to
|
|
func (t *Join) SetUnknownTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &toJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.to = append(t.to, tmp)
|
|
|
|
}
|
|
|
|
// BtoLen determines the number of elements able to be used for the IsBtoObject, GetBtoObject, and RemoveBtoObject functions
|
|
func (t *Join) BtoLen() (l int) {
|
|
return len(t.bto)
|
|
|
|
}
|
|
|
|
// IsBtoObject determines whether the call to GetBtoObject is safe for the specified index
|
|
func (t *Join) IsBtoObject(index int) (ok bool) {
|
|
return t.bto[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetBtoObject returns the value safely if IsBtoObject returned true for the specified index
|
|
func (t *Join) GetBtoObject(index int) (v ObjectType) {
|
|
return t.bto[index].Object
|
|
|
|
}
|
|
|
|
// AppendBtoObject adds to the back of bto a ObjectType type
|
|
func (t *Join) AppendBtoObject(v ObjectType) {
|
|
t.bto = append(t.bto, &btoJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBtoObject adds to the front of bto a ObjectType type
|
|
func (t *Join) PrependBtoObject(v ObjectType) {
|
|
t.bto = append([]*btoJoinIntermediateType{&btoJoinIntermediateType{Object: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoObject deletes the value from the specified index
|
|
func (t *Join) RemoveBtoObject(index int) {
|
|
copy(t.bto[index:], t.bto[index+1:])
|
|
t.bto[len(t.bto)-1] = nil
|
|
t.bto = t.bto[:len(t.bto)-1]
|
|
|
|
}
|
|
|
|
// IsBtoLink determines whether the call to GetBtoLink is safe for the specified index
|
|
func (t *Join) IsBtoLink(index int) (ok bool) {
|
|
return t.bto[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetBtoLink returns the value safely if IsBtoLink returned true for the specified index
|
|
func (t *Join) GetBtoLink(index int) (v LinkType) {
|
|
return t.bto[index].Link
|
|
|
|
}
|
|
|
|
// AppendBtoLink adds to the back of bto a LinkType type
|
|
func (t *Join) AppendBtoLink(v LinkType) {
|
|
t.bto = append(t.bto, &btoJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBtoLink adds to the front of bto a LinkType type
|
|
func (t *Join) PrependBtoLink(v LinkType) {
|
|
t.bto = append([]*btoJoinIntermediateType{&btoJoinIntermediateType{Link: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoLink deletes the value from the specified index
|
|
func (t *Join) RemoveBtoLink(index int) {
|
|
copy(t.bto[index:], t.bto[index+1:])
|
|
t.bto[len(t.bto)-1] = nil
|
|
t.bto = t.bto[:len(t.bto)-1]
|
|
|
|
}
|
|
|
|
// IsBtoIRI determines whether the call to GetBtoIRI is safe for the specified index
|
|
func (t *Join) IsBtoIRI(index int) (ok bool) {
|
|
return t.bto[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetBtoIRI returns the value safely if IsBtoIRI returned true for the specified index
|
|
func (t *Join) GetBtoIRI(index int) (v *url.URL) {
|
|
return t.bto[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBtoIRI adds to the back of bto a *url.URL type
|
|
func (t *Join) AppendBtoIRI(v *url.URL) {
|
|
t.bto = append(t.bto, &btoJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBtoIRI adds to the front of bto a *url.URL type
|
|
func (t *Join) PrependBtoIRI(v *url.URL) {
|
|
t.bto = append([]*btoJoinIntermediateType{&btoJoinIntermediateType{IRI: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoIRI deletes the value from the specified index
|
|
func (t *Join) RemoveBtoIRI(index int) {
|
|
copy(t.bto[index:], t.bto[index+1:])
|
|
t.bto[len(t.bto)-1] = nil
|
|
t.bto = t.bto[:len(t.bto)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownBto determines whether the call to GetUnknownBto is safe
|
|
func (t *Join) HasUnknownBto() (ok bool) {
|
|
return t.bto != nil && t.bto[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBto returns the unknown value for bto
|
|
func (t *Join) GetUnknownBto() (v interface{}) {
|
|
return t.bto[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBto sets the unknown value of bto
|
|
func (t *Join) SetUnknownBto(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &btoJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.bto = append(t.bto, tmp)
|
|
|
|
}
|
|
|
|
// CcLen determines the number of elements able to be used for the IsCcObject, GetCcObject, and RemoveCcObject functions
|
|
func (t *Join) CcLen() (l int) {
|
|
return len(t.cc)
|
|
|
|
}
|
|
|
|
// IsCcObject determines whether the call to GetCcObject is safe for the specified index
|
|
func (t *Join) IsCcObject(index int) (ok bool) {
|
|
return t.cc[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetCcObject returns the value safely if IsCcObject returned true for the specified index
|
|
func (t *Join) GetCcObject(index int) (v ObjectType) {
|
|
return t.cc[index].Object
|
|
|
|
}
|
|
|
|
// AppendCcObject adds to the back of cc a ObjectType type
|
|
func (t *Join) AppendCcObject(v ObjectType) {
|
|
t.cc = append(t.cc, &ccJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependCcObject adds to the front of cc a ObjectType type
|
|
func (t *Join) PrependCcObject(v ObjectType) {
|
|
t.cc = append([]*ccJoinIntermediateType{&ccJoinIntermediateType{Object: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcObject deletes the value from the specified index
|
|
func (t *Join) RemoveCcObject(index int) {
|
|
copy(t.cc[index:], t.cc[index+1:])
|
|
t.cc[len(t.cc)-1] = nil
|
|
t.cc = t.cc[:len(t.cc)-1]
|
|
|
|
}
|
|
|
|
// IsCcLink determines whether the call to GetCcLink is safe for the specified index
|
|
func (t *Join) IsCcLink(index int) (ok bool) {
|
|
return t.cc[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetCcLink returns the value safely if IsCcLink returned true for the specified index
|
|
func (t *Join) GetCcLink(index int) (v LinkType) {
|
|
return t.cc[index].Link
|
|
|
|
}
|
|
|
|
// AppendCcLink adds to the back of cc a LinkType type
|
|
func (t *Join) AppendCcLink(v LinkType) {
|
|
t.cc = append(t.cc, &ccJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependCcLink adds to the front of cc a LinkType type
|
|
func (t *Join) PrependCcLink(v LinkType) {
|
|
t.cc = append([]*ccJoinIntermediateType{&ccJoinIntermediateType{Link: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcLink deletes the value from the specified index
|
|
func (t *Join) RemoveCcLink(index int) {
|
|
copy(t.cc[index:], t.cc[index+1:])
|
|
t.cc[len(t.cc)-1] = nil
|
|
t.cc = t.cc[:len(t.cc)-1]
|
|
|
|
}
|
|
|
|
// IsCcIRI determines whether the call to GetCcIRI is safe for the specified index
|
|
func (t *Join) IsCcIRI(index int) (ok bool) {
|
|
return t.cc[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetCcIRI returns the value safely if IsCcIRI returned true for the specified index
|
|
func (t *Join) GetCcIRI(index int) (v *url.URL) {
|
|
return t.cc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendCcIRI adds to the back of cc a *url.URL type
|
|
func (t *Join) AppendCcIRI(v *url.URL) {
|
|
t.cc = append(t.cc, &ccJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependCcIRI adds to the front of cc a *url.URL type
|
|
func (t *Join) PrependCcIRI(v *url.URL) {
|
|
t.cc = append([]*ccJoinIntermediateType{&ccJoinIntermediateType{IRI: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcIRI deletes the value from the specified index
|
|
func (t *Join) RemoveCcIRI(index int) {
|
|
copy(t.cc[index:], t.cc[index+1:])
|
|
t.cc[len(t.cc)-1] = nil
|
|
t.cc = t.cc[:len(t.cc)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownCc determines whether the call to GetUnknownCc is safe
|
|
func (t *Join) HasUnknownCc() (ok bool) {
|
|
return t.cc != nil && t.cc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownCc returns the unknown value for cc
|
|
func (t *Join) GetUnknownCc() (v interface{}) {
|
|
return t.cc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownCc sets the unknown value of cc
|
|
func (t *Join) SetUnknownCc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &ccJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.cc = append(t.cc, tmp)
|
|
|
|
}
|
|
|
|
// BccLen determines the number of elements able to be used for the IsBccObject, GetBccObject, and RemoveBccObject functions
|
|
func (t *Join) BccLen() (l int) {
|
|
return len(t.bcc)
|
|
|
|
}
|
|
|
|
// IsBccObject determines whether the call to GetBccObject is safe for the specified index
|
|
func (t *Join) IsBccObject(index int) (ok bool) {
|
|
return t.bcc[index].Object != nil
|
|
|
|
}
|
|
|
|
// GetBccObject returns the value safely if IsBccObject returned true for the specified index
|
|
func (t *Join) GetBccObject(index int) (v ObjectType) {
|
|
return t.bcc[index].Object
|
|
|
|
}
|
|
|
|
// AppendBccObject adds to the back of bcc a ObjectType type
|
|
func (t *Join) AppendBccObject(v ObjectType) {
|
|
t.bcc = append(t.bcc, &bccJoinIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBccObject adds to the front of bcc a ObjectType type
|
|
func (t *Join) PrependBccObject(v ObjectType) {
|
|
t.bcc = append([]*bccJoinIntermediateType{&bccJoinIntermediateType{Object: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccObject deletes the value from the specified index
|
|
func (t *Join) RemoveBccObject(index int) {
|
|
copy(t.bcc[index:], t.bcc[index+1:])
|
|
t.bcc[len(t.bcc)-1] = nil
|
|
t.bcc = t.bcc[:len(t.bcc)-1]
|
|
|
|
}
|
|
|
|
// IsBccLink determines whether the call to GetBccLink is safe for the specified index
|
|
func (t *Join) IsBccLink(index int) (ok bool) {
|
|
return t.bcc[index].Link != nil
|
|
|
|
}
|
|
|
|
// GetBccLink returns the value safely if IsBccLink returned true for the specified index
|
|
func (t *Join) GetBccLink(index int) (v LinkType) {
|
|
return t.bcc[index].Link
|
|
|
|
}
|
|
|
|
// AppendBccLink adds to the back of bcc a LinkType type
|
|
func (t *Join) AppendBccLink(v LinkType) {
|
|
t.bcc = append(t.bcc, &bccJoinIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBccLink adds to the front of bcc a LinkType type
|
|
func (t *Join) PrependBccLink(v LinkType) {
|
|
t.bcc = append([]*bccJoinIntermediateType{&bccJoinIntermediateType{Link: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccLink deletes the value from the specified index
|
|
func (t *Join) RemoveBccLink(index int) {
|
|
copy(t.bcc[index:], t.bcc[index+1:])
|
|
t.bcc[len(t.bcc)-1] = nil
|
|
t.bcc = t.bcc[:len(t.bcc)-1]
|
|
|
|
}
|
|
|
|
// IsBccIRI determines whether the call to GetBccIRI is safe for the specified index
|
|
func (t *Join) IsBccIRI(index int) (ok bool) {
|
|
return t.bcc[index].IRI != nil
|
|
|
|
}
|
|
|
|
// GetBccIRI returns the value safely if IsBccIRI returned true for the specified index
|
|
func (t *Join) GetBccIRI(index int) (v *url.URL) {
|
|
return t.bcc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBccIRI adds to the back of bcc a *url.URL type
|
|
func (t *Join) AppendBccIRI(v *url.URL) {
|
|
t.bcc = append(t.bcc, &bccJoinIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBccIRI adds to the front of bcc a *url.URL type
|
|
func (t *Join) PrependBccIRI(v *url.URL) {
|
|
t.bcc = append([]*bccJoinIntermediateType{&bccJoinIntermediateType{IRI: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccIRI deletes the value from the specified index
|
|
func (t *Join) RemoveBccIRI(index int) {
|
|
copy(t.bcc[index:], t.bcc[index+1:])
|
|
t.bcc[len(t.bcc)-1] = nil
|
|
t.bcc = t.bcc[:len(t.bcc)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownBcc determines whether the call to GetUnknownBcc is safe
|
|
func (t *Join) HasUnknownBcc() (ok bool) {
|
|
return t.bcc != nil && t.bcc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBcc returns the unknown value for bcc
|
|
func (t *Join) GetUnknownBcc() (v interface{}) {
|
|
return t.bcc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBcc sets the unknown value of bcc
|
|
func (t *Join) SetUnknownBcc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &bccJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.bcc = append(t.bcc, tmp)
|
|
|
|
}
|
|
|
|
// IsMediaType determines whether the call to GetMediaType is safe
|
|
func (t *Join) IsMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.mimeMediaTypeValue != nil
|
|
|
|
}
|
|
|
|
// GetMediaType returns the value safely if IsMediaType returned true
|
|
func (t *Join) GetMediaType() (v string) {
|
|
return *t.mediaType.mimeMediaTypeValue
|
|
|
|
}
|
|
|
|
// SetMediaType sets the value of mediaType to be of string type
|
|
func (t *Join) SetMediaType(v string) {
|
|
t.mediaType = &mediaTypeJoinIntermediateType{mimeMediaTypeValue: &v}
|
|
|
|
}
|
|
|
|
// IsMediaTypeIRI determines whether the call to GetMediaTypeIRI is safe
|
|
func (t *Join) IsMediaTypeIRI() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.IRI != nil
|
|
|
|
}
|
|
|
|
// GetMediaTypeIRI returns the value safely if IsMediaTypeIRI returned true
|
|
func (t *Join) GetMediaTypeIRI() (v *url.URL) {
|
|
return t.mediaType.IRI
|
|
|
|
}
|
|
|
|
// SetMediaTypeIRI sets the value of mediaType to be of *url.URL type
|
|
func (t *Join) SetMediaTypeIRI(v *url.URL) {
|
|
t.mediaType = &mediaTypeJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownMediaType determines whether the call to GetUnknownMediaType is safe
|
|
func (t *Join) HasUnknownMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownMediaType returns the unknown value for mediaType
|
|
func (t *Join) GetUnknownMediaType() (v interface{}) {
|
|
return t.mediaType.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownMediaType sets the unknown value of mediaType
|
|
func (t *Join) SetUnknownMediaType(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &mediaTypeJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.mediaType = tmp
|
|
|
|
}
|
|
|
|
// IsDuration determines whether the call to GetDuration is safe
|
|
func (t *Join) IsDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.duration != nil
|
|
|
|
}
|
|
|
|
// GetDuration returns the value safely if IsDuration returned true
|
|
func (t *Join) GetDuration() (v time.Duration) {
|
|
return *t.duration.duration
|
|
|
|
}
|
|
|
|
// SetDuration sets the value of duration to be of time.Duration type
|
|
func (t *Join) SetDuration(v time.Duration) {
|
|
t.duration = &durationJoinIntermediateType{duration: &v}
|
|
|
|
}
|
|
|
|
// IsDurationIRI determines whether the call to GetDurationIRI is safe
|
|
func (t *Join) IsDurationIRI() (ok bool) {
|
|
return t.duration != nil && t.duration.IRI != nil
|
|
|
|
}
|
|
|
|
// GetDurationIRI returns the value safely if IsDurationIRI returned true
|
|
func (t *Join) GetDurationIRI() (v *url.URL) {
|
|
return t.duration.IRI
|
|
|
|
}
|
|
|
|
// SetDurationIRI sets the value of duration to be of *url.URL type
|
|
func (t *Join) SetDurationIRI(v *url.URL) {
|
|
t.duration = &durationJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownDuration determines whether the call to GetUnknownDuration is safe
|
|
func (t *Join) HasUnknownDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownDuration returns the unknown value for duration
|
|
func (t *Join) GetUnknownDuration() (v interface{}) {
|
|
return t.duration.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownDuration sets the unknown value of duration
|
|
func (t *Join) SetUnknownDuration(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &durationJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.duration = tmp
|
|
|
|
}
|
|
|
|
// IsSource determines whether the call to GetSource is safe
|
|
func (t *Join) IsSource() (ok bool) {
|
|
return t.source != nil && t.source.Object != nil
|
|
|
|
}
|
|
|
|
// GetSource returns the value safely if IsSource returned true
|
|
func (t *Join) GetSource() (v ObjectType) {
|
|
return t.source.Object
|
|
|
|
}
|
|
|
|
// SetSource sets the value of source to be of ObjectType type
|
|
func (t *Join) SetSource(v ObjectType) {
|
|
t.source = &sourceJoinIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsSourceIRI determines whether the call to GetSourceIRI is safe
|
|
func (t *Join) IsSourceIRI() (ok bool) {
|
|
return t.source != nil && t.source.IRI != nil
|
|
|
|
}
|
|
|
|
// GetSourceIRI returns the value safely if IsSourceIRI returned true
|
|
func (t *Join) GetSourceIRI() (v *url.URL) {
|
|
return t.source.IRI
|
|
|
|
}
|
|
|
|
// SetSourceIRI sets the value of source to be of *url.URL type
|
|
func (t *Join) SetSourceIRI(v *url.URL) {
|
|
t.source = &sourceJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownSource determines whether the call to GetUnknownSource is safe
|
|
func (t *Join) HasUnknownSource() (ok bool) {
|
|
return t.source != nil && t.source.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSource returns the unknown value for source
|
|
func (t *Join) GetUnknownSource() (v interface{}) {
|
|
return t.source.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSource sets the unknown value of source
|
|
func (t *Join) SetUnknownSource(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &sourceJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.source = tmp
|
|
|
|
}
|
|
|
|
// IsInboxOrderedCollection determines whether the call to GetInboxOrderedCollection is safe
|
|
func (t *Join) IsInboxOrderedCollection() (ok bool) {
|
|
return t.inbox != nil && t.inbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetInboxOrderedCollection returns the value safely if IsInboxOrderedCollection returned true
|
|
func (t *Join) GetInboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.inbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetInboxOrderedCollection sets the value of inbox to be of OrderedCollectionType type
|
|
func (t *Join) SetInboxOrderedCollection(v OrderedCollectionType) {
|
|
t.inbox = &inboxJoinIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsInboxAnyURI determines whether the call to GetInboxAnyURI is safe
|
|
func (t *Join) IsInboxAnyURI() (ok bool) {
|
|
return t.inbox != nil && t.inbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetInboxAnyURI returns the value safely if IsInboxAnyURI returned true
|
|
func (t *Join) GetInboxAnyURI() (v *url.URL) {
|
|
return t.inbox.anyURI
|
|
|
|
}
|
|
|
|
// SetInboxAnyURI sets the value of inbox to be of *url.URL type
|
|
func (t *Join) SetInboxAnyURI(v *url.URL) {
|
|
t.inbox = &inboxJoinIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownInbox determines whether the call to GetUnknownInbox is safe
|
|
func (t *Join) HasUnknownInbox() (ok bool) {
|
|
return t.inbox != nil && t.inbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInbox returns the unknown value for inbox
|
|
func (t *Join) GetUnknownInbox() (v interface{}) {
|
|
return t.inbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInbox sets the unknown value of inbox
|
|
func (t *Join) SetUnknownInbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inboxJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.inbox = tmp
|
|
|
|
}
|
|
|
|
// IsOutboxOrderedCollection determines whether the call to GetOutboxOrderedCollection is safe
|
|
func (t *Join) IsOutboxOrderedCollection() (ok bool) {
|
|
return t.outbox != nil && t.outbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetOutboxOrderedCollection returns the value safely if IsOutboxOrderedCollection returned true
|
|
func (t *Join) GetOutboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.outbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetOutboxOrderedCollection sets the value of outbox to be of OrderedCollectionType type
|
|
func (t *Join) SetOutboxOrderedCollection(v OrderedCollectionType) {
|
|
t.outbox = &outboxJoinIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsOutboxAnyURI determines whether the call to GetOutboxAnyURI is safe
|
|
func (t *Join) IsOutboxAnyURI() (ok bool) {
|
|
return t.outbox != nil && t.outbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetOutboxAnyURI returns the value safely if IsOutboxAnyURI returned true
|
|
func (t *Join) GetOutboxAnyURI() (v *url.URL) {
|
|
return t.outbox.anyURI
|
|
|
|
}
|
|
|
|
// SetOutboxAnyURI sets the value of outbox to be of *url.URL type
|
|
func (t *Join) SetOutboxAnyURI(v *url.URL) {
|
|
t.outbox = &outboxJoinIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownOutbox determines whether the call to GetUnknownOutbox is safe
|
|
func (t *Join) HasUnknownOutbox() (ok bool) {
|
|
return t.outbox != nil && t.outbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOutbox returns the unknown value for outbox
|
|
func (t *Join) GetUnknownOutbox() (v interface{}) {
|
|
return t.outbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOutbox sets the unknown value of outbox
|
|
func (t *Join) SetUnknownOutbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &outboxJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.outbox = tmp
|
|
|
|
}
|
|
|
|
// IsFollowingCollection determines whether the call to GetFollowingCollection is safe
|
|
func (t *Join) IsFollowingCollection() (ok bool) {
|
|
return t.following != nil && t.following.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingCollection returns the value safely if IsFollowingCollection returned true
|
|
func (t *Join) GetFollowingCollection() (v CollectionType) {
|
|
return t.following.Collection
|
|
|
|
}
|
|
|
|
// SetFollowingCollection sets the value of following to be of CollectionType type
|
|
func (t *Join) SetFollowingCollection(v CollectionType) {
|
|
t.following = &followingJoinIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingOrderedCollection determines whether the call to GetFollowingOrderedCollection is safe
|
|
func (t *Join) IsFollowingOrderedCollection() (ok bool) {
|
|
return t.following != nil && t.following.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingOrderedCollection returns the value safely if IsFollowingOrderedCollection returned true
|
|
func (t *Join) GetFollowingOrderedCollection() (v OrderedCollectionType) {
|
|
return t.following.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowingOrderedCollection sets the value of following to be of OrderedCollectionType type
|
|
func (t *Join) SetFollowingOrderedCollection(v OrderedCollectionType) {
|
|
t.following = &followingJoinIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingAnyURI determines whether the call to GetFollowingAnyURI is safe
|
|
func (t *Join) IsFollowingAnyURI() (ok bool) {
|
|
return t.following != nil && t.following.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowingAnyURI returns the value safely if IsFollowingAnyURI returned true
|
|
func (t *Join) GetFollowingAnyURI() (v *url.URL) {
|
|
return t.following.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowingAnyURI sets the value of following to be of *url.URL type
|
|
func (t *Join) SetFollowingAnyURI(v *url.URL) {
|
|
t.following = &followingJoinIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowing determines whether the call to GetUnknownFollowing is safe
|
|
func (t *Join) HasUnknownFollowing() (ok bool) {
|
|
return t.following != nil && t.following.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowing returns the unknown value for following
|
|
func (t *Join) GetUnknownFollowing() (v interface{}) {
|
|
return t.following.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowing sets the unknown value of following
|
|
func (t *Join) SetUnknownFollowing(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followingJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.following = tmp
|
|
|
|
}
|
|
|
|
// IsFollowersCollection determines whether the call to GetFollowersCollection is safe
|
|
func (t *Join) IsFollowersCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersCollection returns the value safely if IsFollowersCollection returned true
|
|
func (t *Join) GetFollowersCollection() (v CollectionType) {
|
|
return t.followers.Collection
|
|
|
|
}
|
|
|
|
// SetFollowersCollection sets the value of followers to be of CollectionType type
|
|
func (t *Join) SetFollowersCollection(v CollectionType) {
|
|
t.followers = &followersJoinIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersOrderedCollection determines whether the call to GetFollowersOrderedCollection is safe
|
|
func (t *Join) IsFollowersOrderedCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersOrderedCollection returns the value safely if IsFollowersOrderedCollection returned true
|
|
func (t *Join) GetFollowersOrderedCollection() (v OrderedCollectionType) {
|
|
return t.followers.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowersOrderedCollection sets the value of followers to be of OrderedCollectionType type
|
|
func (t *Join) SetFollowersOrderedCollection(v OrderedCollectionType) {
|
|
t.followers = &followersJoinIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersAnyURI determines whether the call to GetFollowersAnyURI is safe
|
|
func (t *Join) IsFollowersAnyURI() (ok bool) {
|
|
return t.followers != nil && t.followers.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowersAnyURI returns the value safely if IsFollowersAnyURI returned true
|
|
func (t *Join) GetFollowersAnyURI() (v *url.URL) {
|
|
return t.followers.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowersAnyURI sets the value of followers to be of *url.URL type
|
|
func (t *Join) SetFollowersAnyURI(v *url.URL) {
|
|
t.followers = &followersJoinIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowers determines whether the call to GetUnknownFollowers is safe
|
|
func (t *Join) HasUnknownFollowers() (ok bool) {
|
|
return t.followers != nil && t.followers.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowers returns the unknown value for followers
|
|
func (t *Join) GetUnknownFollowers() (v interface{}) {
|
|
return t.followers.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowers sets the unknown value of followers
|
|
func (t *Join) SetUnknownFollowers(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followersJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.followers = tmp
|
|
|
|
}
|
|
|
|
// IsLikedCollection determines whether the call to GetLikedCollection is safe
|
|
func (t *Join) IsLikedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikedCollection returns the value safely if IsLikedCollection returned true
|
|
func (t *Join) GetLikedCollection() (v CollectionType) {
|
|
return t.liked.Collection
|
|
|
|
}
|
|
|
|
// SetLikedCollection sets the value of liked to be of CollectionType type
|
|
func (t *Join) SetLikedCollection(v CollectionType) {
|
|
t.liked = &likedJoinIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikedOrderedCollection determines whether the call to GetLikedOrderedCollection is safe
|
|
func (t *Join) IsLikedOrderedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikedOrderedCollection returns the value safely if IsLikedOrderedCollection returned true
|
|
func (t *Join) GetLikedOrderedCollection() (v OrderedCollectionType) {
|
|
return t.liked.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikedOrderedCollection sets the value of liked to be of OrderedCollectionType type
|
|
func (t *Join) SetLikedOrderedCollection(v OrderedCollectionType) {
|
|
t.liked = &likedJoinIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikedAnyURI determines whether the call to GetLikedAnyURI is safe
|
|
func (t *Join) IsLikedAnyURI() (ok bool) {
|
|
return t.liked != nil && t.liked.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikedAnyURI returns the value safely if IsLikedAnyURI returned true
|
|
func (t *Join) GetLikedAnyURI() (v *url.URL) {
|
|
return t.liked.anyURI
|
|
|
|
}
|
|
|
|
// SetLikedAnyURI sets the value of liked to be of *url.URL type
|
|
func (t *Join) SetLikedAnyURI(v *url.URL) {
|
|
t.liked = &likedJoinIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLiked determines whether the call to GetUnknownLiked is safe
|
|
func (t *Join) HasUnknownLiked() (ok bool) {
|
|
return t.liked != nil && t.liked.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLiked returns the unknown value for liked
|
|
func (t *Join) GetUnknownLiked() (v interface{}) {
|
|
return t.liked.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLiked sets the unknown value of liked
|
|
func (t *Join) SetUnknownLiked(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likedJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.liked = tmp
|
|
|
|
}
|
|
|
|
// IsLikesCollection determines whether the call to GetLikesCollection is safe
|
|
func (t *Join) IsLikesCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikesCollection returns the value safely if IsLikesCollection returned true
|
|
func (t *Join) GetLikesCollection() (v CollectionType) {
|
|
return t.likes.Collection
|
|
|
|
}
|
|
|
|
// SetLikesCollection sets the value of likes to be of CollectionType type
|
|
func (t *Join) SetLikesCollection(v CollectionType) {
|
|
t.likes = &likesJoinIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikesOrderedCollection determines whether the call to GetLikesOrderedCollection is safe
|
|
func (t *Join) IsLikesOrderedCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikesOrderedCollection returns the value safely if IsLikesOrderedCollection returned true
|
|
func (t *Join) GetLikesOrderedCollection() (v OrderedCollectionType) {
|
|
return t.likes.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikesOrderedCollection sets the value of likes to be of OrderedCollectionType type
|
|
func (t *Join) SetLikesOrderedCollection(v OrderedCollectionType) {
|
|
t.likes = &likesJoinIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikesAnyURI determines whether the call to GetLikesAnyURI is safe
|
|
func (t *Join) IsLikesAnyURI() (ok bool) {
|
|
return t.likes != nil && t.likes.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikesAnyURI returns the value safely if IsLikesAnyURI returned true
|
|
func (t *Join) GetLikesAnyURI() (v *url.URL) {
|
|
return t.likes.anyURI
|
|
|
|
}
|
|
|
|
// SetLikesAnyURI sets the value of likes to be of *url.URL type
|
|
func (t *Join) SetLikesAnyURI(v *url.URL) {
|
|
t.likes = &likesJoinIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLikes determines whether the call to GetUnknownLikes is safe
|
|
func (t *Join) HasUnknownLikes() (ok bool) {
|
|
return t.likes != nil && t.likes.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLikes returns the unknown value for likes
|
|
func (t *Join) GetUnknownLikes() (v interface{}) {
|
|
return t.likes.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLikes sets the unknown value of likes
|
|
func (t *Join) SetUnknownLikes(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likesJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.likes = tmp
|
|
|
|
}
|
|
|
|
// StreamsLen determines the number of elements able to be used for the GetStreams and RemoveStreams functions
|
|
func (t *Join) StreamsLen() (l int) {
|
|
return len(t.streams)
|
|
|
|
}
|
|
|
|
// GetStreams returns the value for the specified index
|
|
func (t *Join) GetStreams(index int) (v *url.URL) {
|
|
return t.streams[index]
|
|
|
|
}
|
|
|
|
// AppendStreams adds a value to the back of streams
|
|
func (t *Join) AppendStreams(v *url.URL) {
|
|
t.streams = append(t.streams, v)
|
|
|
|
}
|
|
|
|
// PrependStreams adds a value to the front of streams
|
|
func (t *Join) PrependStreams(v *url.URL) {
|
|
t.streams = append([]*url.URL{v}, t.streams...)
|
|
|
|
}
|
|
|
|
// RemoveStreams deletes the value from the specified index
|
|
func (t *Join) RemoveStreams(index int) {
|
|
copy(t.streams[index:], t.streams[index+1:])
|
|
t.streams[len(t.streams)-1] = nil
|
|
t.streams = t.streams[:len(t.streams)-1]
|
|
|
|
}
|
|
|
|
// HasUnknownStreams determines whether the call to GetUnknownStreams is safe
|
|
func (t *Join) HasUnknownStreams() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["streams"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStreams returns the unknown value for streams
|
|
func (t *Join) GetUnknownStreams() (v interface{}) {
|
|
return t.unknown_["streams"]
|
|
|
|
}
|
|
|
|
// SetUnknownStreams sets the unknown value of streams
|
|
func (t *Join) SetUnknownStreams(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["streams"] = i
|
|
|
|
}
|
|
|
|
// IsPreferredUsername determines whether the call to GetPreferredUsername is safe
|
|
func (t *Join) IsPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.stringName != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsername returns the value safely if IsPreferredUsername returned true
|
|
func (t *Join) GetPreferredUsername() (v string) {
|
|
return *t.preferredUsername.stringName
|
|
|
|
}
|
|
|
|
// SetPreferredUsername sets the value of preferredUsername to be of string type
|
|
func (t *Join) SetPreferredUsername(v string) {
|
|
t.preferredUsername = &preferredUsernameJoinIntermediateType{stringName: &v}
|
|
|
|
}
|
|
|
|
// IsPreferredUsernameIRI determines whether the call to GetPreferredUsernameIRI is safe
|
|
func (t *Join) IsPreferredUsernameIRI() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsernameIRI returns the value safely if IsPreferredUsernameIRI returned true
|
|
func (t *Join) GetPreferredUsernameIRI() (v *url.URL) {
|
|
return t.preferredUsername.IRI
|
|
|
|
}
|
|
|
|
// SetPreferredUsernameIRI sets the value of preferredUsername to be of *url.URL type
|
|
func (t *Join) SetPreferredUsernameIRI(v *url.URL) {
|
|
t.preferredUsername = &preferredUsernameJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPreferredUsername determines whether the call to GetUnknownPreferredUsername is safe
|
|
func (t *Join) HasUnknownPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreferredUsername returns the unknown value for preferredUsername
|
|
func (t *Join) GetUnknownPreferredUsername() (v interface{}) {
|
|
return t.preferredUsername.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreferredUsername sets the unknown value of preferredUsername
|
|
func (t *Join) SetUnknownPreferredUsername(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &preferredUsernameJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preferredUsername = tmp
|
|
|
|
}
|
|
|
|
// PreferredUsernameMapLanguages returns all languages for this property's language mapping, or nil if there are none.
|
|
func (t *Join) PreferredUsernameMapLanguages() (l []string) {
|
|
if t.preferredUsernameMap == nil || len(t.preferredUsernameMap) == 0 {
|
|
return nil
|
|
}
|
|
for k := range t.preferredUsernameMap {
|
|
l = append(l, k)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// GetPreferredUsernameMap retrieves the value of the property for the specified language, or an empty string if it does not exist
|
|
func (t *Join) GetPreferredUsernameMap(l string) (v string) {
|
|
if t.preferredUsernameMap == nil {
|
|
return ""
|
|
}
|
|
ok := false
|
|
v, ok = t.preferredUsernameMap[l]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
return v
|
|
|
|
}
|
|
|
|
// SetPreferredUsernameMap sets the value of the property for the specified language
|
|
func (t *Join) SetPreferredUsernameMap(l string, v string) {
|
|
if t.preferredUsernameMap == nil {
|
|
t.preferredUsernameMap = make(map[string]string)
|
|
}
|
|
t.preferredUsernameMap[l] = v
|
|
|
|
}
|
|
|
|
// IsEndpoints determines whether the call to GetEndpoints is safe
|
|
func (t *Join) IsEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.Object != nil
|
|
|
|
}
|
|
|
|
// GetEndpoints returns the value safely if IsEndpoints returned true
|
|
func (t *Join) GetEndpoints() (v ObjectType) {
|
|
return t.endpoints.Object
|
|
|
|
}
|
|
|
|
// SetEndpoints sets the value of endpoints to be of ObjectType type
|
|
func (t *Join) SetEndpoints(v ObjectType) {
|
|
t.endpoints = &endpointsJoinIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsEndpointsIRI determines whether the call to GetEndpointsIRI is safe
|
|
func (t *Join) IsEndpointsIRI() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndpointsIRI returns the value safely if IsEndpointsIRI returned true
|
|
func (t *Join) GetEndpointsIRI() (v *url.URL) {
|
|
return t.endpoints.IRI
|
|
|
|
}
|
|
|
|
// SetEndpointsIRI sets the value of endpoints to be of *url.URL type
|
|
func (t *Join) SetEndpointsIRI(v *url.URL) {
|
|
t.endpoints = &endpointsJoinIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndpoints determines whether the call to GetUnknownEndpoints is safe
|
|
func (t *Join) HasUnknownEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndpoints returns the unknown value for endpoints
|
|
func (t *Join) GetUnknownEndpoints() (v interface{}) {
|
|
return t.endpoints.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndpoints sets the unknown value of endpoints
|
|
func (t *Join) SetUnknownEndpoints(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endpointsJoinIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.endpoints = tmp
|
|
|
|
}
|
|
|
|
// HasProxyUrl determines whether the call to GetProxyUrl is safe
|
|
func (t *Join) HasProxyUrl() (ok bool) {
|
|
return t.proxyUrl != nil
|
|
|
|
}
|
|
|
|
// GetProxyUrl returns the value for proxyUrl
|
|
func (t *Join) GetProxyUrl() (v *url.URL) {
|
|
return t.proxyUrl
|
|
|
|
}
|
|
|
|
// SetProxyUrl sets the value of proxyUrl
|
|
func (t *Join) SetProxyUrl(v *url.URL) {
|
|
t.proxyUrl = v
|
|
|
|
}
|
|
|
|
// HasUnknownProxyUrl determines whether the call to GetUnknownProxyUrl is safe
|
|
func (t *Join) HasUnknownProxyUrl() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["proxyUrl"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProxyUrl returns the unknown value for proxyUrl
|
|
func (t *Join) GetUnknownProxyUrl() (v interface{}) {
|
|
return t.unknown_["proxyUrl"]
|
|
|
|
}
|
|
|
|
// SetUnknownProxyUrl sets the unknown value of proxyUrl
|
|
func (t *Join) SetUnknownProxyUrl(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["proxyUrl"] = i
|
|
|
|
}
|
|
|
|
// HasOauthAuthorizationEndpoint determines whether the call to GetOauthAuthorizationEndpoint is safe
|
|
func (t *Join) HasOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.oauthAuthorizationEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthAuthorizationEndpoint returns the value for oauthAuthorizationEndpoint
|
|
func (t *Join) GetOauthAuthorizationEndpoint() (v *url.URL) {
|
|
return t.oauthAuthorizationEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthAuthorizationEndpoint sets the value of oauthAuthorizationEndpoint
|
|
func (t *Join) SetOauthAuthorizationEndpoint(v *url.URL) {
|
|
t.oauthAuthorizationEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthAuthorizationEndpoint determines whether the call to GetUnknownOauthAuthorizationEndpoint is safe
|
|
func (t *Join) HasUnknownOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthAuthorizationEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthAuthorizationEndpoint returns the unknown value for oauthAuthorizationEndpoint
|
|
func (t *Join) GetUnknownOauthAuthorizationEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthAuthorizationEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthAuthorizationEndpoint sets the unknown value of oauthAuthorizationEndpoint
|
|
func (t *Join) SetUnknownOauthAuthorizationEndpoint(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["oauthAuthorizationEndpoint"] = i
|
|
|
|
}
|
|
|
|
// HasOauthTokenEndpoint determines whether the call to GetOauthTokenEndpoint is safe
|
|
func (t *Join) HasOauthTokenEndpoint() (ok bool) {
|
|
return t.oauthTokenEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthTokenEndpoint returns the value for oauthTokenEndpoint
|
|
func (t *Join) GetOauthTokenEndpoint() (v *url.URL) {
|
|
return t.oauthTokenEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthTokenEndpoint sets the value of oauthTokenEndpoint
|
|
func (t *Join) SetOauthTokenEndpoint(v *url.URL) {
|
|
t.oauthTokenEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthTokenEndpoint determines whether the call to GetUnknownOauthTokenEndpoint is safe
|
|
func (t *Join) HasUnknownOauthTokenEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthTokenEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthTokenEndpoint returns the unknown value for oauthTokenEndpoint
|
|
func (t *Join) GetUnknownOauthTokenEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthTokenEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthTokenEndpoint sets the unknown value of oauthTokenEndpoint
|
|
func (t *Join) SetUnknownOauthTokenEndpoint(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["oauthTokenEndpoint"] = i
|
|
|
|
}
|
|
|
|
// HasProvideClientKey determines whether the call to GetProvideClientKey is safe
|
|
func (t *Join) HasProvideClientKey() (ok bool) {
|
|
return t.provideClientKey != nil
|
|
|
|
}
|
|
|
|
// GetProvideClientKey returns the value for provideClientKey
|
|
func (t *Join) GetProvideClientKey() (v *url.URL) {
|
|
return t.provideClientKey
|
|
|
|
}
|
|
|
|
// SetProvideClientKey sets the value of provideClientKey
|
|
func (t *Join) SetProvideClientKey(v *url.URL) {
|
|
t.provideClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownProvideClientKey determines whether the call to GetUnknownProvideClientKey is safe
|
|
func (t *Join) HasUnknownProvideClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["provideClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProvideClientKey returns the unknown value for provideClientKey
|
|
func (t *Join) GetUnknownProvideClientKey() (v interface{}) {
|
|
return t.unknown_["provideClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownProvideClientKey sets the unknown value of provideClientKey
|
|
func (t *Join) SetUnknownProvideClientKey(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["provideClientKey"] = i
|
|
|
|
}
|
|
|
|
// HasSignClientKey determines whether the call to GetSignClientKey is safe
|
|
func (t *Join) HasSignClientKey() (ok bool) {
|
|
return t.signClientKey != nil
|
|
|
|
}
|
|
|
|
// GetSignClientKey returns the value for signClientKey
|
|
func (t *Join) GetSignClientKey() (v *url.URL) {
|
|
return t.signClientKey
|
|
|
|
}
|
|
|
|
// SetSignClientKey sets the value of signClientKey
|
|
func (t *Join) SetSignClientKey(v *url.URL) {
|
|
t.signClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownSignClientKey determines whether the call to GetUnknownSignClientKey is safe
|
|
func (t *Join) HasUnknownSignClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["signClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSignClientKey returns the unknown value for signClientKey
|
|
func (t *Join) GetUnknownSignClientKey() (v interface{}) {
|
|
return t.unknown_["signClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownSignClientKey sets the unknown value of signClientKey
|
|
func (t *Join) SetUnknownSignClientKey(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["signClientKey"] = i
|
|
|
|
}
|
|
|
|
// HasSharedInbox determines whether the call to GetSharedInbox is safe
|
|
func (t *Join) HasSharedInbox() (ok bool) {
|
|
return t.sharedInbox != nil
|
|
|
|
}
|
|
|
|
// GetSharedInbox returns the value for sharedInbox
|
|
func (t *Join) GetSharedInbox() (v *url.URL) {
|
|
return t.sharedInbox
|
|
|
|
}
|
|
|
|
// SetSharedInbox sets the value of sharedInbox
|
|
func (t *Join) SetSharedInbox(v *url.URL) {
|
|
t.sharedInbox = v
|
|
|
|
}
|
|
|
|
// HasUnknownSharedInbox determines whether the call to GetUnknownSharedInbox is safe
|
|
func (t *Join) HasUnknownSharedInbox() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["sharedInbox"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSharedInbox returns the unknown value for sharedInbox
|
|
func (t *Join) GetUnknownSharedInbox() (v interface{}) {
|
|
return t.unknown_["sharedInbox"]
|
|
|
|
}
|
|
|
|
// SetUnknownSharedInbox sets the unknown value of sharedInbox
|
|
func (t *Join) SetUnknownSharedInbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_["sharedInbox"] = i
|
|
|
|
}
|
|
|
|
// AddUnknown adds a raw extension to this object with the specified key
|
|
func (t *Join) AddUnknown(k string, i interface{}) (this *Join) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_[k] = i
|
|
return t
|
|
|
|
}
|
|
|
|
// HasUnknown returns true if there is an unknown object with the specified key
|
|
func (t *Join) HasUnknown(k string) (b bool) {
|
|
if t.unknown_ == nil {
|
|
return false
|
|
}
|
|
_, ok := t.unknown_[k]
|
|
return ok
|
|
|
|
}
|
|
|
|
// RemoveUnknown removes a raw extension from this object with the specified key
|
|
func (t *Join) RemoveUnknown(k string) (this *Join) {
|
|
delete(t.unknown_, k)
|
|
return t
|
|
|
|
}
|
|
|
|
// Serialize turns this object into a map[string]interface{}. Note that the "type" property will automatically be populated with "Join" if not manually set by the caller
|
|
func (t *Join) Serialize() (m map[string]interface{}, err error) {
|
|
m = make(map[string]interface{})
|
|
for k, v := range t.unknown_ {
|
|
m[k] = unknownValueSerialize(v)
|
|
}
|
|
var typeAlreadySet bool
|
|
for _, k := range t.typeName {
|
|
if ks, ok := k.(string); ok {
|
|
if ks == "Join" {
|
|
typeAlreadySet = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !typeAlreadySet {
|
|
t.typeName = append(t.typeName, "Join")
|
|
}
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceActorJoinIntermediateType(t.actor); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["actor"] = v[0]
|
|
} else {
|
|
m["actor"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceObjectJoinIntermediateType(t.object); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["object"] = v[0]
|
|
} else {
|
|
m["object"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceTargetJoinIntermediateType(t.target); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["target"] = v[0]
|
|
} else {
|
|
m["target"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceResultJoinIntermediateType(t.result); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["result"] = v[0]
|
|
} else {
|
|
m["result"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceOriginJoinIntermediateType(t.origin); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["origin"] = v[0]
|
|
} else {
|
|
m["origin"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceInstrumentJoinIntermediateType(t.instrument); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["instrument"] = v[0]
|
|
} else {
|
|
m["instrument"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.altitude != nil {
|
|
if v, err := serializeAltitudeJoinIntermediateType(t.altitude); err == nil {
|
|
m["altitude"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceAttachmentJoinIntermediateType(t.attachment); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["attachment"] = v[0]
|
|
} else {
|
|
m["attachment"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceAttributedToJoinIntermediateType(t.attributedTo); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["attributedTo"] = v[0]
|
|
} else {
|
|
m["attributedTo"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceAudienceJoinIntermediateType(t.audience); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["audience"] = v[0]
|
|
} else {
|
|
m["audience"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceContentJoinIntermediateType(t.content); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["content"] = v[0]
|
|
} else {
|
|
m["content"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if t.contentMap != nil && len(t.contentMap) >= 0 {
|
|
m["contentMap"] = t.contentMap
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceContextJoinIntermediateType(t.context); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["context"] = v[0]
|
|
} else {
|
|
m["context"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceNameJoinIntermediateType(t.name); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["name"] = v[0]
|
|
} else {
|
|
m["name"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if t.nameMap != nil && len(t.nameMap) >= 0 {
|
|
m["nameMap"] = t.nameMap
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.endTime != nil {
|
|
if v, err := serializeEndTimeJoinIntermediateType(t.endTime); err == nil {
|
|
m["endTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceGeneratorJoinIntermediateType(t.generator); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["generator"] = v[0]
|
|
} else {
|
|
m["generator"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceIconJoinIntermediateType(t.icon); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["icon"] = v[0]
|
|
} else {
|
|
m["icon"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
if t.id != nil {
|
|
idSerializeFunc := func() (interface{}, error) {
|
|
v := t.id
|
|
tmp := anyURISerialize(v)
|
|
return tmp, nil
|
|
}
|
|
idResult, err := idSerializeFunc()
|
|
if err == nil {
|
|
m["id"] = idResult
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceImageJoinIntermediateType(t.image); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["image"] = v[0]
|
|
} else {
|
|
m["image"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceInReplyToJoinIntermediateType(t.inReplyTo); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["inReplyTo"] = v[0]
|
|
} else {
|
|
m["inReplyTo"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceLocationJoinIntermediateType(t.location); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["location"] = v[0]
|
|
} else {
|
|
m["location"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSlicePreviewJoinIntermediateType(t.preview); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["preview"] = v[0]
|
|
} else {
|
|
m["preview"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.published != nil {
|
|
if v, err := serializePublishedJoinIntermediateType(t.published); err == nil {
|
|
m["published"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.replies != nil {
|
|
if v, err := serializeRepliesJoinIntermediateType(t.replies); err == nil {
|
|
m["replies"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.startTime != nil {
|
|
if v, err := serializeStartTimeJoinIntermediateType(t.startTime); err == nil {
|
|
m["startTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceSummaryJoinIntermediateType(t.summary); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["summary"] = v[0]
|
|
} else {
|
|
m["summary"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if t.summaryMap != nil && len(t.summaryMap) >= 0 {
|
|
m["summaryMap"] = t.summaryMap
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceTagJoinIntermediateType(t.tag); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["tag"] = v[0]
|
|
} else {
|
|
m["tag"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalAnyDefinition
|
|
if t.typeName != nil {
|
|
if len(t.typeName) == 1 {
|
|
m["type"] = t.typeName[0]
|
|
} else {
|
|
m["type"] = t.typeName
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalAnyDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.updated != nil {
|
|
if v, err := serializeUpdatedJoinIntermediateType(t.updated); err == nil {
|
|
m["updated"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceUrlJoinIntermediateType(t.url); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["url"] = v[0]
|
|
} else {
|
|
m["url"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceToJoinIntermediateType(t.to); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["to"] = v[0]
|
|
} else {
|
|
m["to"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceBtoJoinIntermediateType(t.bto); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["bto"] = v[0]
|
|
} else {
|
|
m["bto"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceCcJoinIntermediateType(t.cc); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["cc"] = v[0]
|
|
} else {
|
|
m["cc"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceBccJoinIntermediateType(t.bcc); err == nil && v != nil {
|
|
if len(v) == 1 {
|
|
m["bcc"] = v[0]
|
|
} else {
|
|
m["bcc"] = v
|
|
}
|
|
} else if err != nil {
|
|
return m, err
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.mediaType != nil {
|
|
if v, err := serializeMediaTypeJoinIntermediateType(t.mediaType); err == nil {
|
|
m["mediaType"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.duration != nil {
|
|
if v, err := serializeDurationJoinIntermediateType(t.duration); err == nil {
|
|
m["duration"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.source != nil {
|
|
if v, err := serializeSourceJoinIntermediateType(t.source); err == nil {
|
|
m["source"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.inbox != nil {
|
|
if v, err := serializeInboxJoinIntermediateType(t.inbox); err == nil {
|
|
m["inbox"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.outbox != nil {
|
|
if v, err := serializeOutboxJoinIntermediateType(t.outbox); err == nil {
|
|
m["outbox"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.following != nil {
|
|
if v, err := serializeFollowingJoinIntermediateType(t.following); err == nil {
|
|
m["following"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.followers != nil {
|
|
if v, err := serializeFollowersJoinIntermediateType(t.followers); err == nil {
|
|
m["followers"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.liked != nil {
|
|
if v, err := serializeLikedJoinIntermediateType(t.liked); err == nil {
|
|
m["liked"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.likes != nil {
|
|
if v, err := serializeLikesJoinIntermediateType(t.likes); err == nil {
|
|
m["likes"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
var streamsTemp []interface{}
|
|
for _, v := range t.streams {
|
|
tmp := anyURISerialize(v)
|
|
streamsTemp = append(streamsTemp, tmp)
|
|
}
|
|
if streamsTemp != nil {
|
|
if len(streamsTemp) == 1 {
|
|
m["streams"] = streamsTemp[0]
|
|
} else {
|
|
m["streams"] = streamsTemp
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.preferredUsername != nil {
|
|
if v, err := serializePreferredUsernameJoinIntermediateType(t.preferredUsername); err == nil {
|
|
m["preferredUsername"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if t.preferredUsernameMap != nil && len(t.preferredUsernameMap) >= 0 {
|
|
m["preferredUsernameMap"] = t.preferredUsernameMap
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if t.endpoints != nil {
|
|
if v, err := serializeEndpointsJoinIntermediateType(t.endpoints); err == nil {
|
|
m["endpoints"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
if t.proxyUrl != nil {
|
|
proxyUrlSerializeFunc := func() (interface{}, error) {
|
|
v := t.proxyUrl
|
|
tmp := anyURISerialize(v)
|
|
return tmp, nil
|
|
}
|
|
proxyUrlResult, err := proxyUrlSerializeFunc()
|
|
if err == nil {
|
|
m["proxyUrl"] = proxyUrlResult
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
if t.oauthAuthorizationEndpoint != nil {
|
|
oauthAuthorizationEndpointSerializeFunc := func() (interface{}, error) {
|
|
v := t.oauthAuthorizationEndpoint
|
|
tmp := anyURISerialize(v)
|
|
return tmp, nil
|
|
}
|
|
oauthAuthorizationEndpointResult, err := oauthAuthorizationEndpointSerializeFunc()
|
|
if err == nil {
|
|
m["oauthAuthorizationEndpoint"] = oauthAuthorizationEndpointResult
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
if t.oauthTokenEndpoint != nil {
|
|
oauthTokenEndpointSerializeFunc := func() (interface{}, error) {
|
|
v := t.oauthTokenEndpoint
|
|
tmp := anyURISerialize(v)
|
|
return tmp, nil
|
|
}
|
|
oauthTokenEndpointResult, err := oauthTokenEndpointSerializeFunc()
|
|
if err == nil {
|
|
m["oauthTokenEndpoint"] = oauthTokenEndpointResult
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
if t.provideClientKey != nil {
|
|
provideClientKeySerializeFunc := func() (interface{}, error) {
|
|
v := t.provideClientKey
|
|
tmp := anyURISerialize(v)
|
|
return tmp, nil
|
|
}
|
|
provideClientKeyResult, err := provideClientKeySerializeFunc()
|
|
if err == nil {
|
|
m["provideClientKey"] = provideClientKeyResult
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
if t.signClientKey != nil {
|
|
signClientKeySerializeFunc := func() (interface{}, error) {
|
|
v := t.signClientKey
|
|
tmp := anyURISerialize(v)
|
|
return tmp, nil
|
|
}
|
|
signClientKeyResult, err := signClientKeySerializeFunc()
|
|
if err == nil {
|
|
m["signClientKey"] = signClientKeyResult
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
// Begin generation by RangeReference.Serialize for Value
|
|
if t.sharedInbox != nil {
|
|
sharedInboxSerializeFunc := func() (interface{}, error) {
|
|
v := t.sharedInbox
|
|
tmp := anyURISerialize(v)
|
|
return tmp, nil
|
|
}
|
|
sharedInboxResult, err := sharedInboxSerializeFunc()
|
|
if err == nil {
|
|
m["sharedInbox"] = sharedInboxResult
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by RangeReference.Serialize for Value
|
|
return
|
|
|
|
}
|
|
|
|
// Deserialize populates this object from a map[string]interface{}
|
|
func (t *Join) Deserialize(m map[string]interface{}) (err error) {
|
|
for k, v := range m {
|
|
handled := false
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "actor" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeActorJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.actor, err = deserializeSliceActorJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &actorJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "object" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeObjectJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.object, err = deserializeSliceObjectJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &objectJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "target" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeTargetJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.target, err = deserializeSliceTargetJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &targetJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "result" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeResultJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.result, err = deserializeSliceResultJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &resultJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "origin" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeOriginJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.origin, err = deserializeSliceOriginJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &originJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "instrument" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeInstrumentJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.instrument, err = deserializeSliceInstrumentJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &instrumentJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "altitude" {
|
|
t.altitude, err = deserializeAltitudeJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "attachment" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeAttachmentJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attachment, err = deserializeSliceAttachmentJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attachmentJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "attributedTo" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeAttributedToJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attributedTo, err = deserializeSliceAttributedToJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attributedToJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "audience" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeAudienceJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.audience, err = deserializeSliceAudienceJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &audienceJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "content" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeContentJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.content, err = deserializeSliceContentJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contentJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if k == "contentMap" {
|
|
if vMap, ok := v.(map[string]interface{}); ok {
|
|
val := make(map[string]string)
|
|
for k, iVal := range vMap {
|
|
if sVal, ok := iVal.(string); ok {
|
|
val[k] = sVal
|
|
}
|
|
}
|
|
t.contentMap = val
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "context" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeContextJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.context, err = deserializeSliceContextJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contextJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "name" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeNameJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.name, err = deserializeSliceNameJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &nameJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if k == "nameMap" {
|
|
if vMap, ok := v.(map[string]interface{}); ok {
|
|
val := make(map[string]string)
|
|
for k, iVal := range vMap {
|
|
if sVal, ok := iVal.(string); ok {
|
|
val[k] = sVal
|
|
}
|
|
}
|
|
t.nameMap = val
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "endTime" {
|
|
t.endTime, err = deserializeEndTimeJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "generator" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeGeneratorJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.generator, err = deserializeSliceGeneratorJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &generatorJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "icon" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeIconJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.icon, err = deserializeSliceIconJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &iconJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "id" {
|
|
if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.id = tmp
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "image" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeImageJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.image, err = deserializeSliceImageJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &imageJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "inReplyTo" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeInReplyToJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.inReplyTo, err = deserializeSliceInReplyToJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &inReplyToJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "location" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeLocationJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.location, err = deserializeSliceLocationJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &locationJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "preview" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializePreviewJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.preview, err = deserializeSlicePreviewJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &previewJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "published" {
|
|
t.published, err = deserializePublishedJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "replies" {
|
|
t.replies, err = deserializeRepliesJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "startTime" {
|
|
t.startTime, err = deserializeStartTimeJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "summary" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeSummaryJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.summary, err = deserializeSliceSummaryJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &summaryJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if k == "summaryMap" {
|
|
if vMap, ok := v.(map[string]interface{}); ok {
|
|
val := make(map[string]string)
|
|
for k, iVal := range vMap {
|
|
if sVal, ok := iVal.(string); ok {
|
|
val[k] = sVal
|
|
}
|
|
}
|
|
t.summaryMap = val
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "tag" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeTagJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.tag, err = deserializeSliceTagJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &tagJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalAnyDefinition
|
|
if k == "type" {
|
|
if tmpTypeSlice, ok := v.([]interface{}); ok {
|
|
t.typeName = tmpTypeSlice
|
|
handled = true
|
|
} else {
|
|
t.typeName = []interface{}{v}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalAnyDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "updated" {
|
|
t.updated, err = deserializeUpdatedJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "url" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeUrlJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.url, err = deserializeSliceUrlJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &urlJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "to" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeToJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.to, err = deserializeSliceToJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &toJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "bto" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeBtoJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bto, err = deserializeSliceBtoJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &btoJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "cc" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeCcJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.cc, err = deserializeSliceCcJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &ccJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if k == "bcc" {
|
|
if tmpMap, ok := v.(map[string]interface{}); ok {
|
|
tmp, err := deserializeBccJoinIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccJoinIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bcc, err = deserializeSliceBccJoinIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &bccJoinIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccJoinIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "mediaType" {
|
|
t.mediaType, err = deserializeMediaTypeJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "duration" {
|
|
t.duration, err = deserializeDurationJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "source" {
|
|
t.source, err = deserializeSourceJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "inbox" {
|
|
t.inbox, err = deserializeInboxJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "outbox" {
|
|
t.outbox, err = deserializeOutboxJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "following" {
|
|
t.following, err = deserializeFollowingJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "followers" {
|
|
t.followers, err = deserializeFollowersJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "liked" {
|
|
t.liked, err = deserializeLikedJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "likes" {
|
|
t.likes, err = deserializeLikesJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "streams" {
|
|
if tmpSlice, ok := v.([]interface{}); ok {
|
|
for _, tmpElem := range tmpSlice {
|
|
if v, ok := tmpElem.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.streams = append(t.streams, tmp)
|
|
handled = true
|
|
}
|
|
}
|
|
} else if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.streams = append(t.streams, tmp)
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "preferredUsername" {
|
|
t.preferredUsername, err = deserializePreferredUsernameJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
|
|
// Begin generation by generateNaturalLanguageMap
|
|
if k == "preferredUsernameMap" {
|
|
if vMap, ok := v.(map[string]interface{}); ok {
|
|
val := make(map[string]string)
|
|
for k, iVal := range vMap {
|
|
if sVal, ok := iVal.(string); ok {
|
|
val[k] = sVal
|
|
}
|
|
}
|
|
t.preferredUsernameMap = val
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNaturalLanguageMap
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "endpoints" {
|
|
t.endpoints, err = deserializeEndpointsJoinIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "proxyUrl" {
|
|
if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.proxyUrl = tmp
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "oauthAuthorizationEndpoint" {
|
|
if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.oauthAuthorizationEndpoint = tmp
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "oauthTokenEndpoint" {
|
|
if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.oauthTokenEndpoint = tmp
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "provideClientKey" {
|
|
if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.provideClientKey = tmp
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "signClientKey" {
|
|
if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.signClientKey = tmp
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled {
|
|
// Begin generation by RangeReference.Deserialize for Value
|
|
if k == "sharedInbox" {
|
|
if v, ok := v.(interface{}); ok {
|
|
tmp, err := anyURIDeserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.sharedInbox = tmp
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by RangeReference.Deserialize for Value
|
|
}
|
|
if !handled && k != "@context" {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
t.unknown_[k] = unknownValueDeserialize(v)
|
|
}
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// actorJoinIntermediateType will only have one of its values set at most
|
|
type actorJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for actor property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for actor property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for actor property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *actorJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *actorJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// objectJoinIntermediateType will only have one of its values set at most
|
|
type objectJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for object property
|
|
Object ObjectType
|
|
// Stores possible *url.URL type for object property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *objectJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *objectJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// targetJoinIntermediateType will only have one of its values set at most
|
|
type targetJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for target property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for target property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for target property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *targetJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *targetJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// resultJoinIntermediateType will only have one of its values set at most
|
|
type resultJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for result property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for result property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for result property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *resultJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *resultJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// originJoinIntermediateType will only have one of its values set at most
|
|
type originJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for origin property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for origin property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for origin property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *originJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *originJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// instrumentJoinIntermediateType will only have one of its values set at most
|
|
type instrumentJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for instrument property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for instrument property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for instrument property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *instrumentJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *instrumentJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// altitudeJoinIntermediateType will only have one of its values set at most
|
|
type altitudeJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *float64 type for altitude property
|
|
float *float64
|
|
// Stores possible *url.URL type for altitude property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *altitudeJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.float, err = floatDeserialize(i)
|
|
if err != nil {
|
|
t.float = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *altitudeJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.float != nil {
|
|
i = floatSerialize(*t.float)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// attachmentJoinIntermediateType will only have one of its values set at most
|
|
type attachmentJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for attachment property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for attachment property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for attachment property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *attachmentJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *attachmentJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// attributedToJoinIntermediateType will only have one of its values set at most
|
|
type attributedToJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for attributedTo property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for attributedTo property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for attributedTo property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *attributedToJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *attributedToJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// audienceJoinIntermediateType will only have one of its values set at most
|
|
type audienceJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for audience property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for audience property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for audience property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *audienceJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *audienceJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// contentJoinIntermediateType will only have one of its values set at most
|
|
type contentJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *string type for content property
|
|
stringName *string
|
|
// Stores possible *string type for content property
|
|
langString *string
|
|
// Stores possible *url.URL type for content property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *contentJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.stringName, err = stringDeserialize(i)
|
|
if err != nil {
|
|
t.stringName = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.langString, err = langStringDeserialize(i)
|
|
if err != nil {
|
|
t.langString = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *contentJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.stringName != nil {
|
|
i = stringSerialize(*t.stringName)
|
|
return
|
|
}
|
|
if t.langString != nil {
|
|
i = langStringSerialize(*t.langString)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// contextJoinIntermediateType will only have one of its values set at most
|
|
type contextJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for context property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for context property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for context property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *contextJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *contextJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// nameJoinIntermediateType will only have one of its values set at most
|
|
type nameJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *string type for name property
|
|
stringName *string
|
|
// Stores possible *string type for name property
|
|
langString *string
|
|
// Stores possible *url.URL type for name property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *nameJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.stringName, err = stringDeserialize(i)
|
|
if err != nil {
|
|
t.stringName = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.langString, err = langStringDeserialize(i)
|
|
if err != nil {
|
|
t.langString = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *nameJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.stringName != nil {
|
|
i = stringSerialize(*t.stringName)
|
|
return
|
|
}
|
|
if t.langString != nil {
|
|
i = langStringSerialize(*t.langString)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// endTimeJoinIntermediateType will only have one of its values set at most
|
|
type endTimeJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *time.Time type for endTime property
|
|
dateTime *time.Time
|
|
// Stores possible *url.URL type for endTime property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *endTimeJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.dateTime, err = dateTimeDeserialize(i)
|
|
if err != nil {
|
|
t.dateTime = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *endTimeJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.dateTime != nil {
|
|
i = dateTimeSerialize(*t.dateTime)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// generatorJoinIntermediateType will only have one of its values set at most
|
|
type generatorJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for generator property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for generator property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for generator property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *generatorJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *generatorJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// iconJoinIntermediateType will only have one of its values set at most
|
|
type iconJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ImageType type for icon property
|
|
Image ImageType
|
|
// Stores possible LinkType type for icon property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for icon property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *iconJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Image, ok = resolveObject(kind).(ImageType); t.Image != nil && ok {
|
|
err = t.Image.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *iconJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Image != nil {
|
|
i, err = t.Image.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// imageJoinIntermediateType will only have one of its values set at most
|
|
type imageJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ImageType type for image property
|
|
Image ImageType
|
|
// Stores possible LinkType type for image property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for image property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *imageJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Image, ok = resolveObject(kind).(ImageType); t.Image != nil && ok {
|
|
err = t.Image.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *imageJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Image != nil {
|
|
i, err = t.Image.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// inReplyToJoinIntermediateType will only have one of its values set at most
|
|
type inReplyToJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for inReplyTo property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for inReplyTo property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for inReplyTo property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *inReplyToJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *inReplyToJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// locationJoinIntermediateType will only have one of its values set at most
|
|
type locationJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for location property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for location property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for location property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *locationJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *locationJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// previewJoinIntermediateType will only have one of its values set at most
|
|
type previewJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for preview property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for preview property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for preview property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *previewJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *previewJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// publishedJoinIntermediateType will only have one of its values set at most
|
|
type publishedJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *time.Time type for published property
|
|
dateTime *time.Time
|
|
// Stores possible *url.URL type for published property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *publishedJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.dateTime, err = dateTimeDeserialize(i)
|
|
if err != nil {
|
|
t.dateTime = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *publishedJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.dateTime != nil {
|
|
i = dateTimeSerialize(*t.dateTime)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// repliesJoinIntermediateType will only have one of its values set at most
|
|
type repliesJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible CollectionType type for replies property
|
|
Collection CollectionType
|
|
// Stores possible *url.URL type for replies property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *repliesJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok {
|
|
err = t.Collection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *repliesJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Collection != nil {
|
|
i, err = t.Collection.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// startTimeJoinIntermediateType will only have one of its values set at most
|
|
type startTimeJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *time.Time type for startTime property
|
|
dateTime *time.Time
|
|
// Stores possible *url.URL type for startTime property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *startTimeJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.dateTime, err = dateTimeDeserialize(i)
|
|
if err != nil {
|
|
t.dateTime = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *startTimeJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.dateTime != nil {
|
|
i = dateTimeSerialize(*t.dateTime)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// summaryJoinIntermediateType will only have one of its values set at most
|
|
type summaryJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *string type for summary property
|
|
stringName *string
|
|
// Stores possible *string type for summary property
|
|
langString *string
|
|
// Stores possible *url.URL type for summary property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *summaryJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.stringName, err = stringDeserialize(i)
|
|
if err != nil {
|
|
t.stringName = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.langString, err = langStringDeserialize(i)
|
|
if err != nil {
|
|
t.langString = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *summaryJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.stringName != nil {
|
|
i = stringSerialize(*t.stringName)
|
|
return
|
|
}
|
|
if t.langString != nil {
|
|
i = langStringSerialize(*t.langString)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// tagJoinIntermediateType will only have one of its values set at most
|
|
type tagJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for tag property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for tag property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for tag property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *tagJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *tagJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// updatedJoinIntermediateType will only have one of its values set at most
|
|
type updatedJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *time.Time type for updated property
|
|
dateTime *time.Time
|
|
// Stores possible *url.URL type for updated property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *updatedJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.dateTime, err = dateTimeDeserialize(i)
|
|
if err != nil {
|
|
t.dateTime = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *updatedJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.dateTime != nil {
|
|
i = dateTimeSerialize(*t.dateTime)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// urlJoinIntermediateType will only have one of its values set at most
|
|
type urlJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *url.URL type for url property
|
|
anyURI *url.URL
|
|
// Stores possible LinkType type for url property
|
|
Link LinkType
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *urlJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.anyURI, err = anyURIDeserialize(i)
|
|
if err != nil {
|
|
t.anyURI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *urlJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.anyURI != nil {
|
|
i = anyURISerialize(t.anyURI)
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// toJoinIntermediateType will only have one of its values set at most
|
|
type toJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for to property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for to property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for to property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *toJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *toJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// btoJoinIntermediateType will only have one of its values set at most
|
|
type btoJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for bto property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for bto property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for bto property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *btoJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *btoJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// ccJoinIntermediateType will only have one of its values set at most
|
|
type ccJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for cc property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for cc property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for cc property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *ccJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *ccJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// bccJoinIntermediateType will only have one of its values set at most
|
|
type bccJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for bcc property
|
|
Object ObjectType
|
|
// Stores possible LinkType type for bcc property
|
|
Link LinkType
|
|
// Stores possible *url.URL type for bcc property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *bccJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Link, ok = resolveLink(kind).(LinkType); t.Link != nil && ok {
|
|
err = t.Link.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *bccJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.Link != nil {
|
|
i, err = t.Link.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// mediaTypeJoinIntermediateType will only have one of its values set at most
|
|
type mediaTypeJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *string type for mediaType property
|
|
mimeMediaTypeValue *string
|
|
// Stores possible *url.URL type for mediaType property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *mediaTypeJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.mimeMediaTypeValue, err = mimeMediaTypeValueDeserialize(i)
|
|
if err != nil {
|
|
t.mimeMediaTypeValue = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *mediaTypeJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.mimeMediaTypeValue != nil {
|
|
i = mimeMediaTypeValueSerialize(*t.mimeMediaTypeValue)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// durationJoinIntermediateType will only have one of its values set at most
|
|
type durationJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *time.Duration type for duration property
|
|
duration *time.Duration
|
|
// Stores possible *url.URL type for duration property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *durationJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.duration, err = durationDeserialize(i)
|
|
if err != nil {
|
|
t.duration = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *durationJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.duration != nil {
|
|
i = durationSerialize(*t.duration)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// sourceJoinIntermediateType will only have one of its values set at most
|
|
type sourceJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for source property
|
|
Object ObjectType
|
|
// Stores possible *url.URL type for source property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *sourceJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *sourceJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// inboxJoinIntermediateType will only have one of its values set at most
|
|
type inboxJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible OrderedCollectionType type for inbox property
|
|
OrderedCollection OrderedCollectionType
|
|
// Stores possible *url.URL type for inbox property
|
|
anyURI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *inboxJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok {
|
|
err = t.OrderedCollection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.anyURI, err = anyURIDeserialize(i)
|
|
if err != nil {
|
|
t.anyURI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *inboxJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.OrderedCollection != nil {
|
|
i, err = t.OrderedCollection.Serialize()
|
|
return
|
|
}
|
|
if t.anyURI != nil {
|
|
i = anyURISerialize(t.anyURI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// outboxJoinIntermediateType will only have one of its values set at most
|
|
type outboxJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible OrderedCollectionType type for outbox property
|
|
OrderedCollection OrderedCollectionType
|
|
// Stores possible *url.URL type for outbox property
|
|
anyURI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *outboxJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok {
|
|
err = t.OrderedCollection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.anyURI, err = anyURIDeserialize(i)
|
|
if err != nil {
|
|
t.anyURI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *outboxJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.OrderedCollection != nil {
|
|
i, err = t.OrderedCollection.Serialize()
|
|
return
|
|
}
|
|
if t.anyURI != nil {
|
|
i = anyURISerialize(t.anyURI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// followingJoinIntermediateType will only have one of its values set at most
|
|
type followingJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible CollectionType type for following property
|
|
Collection CollectionType
|
|
// Stores possible OrderedCollectionType type for following property
|
|
OrderedCollection OrderedCollectionType
|
|
// Stores possible *url.URL type for following property
|
|
anyURI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *followingJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok {
|
|
err = t.Collection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok {
|
|
err = t.OrderedCollection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.anyURI, err = anyURIDeserialize(i)
|
|
if err != nil {
|
|
t.anyURI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *followingJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Collection != nil {
|
|
i, err = t.Collection.Serialize()
|
|
return
|
|
}
|
|
if t.OrderedCollection != nil {
|
|
i, err = t.OrderedCollection.Serialize()
|
|
return
|
|
}
|
|
if t.anyURI != nil {
|
|
i = anyURISerialize(t.anyURI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// followersJoinIntermediateType will only have one of its values set at most
|
|
type followersJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible CollectionType type for followers property
|
|
Collection CollectionType
|
|
// Stores possible OrderedCollectionType type for followers property
|
|
OrderedCollection OrderedCollectionType
|
|
// Stores possible *url.URL type for followers property
|
|
anyURI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *followersJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok {
|
|
err = t.Collection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok {
|
|
err = t.OrderedCollection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.anyURI, err = anyURIDeserialize(i)
|
|
if err != nil {
|
|
t.anyURI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *followersJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Collection != nil {
|
|
i, err = t.Collection.Serialize()
|
|
return
|
|
}
|
|
if t.OrderedCollection != nil {
|
|
i, err = t.OrderedCollection.Serialize()
|
|
return
|
|
}
|
|
if t.anyURI != nil {
|
|
i = anyURISerialize(t.anyURI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// likedJoinIntermediateType will only have one of its values set at most
|
|
type likedJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible CollectionType type for liked property
|
|
Collection CollectionType
|
|
// Stores possible OrderedCollectionType type for liked property
|
|
OrderedCollection OrderedCollectionType
|
|
// Stores possible *url.URL type for liked property
|
|
anyURI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *likedJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok {
|
|
err = t.Collection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok {
|
|
err = t.OrderedCollection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.anyURI, err = anyURIDeserialize(i)
|
|
if err != nil {
|
|
t.anyURI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *likedJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Collection != nil {
|
|
i, err = t.Collection.Serialize()
|
|
return
|
|
}
|
|
if t.OrderedCollection != nil {
|
|
i, err = t.OrderedCollection.Serialize()
|
|
return
|
|
}
|
|
if t.anyURI != nil {
|
|
i = anyURISerialize(t.anyURI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// likesJoinIntermediateType will only have one of its values set at most
|
|
type likesJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible CollectionType type for likes property
|
|
Collection CollectionType
|
|
// Stores possible OrderedCollectionType type for likes property
|
|
OrderedCollection OrderedCollectionType
|
|
// Stores possible *url.URL type for likes property
|
|
anyURI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *likesJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Collection, ok = resolveObject(kind).(CollectionType); t.Collection != nil && ok {
|
|
err = t.Collection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.OrderedCollection, ok = resolveObject(kind).(OrderedCollectionType); t.OrderedCollection != nil && ok {
|
|
err = t.OrderedCollection.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.anyURI, err = anyURIDeserialize(i)
|
|
if err != nil {
|
|
t.anyURI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *likesJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Collection != nil {
|
|
i, err = t.Collection.Serialize()
|
|
return
|
|
}
|
|
if t.OrderedCollection != nil {
|
|
i, err = t.OrderedCollection.Serialize()
|
|
return
|
|
}
|
|
if t.anyURI != nil {
|
|
i = anyURISerialize(t.anyURI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// preferredUsernameJoinIntermediateType will only have one of its values set at most
|
|
type preferredUsernameJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible *string type for preferredUsername property
|
|
stringName *string
|
|
// Stores possible *url.URL type for preferredUsername property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *preferredUsernameJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
err = fmt.Errorf("Given map but nothing to do with it for this type: %v", m)
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.stringName, err = stringDeserialize(i)
|
|
if err != nil {
|
|
t.stringName = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *preferredUsernameJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.stringName != nil {
|
|
i = stringSerialize(*t.stringName)
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// endpointsJoinIntermediateType will only have one of its values set at most
|
|
type endpointsJoinIntermediateType struct {
|
|
// An unknown value.
|
|
unknown_ interface{}
|
|
// Stores possible ObjectType type for endpoints property
|
|
Object ObjectType
|
|
// Stores possible *url.URL type for endpoints property
|
|
IRI *url.URL
|
|
}
|
|
|
|
// Deserialize takes an interface{} and attempts to create a valid intermediate type.
|
|
func (t *endpointsJoinIntermediateType) Deserialize(i interface{}) (err error) {
|
|
matched := false
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
if tv, ok := m["type"]; ok {
|
|
var types []string
|
|
if tvs, ok := tv.([]interface{}); ok {
|
|
for _, tvi := range tvs {
|
|
if typeString, ok := tvi.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
}
|
|
} else if typeString, ok := tv.(string); ok {
|
|
types = append(types, typeString)
|
|
}
|
|
if !matched {
|
|
for _, kind := range types {
|
|
if t.Object, ok = resolveObject(kind).(ObjectType); t.Object != nil && ok {
|
|
err = t.Object.Deserialize(m)
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
t.unknown_ = m
|
|
}
|
|
} else if i != nil {
|
|
if !matched {
|
|
t.IRI, err = IRIDeserialize(i)
|
|
if err != nil {
|
|
t.IRI = nil
|
|
} else {
|
|
matched = true
|
|
}
|
|
}
|
|
}
|
|
if !matched {
|
|
t.unknown_ = unknownValueDeserialize(i)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// Serialize turns this object into an interface{}.
|
|
func (t *endpointsJoinIntermediateType) Serialize() (i interface{}, err error) {
|
|
if t.Object != nil {
|
|
i, err = t.Object.Serialize()
|
|
return
|
|
}
|
|
if t.IRI != nil {
|
|
i = IRISerialize(t.IRI)
|
|
return
|
|
}
|
|
i = unknownValueSerialize(t.unknown_)
|
|
return
|
|
}
|
|
|
|
// deserializeactorJoinIntermediateType will accept a map to create a actorJoinIntermediateType
|
|
func deserializeActorJoinIntermediateType(in interface{}) (t *actorJoinIntermediateType, err error) {
|
|
tmp := &actorJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice actorJoinIntermediateType will accept a slice to create a slice of actorJoinIntermediateType
|
|
func deserializeSliceActorJoinIntermediateType(in []interface{}) (t []*actorJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &actorJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeactorJoinIntermediateType will accept a actorJoinIntermediateType to create a map
|
|
func serializeActorJoinIntermediateType(t *actorJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceactorJoinIntermediateType will accept a slice of actorJoinIntermediateType to create a slice result
|
|
func serializeSliceActorJoinIntermediateType(s []*actorJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeobjectJoinIntermediateType will accept a map to create a objectJoinIntermediateType
|
|
func deserializeObjectJoinIntermediateType(in interface{}) (t *objectJoinIntermediateType, err error) {
|
|
tmp := &objectJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice objectJoinIntermediateType will accept a slice to create a slice of objectJoinIntermediateType
|
|
func deserializeSliceObjectJoinIntermediateType(in []interface{}) (t []*objectJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &objectJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeobjectJoinIntermediateType will accept a objectJoinIntermediateType to create a map
|
|
func serializeObjectJoinIntermediateType(t *objectJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceobjectJoinIntermediateType will accept a slice of objectJoinIntermediateType to create a slice result
|
|
func serializeSliceObjectJoinIntermediateType(s []*objectJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetargetJoinIntermediateType will accept a map to create a targetJoinIntermediateType
|
|
func deserializeTargetJoinIntermediateType(in interface{}) (t *targetJoinIntermediateType, err error) {
|
|
tmp := &targetJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice targetJoinIntermediateType will accept a slice to create a slice of targetJoinIntermediateType
|
|
func deserializeSliceTargetJoinIntermediateType(in []interface{}) (t []*targetJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &targetJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetargetJoinIntermediateType will accept a targetJoinIntermediateType to create a map
|
|
func serializeTargetJoinIntermediateType(t *targetJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetargetJoinIntermediateType will accept a slice of targetJoinIntermediateType to create a slice result
|
|
func serializeSliceTargetJoinIntermediateType(s []*targetJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeresultJoinIntermediateType will accept a map to create a resultJoinIntermediateType
|
|
func deserializeResultJoinIntermediateType(in interface{}) (t *resultJoinIntermediateType, err error) {
|
|
tmp := &resultJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice resultJoinIntermediateType will accept a slice to create a slice of resultJoinIntermediateType
|
|
func deserializeSliceResultJoinIntermediateType(in []interface{}) (t []*resultJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &resultJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeresultJoinIntermediateType will accept a resultJoinIntermediateType to create a map
|
|
func serializeResultJoinIntermediateType(t *resultJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceresultJoinIntermediateType will accept a slice of resultJoinIntermediateType to create a slice result
|
|
func serializeSliceResultJoinIntermediateType(s []*resultJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoriginJoinIntermediateType will accept a map to create a originJoinIntermediateType
|
|
func deserializeOriginJoinIntermediateType(in interface{}) (t *originJoinIntermediateType, err error) {
|
|
tmp := &originJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice originJoinIntermediateType will accept a slice to create a slice of originJoinIntermediateType
|
|
func deserializeSliceOriginJoinIntermediateType(in []interface{}) (t []*originJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &originJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoriginJoinIntermediateType will accept a originJoinIntermediateType to create a map
|
|
func serializeOriginJoinIntermediateType(t *originJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoriginJoinIntermediateType will accept a slice of originJoinIntermediateType to create a slice result
|
|
func serializeSliceOriginJoinIntermediateType(s []*originJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinstrumentJoinIntermediateType will accept a map to create a instrumentJoinIntermediateType
|
|
func deserializeInstrumentJoinIntermediateType(in interface{}) (t *instrumentJoinIntermediateType, err error) {
|
|
tmp := &instrumentJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice instrumentJoinIntermediateType will accept a slice to create a slice of instrumentJoinIntermediateType
|
|
func deserializeSliceInstrumentJoinIntermediateType(in []interface{}) (t []*instrumentJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &instrumentJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinstrumentJoinIntermediateType will accept a instrumentJoinIntermediateType to create a map
|
|
func serializeInstrumentJoinIntermediateType(t *instrumentJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinstrumentJoinIntermediateType will accept a slice of instrumentJoinIntermediateType to create a slice result
|
|
func serializeSliceInstrumentJoinIntermediateType(s []*instrumentJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializealtitudeJoinIntermediateType will accept a map to create a altitudeJoinIntermediateType
|
|
func deserializeAltitudeJoinIntermediateType(in interface{}) (t *altitudeJoinIntermediateType, err error) {
|
|
tmp := &altitudeJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice altitudeJoinIntermediateType will accept a slice to create a slice of altitudeJoinIntermediateType
|
|
func deserializeSliceAltitudeJoinIntermediateType(in []interface{}) (t []*altitudeJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &altitudeJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializealtitudeJoinIntermediateType will accept a altitudeJoinIntermediateType to create a map
|
|
func serializeAltitudeJoinIntermediateType(t *altitudeJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicealtitudeJoinIntermediateType will accept a slice of altitudeJoinIntermediateType to create a slice result
|
|
func serializeSliceAltitudeJoinIntermediateType(s []*altitudeJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattachmentJoinIntermediateType will accept a map to create a attachmentJoinIntermediateType
|
|
func deserializeAttachmentJoinIntermediateType(in interface{}) (t *attachmentJoinIntermediateType, err error) {
|
|
tmp := &attachmentJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attachmentJoinIntermediateType will accept a slice to create a slice of attachmentJoinIntermediateType
|
|
func deserializeSliceAttachmentJoinIntermediateType(in []interface{}) (t []*attachmentJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attachmentJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattachmentJoinIntermediateType will accept a attachmentJoinIntermediateType to create a map
|
|
func serializeAttachmentJoinIntermediateType(t *attachmentJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattachmentJoinIntermediateType will accept a slice of attachmentJoinIntermediateType to create a slice result
|
|
func serializeSliceAttachmentJoinIntermediateType(s []*attachmentJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattributedToJoinIntermediateType will accept a map to create a attributedToJoinIntermediateType
|
|
func deserializeAttributedToJoinIntermediateType(in interface{}) (t *attributedToJoinIntermediateType, err error) {
|
|
tmp := &attributedToJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attributedToJoinIntermediateType will accept a slice to create a slice of attributedToJoinIntermediateType
|
|
func deserializeSliceAttributedToJoinIntermediateType(in []interface{}) (t []*attributedToJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attributedToJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattributedToJoinIntermediateType will accept a attributedToJoinIntermediateType to create a map
|
|
func serializeAttributedToJoinIntermediateType(t *attributedToJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattributedToJoinIntermediateType will accept a slice of attributedToJoinIntermediateType to create a slice result
|
|
func serializeSliceAttributedToJoinIntermediateType(s []*attributedToJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeaudienceJoinIntermediateType will accept a map to create a audienceJoinIntermediateType
|
|
func deserializeAudienceJoinIntermediateType(in interface{}) (t *audienceJoinIntermediateType, err error) {
|
|
tmp := &audienceJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice audienceJoinIntermediateType will accept a slice to create a slice of audienceJoinIntermediateType
|
|
func deserializeSliceAudienceJoinIntermediateType(in []interface{}) (t []*audienceJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &audienceJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeaudienceJoinIntermediateType will accept a audienceJoinIntermediateType to create a map
|
|
func serializeAudienceJoinIntermediateType(t *audienceJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceaudienceJoinIntermediateType will accept a slice of audienceJoinIntermediateType to create a slice result
|
|
func serializeSliceAudienceJoinIntermediateType(s []*audienceJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontentJoinIntermediateType will accept a map to create a contentJoinIntermediateType
|
|
func deserializeContentJoinIntermediateType(in interface{}) (t *contentJoinIntermediateType, err error) {
|
|
tmp := &contentJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contentJoinIntermediateType will accept a slice to create a slice of contentJoinIntermediateType
|
|
func deserializeSliceContentJoinIntermediateType(in []interface{}) (t []*contentJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contentJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontentJoinIntermediateType will accept a contentJoinIntermediateType to create a map
|
|
func serializeContentJoinIntermediateType(t *contentJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontentJoinIntermediateType will accept a slice of contentJoinIntermediateType to create a slice result
|
|
func serializeSliceContentJoinIntermediateType(s []*contentJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontextJoinIntermediateType will accept a map to create a contextJoinIntermediateType
|
|
func deserializeContextJoinIntermediateType(in interface{}) (t *contextJoinIntermediateType, err error) {
|
|
tmp := &contextJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contextJoinIntermediateType will accept a slice to create a slice of contextJoinIntermediateType
|
|
func deserializeSliceContextJoinIntermediateType(in []interface{}) (t []*contextJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contextJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontextJoinIntermediateType will accept a contextJoinIntermediateType to create a map
|
|
func serializeContextJoinIntermediateType(t *contextJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontextJoinIntermediateType will accept a slice of contextJoinIntermediateType to create a slice result
|
|
func serializeSliceContextJoinIntermediateType(s []*contextJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializenameJoinIntermediateType will accept a map to create a nameJoinIntermediateType
|
|
func deserializeNameJoinIntermediateType(in interface{}) (t *nameJoinIntermediateType, err error) {
|
|
tmp := &nameJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice nameJoinIntermediateType will accept a slice to create a slice of nameJoinIntermediateType
|
|
func deserializeSliceNameJoinIntermediateType(in []interface{}) (t []*nameJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &nameJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializenameJoinIntermediateType will accept a nameJoinIntermediateType to create a map
|
|
func serializeNameJoinIntermediateType(t *nameJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicenameJoinIntermediateType will accept a slice of nameJoinIntermediateType to create a slice result
|
|
func serializeSliceNameJoinIntermediateType(s []*nameJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendTimeJoinIntermediateType will accept a map to create a endTimeJoinIntermediateType
|
|
func deserializeEndTimeJoinIntermediateType(in interface{}) (t *endTimeJoinIntermediateType, err error) {
|
|
tmp := &endTimeJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endTimeJoinIntermediateType will accept a slice to create a slice of endTimeJoinIntermediateType
|
|
func deserializeSliceEndTimeJoinIntermediateType(in []interface{}) (t []*endTimeJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endTimeJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendTimeJoinIntermediateType will accept a endTimeJoinIntermediateType to create a map
|
|
func serializeEndTimeJoinIntermediateType(t *endTimeJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendTimeJoinIntermediateType will accept a slice of endTimeJoinIntermediateType to create a slice result
|
|
func serializeSliceEndTimeJoinIntermediateType(s []*endTimeJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializegeneratorJoinIntermediateType will accept a map to create a generatorJoinIntermediateType
|
|
func deserializeGeneratorJoinIntermediateType(in interface{}) (t *generatorJoinIntermediateType, err error) {
|
|
tmp := &generatorJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice generatorJoinIntermediateType will accept a slice to create a slice of generatorJoinIntermediateType
|
|
func deserializeSliceGeneratorJoinIntermediateType(in []interface{}) (t []*generatorJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &generatorJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializegeneratorJoinIntermediateType will accept a generatorJoinIntermediateType to create a map
|
|
func serializeGeneratorJoinIntermediateType(t *generatorJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicegeneratorJoinIntermediateType will accept a slice of generatorJoinIntermediateType to create a slice result
|
|
func serializeSliceGeneratorJoinIntermediateType(s []*generatorJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeiconJoinIntermediateType will accept a map to create a iconJoinIntermediateType
|
|
func deserializeIconJoinIntermediateType(in interface{}) (t *iconJoinIntermediateType, err error) {
|
|
tmp := &iconJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice iconJoinIntermediateType will accept a slice to create a slice of iconJoinIntermediateType
|
|
func deserializeSliceIconJoinIntermediateType(in []interface{}) (t []*iconJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &iconJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeiconJoinIntermediateType will accept a iconJoinIntermediateType to create a map
|
|
func serializeIconJoinIntermediateType(t *iconJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceiconJoinIntermediateType will accept a slice of iconJoinIntermediateType to create a slice result
|
|
func serializeSliceIconJoinIntermediateType(s []*iconJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeimageJoinIntermediateType will accept a map to create a imageJoinIntermediateType
|
|
func deserializeImageJoinIntermediateType(in interface{}) (t *imageJoinIntermediateType, err error) {
|
|
tmp := &imageJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice imageJoinIntermediateType will accept a slice to create a slice of imageJoinIntermediateType
|
|
func deserializeSliceImageJoinIntermediateType(in []interface{}) (t []*imageJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &imageJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeimageJoinIntermediateType will accept a imageJoinIntermediateType to create a map
|
|
func serializeImageJoinIntermediateType(t *imageJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceimageJoinIntermediateType will accept a slice of imageJoinIntermediateType to create a slice result
|
|
func serializeSliceImageJoinIntermediateType(s []*imageJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinReplyToJoinIntermediateType will accept a map to create a inReplyToJoinIntermediateType
|
|
func deserializeInReplyToJoinIntermediateType(in interface{}) (t *inReplyToJoinIntermediateType, err error) {
|
|
tmp := &inReplyToJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inReplyToJoinIntermediateType will accept a slice to create a slice of inReplyToJoinIntermediateType
|
|
func deserializeSliceInReplyToJoinIntermediateType(in []interface{}) (t []*inReplyToJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inReplyToJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinReplyToJoinIntermediateType will accept a inReplyToJoinIntermediateType to create a map
|
|
func serializeInReplyToJoinIntermediateType(t *inReplyToJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinReplyToJoinIntermediateType will accept a slice of inReplyToJoinIntermediateType to create a slice result
|
|
func serializeSliceInReplyToJoinIntermediateType(s []*inReplyToJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelocationJoinIntermediateType will accept a map to create a locationJoinIntermediateType
|
|
func deserializeLocationJoinIntermediateType(in interface{}) (t *locationJoinIntermediateType, err error) {
|
|
tmp := &locationJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice locationJoinIntermediateType will accept a slice to create a slice of locationJoinIntermediateType
|
|
func deserializeSliceLocationJoinIntermediateType(in []interface{}) (t []*locationJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &locationJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelocationJoinIntermediateType will accept a locationJoinIntermediateType to create a map
|
|
func serializeLocationJoinIntermediateType(t *locationJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelocationJoinIntermediateType will accept a slice of locationJoinIntermediateType to create a slice result
|
|
func serializeSliceLocationJoinIntermediateType(s []*locationJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreviewJoinIntermediateType will accept a map to create a previewJoinIntermediateType
|
|
func deserializePreviewJoinIntermediateType(in interface{}) (t *previewJoinIntermediateType, err error) {
|
|
tmp := &previewJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice previewJoinIntermediateType will accept a slice to create a slice of previewJoinIntermediateType
|
|
func deserializeSlicePreviewJoinIntermediateType(in []interface{}) (t []*previewJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &previewJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreviewJoinIntermediateType will accept a previewJoinIntermediateType to create a map
|
|
func serializePreviewJoinIntermediateType(t *previewJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreviewJoinIntermediateType will accept a slice of previewJoinIntermediateType to create a slice result
|
|
func serializeSlicePreviewJoinIntermediateType(s []*previewJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepublishedJoinIntermediateType will accept a map to create a publishedJoinIntermediateType
|
|
func deserializePublishedJoinIntermediateType(in interface{}) (t *publishedJoinIntermediateType, err error) {
|
|
tmp := &publishedJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice publishedJoinIntermediateType will accept a slice to create a slice of publishedJoinIntermediateType
|
|
func deserializeSlicePublishedJoinIntermediateType(in []interface{}) (t []*publishedJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &publishedJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepublishedJoinIntermediateType will accept a publishedJoinIntermediateType to create a map
|
|
func serializePublishedJoinIntermediateType(t *publishedJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepublishedJoinIntermediateType will accept a slice of publishedJoinIntermediateType to create a slice result
|
|
func serializeSlicePublishedJoinIntermediateType(s []*publishedJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializerepliesJoinIntermediateType will accept a map to create a repliesJoinIntermediateType
|
|
func deserializeRepliesJoinIntermediateType(in interface{}) (t *repliesJoinIntermediateType, err error) {
|
|
tmp := &repliesJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice repliesJoinIntermediateType will accept a slice to create a slice of repliesJoinIntermediateType
|
|
func deserializeSliceRepliesJoinIntermediateType(in []interface{}) (t []*repliesJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &repliesJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializerepliesJoinIntermediateType will accept a repliesJoinIntermediateType to create a map
|
|
func serializeRepliesJoinIntermediateType(t *repliesJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicerepliesJoinIntermediateType will accept a slice of repliesJoinIntermediateType to create a slice result
|
|
func serializeSliceRepliesJoinIntermediateType(s []*repliesJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializestartTimeJoinIntermediateType will accept a map to create a startTimeJoinIntermediateType
|
|
func deserializeStartTimeJoinIntermediateType(in interface{}) (t *startTimeJoinIntermediateType, err error) {
|
|
tmp := &startTimeJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice startTimeJoinIntermediateType will accept a slice to create a slice of startTimeJoinIntermediateType
|
|
func deserializeSliceStartTimeJoinIntermediateType(in []interface{}) (t []*startTimeJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &startTimeJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializestartTimeJoinIntermediateType will accept a startTimeJoinIntermediateType to create a map
|
|
func serializeStartTimeJoinIntermediateType(t *startTimeJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicestartTimeJoinIntermediateType will accept a slice of startTimeJoinIntermediateType to create a slice result
|
|
func serializeSliceStartTimeJoinIntermediateType(s []*startTimeJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesummaryJoinIntermediateType will accept a map to create a summaryJoinIntermediateType
|
|
func deserializeSummaryJoinIntermediateType(in interface{}) (t *summaryJoinIntermediateType, err error) {
|
|
tmp := &summaryJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice summaryJoinIntermediateType will accept a slice to create a slice of summaryJoinIntermediateType
|
|
func deserializeSliceSummaryJoinIntermediateType(in []interface{}) (t []*summaryJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &summaryJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesummaryJoinIntermediateType will accept a summaryJoinIntermediateType to create a map
|
|
func serializeSummaryJoinIntermediateType(t *summaryJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesummaryJoinIntermediateType will accept a slice of summaryJoinIntermediateType to create a slice result
|
|
func serializeSliceSummaryJoinIntermediateType(s []*summaryJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetagJoinIntermediateType will accept a map to create a tagJoinIntermediateType
|
|
func deserializeTagJoinIntermediateType(in interface{}) (t *tagJoinIntermediateType, err error) {
|
|
tmp := &tagJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice tagJoinIntermediateType will accept a slice to create a slice of tagJoinIntermediateType
|
|
func deserializeSliceTagJoinIntermediateType(in []interface{}) (t []*tagJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &tagJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetagJoinIntermediateType will accept a tagJoinIntermediateType to create a map
|
|
func serializeTagJoinIntermediateType(t *tagJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetagJoinIntermediateType will accept a slice of tagJoinIntermediateType to create a slice result
|
|
func serializeSliceTagJoinIntermediateType(s []*tagJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeupdatedJoinIntermediateType will accept a map to create a updatedJoinIntermediateType
|
|
func deserializeUpdatedJoinIntermediateType(in interface{}) (t *updatedJoinIntermediateType, err error) {
|
|
tmp := &updatedJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice updatedJoinIntermediateType will accept a slice to create a slice of updatedJoinIntermediateType
|
|
func deserializeSliceUpdatedJoinIntermediateType(in []interface{}) (t []*updatedJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &updatedJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeupdatedJoinIntermediateType will accept a updatedJoinIntermediateType to create a map
|
|
func serializeUpdatedJoinIntermediateType(t *updatedJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceupdatedJoinIntermediateType will accept a slice of updatedJoinIntermediateType to create a slice result
|
|
func serializeSliceUpdatedJoinIntermediateType(s []*updatedJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeurlJoinIntermediateType will accept a map to create a urlJoinIntermediateType
|
|
func deserializeUrlJoinIntermediateType(in interface{}) (t *urlJoinIntermediateType, err error) {
|
|
tmp := &urlJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice urlJoinIntermediateType will accept a slice to create a slice of urlJoinIntermediateType
|
|
func deserializeSliceUrlJoinIntermediateType(in []interface{}) (t []*urlJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &urlJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeurlJoinIntermediateType will accept a urlJoinIntermediateType to create a map
|
|
func serializeUrlJoinIntermediateType(t *urlJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceurlJoinIntermediateType will accept a slice of urlJoinIntermediateType to create a slice result
|
|
func serializeSliceUrlJoinIntermediateType(s []*urlJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetoJoinIntermediateType will accept a map to create a toJoinIntermediateType
|
|
func deserializeToJoinIntermediateType(in interface{}) (t *toJoinIntermediateType, err error) {
|
|
tmp := &toJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice toJoinIntermediateType will accept a slice to create a slice of toJoinIntermediateType
|
|
func deserializeSliceToJoinIntermediateType(in []interface{}) (t []*toJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &toJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetoJoinIntermediateType will accept a toJoinIntermediateType to create a map
|
|
func serializeToJoinIntermediateType(t *toJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetoJoinIntermediateType will accept a slice of toJoinIntermediateType to create a slice result
|
|
func serializeSliceToJoinIntermediateType(s []*toJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebtoJoinIntermediateType will accept a map to create a btoJoinIntermediateType
|
|
func deserializeBtoJoinIntermediateType(in interface{}) (t *btoJoinIntermediateType, err error) {
|
|
tmp := &btoJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice btoJoinIntermediateType will accept a slice to create a slice of btoJoinIntermediateType
|
|
func deserializeSliceBtoJoinIntermediateType(in []interface{}) (t []*btoJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &btoJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebtoJoinIntermediateType will accept a btoJoinIntermediateType to create a map
|
|
func serializeBtoJoinIntermediateType(t *btoJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebtoJoinIntermediateType will accept a slice of btoJoinIntermediateType to create a slice result
|
|
func serializeSliceBtoJoinIntermediateType(s []*btoJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeccJoinIntermediateType will accept a map to create a ccJoinIntermediateType
|
|
func deserializeCcJoinIntermediateType(in interface{}) (t *ccJoinIntermediateType, err error) {
|
|
tmp := &ccJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice ccJoinIntermediateType will accept a slice to create a slice of ccJoinIntermediateType
|
|
func deserializeSliceCcJoinIntermediateType(in []interface{}) (t []*ccJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &ccJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeccJoinIntermediateType will accept a ccJoinIntermediateType to create a map
|
|
func serializeCcJoinIntermediateType(t *ccJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceccJoinIntermediateType will accept a slice of ccJoinIntermediateType to create a slice result
|
|
func serializeSliceCcJoinIntermediateType(s []*ccJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebccJoinIntermediateType will accept a map to create a bccJoinIntermediateType
|
|
func deserializeBccJoinIntermediateType(in interface{}) (t *bccJoinIntermediateType, err error) {
|
|
tmp := &bccJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice bccJoinIntermediateType will accept a slice to create a slice of bccJoinIntermediateType
|
|
func deserializeSliceBccJoinIntermediateType(in []interface{}) (t []*bccJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &bccJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebccJoinIntermediateType will accept a bccJoinIntermediateType to create a map
|
|
func serializeBccJoinIntermediateType(t *bccJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebccJoinIntermediateType will accept a slice of bccJoinIntermediateType to create a slice result
|
|
func serializeSliceBccJoinIntermediateType(s []*bccJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializemediaTypeJoinIntermediateType will accept a map to create a mediaTypeJoinIntermediateType
|
|
func deserializeMediaTypeJoinIntermediateType(in interface{}) (t *mediaTypeJoinIntermediateType, err error) {
|
|
tmp := &mediaTypeJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice mediaTypeJoinIntermediateType will accept a slice to create a slice of mediaTypeJoinIntermediateType
|
|
func deserializeSliceMediaTypeJoinIntermediateType(in []interface{}) (t []*mediaTypeJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &mediaTypeJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializemediaTypeJoinIntermediateType will accept a mediaTypeJoinIntermediateType to create a map
|
|
func serializeMediaTypeJoinIntermediateType(t *mediaTypeJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicemediaTypeJoinIntermediateType will accept a slice of mediaTypeJoinIntermediateType to create a slice result
|
|
func serializeSliceMediaTypeJoinIntermediateType(s []*mediaTypeJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializedurationJoinIntermediateType will accept a map to create a durationJoinIntermediateType
|
|
func deserializeDurationJoinIntermediateType(in interface{}) (t *durationJoinIntermediateType, err error) {
|
|
tmp := &durationJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice durationJoinIntermediateType will accept a slice to create a slice of durationJoinIntermediateType
|
|
func deserializeSliceDurationJoinIntermediateType(in []interface{}) (t []*durationJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &durationJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializedurationJoinIntermediateType will accept a durationJoinIntermediateType to create a map
|
|
func serializeDurationJoinIntermediateType(t *durationJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicedurationJoinIntermediateType will accept a slice of durationJoinIntermediateType to create a slice result
|
|
func serializeSliceDurationJoinIntermediateType(s []*durationJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesourceJoinIntermediateType will accept a map to create a sourceJoinIntermediateType
|
|
func deserializeSourceJoinIntermediateType(in interface{}) (t *sourceJoinIntermediateType, err error) {
|
|
tmp := &sourceJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice sourceJoinIntermediateType will accept a slice to create a slice of sourceJoinIntermediateType
|
|
func deserializeSliceSourceJoinIntermediateType(in []interface{}) (t []*sourceJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &sourceJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesourceJoinIntermediateType will accept a sourceJoinIntermediateType to create a map
|
|
func serializeSourceJoinIntermediateType(t *sourceJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesourceJoinIntermediateType will accept a slice of sourceJoinIntermediateType to create a slice result
|
|
func serializeSliceSourceJoinIntermediateType(s []*sourceJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinboxJoinIntermediateType will accept a map to create a inboxJoinIntermediateType
|
|
func deserializeInboxJoinIntermediateType(in interface{}) (t *inboxJoinIntermediateType, err error) {
|
|
tmp := &inboxJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inboxJoinIntermediateType will accept a slice to create a slice of inboxJoinIntermediateType
|
|
func deserializeSliceInboxJoinIntermediateType(in []interface{}) (t []*inboxJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inboxJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinboxJoinIntermediateType will accept a inboxJoinIntermediateType to create a map
|
|
func serializeInboxJoinIntermediateType(t *inboxJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinboxJoinIntermediateType will accept a slice of inboxJoinIntermediateType to create a slice result
|
|
func serializeSliceInboxJoinIntermediateType(s []*inboxJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoutboxJoinIntermediateType will accept a map to create a outboxJoinIntermediateType
|
|
func deserializeOutboxJoinIntermediateType(in interface{}) (t *outboxJoinIntermediateType, err error) {
|
|
tmp := &outboxJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice outboxJoinIntermediateType will accept a slice to create a slice of outboxJoinIntermediateType
|
|
func deserializeSliceOutboxJoinIntermediateType(in []interface{}) (t []*outboxJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &outboxJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoutboxJoinIntermediateType will accept a outboxJoinIntermediateType to create a map
|
|
func serializeOutboxJoinIntermediateType(t *outboxJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoutboxJoinIntermediateType will accept a slice of outboxJoinIntermediateType to create a slice result
|
|
func serializeSliceOutboxJoinIntermediateType(s []*outboxJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowingJoinIntermediateType will accept a map to create a followingJoinIntermediateType
|
|
func deserializeFollowingJoinIntermediateType(in interface{}) (t *followingJoinIntermediateType, err error) {
|
|
tmp := &followingJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followingJoinIntermediateType will accept a slice to create a slice of followingJoinIntermediateType
|
|
func deserializeSliceFollowingJoinIntermediateType(in []interface{}) (t []*followingJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followingJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowingJoinIntermediateType will accept a followingJoinIntermediateType to create a map
|
|
func serializeFollowingJoinIntermediateType(t *followingJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowingJoinIntermediateType will accept a slice of followingJoinIntermediateType to create a slice result
|
|
func serializeSliceFollowingJoinIntermediateType(s []*followingJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowersJoinIntermediateType will accept a map to create a followersJoinIntermediateType
|
|
func deserializeFollowersJoinIntermediateType(in interface{}) (t *followersJoinIntermediateType, err error) {
|
|
tmp := &followersJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followersJoinIntermediateType will accept a slice to create a slice of followersJoinIntermediateType
|
|
func deserializeSliceFollowersJoinIntermediateType(in []interface{}) (t []*followersJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followersJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowersJoinIntermediateType will accept a followersJoinIntermediateType to create a map
|
|
func serializeFollowersJoinIntermediateType(t *followersJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowersJoinIntermediateType will accept a slice of followersJoinIntermediateType to create a slice result
|
|
func serializeSliceFollowersJoinIntermediateType(s []*followersJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikedJoinIntermediateType will accept a map to create a likedJoinIntermediateType
|
|
func deserializeLikedJoinIntermediateType(in interface{}) (t *likedJoinIntermediateType, err error) {
|
|
tmp := &likedJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likedJoinIntermediateType will accept a slice to create a slice of likedJoinIntermediateType
|
|
func deserializeSliceLikedJoinIntermediateType(in []interface{}) (t []*likedJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likedJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikedJoinIntermediateType will accept a likedJoinIntermediateType to create a map
|
|
func serializeLikedJoinIntermediateType(t *likedJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikedJoinIntermediateType will accept a slice of likedJoinIntermediateType to create a slice result
|
|
func serializeSliceLikedJoinIntermediateType(s []*likedJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikesJoinIntermediateType will accept a map to create a likesJoinIntermediateType
|
|
func deserializeLikesJoinIntermediateType(in interface{}) (t *likesJoinIntermediateType, err error) {
|
|
tmp := &likesJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likesJoinIntermediateType will accept a slice to create a slice of likesJoinIntermediateType
|
|
func deserializeSliceLikesJoinIntermediateType(in []interface{}) (t []*likesJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likesJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikesJoinIntermediateType will accept a likesJoinIntermediateType to create a map
|
|
func serializeLikesJoinIntermediateType(t *likesJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikesJoinIntermediateType will accept a slice of likesJoinIntermediateType to create a slice result
|
|
func serializeSliceLikesJoinIntermediateType(s []*likesJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreferredUsernameJoinIntermediateType will accept a map to create a preferredUsernameJoinIntermediateType
|
|
func deserializePreferredUsernameJoinIntermediateType(in interface{}) (t *preferredUsernameJoinIntermediateType, err error) {
|
|
tmp := &preferredUsernameJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice preferredUsernameJoinIntermediateType will accept a slice to create a slice of preferredUsernameJoinIntermediateType
|
|
func deserializeSlicePreferredUsernameJoinIntermediateType(in []interface{}) (t []*preferredUsernameJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &preferredUsernameJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreferredUsernameJoinIntermediateType will accept a preferredUsernameJoinIntermediateType to create a map
|
|
func serializePreferredUsernameJoinIntermediateType(t *preferredUsernameJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreferredUsernameJoinIntermediateType will accept a slice of preferredUsernameJoinIntermediateType to create a slice result
|
|
func serializeSlicePreferredUsernameJoinIntermediateType(s []*preferredUsernameJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendpointsJoinIntermediateType will accept a map to create a endpointsJoinIntermediateType
|
|
func deserializeEndpointsJoinIntermediateType(in interface{}) (t *endpointsJoinIntermediateType, err error) {
|
|
tmp := &endpointsJoinIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endpointsJoinIntermediateType will accept a slice to create a slice of endpointsJoinIntermediateType
|
|
func deserializeSliceEndpointsJoinIntermediateType(in []interface{}) (t []*endpointsJoinIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endpointsJoinIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendpointsJoinIntermediateType will accept a endpointsJoinIntermediateType to create a map
|
|
func serializeEndpointsJoinIntermediateType(t *endpointsJoinIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendpointsJoinIntermediateType will accept a slice of endpointsJoinIntermediateType to create a slice result
|
|
func serializeSliceEndpointsJoinIntermediateType(s []*endpointsJoinIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|