11931 行
340 KiB
Go
11931 行
340 KiB
Go
//
|
|
package vocab
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
// ActivityType is an interface for accepting types that extend from 'Activity'.
|
|
type ActivityType 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{})
|
|
}
|
|
|
|
// An Activity is a subtype of Object that describes some form of action that may happen, is currently happening, or has already happened. The Activity type itself serves as an abstract base type for all types of activities. It is important to note that the Activity type itself does not carry any specific semantics about the kind of action being taken.
|
|
type Activity struct {
|
|
// An unknown value.
|
|
unknown_ map[string]interface{}
|
|
// The 'actor' value could have multiple types and values
|
|
actor []*actorActivityIntermediateType
|
|
// The 'object' value could have multiple types and values
|
|
object []*objectActivityIntermediateType
|
|
// The 'target' value could have multiple types and values
|
|
target []*targetActivityIntermediateType
|
|
// The 'result' value could have multiple types and values
|
|
result []*resultActivityIntermediateType
|
|
// The 'origin' value could have multiple types and values
|
|
origin []*originActivityIntermediateType
|
|
// The 'instrument' value could have multiple types and values
|
|
instrument []*instrumentActivityIntermediateType
|
|
// The functional 'altitude' value could have multiple types, but only a single value
|
|
altitude *altitudeActivityIntermediateType
|
|
// The 'attachment' value could have multiple types and values
|
|
attachment []*attachmentActivityIntermediateType
|
|
// The 'attributedTo' value could have multiple types and values
|
|
attributedTo []*attributedToActivityIntermediateType
|
|
// The 'audience' value could have multiple types and values
|
|
audience []*audienceActivityIntermediateType
|
|
// The 'content' value could have multiple types and values
|
|
content []*contentActivityIntermediateType
|
|
// The 'contentMap' value holds language-specific values for property 'content'
|
|
contentMap map[string]string
|
|
// The 'context' value could have multiple types and values
|
|
context []*contextActivityIntermediateType
|
|
// The 'name' value could have multiple types and values
|
|
name []*nameActivityIntermediateType
|
|
// 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 *endTimeActivityIntermediateType
|
|
// The 'generator' value could have multiple types and values
|
|
generator []*generatorActivityIntermediateType
|
|
// The 'icon' value could have multiple types and values
|
|
icon []*iconActivityIntermediateType
|
|
// 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 []*imageActivityIntermediateType
|
|
// The 'inReplyTo' value could have multiple types and values
|
|
inReplyTo []*inReplyToActivityIntermediateType
|
|
// The 'location' value could have multiple types and values
|
|
location []*locationActivityIntermediateType
|
|
// The 'preview' value could have multiple types and values
|
|
preview []*previewActivityIntermediateType
|
|
// The functional 'published' value could have multiple types, but only a single value
|
|
published *publishedActivityIntermediateType
|
|
// The functional 'replies' value could have multiple types, but only a single value
|
|
replies *repliesActivityIntermediateType
|
|
// The functional 'startTime' value could have multiple types, but only a single value
|
|
startTime *startTimeActivityIntermediateType
|
|
// The 'summary' value could have multiple types and values
|
|
summary []*summaryActivityIntermediateType
|
|
// The 'summaryMap' value holds language-specific values for property 'summary'
|
|
summaryMap map[string]string
|
|
// The 'tag' value could have multiple types and values
|
|
tag []*tagActivityIntermediateType
|
|
// 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 *updatedActivityIntermediateType
|
|
// The 'url' value could have multiple types and values
|
|
url []*urlActivityIntermediateType
|
|
// The 'to' value could have multiple types and values
|
|
to []*toActivityIntermediateType
|
|
// The 'bto' value could have multiple types and values
|
|
bto []*btoActivityIntermediateType
|
|
// The 'cc' value could have multiple types and values
|
|
cc []*ccActivityIntermediateType
|
|
// The 'bcc' value could have multiple types and values
|
|
bcc []*bccActivityIntermediateType
|
|
// The functional 'mediaType' value could have multiple types, but only a single value
|
|
mediaType *mediaTypeActivityIntermediateType
|
|
// The functional 'duration' value could have multiple types, but only a single value
|
|
duration *durationActivityIntermediateType
|
|
// The functional 'source' value could have multiple types, but only a single value
|
|
source *sourceActivityIntermediateType
|
|
// The functional 'inbox' value could have multiple types, but only a single value
|
|
inbox *inboxActivityIntermediateType
|
|
// The functional 'outbox' value could have multiple types, but only a single value
|
|
outbox *outboxActivityIntermediateType
|
|
// The functional 'following' value could have multiple types, but only a single value
|
|
following *followingActivityIntermediateType
|
|
// The functional 'followers' value could have multiple types, but only a single value
|
|
followers *followersActivityIntermediateType
|
|
// The functional 'liked' value could have multiple types, but only a single value
|
|
liked *likedActivityIntermediateType
|
|
// The functional 'likes' value could have multiple types, but only a single value
|
|
likes *likesActivityIntermediateType
|
|
// 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 *preferredUsernameActivityIntermediateType
|
|
// 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 *endpointsActivityIntermediateType
|
|
// 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 *Activity) ActorLen() (l int) {
|
|
return len(t.actor)
|
|
|
|
}
|
|
|
|
// IsActorObject determines whether the call to GetActorObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetActorObject(index int) (v ObjectType) {
|
|
return t.actor[index].Object
|
|
|
|
}
|
|
|
|
// AppendActorObject adds to the back of actor a ObjectType type
|
|
func (t *Activity) AppendActorObject(v ObjectType) {
|
|
t.actor = append(t.actor, &actorActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependActorObject adds to the front of actor a ObjectType type
|
|
func (t *Activity) PrependActorObject(v ObjectType) {
|
|
t.actor = append([]*actorActivityIntermediateType{&actorActivityIntermediateType{Object: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetActorLink(index int) (v LinkType) {
|
|
return t.actor[index].Link
|
|
|
|
}
|
|
|
|
// AppendActorLink adds to the back of actor a LinkType type
|
|
func (t *Activity) AppendActorLink(v LinkType) {
|
|
t.actor = append(t.actor, &actorActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependActorLink adds to the front of actor a LinkType type
|
|
func (t *Activity) PrependActorLink(v LinkType) {
|
|
t.actor = append([]*actorActivityIntermediateType{&actorActivityIntermediateType{Link: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetActorIRI(index int) (v *url.URL) {
|
|
return t.actor[index].IRI
|
|
|
|
}
|
|
|
|
// AppendActorIRI adds to the back of actor a *url.URL type
|
|
func (t *Activity) AppendActorIRI(v *url.URL) {
|
|
t.actor = append(t.actor, &actorActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependActorIRI adds to the front of actor a *url.URL type
|
|
func (t *Activity) PrependActorIRI(v *url.URL) {
|
|
t.actor = append([]*actorActivityIntermediateType{&actorActivityIntermediateType{IRI: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownActor() (ok bool) {
|
|
return t.actor != nil && t.actor[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownActor returns the unknown value for actor
|
|
func (t *Activity) GetUnknownActor() (v interface{}) {
|
|
return t.actor[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownActor sets the unknown value of actor
|
|
func (t *Activity) SetUnknownActor(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &actorActivityIntermediateType{}
|
|
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 *Activity) ObjectLen() (l int) {
|
|
return len(t.object)
|
|
|
|
}
|
|
|
|
// IsObject determines whether the call to GetObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetObject(index int) (v ObjectType) {
|
|
return t.object[index].Object
|
|
|
|
}
|
|
|
|
// AppendObject adds to the back of object a ObjectType type
|
|
func (t *Activity) AppendObject(v ObjectType) {
|
|
t.object = append(t.object, &objectActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependObject adds to the front of object a ObjectType type
|
|
func (t *Activity) PrependObject(v ObjectType) {
|
|
t.object = append([]*objectActivityIntermediateType{&objectActivityIntermediateType{Object: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetObjectIRI(index int) (v *url.URL) {
|
|
return t.object[index].IRI
|
|
|
|
}
|
|
|
|
// AppendObjectIRI adds to the back of object a *url.URL type
|
|
func (t *Activity) AppendObjectIRI(v *url.URL) {
|
|
t.object = append(t.object, &objectActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependObjectIRI adds to the front of object a *url.URL type
|
|
func (t *Activity) PrependObjectIRI(v *url.URL) {
|
|
t.object = append([]*objectActivityIntermediateType{&objectActivityIntermediateType{IRI: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObjectIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownObject() (ok bool) {
|
|
return t.object != nil && t.object[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownObject returns the unknown value for object
|
|
func (t *Activity) GetUnknownObject() (v interface{}) {
|
|
return t.object[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownObject sets the unknown value of object
|
|
func (t *Activity) SetUnknownObject(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &objectActivityIntermediateType{}
|
|
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 *Activity) TargetLen() (l int) {
|
|
return len(t.target)
|
|
|
|
}
|
|
|
|
// IsTargetObject determines whether the call to GetTargetObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetTargetObject(index int) (v ObjectType) {
|
|
return t.target[index].Object
|
|
|
|
}
|
|
|
|
// AppendTargetObject adds to the back of target a ObjectType type
|
|
func (t *Activity) AppendTargetObject(v ObjectType) {
|
|
t.target = append(t.target, &targetActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTargetObject adds to the front of target a ObjectType type
|
|
func (t *Activity) PrependTargetObject(v ObjectType) {
|
|
t.target = append([]*targetActivityIntermediateType{&targetActivityIntermediateType{Object: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetTargetLink(index int) (v LinkType) {
|
|
return t.target[index].Link
|
|
|
|
}
|
|
|
|
// AppendTargetLink adds to the back of target a LinkType type
|
|
func (t *Activity) AppendTargetLink(v LinkType) {
|
|
t.target = append(t.target, &targetActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTargetLink adds to the front of target a LinkType type
|
|
func (t *Activity) PrependTargetLink(v LinkType) {
|
|
t.target = append([]*targetActivityIntermediateType{&targetActivityIntermediateType{Link: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetTargetIRI(index int) (v *url.URL) {
|
|
return t.target[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTargetIRI adds to the back of target a *url.URL type
|
|
func (t *Activity) AppendTargetIRI(v *url.URL) {
|
|
t.target = append(t.target, &targetActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTargetIRI adds to the front of target a *url.URL type
|
|
func (t *Activity) PrependTargetIRI(v *url.URL) {
|
|
t.target = append([]*targetActivityIntermediateType{&targetActivityIntermediateType{IRI: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownTarget() (ok bool) {
|
|
return t.target != nil && t.target[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTarget returns the unknown value for target
|
|
func (t *Activity) GetUnknownTarget() (v interface{}) {
|
|
return t.target[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTarget sets the unknown value of target
|
|
func (t *Activity) SetUnknownTarget(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &targetActivityIntermediateType{}
|
|
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 *Activity) ResultLen() (l int) {
|
|
return len(t.result)
|
|
|
|
}
|
|
|
|
// IsResultObject determines whether the call to GetResultObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetResultObject(index int) (v ObjectType) {
|
|
return t.result[index].Object
|
|
|
|
}
|
|
|
|
// AppendResultObject adds to the back of result a ObjectType type
|
|
func (t *Activity) AppendResultObject(v ObjectType) {
|
|
t.result = append(t.result, &resultActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependResultObject adds to the front of result a ObjectType type
|
|
func (t *Activity) PrependResultObject(v ObjectType) {
|
|
t.result = append([]*resultActivityIntermediateType{&resultActivityIntermediateType{Object: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetResultLink(index int) (v LinkType) {
|
|
return t.result[index].Link
|
|
|
|
}
|
|
|
|
// AppendResultLink adds to the back of result a LinkType type
|
|
func (t *Activity) AppendResultLink(v LinkType) {
|
|
t.result = append(t.result, &resultActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependResultLink adds to the front of result a LinkType type
|
|
func (t *Activity) PrependResultLink(v LinkType) {
|
|
t.result = append([]*resultActivityIntermediateType{&resultActivityIntermediateType{Link: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetResultIRI(index int) (v *url.URL) {
|
|
return t.result[index].IRI
|
|
|
|
}
|
|
|
|
// AppendResultIRI adds to the back of result a *url.URL type
|
|
func (t *Activity) AppendResultIRI(v *url.URL) {
|
|
t.result = append(t.result, &resultActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependResultIRI adds to the front of result a *url.URL type
|
|
func (t *Activity) PrependResultIRI(v *url.URL) {
|
|
t.result = append([]*resultActivityIntermediateType{&resultActivityIntermediateType{IRI: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownResult() (ok bool) {
|
|
return t.result != nil && t.result[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownResult returns the unknown value for result
|
|
func (t *Activity) GetUnknownResult() (v interface{}) {
|
|
return t.result[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownResult sets the unknown value of result
|
|
func (t *Activity) SetUnknownResult(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &resultActivityIntermediateType{}
|
|
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 *Activity) OriginLen() (l int) {
|
|
return len(t.origin)
|
|
|
|
}
|
|
|
|
// IsOriginObject determines whether the call to GetOriginObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetOriginObject(index int) (v ObjectType) {
|
|
return t.origin[index].Object
|
|
|
|
}
|
|
|
|
// AppendOriginObject adds to the back of origin a ObjectType type
|
|
func (t *Activity) AppendOriginObject(v ObjectType) {
|
|
t.origin = append(t.origin, &originActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependOriginObject adds to the front of origin a ObjectType type
|
|
func (t *Activity) PrependOriginObject(v ObjectType) {
|
|
t.origin = append([]*originActivityIntermediateType{&originActivityIntermediateType{Object: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetOriginLink(index int) (v LinkType) {
|
|
return t.origin[index].Link
|
|
|
|
}
|
|
|
|
// AppendOriginLink adds to the back of origin a LinkType type
|
|
func (t *Activity) AppendOriginLink(v LinkType) {
|
|
t.origin = append(t.origin, &originActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependOriginLink adds to the front of origin a LinkType type
|
|
func (t *Activity) PrependOriginLink(v LinkType) {
|
|
t.origin = append([]*originActivityIntermediateType{&originActivityIntermediateType{Link: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetOriginIRI(index int) (v *url.URL) {
|
|
return t.origin[index].IRI
|
|
|
|
}
|
|
|
|
// AppendOriginIRI adds to the back of origin a *url.URL type
|
|
func (t *Activity) AppendOriginIRI(v *url.URL) {
|
|
t.origin = append(t.origin, &originActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependOriginIRI adds to the front of origin a *url.URL type
|
|
func (t *Activity) PrependOriginIRI(v *url.URL) {
|
|
t.origin = append([]*originActivityIntermediateType{&originActivityIntermediateType{IRI: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownOrigin() (ok bool) {
|
|
return t.origin != nil && t.origin[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOrigin returns the unknown value for origin
|
|
func (t *Activity) GetUnknownOrigin() (v interface{}) {
|
|
return t.origin[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOrigin sets the unknown value of origin
|
|
func (t *Activity) SetUnknownOrigin(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &originActivityIntermediateType{}
|
|
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 *Activity) InstrumentLen() (l int) {
|
|
return len(t.instrument)
|
|
|
|
}
|
|
|
|
// IsInstrumentObject determines whether the call to GetInstrumentObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetInstrumentObject(index int) (v ObjectType) {
|
|
return t.instrument[index].Object
|
|
|
|
}
|
|
|
|
// AppendInstrumentObject adds to the back of instrument a ObjectType type
|
|
func (t *Activity) AppendInstrumentObject(v ObjectType) {
|
|
t.instrument = append(t.instrument, &instrumentActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentObject adds to the front of instrument a ObjectType type
|
|
func (t *Activity) PrependInstrumentObject(v ObjectType) {
|
|
t.instrument = append([]*instrumentActivityIntermediateType{&instrumentActivityIntermediateType{Object: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetInstrumentLink(index int) (v LinkType) {
|
|
return t.instrument[index].Link
|
|
|
|
}
|
|
|
|
// AppendInstrumentLink adds to the back of instrument a LinkType type
|
|
func (t *Activity) AppendInstrumentLink(v LinkType) {
|
|
t.instrument = append(t.instrument, &instrumentActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentLink adds to the front of instrument a LinkType type
|
|
func (t *Activity) PrependInstrumentLink(v LinkType) {
|
|
t.instrument = append([]*instrumentActivityIntermediateType{&instrumentActivityIntermediateType{Link: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetInstrumentIRI(index int) (v *url.URL) {
|
|
return t.instrument[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInstrumentIRI adds to the back of instrument a *url.URL type
|
|
func (t *Activity) AppendInstrumentIRI(v *url.URL) {
|
|
t.instrument = append(t.instrument, &instrumentActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentIRI adds to the front of instrument a *url.URL type
|
|
func (t *Activity) PrependInstrumentIRI(v *url.URL) {
|
|
t.instrument = append([]*instrumentActivityIntermediateType{&instrumentActivityIntermediateType{IRI: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownInstrument() (ok bool) {
|
|
return t.instrument != nil && t.instrument[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInstrument returns the unknown value for instrument
|
|
func (t *Activity) GetUnknownInstrument() (v interface{}) {
|
|
return t.instrument[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInstrument sets the unknown value of instrument
|
|
func (t *Activity) SetUnknownInstrument(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &instrumentActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.instrument = append(t.instrument, tmp)
|
|
|
|
}
|
|
|
|
// IsAltitude determines whether the call to GetAltitude is safe
|
|
func (t *Activity) IsAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.float != nil
|
|
|
|
}
|
|
|
|
// GetAltitude returns the value safely if IsAltitude returned true
|
|
func (t *Activity) GetAltitude() (v float64) {
|
|
return *t.altitude.float
|
|
|
|
}
|
|
|
|
// SetAltitude sets the value of altitude to be of float64 type
|
|
func (t *Activity) SetAltitude(v float64) {
|
|
t.altitude = &altitudeActivityIntermediateType{float: &v}
|
|
|
|
}
|
|
|
|
// IsAltitudeIRI determines whether the call to GetAltitudeIRI is safe
|
|
func (t *Activity) IsAltitudeIRI() (ok bool) {
|
|
return t.altitude != nil && t.altitude.IRI != nil
|
|
|
|
}
|
|
|
|
// GetAltitudeIRI returns the value safely if IsAltitudeIRI returned true
|
|
func (t *Activity) GetAltitudeIRI() (v *url.URL) {
|
|
return t.altitude.IRI
|
|
|
|
}
|
|
|
|
// SetAltitudeIRI sets the value of altitude to be of *url.URL type
|
|
func (t *Activity) SetAltitudeIRI(v *url.URL) {
|
|
t.altitude = &altitudeActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownAltitude determines whether the call to GetUnknownAltitude is safe
|
|
func (t *Activity) HasUnknownAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAltitude returns the unknown value for altitude
|
|
func (t *Activity) GetUnknownAltitude() (v interface{}) {
|
|
return t.altitude.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAltitude sets the unknown value of altitude
|
|
func (t *Activity) SetUnknownAltitude(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &altitudeActivityIntermediateType{}
|
|
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 *Activity) AttachmentLen() (l int) {
|
|
return len(t.attachment)
|
|
|
|
}
|
|
|
|
// IsAttachmentObject determines whether the call to GetAttachmentObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetAttachmentObject(index int) (v ObjectType) {
|
|
return t.attachment[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttachmentObject adds to the back of attachment a ObjectType type
|
|
func (t *Activity) AppendAttachmentObject(v ObjectType) {
|
|
t.attachment = append(t.attachment, &attachmentActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentObject adds to the front of attachment a ObjectType type
|
|
func (t *Activity) PrependAttachmentObject(v ObjectType) {
|
|
t.attachment = append([]*attachmentActivityIntermediateType{&attachmentActivityIntermediateType{Object: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetAttachmentLink(index int) (v LinkType) {
|
|
return t.attachment[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttachmentLink adds to the back of attachment a LinkType type
|
|
func (t *Activity) AppendAttachmentLink(v LinkType) {
|
|
t.attachment = append(t.attachment, &attachmentActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentLink adds to the front of attachment a LinkType type
|
|
func (t *Activity) PrependAttachmentLink(v LinkType) {
|
|
t.attachment = append([]*attachmentActivityIntermediateType{&attachmentActivityIntermediateType{Link: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetAttachmentIRI(index int) (v *url.URL) {
|
|
return t.attachment[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttachmentIRI adds to the back of attachment a *url.URL type
|
|
func (t *Activity) AppendAttachmentIRI(v *url.URL) {
|
|
t.attachment = append(t.attachment, &attachmentActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentIRI adds to the front of attachment a *url.URL type
|
|
func (t *Activity) PrependAttachmentIRI(v *url.URL) {
|
|
t.attachment = append([]*attachmentActivityIntermediateType{&attachmentActivityIntermediateType{IRI: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownAttachment() (ok bool) {
|
|
return t.attachment != nil && t.attachment[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttachment returns the unknown value for attachment
|
|
func (t *Activity) GetUnknownAttachment() (v interface{}) {
|
|
return t.attachment[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttachment sets the unknown value of attachment
|
|
func (t *Activity) SetUnknownAttachment(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attachmentActivityIntermediateType{}
|
|
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 *Activity) AttributedToLen() (l int) {
|
|
return len(t.attributedTo)
|
|
|
|
}
|
|
|
|
// IsAttributedToObject determines whether the call to GetAttributedToObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetAttributedToObject(index int) (v ObjectType) {
|
|
return t.attributedTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttributedToObject adds to the back of attributedTo a ObjectType type
|
|
func (t *Activity) AppendAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToObject adds to the front of attributedTo a ObjectType type
|
|
func (t *Activity) PrependAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append([]*attributedToActivityIntermediateType{&attributedToActivityIntermediateType{Object: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetAttributedToLink(index int) (v LinkType) {
|
|
return t.attributedTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttributedToLink adds to the back of attributedTo a LinkType type
|
|
func (t *Activity) AppendAttributedToLink(v LinkType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToLink adds to the front of attributedTo a LinkType type
|
|
func (t *Activity) PrependAttributedToLink(v LinkType) {
|
|
t.attributedTo = append([]*attributedToActivityIntermediateType{&attributedToActivityIntermediateType{Link: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetAttributedToIRI(index int) (v *url.URL) {
|
|
return t.attributedTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttributedToIRI adds to the back of attributedTo a *url.URL type
|
|
func (t *Activity) AppendAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToIRI adds to the front of attributedTo a *url.URL type
|
|
func (t *Activity) PrependAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append([]*attributedToActivityIntermediateType{&attributedToActivityIntermediateType{IRI: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownAttributedTo() (ok bool) {
|
|
return t.attributedTo != nil && t.attributedTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttributedTo returns the unknown value for attributedTo
|
|
func (t *Activity) GetUnknownAttributedTo() (v interface{}) {
|
|
return t.attributedTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttributedTo sets the unknown value of attributedTo
|
|
func (t *Activity) SetUnknownAttributedTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attributedToActivityIntermediateType{}
|
|
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 *Activity) AudienceLen() (l int) {
|
|
return len(t.audience)
|
|
|
|
}
|
|
|
|
// IsAudienceObject determines whether the call to GetAudienceObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetAudienceObject(index int) (v ObjectType) {
|
|
return t.audience[index].Object
|
|
|
|
}
|
|
|
|
// AppendAudienceObject adds to the back of audience a ObjectType type
|
|
func (t *Activity) AppendAudienceObject(v ObjectType) {
|
|
t.audience = append(t.audience, &audienceActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceObject adds to the front of audience a ObjectType type
|
|
func (t *Activity) PrependAudienceObject(v ObjectType) {
|
|
t.audience = append([]*audienceActivityIntermediateType{&audienceActivityIntermediateType{Object: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetAudienceLink(index int) (v LinkType) {
|
|
return t.audience[index].Link
|
|
|
|
}
|
|
|
|
// AppendAudienceLink adds to the back of audience a LinkType type
|
|
func (t *Activity) AppendAudienceLink(v LinkType) {
|
|
t.audience = append(t.audience, &audienceActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceLink adds to the front of audience a LinkType type
|
|
func (t *Activity) PrependAudienceLink(v LinkType) {
|
|
t.audience = append([]*audienceActivityIntermediateType{&audienceActivityIntermediateType{Link: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetAudienceIRI(index int) (v *url.URL) {
|
|
return t.audience[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAudienceIRI adds to the back of audience a *url.URL type
|
|
func (t *Activity) AppendAudienceIRI(v *url.URL) {
|
|
t.audience = append(t.audience, &audienceActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceIRI adds to the front of audience a *url.URL type
|
|
func (t *Activity) PrependAudienceIRI(v *url.URL) {
|
|
t.audience = append([]*audienceActivityIntermediateType{&audienceActivityIntermediateType{IRI: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownAudience() (ok bool) {
|
|
return t.audience != nil && t.audience[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAudience returns the unknown value for audience
|
|
func (t *Activity) GetUnknownAudience() (v interface{}) {
|
|
return t.audience[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAudience sets the unknown value of audience
|
|
func (t *Activity) SetUnknownAudience(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &audienceActivityIntermediateType{}
|
|
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 *Activity) ContentLen() (l int) {
|
|
return len(t.content)
|
|
|
|
}
|
|
|
|
// IsContentString determines whether the call to GetContentString is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetContentString(index int) (v string) {
|
|
return *t.content[index].stringName
|
|
|
|
}
|
|
|
|
// AppendContentString adds to the back of content a string type
|
|
func (t *Activity) AppendContentString(v string) {
|
|
t.content = append(t.content, &contentActivityIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependContentString adds to the front of content a string type
|
|
func (t *Activity) PrependContentString(v string) {
|
|
t.content = append([]*contentActivityIntermediateType{&contentActivityIntermediateType{stringName: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentString deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetContentLangString(index int) (v string) {
|
|
return *t.content[index].langString
|
|
|
|
}
|
|
|
|
// AppendContentLangString adds to the back of content a string type
|
|
func (t *Activity) AppendContentLangString(v string) {
|
|
t.content = append(t.content, &contentActivityIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependContentLangString adds to the front of content a string type
|
|
func (t *Activity) PrependContentLangString(v string) {
|
|
t.content = append([]*contentActivityIntermediateType{&contentActivityIntermediateType{langString: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentLangString deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetContentIRI(index int) (v *url.URL) {
|
|
return t.content[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContentIRI adds to the back of content a *url.URL type
|
|
func (t *Activity) AppendContentIRI(v *url.URL) {
|
|
t.content = append(t.content, &contentActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContentIRI adds to the front of content a *url.URL type
|
|
func (t *Activity) PrependContentIRI(v *url.URL) {
|
|
t.content = append([]*contentActivityIntermediateType{&contentActivityIntermediateType{IRI: v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownContent() (ok bool) {
|
|
return t.content != nil && t.content[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContent returns the unknown value for content
|
|
func (t *Activity) GetUnknownContent() (v interface{}) {
|
|
return t.content[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContent sets the unknown value of content
|
|
func (t *Activity) SetUnknownContent(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contentActivityIntermediateType{}
|
|
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 *Activity) 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 *Activity) 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 *Activity) 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 *Activity) ContextLen() (l int) {
|
|
return len(t.context)
|
|
|
|
}
|
|
|
|
// IsContextObject determines whether the call to GetContextObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetContextObject(index int) (v ObjectType) {
|
|
return t.context[index].Object
|
|
|
|
}
|
|
|
|
// AppendContextObject adds to the back of context a ObjectType type
|
|
func (t *Activity) AppendContextObject(v ObjectType) {
|
|
t.context = append(t.context, &contextActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependContextObject adds to the front of context a ObjectType type
|
|
func (t *Activity) PrependContextObject(v ObjectType) {
|
|
t.context = append([]*contextActivityIntermediateType{&contextActivityIntermediateType{Object: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetContextLink(index int) (v LinkType) {
|
|
return t.context[index].Link
|
|
|
|
}
|
|
|
|
// AppendContextLink adds to the back of context a LinkType type
|
|
func (t *Activity) AppendContextLink(v LinkType) {
|
|
t.context = append(t.context, &contextActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependContextLink adds to the front of context a LinkType type
|
|
func (t *Activity) PrependContextLink(v LinkType) {
|
|
t.context = append([]*contextActivityIntermediateType{&contextActivityIntermediateType{Link: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetContextIRI(index int) (v *url.URL) {
|
|
return t.context[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContextIRI adds to the back of context a *url.URL type
|
|
func (t *Activity) AppendContextIRI(v *url.URL) {
|
|
t.context = append(t.context, &contextActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContextIRI adds to the front of context a *url.URL type
|
|
func (t *Activity) PrependContextIRI(v *url.URL) {
|
|
t.context = append([]*contextActivityIntermediateType{&contextActivityIntermediateType{IRI: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownContext() (ok bool) {
|
|
return t.context != nil && t.context[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContext returns the unknown value for context
|
|
func (t *Activity) GetUnknownContext() (v interface{}) {
|
|
return t.context[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContext sets the unknown value of context
|
|
func (t *Activity) SetUnknownContext(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contextActivityIntermediateType{}
|
|
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 *Activity) NameLen() (l int) {
|
|
return len(t.name)
|
|
|
|
}
|
|
|
|
// IsNameString determines whether the call to GetNameString is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetNameString(index int) (v string) {
|
|
return *t.name[index].stringName
|
|
|
|
}
|
|
|
|
// AppendNameString adds to the back of name a string type
|
|
func (t *Activity) AppendNameString(v string) {
|
|
t.name = append(t.name, &nameActivityIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependNameString adds to the front of name a string type
|
|
func (t *Activity) PrependNameString(v string) {
|
|
t.name = append([]*nameActivityIntermediateType{&nameActivityIntermediateType{stringName: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameString deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetNameLangString(index int) (v string) {
|
|
return *t.name[index].langString
|
|
|
|
}
|
|
|
|
// AppendNameLangString adds to the back of name a string type
|
|
func (t *Activity) AppendNameLangString(v string) {
|
|
t.name = append(t.name, &nameActivityIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependNameLangString adds to the front of name a string type
|
|
func (t *Activity) PrependNameLangString(v string) {
|
|
t.name = append([]*nameActivityIntermediateType{&nameActivityIntermediateType{langString: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameLangString deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetNameIRI(index int) (v *url.URL) {
|
|
return t.name[index].IRI
|
|
|
|
}
|
|
|
|
// AppendNameIRI adds to the back of name a *url.URL type
|
|
func (t *Activity) AppendNameIRI(v *url.URL) {
|
|
t.name = append(t.name, &nameActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependNameIRI adds to the front of name a *url.URL type
|
|
func (t *Activity) PrependNameIRI(v *url.URL) {
|
|
t.name = append([]*nameActivityIntermediateType{&nameActivityIntermediateType{IRI: v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownName() (ok bool) {
|
|
return t.name != nil && t.name[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownName returns the unknown value for name
|
|
func (t *Activity) GetUnknownName() (v interface{}) {
|
|
return t.name[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownName sets the unknown value of name
|
|
func (t *Activity) SetUnknownName(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &nameActivityIntermediateType{}
|
|
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 *Activity) 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 *Activity) 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 *Activity) 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 *Activity) IsEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetEndTime returns the value safely if IsEndTime returned true
|
|
func (t *Activity) GetEndTime() (v time.Time) {
|
|
return *t.endTime.dateTime
|
|
|
|
}
|
|
|
|
// SetEndTime sets the value of endTime to be of time.Time type
|
|
func (t *Activity) SetEndTime(v time.Time) {
|
|
t.endTime = &endTimeActivityIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsEndTimeIRI determines whether the call to GetEndTimeIRI is safe
|
|
func (t *Activity) IsEndTimeIRI() (ok bool) {
|
|
return t.endTime != nil && t.endTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndTimeIRI returns the value safely if IsEndTimeIRI returned true
|
|
func (t *Activity) GetEndTimeIRI() (v *url.URL) {
|
|
return t.endTime.IRI
|
|
|
|
}
|
|
|
|
// SetEndTimeIRI sets the value of endTime to be of *url.URL type
|
|
func (t *Activity) SetEndTimeIRI(v *url.URL) {
|
|
t.endTime = &endTimeActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndTime determines whether the call to GetUnknownEndTime is safe
|
|
func (t *Activity) HasUnknownEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndTime returns the unknown value for endTime
|
|
func (t *Activity) GetUnknownEndTime() (v interface{}) {
|
|
return t.endTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndTime sets the unknown value of endTime
|
|
func (t *Activity) SetUnknownEndTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endTimeActivityIntermediateType{}
|
|
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 *Activity) GeneratorLen() (l int) {
|
|
return len(t.generator)
|
|
|
|
}
|
|
|
|
// IsGeneratorObject determines whether the call to GetGeneratorObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetGeneratorObject(index int) (v ObjectType) {
|
|
return t.generator[index].Object
|
|
|
|
}
|
|
|
|
// AppendGeneratorObject adds to the back of generator a ObjectType type
|
|
func (t *Activity) AppendGeneratorObject(v ObjectType) {
|
|
t.generator = append(t.generator, &generatorActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorObject adds to the front of generator a ObjectType type
|
|
func (t *Activity) PrependGeneratorObject(v ObjectType) {
|
|
t.generator = append([]*generatorActivityIntermediateType{&generatorActivityIntermediateType{Object: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetGeneratorLink(index int) (v LinkType) {
|
|
return t.generator[index].Link
|
|
|
|
}
|
|
|
|
// AppendGeneratorLink adds to the back of generator a LinkType type
|
|
func (t *Activity) AppendGeneratorLink(v LinkType) {
|
|
t.generator = append(t.generator, &generatorActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorLink adds to the front of generator a LinkType type
|
|
func (t *Activity) PrependGeneratorLink(v LinkType) {
|
|
t.generator = append([]*generatorActivityIntermediateType{&generatorActivityIntermediateType{Link: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetGeneratorIRI(index int) (v *url.URL) {
|
|
return t.generator[index].IRI
|
|
|
|
}
|
|
|
|
// AppendGeneratorIRI adds to the back of generator a *url.URL type
|
|
func (t *Activity) AppendGeneratorIRI(v *url.URL) {
|
|
t.generator = append(t.generator, &generatorActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorIRI adds to the front of generator a *url.URL type
|
|
func (t *Activity) PrependGeneratorIRI(v *url.URL) {
|
|
t.generator = append([]*generatorActivityIntermediateType{&generatorActivityIntermediateType{IRI: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownGenerator() (ok bool) {
|
|
return t.generator != nil && t.generator[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownGenerator returns the unknown value for generator
|
|
func (t *Activity) GetUnknownGenerator() (v interface{}) {
|
|
return t.generator[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownGenerator sets the unknown value of generator
|
|
func (t *Activity) SetUnknownGenerator(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &generatorActivityIntermediateType{}
|
|
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 *Activity) IconLen() (l int) {
|
|
return len(t.icon)
|
|
|
|
}
|
|
|
|
// IsIconImage determines whether the call to GetIconImage is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetIconImage(index int) (v ImageType) {
|
|
return t.icon[index].Image
|
|
|
|
}
|
|
|
|
// AppendIconImage adds to the back of icon a ImageType type
|
|
func (t *Activity) AppendIconImage(v ImageType) {
|
|
t.icon = append(t.icon, &iconActivityIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependIconImage adds to the front of icon a ImageType type
|
|
func (t *Activity) PrependIconImage(v ImageType) {
|
|
t.icon = append([]*iconActivityIntermediateType{&iconActivityIntermediateType{Image: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconImage deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetIconLink(index int) (v LinkType) {
|
|
return t.icon[index].Link
|
|
|
|
}
|
|
|
|
// AppendIconLink adds to the back of icon a LinkType type
|
|
func (t *Activity) AppendIconLink(v LinkType) {
|
|
t.icon = append(t.icon, &iconActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependIconLink adds to the front of icon a LinkType type
|
|
func (t *Activity) PrependIconLink(v LinkType) {
|
|
t.icon = append([]*iconActivityIntermediateType{&iconActivityIntermediateType{Link: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetIconIRI(index int) (v *url.URL) {
|
|
return t.icon[index].IRI
|
|
|
|
}
|
|
|
|
// AppendIconIRI adds to the back of icon a *url.URL type
|
|
func (t *Activity) AppendIconIRI(v *url.URL) {
|
|
t.icon = append(t.icon, &iconActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependIconIRI adds to the front of icon a *url.URL type
|
|
func (t *Activity) PrependIconIRI(v *url.URL) {
|
|
t.icon = append([]*iconActivityIntermediateType{&iconActivityIntermediateType{IRI: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownIcon() (ok bool) {
|
|
return t.icon != nil && t.icon[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownIcon returns the unknown value for icon
|
|
func (t *Activity) GetUnknownIcon() (v interface{}) {
|
|
return t.icon[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownIcon sets the unknown value of icon
|
|
func (t *Activity) SetUnknownIcon(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &iconActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.icon = append(t.icon, tmp)
|
|
|
|
}
|
|
|
|
// HasId determines whether the call to GetId is safe
|
|
func (t *Activity) HasId() (ok bool) {
|
|
return t.id != nil
|
|
|
|
}
|
|
|
|
// GetId returns the value for id
|
|
func (t *Activity) GetId() (v *url.URL) {
|
|
return t.id
|
|
|
|
}
|
|
|
|
// SetId sets the value of id
|
|
func (t *Activity) SetId(v *url.URL) {
|
|
t.id = v
|
|
|
|
}
|
|
|
|
// HasUnknownId determines whether the call to GetUnknownId is safe
|
|
func (t *Activity) HasUnknownId() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["id"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownId returns the unknown value for id
|
|
func (t *Activity) GetUnknownId() (v interface{}) {
|
|
return t.unknown_["id"]
|
|
|
|
}
|
|
|
|
// SetUnknownId sets the unknown value of id
|
|
func (t *Activity) 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 *Activity) ImageLen() (l int) {
|
|
return len(t.image)
|
|
|
|
}
|
|
|
|
// IsImageImage determines whether the call to GetImageImage is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetImageImage(index int) (v ImageType) {
|
|
return t.image[index].Image
|
|
|
|
}
|
|
|
|
// AppendImageImage adds to the back of image a ImageType type
|
|
func (t *Activity) AppendImageImage(v ImageType) {
|
|
t.image = append(t.image, &imageActivityIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependImageImage adds to the front of image a ImageType type
|
|
func (t *Activity) PrependImageImage(v ImageType) {
|
|
t.image = append([]*imageActivityIntermediateType{&imageActivityIntermediateType{Image: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageImage deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetImageLink(index int) (v LinkType) {
|
|
return t.image[index].Link
|
|
|
|
}
|
|
|
|
// AppendImageLink adds to the back of image a LinkType type
|
|
func (t *Activity) AppendImageLink(v LinkType) {
|
|
t.image = append(t.image, &imageActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependImageLink adds to the front of image a LinkType type
|
|
func (t *Activity) PrependImageLink(v LinkType) {
|
|
t.image = append([]*imageActivityIntermediateType{&imageActivityIntermediateType{Link: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetImageIRI(index int) (v *url.URL) {
|
|
return t.image[index].IRI
|
|
|
|
}
|
|
|
|
// AppendImageIRI adds to the back of image a *url.URL type
|
|
func (t *Activity) AppendImageIRI(v *url.URL) {
|
|
t.image = append(t.image, &imageActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependImageIRI adds to the front of image a *url.URL type
|
|
func (t *Activity) PrependImageIRI(v *url.URL) {
|
|
t.image = append([]*imageActivityIntermediateType{&imageActivityIntermediateType{IRI: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownImage() (ok bool) {
|
|
return t.image != nil && t.image[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownImage returns the unknown value for image
|
|
func (t *Activity) GetUnknownImage() (v interface{}) {
|
|
return t.image[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownImage sets the unknown value of image
|
|
func (t *Activity) SetUnknownImage(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &imageActivityIntermediateType{}
|
|
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 *Activity) InReplyToLen() (l int) {
|
|
return len(t.inReplyTo)
|
|
|
|
}
|
|
|
|
// IsInReplyToObject determines whether the call to GetInReplyToObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetInReplyToObject(index int) (v ObjectType) {
|
|
return t.inReplyTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendInReplyToObject adds to the back of inReplyTo a ObjectType type
|
|
func (t *Activity) AppendInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToObject adds to the front of inReplyTo a ObjectType type
|
|
func (t *Activity) PrependInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append([]*inReplyToActivityIntermediateType{&inReplyToActivityIntermediateType{Object: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetInReplyToLink(index int) (v LinkType) {
|
|
return t.inReplyTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendInReplyToLink adds to the back of inReplyTo a LinkType type
|
|
func (t *Activity) AppendInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToLink adds to the front of inReplyTo a LinkType type
|
|
func (t *Activity) PrependInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append([]*inReplyToActivityIntermediateType{&inReplyToActivityIntermediateType{Link: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetInReplyToIRI(index int) (v *url.URL) {
|
|
return t.inReplyTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInReplyToIRI adds to the back of inReplyTo a *url.URL type
|
|
func (t *Activity) AppendInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToIRI adds to the front of inReplyTo a *url.URL type
|
|
func (t *Activity) PrependInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append([]*inReplyToActivityIntermediateType{&inReplyToActivityIntermediateType{IRI: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownInReplyTo() (ok bool) {
|
|
return t.inReplyTo != nil && t.inReplyTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInReplyTo returns the unknown value for inReplyTo
|
|
func (t *Activity) GetUnknownInReplyTo() (v interface{}) {
|
|
return t.inReplyTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInReplyTo sets the unknown value of inReplyTo
|
|
func (t *Activity) SetUnknownInReplyTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inReplyToActivityIntermediateType{}
|
|
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 *Activity) LocationLen() (l int) {
|
|
return len(t.location)
|
|
|
|
}
|
|
|
|
// IsLocationObject determines whether the call to GetLocationObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetLocationObject(index int) (v ObjectType) {
|
|
return t.location[index].Object
|
|
|
|
}
|
|
|
|
// AppendLocationObject adds to the back of location a ObjectType type
|
|
func (t *Activity) AppendLocationObject(v ObjectType) {
|
|
t.location = append(t.location, &locationActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependLocationObject adds to the front of location a ObjectType type
|
|
func (t *Activity) PrependLocationObject(v ObjectType) {
|
|
t.location = append([]*locationActivityIntermediateType{&locationActivityIntermediateType{Object: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetLocationLink(index int) (v LinkType) {
|
|
return t.location[index].Link
|
|
|
|
}
|
|
|
|
// AppendLocationLink adds to the back of location a LinkType type
|
|
func (t *Activity) AppendLocationLink(v LinkType) {
|
|
t.location = append(t.location, &locationActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependLocationLink adds to the front of location a LinkType type
|
|
func (t *Activity) PrependLocationLink(v LinkType) {
|
|
t.location = append([]*locationActivityIntermediateType{&locationActivityIntermediateType{Link: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetLocationIRI(index int) (v *url.URL) {
|
|
return t.location[index].IRI
|
|
|
|
}
|
|
|
|
// AppendLocationIRI adds to the back of location a *url.URL type
|
|
func (t *Activity) AppendLocationIRI(v *url.URL) {
|
|
t.location = append(t.location, &locationActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependLocationIRI adds to the front of location a *url.URL type
|
|
func (t *Activity) PrependLocationIRI(v *url.URL) {
|
|
t.location = append([]*locationActivityIntermediateType{&locationActivityIntermediateType{IRI: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownLocation() (ok bool) {
|
|
return t.location != nil && t.location[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLocation returns the unknown value for location
|
|
func (t *Activity) GetUnknownLocation() (v interface{}) {
|
|
return t.location[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLocation sets the unknown value of location
|
|
func (t *Activity) SetUnknownLocation(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &locationActivityIntermediateType{}
|
|
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 *Activity) PreviewLen() (l int) {
|
|
return len(t.preview)
|
|
|
|
}
|
|
|
|
// IsPreviewObject determines whether the call to GetPreviewObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetPreviewObject(index int) (v ObjectType) {
|
|
return t.preview[index].Object
|
|
|
|
}
|
|
|
|
// AppendPreviewObject adds to the back of preview a ObjectType type
|
|
func (t *Activity) AppendPreviewObject(v ObjectType) {
|
|
t.preview = append(t.preview, &previewActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewObject adds to the front of preview a ObjectType type
|
|
func (t *Activity) PrependPreviewObject(v ObjectType) {
|
|
t.preview = append([]*previewActivityIntermediateType{&previewActivityIntermediateType{Object: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetPreviewLink(index int) (v LinkType) {
|
|
return t.preview[index].Link
|
|
|
|
}
|
|
|
|
// AppendPreviewLink adds to the back of preview a LinkType type
|
|
func (t *Activity) AppendPreviewLink(v LinkType) {
|
|
t.preview = append(t.preview, &previewActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewLink adds to the front of preview a LinkType type
|
|
func (t *Activity) PrependPreviewLink(v LinkType) {
|
|
t.preview = append([]*previewActivityIntermediateType{&previewActivityIntermediateType{Link: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetPreviewIRI(index int) (v *url.URL) {
|
|
return t.preview[index].IRI
|
|
|
|
}
|
|
|
|
// AppendPreviewIRI adds to the back of preview a *url.URL type
|
|
func (t *Activity) AppendPreviewIRI(v *url.URL) {
|
|
t.preview = append(t.preview, &previewActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewIRI adds to the front of preview a *url.URL type
|
|
func (t *Activity) PrependPreviewIRI(v *url.URL) {
|
|
t.preview = append([]*previewActivityIntermediateType{&previewActivityIntermediateType{IRI: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownPreview() (ok bool) {
|
|
return t.preview != nil && t.preview[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreview returns the unknown value for preview
|
|
func (t *Activity) GetUnknownPreview() (v interface{}) {
|
|
return t.preview[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreview sets the unknown value of preview
|
|
func (t *Activity) SetUnknownPreview(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &previewActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preview = append(t.preview, tmp)
|
|
|
|
}
|
|
|
|
// IsPublished determines whether the call to GetPublished is safe
|
|
func (t *Activity) IsPublished() (ok bool) {
|
|
return t.published != nil && t.published.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetPublished returns the value safely if IsPublished returned true
|
|
func (t *Activity) GetPublished() (v time.Time) {
|
|
return *t.published.dateTime
|
|
|
|
}
|
|
|
|
// SetPublished sets the value of published to be of time.Time type
|
|
func (t *Activity) SetPublished(v time.Time) {
|
|
t.published = &publishedActivityIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsPublishedIRI determines whether the call to GetPublishedIRI is safe
|
|
func (t *Activity) IsPublishedIRI() (ok bool) {
|
|
return t.published != nil && t.published.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPublishedIRI returns the value safely if IsPublishedIRI returned true
|
|
func (t *Activity) GetPublishedIRI() (v *url.URL) {
|
|
return t.published.IRI
|
|
|
|
}
|
|
|
|
// SetPublishedIRI sets the value of published to be of *url.URL type
|
|
func (t *Activity) SetPublishedIRI(v *url.URL) {
|
|
t.published = &publishedActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPublished determines whether the call to GetUnknownPublished is safe
|
|
func (t *Activity) HasUnknownPublished() (ok bool) {
|
|
return t.published != nil && t.published.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPublished returns the unknown value for published
|
|
func (t *Activity) GetUnknownPublished() (v interface{}) {
|
|
return t.published.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPublished sets the unknown value of published
|
|
func (t *Activity) SetUnknownPublished(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &publishedActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.published = tmp
|
|
|
|
}
|
|
|
|
// IsReplies determines whether the call to GetReplies is safe
|
|
func (t *Activity) IsReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.Collection != nil
|
|
|
|
}
|
|
|
|
// GetReplies returns the value safely if IsReplies returned true
|
|
func (t *Activity) GetReplies() (v CollectionType) {
|
|
return t.replies.Collection
|
|
|
|
}
|
|
|
|
// SetReplies sets the value of replies to be of CollectionType type
|
|
func (t *Activity) SetReplies(v CollectionType) {
|
|
t.replies = &repliesActivityIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsRepliesIRI determines whether the call to GetRepliesIRI is safe
|
|
func (t *Activity) IsRepliesIRI() (ok bool) {
|
|
return t.replies != nil && t.replies.IRI != nil
|
|
|
|
}
|
|
|
|
// GetRepliesIRI returns the value safely if IsRepliesIRI returned true
|
|
func (t *Activity) GetRepliesIRI() (v *url.URL) {
|
|
return t.replies.IRI
|
|
|
|
}
|
|
|
|
// SetRepliesIRI sets the value of replies to be of *url.URL type
|
|
func (t *Activity) SetRepliesIRI(v *url.URL) {
|
|
t.replies = &repliesActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownReplies determines whether the call to GetUnknownReplies is safe
|
|
func (t *Activity) HasUnknownReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownReplies returns the unknown value for replies
|
|
func (t *Activity) GetUnknownReplies() (v interface{}) {
|
|
return t.replies.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownReplies sets the unknown value of replies
|
|
func (t *Activity) SetUnknownReplies(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &repliesActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.replies = tmp
|
|
|
|
}
|
|
|
|
// IsStartTime determines whether the call to GetStartTime is safe
|
|
func (t *Activity) IsStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetStartTime returns the value safely if IsStartTime returned true
|
|
func (t *Activity) GetStartTime() (v time.Time) {
|
|
return *t.startTime.dateTime
|
|
|
|
}
|
|
|
|
// SetStartTime sets the value of startTime to be of time.Time type
|
|
func (t *Activity) SetStartTime(v time.Time) {
|
|
t.startTime = &startTimeActivityIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsStartTimeIRI determines whether the call to GetStartTimeIRI is safe
|
|
func (t *Activity) IsStartTimeIRI() (ok bool) {
|
|
return t.startTime != nil && t.startTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetStartTimeIRI returns the value safely if IsStartTimeIRI returned true
|
|
func (t *Activity) GetStartTimeIRI() (v *url.URL) {
|
|
return t.startTime.IRI
|
|
|
|
}
|
|
|
|
// SetStartTimeIRI sets the value of startTime to be of *url.URL type
|
|
func (t *Activity) SetStartTimeIRI(v *url.URL) {
|
|
t.startTime = &startTimeActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownStartTime determines whether the call to GetUnknownStartTime is safe
|
|
func (t *Activity) HasUnknownStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStartTime returns the unknown value for startTime
|
|
func (t *Activity) GetUnknownStartTime() (v interface{}) {
|
|
return t.startTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownStartTime sets the unknown value of startTime
|
|
func (t *Activity) SetUnknownStartTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &startTimeActivityIntermediateType{}
|
|
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 *Activity) SummaryLen() (l int) {
|
|
return len(t.summary)
|
|
|
|
}
|
|
|
|
// IsSummaryString determines whether the call to GetSummaryString is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetSummaryString(index int) (v string) {
|
|
return *t.summary[index].stringName
|
|
|
|
}
|
|
|
|
// AppendSummaryString adds to the back of summary a string type
|
|
func (t *Activity) AppendSummaryString(v string) {
|
|
t.summary = append(t.summary, &summaryActivityIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryString adds to the front of summary a string type
|
|
func (t *Activity) PrependSummaryString(v string) {
|
|
t.summary = append([]*summaryActivityIntermediateType{&summaryActivityIntermediateType{stringName: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryString deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetSummaryLangString(index int) (v string) {
|
|
return *t.summary[index].langString
|
|
|
|
}
|
|
|
|
// AppendSummaryLangString adds to the back of summary a string type
|
|
func (t *Activity) AppendSummaryLangString(v string) {
|
|
t.summary = append(t.summary, &summaryActivityIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryLangString adds to the front of summary a string type
|
|
func (t *Activity) PrependSummaryLangString(v string) {
|
|
t.summary = append([]*summaryActivityIntermediateType{&summaryActivityIntermediateType{langString: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryLangString deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetSummaryIRI(index int) (v *url.URL) {
|
|
return t.summary[index].IRI
|
|
|
|
}
|
|
|
|
// AppendSummaryIRI adds to the back of summary a *url.URL type
|
|
func (t *Activity) AppendSummaryIRI(v *url.URL) {
|
|
t.summary = append(t.summary, &summaryActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependSummaryIRI adds to the front of summary a *url.URL type
|
|
func (t *Activity) PrependSummaryIRI(v *url.URL) {
|
|
t.summary = append([]*summaryActivityIntermediateType{&summaryActivityIntermediateType{IRI: v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownSummary() (ok bool) {
|
|
return t.summary != nil && t.summary[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSummary returns the unknown value for summary
|
|
func (t *Activity) GetUnknownSummary() (v interface{}) {
|
|
return t.summary[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSummary sets the unknown value of summary
|
|
func (t *Activity) SetUnknownSummary(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &summaryActivityIntermediateType{}
|
|
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 *Activity) 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 *Activity) 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 *Activity) 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 *Activity) TagLen() (l int) {
|
|
return len(t.tag)
|
|
|
|
}
|
|
|
|
// IsTagObject determines whether the call to GetTagObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetTagObject(index int) (v ObjectType) {
|
|
return t.tag[index].Object
|
|
|
|
}
|
|
|
|
// AppendTagObject adds to the back of tag a ObjectType type
|
|
func (t *Activity) AppendTagObject(v ObjectType) {
|
|
t.tag = append(t.tag, &tagActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTagObject adds to the front of tag a ObjectType type
|
|
func (t *Activity) PrependTagObject(v ObjectType) {
|
|
t.tag = append([]*tagActivityIntermediateType{&tagActivityIntermediateType{Object: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetTagLink(index int) (v LinkType) {
|
|
return t.tag[index].Link
|
|
|
|
}
|
|
|
|
// AppendTagLink adds to the back of tag a LinkType type
|
|
func (t *Activity) AppendTagLink(v LinkType) {
|
|
t.tag = append(t.tag, &tagActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTagLink adds to the front of tag a LinkType type
|
|
func (t *Activity) PrependTagLink(v LinkType) {
|
|
t.tag = append([]*tagActivityIntermediateType{&tagActivityIntermediateType{Link: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetTagIRI(index int) (v *url.URL) {
|
|
return t.tag[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTagIRI adds to the back of tag a *url.URL type
|
|
func (t *Activity) AppendTagIRI(v *url.URL) {
|
|
t.tag = append(t.tag, &tagActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTagIRI adds to the front of tag a *url.URL type
|
|
func (t *Activity) PrependTagIRI(v *url.URL) {
|
|
t.tag = append([]*tagActivityIntermediateType{&tagActivityIntermediateType{IRI: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownTag() (ok bool) {
|
|
return t.tag != nil && t.tag[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTag returns the unknown value for tag
|
|
func (t *Activity) GetUnknownTag() (v interface{}) {
|
|
return t.tag[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTag sets the unknown value of tag
|
|
func (t *Activity) SetUnknownTag(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &tagActivityIntermediateType{}
|
|
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 *Activity) TypeLen() (l int) {
|
|
return len(t.typeName)
|
|
|
|
}
|
|
|
|
// GetType returns the value for the specified index
|
|
func (t *Activity) GetType(index int) (v interface{}) {
|
|
return t.typeName[index]
|
|
|
|
}
|
|
|
|
// AppendType adds a value to the back of type
|
|
func (t *Activity) AppendType(v interface{}) {
|
|
t.typeName = append(t.typeName, v)
|
|
|
|
}
|
|
|
|
// PrependType adds a value to the front of type
|
|
func (t *Activity) PrependType(v interface{}) {
|
|
t.typeName = append([]interface{}{v}, t.typeName...)
|
|
|
|
}
|
|
|
|
// RemoveType deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) IsUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetUpdated returns the value safely if IsUpdated returned true
|
|
func (t *Activity) GetUpdated() (v time.Time) {
|
|
return *t.updated.dateTime
|
|
|
|
}
|
|
|
|
// SetUpdated sets the value of updated to be of time.Time type
|
|
func (t *Activity) SetUpdated(v time.Time) {
|
|
t.updated = &updatedActivityIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsUpdatedIRI determines whether the call to GetUpdatedIRI is safe
|
|
func (t *Activity) IsUpdatedIRI() (ok bool) {
|
|
return t.updated != nil && t.updated.IRI != nil
|
|
|
|
}
|
|
|
|
// GetUpdatedIRI returns the value safely if IsUpdatedIRI returned true
|
|
func (t *Activity) GetUpdatedIRI() (v *url.URL) {
|
|
return t.updated.IRI
|
|
|
|
}
|
|
|
|
// SetUpdatedIRI sets the value of updated to be of *url.URL type
|
|
func (t *Activity) SetUpdatedIRI(v *url.URL) {
|
|
t.updated = &updatedActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownUpdated determines whether the call to GetUnknownUpdated is safe
|
|
func (t *Activity) HasUnknownUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUpdated returns the unknown value for updated
|
|
func (t *Activity) GetUnknownUpdated() (v interface{}) {
|
|
return t.updated.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUpdated sets the unknown value of updated
|
|
func (t *Activity) SetUnknownUpdated(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &updatedActivityIntermediateType{}
|
|
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 *Activity) UrlLen() (l int) {
|
|
return len(t.url)
|
|
|
|
}
|
|
|
|
// IsUrlAnyURI determines whether the call to GetUrlAnyURI is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetUrlAnyURI(index int) (v *url.URL) {
|
|
return t.url[index].anyURI
|
|
|
|
}
|
|
|
|
// AppendUrlAnyURI adds to the back of url a *url.URL type
|
|
func (t *Activity) AppendUrlAnyURI(v *url.URL) {
|
|
t.url = append(t.url, &urlActivityIntermediateType{anyURI: v})
|
|
|
|
}
|
|
|
|
// PrependUrlAnyURI adds to the front of url a *url.URL type
|
|
func (t *Activity) PrependUrlAnyURI(v *url.URL) {
|
|
t.url = append([]*urlActivityIntermediateType{&urlActivityIntermediateType{anyURI: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlAnyURI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetUrlLink(index int) (v LinkType) {
|
|
return t.url[index].Link
|
|
|
|
}
|
|
|
|
// AppendUrlLink adds to the back of url a LinkType type
|
|
func (t *Activity) AppendUrlLink(v LinkType) {
|
|
t.url = append(t.url, &urlActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependUrlLink adds to the front of url a LinkType type
|
|
func (t *Activity) PrependUrlLink(v LinkType) {
|
|
t.url = append([]*urlActivityIntermediateType{&urlActivityIntermediateType{Link: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownUrl() (ok bool) {
|
|
return t.url != nil && t.url[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUrl returns the unknown value for url
|
|
func (t *Activity) GetUnknownUrl() (v interface{}) {
|
|
return t.url[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUrl sets the unknown value of url
|
|
func (t *Activity) SetUnknownUrl(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &urlActivityIntermediateType{}
|
|
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 *Activity) ToLen() (l int) {
|
|
return len(t.to)
|
|
|
|
}
|
|
|
|
// IsToObject determines whether the call to GetToObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetToObject(index int) (v ObjectType) {
|
|
return t.to[index].Object
|
|
|
|
}
|
|
|
|
// AppendToObject adds to the back of to a ObjectType type
|
|
func (t *Activity) AppendToObject(v ObjectType) {
|
|
t.to = append(t.to, &toActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependToObject adds to the front of to a ObjectType type
|
|
func (t *Activity) PrependToObject(v ObjectType) {
|
|
t.to = append([]*toActivityIntermediateType{&toActivityIntermediateType{Object: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetToLink(index int) (v LinkType) {
|
|
return t.to[index].Link
|
|
|
|
}
|
|
|
|
// AppendToLink adds to the back of to a LinkType type
|
|
func (t *Activity) AppendToLink(v LinkType) {
|
|
t.to = append(t.to, &toActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependToLink adds to the front of to a LinkType type
|
|
func (t *Activity) PrependToLink(v LinkType) {
|
|
t.to = append([]*toActivityIntermediateType{&toActivityIntermediateType{Link: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetToIRI(index int) (v *url.URL) {
|
|
return t.to[index].IRI
|
|
|
|
}
|
|
|
|
// AppendToIRI adds to the back of to a *url.URL type
|
|
func (t *Activity) AppendToIRI(v *url.URL) {
|
|
t.to = append(t.to, &toActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependToIRI adds to the front of to a *url.URL type
|
|
func (t *Activity) PrependToIRI(v *url.URL) {
|
|
t.to = append([]*toActivityIntermediateType{&toActivityIntermediateType{IRI: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownTo() (ok bool) {
|
|
return t.to != nil && t.to[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTo returns the unknown value for to
|
|
func (t *Activity) GetUnknownTo() (v interface{}) {
|
|
return t.to[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTo sets the unknown value of to
|
|
func (t *Activity) SetUnknownTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &toActivityIntermediateType{}
|
|
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 *Activity) BtoLen() (l int) {
|
|
return len(t.bto)
|
|
|
|
}
|
|
|
|
// IsBtoObject determines whether the call to GetBtoObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetBtoObject(index int) (v ObjectType) {
|
|
return t.bto[index].Object
|
|
|
|
}
|
|
|
|
// AppendBtoObject adds to the back of bto a ObjectType type
|
|
func (t *Activity) AppendBtoObject(v ObjectType) {
|
|
t.bto = append(t.bto, &btoActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBtoObject adds to the front of bto a ObjectType type
|
|
func (t *Activity) PrependBtoObject(v ObjectType) {
|
|
t.bto = append([]*btoActivityIntermediateType{&btoActivityIntermediateType{Object: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetBtoLink(index int) (v LinkType) {
|
|
return t.bto[index].Link
|
|
|
|
}
|
|
|
|
// AppendBtoLink adds to the back of bto a LinkType type
|
|
func (t *Activity) AppendBtoLink(v LinkType) {
|
|
t.bto = append(t.bto, &btoActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBtoLink adds to the front of bto a LinkType type
|
|
func (t *Activity) PrependBtoLink(v LinkType) {
|
|
t.bto = append([]*btoActivityIntermediateType{&btoActivityIntermediateType{Link: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetBtoIRI(index int) (v *url.URL) {
|
|
return t.bto[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBtoIRI adds to the back of bto a *url.URL type
|
|
func (t *Activity) AppendBtoIRI(v *url.URL) {
|
|
t.bto = append(t.bto, &btoActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBtoIRI adds to the front of bto a *url.URL type
|
|
func (t *Activity) PrependBtoIRI(v *url.URL) {
|
|
t.bto = append([]*btoActivityIntermediateType{&btoActivityIntermediateType{IRI: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownBto() (ok bool) {
|
|
return t.bto != nil && t.bto[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBto returns the unknown value for bto
|
|
func (t *Activity) GetUnknownBto() (v interface{}) {
|
|
return t.bto[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBto sets the unknown value of bto
|
|
func (t *Activity) SetUnknownBto(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &btoActivityIntermediateType{}
|
|
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 *Activity) CcLen() (l int) {
|
|
return len(t.cc)
|
|
|
|
}
|
|
|
|
// IsCcObject determines whether the call to GetCcObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetCcObject(index int) (v ObjectType) {
|
|
return t.cc[index].Object
|
|
|
|
}
|
|
|
|
// AppendCcObject adds to the back of cc a ObjectType type
|
|
func (t *Activity) AppendCcObject(v ObjectType) {
|
|
t.cc = append(t.cc, &ccActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependCcObject adds to the front of cc a ObjectType type
|
|
func (t *Activity) PrependCcObject(v ObjectType) {
|
|
t.cc = append([]*ccActivityIntermediateType{&ccActivityIntermediateType{Object: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetCcLink(index int) (v LinkType) {
|
|
return t.cc[index].Link
|
|
|
|
}
|
|
|
|
// AppendCcLink adds to the back of cc a LinkType type
|
|
func (t *Activity) AppendCcLink(v LinkType) {
|
|
t.cc = append(t.cc, &ccActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependCcLink adds to the front of cc a LinkType type
|
|
func (t *Activity) PrependCcLink(v LinkType) {
|
|
t.cc = append([]*ccActivityIntermediateType{&ccActivityIntermediateType{Link: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetCcIRI(index int) (v *url.URL) {
|
|
return t.cc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendCcIRI adds to the back of cc a *url.URL type
|
|
func (t *Activity) AppendCcIRI(v *url.URL) {
|
|
t.cc = append(t.cc, &ccActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependCcIRI adds to the front of cc a *url.URL type
|
|
func (t *Activity) PrependCcIRI(v *url.URL) {
|
|
t.cc = append([]*ccActivityIntermediateType{&ccActivityIntermediateType{IRI: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownCc() (ok bool) {
|
|
return t.cc != nil && t.cc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownCc returns the unknown value for cc
|
|
func (t *Activity) GetUnknownCc() (v interface{}) {
|
|
return t.cc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownCc sets the unknown value of cc
|
|
func (t *Activity) SetUnknownCc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &ccActivityIntermediateType{}
|
|
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 *Activity) BccLen() (l int) {
|
|
return len(t.bcc)
|
|
|
|
}
|
|
|
|
// IsBccObject determines whether the call to GetBccObject is safe for the specified index
|
|
func (t *Activity) 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 *Activity) GetBccObject(index int) (v ObjectType) {
|
|
return t.bcc[index].Object
|
|
|
|
}
|
|
|
|
// AppendBccObject adds to the back of bcc a ObjectType type
|
|
func (t *Activity) AppendBccObject(v ObjectType) {
|
|
t.bcc = append(t.bcc, &bccActivityIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBccObject adds to the front of bcc a ObjectType type
|
|
func (t *Activity) PrependBccObject(v ObjectType) {
|
|
t.bcc = append([]*bccActivityIntermediateType{&bccActivityIntermediateType{Object: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccObject deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetBccLink(index int) (v LinkType) {
|
|
return t.bcc[index].Link
|
|
|
|
}
|
|
|
|
// AppendBccLink adds to the back of bcc a LinkType type
|
|
func (t *Activity) AppendBccLink(v LinkType) {
|
|
t.bcc = append(t.bcc, &bccActivityIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBccLink adds to the front of bcc a LinkType type
|
|
func (t *Activity) PrependBccLink(v LinkType) {
|
|
t.bcc = append([]*bccActivityIntermediateType{&bccActivityIntermediateType{Link: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccLink deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) 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 *Activity) GetBccIRI(index int) (v *url.URL) {
|
|
return t.bcc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBccIRI adds to the back of bcc a *url.URL type
|
|
func (t *Activity) AppendBccIRI(v *url.URL) {
|
|
t.bcc = append(t.bcc, &bccActivityIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBccIRI adds to the front of bcc a *url.URL type
|
|
func (t *Activity) PrependBccIRI(v *url.URL) {
|
|
t.bcc = append([]*bccActivityIntermediateType{&bccActivityIntermediateType{IRI: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccIRI deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownBcc() (ok bool) {
|
|
return t.bcc != nil && t.bcc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBcc returns the unknown value for bcc
|
|
func (t *Activity) GetUnknownBcc() (v interface{}) {
|
|
return t.bcc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBcc sets the unknown value of bcc
|
|
func (t *Activity) SetUnknownBcc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &bccActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.bcc = append(t.bcc, tmp)
|
|
|
|
}
|
|
|
|
// IsMediaType determines whether the call to GetMediaType is safe
|
|
func (t *Activity) IsMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.mimeMediaTypeValue != nil
|
|
|
|
}
|
|
|
|
// GetMediaType returns the value safely if IsMediaType returned true
|
|
func (t *Activity) GetMediaType() (v string) {
|
|
return *t.mediaType.mimeMediaTypeValue
|
|
|
|
}
|
|
|
|
// SetMediaType sets the value of mediaType to be of string type
|
|
func (t *Activity) SetMediaType(v string) {
|
|
t.mediaType = &mediaTypeActivityIntermediateType{mimeMediaTypeValue: &v}
|
|
|
|
}
|
|
|
|
// IsMediaTypeIRI determines whether the call to GetMediaTypeIRI is safe
|
|
func (t *Activity) IsMediaTypeIRI() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.IRI != nil
|
|
|
|
}
|
|
|
|
// GetMediaTypeIRI returns the value safely if IsMediaTypeIRI returned true
|
|
func (t *Activity) GetMediaTypeIRI() (v *url.URL) {
|
|
return t.mediaType.IRI
|
|
|
|
}
|
|
|
|
// SetMediaTypeIRI sets the value of mediaType to be of *url.URL type
|
|
func (t *Activity) SetMediaTypeIRI(v *url.URL) {
|
|
t.mediaType = &mediaTypeActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownMediaType determines whether the call to GetUnknownMediaType is safe
|
|
func (t *Activity) HasUnknownMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownMediaType returns the unknown value for mediaType
|
|
func (t *Activity) GetUnknownMediaType() (v interface{}) {
|
|
return t.mediaType.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownMediaType sets the unknown value of mediaType
|
|
func (t *Activity) SetUnknownMediaType(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &mediaTypeActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.mediaType = tmp
|
|
|
|
}
|
|
|
|
// IsDuration determines whether the call to GetDuration is safe
|
|
func (t *Activity) IsDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.duration != nil
|
|
|
|
}
|
|
|
|
// GetDuration returns the value safely if IsDuration returned true
|
|
func (t *Activity) GetDuration() (v time.Duration) {
|
|
return *t.duration.duration
|
|
|
|
}
|
|
|
|
// SetDuration sets the value of duration to be of time.Duration type
|
|
func (t *Activity) SetDuration(v time.Duration) {
|
|
t.duration = &durationActivityIntermediateType{duration: &v}
|
|
|
|
}
|
|
|
|
// IsDurationIRI determines whether the call to GetDurationIRI is safe
|
|
func (t *Activity) IsDurationIRI() (ok bool) {
|
|
return t.duration != nil && t.duration.IRI != nil
|
|
|
|
}
|
|
|
|
// GetDurationIRI returns the value safely if IsDurationIRI returned true
|
|
func (t *Activity) GetDurationIRI() (v *url.URL) {
|
|
return t.duration.IRI
|
|
|
|
}
|
|
|
|
// SetDurationIRI sets the value of duration to be of *url.URL type
|
|
func (t *Activity) SetDurationIRI(v *url.URL) {
|
|
t.duration = &durationActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownDuration determines whether the call to GetUnknownDuration is safe
|
|
func (t *Activity) HasUnknownDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownDuration returns the unknown value for duration
|
|
func (t *Activity) GetUnknownDuration() (v interface{}) {
|
|
return t.duration.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownDuration sets the unknown value of duration
|
|
func (t *Activity) SetUnknownDuration(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &durationActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.duration = tmp
|
|
|
|
}
|
|
|
|
// IsSource determines whether the call to GetSource is safe
|
|
func (t *Activity) IsSource() (ok bool) {
|
|
return t.source != nil && t.source.Object != nil
|
|
|
|
}
|
|
|
|
// GetSource returns the value safely if IsSource returned true
|
|
func (t *Activity) GetSource() (v ObjectType) {
|
|
return t.source.Object
|
|
|
|
}
|
|
|
|
// SetSource sets the value of source to be of ObjectType type
|
|
func (t *Activity) SetSource(v ObjectType) {
|
|
t.source = &sourceActivityIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsSourceIRI determines whether the call to GetSourceIRI is safe
|
|
func (t *Activity) IsSourceIRI() (ok bool) {
|
|
return t.source != nil && t.source.IRI != nil
|
|
|
|
}
|
|
|
|
// GetSourceIRI returns the value safely if IsSourceIRI returned true
|
|
func (t *Activity) GetSourceIRI() (v *url.URL) {
|
|
return t.source.IRI
|
|
|
|
}
|
|
|
|
// SetSourceIRI sets the value of source to be of *url.URL type
|
|
func (t *Activity) SetSourceIRI(v *url.URL) {
|
|
t.source = &sourceActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownSource determines whether the call to GetUnknownSource is safe
|
|
func (t *Activity) HasUnknownSource() (ok bool) {
|
|
return t.source != nil && t.source.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSource returns the unknown value for source
|
|
func (t *Activity) GetUnknownSource() (v interface{}) {
|
|
return t.source.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSource sets the unknown value of source
|
|
func (t *Activity) SetUnknownSource(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &sourceActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.source = tmp
|
|
|
|
}
|
|
|
|
// IsInboxOrderedCollection determines whether the call to GetInboxOrderedCollection is safe
|
|
func (t *Activity) IsInboxOrderedCollection() (ok bool) {
|
|
return t.inbox != nil && t.inbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetInboxOrderedCollection returns the value safely if IsInboxOrderedCollection returned true
|
|
func (t *Activity) GetInboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.inbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetInboxOrderedCollection sets the value of inbox to be of OrderedCollectionType type
|
|
func (t *Activity) SetInboxOrderedCollection(v OrderedCollectionType) {
|
|
t.inbox = &inboxActivityIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsInboxAnyURI determines whether the call to GetInboxAnyURI is safe
|
|
func (t *Activity) IsInboxAnyURI() (ok bool) {
|
|
return t.inbox != nil && t.inbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetInboxAnyURI returns the value safely if IsInboxAnyURI returned true
|
|
func (t *Activity) GetInboxAnyURI() (v *url.URL) {
|
|
return t.inbox.anyURI
|
|
|
|
}
|
|
|
|
// SetInboxAnyURI sets the value of inbox to be of *url.URL type
|
|
func (t *Activity) SetInboxAnyURI(v *url.URL) {
|
|
t.inbox = &inboxActivityIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownInbox determines whether the call to GetUnknownInbox is safe
|
|
func (t *Activity) HasUnknownInbox() (ok bool) {
|
|
return t.inbox != nil && t.inbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInbox returns the unknown value for inbox
|
|
func (t *Activity) GetUnknownInbox() (v interface{}) {
|
|
return t.inbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInbox sets the unknown value of inbox
|
|
func (t *Activity) SetUnknownInbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inboxActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.inbox = tmp
|
|
|
|
}
|
|
|
|
// IsOutboxOrderedCollection determines whether the call to GetOutboxOrderedCollection is safe
|
|
func (t *Activity) IsOutboxOrderedCollection() (ok bool) {
|
|
return t.outbox != nil && t.outbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetOutboxOrderedCollection returns the value safely if IsOutboxOrderedCollection returned true
|
|
func (t *Activity) GetOutboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.outbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetOutboxOrderedCollection sets the value of outbox to be of OrderedCollectionType type
|
|
func (t *Activity) SetOutboxOrderedCollection(v OrderedCollectionType) {
|
|
t.outbox = &outboxActivityIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsOutboxAnyURI determines whether the call to GetOutboxAnyURI is safe
|
|
func (t *Activity) IsOutboxAnyURI() (ok bool) {
|
|
return t.outbox != nil && t.outbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetOutboxAnyURI returns the value safely if IsOutboxAnyURI returned true
|
|
func (t *Activity) GetOutboxAnyURI() (v *url.URL) {
|
|
return t.outbox.anyURI
|
|
|
|
}
|
|
|
|
// SetOutboxAnyURI sets the value of outbox to be of *url.URL type
|
|
func (t *Activity) SetOutboxAnyURI(v *url.URL) {
|
|
t.outbox = &outboxActivityIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownOutbox determines whether the call to GetUnknownOutbox is safe
|
|
func (t *Activity) HasUnknownOutbox() (ok bool) {
|
|
return t.outbox != nil && t.outbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOutbox returns the unknown value for outbox
|
|
func (t *Activity) GetUnknownOutbox() (v interface{}) {
|
|
return t.outbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOutbox sets the unknown value of outbox
|
|
func (t *Activity) SetUnknownOutbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &outboxActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.outbox = tmp
|
|
|
|
}
|
|
|
|
// IsFollowingCollection determines whether the call to GetFollowingCollection is safe
|
|
func (t *Activity) IsFollowingCollection() (ok bool) {
|
|
return t.following != nil && t.following.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingCollection returns the value safely if IsFollowingCollection returned true
|
|
func (t *Activity) GetFollowingCollection() (v CollectionType) {
|
|
return t.following.Collection
|
|
|
|
}
|
|
|
|
// SetFollowingCollection sets the value of following to be of CollectionType type
|
|
func (t *Activity) SetFollowingCollection(v CollectionType) {
|
|
t.following = &followingActivityIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingOrderedCollection determines whether the call to GetFollowingOrderedCollection is safe
|
|
func (t *Activity) IsFollowingOrderedCollection() (ok bool) {
|
|
return t.following != nil && t.following.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingOrderedCollection returns the value safely if IsFollowingOrderedCollection returned true
|
|
func (t *Activity) GetFollowingOrderedCollection() (v OrderedCollectionType) {
|
|
return t.following.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowingOrderedCollection sets the value of following to be of OrderedCollectionType type
|
|
func (t *Activity) SetFollowingOrderedCollection(v OrderedCollectionType) {
|
|
t.following = &followingActivityIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingAnyURI determines whether the call to GetFollowingAnyURI is safe
|
|
func (t *Activity) IsFollowingAnyURI() (ok bool) {
|
|
return t.following != nil && t.following.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowingAnyURI returns the value safely if IsFollowingAnyURI returned true
|
|
func (t *Activity) GetFollowingAnyURI() (v *url.URL) {
|
|
return t.following.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowingAnyURI sets the value of following to be of *url.URL type
|
|
func (t *Activity) SetFollowingAnyURI(v *url.URL) {
|
|
t.following = &followingActivityIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowing determines whether the call to GetUnknownFollowing is safe
|
|
func (t *Activity) HasUnknownFollowing() (ok bool) {
|
|
return t.following != nil && t.following.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowing returns the unknown value for following
|
|
func (t *Activity) GetUnknownFollowing() (v interface{}) {
|
|
return t.following.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowing sets the unknown value of following
|
|
func (t *Activity) SetUnknownFollowing(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followingActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.following = tmp
|
|
|
|
}
|
|
|
|
// IsFollowersCollection determines whether the call to GetFollowersCollection is safe
|
|
func (t *Activity) IsFollowersCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersCollection returns the value safely if IsFollowersCollection returned true
|
|
func (t *Activity) GetFollowersCollection() (v CollectionType) {
|
|
return t.followers.Collection
|
|
|
|
}
|
|
|
|
// SetFollowersCollection sets the value of followers to be of CollectionType type
|
|
func (t *Activity) SetFollowersCollection(v CollectionType) {
|
|
t.followers = &followersActivityIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersOrderedCollection determines whether the call to GetFollowersOrderedCollection is safe
|
|
func (t *Activity) IsFollowersOrderedCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersOrderedCollection returns the value safely if IsFollowersOrderedCollection returned true
|
|
func (t *Activity) GetFollowersOrderedCollection() (v OrderedCollectionType) {
|
|
return t.followers.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowersOrderedCollection sets the value of followers to be of OrderedCollectionType type
|
|
func (t *Activity) SetFollowersOrderedCollection(v OrderedCollectionType) {
|
|
t.followers = &followersActivityIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersAnyURI determines whether the call to GetFollowersAnyURI is safe
|
|
func (t *Activity) IsFollowersAnyURI() (ok bool) {
|
|
return t.followers != nil && t.followers.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowersAnyURI returns the value safely if IsFollowersAnyURI returned true
|
|
func (t *Activity) GetFollowersAnyURI() (v *url.URL) {
|
|
return t.followers.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowersAnyURI sets the value of followers to be of *url.URL type
|
|
func (t *Activity) SetFollowersAnyURI(v *url.URL) {
|
|
t.followers = &followersActivityIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowers determines whether the call to GetUnknownFollowers is safe
|
|
func (t *Activity) HasUnknownFollowers() (ok bool) {
|
|
return t.followers != nil && t.followers.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowers returns the unknown value for followers
|
|
func (t *Activity) GetUnknownFollowers() (v interface{}) {
|
|
return t.followers.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowers sets the unknown value of followers
|
|
func (t *Activity) SetUnknownFollowers(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followersActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.followers = tmp
|
|
|
|
}
|
|
|
|
// IsLikedCollection determines whether the call to GetLikedCollection is safe
|
|
func (t *Activity) IsLikedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikedCollection returns the value safely if IsLikedCollection returned true
|
|
func (t *Activity) GetLikedCollection() (v CollectionType) {
|
|
return t.liked.Collection
|
|
|
|
}
|
|
|
|
// SetLikedCollection sets the value of liked to be of CollectionType type
|
|
func (t *Activity) SetLikedCollection(v CollectionType) {
|
|
t.liked = &likedActivityIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikedOrderedCollection determines whether the call to GetLikedOrderedCollection is safe
|
|
func (t *Activity) IsLikedOrderedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikedOrderedCollection returns the value safely if IsLikedOrderedCollection returned true
|
|
func (t *Activity) GetLikedOrderedCollection() (v OrderedCollectionType) {
|
|
return t.liked.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikedOrderedCollection sets the value of liked to be of OrderedCollectionType type
|
|
func (t *Activity) SetLikedOrderedCollection(v OrderedCollectionType) {
|
|
t.liked = &likedActivityIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikedAnyURI determines whether the call to GetLikedAnyURI is safe
|
|
func (t *Activity) IsLikedAnyURI() (ok bool) {
|
|
return t.liked != nil && t.liked.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikedAnyURI returns the value safely if IsLikedAnyURI returned true
|
|
func (t *Activity) GetLikedAnyURI() (v *url.URL) {
|
|
return t.liked.anyURI
|
|
|
|
}
|
|
|
|
// SetLikedAnyURI sets the value of liked to be of *url.URL type
|
|
func (t *Activity) SetLikedAnyURI(v *url.URL) {
|
|
t.liked = &likedActivityIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLiked determines whether the call to GetUnknownLiked is safe
|
|
func (t *Activity) HasUnknownLiked() (ok bool) {
|
|
return t.liked != nil && t.liked.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLiked returns the unknown value for liked
|
|
func (t *Activity) GetUnknownLiked() (v interface{}) {
|
|
return t.liked.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLiked sets the unknown value of liked
|
|
func (t *Activity) SetUnknownLiked(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likedActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.liked = tmp
|
|
|
|
}
|
|
|
|
// IsLikesCollection determines whether the call to GetLikesCollection is safe
|
|
func (t *Activity) IsLikesCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikesCollection returns the value safely if IsLikesCollection returned true
|
|
func (t *Activity) GetLikesCollection() (v CollectionType) {
|
|
return t.likes.Collection
|
|
|
|
}
|
|
|
|
// SetLikesCollection sets the value of likes to be of CollectionType type
|
|
func (t *Activity) SetLikesCollection(v CollectionType) {
|
|
t.likes = &likesActivityIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikesOrderedCollection determines whether the call to GetLikesOrderedCollection is safe
|
|
func (t *Activity) IsLikesOrderedCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikesOrderedCollection returns the value safely if IsLikesOrderedCollection returned true
|
|
func (t *Activity) GetLikesOrderedCollection() (v OrderedCollectionType) {
|
|
return t.likes.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikesOrderedCollection sets the value of likes to be of OrderedCollectionType type
|
|
func (t *Activity) SetLikesOrderedCollection(v OrderedCollectionType) {
|
|
t.likes = &likesActivityIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikesAnyURI determines whether the call to GetLikesAnyURI is safe
|
|
func (t *Activity) IsLikesAnyURI() (ok bool) {
|
|
return t.likes != nil && t.likes.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikesAnyURI returns the value safely if IsLikesAnyURI returned true
|
|
func (t *Activity) GetLikesAnyURI() (v *url.URL) {
|
|
return t.likes.anyURI
|
|
|
|
}
|
|
|
|
// SetLikesAnyURI sets the value of likes to be of *url.URL type
|
|
func (t *Activity) SetLikesAnyURI(v *url.URL) {
|
|
t.likes = &likesActivityIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLikes determines whether the call to GetUnknownLikes is safe
|
|
func (t *Activity) HasUnknownLikes() (ok bool) {
|
|
return t.likes != nil && t.likes.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLikes returns the unknown value for likes
|
|
func (t *Activity) GetUnknownLikes() (v interface{}) {
|
|
return t.likes.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLikes sets the unknown value of likes
|
|
func (t *Activity) SetUnknownLikes(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likesActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.likes = tmp
|
|
|
|
}
|
|
|
|
// StreamsLen determines the number of elements able to be used for the GetStreams and RemoveStreams functions
|
|
func (t *Activity) StreamsLen() (l int) {
|
|
return len(t.streams)
|
|
|
|
}
|
|
|
|
// GetStreams returns the value for the specified index
|
|
func (t *Activity) GetStreams(index int) (v *url.URL) {
|
|
return t.streams[index]
|
|
|
|
}
|
|
|
|
// AppendStreams adds a value to the back of streams
|
|
func (t *Activity) AppendStreams(v *url.URL) {
|
|
t.streams = append(t.streams, v)
|
|
|
|
}
|
|
|
|
// PrependStreams adds a value to the front of streams
|
|
func (t *Activity) PrependStreams(v *url.URL) {
|
|
t.streams = append([]*url.URL{v}, t.streams...)
|
|
|
|
}
|
|
|
|
// RemoveStreams deletes the value from the specified index
|
|
func (t *Activity) 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 *Activity) HasUnknownStreams() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["streams"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStreams returns the unknown value for streams
|
|
func (t *Activity) GetUnknownStreams() (v interface{}) {
|
|
return t.unknown_["streams"]
|
|
|
|
}
|
|
|
|
// SetUnknownStreams sets the unknown value of streams
|
|
func (t *Activity) 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 *Activity) IsPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.stringName != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsername returns the value safely if IsPreferredUsername returned true
|
|
func (t *Activity) GetPreferredUsername() (v string) {
|
|
return *t.preferredUsername.stringName
|
|
|
|
}
|
|
|
|
// SetPreferredUsername sets the value of preferredUsername to be of string type
|
|
func (t *Activity) SetPreferredUsername(v string) {
|
|
t.preferredUsername = &preferredUsernameActivityIntermediateType{stringName: &v}
|
|
|
|
}
|
|
|
|
// IsPreferredUsernameIRI determines whether the call to GetPreferredUsernameIRI is safe
|
|
func (t *Activity) IsPreferredUsernameIRI() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsernameIRI returns the value safely if IsPreferredUsernameIRI returned true
|
|
func (t *Activity) GetPreferredUsernameIRI() (v *url.URL) {
|
|
return t.preferredUsername.IRI
|
|
|
|
}
|
|
|
|
// SetPreferredUsernameIRI sets the value of preferredUsername to be of *url.URL type
|
|
func (t *Activity) SetPreferredUsernameIRI(v *url.URL) {
|
|
t.preferredUsername = &preferredUsernameActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPreferredUsername determines whether the call to GetUnknownPreferredUsername is safe
|
|
func (t *Activity) HasUnknownPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreferredUsername returns the unknown value for preferredUsername
|
|
func (t *Activity) GetUnknownPreferredUsername() (v interface{}) {
|
|
return t.preferredUsername.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreferredUsername sets the unknown value of preferredUsername
|
|
func (t *Activity) SetUnknownPreferredUsername(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &preferredUsernameActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preferredUsername = tmp
|
|
|
|
}
|
|
|
|
// PreferredUsernameMapLanguages returns all languages for this property's language mapping, or nil if there are none.
|
|
func (t *Activity) 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 *Activity) 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 *Activity) 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 *Activity) IsEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.Object != nil
|
|
|
|
}
|
|
|
|
// GetEndpoints returns the value safely if IsEndpoints returned true
|
|
func (t *Activity) GetEndpoints() (v ObjectType) {
|
|
return t.endpoints.Object
|
|
|
|
}
|
|
|
|
// SetEndpoints sets the value of endpoints to be of ObjectType type
|
|
func (t *Activity) SetEndpoints(v ObjectType) {
|
|
t.endpoints = &endpointsActivityIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsEndpointsIRI determines whether the call to GetEndpointsIRI is safe
|
|
func (t *Activity) IsEndpointsIRI() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndpointsIRI returns the value safely if IsEndpointsIRI returned true
|
|
func (t *Activity) GetEndpointsIRI() (v *url.URL) {
|
|
return t.endpoints.IRI
|
|
|
|
}
|
|
|
|
// SetEndpointsIRI sets the value of endpoints to be of *url.URL type
|
|
func (t *Activity) SetEndpointsIRI(v *url.URL) {
|
|
t.endpoints = &endpointsActivityIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndpoints determines whether the call to GetUnknownEndpoints is safe
|
|
func (t *Activity) HasUnknownEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndpoints returns the unknown value for endpoints
|
|
func (t *Activity) GetUnknownEndpoints() (v interface{}) {
|
|
return t.endpoints.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndpoints sets the unknown value of endpoints
|
|
func (t *Activity) SetUnknownEndpoints(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endpointsActivityIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.endpoints = tmp
|
|
|
|
}
|
|
|
|
// HasProxyUrl determines whether the call to GetProxyUrl is safe
|
|
func (t *Activity) HasProxyUrl() (ok bool) {
|
|
return t.proxyUrl != nil
|
|
|
|
}
|
|
|
|
// GetProxyUrl returns the value for proxyUrl
|
|
func (t *Activity) GetProxyUrl() (v *url.URL) {
|
|
return t.proxyUrl
|
|
|
|
}
|
|
|
|
// SetProxyUrl sets the value of proxyUrl
|
|
func (t *Activity) SetProxyUrl(v *url.URL) {
|
|
t.proxyUrl = v
|
|
|
|
}
|
|
|
|
// HasUnknownProxyUrl determines whether the call to GetUnknownProxyUrl is safe
|
|
func (t *Activity) HasUnknownProxyUrl() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["proxyUrl"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProxyUrl returns the unknown value for proxyUrl
|
|
func (t *Activity) GetUnknownProxyUrl() (v interface{}) {
|
|
return t.unknown_["proxyUrl"]
|
|
|
|
}
|
|
|
|
// SetUnknownProxyUrl sets the unknown value of proxyUrl
|
|
func (t *Activity) 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 *Activity) HasOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.oauthAuthorizationEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthAuthorizationEndpoint returns the value for oauthAuthorizationEndpoint
|
|
func (t *Activity) GetOauthAuthorizationEndpoint() (v *url.URL) {
|
|
return t.oauthAuthorizationEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthAuthorizationEndpoint sets the value of oauthAuthorizationEndpoint
|
|
func (t *Activity) SetOauthAuthorizationEndpoint(v *url.URL) {
|
|
t.oauthAuthorizationEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthAuthorizationEndpoint determines whether the call to GetUnknownOauthAuthorizationEndpoint is safe
|
|
func (t *Activity) HasUnknownOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthAuthorizationEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthAuthorizationEndpoint returns the unknown value for oauthAuthorizationEndpoint
|
|
func (t *Activity) GetUnknownOauthAuthorizationEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthAuthorizationEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthAuthorizationEndpoint sets the unknown value of oauthAuthorizationEndpoint
|
|
func (t *Activity) 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 *Activity) HasOauthTokenEndpoint() (ok bool) {
|
|
return t.oauthTokenEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthTokenEndpoint returns the value for oauthTokenEndpoint
|
|
func (t *Activity) GetOauthTokenEndpoint() (v *url.URL) {
|
|
return t.oauthTokenEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthTokenEndpoint sets the value of oauthTokenEndpoint
|
|
func (t *Activity) SetOauthTokenEndpoint(v *url.URL) {
|
|
t.oauthTokenEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthTokenEndpoint determines whether the call to GetUnknownOauthTokenEndpoint is safe
|
|
func (t *Activity) HasUnknownOauthTokenEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthTokenEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthTokenEndpoint returns the unknown value for oauthTokenEndpoint
|
|
func (t *Activity) GetUnknownOauthTokenEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthTokenEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthTokenEndpoint sets the unknown value of oauthTokenEndpoint
|
|
func (t *Activity) 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 *Activity) HasProvideClientKey() (ok bool) {
|
|
return t.provideClientKey != nil
|
|
|
|
}
|
|
|
|
// GetProvideClientKey returns the value for provideClientKey
|
|
func (t *Activity) GetProvideClientKey() (v *url.URL) {
|
|
return t.provideClientKey
|
|
|
|
}
|
|
|
|
// SetProvideClientKey sets the value of provideClientKey
|
|
func (t *Activity) SetProvideClientKey(v *url.URL) {
|
|
t.provideClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownProvideClientKey determines whether the call to GetUnknownProvideClientKey is safe
|
|
func (t *Activity) HasUnknownProvideClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["provideClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProvideClientKey returns the unknown value for provideClientKey
|
|
func (t *Activity) GetUnknownProvideClientKey() (v interface{}) {
|
|
return t.unknown_["provideClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownProvideClientKey sets the unknown value of provideClientKey
|
|
func (t *Activity) 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 *Activity) HasSignClientKey() (ok bool) {
|
|
return t.signClientKey != nil
|
|
|
|
}
|
|
|
|
// GetSignClientKey returns the value for signClientKey
|
|
func (t *Activity) GetSignClientKey() (v *url.URL) {
|
|
return t.signClientKey
|
|
|
|
}
|
|
|
|
// SetSignClientKey sets the value of signClientKey
|
|
func (t *Activity) SetSignClientKey(v *url.URL) {
|
|
t.signClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownSignClientKey determines whether the call to GetUnknownSignClientKey is safe
|
|
func (t *Activity) HasUnknownSignClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["signClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSignClientKey returns the unknown value for signClientKey
|
|
func (t *Activity) GetUnknownSignClientKey() (v interface{}) {
|
|
return t.unknown_["signClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownSignClientKey sets the unknown value of signClientKey
|
|
func (t *Activity) 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 *Activity) HasSharedInbox() (ok bool) {
|
|
return t.sharedInbox != nil
|
|
|
|
}
|
|
|
|
// GetSharedInbox returns the value for sharedInbox
|
|
func (t *Activity) GetSharedInbox() (v *url.URL) {
|
|
return t.sharedInbox
|
|
|
|
}
|
|
|
|
// SetSharedInbox sets the value of sharedInbox
|
|
func (t *Activity) SetSharedInbox(v *url.URL) {
|
|
t.sharedInbox = v
|
|
|
|
}
|
|
|
|
// HasUnknownSharedInbox determines whether the call to GetUnknownSharedInbox is safe
|
|
func (t *Activity) HasUnknownSharedInbox() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["sharedInbox"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSharedInbox returns the unknown value for sharedInbox
|
|
func (t *Activity) GetUnknownSharedInbox() (v interface{}) {
|
|
return t.unknown_["sharedInbox"]
|
|
|
|
}
|
|
|
|
// SetUnknownSharedInbox sets the unknown value of sharedInbox
|
|
func (t *Activity) 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 *Activity) AddUnknown(k string, i interface{}) (this *Activity) {
|
|
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 *Activity) 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 *Activity) RemoveUnknown(k string) (this *Activity) {
|
|
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 "Activity" if not manually set by the caller
|
|
func (t *Activity) 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 == "Activity" {
|
|
typeAlreadySet = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !typeAlreadySet {
|
|
t.typeName = append(t.typeName, "Activity")
|
|
}
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceActorActivityIntermediateType(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 := serializeSliceObjectActivityIntermediateType(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 := serializeSliceTargetActivityIntermediateType(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 := serializeSliceResultActivityIntermediateType(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 := serializeSliceOriginActivityIntermediateType(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 := serializeSliceInstrumentActivityIntermediateType(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 := serializeAltitudeActivityIntermediateType(t.altitude); err == nil {
|
|
m["altitude"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceAttachmentActivityIntermediateType(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 := serializeSliceAttributedToActivityIntermediateType(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 := serializeSliceAudienceActivityIntermediateType(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 := serializeSliceContentActivityIntermediateType(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 := serializeSliceContextActivityIntermediateType(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 := serializeSliceNameActivityIntermediateType(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 := serializeEndTimeActivityIntermediateType(t.endTime); err == nil {
|
|
m["endTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceGeneratorActivityIntermediateType(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 := serializeSliceIconActivityIntermediateType(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 := serializeSliceImageActivityIntermediateType(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 := serializeSliceInReplyToActivityIntermediateType(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 := serializeSliceLocationActivityIntermediateType(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 := serializeSlicePreviewActivityIntermediateType(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 := serializePublishedActivityIntermediateType(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 := serializeRepliesActivityIntermediateType(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 := serializeStartTimeActivityIntermediateType(t.startTime); err == nil {
|
|
m["startTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceSummaryActivityIntermediateType(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 := serializeSliceTagActivityIntermediateType(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 := serializeUpdatedActivityIntermediateType(t.updated); err == nil {
|
|
m["updated"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceUrlActivityIntermediateType(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 := serializeSliceToActivityIntermediateType(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 := serializeSliceBtoActivityIntermediateType(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 := serializeSliceCcActivityIntermediateType(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 := serializeSliceBccActivityIntermediateType(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 := serializeMediaTypeActivityIntermediateType(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 := serializeDurationActivityIntermediateType(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 := serializeSourceActivityIntermediateType(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 := serializeInboxActivityIntermediateType(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 := serializeOutboxActivityIntermediateType(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 := serializeFollowingActivityIntermediateType(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 := serializeFollowersActivityIntermediateType(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 := serializeLikedActivityIntermediateType(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 := serializeLikesActivityIntermediateType(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 := serializePreferredUsernameActivityIntermediateType(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 := serializeEndpointsActivityIntermediateType(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 *Activity) 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 := deserializeActorActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.actor, err = deserializeSliceActorActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &actorActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorActivityIntermediateType{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 := deserializeObjectActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.object, err = deserializeSliceObjectActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &objectActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectActivityIntermediateType{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 := deserializeTargetActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.target, err = deserializeSliceTargetActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &targetActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetActivityIntermediateType{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 := deserializeResultActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.result, err = deserializeSliceResultActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &resultActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultActivityIntermediateType{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 := deserializeOriginActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.origin, err = deserializeSliceOriginActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &originActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originActivityIntermediateType{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 := deserializeInstrumentActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.instrument, err = deserializeSliceInstrumentActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &instrumentActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentActivityIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "altitude" {
|
|
t.altitude, err = deserializeAltitudeActivityIntermediateType(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 := deserializeAttachmentActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attachment, err = deserializeSliceAttachmentActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attachmentActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentActivityIntermediateType{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 := deserializeAttributedToActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attributedTo, err = deserializeSliceAttributedToActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attributedToActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToActivityIntermediateType{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 := deserializeAudienceActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.audience, err = deserializeSliceAudienceActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &audienceActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceActivityIntermediateType{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 := deserializeContentActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.content, err = deserializeSliceContentActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contentActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentActivityIntermediateType{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 := deserializeContextActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.context, err = deserializeSliceContextActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contextActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextActivityIntermediateType{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 := deserializeNameActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.name, err = deserializeSliceNameActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &nameActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameActivityIntermediateType{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 = deserializeEndTimeActivityIntermediateType(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 := deserializeGeneratorActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.generator, err = deserializeSliceGeneratorActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &generatorActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorActivityIntermediateType{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 := deserializeIconActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.icon, err = deserializeSliceIconActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &iconActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconActivityIntermediateType{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 := deserializeImageActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.image, err = deserializeSliceImageActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &imageActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageActivityIntermediateType{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 := deserializeInReplyToActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.inReplyTo, err = deserializeSliceInReplyToActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &inReplyToActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToActivityIntermediateType{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 := deserializeLocationActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.location, err = deserializeSliceLocationActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &locationActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationActivityIntermediateType{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 := deserializePreviewActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.preview, err = deserializeSlicePreviewActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &previewActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewActivityIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "published" {
|
|
t.published, err = deserializePublishedActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "replies" {
|
|
t.replies, err = deserializeRepliesActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "startTime" {
|
|
t.startTime, err = deserializeStartTimeActivityIntermediateType(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 := deserializeSummaryActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.summary, err = deserializeSliceSummaryActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &summaryActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryActivityIntermediateType{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 := deserializeTagActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.tag, err = deserializeSliceTagActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &tagActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagActivityIntermediateType{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 = deserializeUpdatedActivityIntermediateType(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 := deserializeUrlActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.url, err = deserializeSliceUrlActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &urlActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlActivityIntermediateType{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 := deserializeToActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.to, err = deserializeSliceToActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &toActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toActivityIntermediateType{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 := deserializeBtoActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bto, err = deserializeSliceBtoActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &btoActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoActivityIntermediateType{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 := deserializeCcActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.cc, err = deserializeSliceCcActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &ccActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccActivityIntermediateType{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 := deserializeBccActivityIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccActivityIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bcc, err = deserializeSliceBccActivityIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &bccActivityIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccActivityIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "mediaType" {
|
|
t.mediaType, err = deserializeMediaTypeActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "duration" {
|
|
t.duration, err = deserializeDurationActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "source" {
|
|
t.source, err = deserializeSourceActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "inbox" {
|
|
t.inbox, err = deserializeInboxActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "outbox" {
|
|
t.outbox, err = deserializeOutboxActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "following" {
|
|
t.following, err = deserializeFollowingActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "followers" {
|
|
t.followers, err = deserializeFollowersActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "liked" {
|
|
t.liked, err = deserializeLikedActivityIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "likes" {
|
|
t.likes, err = deserializeLikesActivityIntermediateType(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 = deserializePreferredUsernameActivityIntermediateType(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 = deserializeEndpointsActivityIntermediateType(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
|
|
|
|
}
|
|
|
|
// actorActivityIntermediateType will only have one of its values set at most
|
|
type actorActivityIntermediateType 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 *actorActivityIntermediateType) 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 *actorActivityIntermediateType) 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
|
|
}
|
|
|
|
// objectActivityIntermediateType will only have one of its values set at most
|
|
type objectActivityIntermediateType 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 *objectActivityIntermediateType) 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 *objectActivityIntermediateType) 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
|
|
}
|
|
|
|
// targetActivityIntermediateType will only have one of its values set at most
|
|
type targetActivityIntermediateType 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 *targetActivityIntermediateType) 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 *targetActivityIntermediateType) 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
|
|
}
|
|
|
|
// resultActivityIntermediateType will only have one of its values set at most
|
|
type resultActivityIntermediateType 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 *resultActivityIntermediateType) 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 *resultActivityIntermediateType) 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
|
|
}
|
|
|
|
// originActivityIntermediateType will only have one of its values set at most
|
|
type originActivityIntermediateType 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 *originActivityIntermediateType) 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 *originActivityIntermediateType) 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
|
|
}
|
|
|
|
// instrumentActivityIntermediateType will only have one of its values set at most
|
|
type instrumentActivityIntermediateType 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 *instrumentActivityIntermediateType) 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 *instrumentActivityIntermediateType) 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
|
|
}
|
|
|
|
// altitudeActivityIntermediateType will only have one of its values set at most
|
|
type altitudeActivityIntermediateType 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 *altitudeActivityIntermediateType) 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 *altitudeActivityIntermediateType) 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
|
|
}
|
|
|
|
// attachmentActivityIntermediateType will only have one of its values set at most
|
|
type attachmentActivityIntermediateType 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 *attachmentActivityIntermediateType) 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 *attachmentActivityIntermediateType) 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
|
|
}
|
|
|
|
// attributedToActivityIntermediateType will only have one of its values set at most
|
|
type attributedToActivityIntermediateType 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 *attributedToActivityIntermediateType) 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 *attributedToActivityIntermediateType) 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
|
|
}
|
|
|
|
// audienceActivityIntermediateType will only have one of its values set at most
|
|
type audienceActivityIntermediateType 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 *audienceActivityIntermediateType) 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 *audienceActivityIntermediateType) 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
|
|
}
|
|
|
|
// contentActivityIntermediateType will only have one of its values set at most
|
|
type contentActivityIntermediateType 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 *contentActivityIntermediateType) 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 *contentActivityIntermediateType) 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
|
|
}
|
|
|
|
// contextActivityIntermediateType will only have one of its values set at most
|
|
type contextActivityIntermediateType 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 *contextActivityIntermediateType) 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 *contextActivityIntermediateType) 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
|
|
}
|
|
|
|
// nameActivityIntermediateType will only have one of its values set at most
|
|
type nameActivityIntermediateType 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 *nameActivityIntermediateType) 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 *nameActivityIntermediateType) 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
|
|
}
|
|
|
|
// endTimeActivityIntermediateType will only have one of its values set at most
|
|
type endTimeActivityIntermediateType 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 *endTimeActivityIntermediateType) 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 *endTimeActivityIntermediateType) 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
|
|
}
|
|
|
|
// generatorActivityIntermediateType will only have one of its values set at most
|
|
type generatorActivityIntermediateType 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 *generatorActivityIntermediateType) 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 *generatorActivityIntermediateType) 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
|
|
}
|
|
|
|
// iconActivityIntermediateType will only have one of its values set at most
|
|
type iconActivityIntermediateType 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 *iconActivityIntermediateType) 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 *iconActivityIntermediateType) 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
|
|
}
|
|
|
|
// imageActivityIntermediateType will only have one of its values set at most
|
|
type imageActivityIntermediateType 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 *imageActivityIntermediateType) 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 *imageActivityIntermediateType) 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
|
|
}
|
|
|
|
// inReplyToActivityIntermediateType will only have one of its values set at most
|
|
type inReplyToActivityIntermediateType 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 *inReplyToActivityIntermediateType) 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 *inReplyToActivityIntermediateType) 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
|
|
}
|
|
|
|
// locationActivityIntermediateType will only have one of its values set at most
|
|
type locationActivityIntermediateType 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 *locationActivityIntermediateType) 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 *locationActivityIntermediateType) 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
|
|
}
|
|
|
|
// previewActivityIntermediateType will only have one of its values set at most
|
|
type previewActivityIntermediateType 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 *previewActivityIntermediateType) 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 *previewActivityIntermediateType) 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
|
|
}
|
|
|
|
// publishedActivityIntermediateType will only have one of its values set at most
|
|
type publishedActivityIntermediateType 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 *publishedActivityIntermediateType) 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 *publishedActivityIntermediateType) 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
|
|
}
|
|
|
|
// repliesActivityIntermediateType will only have one of its values set at most
|
|
type repliesActivityIntermediateType 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 *repliesActivityIntermediateType) 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 *repliesActivityIntermediateType) 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
|
|
}
|
|
|
|
// startTimeActivityIntermediateType will only have one of its values set at most
|
|
type startTimeActivityIntermediateType 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 *startTimeActivityIntermediateType) 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 *startTimeActivityIntermediateType) 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
|
|
}
|
|
|
|
// summaryActivityIntermediateType will only have one of its values set at most
|
|
type summaryActivityIntermediateType 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 *summaryActivityIntermediateType) 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 *summaryActivityIntermediateType) 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
|
|
}
|
|
|
|
// tagActivityIntermediateType will only have one of its values set at most
|
|
type tagActivityIntermediateType 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 *tagActivityIntermediateType) 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 *tagActivityIntermediateType) 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
|
|
}
|
|
|
|
// updatedActivityIntermediateType will only have one of its values set at most
|
|
type updatedActivityIntermediateType 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 *updatedActivityIntermediateType) 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 *updatedActivityIntermediateType) 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
|
|
}
|
|
|
|
// urlActivityIntermediateType will only have one of its values set at most
|
|
type urlActivityIntermediateType 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 *urlActivityIntermediateType) 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 *urlActivityIntermediateType) 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
|
|
}
|
|
|
|
// toActivityIntermediateType will only have one of its values set at most
|
|
type toActivityIntermediateType 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 *toActivityIntermediateType) 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 *toActivityIntermediateType) 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
|
|
}
|
|
|
|
// btoActivityIntermediateType will only have one of its values set at most
|
|
type btoActivityIntermediateType 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 *btoActivityIntermediateType) 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 *btoActivityIntermediateType) 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
|
|
}
|
|
|
|
// ccActivityIntermediateType will only have one of its values set at most
|
|
type ccActivityIntermediateType 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 *ccActivityIntermediateType) 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 *ccActivityIntermediateType) 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
|
|
}
|
|
|
|
// bccActivityIntermediateType will only have one of its values set at most
|
|
type bccActivityIntermediateType 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 *bccActivityIntermediateType) 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 *bccActivityIntermediateType) 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
|
|
}
|
|
|
|
// mediaTypeActivityIntermediateType will only have one of its values set at most
|
|
type mediaTypeActivityIntermediateType 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 *mediaTypeActivityIntermediateType) 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 *mediaTypeActivityIntermediateType) 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
|
|
}
|
|
|
|
// durationActivityIntermediateType will only have one of its values set at most
|
|
type durationActivityIntermediateType 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 *durationActivityIntermediateType) 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 *durationActivityIntermediateType) 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
|
|
}
|
|
|
|
// sourceActivityIntermediateType will only have one of its values set at most
|
|
type sourceActivityIntermediateType 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 *sourceActivityIntermediateType) 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 *sourceActivityIntermediateType) 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
|
|
}
|
|
|
|
// inboxActivityIntermediateType will only have one of its values set at most
|
|
type inboxActivityIntermediateType 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 *inboxActivityIntermediateType) 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 *inboxActivityIntermediateType) 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
|
|
}
|
|
|
|
// outboxActivityIntermediateType will only have one of its values set at most
|
|
type outboxActivityIntermediateType 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 *outboxActivityIntermediateType) 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 *outboxActivityIntermediateType) 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
|
|
}
|
|
|
|
// followingActivityIntermediateType will only have one of its values set at most
|
|
type followingActivityIntermediateType 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 *followingActivityIntermediateType) 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 *followingActivityIntermediateType) 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
|
|
}
|
|
|
|
// followersActivityIntermediateType will only have one of its values set at most
|
|
type followersActivityIntermediateType 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 *followersActivityIntermediateType) 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 *followersActivityIntermediateType) 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
|
|
}
|
|
|
|
// likedActivityIntermediateType will only have one of its values set at most
|
|
type likedActivityIntermediateType 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 *likedActivityIntermediateType) 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 *likedActivityIntermediateType) 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
|
|
}
|
|
|
|
// likesActivityIntermediateType will only have one of its values set at most
|
|
type likesActivityIntermediateType 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 *likesActivityIntermediateType) 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 *likesActivityIntermediateType) 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
|
|
}
|
|
|
|
// preferredUsernameActivityIntermediateType will only have one of its values set at most
|
|
type preferredUsernameActivityIntermediateType 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 *preferredUsernameActivityIntermediateType) 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 *preferredUsernameActivityIntermediateType) 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
|
|
}
|
|
|
|
// endpointsActivityIntermediateType will only have one of its values set at most
|
|
type endpointsActivityIntermediateType 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 *endpointsActivityIntermediateType) 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 *endpointsActivityIntermediateType) 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
|
|
}
|
|
|
|
// deserializeactorActivityIntermediateType will accept a map to create a actorActivityIntermediateType
|
|
func deserializeActorActivityIntermediateType(in interface{}) (t *actorActivityIntermediateType, err error) {
|
|
tmp := &actorActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice actorActivityIntermediateType will accept a slice to create a slice of actorActivityIntermediateType
|
|
func deserializeSliceActorActivityIntermediateType(in []interface{}) (t []*actorActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &actorActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeactorActivityIntermediateType will accept a actorActivityIntermediateType to create a map
|
|
func serializeActorActivityIntermediateType(t *actorActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceactorActivityIntermediateType will accept a slice of actorActivityIntermediateType to create a slice result
|
|
func serializeSliceActorActivityIntermediateType(s []*actorActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeobjectActivityIntermediateType will accept a map to create a objectActivityIntermediateType
|
|
func deserializeObjectActivityIntermediateType(in interface{}) (t *objectActivityIntermediateType, err error) {
|
|
tmp := &objectActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice objectActivityIntermediateType will accept a slice to create a slice of objectActivityIntermediateType
|
|
func deserializeSliceObjectActivityIntermediateType(in []interface{}) (t []*objectActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &objectActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeobjectActivityIntermediateType will accept a objectActivityIntermediateType to create a map
|
|
func serializeObjectActivityIntermediateType(t *objectActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceobjectActivityIntermediateType will accept a slice of objectActivityIntermediateType to create a slice result
|
|
func serializeSliceObjectActivityIntermediateType(s []*objectActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetargetActivityIntermediateType will accept a map to create a targetActivityIntermediateType
|
|
func deserializeTargetActivityIntermediateType(in interface{}) (t *targetActivityIntermediateType, err error) {
|
|
tmp := &targetActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice targetActivityIntermediateType will accept a slice to create a slice of targetActivityIntermediateType
|
|
func deserializeSliceTargetActivityIntermediateType(in []interface{}) (t []*targetActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &targetActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetargetActivityIntermediateType will accept a targetActivityIntermediateType to create a map
|
|
func serializeTargetActivityIntermediateType(t *targetActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetargetActivityIntermediateType will accept a slice of targetActivityIntermediateType to create a slice result
|
|
func serializeSliceTargetActivityIntermediateType(s []*targetActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeresultActivityIntermediateType will accept a map to create a resultActivityIntermediateType
|
|
func deserializeResultActivityIntermediateType(in interface{}) (t *resultActivityIntermediateType, err error) {
|
|
tmp := &resultActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice resultActivityIntermediateType will accept a slice to create a slice of resultActivityIntermediateType
|
|
func deserializeSliceResultActivityIntermediateType(in []interface{}) (t []*resultActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &resultActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeresultActivityIntermediateType will accept a resultActivityIntermediateType to create a map
|
|
func serializeResultActivityIntermediateType(t *resultActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceresultActivityIntermediateType will accept a slice of resultActivityIntermediateType to create a slice result
|
|
func serializeSliceResultActivityIntermediateType(s []*resultActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoriginActivityIntermediateType will accept a map to create a originActivityIntermediateType
|
|
func deserializeOriginActivityIntermediateType(in interface{}) (t *originActivityIntermediateType, err error) {
|
|
tmp := &originActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice originActivityIntermediateType will accept a slice to create a slice of originActivityIntermediateType
|
|
func deserializeSliceOriginActivityIntermediateType(in []interface{}) (t []*originActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &originActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoriginActivityIntermediateType will accept a originActivityIntermediateType to create a map
|
|
func serializeOriginActivityIntermediateType(t *originActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoriginActivityIntermediateType will accept a slice of originActivityIntermediateType to create a slice result
|
|
func serializeSliceOriginActivityIntermediateType(s []*originActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinstrumentActivityIntermediateType will accept a map to create a instrumentActivityIntermediateType
|
|
func deserializeInstrumentActivityIntermediateType(in interface{}) (t *instrumentActivityIntermediateType, err error) {
|
|
tmp := &instrumentActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice instrumentActivityIntermediateType will accept a slice to create a slice of instrumentActivityIntermediateType
|
|
func deserializeSliceInstrumentActivityIntermediateType(in []interface{}) (t []*instrumentActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &instrumentActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinstrumentActivityIntermediateType will accept a instrumentActivityIntermediateType to create a map
|
|
func serializeInstrumentActivityIntermediateType(t *instrumentActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinstrumentActivityIntermediateType will accept a slice of instrumentActivityIntermediateType to create a slice result
|
|
func serializeSliceInstrumentActivityIntermediateType(s []*instrumentActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializealtitudeActivityIntermediateType will accept a map to create a altitudeActivityIntermediateType
|
|
func deserializeAltitudeActivityIntermediateType(in interface{}) (t *altitudeActivityIntermediateType, err error) {
|
|
tmp := &altitudeActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice altitudeActivityIntermediateType will accept a slice to create a slice of altitudeActivityIntermediateType
|
|
func deserializeSliceAltitudeActivityIntermediateType(in []interface{}) (t []*altitudeActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &altitudeActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializealtitudeActivityIntermediateType will accept a altitudeActivityIntermediateType to create a map
|
|
func serializeAltitudeActivityIntermediateType(t *altitudeActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicealtitudeActivityIntermediateType will accept a slice of altitudeActivityIntermediateType to create a slice result
|
|
func serializeSliceAltitudeActivityIntermediateType(s []*altitudeActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattachmentActivityIntermediateType will accept a map to create a attachmentActivityIntermediateType
|
|
func deserializeAttachmentActivityIntermediateType(in interface{}) (t *attachmentActivityIntermediateType, err error) {
|
|
tmp := &attachmentActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attachmentActivityIntermediateType will accept a slice to create a slice of attachmentActivityIntermediateType
|
|
func deserializeSliceAttachmentActivityIntermediateType(in []interface{}) (t []*attachmentActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attachmentActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattachmentActivityIntermediateType will accept a attachmentActivityIntermediateType to create a map
|
|
func serializeAttachmentActivityIntermediateType(t *attachmentActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattachmentActivityIntermediateType will accept a slice of attachmentActivityIntermediateType to create a slice result
|
|
func serializeSliceAttachmentActivityIntermediateType(s []*attachmentActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattributedToActivityIntermediateType will accept a map to create a attributedToActivityIntermediateType
|
|
func deserializeAttributedToActivityIntermediateType(in interface{}) (t *attributedToActivityIntermediateType, err error) {
|
|
tmp := &attributedToActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attributedToActivityIntermediateType will accept a slice to create a slice of attributedToActivityIntermediateType
|
|
func deserializeSliceAttributedToActivityIntermediateType(in []interface{}) (t []*attributedToActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attributedToActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattributedToActivityIntermediateType will accept a attributedToActivityIntermediateType to create a map
|
|
func serializeAttributedToActivityIntermediateType(t *attributedToActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattributedToActivityIntermediateType will accept a slice of attributedToActivityIntermediateType to create a slice result
|
|
func serializeSliceAttributedToActivityIntermediateType(s []*attributedToActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeaudienceActivityIntermediateType will accept a map to create a audienceActivityIntermediateType
|
|
func deserializeAudienceActivityIntermediateType(in interface{}) (t *audienceActivityIntermediateType, err error) {
|
|
tmp := &audienceActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice audienceActivityIntermediateType will accept a slice to create a slice of audienceActivityIntermediateType
|
|
func deserializeSliceAudienceActivityIntermediateType(in []interface{}) (t []*audienceActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &audienceActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeaudienceActivityIntermediateType will accept a audienceActivityIntermediateType to create a map
|
|
func serializeAudienceActivityIntermediateType(t *audienceActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceaudienceActivityIntermediateType will accept a slice of audienceActivityIntermediateType to create a slice result
|
|
func serializeSliceAudienceActivityIntermediateType(s []*audienceActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontentActivityIntermediateType will accept a map to create a contentActivityIntermediateType
|
|
func deserializeContentActivityIntermediateType(in interface{}) (t *contentActivityIntermediateType, err error) {
|
|
tmp := &contentActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contentActivityIntermediateType will accept a slice to create a slice of contentActivityIntermediateType
|
|
func deserializeSliceContentActivityIntermediateType(in []interface{}) (t []*contentActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contentActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontentActivityIntermediateType will accept a contentActivityIntermediateType to create a map
|
|
func serializeContentActivityIntermediateType(t *contentActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontentActivityIntermediateType will accept a slice of contentActivityIntermediateType to create a slice result
|
|
func serializeSliceContentActivityIntermediateType(s []*contentActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontextActivityIntermediateType will accept a map to create a contextActivityIntermediateType
|
|
func deserializeContextActivityIntermediateType(in interface{}) (t *contextActivityIntermediateType, err error) {
|
|
tmp := &contextActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contextActivityIntermediateType will accept a slice to create a slice of contextActivityIntermediateType
|
|
func deserializeSliceContextActivityIntermediateType(in []interface{}) (t []*contextActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contextActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontextActivityIntermediateType will accept a contextActivityIntermediateType to create a map
|
|
func serializeContextActivityIntermediateType(t *contextActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontextActivityIntermediateType will accept a slice of contextActivityIntermediateType to create a slice result
|
|
func serializeSliceContextActivityIntermediateType(s []*contextActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializenameActivityIntermediateType will accept a map to create a nameActivityIntermediateType
|
|
func deserializeNameActivityIntermediateType(in interface{}) (t *nameActivityIntermediateType, err error) {
|
|
tmp := &nameActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice nameActivityIntermediateType will accept a slice to create a slice of nameActivityIntermediateType
|
|
func deserializeSliceNameActivityIntermediateType(in []interface{}) (t []*nameActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &nameActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializenameActivityIntermediateType will accept a nameActivityIntermediateType to create a map
|
|
func serializeNameActivityIntermediateType(t *nameActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicenameActivityIntermediateType will accept a slice of nameActivityIntermediateType to create a slice result
|
|
func serializeSliceNameActivityIntermediateType(s []*nameActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendTimeActivityIntermediateType will accept a map to create a endTimeActivityIntermediateType
|
|
func deserializeEndTimeActivityIntermediateType(in interface{}) (t *endTimeActivityIntermediateType, err error) {
|
|
tmp := &endTimeActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endTimeActivityIntermediateType will accept a slice to create a slice of endTimeActivityIntermediateType
|
|
func deserializeSliceEndTimeActivityIntermediateType(in []interface{}) (t []*endTimeActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endTimeActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendTimeActivityIntermediateType will accept a endTimeActivityIntermediateType to create a map
|
|
func serializeEndTimeActivityIntermediateType(t *endTimeActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendTimeActivityIntermediateType will accept a slice of endTimeActivityIntermediateType to create a slice result
|
|
func serializeSliceEndTimeActivityIntermediateType(s []*endTimeActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializegeneratorActivityIntermediateType will accept a map to create a generatorActivityIntermediateType
|
|
func deserializeGeneratorActivityIntermediateType(in interface{}) (t *generatorActivityIntermediateType, err error) {
|
|
tmp := &generatorActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice generatorActivityIntermediateType will accept a slice to create a slice of generatorActivityIntermediateType
|
|
func deserializeSliceGeneratorActivityIntermediateType(in []interface{}) (t []*generatorActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &generatorActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializegeneratorActivityIntermediateType will accept a generatorActivityIntermediateType to create a map
|
|
func serializeGeneratorActivityIntermediateType(t *generatorActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicegeneratorActivityIntermediateType will accept a slice of generatorActivityIntermediateType to create a slice result
|
|
func serializeSliceGeneratorActivityIntermediateType(s []*generatorActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeiconActivityIntermediateType will accept a map to create a iconActivityIntermediateType
|
|
func deserializeIconActivityIntermediateType(in interface{}) (t *iconActivityIntermediateType, err error) {
|
|
tmp := &iconActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice iconActivityIntermediateType will accept a slice to create a slice of iconActivityIntermediateType
|
|
func deserializeSliceIconActivityIntermediateType(in []interface{}) (t []*iconActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &iconActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeiconActivityIntermediateType will accept a iconActivityIntermediateType to create a map
|
|
func serializeIconActivityIntermediateType(t *iconActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceiconActivityIntermediateType will accept a slice of iconActivityIntermediateType to create a slice result
|
|
func serializeSliceIconActivityIntermediateType(s []*iconActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeimageActivityIntermediateType will accept a map to create a imageActivityIntermediateType
|
|
func deserializeImageActivityIntermediateType(in interface{}) (t *imageActivityIntermediateType, err error) {
|
|
tmp := &imageActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice imageActivityIntermediateType will accept a slice to create a slice of imageActivityIntermediateType
|
|
func deserializeSliceImageActivityIntermediateType(in []interface{}) (t []*imageActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &imageActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeimageActivityIntermediateType will accept a imageActivityIntermediateType to create a map
|
|
func serializeImageActivityIntermediateType(t *imageActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceimageActivityIntermediateType will accept a slice of imageActivityIntermediateType to create a slice result
|
|
func serializeSliceImageActivityIntermediateType(s []*imageActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinReplyToActivityIntermediateType will accept a map to create a inReplyToActivityIntermediateType
|
|
func deserializeInReplyToActivityIntermediateType(in interface{}) (t *inReplyToActivityIntermediateType, err error) {
|
|
tmp := &inReplyToActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inReplyToActivityIntermediateType will accept a slice to create a slice of inReplyToActivityIntermediateType
|
|
func deserializeSliceInReplyToActivityIntermediateType(in []interface{}) (t []*inReplyToActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inReplyToActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinReplyToActivityIntermediateType will accept a inReplyToActivityIntermediateType to create a map
|
|
func serializeInReplyToActivityIntermediateType(t *inReplyToActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinReplyToActivityIntermediateType will accept a slice of inReplyToActivityIntermediateType to create a slice result
|
|
func serializeSliceInReplyToActivityIntermediateType(s []*inReplyToActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelocationActivityIntermediateType will accept a map to create a locationActivityIntermediateType
|
|
func deserializeLocationActivityIntermediateType(in interface{}) (t *locationActivityIntermediateType, err error) {
|
|
tmp := &locationActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice locationActivityIntermediateType will accept a slice to create a slice of locationActivityIntermediateType
|
|
func deserializeSliceLocationActivityIntermediateType(in []interface{}) (t []*locationActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &locationActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelocationActivityIntermediateType will accept a locationActivityIntermediateType to create a map
|
|
func serializeLocationActivityIntermediateType(t *locationActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelocationActivityIntermediateType will accept a slice of locationActivityIntermediateType to create a slice result
|
|
func serializeSliceLocationActivityIntermediateType(s []*locationActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreviewActivityIntermediateType will accept a map to create a previewActivityIntermediateType
|
|
func deserializePreviewActivityIntermediateType(in interface{}) (t *previewActivityIntermediateType, err error) {
|
|
tmp := &previewActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice previewActivityIntermediateType will accept a slice to create a slice of previewActivityIntermediateType
|
|
func deserializeSlicePreviewActivityIntermediateType(in []interface{}) (t []*previewActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &previewActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreviewActivityIntermediateType will accept a previewActivityIntermediateType to create a map
|
|
func serializePreviewActivityIntermediateType(t *previewActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreviewActivityIntermediateType will accept a slice of previewActivityIntermediateType to create a slice result
|
|
func serializeSlicePreviewActivityIntermediateType(s []*previewActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepublishedActivityIntermediateType will accept a map to create a publishedActivityIntermediateType
|
|
func deserializePublishedActivityIntermediateType(in interface{}) (t *publishedActivityIntermediateType, err error) {
|
|
tmp := &publishedActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice publishedActivityIntermediateType will accept a slice to create a slice of publishedActivityIntermediateType
|
|
func deserializeSlicePublishedActivityIntermediateType(in []interface{}) (t []*publishedActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &publishedActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepublishedActivityIntermediateType will accept a publishedActivityIntermediateType to create a map
|
|
func serializePublishedActivityIntermediateType(t *publishedActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepublishedActivityIntermediateType will accept a slice of publishedActivityIntermediateType to create a slice result
|
|
func serializeSlicePublishedActivityIntermediateType(s []*publishedActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializerepliesActivityIntermediateType will accept a map to create a repliesActivityIntermediateType
|
|
func deserializeRepliesActivityIntermediateType(in interface{}) (t *repliesActivityIntermediateType, err error) {
|
|
tmp := &repliesActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice repliesActivityIntermediateType will accept a slice to create a slice of repliesActivityIntermediateType
|
|
func deserializeSliceRepliesActivityIntermediateType(in []interface{}) (t []*repliesActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &repliesActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializerepliesActivityIntermediateType will accept a repliesActivityIntermediateType to create a map
|
|
func serializeRepliesActivityIntermediateType(t *repliesActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicerepliesActivityIntermediateType will accept a slice of repliesActivityIntermediateType to create a slice result
|
|
func serializeSliceRepliesActivityIntermediateType(s []*repliesActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializestartTimeActivityIntermediateType will accept a map to create a startTimeActivityIntermediateType
|
|
func deserializeStartTimeActivityIntermediateType(in interface{}) (t *startTimeActivityIntermediateType, err error) {
|
|
tmp := &startTimeActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice startTimeActivityIntermediateType will accept a slice to create a slice of startTimeActivityIntermediateType
|
|
func deserializeSliceStartTimeActivityIntermediateType(in []interface{}) (t []*startTimeActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &startTimeActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializestartTimeActivityIntermediateType will accept a startTimeActivityIntermediateType to create a map
|
|
func serializeStartTimeActivityIntermediateType(t *startTimeActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicestartTimeActivityIntermediateType will accept a slice of startTimeActivityIntermediateType to create a slice result
|
|
func serializeSliceStartTimeActivityIntermediateType(s []*startTimeActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesummaryActivityIntermediateType will accept a map to create a summaryActivityIntermediateType
|
|
func deserializeSummaryActivityIntermediateType(in interface{}) (t *summaryActivityIntermediateType, err error) {
|
|
tmp := &summaryActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice summaryActivityIntermediateType will accept a slice to create a slice of summaryActivityIntermediateType
|
|
func deserializeSliceSummaryActivityIntermediateType(in []interface{}) (t []*summaryActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &summaryActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesummaryActivityIntermediateType will accept a summaryActivityIntermediateType to create a map
|
|
func serializeSummaryActivityIntermediateType(t *summaryActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesummaryActivityIntermediateType will accept a slice of summaryActivityIntermediateType to create a slice result
|
|
func serializeSliceSummaryActivityIntermediateType(s []*summaryActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetagActivityIntermediateType will accept a map to create a tagActivityIntermediateType
|
|
func deserializeTagActivityIntermediateType(in interface{}) (t *tagActivityIntermediateType, err error) {
|
|
tmp := &tagActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice tagActivityIntermediateType will accept a slice to create a slice of tagActivityIntermediateType
|
|
func deserializeSliceTagActivityIntermediateType(in []interface{}) (t []*tagActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &tagActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetagActivityIntermediateType will accept a tagActivityIntermediateType to create a map
|
|
func serializeTagActivityIntermediateType(t *tagActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetagActivityIntermediateType will accept a slice of tagActivityIntermediateType to create a slice result
|
|
func serializeSliceTagActivityIntermediateType(s []*tagActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeupdatedActivityIntermediateType will accept a map to create a updatedActivityIntermediateType
|
|
func deserializeUpdatedActivityIntermediateType(in interface{}) (t *updatedActivityIntermediateType, err error) {
|
|
tmp := &updatedActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice updatedActivityIntermediateType will accept a slice to create a slice of updatedActivityIntermediateType
|
|
func deserializeSliceUpdatedActivityIntermediateType(in []interface{}) (t []*updatedActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &updatedActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeupdatedActivityIntermediateType will accept a updatedActivityIntermediateType to create a map
|
|
func serializeUpdatedActivityIntermediateType(t *updatedActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceupdatedActivityIntermediateType will accept a slice of updatedActivityIntermediateType to create a slice result
|
|
func serializeSliceUpdatedActivityIntermediateType(s []*updatedActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeurlActivityIntermediateType will accept a map to create a urlActivityIntermediateType
|
|
func deserializeUrlActivityIntermediateType(in interface{}) (t *urlActivityIntermediateType, err error) {
|
|
tmp := &urlActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice urlActivityIntermediateType will accept a slice to create a slice of urlActivityIntermediateType
|
|
func deserializeSliceUrlActivityIntermediateType(in []interface{}) (t []*urlActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &urlActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeurlActivityIntermediateType will accept a urlActivityIntermediateType to create a map
|
|
func serializeUrlActivityIntermediateType(t *urlActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceurlActivityIntermediateType will accept a slice of urlActivityIntermediateType to create a slice result
|
|
func serializeSliceUrlActivityIntermediateType(s []*urlActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetoActivityIntermediateType will accept a map to create a toActivityIntermediateType
|
|
func deserializeToActivityIntermediateType(in interface{}) (t *toActivityIntermediateType, err error) {
|
|
tmp := &toActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice toActivityIntermediateType will accept a slice to create a slice of toActivityIntermediateType
|
|
func deserializeSliceToActivityIntermediateType(in []interface{}) (t []*toActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &toActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetoActivityIntermediateType will accept a toActivityIntermediateType to create a map
|
|
func serializeToActivityIntermediateType(t *toActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetoActivityIntermediateType will accept a slice of toActivityIntermediateType to create a slice result
|
|
func serializeSliceToActivityIntermediateType(s []*toActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebtoActivityIntermediateType will accept a map to create a btoActivityIntermediateType
|
|
func deserializeBtoActivityIntermediateType(in interface{}) (t *btoActivityIntermediateType, err error) {
|
|
tmp := &btoActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice btoActivityIntermediateType will accept a slice to create a slice of btoActivityIntermediateType
|
|
func deserializeSliceBtoActivityIntermediateType(in []interface{}) (t []*btoActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &btoActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebtoActivityIntermediateType will accept a btoActivityIntermediateType to create a map
|
|
func serializeBtoActivityIntermediateType(t *btoActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebtoActivityIntermediateType will accept a slice of btoActivityIntermediateType to create a slice result
|
|
func serializeSliceBtoActivityIntermediateType(s []*btoActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeccActivityIntermediateType will accept a map to create a ccActivityIntermediateType
|
|
func deserializeCcActivityIntermediateType(in interface{}) (t *ccActivityIntermediateType, err error) {
|
|
tmp := &ccActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice ccActivityIntermediateType will accept a slice to create a slice of ccActivityIntermediateType
|
|
func deserializeSliceCcActivityIntermediateType(in []interface{}) (t []*ccActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &ccActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeccActivityIntermediateType will accept a ccActivityIntermediateType to create a map
|
|
func serializeCcActivityIntermediateType(t *ccActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceccActivityIntermediateType will accept a slice of ccActivityIntermediateType to create a slice result
|
|
func serializeSliceCcActivityIntermediateType(s []*ccActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebccActivityIntermediateType will accept a map to create a bccActivityIntermediateType
|
|
func deserializeBccActivityIntermediateType(in interface{}) (t *bccActivityIntermediateType, err error) {
|
|
tmp := &bccActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice bccActivityIntermediateType will accept a slice to create a slice of bccActivityIntermediateType
|
|
func deserializeSliceBccActivityIntermediateType(in []interface{}) (t []*bccActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &bccActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebccActivityIntermediateType will accept a bccActivityIntermediateType to create a map
|
|
func serializeBccActivityIntermediateType(t *bccActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebccActivityIntermediateType will accept a slice of bccActivityIntermediateType to create a slice result
|
|
func serializeSliceBccActivityIntermediateType(s []*bccActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializemediaTypeActivityIntermediateType will accept a map to create a mediaTypeActivityIntermediateType
|
|
func deserializeMediaTypeActivityIntermediateType(in interface{}) (t *mediaTypeActivityIntermediateType, err error) {
|
|
tmp := &mediaTypeActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice mediaTypeActivityIntermediateType will accept a slice to create a slice of mediaTypeActivityIntermediateType
|
|
func deserializeSliceMediaTypeActivityIntermediateType(in []interface{}) (t []*mediaTypeActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &mediaTypeActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializemediaTypeActivityIntermediateType will accept a mediaTypeActivityIntermediateType to create a map
|
|
func serializeMediaTypeActivityIntermediateType(t *mediaTypeActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicemediaTypeActivityIntermediateType will accept a slice of mediaTypeActivityIntermediateType to create a slice result
|
|
func serializeSliceMediaTypeActivityIntermediateType(s []*mediaTypeActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializedurationActivityIntermediateType will accept a map to create a durationActivityIntermediateType
|
|
func deserializeDurationActivityIntermediateType(in interface{}) (t *durationActivityIntermediateType, err error) {
|
|
tmp := &durationActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice durationActivityIntermediateType will accept a slice to create a slice of durationActivityIntermediateType
|
|
func deserializeSliceDurationActivityIntermediateType(in []interface{}) (t []*durationActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &durationActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializedurationActivityIntermediateType will accept a durationActivityIntermediateType to create a map
|
|
func serializeDurationActivityIntermediateType(t *durationActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicedurationActivityIntermediateType will accept a slice of durationActivityIntermediateType to create a slice result
|
|
func serializeSliceDurationActivityIntermediateType(s []*durationActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesourceActivityIntermediateType will accept a map to create a sourceActivityIntermediateType
|
|
func deserializeSourceActivityIntermediateType(in interface{}) (t *sourceActivityIntermediateType, err error) {
|
|
tmp := &sourceActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice sourceActivityIntermediateType will accept a slice to create a slice of sourceActivityIntermediateType
|
|
func deserializeSliceSourceActivityIntermediateType(in []interface{}) (t []*sourceActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &sourceActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesourceActivityIntermediateType will accept a sourceActivityIntermediateType to create a map
|
|
func serializeSourceActivityIntermediateType(t *sourceActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesourceActivityIntermediateType will accept a slice of sourceActivityIntermediateType to create a slice result
|
|
func serializeSliceSourceActivityIntermediateType(s []*sourceActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinboxActivityIntermediateType will accept a map to create a inboxActivityIntermediateType
|
|
func deserializeInboxActivityIntermediateType(in interface{}) (t *inboxActivityIntermediateType, err error) {
|
|
tmp := &inboxActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inboxActivityIntermediateType will accept a slice to create a slice of inboxActivityIntermediateType
|
|
func deserializeSliceInboxActivityIntermediateType(in []interface{}) (t []*inboxActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inboxActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinboxActivityIntermediateType will accept a inboxActivityIntermediateType to create a map
|
|
func serializeInboxActivityIntermediateType(t *inboxActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinboxActivityIntermediateType will accept a slice of inboxActivityIntermediateType to create a slice result
|
|
func serializeSliceInboxActivityIntermediateType(s []*inboxActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoutboxActivityIntermediateType will accept a map to create a outboxActivityIntermediateType
|
|
func deserializeOutboxActivityIntermediateType(in interface{}) (t *outboxActivityIntermediateType, err error) {
|
|
tmp := &outboxActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice outboxActivityIntermediateType will accept a slice to create a slice of outboxActivityIntermediateType
|
|
func deserializeSliceOutboxActivityIntermediateType(in []interface{}) (t []*outboxActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &outboxActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoutboxActivityIntermediateType will accept a outboxActivityIntermediateType to create a map
|
|
func serializeOutboxActivityIntermediateType(t *outboxActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoutboxActivityIntermediateType will accept a slice of outboxActivityIntermediateType to create a slice result
|
|
func serializeSliceOutboxActivityIntermediateType(s []*outboxActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowingActivityIntermediateType will accept a map to create a followingActivityIntermediateType
|
|
func deserializeFollowingActivityIntermediateType(in interface{}) (t *followingActivityIntermediateType, err error) {
|
|
tmp := &followingActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followingActivityIntermediateType will accept a slice to create a slice of followingActivityIntermediateType
|
|
func deserializeSliceFollowingActivityIntermediateType(in []interface{}) (t []*followingActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followingActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowingActivityIntermediateType will accept a followingActivityIntermediateType to create a map
|
|
func serializeFollowingActivityIntermediateType(t *followingActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowingActivityIntermediateType will accept a slice of followingActivityIntermediateType to create a slice result
|
|
func serializeSliceFollowingActivityIntermediateType(s []*followingActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowersActivityIntermediateType will accept a map to create a followersActivityIntermediateType
|
|
func deserializeFollowersActivityIntermediateType(in interface{}) (t *followersActivityIntermediateType, err error) {
|
|
tmp := &followersActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followersActivityIntermediateType will accept a slice to create a slice of followersActivityIntermediateType
|
|
func deserializeSliceFollowersActivityIntermediateType(in []interface{}) (t []*followersActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followersActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowersActivityIntermediateType will accept a followersActivityIntermediateType to create a map
|
|
func serializeFollowersActivityIntermediateType(t *followersActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowersActivityIntermediateType will accept a slice of followersActivityIntermediateType to create a slice result
|
|
func serializeSliceFollowersActivityIntermediateType(s []*followersActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikedActivityIntermediateType will accept a map to create a likedActivityIntermediateType
|
|
func deserializeLikedActivityIntermediateType(in interface{}) (t *likedActivityIntermediateType, err error) {
|
|
tmp := &likedActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likedActivityIntermediateType will accept a slice to create a slice of likedActivityIntermediateType
|
|
func deserializeSliceLikedActivityIntermediateType(in []interface{}) (t []*likedActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likedActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikedActivityIntermediateType will accept a likedActivityIntermediateType to create a map
|
|
func serializeLikedActivityIntermediateType(t *likedActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikedActivityIntermediateType will accept a slice of likedActivityIntermediateType to create a slice result
|
|
func serializeSliceLikedActivityIntermediateType(s []*likedActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikesActivityIntermediateType will accept a map to create a likesActivityIntermediateType
|
|
func deserializeLikesActivityIntermediateType(in interface{}) (t *likesActivityIntermediateType, err error) {
|
|
tmp := &likesActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likesActivityIntermediateType will accept a slice to create a slice of likesActivityIntermediateType
|
|
func deserializeSliceLikesActivityIntermediateType(in []interface{}) (t []*likesActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likesActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikesActivityIntermediateType will accept a likesActivityIntermediateType to create a map
|
|
func serializeLikesActivityIntermediateType(t *likesActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikesActivityIntermediateType will accept a slice of likesActivityIntermediateType to create a slice result
|
|
func serializeSliceLikesActivityIntermediateType(s []*likesActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreferredUsernameActivityIntermediateType will accept a map to create a preferredUsernameActivityIntermediateType
|
|
func deserializePreferredUsernameActivityIntermediateType(in interface{}) (t *preferredUsernameActivityIntermediateType, err error) {
|
|
tmp := &preferredUsernameActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice preferredUsernameActivityIntermediateType will accept a slice to create a slice of preferredUsernameActivityIntermediateType
|
|
func deserializeSlicePreferredUsernameActivityIntermediateType(in []interface{}) (t []*preferredUsernameActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &preferredUsernameActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreferredUsernameActivityIntermediateType will accept a preferredUsernameActivityIntermediateType to create a map
|
|
func serializePreferredUsernameActivityIntermediateType(t *preferredUsernameActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreferredUsernameActivityIntermediateType will accept a slice of preferredUsernameActivityIntermediateType to create a slice result
|
|
func serializeSlicePreferredUsernameActivityIntermediateType(s []*preferredUsernameActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendpointsActivityIntermediateType will accept a map to create a endpointsActivityIntermediateType
|
|
func deserializeEndpointsActivityIntermediateType(in interface{}) (t *endpointsActivityIntermediateType, err error) {
|
|
tmp := &endpointsActivityIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endpointsActivityIntermediateType will accept a slice to create a slice of endpointsActivityIntermediateType
|
|
func deserializeSliceEndpointsActivityIntermediateType(in []interface{}) (t []*endpointsActivityIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endpointsActivityIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendpointsActivityIntermediateType will accept a endpointsActivityIntermediateType to create a map
|
|
func serializeEndpointsActivityIntermediateType(t *endpointsActivityIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendpointsActivityIntermediateType will accept a slice of endpointsActivityIntermediateType to create a slice result
|
|
func serializeSliceEndpointsActivityIntermediateType(s []*endpointsActivityIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|