11931 行
336 KiB
Go
11931 行
336 KiB
Go
//
|
|
package vocab
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
// ListenType is an interface for accepting types that extend from 'Listen'.
|
|
type ListenType 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 listened to the object.
|
|
type Listen struct {
|
|
// An unknown value.
|
|
unknown_ map[string]interface{}
|
|
// The 'actor' value could have multiple types and values
|
|
actor []*actorListenIntermediateType
|
|
// The 'object' value could have multiple types and values
|
|
object []*objectListenIntermediateType
|
|
// The 'target' value could have multiple types and values
|
|
target []*targetListenIntermediateType
|
|
// The 'result' value could have multiple types and values
|
|
result []*resultListenIntermediateType
|
|
// The 'origin' value could have multiple types and values
|
|
origin []*originListenIntermediateType
|
|
// The 'instrument' value could have multiple types and values
|
|
instrument []*instrumentListenIntermediateType
|
|
// The functional 'altitude' value could have multiple types, but only a single value
|
|
altitude *altitudeListenIntermediateType
|
|
// The 'attachment' value could have multiple types and values
|
|
attachment []*attachmentListenIntermediateType
|
|
// The 'attributedTo' value could have multiple types and values
|
|
attributedTo []*attributedToListenIntermediateType
|
|
// The 'audience' value could have multiple types and values
|
|
audience []*audienceListenIntermediateType
|
|
// The 'content' value could have multiple types and values
|
|
content []*contentListenIntermediateType
|
|
// The 'contentMap' value holds language-specific values for property 'content'
|
|
contentMap map[string]string
|
|
// The 'context' value could have multiple types and values
|
|
context []*contextListenIntermediateType
|
|
// The 'name' value could have multiple types and values
|
|
name []*nameListenIntermediateType
|
|
// 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 *endTimeListenIntermediateType
|
|
// The 'generator' value could have multiple types and values
|
|
generator []*generatorListenIntermediateType
|
|
// The 'icon' value could have multiple types and values
|
|
icon []*iconListenIntermediateType
|
|
// 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 []*imageListenIntermediateType
|
|
// The 'inReplyTo' value could have multiple types and values
|
|
inReplyTo []*inReplyToListenIntermediateType
|
|
// The 'location' value could have multiple types and values
|
|
location []*locationListenIntermediateType
|
|
// The 'preview' value could have multiple types and values
|
|
preview []*previewListenIntermediateType
|
|
// The functional 'published' value could have multiple types, but only a single value
|
|
published *publishedListenIntermediateType
|
|
// The functional 'replies' value could have multiple types, but only a single value
|
|
replies *repliesListenIntermediateType
|
|
// The functional 'startTime' value could have multiple types, but only a single value
|
|
startTime *startTimeListenIntermediateType
|
|
// The 'summary' value could have multiple types and values
|
|
summary []*summaryListenIntermediateType
|
|
// The 'summaryMap' value holds language-specific values for property 'summary'
|
|
summaryMap map[string]string
|
|
// The 'tag' value could have multiple types and values
|
|
tag []*tagListenIntermediateType
|
|
// 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 *updatedListenIntermediateType
|
|
// The 'url' value could have multiple types and values
|
|
url []*urlListenIntermediateType
|
|
// The 'to' value could have multiple types and values
|
|
to []*toListenIntermediateType
|
|
// The 'bto' value could have multiple types and values
|
|
bto []*btoListenIntermediateType
|
|
// The 'cc' value could have multiple types and values
|
|
cc []*ccListenIntermediateType
|
|
// The 'bcc' value could have multiple types and values
|
|
bcc []*bccListenIntermediateType
|
|
// The functional 'mediaType' value could have multiple types, but only a single value
|
|
mediaType *mediaTypeListenIntermediateType
|
|
// The functional 'duration' value could have multiple types, but only a single value
|
|
duration *durationListenIntermediateType
|
|
// The functional 'source' value could have multiple types, but only a single value
|
|
source *sourceListenIntermediateType
|
|
// The functional 'inbox' value could have multiple types, but only a single value
|
|
inbox *inboxListenIntermediateType
|
|
// The functional 'outbox' value could have multiple types, but only a single value
|
|
outbox *outboxListenIntermediateType
|
|
// The functional 'following' value could have multiple types, but only a single value
|
|
following *followingListenIntermediateType
|
|
// The functional 'followers' value could have multiple types, but only a single value
|
|
followers *followersListenIntermediateType
|
|
// The functional 'liked' value could have multiple types, but only a single value
|
|
liked *likedListenIntermediateType
|
|
// The functional 'likes' value could have multiple types, but only a single value
|
|
likes *likesListenIntermediateType
|
|
// 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 *preferredUsernameListenIntermediateType
|
|
// 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 *endpointsListenIntermediateType
|
|
// 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 *Listen) ActorLen() (l int) {
|
|
return len(t.actor)
|
|
|
|
}
|
|
|
|
// IsActorObject determines whether the call to GetActorObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetActorObject(index int) (v ObjectType) {
|
|
return t.actor[index].Object
|
|
|
|
}
|
|
|
|
// AppendActorObject adds to the back of actor a ObjectType type
|
|
func (t *Listen) AppendActorObject(v ObjectType) {
|
|
t.actor = append(t.actor, &actorListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependActorObject adds to the front of actor a ObjectType type
|
|
func (t *Listen) PrependActorObject(v ObjectType) {
|
|
t.actor = append([]*actorListenIntermediateType{&actorListenIntermediateType{Object: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetActorLink(index int) (v LinkType) {
|
|
return t.actor[index].Link
|
|
|
|
}
|
|
|
|
// AppendActorLink adds to the back of actor a LinkType type
|
|
func (t *Listen) AppendActorLink(v LinkType) {
|
|
t.actor = append(t.actor, &actorListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependActorLink adds to the front of actor a LinkType type
|
|
func (t *Listen) PrependActorLink(v LinkType) {
|
|
t.actor = append([]*actorListenIntermediateType{&actorListenIntermediateType{Link: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetActorIRI(index int) (v *url.URL) {
|
|
return t.actor[index].IRI
|
|
|
|
}
|
|
|
|
// AppendActorIRI adds to the back of actor a *url.URL type
|
|
func (t *Listen) AppendActorIRI(v *url.URL) {
|
|
t.actor = append(t.actor, &actorListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependActorIRI adds to the front of actor a *url.URL type
|
|
func (t *Listen) PrependActorIRI(v *url.URL) {
|
|
t.actor = append([]*actorListenIntermediateType{&actorListenIntermediateType{IRI: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownActor() (ok bool) {
|
|
return t.actor != nil && t.actor[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownActor returns the unknown value for actor
|
|
func (t *Listen) GetUnknownActor() (v interface{}) {
|
|
return t.actor[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownActor sets the unknown value of actor
|
|
func (t *Listen) SetUnknownActor(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &actorListenIntermediateType{}
|
|
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 *Listen) ObjectLen() (l int) {
|
|
return len(t.object)
|
|
|
|
}
|
|
|
|
// IsObject determines whether the call to GetObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetObject(index int) (v ObjectType) {
|
|
return t.object[index].Object
|
|
|
|
}
|
|
|
|
// AppendObject adds to the back of object a ObjectType type
|
|
func (t *Listen) AppendObject(v ObjectType) {
|
|
t.object = append(t.object, &objectListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependObject adds to the front of object a ObjectType type
|
|
func (t *Listen) PrependObject(v ObjectType) {
|
|
t.object = append([]*objectListenIntermediateType{&objectListenIntermediateType{Object: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetObjectIRI(index int) (v *url.URL) {
|
|
return t.object[index].IRI
|
|
|
|
}
|
|
|
|
// AppendObjectIRI adds to the back of object a *url.URL type
|
|
func (t *Listen) AppendObjectIRI(v *url.URL) {
|
|
t.object = append(t.object, &objectListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependObjectIRI adds to the front of object a *url.URL type
|
|
func (t *Listen) PrependObjectIRI(v *url.URL) {
|
|
t.object = append([]*objectListenIntermediateType{&objectListenIntermediateType{IRI: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObjectIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownObject() (ok bool) {
|
|
return t.object != nil && t.object[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownObject returns the unknown value for object
|
|
func (t *Listen) GetUnknownObject() (v interface{}) {
|
|
return t.object[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownObject sets the unknown value of object
|
|
func (t *Listen) SetUnknownObject(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &objectListenIntermediateType{}
|
|
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 *Listen) TargetLen() (l int) {
|
|
return len(t.target)
|
|
|
|
}
|
|
|
|
// IsTargetObject determines whether the call to GetTargetObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetTargetObject(index int) (v ObjectType) {
|
|
return t.target[index].Object
|
|
|
|
}
|
|
|
|
// AppendTargetObject adds to the back of target a ObjectType type
|
|
func (t *Listen) AppendTargetObject(v ObjectType) {
|
|
t.target = append(t.target, &targetListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTargetObject adds to the front of target a ObjectType type
|
|
func (t *Listen) PrependTargetObject(v ObjectType) {
|
|
t.target = append([]*targetListenIntermediateType{&targetListenIntermediateType{Object: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetTargetLink(index int) (v LinkType) {
|
|
return t.target[index].Link
|
|
|
|
}
|
|
|
|
// AppendTargetLink adds to the back of target a LinkType type
|
|
func (t *Listen) AppendTargetLink(v LinkType) {
|
|
t.target = append(t.target, &targetListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTargetLink adds to the front of target a LinkType type
|
|
func (t *Listen) PrependTargetLink(v LinkType) {
|
|
t.target = append([]*targetListenIntermediateType{&targetListenIntermediateType{Link: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetTargetIRI(index int) (v *url.URL) {
|
|
return t.target[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTargetIRI adds to the back of target a *url.URL type
|
|
func (t *Listen) AppendTargetIRI(v *url.URL) {
|
|
t.target = append(t.target, &targetListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTargetIRI adds to the front of target a *url.URL type
|
|
func (t *Listen) PrependTargetIRI(v *url.URL) {
|
|
t.target = append([]*targetListenIntermediateType{&targetListenIntermediateType{IRI: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownTarget() (ok bool) {
|
|
return t.target != nil && t.target[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTarget returns the unknown value for target
|
|
func (t *Listen) GetUnknownTarget() (v interface{}) {
|
|
return t.target[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTarget sets the unknown value of target
|
|
func (t *Listen) SetUnknownTarget(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &targetListenIntermediateType{}
|
|
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 *Listen) ResultLen() (l int) {
|
|
return len(t.result)
|
|
|
|
}
|
|
|
|
// IsResultObject determines whether the call to GetResultObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetResultObject(index int) (v ObjectType) {
|
|
return t.result[index].Object
|
|
|
|
}
|
|
|
|
// AppendResultObject adds to the back of result a ObjectType type
|
|
func (t *Listen) AppendResultObject(v ObjectType) {
|
|
t.result = append(t.result, &resultListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependResultObject adds to the front of result a ObjectType type
|
|
func (t *Listen) PrependResultObject(v ObjectType) {
|
|
t.result = append([]*resultListenIntermediateType{&resultListenIntermediateType{Object: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetResultLink(index int) (v LinkType) {
|
|
return t.result[index].Link
|
|
|
|
}
|
|
|
|
// AppendResultLink adds to the back of result a LinkType type
|
|
func (t *Listen) AppendResultLink(v LinkType) {
|
|
t.result = append(t.result, &resultListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependResultLink adds to the front of result a LinkType type
|
|
func (t *Listen) PrependResultLink(v LinkType) {
|
|
t.result = append([]*resultListenIntermediateType{&resultListenIntermediateType{Link: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetResultIRI(index int) (v *url.URL) {
|
|
return t.result[index].IRI
|
|
|
|
}
|
|
|
|
// AppendResultIRI adds to the back of result a *url.URL type
|
|
func (t *Listen) AppendResultIRI(v *url.URL) {
|
|
t.result = append(t.result, &resultListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependResultIRI adds to the front of result a *url.URL type
|
|
func (t *Listen) PrependResultIRI(v *url.URL) {
|
|
t.result = append([]*resultListenIntermediateType{&resultListenIntermediateType{IRI: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownResult() (ok bool) {
|
|
return t.result != nil && t.result[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownResult returns the unknown value for result
|
|
func (t *Listen) GetUnknownResult() (v interface{}) {
|
|
return t.result[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownResult sets the unknown value of result
|
|
func (t *Listen) SetUnknownResult(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &resultListenIntermediateType{}
|
|
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 *Listen) OriginLen() (l int) {
|
|
return len(t.origin)
|
|
|
|
}
|
|
|
|
// IsOriginObject determines whether the call to GetOriginObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetOriginObject(index int) (v ObjectType) {
|
|
return t.origin[index].Object
|
|
|
|
}
|
|
|
|
// AppendOriginObject adds to the back of origin a ObjectType type
|
|
func (t *Listen) AppendOriginObject(v ObjectType) {
|
|
t.origin = append(t.origin, &originListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependOriginObject adds to the front of origin a ObjectType type
|
|
func (t *Listen) PrependOriginObject(v ObjectType) {
|
|
t.origin = append([]*originListenIntermediateType{&originListenIntermediateType{Object: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetOriginLink(index int) (v LinkType) {
|
|
return t.origin[index].Link
|
|
|
|
}
|
|
|
|
// AppendOriginLink adds to the back of origin a LinkType type
|
|
func (t *Listen) AppendOriginLink(v LinkType) {
|
|
t.origin = append(t.origin, &originListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependOriginLink adds to the front of origin a LinkType type
|
|
func (t *Listen) PrependOriginLink(v LinkType) {
|
|
t.origin = append([]*originListenIntermediateType{&originListenIntermediateType{Link: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetOriginIRI(index int) (v *url.URL) {
|
|
return t.origin[index].IRI
|
|
|
|
}
|
|
|
|
// AppendOriginIRI adds to the back of origin a *url.URL type
|
|
func (t *Listen) AppendOriginIRI(v *url.URL) {
|
|
t.origin = append(t.origin, &originListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependOriginIRI adds to the front of origin a *url.URL type
|
|
func (t *Listen) PrependOriginIRI(v *url.URL) {
|
|
t.origin = append([]*originListenIntermediateType{&originListenIntermediateType{IRI: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownOrigin() (ok bool) {
|
|
return t.origin != nil && t.origin[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOrigin returns the unknown value for origin
|
|
func (t *Listen) GetUnknownOrigin() (v interface{}) {
|
|
return t.origin[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOrigin sets the unknown value of origin
|
|
func (t *Listen) SetUnknownOrigin(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &originListenIntermediateType{}
|
|
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 *Listen) InstrumentLen() (l int) {
|
|
return len(t.instrument)
|
|
|
|
}
|
|
|
|
// IsInstrumentObject determines whether the call to GetInstrumentObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetInstrumentObject(index int) (v ObjectType) {
|
|
return t.instrument[index].Object
|
|
|
|
}
|
|
|
|
// AppendInstrumentObject adds to the back of instrument a ObjectType type
|
|
func (t *Listen) AppendInstrumentObject(v ObjectType) {
|
|
t.instrument = append(t.instrument, &instrumentListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentObject adds to the front of instrument a ObjectType type
|
|
func (t *Listen) PrependInstrumentObject(v ObjectType) {
|
|
t.instrument = append([]*instrumentListenIntermediateType{&instrumentListenIntermediateType{Object: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetInstrumentLink(index int) (v LinkType) {
|
|
return t.instrument[index].Link
|
|
|
|
}
|
|
|
|
// AppendInstrumentLink adds to the back of instrument a LinkType type
|
|
func (t *Listen) AppendInstrumentLink(v LinkType) {
|
|
t.instrument = append(t.instrument, &instrumentListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentLink adds to the front of instrument a LinkType type
|
|
func (t *Listen) PrependInstrumentLink(v LinkType) {
|
|
t.instrument = append([]*instrumentListenIntermediateType{&instrumentListenIntermediateType{Link: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetInstrumentIRI(index int) (v *url.URL) {
|
|
return t.instrument[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInstrumentIRI adds to the back of instrument a *url.URL type
|
|
func (t *Listen) AppendInstrumentIRI(v *url.URL) {
|
|
t.instrument = append(t.instrument, &instrumentListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentIRI adds to the front of instrument a *url.URL type
|
|
func (t *Listen) PrependInstrumentIRI(v *url.URL) {
|
|
t.instrument = append([]*instrumentListenIntermediateType{&instrumentListenIntermediateType{IRI: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownInstrument() (ok bool) {
|
|
return t.instrument != nil && t.instrument[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInstrument returns the unknown value for instrument
|
|
func (t *Listen) GetUnknownInstrument() (v interface{}) {
|
|
return t.instrument[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInstrument sets the unknown value of instrument
|
|
func (t *Listen) SetUnknownInstrument(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &instrumentListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.instrument = append(t.instrument, tmp)
|
|
|
|
}
|
|
|
|
// IsAltitude determines whether the call to GetAltitude is safe
|
|
func (t *Listen) IsAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.float != nil
|
|
|
|
}
|
|
|
|
// GetAltitude returns the value safely if IsAltitude returned true
|
|
func (t *Listen) GetAltitude() (v float64) {
|
|
return *t.altitude.float
|
|
|
|
}
|
|
|
|
// SetAltitude sets the value of altitude to be of float64 type
|
|
func (t *Listen) SetAltitude(v float64) {
|
|
t.altitude = &altitudeListenIntermediateType{float: &v}
|
|
|
|
}
|
|
|
|
// IsAltitudeIRI determines whether the call to GetAltitudeIRI is safe
|
|
func (t *Listen) IsAltitudeIRI() (ok bool) {
|
|
return t.altitude != nil && t.altitude.IRI != nil
|
|
|
|
}
|
|
|
|
// GetAltitudeIRI returns the value safely if IsAltitudeIRI returned true
|
|
func (t *Listen) GetAltitudeIRI() (v *url.URL) {
|
|
return t.altitude.IRI
|
|
|
|
}
|
|
|
|
// SetAltitudeIRI sets the value of altitude to be of *url.URL type
|
|
func (t *Listen) SetAltitudeIRI(v *url.URL) {
|
|
t.altitude = &altitudeListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownAltitude determines whether the call to GetUnknownAltitude is safe
|
|
func (t *Listen) HasUnknownAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAltitude returns the unknown value for altitude
|
|
func (t *Listen) GetUnknownAltitude() (v interface{}) {
|
|
return t.altitude.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAltitude sets the unknown value of altitude
|
|
func (t *Listen) SetUnknownAltitude(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &altitudeListenIntermediateType{}
|
|
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 *Listen) AttachmentLen() (l int) {
|
|
return len(t.attachment)
|
|
|
|
}
|
|
|
|
// IsAttachmentObject determines whether the call to GetAttachmentObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetAttachmentObject(index int) (v ObjectType) {
|
|
return t.attachment[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttachmentObject adds to the back of attachment a ObjectType type
|
|
func (t *Listen) AppendAttachmentObject(v ObjectType) {
|
|
t.attachment = append(t.attachment, &attachmentListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentObject adds to the front of attachment a ObjectType type
|
|
func (t *Listen) PrependAttachmentObject(v ObjectType) {
|
|
t.attachment = append([]*attachmentListenIntermediateType{&attachmentListenIntermediateType{Object: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetAttachmentLink(index int) (v LinkType) {
|
|
return t.attachment[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttachmentLink adds to the back of attachment a LinkType type
|
|
func (t *Listen) AppendAttachmentLink(v LinkType) {
|
|
t.attachment = append(t.attachment, &attachmentListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentLink adds to the front of attachment a LinkType type
|
|
func (t *Listen) PrependAttachmentLink(v LinkType) {
|
|
t.attachment = append([]*attachmentListenIntermediateType{&attachmentListenIntermediateType{Link: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetAttachmentIRI(index int) (v *url.URL) {
|
|
return t.attachment[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttachmentIRI adds to the back of attachment a *url.URL type
|
|
func (t *Listen) AppendAttachmentIRI(v *url.URL) {
|
|
t.attachment = append(t.attachment, &attachmentListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentIRI adds to the front of attachment a *url.URL type
|
|
func (t *Listen) PrependAttachmentIRI(v *url.URL) {
|
|
t.attachment = append([]*attachmentListenIntermediateType{&attachmentListenIntermediateType{IRI: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownAttachment() (ok bool) {
|
|
return t.attachment != nil && t.attachment[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttachment returns the unknown value for attachment
|
|
func (t *Listen) GetUnknownAttachment() (v interface{}) {
|
|
return t.attachment[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttachment sets the unknown value of attachment
|
|
func (t *Listen) SetUnknownAttachment(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attachmentListenIntermediateType{}
|
|
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 *Listen) AttributedToLen() (l int) {
|
|
return len(t.attributedTo)
|
|
|
|
}
|
|
|
|
// IsAttributedToObject determines whether the call to GetAttributedToObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetAttributedToObject(index int) (v ObjectType) {
|
|
return t.attributedTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttributedToObject adds to the back of attributedTo a ObjectType type
|
|
func (t *Listen) AppendAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToObject adds to the front of attributedTo a ObjectType type
|
|
func (t *Listen) PrependAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append([]*attributedToListenIntermediateType{&attributedToListenIntermediateType{Object: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetAttributedToLink(index int) (v LinkType) {
|
|
return t.attributedTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttributedToLink adds to the back of attributedTo a LinkType type
|
|
func (t *Listen) AppendAttributedToLink(v LinkType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToLink adds to the front of attributedTo a LinkType type
|
|
func (t *Listen) PrependAttributedToLink(v LinkType) {
|
|
t.attributedTo = append([]*attributedToListenIntermediateType{&attributedToListenIntermediateType{Link: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetAttributedToIRI(index int) (v *url.URL) {
|
|
return t.attributedTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttributedToIRI adds to the back of attributedTo a *url.URL type
|
|
func (t *Listen) AppendAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToIRI adds to the front of attributedTo a *url.URL type
|
|
func (t *Listen) PrependAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append([]*attributedToListenIntermediateType{&attributedToListenIntermediateType{IRI: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownAttributedTo() (ok bool) {
|
|
return t.attributedTo != nil && t.attributedTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttributedTo returns the unknown value for attributedTo
|
|
func (t *Listen) GetUnknownAttributedTo() (v interface{}) {
|
|
return t.attributedTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttributedTo sets the unknown value of attributedTo
|
|
func (t *Listen) SetUnknownAttributedTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attributedToListenIntermediateType{}
|
|
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 *Listen) AudienceLen() (l int) {
|
|
return len(t.audience)
|
|
|
|
}
|
|
|
|
// IsAudienceObject determines whether the call to GetAudienceObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetAudienceObject(index int) (v ObjectType) {
|
|
return t.audience[index].Object
|
|
|
|
}
|
|
|
|
// AppendAudienceObject adds to the back of audience a ObjectType type
|
|
func (t *Listen) AppendAudienceObject(v ObjectType) {
|
|
t.audience = append(t.audience, &audienceListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceObject adds to the front of audience a ObjectType type
|
|
func (t *Listen) PrependAudienceObject(v ObjectType) {
|
|
t.audience = append([]*audienceListenIntermediateType{&audienceListenIntermediateType{Object: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetAudienceLink(index int) (v LinkType) {
|
|
return t.audience[index].Link
|
|
|
|
}
|
|
|
|
// AppendAudienceLink adds to the back of audience a LinkType type
|
|
func (t *Listen) AppendAudienceLink(v LinkType) {
|
|
t.audience = append(t.audience, &audienceListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceLink adds to the front of audience a LinkType type
|
|
func (t *Listen) PrependAudienceLink(v LinkType) {
|
|
t.audience = append([]*audienceListenIntermediateType{&audienceListenIntermediateType{Link: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetAudienceIRI(index int) (v *url.URL) {
|
|
return t.audience[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAudienceIRI adds to the back of audience a *url.URL type
|
|
func (t *Listen) AppendAudienceIRI(v *url.URL) {
|
|
t.audience = append(t.audience, &audienceListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceIRI adds to the front of audience a *url.URL type
|
|
func (t *Listen) PrependAudienceIRI(v *url.URL) {
|
|
t.audience = append([]*audienceListenIntermediateType{&audienceListenIntermediateType{IRI: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownAudience() (ok bool) {
|
|
return t.audience != nil && t.audience[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAudience returns the unknown value for audience
|
|
func (t *Listen) GetUnknownAudience() (v interface{}) {
|
|
return t.audience[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAudience sets the unknown value of audience
|
|
func (t *Listen) SetUnknownAudience(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &audienceListenIntermediateType{}
|
|
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 *Listen) ContentLen() (l int) {
|
|
return len(t.content)
|
|
|
|
}
|
|
|
|
// IsContentString determines whether the call to GetContentString is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetContentString(index int) (v string) {
|
|
return *t.content[index].stringName
|
|
|
|
}
|
|
|
|
// AppendContentString adds to the back of content a string type
|
|
func (t *Listen) AppendContentString(v string) {
|
|
t.content = append(t.content, &contentListenIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependContentString adds to the front of content a string type
|
|
func (t *Listen) PrependContentString(v string) {
|
|
t.content = append([]*contentListenIntermediateType{&contentListenIntermediateType{stringName: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentString deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetContentLangString(index int) (v string) {
|
|
return *t.content[index].langString
|
|
|
|
}
|
|
|
|
// AppendContentLangString adds to the back of content a string type
|
|
func (t *Listen) AppendContentLangString(v string) {
|
|
t.content = append(t.content, &contentListenIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependContentLangString adds to the front of content a string type
|
|
func (t *Listen) PrependContentLangString(v string) {
|
|
t.content = append([]*contentListenIntermediateType{&contentListenIntermediateType{langString: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentLangString deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetContentIRI(index int) (v *url.URL) {
|
|
return t.content[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContentIRI adds to the back of content a *url.URL type
|
|
func (t *Listen) AppendContentIRI(v *url.URL) {
|
|
t.content = append(t.content, &contentListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContentIRI adds to the front of content a *url.URL type
|
|
func (t *Listen) PrependContentIRI(v *url.URL) {
|
|
t.content = append([]*contentListenIntermediateType{&contentListenIntermediateType{IRI: v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownContent() (ok bool) {
|
|
return t.content != nil && t.content[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContent returns the unknown value for content
|
|
func (t *Listen) GetUnknownContent() (v interface{}) {
|
|
return t.content[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContent sets the unknown value of content
|
|
func (t *Listen) SetUnknownContent(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contentListenIntermediateType{}
|
|
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 *Listen) 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 *Listen) 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 *Listen) 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 *Listen) ContextLen() (l int) {
|
|
return len(t.context)
|
|
|
|
}
|
|
|
|
// IsContextObject determines whether the call to GetContextObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetContextObject(index int) (v ObjectType) {
|
|
return t.context[index].Object
|
|
|
|
}
|
|
|
|
// AppendContextObject adds to the back of context a ObjectType type
|
|
func (t *Listen) AppendContextObject(v ObjectType) {
|
|
t.context = append(t.context, &contextListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependContextObject adds to the front of context a ObjectType type
|
|
func (t *Listen) PrependContextObject(v ObjectType) {
|
|
t.context = append([]*contextListenIntermediateType{&contextListenIntermediateType{Object: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetContextLink(index int) (v LinkType) {
|
|
return t.context[index].Link
|
|
|
|
}
|
|
|
|
// AppendContextLink adds to the back of context a LinkType type
|
|
func (t *Listen) AppendContextLink(v LinkType) {
|
|
t.context = append(t.context, &contextListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependContextLink adds to the front of context a LinkType type
|
|
func (t *Listen) PrependContextLink(v LinkType) {
|
|
t.context = append([]*contextListenIntermediateType{&contextListenIntermediateType{Link: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetContextIRI(index int) (v *url.URL) {
|
|
return t.context[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContextIRI adds to the back of context a *url.URL type
|
|
func (t *Listen) AppendContextIRI(v *url.URL) {
|
|
t.context = append(t.context, &contextListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContextIRI adds to the front of context a *url.URL type
|
|
func (t *Listen) PrependContextIRI(v *url.URL) {
|
|
t.context = append([]*contextListenIntermediateType{&contextListenIntermediateType{IRI: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownContext() (ok bool) {
|
|
return t.context != nil && t.context[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContext returns the unknown value for context
|
|
func (t *Listen) GetUnknownContext() (v interface{}) {
|
|
return t.context[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContext sets the unknown value of context
|
|
func (t *Listen) SetUnknownContext(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contextListenIntermediateType{}
|
|
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 *Listen) NameLen() (l int) {
|
|
return len(t.name)
|
|
|
|
}
|
|
|
|
// IsNameString determines whether the call to GetNameString is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetNameString(index int) (v string) {
|
|
return *t.name[index].stringName
|
|
|
|
}
|
|
|
|
// AppendNameString adds to the back of name a string type
|
|
func (t *Listen) AppendNameString(v string) {
|
|
t.name = append(t.name, &nameListenIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependNameString adds to the front of name a string type
|
|
func (t *Listen) PrependNameString(v string) {
|
|
t.name = append([]*nameListenIntermediateType{&nameListenIntermediateType{stringName: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameString deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetNameLangString(index int) (v string) {
|
|
return *t.name[index].langString
|
|
|
|
}
|
|
|
|
// AppendNameLangString adds to the back of name a string type
|
|
func (t *Listen) AppendNameLangString(v string) {
|
|
t.name = append(t.name, &nameListenIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependNameLangString adds to the front of name a string type
|
|
func (t *Listen) PrependNameLangString(v string) {
|
|
t.name = append([]*nameListenIntermediateType{&nameListenIntermediateType{langString: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameLangString deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetNameIRI(index int) (v *url.URL) {
|
|
return t.name[index].IRI
|
|
|
|
}
|
|
|
|
// AppendNameIRI adds to the back of name a *url.URL type
|
|
func (t *Listen) AppendNameIRI(v *url.URL) {
|
|
t.name = append(t.name, &nameListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependNameIRI adds to the front of name a *url.URL type
|
|
func (t *Listen) PrependNameIRI(v *url.URL) {
|
|
t.name = append([]*nameListenIntermediateType{&nameListenIntermediateType{IRI: v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownName() (ok bool) {
|
|
return t.name != nil && t.name[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownName returns the unknown value for name
|
|
func (t *Listen) GetUnknownName() (v interface{}) {
|
|
return t.name[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownName sets the unknown value of name
|
|
func (t *Listen) SetUnknownName(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &nameListenIntermediateType{}
|
|
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 *Listen) 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 *Listen) 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 *Listen) 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 *Listen) IsEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetEndTime returns the value safely if IsEndTime returned true
|
|
func (t *Listen) GetEndTime() (v time.Time) {
|
|
return *t.endTime.dateTime
|
|
|
|
}
|
|
|
|
// SetEndTime sets the value of endTime to be of time.Time type
|
|
func (t *Listen) SetEndTime(v time.Time) {
|
|
t.endTime = &endTimeListenIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsEndTimeIRI determines whether the call to GetEndTimeIRI is safe
|
|
func (t *Listen) IsEndTimeIRI() (ok bool) {
|
|
return t.endTime != nil && t.endTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndTimeIRI returns the value safely if IsEndTimeIRI returned true
|
|
func (t *Listen) GetEndTimeIRI() (v *url.URL) {
|
|
return t.endTime.IRI
|
|
|
|
}
|
|
|
|
// SetEndTimeIRI sets the value of endTime to be of *url.URL type
|
|
func (t *Listen) SetEndTimeIRI(v *url.URL) {
|
|
t.endTime = &endTimeListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndTime determines whether the call to GetUnknownEndTime is safe
|
|
func (t *Listen) HasUnknownEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndTime returns the unknown value for endTime
|
|
func (t *Listen) GetUnknownEndTime() (v interface{}) {
|
|
return t.endTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndTime sets the unknown value of endTime
|
|
func (t *Listen) SetUnknownEndTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endTimeListenIntermediateType{}
|
|
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 *Listen) GeneratorLen() (l int) {
|
|
return len(t.generator)
|
|
|
|
}
|
|
|
|
// IsGeneratorObject determines whether the call to GetGeneratorObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetGeneratorObject(index int) (v ObjectType) {
|
|
return t.generator[index].Object
|
|
|
|
}
|
|
|
|
// AppendGeneratorObject adds to the back of generator a ObjectType type
|
|
func (t *Listen) AppendGeneratorObject(v ObjectType) {
|
|
t.generator = append(t.generator, &generatorListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorObject adds to the front of generator a ObjectType type
|
|
func (t *Listen) PrependGeneratorObject(v ObjectType) {
|
|
t.generator = append([]*generatorListenIntermediateType{&generatorListenIntermediateType{Object: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetGeneratorLink(index int) (v LinkType) {
|
|
return t.generator[index].Link
|
|
|
|
}
|
|
|
|
// AppendGeneratorLink adds to the back of generator a LinkType type
|
|
func (t *Listen) AppendGeneratorLink(v LinkType) {
|
|
t.generator = append(t.generator, &generatorListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorLink adds to the front of generator a LinkType type
|
|
func (t *Listen) PrependGeneratorLink(v LinkType) {
|
|
t.generator = append([]*generatorListenIntermediateType{&generatorListenIntermediateType{Link: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetGeneratorIRI(index int) (v *url.URL) {
|
|
return t.generator[index].IRI
|
|
|
|
}
|
|
|
|
// AppendGeneratorIRI adds to the back of generator a *url.URL type
|
|
func (t *Listen) AppendGeneratorIRI(v *url.URL) {
|
|
t.generator = append(t.generator, &generatorListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorIRI adds to the front of generator a *url.URL type
|
|
func (t *Listen) PrependGeneratorIRI(v *url.URL) {
|
|
t.generator = append([]*generatorListenIntermediateType{&generatorListenIntermediateType{IRI: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownGenerator() (ok bool) {
|
|
return t.generator != nil && t.generator[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownGenerator returns the unknown value for generator
|
|
func (t *Listen) GetUnknownGenerator() (v interface{}) {
|
|
return t.generator[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownGenerator sets the unknown value of generator
|
|
func (t *Listen) SetUnknownGenerator(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &generatorListenIntermediateType{}
|
|
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 *Listen) IconLen() (l int) {
|
|
return len(t.icon)
|
|
|
|
}
|
|
|
|
// IsIconImage determines whether the call to GetIconImage is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetIconImage(index int) (v ImageType) {
|
|
return t.icon[index].Image
|
|
|
|
}
|
|
|
|
// AppendIconImage adds to the back of icon a ImageType type
|
|
func (t *Listen) AppendIconImage(v ImageType) {
|
|
t.icon = append(t.icon, &iconListenIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependIconImage adds to the front of icon a ImageType type
|
|
func (t *Listen) PrependIconImage(v ImageType) {
|
|
t.icon = append([]*iconListenIntermediateType{&iconListenIntermediateType{Image: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconImage deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetIconLink(index int) (v LinkType) {
|
|
return t.icon[index].Link
|
|
|
|
}
|
|
|
|
// AppendIconLink adds to the back of icon a LinkType type
|
|
func (t *Listen) AppendIconLink(v LinkType) {
|
|
t.icon = append(t.icon, &iconListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependIconLink adds to the front of icon a LinkType type
|
|
func (t *Listen) PrependIconLink(v LinkType) {
|
|
t.icon = append([]*iconListenIntermediateType{&iconListenIntermediateType{Link: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetIconIRI(index int) (v *url.URL) {
|
|
return t.icon[index].IRI
|
|
|
|
}
|
|
|
|
// AppendIconIRI adds to the back of icon a *url.URL type
|
|
func (t *Listen) AppendIconIRI(v *url.URL) {
|
|
t.icon = append(t.icon, &iconListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependIconIRI adds to the front of icon a *url.URL type
|
|
func (t *Listen) PrependIconIRI(v *url.URL) {
|
|
t.icon = append([]*iconListenIntermediateType{&iconListenIntermediateType{IRI: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownIcon() (ok bool) {
|
|
return t.icon != nil && t.icon[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownIcon returns the unknown value for icon
|
|
func (t *Listen) GetUnknownIcon() (v interface{}) {
|
|
return t.icon[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownIcon sets the unknown value of icon
|
|
func (t *Listen) SetUnknownIcon(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &iconListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.icon = append(t.icon, tmp)
|
|
|
|
}
|
|
|
|
// HasId determines whether the call to GetId is safe
|
|
func (t *Listen) HasId() (ok bool) {
|
|
return t.id != nil
|
|
|
|
}
|
|
|
|
// GetId returns the value for id
|
|
func (t *Listen) GetId() (v *url.URL) {
|
|
return t.id
|
|
|
|
}
|
|
|
|
// SetId sets the value of id
|
|
func (t *Listen) SetId(v *url.URL) {
|
|
t.id = v
|
|
|
|
}
|
|
|
|
// HasUnknownId determines whether the call to GetUnknownId is safe
|
|
func (t *Listen) HasUnknownId() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["id"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownId returns the unknown value for id
|
|
func (t *Listen) GetUnknownId() (v interface{}) {
|
|
return t.unknown_["id"]
|
|
|
|
}
|
|
|
|
// SetUnknownId sets the unknown value of id
|
|
func (t *Listen) 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 *Listen) ImageLen() (l int) {
|
|
return len(t.image)
|
|
|
|
}
|
|
|
|
// IsImageImage determines whether the call to GetImageImage is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetImageImage(index int) (v ImageType) {
|
|
return t.image[index].Image
|
|
|
|
}
|
|
|
|
// AppendImageImage adds to the back of image a ImageType type
|
|
func (t *Listen) AppendImageImage(v ImageType) {
|
|
t.image = append(t.image, &imageListenIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependImageImage adds to the front of image a ImageType type
|
|
func (t *Listen) PrependImageImage(v ImageType) {
|
|
t.image = append([]*imageListenIntermediateType{&imageListenIntermediateType{Image: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageImage deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetImageLink(index int) (v LinkType) {
|
|
return t.image[index].Link
|
|
|
|
}
|
|
|
|
// AppendImageLink adds to the back of image a LinkType type
|
|
func (t *Listen) AppendImageLink(v LinkType) {
|
|
t.image = append(t.image, &imageListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependImageLink adds to the front of image a LinkType type
|
|
func (t *Listen) PrependImageLink(v LinkType) {
|
|
t.image = append([]*imageListenIntermediateType{&imageListenIntermediateType{Link: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetImageIRI(index int) (v *url.URL) {
|
|
return t.image[index].IRI
|
|
|
|
}
|
|
|
|
// AppendImageIRI adds to the back of image a *url.URL type
|
|
func (t *Listen) AppendImageIRI(v *url.URL) {
|
|
t.image = append(t.image, &imageListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependImageIRI adds to the front of image a *url.URL type
|
|
func (t *Listen) PrependImageIRI(v *url.URL) {
|
|
t.image = append([]*imageListenIntermediateType{&imageListenIntermediateType{IRI: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownImage() (ok bool) {
|
|
return t.image != nil && t.image[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownImage returns the unknown value for image
|
|
func (t *Listen) GetUnknownImage() (v interface{}) {
|
|
return t.image[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownImage sets the unknown value of image
|
|
func (t *Listen) SetUnknownImage(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &imageListenIntermediateType{}
|
|
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 *Listen) InReplyToLen() (l int) {
|
|
return len(t.inReplyTo)
|
|
|
|
}
|
|
|
|
// IsInReplyToObject determines whether the call to GetInReplyToObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetInReplyToObject(index int) (v ObjectType) {
|
|
return t.inReplyTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendInReplyToObject adds to the back of inReplyTo a ObjectType type
|
|
func (t *Listen) AppendInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToObject adds to the front of inReplyTo a ObjectType type
|
|
func (t *Listen) PrependInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append([]*inReplyToListenIntermediateType{&inReplyToListenIntermediateType{Object: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetInReplyToLink(index int) (v LinkType) {
|
|
return t.inReplyTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendInReplyToLink adds to the back of inReplyTo a LinkType type
|
|
func (t *Listen) AppendInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToLink adds to the front of inReplyTo a LinkType type
|
|
func (t *Listen) PrependInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append([]*inReplyToListenIntermediateType{&inReplyToListenIntermediateType{Link: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetInReplyToIRI(index int) (v *url.URL) {
|
|
return t.inReplyTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInReplyToIRI adds to the back of inReplyTo a *url.URL type
|
|
func (t *Listen) AppendInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToIRI adds to the front of inReplyTo a *url.URL type
|
|
func (t *Listen) PrependInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append([]*inReplyToListenIntermediateType{&inReplyToListenIntermediateType{IRI: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownInReplyTo() (ok bool) {
|
|
return t.inReplyTo != nil && t.inReplyTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInReplyTo returns the unknown value for inReplyTo
|
|
func (t *Listen) GetUnknownInReplyTo() (v interface{}) {
|
|
return t.inReplyTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInReplyTo sets the unknown value of inReplyTo
|
|
func (t *Listen) SetUnknownInReplyTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inReplyToListenIntermediateType{}
|
|
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 *Listen) LocationLen() (l int) {
|
|
return len(t.location)
|
|
|
|
}
|
|
|
|
// IsLocationObject determines whether the call to GetLocationObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetLocationObject(index int) (v ObjectType) {
|
|
return t.location[index].Object
|
|
|
|
}
|
|
|
|
// AppendLocationObject adds to the back of location a ObjectType type
|
|
func (t *Listen) AppendLocationObject(v ObjectType) {
|
|
t.location = append(t.location, &locationListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependLocationObject adds to the front of location a ObjectType type
|
|
func (t *Listen) PrependLocationObject(v ObjectType) {
|
|
t.location = append([]*locationListenIntermediateType{&locationListenIntermediateType{Object: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetLocationLink(index int) (v LinkType) {
|
|
return t.location[index].Link
|
|
|
|
}
|
|
|
|
// AppendLocationLink adds to the back of location a LinkType type
|
|
func (t *Listen) AppendLocationLink(v LinkType) {
|
|
t.location = append(t.location, &locationListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependLocationLink adds to the front of location a LinkType type
|
|
func (t *Listen) PrependLocationLink(v LinkType) {
|
|
t.location = append([]*locationListenIntermediateType{&locationListenIntermediateType{Link: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetLocationIRI(index int) (v *url.URL) {
|
|
return t.location[index].IRI
|
|
|
|
}
|
|
|
|
// AppendLocationIRI adds to the back of location a *url.URL type
|
|
func (t *Listen) AppendLocationIRI(v *url.URL) {
|
|
t.location = append(t.location, &locationListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependLocationIRI adds to the front of location a *url.URL type
|
|
func (t *Listen) PrependLocationIRI(v *url.URL) {
|
|
t.location = append([]*locationListenIntermediateType{&locationListenIntermediateType{IRI: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownLocation() (ok bool) {
|
|
return t.location != nil && t.location[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLocation returns the unknown value for location
|
|
func (t *Listen) GetUnknownLocation() (v interface{}) {
|
|
return t.location[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLocation sets the unknown value of location
|
|
func (t *Listen) SetUnknownLocation(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &locationListenIntermediateType{}
|
|
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 *Listen) PreviewLen() (l int) {
|
|
return len(t.preview)
|
|
|
|
}
|
|
|
|
// IsPreviewObject determines whether the call to GetPreviewObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetPreviewObject(index int) (v ObjectType) {
|
|
return t.preview[index].Object
|
|
|
|
}
|
|
|
|
// AppendPreviewObject adds to the back of preview a ObjectType type
|
|
func (t *Listen) AppendPreviewObject(v ObjectType) {
|
|
t.preview = append(t.preview, &previewListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewObject adds to the front of preview a ObjectType type
|
|
func (t *Listen) PrependPreviewObject(v ObjectType) {
|
|
t.preview = append([]*previewListenIntermediateType{&previewListenIntermediateType{Object: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetPreviewLink(index int) (v LinkType) {
|
|
return t.preview[index].Link
|
|
|
|
}
|
|
|
|
// AppendPreviewLink adds to the back of preview a LinkType type
|
|
func (t *Listen) AppendPreviewLink(v LinkType) {
|
|
t.preview = append(t.preview, &previewListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewLink adds to the front of preview a LinkType type
|
|
func (t *Listen) PrependPreviewLink(v LinkType) {
|
|
t.preview = append([]*previewListenIntermediateType{&previewListenIntermediateType{Link: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetPreviewIRI(index int) (v *url.URL) {
|
|
return t.preview[index].IRI
|
|
|
|
}
|
|
|
|
// AppendPreviewIRI adds to the back of preview a *url.URL type
|
|
func (t *Listen) AppendPreviewIRI(v *url.URL) {
|
|
t.preview = append(t.preview, &previewListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewIRI adds to the front of preview a *url.URL type
|
|
func (t *Listen) PrependPreviewIRI(v *url.URL) {
|
|
t.preview = append([]*previewListenIntermediateType{&previewListenIntermediateType{IRI: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownPreview() (ok bool) {
|
|
return t.preview != nil && t.preview[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreview returns the unknown value for preview
|
|
func (t *Listen) GetUnknownPreview() (v interface{}) {
|
|
return t.preview[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreview sets the unknown value of preview
|
|
func (t *Listen) SetUnknownPreview(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &previewListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preview = append(t.preview, tmp)
|
|
|
|
}
|
|
|
|
// IsPublished determines whether the call to GetPublished is safe
|
|
func (t *Listen) IsPublished() (ok bool) {
|
|
return t.published != nil && t.published.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetPublished returns the value safely if IsPublished returned true
|
|
func (t *Listen) GetPublished() (v time.Time) {
|
|
return *t.published.dateTime
|
|
|
|
}
|
|
|
|
// SetPublished sets the value of published to be of time.Time type
|
|
func (t *Listen) SetPublished(v time.Time) {
|
|
t.published = &publishedListenIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsPublishedIRI determines whether the call to GetPublishedIRI is safe
|
|
func (t *Listen) IsPublishedIRI() (ok bool) {
|
|
return t.published != nil && t.published.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPublishedIRI returns the value safely if IsPublishedIRI returned true
|
|
func (t *Listen) GetPublishedIRI() (v *url.URL) {
|
|
return t.published.IRI
|
|
|
|
}
|
|
|
|
// SetPublishedIRI sets the value of published to be of *url.URL type
|
|
func (t *Listen) SetPublishedIRI(v *url.URL) {
|
|
t.published = &publishedListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPublished determines whether the call to GetUnknownPublished is safe
|
|
func (t *Listen) HasUnknownPublished() (ok bool) {
|
|
return t.published != nil && t.published.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPublished returns the unknown value for published
|
|
func (t *Listen) GetUnknownPublished() (v interface{}) {
|
|
return t.published.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPublished sets the unknown value of published
|
|
func (t *Listen) SetUnknownPublished(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &publishedListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.published = tmp
|
|
|
|
}
|
|
|
|
// IsReplies determines whether the call to GetReplies is safe
|
|
func (t *Listen) IsReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.Collection != nil
|
|
|
|
}
|
|
|
|
// GetReplies returns the value safely if IsReplies returned true
|
|
func (t *Listen) GetReplies() (v CollectionType) {
|
|
return t.replies.Collection
|
|
|
|
}
|
|
|
|
// SetReplies sets the value of replies to be of CollectionType type
|
|
func (t *Listen) SetReplies(v CollectionType) {
|
|
t.replies = &repliesListenIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsRepliesIRI determines whether the call to GetRepliesIRI is safe
|
|
func (t *Listen) IsRepliesIRI() (ok bool) {
|
|
return t.replies != nil && t.replies.IRI != nil
|
|
|
|
}
|
|
|
|
// GetRepliesIRI returns the value safely if IsRepliesIRI returned true
|
|
func (t *Listen) GetRepliesIRI() (v *url.URL) {
|
|
return t.replies.IRI
|
|
|
|
}
|
|
|
|
// SetRepliesIRI sets the value of replies to be of *url.URL type
|
|
func (t *Listen) SetRepliesIRI(v *url.URL) {
|
|
t.replies = &repliesListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownReplies determines whether the call to GetUnknownReplies is safe
|
|
func (t *Listen) HasUnknownReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownReplies returns the unknown value for replies
|
|
func (t *Listen) GetUnknownReplies() (v interface{}) {
|
|
return t.replies.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownReplies sets the unknown value of replies
|
|
func (t *Listen) SetUnknownReplies(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &repliesListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.replies = tmp
|
|
|
|
}
|
|
|
|
// IsStartTime determines whether the call to GetStartTime is safe
|
|
func (t *Listen) IsStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetStartTime returns the value safely if IsStartTime returned true
|
|
func (t *Listen) GetStartTime() (v time.Time) {
|
|
return *t.startTime.dateTime
|
|
|
|
}
|
|
|
|
// SetStartTime sets the value of startTime to be of time.Time type
|
|
func (t *Listen) SetStartTime(v time.Time) {
|
|
t.startTime = &startTimeListenIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsStartTimeIRI determines whether the call to GetStartTimeIRI is safe
|
|
func (t *Listen) IsStartTimeIRI() (ok bool) {
|
|
return t.startTime != nil && t.startTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetStartTimeIRI returns the value safely if IsStartTimeIRI returned true
|
|
func (t *Listen) GetStartTimeIRI() (v *url.URL) {
|
|
return t.startTime.IRI
|
|
|
|
}
|
|
|
|
// SetStartTimeIRI sets the value of startTime to be of *url.URL type
|
|
func (t *Listen) SetStartTimeIRI(v *url.URL) {
|
|
t.startTime = &startTimeListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownStartTime determines whether the call to GetUnknownStartTime is safe
|
|
func (t *Listen) HasUnknownStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStartTime returns the unknown value for startTime
|
|
func (t *Listen) GetUnknownStartTime() (v interface{}) {
|
|
return t.startTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownStartTime sets the unknown value of startTime
|
|
func (t *Listen) SetUnknownStartTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &startTimeListenIntermediateType{}
|
|
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 *Listen) SummaryLen() (l int) {
|
|
return len(t.summary)
|
|
|
|
}
|
|
|
|
// IsSummaryString determines whether the call to GetSummaryString is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetSummaryString(index int) (v string) {
|
|
return *t.summary[index].stringName
|
|
|
|
}
|
|
|
|
// AppendSummaryString adds to the back of summary a string type
|
|
func (t *Listen) AppendSummaryString(v string) {
|
|
t.summary = append(t.summary, &summaryListenIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryString adds to the front of summary a string type
|
|
func (t *Listen) PrependSummaryString(v string) {
|
|
t.summary = append([]*summaryListenIntermediateType{&summaryListenIntermediateType{stringName: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryString deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetSummaryLangString(index int) (v string) {
|
|
return *t.summary[index].langString
|
|
|
|
}
|
|
|
|
// AppendSummaryLangString adds to the back of summary a string type
|
|
func (t *Listen) AppendSummaryLangString(v string) {
|
|
t.summary = append(t.summary, &summaryListenIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryLangString adds to the front of summary a string type
|
|
func (t *Listen) PrependSummaryLangString(v string) {
|
|
t.summary = append([]*summaryListenIntermediateType{&summaryListenIntermediateType{langString: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryLangString deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetSummaryIRI(index int) (v *url.URL) {
|
|
return t.summary[index].IRI
|
|
|
|
}
|
|
|
|
// AppendSummaryIRI adds to the back of summary a *url.URL type
|
|
func (t *Listen) AppendSummaryIRI(v *url.URL) {
|
|
t.summary = append(t.summary, &summaryListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependSummaryIRI adds to the front of summary a *url.URL type
|
|
func (t *Listen) PrependSummaryIRI(v *url.URL) {
|
|
t.summary = append([]*summaryListenIntermediateType{&summaryListenIntermediateType{IRI: v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownSummary() (ok bool) {
|
|
return t.summary != nil && t.summary[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSummary returns the unknown value for summary
|
|
func (t *Listen) GetUnknownSummary() (v interface{}) {
|
|
return t.summary[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSummary sets the unknown value of summary
|
|
func (t *Listen) SetUnknownSummary(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &summaryListenIntermediateType{}
|
|
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 *Listen) 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 *Listen) 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 *Listen) 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 *Listen) TagLen() (l int) {
|
|
return len(t.tag)
|
|
|
|
}
|
|
|
|
// IsTagObject determines whether the call to GetTagObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetTagObject(index int) (v ObjectType) {
|
|
return t.tag[index].Object
|
|
|
|
}
|
|
|
|
// AppendTagObject adds to the back of tag a ObjectType type
|
|
func (t *Listen) AppendTagObject(v ObjectType) {
|
|
t.tag = append(t.tag, &tagListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTagObject adds to the front of tag a ObjectType type
|
|
func (t *Listen) PrependTagObject(v ObjectType) {
|
|
t.tag = append([]*tagListenIntermediateType{&tagListenIntermediateType{Object: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetTagLink(index int) (v LinkType) {
|
|
return t.tag[index].Link
|
|
|
|
}
|
|
|
|
// AppendTagLink adds to the back of tag a LinkType type
|
|
func (t *Listen) AppendTagLink(v LinkType) {
|
|
t.tag = append(t.tag, &tagListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTagLink adds to the front of tag a LinkType type
|
|
func (t *Listen) PrependTagLink(v LinkType) {
|
|
t.tag = append([]*tagListenIntermediateType{&tagListenIntermediateType{Link: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetTagIRI(index int) (v *url.URL) {
|
|
return t.tag[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTagIRI adds to the back of tag a *url.URL type
|
|
func (t *Listen) AppendTagIRI(v *url.URL) {
|
|
t.tag = append(t.tag, &tagListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTagIRI adds to the front of tag a *url.URL type
|
|
func (t *Listen) PrependTagIRI(v *url.URL) {
|
|
t.tag = append([]*tagListenIntermediateType{&tagListenIntermediateType{IRI: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownTag() (ok bool) {
|
|
return t.tag != nil && t.tag[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTag returns the unknown value for tag
|
|
func (t *Listen) GetUnknownTag() (v interface{}) {
|
|
return t.tag[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTag sets the unknown value of tag
|
|
func (t *Listen) SetUnknownTag(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &tagListenIntermediateType{}
|
|
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 *Listen) TypeLen() (l int) {
|
|
return len(t.typeName)
|
|
|
|
}
|
|
|
|
// GetType returns the value for the specified index
|
|
func (t *Listen) GetType(index int) (v interface{}) {
|
|
return t.typeName[index]
|
|
|
|
}
|
|
|
|
// AppendType adds a value to the back of type
|
|
func (t *Listen) AppendType(v interface{}) {
|
|
t.typeName = append(t.typeName, v)
|
|
|
|
}
|
|
|
|
// PrependType adds a value to the front of type
|
|
func (t *Listen) PrependType(v interface{}) {
|
|
t.typeName = append([]interface{}{v}, t.typeName...)
|
|
|
|
}
|
|
|
|
// RemoveType deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) IsUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetUpdated returns the value safely if IsUpdated returned true
|
|
func (t *Listen) GetUpdated() (v time.Time) {
|
|
return *t.updated.dateTime
|
|
|
|
}
|
|
|
|
// SetUpdated sets the value of updated to be of time.Time type
|
|
func (t *Listen) SetUpdated(v time.Time) {
|
|
t.updated = &updatedListenIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsUpdatedIRI determines whether the call to GetUpdatedIRI is safe
|
|
func (t *Listen) IsUpdatedIRI() (ok bool) {
|
|
return t.updated != nil && t.updated.IRI != nil
|
|
|
|
}
|
|
|
|
// GetUpdatedIRI returns the value safely if IsUpdatedIRI returned true
|
|
func (t *Listen) GetUpdatedIRI() (v *url.URL) {
|
|
return t.updated.IRI
|
|
|
|
}
|
|
|
|
// SetUpdatedIRI sets the value of updated to be of *url.URL type
|
|
func (t *Listen) SetUpdatedIRI(v *url.URL) {
|
|
t.updated = &updatedListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownUpdated determines whether the call to GetUnknownUpdated is safe
|
|
func (t *Listen) HasUnknownUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUpdated returns the unknown value for updated
|
|
func (t *Listen) GetUnknownUpdated() (v interface{}) {
|
|
return t.updated.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUpdated sets the unknown value of updated
|
|
func (t *Listen) SetUnknownUpdated(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &updatedListenIntermediateType{}
|
|
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 *Listen) UrlLen() (l int) {
|
|
return len(t.url)
|
|
|
|
}
|
|
|
|
// IsUrlAnyURI determines whether the call to GetUrlAnyURI is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetUrlAnyURI(index int) (v *url.URL) {
|
|
return t.url[index].anyURI
|
|
|
|
}
|
|
|
|
// AppendUrlAnyURI adds to the back of url a *url.URL type
|
|
func (t *Listen) AppendUrlAnyURI(v *url.URL) {
|
|
t.url = append(t.url, &urlListenIntermediateType{anyURI: v})
|
|
|
|
}
|
|
|
|
// PrependUrlAnyURI adds to the front of url a *url.URL type
|
|
func (t *Listen) PrependUrlAnyURI(v *url.URL) {
|
|
t.url = append([]*urlListenIntermediateType{&urlListenIntermediateType{anyURI: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlAnyURI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetUrlLink(index int) (v LinkType) {
|
|
return t.url[index].Link
|
|
|
|
}
|
|
|
|
// AppendUrlLink adds to the back of url a LinkType type
|
|
func (t *Listen) AppendUrlLink(v LinkType) {
|
|
t.url = append(t.url, &urlListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependUrlLink adds to the front of url a LinkType type
|
|
func (t *Listen) PrependUrlLink(v LinkType) {
|
|
t.url = append([]*urlListenIntermediateType{&urlListenIntermediateType{Link: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownUrl() (ok bool) {
|
|
return t.url != nil && t.url[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUrl returns the unknown value for url
|
|
func (t *Listen) GetUnknownUrl() (v interface{}) {
|
|
return t.url[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUrl sets the unknown value of url
|
|
func (t *Listen) SetUnknownUrl(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &urlListenIntermediateType{}
|
|
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 *Listen) ToLen() (l int) {
|
|
return len(t.to)
|
|
|
|
}
|
|
|
|
// IsToObject determines whether the call to GetToObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetToObject(index int) (v ObjectType) {
|
|
return t.to[index].Object
|
|
|
|
}
|
|
|
|
// AppendToObject adds to the back of to a ObjectType type
|
|
func (t *Listen) AppendToObject(v ObjectType) {
|
|
t.to = append(t.to, &toListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependToObject adds to the front of to a ObjectType type
|
|
func (t *Listen) PrependToObject(v ObjectType) {
|
|
t.to = append([]*toListenIntermediateType{&toListenIntermediateType{Object: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetToLink(index int) (v LinkType) {
|
|
return t.to[index].Link
|
|
|
|
}
|
|
|
|
// AppendToLink adds to the back of to a LinkType type
|
|
func (t *Listen) AppendToLink(v LinkType) {
|
|
t.to = append(t.to, &toListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependToLink adds to the front of to a LinkType type
|
|
func (t *Listen) PrependToLink(v LinkType) {
|
|
t.to = append([]*toListenIntermediateType{&toListenIntermediateType{Link: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetToIRI(index int) (v *url.URL) {
|
|
return t.to[index].IRI
|
|
|
|
}
|
|
|
|
// AppendToIRI adds to the back of to a *url.URL type
|
|
func (t *Listen) AppendToIRI(v *url.URL) {
|
|
t.to = append(t.to, &toListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependToIRI adds to the front of to a *url.URL type
|
|
func (t *Listen) PrependToIRI(v *url.URL) {
|
|
t.to = append([]*toListenIntermediateType{&toListenIntermediateType{IRI: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownTo() (ok bool) {
|
|
return t.to != nil && t.to[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTo returns the unknown value for to
|
|
func (t *Listen) GetUnknownTo() (v interface{}) {
|
|
return t.to[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTo sets the unknown value of to
|
|
func (t *Listen) SetUnknownTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &toListenIntermediateType{}
|
|
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 *Listen) BtoLen() (l int) {
|
|
return len(t.bto)
|
|
|
|
}
|
|
|
|
// IsBtoObject determines whether the call to GetBtoObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetBtoObject(index int) (v ObjectType) {
|
|
return t.bto[index].Object
|
|
|
|
}
|
|
|
|
// AppendBtoObject adds to the back of bto a ObjectType type
|
|
func (t *Listen) AppendBtoObject(v ObjectType) {
|
|
t.bto = append(t.bto, &btoListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBtoObject adds to the front of bto a ObjectType type
|
|
func (t *Listen) PrependBtoObject(v ObjectType) {
|
|
t.bto = append([]*btoListenIntermediateType{&btoListenIntermediateType{Object: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetBtoLink(index int) (v LinkType) {
|
|
return t.bto[index].Link
|
|
|
|
}
|
|
|
|
// AppendBtoLink adds to the back of bto a LinkType type
|
|
func (t *Listen) AppendBtoLink(v LinkType) {
|
|
t.bto = append(t.bto, &btoListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBtoLink adds to the front of bto a LinkType type
|
|
func (t *Listen) PrependBtoLink(v LinkType) {
|
|
t.bto = append([]*btoListenIntermediateType{&btoListenIntermediateType{Link: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetBtoIRI(index int) (v *url.URL) {
|
|
return t.bto[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBtoIRI adds to the back of bto a *url.URL type
|
|
func (t *Listen) AppendBtoIRI(v *url.URL) {
|
|
t.bto = append(t.bto, &btoListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBtoIRI adds to the front of bto a *url.URL type
|
|
func (t *Listen) PrependBtoIRI(v *url.URL) {
|
|
t.bto = append([]*btoListenIntermediateType{&btoListenIntermediateType{IRI: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownBto() (ok bool) {
|
|
return t.bto != nil && t.bto[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBto returns the unknown value for bto
|
|
func (t *Listen) GetUnknownBto() (v interface{}) {
|
|
return t.bto[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBto sets the unknown value of bto
|
|
func (t *Listen) SetUnknownBto(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &btoListenIntermediateType{}
|
|
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 *Listen) CcLen() (l int) {
|
|
return len(t.cc)
|
|
|
|
}
|
|
|
|
// IsCcObject determines whether the call to GetCcObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetCcObject(index int) (v ObjectType) {
|
|
return t.cc[index].Object
|
|
|
|
}
|
|
|
|
// AppendCcObject adds to the back of cc a ObjectType type
|
|
func (t *Listen) AppendCcObject(v ObjectType) {
|
|
t.cc = append(t.cc, &ccListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependCcObject adds to the front of cc a ObjectType type
|
|
func (t *Listen) PrependCcObject(v ObjectType) {
|
|
t.cc = append([]*ccListenIntermediateType{&ccListenIntermediateType{Object: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetCcLink(index int) (v LinkType) {
|
|
return t.cc[index].Link
|
|
|
|
}
|
|
|
|
// AppendCcLink adds to the back of cc a LinkType type
|
|
func (t *Listen) AppendCcLink(v LinkType) {
|
|
t.cc = append(t.cc, &ccListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependCcLink adds to the front of cc a LinkType type
|
|
func (t *Listen) PrependCcLink(v LinkType) {
|
|
t.cc = append([]*ccListenIntermediateType{&ccListenIntermediateType{Link: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetCcIRI(index int) (v *url.URL) {
|
|
return t.cc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendCcIRI adds to the back of cc a *url.URL type
|
|
func (t *Listen) AppendCcIRI(v *url.URL) {
|
|
t.cc = append(t.cc, &ccListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependCcIRI adds to the front of cc a *url.URL type
|
|
func (t *Listen) PrependCcIRI(v *url.URL) {
|
|
t.cc = append([]*ccListenIntermediateType{&ccListenIntermediateType{IRI: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownCc() (ok bool) {
|
|
return t.cc != nil && t.cc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownCc returns the unknown value for cc
|
|
func (t *Listen) GetUnknownCc() (v interface{}) {
|
|
return t.cc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownCc sets the unknown value of cc
|
|
func (t *Listen) SetUnknownCc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &ccListenIntermediateType{}
|
|
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 *Listen) BccLen() (l int) {
|
|
return len(t.bcc)
|
|
|
|
}
|
|
|
|
// IsBccObject determines whether the call to GetBccObject is safe for the specified index
|
|
func (t *Listen) 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 *Listen) GetBccObject(index int) (v ObjectType) {
|
|
return t.bcc[index].Object
|
|
|
|
}
|
|
|
|
// AppendBccObject adds to the back of bcc a ObjectType type
|
|
func (t *Listen) AppendBccObject(v ObjectType) {
|
|
t.bcc = append(t.bcc, &bccListenIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBccObject adds to the front of bcc a ObjectType type
|
|
func (t *Listen) PrependBccObject(v ObjectType) {
|
|
t.bcc = append([]*bccListenIntermediateType{&bccListenIntermediateType{Object: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccObject deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetBccLink(index int) (v LinkType) {
|
|
return t.bcc[index].Link
|
|
|
|
}
|
|
|
|
// AppendBccLink adds to the back of bcc a LinkType type
|
|
func (t *Listen) AppendBccLink(v LinkType) {
|
|
t.bcc = append(t.bcc, &bccListenIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBccLink adds to the front of bcc a LinkType type
|
|
func (t *Listen) PrependBccLink(v LinkType) {
|
|
t.bcc = append([]*bccListenIntermediateType{&bccListenIntermediateType{Link: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccLink deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) 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 *Listen) GetBccIRI(index int) (v *url.URL) {
|
|
return t.bcc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBccIRI adds to the back of bcc a *url.URL type
|
|
func (t *Listen) AppendBccIRI(v *url.URL) {
|
|
t.bcc = append(t.bcc, &bccListenIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBccIRI adds to the front of bcc a *url.URL type
|
|
func (t *Listen) PrependBccIRI(v *url.URL) {
|
|
t.bcc = append([]*bccListenIntermediateType{&bccListenIntermediateType{IRI: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccIRI deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownBcc() (ok bool) {
|
|
return t.bcc != nil && t.bcc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBcc returns the unknown value for bcc
|
|
func (t *Listen) GetUnknownBcc() (v interface{}) {
|
|
return t.bcc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBcc sets the unknown value of bcc
|
|
func (t *Listen) SetUnknownBcc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &bccListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.bcc = append(t.bcc, tmp)
|
|
|
|
}
|
|
|
|
// IsMediaType determines whether the call to GetMediaType is safe
|
|
func (t *Listen) IsMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.mimeMediaTypeValue != nil
|
|
|
|
}
|
|
|
|
// GetMediaType returns the value safely if IsMediaType returned true
|
|
func (t *Listen) GetMediaType() (v string) {
|
|
return *t.mediaType.mimeMediaTypeValue
|
|
|
|
}
|
|
|
|
// SetMediaType sets the value of mediaType to be of string type
|
|
func (t *Listen) SetMediaType(v string) {
|
|
t.mediaType = &mediaTypeListenIntermediateType{mimeMediaTypeValue: &v}
|
|
|
|
}
|
|
|
|
// IsMediaTypeIRI determines whether the call to GetMediaTypeIRI is safe
|
|
func (t *Listen) IsMediaTypeIRI() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.IRI != nil
|
|
|
|
}
|
|
|
|
// GetMediaTypeIRI returns the value safely if IsMediaTypeIRI returned true
|
|
func (t *Listen) GetMediaTypeIRI() (v *url.URL) {
|
|
return t.mediaType.IRI
|
|
|
|
}
|
|
|
|
// SetMediaTypeIRI sets the value of mediaType to be of *url.URL type
|
|
func (t *Listen) SetMediaTypeIRI(v *url.URL) {
|
|
t.mediaType = &mediaTypeListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownMediaType determines whether the call to GetUnknownMediaType is safe
|
|
func (t *Listen) HasUnknownMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownMediaType returns the unknown value for mediaType
|
|
func (t *Listen) GetUnknownMediaType() (v interface{}) {
|
|
return t.mediaType.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownMediaType sets the unknown value of mediaType
|
|
func (t *Listen) SetUnknownMediaType(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &mediaTypeListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.mediaType = tmp
|
|
|
|
}
|
|
|
|
// IsDuration determines whether the call to GetDuration is safe
|
|
func (t *Listen) IsDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.duration != nil
|
|
|
|
}
|
|
|
|
// GetDuration returns the value safely if IsDuration returned true
|
|
func (t *Listen) GetDuration() (v time.Duration) {
|
|
return *t.duration.duration
|
|
|
|
}
|
|
|
|
// SetDuration sets the value of duration to be of time.Duration type
|
|
func (t *Listen) SetDuration(v time.Duration) {
|
|
t.duration = &durationListenIntermediateType{duration: &v}
|
|
|
|
}
|
|
|
|
// IsDurationIRI determines whether the call to GetDurationIRI is safe
|
|
func (t *Listen) IsDurationIRI() (ok bool) {
|
|
return t.duration != nil && t.duration.IRI != nil
|
|
|
|
}
|
|
|
|
// GetDurationIRI returns the value safely if IsDurationIRI returned true
|
|
func (t *Listen) GetDurationIRI() (v *url.URL) {
|
|
return t.duration.IRI
|
|
|
|
}
|
|
|
|
// SetDurationIRI sets the value of duration to be of *url.URL type
|
|
func (t *Listen) SetDurationIRI(v *url.URL) {
|
|
t.duration = &durationListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownDuration determines whether the call to GetUnknownDuration is safe
|
|
func (t *Listen) HasUnknownDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownDuration returns the unknown value for duration
|
|
func (t *Listen) GetUnknownDuration() (v interface{}) {
|
|
return t.duration.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownDuration sets the unknown value of duration
|
|
func (t *Listen) SetUnknownDuration(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &durationListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.duration = tmp
|
|
|
|
}
|
|
|
|
// IsSource determines whether the call to GetSource is safe
|
|
func (t *Listen) IsSource() (ok bool) {
|
|
return t.source != nil && t.source.Object != nil
|
|
|
|
}
|
|
|
|
// GetSource returns the value safely if IsSource returned true
|
|
func (t *Listen) GetSource() (v ObjectType) {
|
|
return t.source.Object
|
|
|
|
}
|
|
|
|
// SetSource sets the value of source to be of ObjectType type
|
|
func (t *Listen) SetSource(v ObjectType) {
|
|
t.source = &sourceListenIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsSourceIRI determines whether the call to GetSourceIRI is safe
|
|
func (t *Listen) IsSourceIRI() (ok bool) {
|
|
return t.source != nil && t.source.IRI != nil
|
|
|
|
}
|
|
|
|
// GetSourceIRI returns the value safely if IsSourceIRI returned true
|
|
func (t *Listen) GetSourceIRI() (v *url.URL) {
|
|
return t.source.IRI
|
|
|
|
}
|
|
|
|
// SetSourceIRI sets the value of source to be of *url.URL type
|
|
func (t *Listen) SetSourceIRI(v *url.URL) {
|
|
t.source = &sourceListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownSource determines whether the call to GetUnknownSource is safe
|
|
func (t *Listen) HasUnknownSource() (ok bool) {
|
|
return t.source != nil && t.source.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSource returns the unknown value for source
|
|
func (t *Listen) GetUnknownSource() (v interface{}) {
|
|
return t.source.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSource sets the unknown value of source
|
|
func (t *Listen) SetUnknownSource(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &sourceListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.source = tmp
|
|
|
|
}
|
|
|
|
// IsInboxOrderedCollection determines whether the call to GetInboxOrderedCollection is safe
|
|
func (t *Listen) IsInboxOrderedCollection() (ok bool) {
|
|
return t.inbox != nil && t.inbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetInboxOrderedCollection returns the value safely if IsInboxOrderedCollection returned true
|
|
func (t *Listen) GetInboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.inbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetInboxOrderedCollection sets the value of inbox to be of OrderedCollectionType type
|
|
func (t *Listen) SetInboxOrderedCollection(v OrderedCollectionType) {
|
|
t.inbox = &inboxListenIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsInboxAnyURI determines whether the call to GetInboxAnyURI is safe
|
|
func (t *Listen) IsInboxAnyURI() (ok bool) {
|
|
return t.inbox != nil && t.inbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetInboxAnyURI returns the value safely if IsInboxAnyURI returned true
|
|
func (t *Listen) GetInboxAnyURI() (v *url.URL) {
|
|
return t.inbox.anyURI
|
|
|
|
}
|
|
|
|
// SetInboxAnyURI sets the value of inbox to be of *url.URL type
|
|
func (t *Listen) SetInboxAnyURI(v *url.URL) {
|
|
t.inbox = &inboxListenIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownInbox determines whether the call to GetUnknownInbox is safe
|
|
func (t *Listen) HasUnknownInbox() (ok bool) {
|
|
return t.inbox != nil && t.inbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInbox returns the unknown value for inbox
|
|
func (t *Listen) GetUnknownInbox() (v interface{}) {
|
|
return t.inbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInbox sets the unknown value of inbox
|
|
func (t *Listen) SetUnknownInbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inboxListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.inbox = tmp
|
|
|
|
}
|
|
|
|
// IsOutboxOrderedCollection determines whether the call to GetOutboxOrderedCollection is safe
|
|
func (t *Listen) IsOutboxOrderedCollection() (ok bool) {
|
|
return t.outbox != nil && t.outbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetOutboxOrderedCollection returns the value safely if IsOutboxOrderedCollection returned true
|
|
func (t *Listen) GetOutboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.outbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetOutboxOrderedCollection sets the value of outbox to be of OrderedCollectionType type
|
|
func (t *Listen) SetOutboxOrderedCollection(v OrderedCollectionType) {
|
|
t.outbox = &outboxListenIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsOutboxAnyURI determines whether the call to GetOutboxAnyURI is safe
|
|
func (t *Listen) IsOutboxAnyURI() (ok bool) {
|
|
return t.outbox != nil && t.outbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetOutboxAnyURI returns the value safely if IsOutboxAnyURI returned true
|
|
func (t *Listen) GetOutboxAnyURI() (v *url.URL) {
|
|
return t.outbox.anyURI
|
|
|
|
}
|
|
|
|
// SetOutboxAnyURI sets the value of outbox to be of *url.URL type
|
|
func (t *Listen) SetOutboxAnyURI(v *url.URL) {
|
|
t.outbox = &outboxListenIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownOutbox determines whether the call to GetUnknownOutbox is safe
|
|
func (t *Listen) HasUnknownOutbox() (ok bool) {
|
|
return t.outbox != nil && t.outbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOutbox returns the unknown value for outbox
|
|
func (t *Listen) GetUnknownOutbox() (v interface{}) {
|
|
return t.outbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOutbox sets the unknown value of outbox
|
|
func (t *Listen) SetUnknownOutbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &outboxListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.outbox = tmp
|
|
|
|
}
|
|
|
|
// IsFollowingCollection determines whether the call to GetFollowingCollection is safe
|
|
func (t *Listen) IsFollowingCollection() (ok bool) {
|
|
return t.following != nil && t.following.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingCollection returns the value safely if IsFollowingCollection returned true
|
|
func (t *Listen) GetFollowingCollection() (v CollectionType) {
|
|
return t.following.Collection
|
|
|
|
}
|
|
|
|
// SetFollowingCollection sets the value of following to be of CollectionType type
|
|
func (t *Listen) SetFollowingCollection(v CollectionType) {
|
|
t.following = &followingListenIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingOrderedCollection determines whether the call to GetFollowingOrderedCollection is safe
|
|
func (t *Listen) IsFollowingOrderedCollection() (ok bool) {
|
|
return t.following != nil && t.following.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingOrderedCollection returns the value safely if IsFollowingOrderedCollection returned true
|
|
func (t *Listen) GetFollowingOrderedCollection() (v OrderedCollectionType) {
|
|
return t.following.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowingOrderedCollection sets the value of following to be of OrderedCollectionType type
|
|
func (t *Listen) SetFollowingOrderedCollection(v OrderedCollectionType) {
|
|
t.following = &followingListenIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingAnyURI determines whether the call to GetFollowingAnyURI is safe
|
|
func (t *Listen) IsFollowingAnyURI() (ok bool) {
|
|
return t.following != nil && t.following.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowingAnyURI returns the value safely if IsFollowingAnyURI returned true
|
|
func (t *Listen) GetFollowingAnyURI() (v *url.URL) {
|
|
return t.following.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowingAnyURI sets the value of following to be of *url.URL type
|
|
func (t *Listen) SetFollowingAnyURI(v *url.URL) {
|
|
t.following = &followingListenIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowing determines whether the call to GetUnknownFollowing is safe
|
|
func (t *Listen) HasUnknownFollowing() (ok bool) {
|
|
return t.following != nil && t.following.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowing returns the unknown value for following
|
|
func (t *Listen) GetUnknownFollowing() (v interface{}) {
|
|
return t.following.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowing sets the unknown value of following
|
|
func (t *Listen) SetUnknownFollowing(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followingListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.following = tmp
|
|
|
|
}
|
|
|
|
// IsFollowersCollection determines whether the call to GetFollowersCollection is safe
|
|
func (t *Listen) IsFollowersCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersCollection returns the value safely if IsFollowersCollection returned true
|
|
func (t *Listen) GetFollowersCollection() (v CollectionType) {
|
|
return t.followers.Collection
|
|
|
|
}
|
|
|
|
// SetFollowersCollection sets the value of followers to be of CollectionType type
|
|
func (t *Listen) SetFollowersCollection(v CollectionType) {
|
|
t.followers = &followersListenIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersOrderedCollection determines whether the call to GetFollowersOrderedCollection is safe
|
|
func (t *Listen) IsFollowersOrderedCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersOrderedCollection returns the value safely if IsFollowersOrderedCollection returned true
|
|
func (t *Listen) GetFollowersOrderedCollection() (v OrderedCollectionType) {
|
|
return t.followers.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowersOrderedCollection sets the value of followers to be of OrderedCollectionType type
|
|
func (t *Listen) SetFollowersOrderedCollection(v OrderedCollectionType) {
|
|
t.followers = &followersListenIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersAnyURI determines whether the call to GetFollowersAnyURI is safe
|
|
func (t *Listen) IsFollowersAnyURI() (ok bool) {
|
|
return t.followers != nil && t.followers.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowersAnyURI returns the value safely if IsFollowersAnyURI returned true
|
|
func (t *Listen) GetFollowersAnyURI() (v *url.URL) {
|
|
return t.followers.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowersAnyURI sets the value of followers to be of *url.URL type
|
|
func (t *Listen) SetFollowersAnyURI(v *url.URL) {
|
|
t.followers = &followersListenIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowers determines whether the call to GetUnknownFollowers is safe
|
|
func (t *Listen) HasUnknownFollowers() (ok bool) {
|
|
return t.followers != nil && t.followers.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowers returns the unknown value for followers
|
|
func (t *Listen) GetUnknownFollowers() (v interface{}) {
|
|
return t.followers.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowers sets the unknown value of followers
|
|
func (t *Listen) SetUnknownFollowers(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followersListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.followers = tmp
|
|
|
|
}
|
|
|
|
// IsLikedCollection determines whether the call to GetLikedCollection is safe
|
|
func (t *Listen) IsLikedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikedCollection returns the value safely if IsLikedCollection returned true
|
|
func (t *Listen) GetLikedCollection() (v CollectionType) {
|
|
return t.liked.Collection
|
|
|
|
}
|
|
|
|
// SetLikedCollection sets the value of liked to be of CollectionType type
|
|
func (t *Listen) SetLikedCollection(v CollectionType) {
|
|
t.liked = &likedListenIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikedOrderedCollection determines whether the call to GetLikedOrderedCollection is safe
|
|
func (t *Listen) IsLikedOrderedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikedOrderedCollection returns the value safely if IsLikedOrderedCollection returned true
|
|
func (t *Listen) GetLikedOrderedCollection() (v OrderedCollectionType) {
|
|
return t.liked.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikedOrderedCollection sets the value of liked to be of OrderedCollectionType type
|
|
func (t *Listen) SetLikedOrderedCollection(v OrderedCollectionType) {
|
|
t.liked = &likedListenIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikedAnyURI determines whether the call to GetLikedAnyURI is safe
|
|
func (t *Listen) IsLikedAnyURI() (ok bool) {
|
|
return t.liked != nil && t.liked.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikedAnyURI returns the value safely if IsLikedAnyURI returned true
|
|
func (t *Listen) GetLikedAnyURI() (v *url.URL) {
|
|
return t.liked.anyURI
|
|
|
|
}
|
|
|
|
// SetLikedAnyURI sets the value of liked to be of *url.URL type
|
|
func (t *Listen) SetLikedAnyURI(v *url.URL) {
|
|
t.liked = &likedListenIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLiked determines whether the call to GetUnknownLiked is safe
|
|
func (t *Listen) HasUnknownLiked() (ok bool) {
|
|
return t.liked != nil && t.liked.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLiked returns the unknown value for liked
|
|
func (t *Listen) GetUnknownLiked() (v interface{}) {
|
|
return t.liked.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLiked sets the unknown value of liked
|
|
func (t *Listen) SetUnknownLiked(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likedListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.liked = tmp
|
|
|
|
}
|
|
|
|
// IsLikesCollection determines whether the call to GetLikesCollection is safe
|
|
func (t *Listen) IsLikesCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikesCollection returns the value safely if IsLikesCollection returned true
|
|
func (t *Listen) GetLikesCollection() (v CollectionType) {
|
|
return t.likes.Collection
|
|
|
|
}
|
|
|
|
// SetLikesCollection sets the value of likes to be of CollectionType type
|
|
func (t *Listen) SetLikesCollection(v CollectionType) {
|
|
t.likes = &likesListenIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikesOrderedCollection determines whether the call to GetLikesOrderedCollection is safe
|
|
func (t *Listen) IsLikesOrderedCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikesOrderedCollection returns the value safely if IsLikesOrderedCollection returned true
|
|
func (t *Listen) GetLikesOrderedCollection() (v OrderedCollectionType) {
|
|
return t.likes.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikesOrderedCollection sets the value of likes to be of OrderedCollectionType type
|
|
func (t *Listen) SetLikesOrderedCollection(v OrderedCollectionType) {
|
|
t.likes = &likesListenIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikesAnyURI determines whether the call to GetLikesAnyURI is safe
|
|
func (t *Listen) IsLikesAnyURI() (ok bool) {
|
|
return t.likes != nil && t.likes.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikesAnyURI returns the value safely if IsLikesAnyURI returned true
|
|
func (t *Listen) GetLikesAnyURI() (v *url.URL) {
|
|
return t.likes.anyURI
|
|
|
|
}
|
|
|
|
// SetLikesAnyURI sets the value of likes to be of *url.URL type
|
|
func (t *Listen) SetLikesAnyURI(v *url.URL) {
|
|
t.likes = &likesListenIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLikes determines whether the call to GetUnknownLikes is safe
|
|
func (t *Listen) HasUnknownLikes() (ok bool) {
|
|
return t.likes != nil && t.likes.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLikes returns the unknown value for likes
|
|
func (t *Listen) GetUnknownLikes() (v interface{}) {
|
|
return t.likes.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLikes sets the unknown value of likes
|
|
func (t *Listen) SetUnknownLikes(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likesListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.likes = tmp
|
|
|
|
}
|
|
|
|
// StreamsLen determines the number of elements able to be used for the GetStreams and RemoveStreams functions
|
|
func (t *Listen) StreamsLen() (l int) {
|
|
return len(t.streams)
|
|
|
|
}
|
|
|
|
// GetStreams returns the value for the specified index
|
|
func (t *Listen) GetStreams(index int) (v *url.URL) {
|
|
return t.streams[index]
|
|
|
|
}
|
|
|
|
// AppendStreams adds a value to the back of streams
|
|
func (t *Listen) AppendStreams(v *url.URL) {
|
|
t.streams = append(t.streams, v)
|
|
|
|
}
|
|
|
|
// PrependStreams adds a value to the front of streams
|
|
func (t *Listen) PrependStreams(v *url.URL) {
|
|
t.streams = append([]*url.URL{v}, t.streams...)
|
|
|
|
}
|
|
|
|
// RemoveStreams deletes the value from the specified index
|
|
func (t *Listen) 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 *Listen) HasUnknownStreams() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["streams"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStreams returns the unknown value for streams
|
|
func (t *Listen) GetUnknownStreams() (v interface{}) {
|
|
return t.unknown_["streams"]
|
|
|
|
}
|
|
|
|
// SetUnknownStreams sets the unknown value of streams
|
|
func (t *Listen) 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 *Listen) IsPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.stringName != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsername returns the value safely if IsPreferredUsername returned true
|
|
func (t *Listen) GetPreferredUsername() (v string) {
|
|
return *t.preferredUsername.stringName
|
|
|
|
}
|
|
|
|
// SetPreferredUsername sets the value of preferredUsername to be of string type
|
|
func (t *Listen) SetPreferredUsername(v string) {
|
|
t.preferredUsername = &preferredUsernameListenIntermediateType{stringName: &v}
|
|
|
|
}
|
|
|
|
// IsPreferredUsernameIRI determines whether the call to GetPreferredUsernameIRI is safe
|
|
func (t *Listen) IsPreferredUsernameIRI() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsernameIRI returns the value safely if IsPreferredUsernameIRI returned true
|
|
func (t *Listen) GetPreferredUsernameIRI() (v *url.URL) {
|
|
return t.preferredUsername.IRI
|
|
|
|
}
|
|
|
|
// SetPreferredUsernameIRI sets the value of preferredUsername to be of *url.URL type
|
|
func (t *Listen) SetPreferredUsernameIRI(v *url.URL) {
|
|
t.preferredUsername = &preferredUsernameListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPreferredUsername determines whether the call to GetUnknownPreferredUsername is safe
|
|
func (t *Listen) HasUnknownPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreferredUsername returns the unknown value for preferredUsername
|
|
func (t *Listen) GetUnknownPreferredUsername() (v interface{}) {
|
|
return t.preferredUsername.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreferredUsername sets the unknown value of preferredUsername
|
|
func (t *Listen) SetUnknownPreferredUsername(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &preferredUsernameListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preferredUsername = tmp
|
|
|
|
}
|
|
|
|
// PreferredUsernameMapLanguages returns all languages for this property's language mapping, or nil if there are none.
|
|
func (t *Listen) 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 *Listen) 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 *Listen) 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 *Listen) IsEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.Object != nil
|
|
|
|
}
|
|
|
|
// GetEndpoints returns the value safely if IsEndpoints returned true
|
|
func (t *Listen) GetEndpoints() (v ObjectType) {
|
|
return t.endpoints.Object
|
|
|
|
}
|
|
|
|
// SetEndpoints sets the value of endpoints to be of ObjectType type
|
|
func (t *Listen) SetEndpoints(v ObjectType) {
|
|
t.endpoints = &endpointsListenIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsEndpointsIRI determines whether the call to GetEndpointsIRI is safe
|
|
func (t *Listen) IsEndpointsIRI() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndpointsIRI returns the value safely if IsEndpointsIRI returned true
|
|
func (t *Listen) GetEndpointsIRI() (v *url.URL) {
|
|
return t.endpoints.IRI
|
|
|
|
}
|
|
|
|
// SetEndpointsIRI sets the value of endpoints to be of *url.URL type
|
|
func (t *Listen) SetEndpointsIRI(v *url.URL) {
|
|
t.endpoints = &endpointsListenIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndpoints determines whether the call to GetUnknownEndpoints is safe
|
|
func (t *Listen) HasUnknownEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndpoints returns the unknown value for endpoints
|
|
func (t *Listen) GetUnknownEndpoints() (v interface{}) {
|
|
return t.endpoints.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndpoints sets the unknown value of endpoints
|
|
func (t *Listen) SetUnknownEndpoints(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endpointsListenIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.endpoints = tmp
|
|
|
|
}
|
|
|
|
// HasProxyUrl determines whether the call to GetProxyUrl is safe
|
|
func (t *Listen) HasProxyUrl() (ok bool) {
|
|
return t.proxyUrl != nil
|
|
|
|
}
|
|
|
|
// GetProxyUrl returns the value for proxyUrl
|
|
func (t *Listen) GetProxyUrl() (v *url.URL) {
|
|
return t.proxyUrl
|
|
|
|
}
|
|
|
|
// SetProxyUrl sets the value of proxyUrl
|
|
func (t *Listen) SetProxyUrl(v *url.URL) {
|
|
t.proxyUrl = v
|
|
|
|
}
|
|
|
|
// HasUnknownProxyUrl determines whether the call to GetUnknownProxyUrl is safe
|
|
func (t *Listen) HasUnknownProxyUrl() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["proxyUrl"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProxyUrl returns the unknown value for proxyUrl
|
|
func (t *Listen) GetUnknownProxyUrl() (v interface{}) {
|
|
return t.unknown_["proxyUrl"]
|
|
|
|
}
|
|
|
|
// SetUnknownProxyUrl sets the unknown value of proxyUrl
|
|
func (t *Listen) 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 *Listen) HasOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.oauthAuthorizationEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthAuthorizationEndpoint returns the value for oauthAuthorizationEndpoint
|
|
func (t *Listen) GetOauthAuthorizationEndpoint() (v *url.URL) {
|
|
return t.oauthAuthorizationEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthAuthorizationEndpoint sets the value of oauthAuthorizationEndpoint
|
|
func (t *Listen) SetOauthAuthorizationEndpoint(v *url.URL) {
|
|
t.oauthAuthorizationEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthAuthorizationEndpoint determines whether the call to GetUnknownOauthAuthorizationEndpoint is safe
|
|
func (t *Listen) HasUnknownOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthAuthorizationEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthAuthorizationEndpoint returns the unknown value for oauthAuthorizationEndpoint
|
|
func (t *Listen) GetUnknownOauthAuthorizationEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthAuthorizationEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthAuthorizationEndpoint sets the unknown value of oauthAuthorizationEndpoint
|
|
func (t *Listen) 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 *Listen) HasOauthTokenEndpoint() (ok bool) {
|
|
return t.oauthTokenEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthTokenEndpoint returns the value for oauthTokenEndpoint
|
|
func (t *Listen) GetOauthTokenEndpoint() (v *url.URL) {
|
|
return t.oauthTokenEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthTokenEndpoint sets the value of oauthTokenEndpoint
|
|
func (t *Listen) SetOauthTokenEndpoint(v *url.URL) {
|
|
t.oauthTokenEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthTokenEndpoint determines whether the call to GetUnknownOauthTokenEndpoint is safe
|
|
func (t *Listen) HasUnknownOauthTokenEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthTokenEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthTokenEndpoint returns the unknown value for oauthTokenEndpoint
|
|
func (t *Listen) GetUnknownOauthTokenEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthTokenEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthTokenEndpoint sets the unknown value of oauthTokenEndpoint
|
|
func (t *Listen) 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 *Listen) HasProvideClientKey() (ok bool) {
|
|
return t.provideClientKey != nil
|
|
|
|
}
|
|
|
|
// GetProvideClientKey returns the value for provideClientKey
|
|
func (t *Listen) GetProvideClientKey() (v *url.URL) {
|
|
return t.provideClientKey
|
|
|
|
}
|
|
|
|
// SetProvideClientKey sets the value of provideClientKey
|
|
func (t *Listen) SetProvideClientKey(v *url.URL) {
|
|
t.provideClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownProvideClientKey determines whether the call to GetUnknownProvideClientKey is safe
|
|
func (t *Listen) HasUnknownProvideClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["provideClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProvideClientKey returns the unknown value for provideClientKey
|
|
func (t *Listen) GetUnknownProvideClientKey() (v interface{}) {
|
|
return t.unknown_["provideClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownProvideClientKey sets the unknown value of provideClientKey
|
|
func (t *Listen) 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 *Listen) HasSignClientKey() (ok bool) {
|
|
return t.signClientKey != nil
|
|
|
|
}
|
|
|
|
// GetSignClientKey returns the value for signClientKey
|
|
func (t *Listen) GetSignClientKey() (v *url.URL) {
|
|
return t.signClientKey
|
|
|
|
}
|
|
|
|
// SetSignClientKey sets the value of signClientKey
|
|
func (t *Listen) SetSignClientKey(v *url.URL) {
|
|
t.signClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownSignClientKey determines whether the call to GetUnknownSignClientKey is safe
|
|
func (t *Listen) HasUnknownSignClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["signClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSignClientKey returns the unknown value for signClientKey
|
|
func (t *Listen) GetUnknownSignClientKey() (v interface{}) {
|
|
return t.unknown_["signClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownSignClientKey sets the unknown value of signClientKey
|
|
func (t *Listen) 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 *Listen) HasSharedInbox() (ok bool) {
|
|
return t.sharedInbox != nil
|
|
|
|
}
|
|
|
|
// GetSharedInbox returns the value for sharedInbox
|
|
func (t *Listen) GetSharedInbox() (v *url.URL) {
|
|
return t.sharedInbox
|
|
|
|
}
|
|
|
|
// SetSharedInbox sets the value of sharedInbox
|
|
func (t *Listen) SetSharedInbox(v *url.URL) {
|
|
t.sharedInbox = v
|
|
|
|
}
|
|
|
|
// HasUnknownSharedInbox determines whether the call to GetUnknownSharedInbox is safe
|
|
func (t *Listen) HasUnknownSharedInbox() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["sharedInbox"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSharedInbox returns the unknown value for sharedInbox
|
|
func (t *Listen) GetUnknownSharedInbox() (v interface{}) {
|
|
return t.unknown_["sharedInbox"]
|
|
|
|
}
|
|
|
|
// SetUnknownSharedInbox sets the unknown value of sharedInbox
|
|
func (t *Listen) 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 *Listen) AddUnknown(k string, i interface{}) (this *Listen) {
|
|
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 *Listen) 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 *Listen) RemoveUnknown(k string) (this *Listen) {
|
|
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 "Listen" if not manually set by the caller
|
|
func (t *Listen) 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 == "Listen" {
|
|
typeAlreadySet = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !typeAlreadySet {
|
|
t.typeName = append(t.typeName, "Listen")
|
|
}
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceActorListenIntermediateType(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 := serializeSliceObjectListenIntermediateType(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 := serializeSliceTargetListenIntermediateType(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 := serializeSliceResultListenIntermediateType(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 := serializeSliceOriginListenIntermediateType(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 := serializeSliceInstrumentListenIntermediateType(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 := serializeAltitudeListenIntermediateType(t.altitude); err == nil {
|
|
m["altitude"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceAttachmentListenIntermediateType(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 := serializeSliceAttributedToListenIntermediateType(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 := serializeSliceAudienceListenIntermediateType(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 := serializeSliceContentListenIntermediateType(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 := serializeSliceContextListenIntermediateType(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 := serializeSliceNameListenIntermediateType(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 := serializeEndTimeListenIntermediateType(t.endTime); err == nil {
|
|
m["endTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceGeneratorListenIntermediateType(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 := serializeSliceIconListenIntermediateType(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 := serializeSliceImageListenIntermediateType(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 := serializeSliceInReplyToListenIntermediateType(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 := serializeSliceLocationListenIntermediateType(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 := serializeSlicePreviewListenIntermediateType(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 := serializePublishedListenIntermediateType(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 := serializeRepliesListenIntermediateType(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 := serializeStartTimeListenIntermediateType(t.startTime); err == nil {
|
|
m["startTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceSummaryListenIntermediateType(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 := serializeSliceTagListenIntermediateType(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 := serializeUpdatedListenIntermediateType(t.updated); err == nil {
|
|
m["updated"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceUrlListenIntermediateType(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 := serializeSliceToListenIntermediateType(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 := serializeSliceBtoListenIntermediateType(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 := serializeSliceCcListenIntermediateType(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 := serializeSliceBccListenIntermediateType(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 := serializeMediaTypeListenIntermediateType(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 := serializeDurationListenIntermediateType(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 := serializeSourceListenIntermediateType(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 := serializeInboxListenIntermediateType(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 := serializeOutboxListenIntermediateType(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 := serializeFollowingListenIntermediateType(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 := serializeFollowersListenIntermediateType(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 := serializeLikedListenIntermediateType(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 := serializeLikesListenIntermediateType(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 := serializePreferredUsernameListenIntermediateType(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 := serializeEndpointsListenIntermediateType(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 *Listen) 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 := deserializeActorListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.actor, err = deserializeSliceActorListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &actorListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorListenIntermediateType{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 := deserializeObjectListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.object, err = deserializeSliceObjectListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &objectListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectListenIntermediateType{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 := deserializeTargetListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.target, err = deserializeSliceTargetListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &targetListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetListenIntermediateType{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 := deserializeResultListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.result, err = deserializeSliceResultListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &resultListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultListenIntermediateType{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 := deserializeOriginListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.origin, err = deserializeSliceOriginListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &originListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originListenIntermediateType{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 := deserializeInstrumentListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.instrument, err = deserializeSliceInstrumentListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &instrumentListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentListenIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "altitude" {
|
|
t.altitude, err = deserializeAltitudeListenIntermediateType(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 := deserializeAttachmentListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attachment, err = deserializeSliceAttachmentListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attachmentListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentListenIntermediateType{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 := deserializeAttributedToListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attributedTo, err = deserializeSliceAttributedToListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attributedToListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToListenIntermediateType{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 := deserializeAudienceListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.audience, err = deserializeSliceAudienceListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &audienceListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceListenIntermediateType{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 := deserializeContentListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.content, err = deserializeSliceContentListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contentListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentListenIntermediateType{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 := deserializeContextListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.context, err = deserializeSliceContextListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contextListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextListenIntermediateType{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 := deserializeNameListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.name, err = deserializeSliceNameListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &nameListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameListenIntermediateType{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 = deserializeEndTimeListenIntermediateType(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 := deserializeGeneratorListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.generator, err = deserializeSliceGeneratorListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &generatorListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorListenIntermediateType{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 := deserializeIconListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.icon, err = deserializeSliceIconListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &iconListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconListenIntermediateType{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 := deserializeImageListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.image, err = deserializeSliceImageListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &imageListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageListenIntermediateType{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 := deserializeInReplyToListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.inReplyTo, err = deserializeSliceInReplyToListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &inReplyToListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToListenIntermediateType{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 := deserializeLocationListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.location, err = deserializeSliceLocationListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &locationListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationListenIntermediateType{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 := deserializePreviewListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.preview, err = deserializeSlicePreviewListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &previewListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewListenIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "published" {
|
|
t.published, err = deserializePublishedListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "replies" {
|
|
t.replies, err = deserializeRepliesListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "startTime" {
|
|
t.startTime, err = deserializeStartTimeListenIntermediateType(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 := deserializeSummaryListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.summary, err = deserializeSliceSummaryListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &summaryListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryListenIntermediateType{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 := deserializeTagListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.tag, err = deserializeSliceTagListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &tagListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagListenIntermediateType{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 = deserializeUpdatedListenIntermediateType(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 := deserializeUrlListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.url, err = deserializeSliceUrlListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &urlListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlListenIntermediateType{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 := deserializeToListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.to, err = deserializeSliceToListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &toListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toListenIntermediateType{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 := deserializeBtoListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bto, err = deserializeSliceBtoListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &btoListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoListenIntermediateType{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 := deserializeCcListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.cc, err = deserializeSliceCcListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &ccListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccListenIntermediateType{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 := deserializeBccListenIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccListenIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bcc, err = deserializeSliceBccListenIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &bccListenIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccListenIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "mediaType" {
|
|
t.mediaType, err = deserializeMediaTypeListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "duration" {
|
|
t.duration, err = deserializeDurationListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "source" {
|
|
t.source, err = deserializeSourceListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "inbox" {
|
|
t.inbox, err = deserializeInboxListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "outbox" {
|
|
t.outbox, err = deserializeOutboxListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "following" {
|
|
t.following, err = deserializeFollowingListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "followers" {
|
|
t.followers, err = deserializeFollowersListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "liked" {
|
|
t.liked, err = deserializeLikedListenIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "likes" {
|
|
t.likes, err = deserializeLikesListenIntermediateType(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 = deserializePreferredUsernameListenIntermediateType(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 = deserializeEndpointsListenIntermediateType(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
|
|
|
|
}
|
|
|
|
// actorListenIntermediateType will only have one of its values set at most
|
|
type actorListenIntermediateType 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 *actorListenIntermediateType) 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 *actorListenIntermediateType) 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
|
|
}
|
|
|
|
// objectListenIntermediateType will only have one of its values set at most
|
|
type objectListenIntermediateType 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 *objectListenIntermediateType) 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 *objectListenIntermediateType) 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
|
|
}
|
|
|
|
// targetListenIntermediateType will only have one of its values set at most
|
|
type targetListenIntermediateType 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 *targetListenIntermediateType) 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 *targetListenIntermediateType) 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
|
|
}
|
|
|
|
// resultListenIntermediateType will only have one of its values set at most
|
|
type resultListenIntermediateType 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 *resultListenIntermediateType) 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 *resultListenIntermediateType) 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
|
|
}
|
|
|
|
// originListenIntermediateType will only have one of its values set at most
|
|
type originListenIntermediateType 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 *originListenIntermediateType) 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 *originListenIntermediateType) 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
|
|
}
|
|
|
|
// instrumentListenIntermediateType will only have one of its values set at most
|
|
type instrumentListenIntermediateType 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 *instrumentListenIntermediateType) 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 *instrumentListenIntermediateType) 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
|
|
}
|
|
|
|
// altitudeListenIntermediateType will only have one of its values set at most
|
|
type altitudeListenIntermediateType 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 *altitudeListenIntermediateType) 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 *altitudeListenIntermediateType) 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
|
|
}
|
|
|
|
// attachmentListenIntermediateType will only have one of its values set at most
|
|
type attachmentListenIntermediateType 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 *attachmentListenIntermediateType) 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 *attachmentListenIntermediateType) 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
|
|
}
|
|
|
|
// attributedToListenIntermediateType will only have one of its values set at most
|
|
type attributedToListenIntermediateType 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 *attributedToListenIntermediateType) 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 *attributedToListenIntermediateType) 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
|
|
}
|
|
|
|
// audienceListenIntermediateType will only have one of its values set at most
|
|
type audienceListenIntermediateType 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 *audienceListenIntermediateType) 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 *audienceListenIntermediateType) 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
|
|
}
|
|
|
|
// contentListenIntermediateType will only have one of its values set at most
|
|
type contentListenIntermediateType 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 *contentListenIntermediateType) 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 *contentListenIntermediateType) 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
|
|
}
|
|
|
|
// contextListenIntermediateType will only have one of its values set at most
|
|
type contextListenIntermediateType 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 *contextListenIntermediateType) 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 *contextListenIntermediateType) 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
|
|
}
|
|
|
|
// nameListenIntermediateType will only have one of its values set at most
|
|
type nameListenIntermediateType 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 *nameListenIntermediateType) 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 *nameListenIntermediateType) 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
|
|
}
|
|
|
|
// endTimeListenIntermediateType will only have one of its values set at most
|
|
type endTimeListenIntermediateType 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 *endTimeListenIntermediateType) 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 *endTimeListenIntermediateType) 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
|
|
}
|
|
|
|
// generatorListenIntermediateType will only have one of its values set at most
|
|
type generatorListenIntermediateType 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 *generatorListenIntermediateType) 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 *generatorListenIntermediateType) 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
|
|
}
|
|
|
|
// iconListenIntermediateType will only have one of its values set at most
|
|
type iconListenIntermediateType 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 *iconListenIntermediateType) 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 *iconListenIntermediateType) 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
|
|
}
|
|
|
|
// imageListenIntermediateType will only have one of its values set at most
|
|
type imageListenIntermediateType 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 *imageListenIntermediateType) 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 *imageListenIntermediateType) 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
|
|
}
|
|
|
|
// inReplyToListenIntermediateType will only have one of its values set at most
|
|
type inReplyToListenIntermediateType 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 *inReplyToListenIntermediateType) 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 *inReplyToListenIntermediateType) 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
|
|
}
|
|
|
|
// locationListenIntermediateType will only have one of its values set at most
|
|
type locationListenIntermediateType 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 *locationListenIntermediateType) 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 *locationListenIntermediateType) 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
|
|
}
|
|
|
|
// previewListenIntermediateType will only have one of its values set at most
|
|
type previewListenIntermediateType 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 *previewListenIntermediateType) 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 *previewListenIntermediateType) 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
|
|
}
|
|
|
|
// publishedListenIntermediateType will only have one of its values set at most
|
|
type publishedListenIntermediateType 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 *publishedListenIntermediateType) 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 *publishedListenIntermediateType) 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
|
|
}
|
|
|
|
// repliesListenIntermediateType will only have one of its values set at most
|
|
type repliesListenIntermediateType 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 *repliesListenIntermediateType) 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 *repliesListenIntermediateType) 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
|
|
}
|
|
|
|
// startTimeListenIntermediateType will only have one of its values set at most
|
|
type startTimeListenIntermediateType 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 *startTimeListenIntermediateType) 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 *startTimeListenIntermediateType) 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
|
|
}
|
|
|
|
// summaryListenIntermediateType will only have one of its values set at most
|
|
type summaryListenIntermediateType 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 *summaryListenIntermediateType) 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 *summaryListenIntermediateType) 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
|
|
}
|
|
|
|
// tagListenIntermediateType will only have one of its values set at most
|
|
type tagListenIntermediateType 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 *tagListenIntermediateType) 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 *tagListenIntermediateType) 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
|
|
}
|
|
|
|
// updatedListenIntermediateType will only have one of its values set at most
|
|
type updatedListenIntermediateType 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 *updatedListenIntermediateType) 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 *updatedListenIntermediateType) 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
|
|
}
|
|
|
|
// urlListenIntermediateType will only have one of its values set at most
|
|
type urlListenIntermediateType 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 *urlListenIntermediateType) 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 *urlListenIntermediateType) 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
|
|
}
|
|
|
|
// toListenIntermediateType will only have one of its values set at most
|
|
type toListenIntermediateType 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 *toListenIntermediateType) 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 *toListenIntermediateType) 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
|
|
}
|
|
|
|
// btoListenIntermediateType will only have one of its values set at most
|
|
type btoListenIntermediateType 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 *btoListenIntermediateType) 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 *btoListenIntermediateType) 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
|
|
}
|
|
|
|
// ccListenIntermediateType will only have one of its values set at most
|
|
type ccListenIntermediateType 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 *ccListenIntermediateType) 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 *ccListenIntermediateType) 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
|
|
}
|
|
|
|
// bccListenIntermediateType will only have one of its values set at most
|
|
type bccListenIntermediateType 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 *bccListenIntermediateType) 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 *bccListenIntermediateType) 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
|
|
}
|
|
|
|
// mediaTypeListenIntermediateType will only have one of its values set at most
|
|
type mediaTypeListenIntermediateType 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 *mediaTypeListenIntermediateType) 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 *mediaTypeListenIntermediateType) 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
|
|
}
|
|
|
|
// durationListenIntermediateType will only have one of its values set at most
|
|
type durationListenIntermediateType 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 *durationListenIntermediateType) 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 *durationListenIntermediateType) 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
|
|
}
|
|
|
|
// sourceListenIntermediateType will only have one of its values set at most
|
|
type sourceListenIntermediateType 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 *sourceListenIntermediateType) 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 *sourceListenIntermediateType) 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
|
|
}
|
|
|
|
// inboxListenIntermediateType will only have one of its values set at most
|
|
type inboxListenIntermediateType 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 *inboxListenIntermediateType) 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 *inboxListenIntermediateType) 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
|
|
}
|
|
|
|
// outboxListenIntermediateType will only have one of its values set at most
|
|
type outboxListenIntermediateType 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 *outboxListenIntermediateType) 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 *outboxListenIntermediateType) 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
|
|
}
|
|
|
|
// followingListenIntermediateType will only have one of its values set at most
|
|
type followingListenIntermediateType 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 *followingListenIntermediateType) 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 *followingListenIntermediateType) 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
|
|
}
|
|
|
|
// followersListenIntermediateType will only have one of its values set at most
|
|
type followersListenIntermediateType 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 *followersListenIntermediateType) 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 *followersListenIntermediateType) 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
|
|
}
|
|
|
|
// likedListenIntermediateType will only have one of its values set at most
|
|
type likedListenIntermediateType 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 *likedListenIntermediateType) 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 *likedListenIntermediateType) 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
|
|
}
|
|
|
|
// likesListenIntermediateType will only have one of its values set at most
|
|
type likesListenIntermediateType 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 *likesListenIntermediateType) 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 *likesListenIntermediateType) 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
|
|
}
|
|
|
|
// preferredUsernameListenIntermediateType will only have one of its values set at most
|
|
type preferredUsernameListenIntermediateType 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 *preferredUsernameListenIntermediateType) 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 *preferredUsernameListenIntermediateType) 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
|
|
}
|
|
|
|
// endpointsListenIntermediateType will only have one of its values set at most
|
|
type endpointsListenIntermediateType 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 *endpointsListenIntermediateType) 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 *endpointsListenIntermediateType) 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
|
|
}
|
|
|
|
// deserializeactorListenIntermediateType will accept a map to create a actorListenIntermediateType
|
|
func deserializeActorListenIntermediateType(in interface{}) (t *actorListenIntermediateType, err error) {
|
|
tmp := &actorListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice actorListenIntermediateType will accept a slice to create a slice of actorListenIntermediateType
|
|
func deserializeSliceActorListenIntermediateType(in []interface{}) (t []*actorListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &actorListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeactorListenIntermediateType will accept a actorListenIntermediateType to create a map
|
|
func serializeActorListenIntermediateType(t *actorListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceactorListenIntermediateType will accept a slice of actorListenIntermediateType to create a slice result
|
|
func serializeSliceActorListenIntermediateType(s []*actorListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeobjectListenIntermediateType will accept a map to create a objectListenIntermediateType
|
|
func deserializeObjectListenIntermediateType(in interface{}) (t *objectListenIntermediateType, err error) {
|
|
tmp := &objectListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice objectListenIntermediateType will accept a slice to create a slice of objectListenIntermediateType
|
|
func deserializeSliceObjectListenIntermediateType(in []interface{}) (t []*objectListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &objectListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeobjectListenIntermediateType will accept a objectListenIntermediateType to create a map
|
|
func serializeObjectListenIntermediateType(t *objectListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceobjectListenIntermediateType will accept a slice of objectListenIntermediateType to create a slice result
|
|
func serializeSliceObjectListenIntermediateType(s []*objectListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetargetListenIntermediateType will accept a map to create a targetListenIntermediateType
|
|
func deserializeTargetListenIntermediateType(in interface{}) (t *targetListenIntermediateType, err error) {
|
|
tmp := &targetListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice targetListenIntermediateType will accept a slice to create a slice of targetListenIntermediateType
|
|
func deserializeSliceTargetListenIntermediateType(in []interface{}) (t []*targetListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &targetListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetargetListenIntermediateType will accept a targetListenIntermediateType to create a map
|
|
func serializeTargetListenIntermediateType(t *targetListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetargetListenIntermediateType will accept a slice of targetListenIntermediateType to create a slice result
|
|
func serializeSliceTargetListenIntermediateType(s []*targetListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeresultListenIntermediateType will accept a map to create a resultListenIntermediateType
|
|
func deserializeResultListenIntermediateType(in interface{}) (t *resultListenIntermediateType, err error) {
|
|
tmp := &resultListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice resultListenIntermediateType will accept a slice to create a slice of resultListenIntermediateType
|
|
func deserializeSliceResultListenIntermediateType(in []interface{}) (t []*resultListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &resultListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeresultListenIntermediateType will accept a resultListenIntermediateType to create a map
|
|
func serializeResultListenIntermediateType(t *resultListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceresultListenIntermediateType will accept a slice of resultListenIntermediateType to create a slice result
|
|
func serializeSliceResultListenIntermediateType(s []*resultListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoriginListenIntermediateType will accept a map to create a originListenIntermediateType
|
|
func deserializeOriginListenIntermediateType(in interface{}) (t *originListenIntermediateType, err error) {
|
|
tmp := &originListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice originListenIntermediateType will accept a slice to create a slice of originListenIntermediateType
|
|
func deserializeSliceOriginListenIntermediateType(in []interface{}) (t []*originListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &originListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoriginListenIntermediateType will accept a originListenIntermediateType to create a map
|
|
func serializeOriginListenIntermediateType(t *originListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoriginListenIntermediateType will accept a slice of originListenIntermediateType to create a slice result
|
|
func serializeSliceOriginListenIntermediateType(s []*originListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinstrumentListenIntermediateType will accept a map to create a instrumentListenIntermediateType
|
|
func deserializeInstrumentListenIntermediateType(in interface{}) (t *instrumentListenIntermediateType, err error) {
|
|
tmp := &instrumentListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice instrumentListenIntermediateType will accept a slice to create a slice of instrumentListenIntermediateType
|
|
func deserializeSliceInstrumentListenIntermediateType(in []interface{}) (t []*instrumentListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &instrumentListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinstrumentListenIntermediateType will accept a instrumentListenIntermediateType to create a map
|
|
func serializeInstrumentListenIntermediateType(t *instrumentListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinstrumentListenIntermediateType will accept a slice of instrumentListenIntermediateType to create a slice result
|
|
func serializeSliceInstrumentListenIntermediateType(s []*instrumentListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializealtitudeListenIntermediateType will accept a map to create a altitudeListenIntermediateType
|
|
func deserializeAltitudeListenIntermediateType(in interface{}) (t *altitudeListenIntermediateType, err error) {
|
|
tmp := &altitudeListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice altitudeListenIntermediateType will accept a slice to create a slice of altitudeListenIntermediateType
|
|
func deserializeSliceAltitudeListenIntermediateType(in []interface{}) (t []*altitudeListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &altitudeListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializealtitudeListenIntermediateType will accept a altitudeListenIntermediateType to create a map
|
|
func serializeAltitudeListenIntermediateType(t *altitudeListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicealtitudeListenIntermediateType will accept a slice of altitudeListenIntermediateType to create a slice result
|
|
func serializeSliceAltitudeListenIntermediateType(s []*altitudeListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattachmentListenIntermediateType will accept a map to create a attachmentListenIntermediateType
|
|
func deserializeAttachmentListenIntermediateType(in interface{}) (t *attachmentListenIntermediateType, err error) {
|
|
tmp := &attachmentListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attachmentListenIntermediateType will accept a slice to create a slice of attachmentListenIntermediateType
|
|
func deserializeSliceAttachmentListenIntermediateType(in []interface{}) (t []*attachmentListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attachmentListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattachmentListenIntermediateType will accept a attachmentListenIntermediateType to create a map
|
|
func serializeAttachmentListenIntermediateType(t *attachmentListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattachmentListenIntermediateType will accept a slice of attachmentListenIntermediateType to create a slice result
|
|
func serializeSliceAttachmentListenIntermediateType(s []*attachmentListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattributedToListenIntermediateType will accept a map to create a attributedToListenIntermediateType
|
|
func deserializeAttributedToListenIntermediateType(in interface{}) (t *attributedToListenIntermediateType, err error) {
|
|
tmp := &attributedToListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attributedToListenIntermediateType will accept a slice to create a slice of attributedToListenIntermediateType
|
|
func deserializeSliceAttributedToListenIntermediateType(in []interface{}) (t []*attributedToListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attributedToListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattributedToListenIntermediateType will accept a attributedToListenIntermediateType to create a map
|
|
func serializeAttributedToListenIntermediateType(t *attributedToListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattributedToListenIntermediateType will accept a slice of attributedToListenIntermediateType to create a slice result
|
|
func serializeSliceAttributedToListenIntermediateType(s []*attributedToListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeaudienceListenIntermediateType will accept a map to create a audienceListenIntermediateType
|
|
func deserializeAudienceListenIntermediateType(in interface{}) (t *audienceListenIntermediateType, err error) {
|
|
tmp := &audienceListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice audienceListenIntermediateType will accept a slice to create a slice of audienceListenIntermediateType
|
|
func deserializeSliceAudienceListenIntermediateType(in []interface{}) (t []*audienceListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &audienceListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeaudienceListenIntermediateType will accept a audienceListenIntermediateType to create a map
|
|
func serializeAudienceListenIntermediateType(t *audienceListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceaudienceListenIntermediateType will accept a slice of audienceListenIntermediateType to create a slice result
|
|
func serializeSliceAudienceListenIntermediateType(s []*audienceListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontentListenIntermediateType will accept a map to create a contentListenIntermediateType
|
|
func deserializeContentListenIntermediateType(in interface{}) (t *contentListenIntermediateType, err error) {
|
|
tmp := &contentListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contentListenIntermediateType will accept a slice to create a slice of contentListenIntermediateType
|
|
func deserializeSliceContentListenIntermediateType(in []interface{}) (t []*contentListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contentListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontentListenIntermediateType will accept a contentListenIntermediateType to create a map
|
|
func serializeContentListenIntermediateType(t *contentListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontentListenIntermediateType will accept a slice of contentListenIntermediateType to create a slice result
|
|
func serializeSliceContentListenIntermediateType(s []*contentListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontextListenIntermediateType will accept a map to create a contextListenIntermediateType
|
|
func deserializeContextListenIntermediateType(in interface{}) (t *contextListenIntermediateType, err error) {
|
|
tmp := &contextListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contextListenIntermediateType will accept a slice to create a slice of contextListenIntermediateType
|
|
func deserializeSliceContextListenIntermediateType(in []interface{}) (t []*contextListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contextListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontextListenIntermediateType will accept a contextListenIntermediateType to create a map
|
|
func serializeContextListenIntermediateType(t *contextListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontextListenIntermediateType will accept a slice of contextListenIntermediateType to create a slice result
|
|
func serializeSliceContextListenIntermediateType(s []*contextListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializenameListenIntermediateType will accept a map to create a nameListenIntermediateType
|
|
func deserializeNameListenIntermediateType(in interface{}) (t *nameListenIntermediateType, err error) {
|
|
tmp := &nameListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice nameListenIntermediateType will accept a slice to create a slice of nameListenIntermediateType
|
|
func deserializeSliceNameListenIntermediateType(in []interface{}) (t []*nameListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &nameListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializenameListenIntermediateType will accept a nameListenIntermediateType to create a map
|
|
func serializeNameListenIntermediateType(t *nameListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicenameListenIntermediateType will accept a slice of nameListenIntermediateType to create a slice result
|
|
func serializeSliceNameListenIntermediateType(s []*nameListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendTimeListenIntermediateType will accept a map to create a endTimeListenIntermediateType
|
|
func deserializeEndTimeListenIntermediateType(in interface{}) (t *endTimeListenIntermediateType, err error) {
|
|
tmp := &endTimeListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endTimeListenIntermediateType will accept a slice to create a slice of endTimeListenIntermediateType
|
|
func deserializeSliceEndTimeListenIntermediateType(in []interface{}) (t []*endTimeListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endTimeListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendTimeListenIntermediateType will accept a endTimeListenIntermediateType to create a map
|
|
func serializeEndTimeListenIntermediateType(t *endTimeListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendTimeListenIntermediateType will accept a slice of endTimeListenIntermediateType to create a slice result
|
|
func serializeSliceEndTimeListenIntermediateType(s []*endTimeListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializegeneratorListenIntermediateType will accept a map to create a generatorListenIntermediateType
|
|
func deserializeGeneratorListenIntermediateType(in interface{}) (t *generatorListenIntermediateType, err error) {
|
|
tmp := &generatorListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice generatorListenIntermediateType will accept a slice to create a slice of generatorListenIntermediateType
|
|
func deserializeSliceGeneratorListenIntermediateType(in []interface{}) (t []*generatorListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &generatorListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializegeneratorListenIntermediateType will accept a generatorListenIntermediateType to create a map
|
|
func serializeGeneratorListenIntermediateType(t *generatorListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicegeneratorListenIntermediateType will accept a slice of generatorListenIntermediateType to create a slice result
|
|
func serializeSliceGeneratorListenIntermediateType(s []*generatorListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeiconListenIntermediateType will accept a map to create a iconListenIntermediateType
|
|
func deserializeIconListenIntermediateType(in interface{}) (t *iconListenIntermediateType, err error) {
|
|
tmp := &iconListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice iconListenIntermediateType will accept a slice to create a slice of iconListenIntermediateType
|
|
func deserializeSliceIconListenIntermediateType(in []interface{}) (t []*iconListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &iconListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeiconListenIntermediateType will accept a iconListenIntermediateType to create a map
|
|
func serializeIconListenIntermediateType(t *iconListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceiconListenIntermediateType will accept a slice of iconListenIntermediateType to create a slice result
|
|
func serializeSliceIconListenIntermediateType(s []*iconListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeimageListenIntermediateType will accept a map to create a imageListenIntermediateType
|
|
func deserializeImageListenIntermediateType(in interface{}) (t *imageListenIntermediateType, err error) {
|
|
tmp := &imageListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice imageListenIntermediateType will accept a slice to create a slice of imageListenIntermediateType
|
|
func deserializeSliceImageListenIntermediateType(in []interface{}) (t []*imageListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &imageListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeimageListenIntermediateType will accept a imageListenIntermediateType to create a map
|
|
func serializeImageListenIntermediateType(t *imageListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceimageListenIntermediateType will accept a slice of imageListenIntermediateType to create a slice result
|
|
func serializeSliceImageListenIntermediateType(s []*imageListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinReplyToListenIntermediateType will accept a map to create a inReplyToListenIntermediateType
|
|
func deserializeInReplyToListenIntermediateType(in interface{}) (t *inReplyToListenIntermediateType, err error) {
|
|
tmp := &inReplyToListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inReplyToListenIntermediateType will accept a slice to create a slice of inReplyToListenIntermediateType
|
|
func deserializeSliceInReplyToListenIntermediateType(in []interface{}) (t []*inReplyToListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inReplyToListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinReplyToListenIntermediateType will accept a inReplyToListenIntermediateType to create a map
|
|
func serializeInReplyToListenIntermediateType(t *inReplyToListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinReplyToListenIntermediateType will accept a slice of inReplyToListenIntermediateType to create a slice result
|
|
func serializeSliceInReplyToListenIntermediateType(s []*inReplyToListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelocationListenIntermediateType will accept a map to create a locationListenIntermediateType
|
|
func deserializeLocationListenIntermediateType(in interface{}) (t *locationListenIntermediateType, err error) {
|
|
tmp := &locationListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice locationListenIntermediateType will accept a slice to create a slice of locationListenIntermediateType
|
|
func deserializeSliceLocationListenIntermediateType(in []interface{}) (t []*locationListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &locationListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelocationListenIntermediateType will accept a locationListenIntermediateType to create a map
|
|
func serializeLocationListenIntermediateType(t *locationListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelocationListenIntermediateType will accept a slice of locationListenIntermediateType to create a slice result
|
|
func serializeSliceLocationListenIntermediateType(s []*locationListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreviewListenIntermediateType will accept a map to create a previewListenIntermediateType
|
|
func deserializePreviewListenIntermediateType(in interface{}) (t *previewListenIntermediateType, err error) {
|
|
tmp := &previewListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice previewListenIntermediateType will accept a slice to create a slice of previewListenIntermediateType
|
|
func deserializeSlicePreviewListenIntermediateType(in []interface{}) (t []*previewListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &previewListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreviewListenIntermediateType will accept a previewListenIntermediateType to create a map
|
|
func serializePreviewListenIntermediateType(t *previewListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreviewListenIntermediateType will accept a slice of previewListenIntermediateType to create a slice result
|
|
func serializeSlicePreviewListenIntermediateType(s []*previewListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepublishedListenIntermediateType will accept a map to create a publishedListenIntermediateType
|
|
func deserializePublishedListenIntermediateType(in interface{}) (t *publishedListenIntermediateType, err error) {
|
|
tmp := &publishedListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice publishedListenIntermediateType will accept a slice to create a slice of publishedListenIntermediateType
|
|
func deserializeSlicePublishedListenIntermediateType(in []interface{}) (t []*publishedListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &publishedListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepublishedListenIntermediateType will accept a publishedListenIntermediateType to create a map
|
|
func serializePublishedListenIntermediateType(t *publishedListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepublishedListenIntermediateType will accept a slice of publishedListenIntermediateType to create a slice result
|
|
func serializeSlicePublishedListenIntermediateType(s []*publishedListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializerepliesListenIntermediateType will accept a map to create a repliesListenIntermediateType
|
|
func deserializeRepliesListenIntermediateType(in interface{}) (t *repliesListenIntermediateType, err error) {
|
|
tmp := &repliesListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice repliesListenIntermediateType will accept a slice to create a slice of repliesListenIntermediateType
|
|
func deserializeSliceRepliesListenIntermediateType(in []interface{}) (t []*repliesListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &repliesListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializerepliesListenIntermediateType will accept a repliesListenIntermediateType to create a map
|
|
func serializeRepliesListenIntermediateType(t *repliesListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicerepliesListenIntermediateType will accept a slice of repliesListenIntermediateType to create a slice result
|
|
func serializeSliceRepliesListenIntermediateType(s []*repliesListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializestartTimeListenIntermediateType will accept a map to create a startTimeListenIntermediateType
|
|
func deserializeStartTimeListenIntermediateType(in interface{}) (t *startTimeListenIntermediateType, err error) {
|
|
tmp := &startTimeListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice startTimeListenIntermediateType will accept a slice to create a slice of startTimeListenIntermediateType
|
|
func deserializeSliceStartTimeListenIntermediateType(in []interface{}) (t []*startTimeListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &startTimeListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializestartTimeListenIntermediateType will accept a startTimeListenIntermediateType to create a map
|
|
func serializeStartTimeListenIntermediateType(t *startTimeListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicestartTimeListenIntermediateType will accept a slice of startTimeListenIntermediateType to create a slice result
|
|
func serializeSliceStartTimeListenIntermediateType(s []*startTimeListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesummaryListenIntermediateType will accept a map to create a summaryListenIntermediateType
|
|
func deserializeSummaryListenIntermediateType(in interface{}) (t *summaryListenIntermediateType, err error) {
|
|
tmp := &summaryListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice summaryListenIntermediateType will accept a slice to create a slice of summaryListenIntermediateType
|
|
func deserializeSliceSummaryListenIntermediateType(in []interface{}) (t []*summaryListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &summaryListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesummaryListenIntermediateType will accept a summaryListenIntermediateType to create a map
|
|
func serializeSummaryListenIntermediateType(t *summaryListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesummaryListenIntermediateType will accept a slice of summaryListenIntermediateType to create a slice result
|
|
func serializeSliceSummaryListenIntermediateType(s []*summaryListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetagListenIntermediateType will accept a map to create a tagListenIntermediateType
|
|
func deserializeTagListenIntermediateType(in interface{}) (t *tagListenIntermediateType, err error) {
|
|
tmp := &tagListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice tagListenIntermediateType will accept a slice to create a slice of tagListenIntermediateType
|
|
func deserializeSliceTagListenIntermediateType(in []interface{}) (t []*tagListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &tagListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetagListenIntermediateType will accept a tagListenIntermediateType to create a map
|
|
func serializeTagListenIntermediateType(t *tagListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetagListenIntermediateType will accept a slice of tagListenIntermediateType to create a slice result
|
|
func serializeSliceTagListenIntermediateType(s []*tagListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeupdatedListenIntermediateType will accept a map to create a updatedListenIntermediateType
|
|
func deserializeUpdatedListenIntermediateType(in interface{}) (t *updatedListenIntermediateType, err error) {
|
|
tmp := &updatedListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice updatedListenIntermediateType will accept a slice to create a slice of updatedListenIntermediateType
|
|
func deserializeSliceUpdatedListenIntermediateType(in []interface{}) (t []*updatedListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &updatedListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeupdatedListenIntermediateType will accept a updatedListenIntermediateType to create a map
|
|
func serializeUpdatedListenIntermediateType(t *updatedListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceupdatedListenIntermediateType will accept a slice of updatedListenIntermediateType to create a slice result
|
|
func serializeSliceUpdatedListenIntermediateType(s []*updatedListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeurlListenIntermediateType will accept a map to create a urlListenIntermediateType
|
|
func deserializeUrlListenIntermediateType(in interface{}) (t *urlListenIntermediateType, err error) {
|
|
tmp := &urlListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice urlListenIntermediateType will accept a slice to create a slice of urlListenIntermediateType
|
|
func deserializeSliceUrlListenIntermediateType(in []interface{}) (t []*urlListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &urlListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeurlListenIntermediateType will accept a urlListenIntermediateType to create a map
|
|
func serializeUrlListenIntermediateType(t *urlListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceurlListenIntermediateType will accept a slice of urlListenIntermediateType to create a slice result
|
|
func serializeSliceUrlListenIntermediateType(s []*urlListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetoListenIntermediateType will accept a map to create a toListenIntermediateType
|
|
func deserializeToListenIntermediateType(in interface{}) (t *toListenIntermediateType, err error) {
|
|
tmp := &toListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice toListenIntermediateType will accept a slice to create a slice of toListenIntermediateType
|
|
func deserializeSliceToListenIntermediateType(in []interface{}) (t []*toListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &toListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetoListenIntermediateType will accept a toListenIntermediateType to create a map
|
|
func serializeToListenIntermediateType(t *toListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetoListenIntermediateType will accept a slice of toListenIntermediateType to create a slice result
|
|
func serializeSliceToListenIntermediateType(s []*toListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebtoListenIntermediateType will accept a map to create a btoListenIntermediateType
|
|
func deserializeBtoListenIntermediateType(in interface{}) (t *btoListenIntermediateType, err error) {
|
|
tmp := &btoListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice btoListenIntermediateType will accept a slice to create a slice of btoListenIntermediateType
|
|
func deserializeSliceBtoListenIntermediateType(in []interface{}) (t []*btoListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &btoListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebtoListenIntermediateType will accept a btoListenIntermediateType to create a map
|
|
func serializeBtoListenIntermediateType(t *btoListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebtoListenIntermediateType will accept a slice of btoListenIntermediateType to create a slice result
|
|
func serializeSliceBtoListenIntermediateType(s []*btoListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeccListenIntermediateType will accept a map to create a ccListenIntermediateType
|
|
func deserializeCcListenIntermediateType(in interface{}) (t *ccListenIntermediateType, err error) {
|
|
tmp := &ccListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice ccListenIntermediateType will accept a slice to create a slice of ccListenIntermediateType
|
|
func deserializeSliceCcListenIntermediateType(in []interface{}) (t []*ccListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &ccListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeccListenIntermediateType will accept a ccListenIntermediateType to create a map
|
|
func serializeCcListenIntermediateType(t *ccListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceccListenIntermediateType will accept a slice of ccListenIntermediateType to create a slice result
|
|
func serializeSliceCcListenIntermediateType(s []*ccListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebccListenIntermediateType will accept a map to create a bccListenIntermediateType
|
|
func deserializeBccListenIntermediateType(in interface{}) (t *bccListenIntermediateType, err error) {
|
|
tmp := &bccListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice bccListenIntermediateType will accept a slice to create a slice of bccListenIntermediateType
|
|
func deserializeSliceBccListenIntermediateType(in []interface{}) (t []*bccListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &bccListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebccListenIntermediateType will accept a bccListenIntermediateType to create a map
|
|
func serializeBccListenIntermediateType(t *bccListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebccListenIntermediateType will accept a slice of bccListenIntermediateType to create a slice result
|
|
func serializeSliceBccListenIntermediateType(s []*bccListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializemediaTypeListenIntermediateType will accept a map to create a mediaTypeListenIntermediateType
|
|
func deserializeMediaTypeListenIntermediateType(in interface{}) (t *mediaTypeListenIntermediateType, err error) {
|
|
tmp := &mediaTypeListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice mediaTypeListenIntermediateType will accept a slice to create a slice of mediaTypeListenIntermediateType
|
|
func deserializeSliceMediaTypeListenIntermediateType(in []interface{}) (t []*mediaTypeListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &mediaTypeListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializemediaTypeListenIntermediateType will accept a mediaTypeListenIntermediateType to create a map
|
|
func serializeMediaTypeListenIntermediateType(t *mediaTypeListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicemediaTypeListenIntermediateType will accept a slice of mediaTypeListenIntermediateType to create a slice result
|
|
func serializeSliceMediaTypeListenIntermediateType(s []*mediaTypeListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializedurationListenIntermediateType will accept a map to create a durationListenIntermediateType
|
|
func deserializeDurationListenIntermediateType(in interface{}) (t *durationListenIntermediateType, err error) {
|
|
tmp := &durationListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice durationListenIntermediateType will accept a slice to create a slice of durationListenIntermediateType
|
|
func deserializeSliceDurationListenIntermediateType(in []interface{}) (t []*durationListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &durationListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializedurationListenIntermediateType will accept a durationListenIntermediateType to create a map
|
|
func serializeDurationListenIntermediateType(t *durationListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicedurationListenIntermediateType will accept a slice of durationListenIntermediateType to create a slice result
|
|
func serializeSliceDurationListenIntermediateType(s []*durationListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesourceListenIntermediateType will accept a map to create a sourceListenIntermediateType
|
|
func deserializeSourceListenIntermediateType(in interface{}) (t *sourceListenIntermediateType, err error) {
|
|
tmp := &sourceListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice sourceListenIntermediateType will accept a slice to create a slice of sourceListenIntermediateType
|
|
func deserializeSliceSourceListenIntermediateType(in []interface{}) (t []*sourceListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &sourceListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesourceListenIntermediateType will accept a sourceListenIntermediateType to create a map
|
|
func serializeSourceListenIntermediateType(t *sourceListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesourceListenIntermediateType will accept a slice of sourceListenIntermediateType to create a slice result
|
|
func serializeSliceSourceListenIntermediateType(s []*sourceListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinboxListenIntermediateType will accept a map to create a inboxListenIntermediateType
|
|
func deserializeInboxListenIntermediateType(in interface{}) (t *inboxListenIntermediateType, err error) {
|
|
tmp := &inboxListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inboxListenIntermediateType will accept a slice to create a slice of inboxListenIntermediateType
|
|
func deserializeSliceInboxListenIntermediateType(in []interface{}) (t []*inboxListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inboxListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinboxListenIntermediateType will accept a inboxListenIntermediateType to create a map
|
|
func serializeInboxListenIntermediateType(t *inboxListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinboxListenIntermediateType will accept a slice of inboxListenIntermediateType to create a slice result
|
|
func serializeSliceInboxListenIntermediateType(s []*inboxListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoutboxListenIntermediateType will accept a map to create a outboxListenIntermediateType
|
|
func deserializeOutboxListenIntermediateType(in interface{}) (t *outboxListenIntermediateType, err error) {
|
|
tmp := &outboxListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice outboxListenIntermediateType will accept a slice to create a slice of outboxListenIntermediateType
|
|
func deserializeSliceOutboxListenIntermediateType(in []interface{}) (t []*outboxListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &outboxListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoutboxListenIntermediateType will accept a outboxListenIntermediateType to create a map
|
|
func serializeOutboxListenIntermediateType(t *outboxListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoutboxListenIntermediateType will accept a slice of outboxListenIntermediateType to create a slice result
|
|
func serializeSliceOutboxListenIntermediateType(s []*outboxListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowingListenIntermediateType will accept a map to create a followingListenIntermediateType
|
|
func deserializeFollowingListenIntermediateType(in interface{}) (t *followingListenIntermediateType, err error) {
|
|
tmp := &followingListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followingListenIntermediateType will accept a slice to create a slice of followingListenIntermediateType
|
|
func deserializeSliceFollowingListenIntermediateType(in []interface{}) (t []*followingListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followingListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowingListenIntermediateType will accept a followingListenIntermediateType to create a map
|
|
func serializeFollowingListenIntermediateType(t *followingListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowingListenIntermediateType will accept a slice of followingListenIntermediateType to create a slice result
|
|
func serializeSliceFollowingListenIntermediateType(s []*followingListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowersListenIntermediateType will accept a map to create a followersListenIntermediateType
|
|
func deserializeFollowersListenIntermediateType(in interface{}) (t *followersListenIntermediateType, err error) {
|
|
tmp := &followersListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followersListenIntermediateType will accept a slice to create a slice of followersListenIntermediateType
|
|
func deserializeSliceFollowersListenIntermediateType(in []interface{}) (t []*followersListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followersListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowersListenIntermediateType will accept a followersListenIntermediateType to create a map
|
|
func serializeFollowersListenIntermediateType(t *followersListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowersListenIntermediateType will accept a slice of followersListenIntermediateType to create a slice result
|
|
func serializeSliceFollowersListenIntermediateType(s []*followersListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikedListenIntermediateType will accept a map to create a likedListenIntermediateType
|
|
func deserializeLikedListenIntermediateType(in interface{}) (t *likedListenIntermediateType, err error) {
|
|
tmp := &likedListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likedListenIntermediateType will accept a slice to create a slice of likedListenIntermediateType
|
|
func deserializeSliceLikedListenIntermediateType(in []interface{}) (t []*likedListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likedListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikedListenIntermediateType will accept a likedListenIntermediateType to create a map
|
|
func serializeLikedListenIntermediateType(t *likedListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikedListenIntermediateType will accept a slice of likedListenIntermediateType to create a slice result
|
|
func serializeSliceLikedListenIntermediateType(s []*likedListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikesListenIntermediateType will accept a map to create a likesListenIntermediateType
|
|
func deserializeLikesListenIntermediateType(in interface{}) (t *likesListenIntermediateType, err error) {
|
|
tmp := &likesListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likesListenIntermediateType will accept a slice to create a slice of likesListenIntermediateType
|
|
func deserializeSliceLikesListenIntermediateType(in []interface{}) (t []*likesListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likesListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikesListenIntermediateType will accept a likesListenIntermediateType to create a map
|
|
func serializeLikesListenIntermediateType(t *likesListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikesListenIntermediateType will accept a slice of likesListenIntermediateType to create a slice result
|
|
func serializeSliceLikesListenIntermediateType(s []*likesListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreferredUsernameListenIntermediateType will accept a map to create a preferredUsernameListenIntermediateType
|
|
func deserializePreferredUsernameListenIntermediateType(in interface{}) (t *preferredUsernameListenIntermediateType, err error) {
|
|
tmp := &preferredUsernameListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice preferredUsernameListenIntermediateType will accept a slice to create a slice of preferredUsernameListenIntermediateType
|
|
func deserializeSlicePreferredUsernameListenIntermediateType(in []interface{}) (t []*preferredUsernameListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &preferredUsernameListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreferredUsernameListenIntermediateType will accept a preferredUsernameListenIntermediateType to create a map
|
|
func serializePreferredUsernameListenIntermediateType(t *preferredUsernameListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreferredUsernameListenIntermediateType will accept a slice of preferredUsernameListenIntermediateType to create a slice result
|
|
func serializeSlicePreferredUsernameListenIntermediateType(s []*preferredUsernameListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendpointsListenIntermediateType will accept a map to create a endpointsListenIntermediateType
|
|
func deserializeEndpointsListenIntermediateType(in interface{}) (t *endpointsListenIntermediateType, err error) {
|
|
tmp := &endpointsListenIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endpointsListenIntermediateType will accept a slice to create a slice of endpointsListenIntermediateType
|
|
func deserializeSliceEndpointsListenIntermediateType(in []interface{}) (t []*endpointsListenIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endpointsListenIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendpointsListenIntermediateType will accept a endpointsListenIntermediateType to create a map
|
|
func serializeEndpointsListenIntermediateType(t *endpointsListenIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendpointsListenIntermediateType will accept a slice of endpointsListenIntermediateType to create a slice result
|
|
func serializeSliceEndpointsListenIntermediateType(s []*endpointsListenIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|