11931 行
336 KiB
Go
11931 行
336 KiB
Go
//
|
|
package vocab
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
// IgnoreType is an interface for accepting types that extend from 'Ignore'.
|
|
type IgnoreType interface {
|
|
Serializer
|
|
Deserializer
|
|
ActorLen() (l int)
|
|
IsActorObject(index int) (ok bool)
|
|
GetActorObject(index int) (v ObjectType)
|
|
AppendActorObject(v ObjectType)
|
|
PrependActorObject(v ObjectType)
|
|
RemoveActorObject(index int)
|
|
IsActorLink(index int) (ok bool)
|
|
GetActorLink(index int) (v LinkType)
|
|
AppendActorLink(v LinkType)
|
|
PrependActorLink(v LinkType)
|
|
RemoveActorLink(index int)
|
|
IsActorIRI(index int) (ok bool)
|
|
GetActorIRI(index int) (v *url.URL)
|
|
AppendActorIRI(v *url.URL)
|
|
PrependActorIRI(v *url.URL)
|
|
RemoveActorIRI(index int)
|
|
ObjectLen() (l int)
|
|
IsObject(index int) (ok bool)
|
|
GetObject(index int) (v ObjectType)
|
|
AppendObject(v ObjectType)
|
|
PrependObject(v ObjectType)
|
|
RemoveObject(index int)
|
|
IsObjectIRI(index int) (ok bool)
|
|
GetObjectIRI(index int) (v *url.URL)
|
|
AppendObjectIRI(v *url.URL)
|
|
PrependObjectIRI(v *url.URL)
|
|
RemoveObjectIRI(index int)
|
|
TargetLen() (l int)
|
|
IsTargetObject(index int) (ok bool)
|
|
GetTargetObject(index int) (v ObjectType)
|
|
AppendTargetObject(v ObjectType)
|
|
PrependTargetObject(v ObjectType)
|
|
RemoveTargetObject(index int)
|
|
IsTargetLink(index int) (ok bool)
|
|
GetTargetLink(index int) (v LinkType)
|
|
AppendTargetLink(v LinkType)
|
|
PrependTargetLink(v LinkType)
|
|
RemoveTargetLink(index int)
|
|
IsTargetIRI(index int) (ok bool)
|
|
GetTargetIRI(index int) (v *url.URL)
|
|
AppendTargetIRI(v *url.URL)
|
|
PrependTargetIRI(v *url.URL)
|
|
RemoveTargetIRI(index int)
|
|
ResultLen() (l int)
|
|
IsResultObject(index int) (ok bool)
|
|
GetResultObject(index int) (v ObjectType)
|
|
AppendResultObject(v ObjectType)
|
|
PrependResultObject(v ObjectType)
|
|
RemoveResultObject(index int)
|
|
IsResultLink(index int) (ok bool)
|
|
GetResultLink(index int) (v LinkType)
|
|
AppendResultLink(v LinkType)
|
|
PrependResultLink(v LinkType)
|
|
RemoveResultLink(index int)
|
|
IsResultIRI(index int) (ok bool)
|
|
GetResultIRI(index int) (v *url.URL)
|
|
AppendResultIRI(v *url.URL)
|
|
PrependResultIRI(v *url.URL)
|
|
RemoveResultIRI(index int)
|
|
OriginLen() (l int)
|
|
IsOriginObject(index int) (ok bool)
|
|
GetOriginObject(index int) (v ObjectType)
|
|
AppendOriginObject(v ObjectType)
|
|
PrependOriginObject(v ObjectType)
|
|
RemoveOriginObject(index int)
|
|
IsOriginLink(index int) (ok bool)
|
|
GetOriginLink(index int) (v LinkType)
|
|
AppendOriginLink(v LinkType)
|
|
PrependOriginLink(v LinkType)
|
|
RemoveOriginLink(index int)
|
|
IsOriginIRI(index int) (ok bool)
|
|
GetOriginIRI(index int) (v *url.URL)
|
|
AppendOriginIRI(v *url.URL)
|
|
PrependOriginIRI(v *url.URL)
|
|
RemoveOriginIRI(index int)
|
|
InstrumentLen() (l int)
|
|
IsInstrumentObject(index int) (ok bool)
|
|
GetInstrumentObject(index int) (v ObjectType)
|
|
AppendInstrumentObject(v ObjectType)
|
|
PrependInstrumentObject(v ObjectType)
|
|
RemoveInstrumentObject(index int)
|
|
IsInstrumentLink(index int) (ok bool)
|
|
GetInstrumentLink(index int) (v LinkType)
|
|
AppendInstrumentLink(v LinkType)
|
|
PrependInstrumentLink(v LinkType)
|
|
RemoveInstrumentLink(index int)
|
|
IsInstrumentIRI(index int) (ok bool)
|
|
GetInstrumentIRI(index int) (v *url.URL)
|
|
AppendInstrumentIRI(v *url.URL)
|
|
PrependInstrumentIRI(v *url.URL)
|
|
RemoveInstrumentIRI(index int)
|
|
IsAltitude() (ok bool)
|
|
GetAltitude() (v float64)
|
|
SetAltitude(v float64)
|
|
IsAltitudeIRI() (ok bool)
|
|
GetAltitudeIRI() (v *url.URL)
|
|
SetAltitudeIRI(v *url.URL)
|
|
AttachmentLen() (l int)
|
|
IsAttachmentObject(index int) (ok bool)
|
|
GetAttachmentObject(index int) (v ObjectType)
|
|
AppendAttachmentObject(v ObjectType)
|
|
PrependAttachmentObject(v ObjectType)
|
|
RemoveAttachmentObject(index int)
|
|
IsAttachmentLink(index int) (ok bool)
|
|
GetAttachmentLink(index int) (v LinkType)
|
|
AppendAttachmentLink(v LinkType)
|
|
PrependAttachmentLink(v LinkType)
|
|
RemoveAttachmentLink(index int)
|
|
IsAttachmentIRI(index int) (ok bool)
|
|
GetAttachmentIRI(index int) (v *url.URL)
|
|
AppendAttachmentIRI(v *url.URL)
|
|
PrependAttachmentIRI(v *url.URL)
|
|
RemoveAttachmentIRI(index int)
|
|
AttributedToLen() (l int)
|
|
IsAttributedToObject(index int) (ok bool)
|
|
GetAttributedToObject(index int) (v ObjectType)
|
|
AppendAttributedToObject(v ObjectType)
|
|
PrependAttributedToObject(v ObjectType)
|
|
RemoveAttributedToObject(index int)
|
|
IsAttributedToLink(index int) (ok bool)
|
|
GetAttributedToLink(index int) (v LinkType)
|
|
AppendAttributedToLink(v LinkType)
|
|
PrependAttributedToLink(v LinkType)
|
|
RemoveAttributedToLink(index int)
|
|
IsAttributedToIRI(index int) (ok bool)
|
|
GetAttributedToIRI(index int) (v *url.URL)
|
|
AppendAttributedToIRI(v *url.URL)
|
|
PrependAttributedToIRI(v *url.URL)
|
|
RemoveAttributedToIRI(index int)
|
|
AudienceLen() (l int)
|
|
IsAudienceObject(index int) (ok bool)
|
|
GetAudienceObject(index int) (v ObjectType)
|
|
AppendAudienceObject(v ObjectType)
|
|
PrependAudienceObject(v ObjectType)
|
|
RemoveAudienceObject(index int)
|
|
IsAudienceLink(index int) (ok bool)
|
|
GetAudienceLink(index int) (v LinkType)
|
|
AppendAudienceLink(v LinkType)
|
|
PrependAudienceLink(v LinkType)
|
|
RemoveAudienceLink(index int)
|
|
IsAudienceIRI(index int) (ok bool)
|
|
GetAudienceIRI(index int) (v *url.URL)
|
|
AppendAudienceIRI(v *url.URL)
|
|
PrependAudienceIRI(v *url.URL)
|
|
RemoveAudienceIRI(index int)
|
|
ContentLen() (l int)
|
|
IsContentString(index int) (ok bool)
|
|
GetContentString(index int) (v string)
|
|
AppendContentString(v string)
|
|
PrependContentString(v string)
|
|
RemoveContentString(index int)
|
|
IsContentLangString(index int) (ok bool)
|
|
GetContentLangString(index int) (v string)
|
|
AppendContentLangString(v string)
|
|
PrependContentLangString(v string)
|
|
RemoveContentLangString(index int)
|
|
IsContentIRI(index int) (ok bool)
|
|
GetContentIRI(index int) (v *url.URL)
|
|
AppendContentIRI(v *url.URL)
|
|
PrependContentIRI(v *url.URL)
|
|
RemoveContentIRI(index int)
|
|
ContentMapLanguages() (l []string)
|
|
GetContentMap(l string) (v string)
|
|
SetContentMap(l string, v string)
|
|
ContextLen() (l int)
|
|
IsContextObject(index int) (ok bool)
|
|
GetContextObject(index int) (v ObjectType)
|
|
AppendContextObject(v ObjectType)
|
|
PrependContextObject(v ObjectType)
|
|
RemoveContextObject(index int)
|
|
IsContextLink(index int) (ok bool)
|
|
GetContextLink(index int) (v LinkType)
|
|
AppendContextLink(v LinkType)
|
|
PrependContextLink(v LinkType)
|
|
RemoveContextLink(index int)
|
|
IsContextIRI(index int) (ok bool)
|
|
GetContextIRI(index int) (v *url.URL)
|
|
AppendContextIRI(v *url.URL)
|
|
PrependContextIRI(v *url.URL)
|
|
RemoveContextIRI(index int)
|
|
NameLen() (l int)
|
|
IsNameString(index int) (ok bool)
|
|
GetNameString(index int) (v string)
|
|
AppendNameString(v string)
|
|
PrependNameString(v string)
|
|
RemoveNameString(index int)
|
|
IsNameLangString(index int) (ok bool)
|
|
GetNameLangString(index int) (v string)
|
|
AppendNameLangString(v string)
|
|
PrependNameLangString(v string)
|
|
RemoveNameLangString(index int)
|
|
IsNameIRI(index int) (ok bool)
|
|
GetNameIRI(index int) (v *url.URL)
|
|
AppendNameIRI(v *url.URL)
|
|
PrependNameIRI(v *url.URL)
|
|
RemoveNameIRI(index int)
|
|
NameMapLanguages() (l []string)
|
|
GetNameMap(l string) (v string)
|
|
SetNameMap(l string, v string)
|
|
IsEndTime() (ok bool)
|
|
GetEndTime() (v time.Time)
|
|
SetEndTime(v time.Time)
|
|
IsEndTimeIRI() (ok bool)
|
|
GetEndTimeIRI() (v *url.URL)
|
|
SetEndTimeIRI(v *url.URL)
|
|
GeneratorLen() (l int)
|
|
IsGeneratorObject(index int) (ok bool)
|
|
GetGeneratorObject(index int) (v ObjectType)
|
|
AppendGeneratorObject(v ObjectType)
|
|
PrependGeneratorObject(v ObjectType)
|
|
RemoveGeneratorObject(index int)
|
|
IsGeneratorLink(index int) (ok bool)
|
|
GetGeneratorLink(index int) (v LinkType)
|
|
AppendGeneratorLink(v LinkType)
|
|
PrependGeneratorLink(v LinkType)
|
|
RemoveGeneratorLink(index int)
|
|
IsGeneratorIRI(index int) (ok bool)
|
|
GetGeneratorIRI(index int) (v *url.URL)
|
|
AppendGeneratorIRI(v *url.URL)
|
|
PrependGeneratorIRI(v *url.URL)
|
|
RemoveGeneratorIRI(index int)
|
|
IconLen() (l int)
|
|
IsIconImage(index int) (ok bool)
|
|
GetIconImage(index int) (v ImageType)
|
|
AppendIconImage(v ImageType)
|
|
PrependIconImage(v ImageType)
|
|
RemoveIconImage(index int)
|
|
IsIconLink(index int) (ok bool)
|
|
GetIconLink(index int) (v LinkType)
|
|
AppendIconLink(v LinkType)
|
|
PrependIconLink(v LinkType)
|
|
RemoveIconLink(index int)
|
|
IsIconIRI(index int) (ok bool)
|
|
GetIconIRI(index int) (v *url.URL)
|
|
AppendIconIRI(v *url.URL)
|
|
PrependIconIRI(v *url.URL)
|
|
RemoveIconIRI(index int)
|
|
HasId() (ok bool)
|
|
GetId() (v *url.URL)
|
|
SetId(v *url.URL)
|
|
HasUnknownId() (ok bool)
|
|
GetUnknownId() (v interface{})
|
|
SetUnknownId(i interface{})
|
|
ImageLen() (l int)
|
|
IsImageImage(index int) (ok bool)
|
|
GetImageImage(index int) (v ImageType)
|
|
AppendImageImage(v ImageType)
|
|
PrependImageImage(v ImageType)
|
|
RemoveImageImage(index int)
|
|
IsImageLink(index int) (ok bool)
|
|
GetImageLink(index int) (v LinkType)
|
|
AppendImageLink(v LinkType)
|
|
PrependImageLink(v LinkType)
|
|
RemoveImageLink(index int)
|
|
IsImageIRI(index int) (ok bool)
|
|
GetImageIRI(index int) (v *url.URL)
|
|
AppendImageIRI(v *url.URL)
|
|
PrependImageIRI(v *url.URL)
|
|
RemoveImageIRI(index int)
|
|
InReplyToLen() (l int)
|
|
IsInReplyToObject(index int) (ok bool)
|
|
GetInReplyToObject(index int) (v ObjectType)
|
|
AppendInReplyToObject(v ObjectType)
|
|
PrependInReplyToObject(v ObjectType)
|
|
RemoveInReplyToObject(index int)
|
|
IsInReplyToLink(index int) (ok bool)
|
|
GetInReplyToLink(index int) (v LinkType)
|
|
AppendInReplyToLink(v LinkType)
|
|
PrependInReplyToLink(v LinkType)
|
|
RemoveInReplyToLink(index int)
|
|
IsInReplyToIRI(index int) (ok bool)
|
|
GetInReplyToIRI(index int) (v *url.URL)
|
|
AppendInReplyToIRI(v *url.URL)
|
|
PrependInReplyToIRI(v *url.URL)
|
|
RemoveInReplyToIRI(index int)
|
|
LocationLen() (l int)
|
|
IsLocationObject(index int) (ok bool)
|
|
GetLocationObject(index int) (v ObjectType)
|
|
AppendLocationObject(v ObjectType)
|
|
PrependLocationObject(v ObjectType)
|
|
RemoveLocationObject(index int)
|
|
IsLocationLink(index int) (ok bool)
|
|
GetLocationLink(index int) (v LinkType)
|
|
AppendLocationLink(v LinkType)
|
|
PrependLocationLink(v LinkType)
|
|
RemoveLocationLink(index int)
|
|
IsLocationIRI(index int) (ok bool)
|
|
GetLocationIRI(index int) (v *url.URL)
|
|
AppendLocationIRI(v *url.URL)
|
|
PrependLocationIRI(v *url.URL)
|
|
RemoveLocationIRI(index int)
|
|
PreviewLen() (l int)
|
|
IsPreviewObject(index int) (ok bool)
|
|
GetPreviewObject(index int) (v ObjectType)
|
|
AppendPreviewObject(v ObjectType)
|
|
PrependPreviewObject(v ObjectType)
|
|
RemovePreviewObject(index int)
|
|
IsPreviewLink(index int) (ok bool)
|
|
GetPreviewLink(index int) (v LinkType)
|
|
AppendPreviewLink(v LinkType)
|
|
PrependPreviewLink(v LinkType)
|
|
RemovePreviewLink(index int)
|
|
IsPreviewIRI(index int) (ok bool)
|
|
GetPreviewIRI(index int) (v *url.URL)
|
|
AppendPreviewIRI(v *url.URL)
|
|
PrependPreviewIRI(v *url.URL)
|
|
RemovePreviewIRI(index int)
|
|
IsPublished() (ok bool)
|
|
GetPublished() (v time.Time)
|
|
SetPublished(v time.Time)
|
|
IsPublishedIRI() (ok bool)
|
|
GetPublishedIRI() (v *url.URL)
|
|
SetPublishedIRI(v *url.URL)
|
|
IsReplies() (ok bool)
|
|
GetReplies() (v CollectionType)
|
|
SetReplies(v CollectionType)
|
|
IsRepliesIRI() (ok bool)
|
|
GetRepliesIRI() (v *url.URL)
|
|
SetRepliesIRI(v *url.URL)
|
|
IsStartTime() (ok bool)
|
|
GetStartTime() (v time.Time)
|
|
SetStartTime(v time.Time)
|
|
IsStartTimeIRI() (ok bool)
|
|
GetStartTimeIRI() (v *url.URL)
|
|
SetStartTimeIRI(v *url.URL)
|
|
SummaryLen() (l int)
|
|
IsSummaryString(index int) (ok bool)
|
|
GetSummaryString(index int) (v string)
|
|
AppendSummaryString(v string)
|
|
PrependSummaryString(v string)
|
|
RemoveSummaryString(index int)
|
|
IsSummaryLangString(index int) (ok bool)
|
|
GetSummaryLangString(index int) (v string)
|
|
AppendSummaryLangString(v string)
|
|
PrependSummaryLangString(v string)
|
|
RemoveSummaryLangString(index int)
|
|
IsSummaryIRI(index int) (ok bool)
|
|
GetSummaryIRI(index int) (v *url.URL)
|
|
AppendSummaryIRI(v *url.URL)
|
|
PrependSummaryIRI(v *url.URL)
|
|
RemoveSummaryIRI(index int)
|
|
SummaryMapLanguages() (l []string)
|
|
GetSummaryMap(l string) (v string)
|
|
SetSummaryMap(l string, v string)
|
|
TagLen() (l int)
|
|
IsTagObject(index int) (ok bool)
|
|
GetTagObject(index int) (v ObjectType)
|
|
AppendTagObject(v ObjectType)
|
|
PrependTagObject(v ObjectType)
|
|
RemoveTagObject(index int)
|
|
IsTagLink(index int) (ok bool)
|
|
GetTagLink(index int) (v LinkType)
|
|
AppendTagLink(v LinkType)
|
|
PrependTagLink(v LinkType)
|
|
RemoveTagLink(index int)
|
|
IsTagIRI(index int) (ok bool)
|
|
GetTagIRI(index int) (v *url.URL)
|
|
AppendTagIRI(v *url.URL)
|
|
PrependTagIRI(v *url.URL)
|
|
RemoveTagIRI(index int)
|
|
TypeLen() (l int)
|
|
GetType(index int) (v interface{})
|
|
AppendType(v interface{})
|
|
PrependType(v interface{})
|
|
RemoveType(index int)
|
|
IsUpdated() (ok bool)
|
|
GetUpdated() (v time.Time)
|
|
SetUpdated(v time.Time)
|
|
IsUpdatedIRI() (ok bool)
|
|
GetUpdatedIRI() (v *url.URL)
|
|
SetUpdatedIRI(v *url.URL)
|
|
UrlLen() (l int)
|
|
IsUrlAnyURI(index int) (ok bool)
|
|
GetUrlAnyURI(index int) (v *url.URL)
|
|
AppendUrlAnyURI(v *url.URL)
|
|
PrependUrlAnyURI(v *url.URL)
|
|
RemoveUrlAnyURI(index int)
|
|
IsUrlLink(index int) (ok bool)
|
|
GetUrlLink(index int) (v LinkType)
|
|
AppendUrlLink(v LinkType)
|
|
PrependUrlLink(v LinkType)
|
|
RemoveUrlLink(index int)
|
|
ToLen() (l int)
|
|
IsToObject(index int) (ok bool)
|
|
GetToObject(index int) (v ObjectType)
|
|
AppendToObject(v ObjectType)
|
|
PrependToObject(v ObjectType)
|
|
RemoveToObject(index int)
|
|
IsToLink(index int) (ok bool)
|
|
GetToLink(index int) (v LinkType)
|
|
AppendToLink(v LinkType)
|
|
PrependToLink(v LinkType)
|
|
RemoveToLink(index int)
|
|
IsToIRI(index int) (ok bool)
|
|
GetToIRI(index int) (v *url.URL)
|
|
AppendToIRI(v *url.URL)
|
|
PrependToIRI(v *url.URL)
|
|
RemoveToIRI(index int)
|
|
BtoLen() (l int)
|
|
IsBtoObject(index int) (ok bool)
|
|
GetBtoObject(index int) (v ObjectType)
|
|
AppendBtoObject(v ObjectType)
|
|
PrependBtoObject(v ObjectType)
|
|
RemoveBtoObject(index int)
|
|
IsBtoLink(index int) (ok bool)
|
|
GetBtoLink(index int) (v LinkType)
|
|
AppendBtoLink(v LinkType)
|
|
PrependBtoLink(v LinkType)
|
|
RemoveBtoLink(index int)
|
|
IsBtoIRI(index int) (ok bool)
|
|
GetBtoIRI(index int) (v *url.URL)
|
|
AppendBtoIRI(v *url.URL)
|
|
PrependBtoIRI(v *url.URL)
|
|
RemoveBtoIRI(index int)
|
|
CcLen() (l int)
|
|
IsCcObject(index int) (ok bool)
|
|
GetCcObject(index int) (v ObjectType)
|
|
AppendCcObject(v ObjectType)
|
|
PrependCcObject(v ObjectType)
|
|
RemoveCcObject(index int)
|
|
IsCcLink(index int) (ok bool)
|
|
GetCcLink(index int) (v LinkType)
|
|
AppendCcLink(v LinkType)
|
|
PrependCcLink(v LinkType)
|
|
RemoveCcLink(index int)
|
|
IsCcIRI(index int) (ok bool)
|
|
GetCcIRI(index int) (v *url.URL)
|
|
AppendCcIRI(v *url.URL)
|
|
PrependCcIRI(v *url.URL)
|
|
RemoveCcIRI(index int)
|
|
BccLen() (l int)
|
|
IsBccObject(index int) (ok bool)
|
|
GetBccObject(index int) (v ObjectType)
|
|
AppendBccObject(v ObjectType)
|
|
PrependBccObject(v ObjectType)
|
|
RemoveBccObject(index int)
|
|
IsBccLink(index int) (ok bool)
|
|
GetBccLink(index int) (v LinkType)
|
|
AppendBccLink(v LinkType)
|
|
PrependBccLink(v LinkType)
|
|
RemoveBccLink(index int)
|
|
IsBccIRI(index int) (ok bool)
|
|
GetBccIRI(index int) (v *url.URL)
|
|
AppendBccIRI(v *url.URL)
|
|
PrependBccIRI(v *url.URL)
|
|
RemoveBccIRI(index int)
|
|
IsMediaType() (ok bool)
|
|
GetMediaType() (v string)
|
|
SetMediaType(v string)
|
|
IsMediaTypeIRI() (ok bool)
|
|
GetMediaTypeIRI() (v *url.URL)
|
|
SetMediaTypeIRI(v *url.URL)
|
|
IsDuration() (ok bool)
|
|
GetDuration() (v time.Duration)
|
|
SetDuration(v time.Duration)
|
|
IsDurationIRI() (ok bool)
|
|
GetDurationIRI() (v *url.URL)
|
|
SetDurationIRI(v *url.URL)
|
|
IsSource() (ok bool)
|
|
GetSource() (v ObjectType)
|
|
SetSource(v ObjectType)
|
|
IsSourceIRI() (ok bool)
|
|
GetSourceIRI() (v *url.URL)
|
|
SetSourceIRI(v *url.URL)
|
|
IsInboxOrderedCollection() (ok bool)
|
|
GetInboxOrderedCollection() (v OrderedCollectionType)
|
|
SetInboxOrderedCollection(v OrderedCollectionType)
|
|
IsInboxAnyURI() (ok bool)
|
|
GetInboxAnyURI() (v *url.URL)
|
|
SetInboxAnyURI(v *url.URL)
|
|
IsOutboxOrderedCollection() (ok bool)
|
|
GetOutboxOrderedCollection() (v OrderedCollectionType)
|
|
SetOutboxOrderedCollection(v OrderedCollectionType)
|
|
IsOutboxAnyURI() (ok bool)
|
|
GetOutboxAnyURI() (v *url.URL)
|
|
SetOutboxAnyURI(v *url.URL)
|
|
IsFollowingCollection() (ok bool)
|
|
GetFollowingCollection() (v CollectionType)
|
|
SetFollowingCollection(v CollectionType)
|
|
IsFollowingOrderedCollection() (ok bool)
|
|
GetFollowingOrderedCollection() (v OrderedCollectionType)
|
|
SetFollowingOrderedCollection(v OrderedCollectionType)
|
|
IsFollowingAnyURI() (ok bool)
|
|
GetFollowingAnyURI() (v *url.URL)
|
|
SetFollowingAnyURI(v *url.URL)
|
|
IsFollowersCollection() (ok bool)
|
|
GetFollowersCollection() (v CollectionType)
|
|
SetFollowersCollection(v CollectionType)
|
|
IsFollowersOrderedCollection() (ok bool)
|
|
GetFollowersOrderedCollection() (v OrderedCollectionType)
|
|
SetFollowersOrderedCollection(v OrderedCollectionType)
|
|
IsFollowersAnyURI() (ok bool)
|
|
GetFollowersAnyURI() (v *url.URL)
|
|
SetFollowersAnyURI(v *url.URL)
|
|
IsLikedCollection() (ok bool)
|
|
GetLikedCollection() (v CollectionType)
|
|
SetLikedCollection(v CollectionType)
|
|
IsLikedOrderedCollection() (ok bool)
|
|
GetLikedOrderedCollection() (v OrderedCollectionType)
|
|
SetLikedOrderedCollection(v OrderedCollectionType)
|
|
IsLikedAnyURI() (ok bool)
|
|
GetLikedAnyURI() (v *url.URL)
|
|
SetLikedAnyURI(v *url.URL)
|
|
IsLikesCollection() (ok bool)
|
|
GetLikesCollection() (v CollectionType)
|
|
SetLikesCollection(v CollectionType)
|
|
IsLikesOrderedCollection() (ok bool)
|
|
GetLikesOrderedCollection() (v OrderedCollectionType)
|
|
SetLikesOrderedCollection(v OrderedCollectionType)
|
|
IsLikesAnyURI() (ok bool)
|
|
GetLikesAnyURI() (v *url.URL)
|
|
SetLikesAnyURI(v *url.URL)
|
|
StreamsLen() (l int)
|
|
GetStreams(index int) (v *url.URL)
|
|
AppendStreams(v *url.URL)
|
|
PrependStreams(v *url.URL)
|
|
RemoveStreams(index int)
|
|
HasUnknownStreams() (ok bool)
|
|
GetUnknownStreams() (v interface{})
|
|
SetUnknownStreams(i interface{})
|
|
IsPreferredUsername() (ok bool)
|
|
GetPreferredUsername() (v string)
|
|
SetPreferredUsername(v string)
|
|
IsPreferredUsernameIRI() (ok bool)
|
|
GetPreferredUsernameIRI() (v *url.URL)
|
|
SetPreferredUsernameIRI(v *url.URL)
|
|
PreferredUsernameMapLanguages() (l []string)
|
|
GetPreferredUsernameMap(l string) (v string)
|
|
SetPreferredUsernameMap(l string, v string)
|
|
IsEndpoints() (ok bool)
|
|
GetEndpoints() (v ObjectType)
|
|
SetEndpoints(v ObjectType)
|
|
IsEndpointsIRI() (ok bool)
|
|
GetEndpointsIRI() (v *url.URL)
|
|
SetEndpointsIRI(v *url.URL)
|
|
HasProxyUrl() (ok bool)
|
|
GetProxyUrl() (v *url.URL)
|
|
SetProxyUrl(v *url.URL)
|
|
HasUnknownProxyUrl() (ok bool)
|
|
GetUnknownProxyUrl() (v interface{})
|
|
SetUnknownProxyUrl(i interface{})
|
|
HasOauthAuthorizationEndpoint() (ok bool)
|
|
GetOauthAuthorizationEndpoint() (v *url.URL)
|
|
SetOauthAuthorizationEndpoint(v *url.URL)
|
|
HasUnknownOauthAuthorizationEndpoint() (ok bool)
|
|
GetUnknownOauthAuthorizationEndpoint() (v interface{})
|
|
SetUnknownOauthAuthorizationEndpoint(i interface{})
|
|
HasOauthTokenEndpoint() (ok bool)
|
|
GetOauthTokenEndpoint() (v *url.URL)
|
|
SetOauthTokenEndpoint(v *url.URL)
|
|
HasUnknownOauthTokenEndpoint() (ok bool)
|
|
GetUnknownOauthTokenEndpoint() (v interface{})
|
|
SetUnknownOauthTokenEndpoint(i interface{})
|
|
HasProvideClientKey() (ok bool)
|
|
GetProvideClientKey() (v *url.URL)
|
|
SetProvideClientKey(v *url.URL)
|
|
HasUnknownProvideClientKey() (ok bool)
|
|
GetUnknownProvideClientKey() (v interface{})
|
|
SetUnknownProvideClientKey(i interface{})
|
|
HasSignClientKey() (ok bool)
|
|
GetSignClientKey() (v *url.URL)
|
|
SetSignClientKey(v *url.URL)
|
|
HasUnknownSignClientKey() (ok bool)
|
|
GetUnknownSignClientKey() (v interface{})
|
|
SetUnknownSignClientKey(i interface{})
|
|
HasSharedInbox() (ok bool)
|
|
GetSharedInbox() (v *url.URL)
|
|
SetSharedInbox(v *url.URL)
|
|
HasUnknownSharedInbox() (ok bool)
|
|
GetUnknownSharedInbox() (v interface{})
|
|
SetUnknownSharedInbox(i interface{})
|
|
}
|
|
|
|
// Indicates that the actor is ignoring the object. The target and origin typically have no defined meaning.
|
|
type Ignore struct {
|
|
// An unknown value.
|
|
unknown_ map[string]interface{}
|
|
// The 'actor' value could have multiple types and values
|
|
actor []*actorIgnoreIntermediateType
|
|
// The 'object' value could have multiple types and values
|
|
object []*objectIgnoreIntermediateType
|
|
// The 'target' value could have multiple types and values
|
|
target []*targetIgnoreIntermediateType
|
|
// The 'result' value could have multiple types and values
|
|
result []*resultIgnoreIntermediateType
|
|
// The 'origin' value could have multiple types and values
|
|
origin []*originIgnoreIntermediateType
|
|
// The 'instrument' value could have multiple types and values
|
|
instrument []*instrumentIgnoreIntermediateType
|
|
// The functional 'altitude' value could have multiple types, but only a single value
|
|
altitude *altitudeIgnoreIntermediateType
|
|
// The 'attachment' value could have multiple types and values
|
|
attachment []*attachmentIgnoreIntermediateType
|
|
// The 'attributedTo' value could have multiple types and values
|
|
attributedTo []*attributedToIgnoreIntermediateType
|
|
// The 'audience' value could have multiple types and values
|
|
audience []*audienceIgnoreIntermediateType
|
|
// The 'content' value could have multiple types and values
|
|
content []*contentIgnoreIntermediateType
|
|
// The 'contentMap' value holds language-specific values for property 'content'
|
|
contentMap map[string]string
|
|
// The 'context' value could have multiple types and values
|
|
context []*contextIgnoreIntermediateType
|
|
// The 'name' value could have multiple types and values
|
|
name []*nameIgnoreIntermediateType
|
|
// 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 *endTimeIgnoreIntermediateType
|
|
// The 'generator' value could have multiple types and values
|
|
generator []*generatorIgnoreIntermediateType
|
|
// The 'icon' value could have multiple types and values
|
|
icon []*iconIgnoreIntermediateType
|
|
// 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 []*imageIgnoreIntermediateType
|
|
// The 'inReplyTo' value could have multiple types and values
|
|
inReplyTo []*inReplyToIgnoreIntermediateType
|
|
// The 'location' value could have multiple types and values
|
|
location []*locationIgnoreIntermediateType
|
|
// The 'preview' value could have multiple types and values
|
|
preview []*previewIgnoreIntermediateType
|
|
// The functional 'published' value could have multiple types, but only a single value
|
|
published *publishedIgnoreIntermediateType
|
|
// The functional 'replies' value could have multiple types, but only a single value
|
|
replies *repliesIgnoreIntermediateType
|
|
// The functional 'startTime' value could have multiple types, but only a single value
|
|
startTime *startTimeIgnoreIntermediateType
|
|
// The 'summary' value could have multiple types and values
|
|
summary []*summaryIgnoreIntermediateType
|
|
// The 'summaryMap' value holds language-specific values for property 'summary'
|
|
summaryMap map[string]string
|
|
// The 'tag' value could have multiple types and values
|
|
tag []*tagIgnoreIntermediateType
|
|
// 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 *updatedIgnoreIntermediateType
|
|
// The 'url' value could have multiple types and values
|
|
url []*urlIgnoreIntermediateType
|
|
// The 'to' value could have multiple types and values
|
|
to []*toIgnoreIntermediateType
|
|
// The 'bto' value could have multiple types and values
|
|
bto []*btoIgnoreIntermediateType
|
|
// The 'cc' value could have multiple types and values
|
|
cc []*ccIgnoreIntermediateType
|
|
// The 'bcc' value could have multiple types and values
|
|
bcc []*bccIgnoreIntermediateType
|
|
// The functional 'mediaType' value could have multiple types, but only a single value
|
|
mediaType *mediaTypeIgnoreIntermediateType
|
|
// The functional 'duration' value could have multiple types, but only a single value
|
|
duration *durationIgnoreIntermediateType
|
|
// The functional 'source' value could have multiple types, but only a single value
|
|
source *sourceIgnoreIntermediateType
|
|
// The functional 'inbox' value could have multiple types, but only a single value
|
|
inbox *inboxIgnoreIntermediateType
|
|
// The functional 'outbox' value could have multiple types, but only a single value
|
|
outbox *outboxIgnoreIntermediateType
|
|
// The functional 'following' value could have multiple types, but only a single value
|
|
following *followingIgnoreIntermediateType
|
|
// The functional 'followers' value could have multiple types, but only a single value
|
|
followers *followersIgnoreIntermediateType
|
|
// The functional 'liked' value could have multiple types, but only a single value
|
|
liked *likedIgnoreIntermediateType
|
|
// The functional 'likes' value could have multiple types, but only a single value
|
|
likes *likesIgnoreIntermediateType
|
|
// 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 *preferredUsernameIgnoreIntermediateType
|
|
// 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 *endpointsIgnoreIntermediateType
|
|
// 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 *Ignore) ActorLen() (l int) {
|
|
return len(t.actor)
|
|
|
|
}
|
|
|
|
// IsActorObject determines whether the call to GetActorObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetActorObject(index int) (v ObjectType) {
|
|
return t.actor[index].Object
|
|
|
|
}
|
|
|
|
// AppendActorObject adds to the back of actor a ObjectType type
|
|
func (t *Ignore) AppendActorObject(v ObjectType) {
|
|
t.actor = append(t.actor, &actorIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependActorObject adds to the front of actor a ObjectType type
|
|
func (t *Ignore) PrependActorObject(v ObjectType) {
|
|
t.actor = append([]*actorIgnoreIntermediateType{&actorIgnoreIntermediateType{Object: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetActorLink(index int) (v LinkType) {
|
|
return t.actor[index].Link
|
|
|
|
}
|
|
|
|
// AppendActorLink adds to the back of actor a LinkType type
|
|
func (t *Ignore) AppendActorLink(v LinkType) {
|
|
t.actor = append(t.actor, &actorIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependActorLink adds to the front of actor a LinkType type
|
|
func (t *Ignore) PrependActorLink(v LinkType) {
|
|
t.actor = append([]*actorIgnoreIntermediateType{&actorIgnoreIntermediateType{Link: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetActorIRI(index int) (v *url.URL) {
|
|
return t.actor[index].IRI
|
|
|
|
}
|
|
|
|
// AppendActorIRI adds to the back of actor a *url.URL type
|
|
func (t *Ignore) AppendActorIRI(v *url.URL) {
|
|
t.actor = append(t.actor, &actorIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependActorIRI adds to the front of actor a *url.URL type
|
|
func (t *Ignore) PrependActorIRI(v *url.URL) {
|
|
t.actor = append([]*actorIgnoreIntermediateType{&actorIgnoreIntermediateType{IRI: v}}, t.actor...)
|
|
|
|
}
|
|
|
|
// RemoveActorIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownActor() (ok bool) {
|
|
return t.actor != nil && t.actor[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownActor returns the unknown value for actor
|
|
func (t *Ignore) GetUnknownActor() (v interface{}) {
|
|
return t.actor[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownActor sets the unknown value of actor
|
|
func (t *Ignore) SetUnknownActor(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &actorIgnoreIntermediateType{}
|
|
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 *Ignore) ObjectLen() (l int) {
|
|
return len(t.object)
|
|
|
|
}
|
|
|
|
// IsObject determines whether the call to GetObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetObject(index int) (v ObjectType) {
|
|
return t.object[index].Object
|
|
|
|
}
|
|
|
|
// AppendObject adds to the back of object a ObjectType type
|
|
func (t *Ignore) AppendObject(v ObjectType) {
|
|
t.object = append(t.object, &objectIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependObject adds to the front of object a ObjectType type
|
|
func (t *Ignore) PrependObject(v ObjectType) {
|
|
t.object = append([]*objectIgnoreIntermediateType{&objectIgnoreIntermediateType{Object: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetObjectIRI(index int) (v *url.URL) {
|
|
return t.object[index].IRI
|
|
|
|
}
|
|
|
|
// AppendObjectIRI adds to the back of object a *url.URL type
|
|
func (t *Ignore) AppendObjectIRI(v *url.URL) {
|
|
t.object = append(t.object, &objectIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependObjectIRI adds to the front of object a *url.URL type
|
|
func (t *Ignore) PrependObjectIRI(v *url.URL) {
|
|
t.object = append([]*objectIgnoreIntermediateType{&objectIgnoreIntermediateType{IRI: v}}, t.object...)
|
|
|
|
}
|
|
|
|
// RemoveObjectIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownObject() (ok bool) {
|
|
return t.object != nil && t.object[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownObject returns the unknown value for object
|
|
func (t *Ignore) GetUnknownObject() (v interface{}) {
|
|
return t.object[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownObject sets the unknown value of object
|
|
func (t *Ignore) SetUnknownObject(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &objectIgnoreIntermediateType{}
|
|
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 *Ignore) TargetLen() (l int) {
|
|
return len(t.target)
|
|
|
|
}
|
|
|
|
// IsTargetObject determines whether the call to GetTargetObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetTargetObject(index int) (v ObjectType) {
|
|
return t.target[index].Object
|
|
|
|
}
|
|
|
|
// AppendTargetObject adds to the back of target a ObjectType type
|
|
func (t *Ignore) AppendTargetObject(v ObjectType) {
|
|
t.target = append(t.target, &targetIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTargetObject adds to the front of target a ObjectType type
|
|
func (t *Ignore) PrependTargetObject(v ObjectType) {
|
|
t.target = append([]*targetIgnoreIntermediateType{&targetIgnoreIntermediateType{Object: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetTargetLink(index int) (v LinkType) {
|
|
return t.target[index].Link
|
|
|
|
}
|
|
|
|
// AppendTargetLink adds to the back of target a LinkType type
|
|
func (t *Ignore) AppendTargetLink(v LinkType) {
|
|
t.target = append(t.target, &targetIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTargetLink adds to the front of target a LinkType type
|
|
func (t *Ignore) PrependTargetLink(v LinkType) {
|
|
t.target = append([]*targetIgnoreIntermediateType{&targetIgnoreIntermediateType{Link: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetTargetIRI(index int) (v *url.URL) {
|
|
return t.target[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTargetIRI adds to the back of target a *url.URL type
|
|
func (t *Ignore) AppendTargetIRI(v *url.URL) {
|
|
t.target = append(t.target, &targetIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTargetIRI adds to the front of target a *url.URL type
|
|
func (t *Ignore) PrependTargetIRI(v *url.URL) {
|
|
t.target = append([]*targetIgnoreIntermediateType{&targetIgnoreIntermediateType{IRI: v}}, t.target...)
|
|
|
|
}
|
|
|
|
// RemoveTargetIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownTarget() (ok bool) {
|
|
return t.target != nil && t.target[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTarget returns the unknown value for target
|
|
func (t *Ignore) GetUnknownTarget() (v interface{}) {
|
|
return t.target[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTarget sets the unknown value of target
|
|
func (t *Ignore) SetUnknownTarget(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &targetIgnoreIntermediateType{}
|
|
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 *Ignore) ResultLen() (l int) {
|
|
return len(t.result)
|
|
|
|
}
|
|
|
|
// IsResultObject determines whether the call to GetResultObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetResultObject(index int) (v ObjectType) {
|
|
return t.result[index].Object
|
|
|
|
}
|
|
|
|
// AppendResultObject adds to the back of result a ObjectType type
|
|
func (t *Ignore) AppendResultObject(v ObjectType) {
|
|
t.result = append(t.result, &resultIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependResultObject adds to the front of result a ObjectType type
|
|
func (t *Ignore) PrependResultObject(v ObjectType) {
|
|
t.result = append([]*resultIgnoreIntermediateType{&resultIgnoreIntermediateType{Object: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetResultLink(index int) (v LinkType) {
|
|
return t.result[index].Link
|
|
|
|
}
|
|
|
|
// AppendResultLink adds to the back of result a LinkType type
|
|
func (t *Ignore) AppendResultLink(v LinkType) {
|
|
t.result = append(t.result, &resultIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependResultLink adds to the front of result a LinkType type
|
|
func (t *Ignore) PrependResultLink(v LinkType) {
|
|
t.result = append([]*resultIgnoreIntermediateType{&resultIgnoreIntermediateType{Link: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetResultIRI(index int) (v *url.URL) {
|
|
return t.result[index].IRI
|
|
|
|
}
|
|
|
|
// AppendResultIRI adds to the back of result a *url.URL type
|
|
func (t *Ignore) AppendResultIRI(v *url.URL) {
|
|
t.result = append(t.result, &resultIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependResultIRI adds to the front of result a *url.URL type
|
|
func (t *Ignore) PrependResultIRI(v *url.URL) {
|
|
t.result = append([]*resultIgnoreIntermediateType{&resultIgnoreIntermediateType{IRI: v}}, t.result...)
|
|
|
|
}
|
|
|
|
// RemoveResultIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownResult() (ok bool) {
|
|
return t.result != nil && t.result[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownResult returns the unknown value for result
|
|
func (t *Ignore) GetUnknownResult() (v interface{}) {
|
|
return t.result[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownResult sets the unknown value of result
|
|
func (t *Ignore) SetUnknownResult(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &resultIgnoreIntermediateType{}
|
|
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 *Ignore) OriginLen() (l int) {
|
|
return len(t.origin)
|
|
|
|
}
|
|
|
|
// IsOriginObject determines whether the call to GetOriginObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetOriginObject(index int) (v ObjectType) {
|
|
return t.origin[index].Object
|
|
|
|
}
|
|
|
|
// AppendOriginObject adds to the back of origin a ObjectType type
|
|
func (t *Ignore) AppendOriginObject(v ObjectType) {
|
|
t.origin = append(t.origin, &originIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependOriginObject adds to the front of origin a ObjectType type
|
|
func (t *Ignore) PrependOriginObject(v ObjectType) {
|
|
t.origin = append([]*originIgnoreIntermediateType{&originIgnoreIntermediateType{Object: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetOriginLink(index int) (v LinkType) {
|
|
return t.origin[index].Link
|
|
|
|
}
|
|
|
|
// AppendOriginLink adds to the back of origin a LinkType type
|
|
func (t *Ignore) AppendOriginLink(v LinkType) {
|
|
t.origin = append(t.origin, &originIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependOriginLink adds to the front of origin a LinkType type
|
|
func (t *Ignore) PrependOriginLink(v LinkType) {
|
|
t.origin = append([]*originIgnoreIntermediateType{&originIgnoreIntermediateType{Link: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetOriginIRI(index int) (v *url.URL) {
|
|
return t.origin[index].IRI
|
|
|
|
}
|
|
|
|
// AppendOriginIRI adds to the back of origin a *url.URL type
|
|
func (t *Ignore) AppendOriginIRI(v *url.URL) {
|
|
t.origin = append(t.origin, &originIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependOriginIRI adds to the front of origin a *url.URL type
|
|
func (t *Ignore) PrependOriginIRI(v *url.URL) {
|
|
t.origin = append([]*originIgnoreIntermediateType{&originIgnoreIntermediateType{IRI: v}}, t.origin...)
|
|
|
|
}
|
|
|
|
// RemoveOriginIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownOrigin() (ok bool) {
|
|
return t.origin != nil && t.origin[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOrigin returns the unknown value for origin
|
|
func (t *Ignore) GetUnknownOrigin() (v interface{}) {
|
|
return t.origin[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOrigin sets the unknown value of origin
|
|
func (t *Ignore) SetUnknownOrigin(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &originIgnoreIntermediateType{}
|
|
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 *Ignore) InstrumentLen() (l int) {
|
|
return len(t.instrument)
|
|
|
|
}
|
|
|
|
// IsInstrumentObject determines whether the call to GetInstrumentObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetInstrumentObject(index int) (v ObjectType) {
|
|
return t.instrument[index].Object
|
|
|
|
}
|
|
|
|
// AppendInstrumentObject adds to the back of instrument a ObjectType type
|
|
func (t *Ignore) AppendInstrumentObject(v ObjectType) {
|
|
t.instrument = append(t.instrument, &instrumentIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentObject adds to the front of instrument a ObjectType type
|
|
func (t *Ignore) PrependInstrumentObject(v ObjectType) {
|
|
t.instrument = append([]*instrumentIgnoreIntermediateType{&instrumentIgnoreIntermediateType{Object: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetInstrumentLink(index int) (v LinkType) {
|
|
return t.instrument[index].Link
|
|
|
|
}
|
|
|
|
// AppendInstrumentLink adds to the back of instrument a LinkType type
|
|
func (t *Ignore) AppendInstrumentLink(v LinkType) {
|
|
t.instrument = append(t.instrument, &instrumentIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentLink adds to the front of instrument a LinkType type
|
|
func (t *Ignore) PrependInstrumentLink(v LinkType) {
|
|
t.instrument = append([]*instrumentIgnoreIntermediateType{&instrumentIgnoreIntermediateType{Link: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetInstrumentIRI(index int) (v *url.URL) {
|
|
return t.instrument[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInstrumentIRI adds to the back of instrument a *url.URL type
|
|
func (t *Ignore) AppendInstrumentIRI(v *url.URL) {
|
|
t.instrument = append(t.instrument, &instrumentIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInstrumentIRI adds to the front of instrument a *url.URL type
|
|
func (t *Ignore) PrependInstrumentIRI(v *url.URL) {
|
|
t.instrument = append([]*instrumentIgnoreIntermediateType{&instrumentIgnoreIntermediateType{IRI: v}}, t.instrument...)
|
|
|
|
}
|
|
|
|
// RemoveInstrumentIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownInstrument() (ok bool) {
|
|
return t.instrument != nil && t.instrument[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInstrument returns the unknown value for instrument
|
|
func (t *Ignore) GetUnknownInstrument() (v interface{}) {
|
|
return t.instrument[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInstrument sets the unknown value of instrument
|
|
func (t *Ignore) SetUnknownInstrument(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &instrumentIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.instrument = append(t.instrument, tmp)
|
|
|
|
}
|
|
|
|
// IsAltitude determines whether the call to GetAltitude is safe
|
|
func (t *Ignore) IsAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.float != nil
|
|
|
|
}
|
|
|
|
// GetAltitude returns the value safely if IsAltitude returned true
|
|
func (t *Ignore) GetAltitude() (v float64) {
|
|
return *t.altitude.float
|
|
|
|
}
|
|
|
|
// SetAltitude sets the value of altitude to be of float64 type
|
|
func (t *Ignore) SetAltitude(v float64) {
|
|
t.altitude = &altitudeIgnoreIntermediateType{float: &v}
|
|
|
|
}
|
|
|
|
// IsAltitudeIRI determines whether the call to GetAltitudeIRI is safe
|
|
func (t *Ignore) IsAltitudeIRI() (ok bool) {
|
|
return t.altitude != nil && t.altitude.IRI != nil
|
|
|
|
}
|
|
|
|
// GetAltitudeIRI returns the value safely if IsAltitudeIRI returned true
|
|
func (t *Ignore) GetAltitudeIRI() (v *url.URL) {
|
|
return t.altitude.IRI
|
|
|
|
}
|
|
|
|
// SetAltitudeIRI sets the value of altitude to be of *url.URL type
|
|
func (t *Ignore) SetAltitudeIRI(v *url.URL) {
|
|
t.altitude = &altitudeIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownAltitude determines whether the call to GetUnknownAltitude is safe
|
|
func (t *Ignore) HasUnknownAltitude() (ok bool) {
|
|
return t.altitude != nil && t.altitude.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAltitude returns the unknown value for altitude
|
|
func (t *Ignore) GetUnknownAltitude() (v interface{}) {
|
|
return t.altitude.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAltitude sets the unknown value of altitude
|
|
func (t *Ignore) SetUnknownAltitude(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &altitudeIgnoreIntermediateType{}
|
|
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 *Ignore) AttachmentLen() (l int) {
|
|
return len(t.attachment)
|
|
|
|
}
|
|
|
|
// IsAttachmentObject determines whether the call to GetAttachmentObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetAttachmentObject(index int) (v ObjectType) {
|
|
return t.attachment[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttachmentObject adds to the back of attachment a ObjectType type
|
|
func (t *Ignore) AppendAttachmentObject(v ObjectType) {
|
|
t.attachment = append(t.attachment, &attachmentIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentObject adds to the front of attachment a ObjectType type
|
|
func (t *Ignore) PrependAttachmentObject(v ObjectType) {
|
|
t.attachment = append([]*attachmentIgnoreIntermediateType{&attachmentIgnoreIntermediateType{Object: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetAttachmentLink(index int) (v LinkType) {
|
|
return t.attachment[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttachmentLink adds to the back of attachment a LinkType type
|
|
func (t *Ignore) AppendAttachmentLink(v LinkType) {
|
|
t.attachment = append(t.attachment, &attachmentIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentLink adds to the front of attachment a LinkType type
|
|
func (t *Ignore) PrependAttachmentLink(v LinkType) {
|
|
t.attachment = append([]*attachmentIgnoreIntermediateType{&attachmentIgnoreIntermediateType{Link: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetAttachmentIRI(index int) (v *url.URL) {
|
|
return t.attachment[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttachmentIRI adds to the back of attachment a *url.URL type
|
|
func (t *Ignore) AppendAttachmentIRI(v *url.URL) {
|
|
t.attachment = append(t.attachment, &attachmentIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttachmentIRI adds to the front of attachment a *url.URL type
|
|
func (t *Ignore) PrependAttachmentIRI(v *url.URL) {
|
|
t.attachment = append([]*attachmentIgnoreIntermediateType{&attachmentIgnoreIntermediateType{IRI: v}}, t.attachment...)
|
|
|
|
}
|
|
|
|
// RemoveAttachmentIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownAttachment() (ok bool) {
|
|
return t.attachment != nil && t.attachment[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttachment returns the unknown value for attachment
|
|
func (t *Ignore) GetUnknownAttachment() (v interface{}) {
|
|
return t.attachment[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttachment sets the unknown value of attachment
|
|
func (t *Ignore) SetUnknownAttachment(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attachmentIgnoreIntermediateType{}
|
|
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 *Ignore) AttributedToLen() (l int) {
|
|
return len(t.attributedTo)
|
|
|
|
}
|
|
|
|
// IsAttributedToObject determines whether the call to GetAttributedToObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetAttributedToObject(index int) (v ObjectType) {
|
|
return t.attributedTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendAttributedToObject adds to the back of attributedTo a ObjectType type
|
|
func (t *Ignore) AppendAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToObject adds to the front of attributedTo a ObjectType type
|
|
func (t *Ignore) PrependAttributedToObject(v ObjectType) {
|
|
t.attributedTo = append([]*attributedToIgnoreIntermediateType{&attributedToIgnoreIntermediateType{Object: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetAttributedToLink(index int) (v LinkType) {
|
|
return t.attributedTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendAttributedToLink adds to the back of attributedTo a LinkType type
|
|
func (t *Ignore) AppendAttributedToLink(v LinkType) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToLink adds to the front of attributedTo a LinkType type
|
|
func (t *Ignore) PrependAttributedToLink(v LinkType) {
|
|
t.attributedTo = append([]*attributedToIgnoreIntermediateType{&attributedToIgnoreIntermediateType{Link: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetAttributedToIRI(index int) (v *url.URL) {
|
|
return t.attributedTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAttributedToIRI adds to the back of attributedTo a *url.URL type
|
|
func (t *Ignore) AppendAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append(t.attributedTo, &attributedToIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAttributedToIRI adds to the front of attributedTo a *url.URL type
|
|
func (t *Ignore) PrependAttributedToIRI(v *url.URL) {
|
|
t.attributedTo = append([]*attributedToIgnoreIntermediateType{&attributedToIgnoreIntermediateType{IRI: v}}, t.attributedTo...)
|
|
|
|
}
|
|
|
|
// RemoveAttributedToIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownAttributedTo() (ok bool) {
|
|
return t.attributedTo != nil && t.attributedTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAttributedTo returns the unknown value for attributedTo
|
|
func (t *Ignore) GetUnknownAttributedTo() (v interface{}) {
|
|
return t.attributedTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAttributedTo sets the unknown value of attributedTo
|
|
func (t *Ignore) SetUnknownAttributedTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &attributedToIgnoreIntermediateType{}
|
|
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 *Ignore) AudienceLen() (l int) {
|
|
return len(t.audience)
|
|
|
|
}
|
|
|
|
// IsAudienceObject determines whether the call to GetAudienceObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetAudienceObject(index int) (v ObjectType) {
|
|
return t.audience[index].Object
|
|
|
|
}
|
|
|
|
// AppendAudienceObject adds to the back of audience a ObjectType type
|
|
func (t *Ignore) AppendAudienceObject(v ObjectType) {
|
|
t.audience = append(t.audience, &audienceIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceObject adds to the front of audience a ObjectType type
|
|
func (t *Ignore) PrependAudienceObject(v ObjectType) {
|
|
t.audience = append([]*audienceIgnoreIntermediateType{&audienceIgnoreIntermediateType{Object: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetAudienceLink(index int) (v LinkType) {
|
|
return t.audience[index].Link
|
|
|
|
}
|
|
|
|
// AppendAudienceLink adds to the back of audience a LinkType type
|
|
func (t *Ignore) AppendAudienceLink(v LinkType) {
|
|
t.audience = append(t.audience, &audienceIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceLink adds to the front of audience a LinkType type
|
|
func (t *Ignore) PrependAudienceLink(v LinkType) {
|
|
t.audience = append([]*audienceIgnoreIntermediateType{&audienceIgnoreIntermediateType{Link: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetAudienceIRI(index int) (v *url.URL) {
|
|
return t.audience[index].IRI
|
|
|
|
}
|
|
|
|
// AppendAudienceIRI adds to the back of audience a *url.URL type
|
|
func (t *Ignore) AppendAudienceIRI(v *url.URL) {
|
|
t.audience = append(t.audience, &audienceIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependAudienceIRI adds to the front of audience a *url.URL type
|
|
func (t *Ignore) PrependAudienceIRI(v *url.URL) {
|
|
t.audience = append([]*audienceIgnoreIntermediateType{&audienceIgnoreIntermediateType{IRI: v}}, t.audience...)
|
|
|
|
}
|
|
|
|
// RemoveAudienceIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownAudience() (ok bool) {
|
|
return t.audience != nil && t.audience[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownAudience returns the unknown value for audience
|
|
func (t *Ignore) GetUnknownAudience() (v interface{}) {
|
|
return t.audience[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownAudience sets the unknown value of audience
|
|
func (t *Ignore) SetUnknownAudience(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &audienceIgnoreIntermediateType{}
|
|
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 *Ignore) ContentLen() (l int) {
|
|
return len(t.content)
|
|
|
|
}
|
|
|
|
// IsContentString determines whether the call to GetContentString is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetContentString(index int) (v string) {
|
|
return *t.content[index].stringName
|
|
|
|
}
|
|
|
|
// AppendContentString adds to the back of content a string type
|
|
func (t *Ignore) AppendContentString(v string) {
|
|
t.content = append(t.content, &contentIgnoreIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependContentString adds to the front of content a string type
|
|
func (t *Ignore) PrependContentString(v string) {
|
|
t.content = append([]*contentIgnoreIntermediateType{&contentIgnoreIntermediateType{stringName: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentString deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetContentLangString(index int) (v string) {
|
|
return *t.content[index].langString
|
|
|
|
}
|
|
|
|
// AppendContentLangString adds to the back of content a string type
|
|
func (t *Ignore) AppendContentLangString(v string) {
|
|
t.content = append(t.content, &contentIgnoreIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependContentLangString adds to the front of content a string type
|
|
func (t *Ignore) PrependContentLangString(v string) {
|
|
t.content = append([]*contentIgnoreIntermediateType{&contentIgnoreIntermediateType{langString: &v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentLangString deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetContentIRI(index int) (v *url.URL) {
|
|
return t.content[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContentIRI adds to the back of content a *url.URL type
|
|
func (t *Ignore) AppendContentIRI(v *url.URL) {
|
|
t.content = append(t.content, &contentIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContentIRI adds to the front of content a *url.URL type
|
|
func (t *Ignore) PrependContentIRI(v *url.URL) {
|
|
t.content = append([]*contentIgnoreIntermediateType{&contentIgnoreIntermediateType{IRI: v}}, t.content...)
|
|
|
|
}
|
|
|
|
// RemoveContentIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownContent() (ok bool) {
|
|
return t.content != nil && t.content[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContent returns the unknown value for content
|
|
func (t *Ignore) GetUnknownContent() (v interface{}) {
|
|
return t.content[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContent sets the unknown value of content
|
|
func (t *Ignore) SetUnknownContent(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contentIgnoreIntermediateType{}
|
|
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 *Ignore) 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 *Ignore) 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 *Ignore) 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 *Ignore) ContextLen() (l int) {
|
|
return len(t.context)
|
|
|
|
}
|
|
|
|
// IsContextObject determines whether the call to GetContextObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetContextObject(index int) (v ObjectType) {
|
|
return t.context[index].Object
|
|
|
|
}
|
|
|
|
// AppendContextObject adds to the back of context a ObjectType type
|
|
func (t *Ignore) AppendContextObject(v ObjectType) {
|
|
t.context = append(t.context, &contextIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependContextObject adds to the front of context a ObjectType type
|
|
func (t *Ignore) PrependContextObject(v ObjectType) {
|
|
t.context = append([]*contextIgnoreIntermediateType{&contextIgnoreIntermediateType{Object: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetContextLink(index int) (v LinkType) {
|
|
return t.context[index].Link
|
|
|
|
}
|
|
|
|
// AppendContextLink adds to the back of context a LinkType type
|
|
func (t *Ignore) AppendContextLink(v LinkType) {
|
|
t.context = append(t.context, &contextIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependContextLink adds to the front of context a LinkType type
|
|
func (t *Ignore) PrependContextLink(v LinkType) {
|
|
t.context = append([]*contextIgnoreIntermediateType{&contextIgnoreIntermediateType{Link: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetContextIRI(index int) (v *url.URL) {
|
|
return t.context[index].IRI
|
|
|
|
}
|
|
|
|
// AppendContextIRI adds to the back of context a *url.URL type
|
|
func (t *Ignore) AppendContextIRI(v *url.URL) {
|
|
t.context = append(t.context, &contextIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependContextIRI adds to the front of context a *url.URL type
|
|
func (t *Ignore) PrependContextIRI(v *url.URL) {
|
|
t.context = append([]*contextIgnoreIntermediateType{&contextIgnoreIntermediateType{IRI: v}}, t.context...)
|
|
|
|
}
|
|
|
|
// RemoveContextIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownContext() (ok bool) {
|
|
return t.context != nil && t.context[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownContext returns the unknown value for context
|
|
func (t *Ignore) GetUnknownContext() (v interface{}) {
|
|
return t.context[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownContext sets the unknown value of context
|
|
func (t *Ignore) SetUnknownContext(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &contextIgnoreIntermediateType{}
|
|
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 *Ignore) NameLen() (l int) {
|
|
return len(t.name)
|
|
|
|
}
|
|
|
|
// IsNameString determines whether the call to GetNameString is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetNameString(index int) (v string) {
|
|
return *t.name[index].stringName
|
|
|
|
}
|
|
|
|
// AppendNameString adds to the back of name a string type
|
|
func (t *Ignore) AppendNameString(v string) {
|
|
t.name = append(t.name, &nameIgnoreIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependNameString adds to the front of name a string type
|
|
func (t *Ignore) PrependNameString(v string) {
|
|
t.name = append([]*nameIgnoreIntermediateType{&nameIgnoreIntermediateType{stringName: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameString deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetNameLangString(index int) (v string) {
|
|
return *t.name[index].langString
|
|
|
|
}
|
|
|
|
// AppendNameLangString adds to the back of name a string type
|
|
func (t *Ignore) AppendNameLangString(v string) {
|
|
t.name = append(t.name, &nameIgnoreIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependNameLangString adds to the front of name a string type
|
|
func (t *Ignore) PrependNameLangString(v string) {
|
|
t.name = append([]*nameIgnoreIntermediateType{&nameIgnoreIntermediateType{langString: &v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameLangString deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetNameIRI(index int) (v *url.URL) {
|
|
return t.name[index].IRI
|
|
|
|
}
|
|
|
|
// AppendNameIRI adds to the back of name a *url.URL type
|
|
func (t *Ignore) AppendNameIRI(v *url.URL) {
|
|
t.name = append(t.name, &nameIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependNameIRI adds to the front of name a *url.URL type
|
|
func (t *Ignore) PrependNameIRI(v *url.URL) {
|
|
t.name = append([]*nameIgnoreIntermediateType{&nameIgnoreIntermediateType{IRI: v}}, t.name...)
|
|
|
|
}
|
|
|
|
// RemoveNameIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownName() (ok bool) {
|
|
return t.name != nil && t.name[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownName returns the unknown value for name
|
|
func (t *Ignore) GetUnknownName() (v interface{}) {
|
|
return t.name[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownName sets the unknown value of name
|
|
func (t *Ignore) SetUnknownName(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &nameIgnoreIntermediateType{}
|
|
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 *Ignore) 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 *Ignore) 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 *Ignore) 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 *Ignore) IsEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetEndTime returns the value safely if IsEndTime returned true
|
|
func (t *Ignore) GetEndTime() (v time.Time) {
|
|
return *t.endTime.dateTime
|
|
|
|
}
|
|
|
|
// SetEndTime sets the value of endTime to be of time.Time type
|
|
func (t *Ignore) SetEndTime(v time.Time) {
|
|
t.endTime = &endTimeIgnoreIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsEndTimeIRI determines whether the call to GetEndTimeIRI is safe
|
|
func (t *Ignore) IsEndTimeIRI() (ok bool) {
|
|
return t.endTime != nil && t.endTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndTimeIRI returns the value safely if IsEndTimeIRI returned true
|
|
func (t *Ignore) GetEndTimeIRI() (v *url.URL) {
|
|
return t.endTime.IRI
|
|
|
|
}
|
|
|
|
// SetEndTimeIRI sets the value of endTime to be of *url.URL type
|
|
func (t *Ignore) SetEndTimeIRI(v *url.URL) {
|
|
t.endTime = &endTimeIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndTime determines whether the call to GetUnknownEndTime is safe
|
|
func (t *Ignore) HasUnknownEndTime() (ok bool) {
|
|
return t.endTime != nil && t.endTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndTime returns the unknown value for endTime
|
|
func (t *Ignore) GetUnknownEndTime() (v interface{}) {
|
|
return t.endTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndTime sets the unknown value of endTime
|
|
func (t *Ignore) SetUnknownEndTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endTimeIgnoreIntermediateType{}
|
|
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 *Ignore) GeneratorLen() (l int) {
|
|
return len(t.generator)
|
|
|
|
}
|
|
|
|
// IsGeneratorObject determines whether the call to GetGeneratorObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetGeneratorObject(index int) (v ObjectType) {
|
|
return t.generator[index].Object
|
|
|
|
}
|
|
|
|
// AppendGeneratorObject adds to the back of generator a ObjectType type
|
|
func (t *Ignore) AppendGeneratorObject(v ObjectType) {
|
|
t.generator = append(t.generator, &generatorIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorObject adds to the front of generator a ObjectType type
|
|
func (t *Ignore) PrependGeneratorObject(v ObjectType) {
|
|
t.generator = append([]*generatorIgnoreIntermediateType{&generatorIgnoreIntermediateType{Object: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetGeneratorLink(index int) (v LinkType) {
|
|
return t.generator[index].Link
|
|
|
|
}
|
|
|
|
// AppendGeneratorLink adds to the back of generator a LinkType type
|
|
func (t *Ignore) AppendGeneratorLink(v LinkType) {
|
|
t.generator = append(t.generator, &generatorIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorLink adds to the front of generator a LinkType type
|
|
func (t *Ignore) PrependGeneratorLink(v LinkType) {
|
|
t.generator = append([]*generatorIgnoreIntermediateType{&generatorIgnoreIntermediateType{Link: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetGeneratorIRI(index int) (v *url.URL) {
|
|
return t.generator[index].IRI
|
|
|
|
}
|
|
|
|
// AppendGeneratorIRI adds to the back of generator a *url.URL type
|
|
func (t *Ignore) AppendGeneratorIRI(v *url.URL) {
|
|
t.generator = append(t.generator, &generatorIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependGeneratorIRI adds to the front of generator a *url.URL type
|
|
func (t *Ignore) PrependGeneratorIRI(v *url.URL) {
|
|
t.generator = append([]*generatorIgnoreIntermediateType{&generatorIgnoreIntermediateType{IRI: v}}, t.generator...)
|
|
|
|
}
|
|
|
|
// RemoveGeneratorIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownGenerator() (ok bool) {
|
|
return t.generator != nil && t.generator[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownGenerator returns the unknown value for generator
|
|
func (t *Ignore) GetUnknownGenerator() (v interface{}) {
|
|
return t.generator[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownGenerator sets the unknown value of generator
|
|
func (t *Ignore) SetUnknownGenerator(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &generatorIgnoreIntermediateType{}
|
|
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 *Ignore) IconLen() (l int) {
|
|
return len(t.icon)
|
|
|
|
}
|
|
|
|
// IsIconImage determines whether the call to GetIconImage is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetIconImage(index int) (v ImageType) {
|
|
return t.icon[index].Image
|
|
|
|
}
|
|
|
|
// AppendIconImage adds to the back of icon a ImageType type
|
|
func (t *Ignore) AppendIconImage(v ImageType) {
|
|
t.icon = append(t.icon, &iconIgnoreIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependIconImage adds to the front of icon a ImageType type
|
|
func (t *Ignore) PrependIconImage(v ImageType) {
|
|
t.icon = append([]*iconIgnoreIntermediateType{&iconIgnoreIntermediateType{Image: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconImage deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetIconLink(index int) (v LinkType) {
|
|
return t.icon[index].Link
|
|
|
|
}
|
|
|
|
// AppendIconLink adds to the back of icon a LinkType type
|
|
func (t *Ignore) AppendIconLink(v LinkType) {
|
|
t.icon = append(t.icon, &iconIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependIconLink adds to the front of icon a LinkType type
|
|
func (t *Ignore) PrependIconLink(v LinkType) {
|
|
t.icon = append([]*iconIgnoreIntermediateType{&iconIgnoreIntermediateType{Link: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetIconIRI(index int) (v *url.URL) {
|
|
return t.icon[index].IRI
|
|
|
|
}
|
|
|
|
// AppendIconIRI adds to the back of icon a *url.URL type
|
|
func (t *Ignore) AppendIconIRI(v *url.URL) {
|
|
t.icon = append(t.icon, &iconIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependIconIRI adds to the front of icon a *url.URL type
|
|
func (t *Ignore) PrependIconIRI(v *url.URL) {
|
|
t.icon = append([]*iconIgnoreIntermediateType{&iconIgnoreIntermediateType{IRI: v}}, t.icon...)
|
|
|
|
}
|
|
|
|
// RemoveIconIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownIcon() (ok bool) {
|
|
return t.icon != nil && t.icon[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownIcon returns the unknown value for icon
|
|
func (t *Ignore) GetUnknownIcon() (v interface{}) {
|
|
return t.icon[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownIcon sets the unknown value of icon
|
|
func (t *Ignore) SetUnknownIcon(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &iconIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.icon = append(t.icon, tmp)
|
|
|
|
}
|
|
|
|
// HasId determines whether the call to GetId is safe
|
|
func (t *Ignore) HasId() (ok bool) {
|
|
return t.id != nil
|
|
|
|
}
|
|
|
|
// GetId returns the value for id
|
|
func (t *Ignore) GetId() (v *url.URL) {
|
|
return t.id
|
|
|
|
}
|
|
|
|
// SetId sets the value of id
|
|
func (t *Ignore) SetId(v *url.URL) {
|
|
t.id = v
|
|
|
|
}
|
|
|
|
// HasUnknownId determines whether the call to GetUnknownId is safe
|
|
func (t *Ignore) HasUnknownId() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["id"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownId returns the unknown value for id
|
|
func (t *Ignore) GetUnknownId() (v interface{}) {
|
|
return t.unknown_["id"]
|
|
|
|
}
|
|
|
|
// SetUnknownId sets the unknown value of id
|
|
func (t *Ignore) 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 *Ignore) ImageLen() (l int) {
|
|
return len(t.image)
|
|
|
|
}
|
|
|
|
// IsImageImage determines whether the call to GetImageImage is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetImageImage(index int) (v ImageType) {
|
|
return t.image[index].Image
|
|
|
|
}
|
|
|
|
// AppendImageImage adds to the back of image a ImageType type
|
|
func (t *Ignore) AppendImageImage(v ImageType) {
|
|
t.image = append(t.image, &imageIgnoreIntermediateType{Image: v})
|
|
|
|
}
|
|
|
|
// PrependImageImage adds to the front of image a ImageType type
|
|
func (t *Ignore) PrependImageImage(v ImageType) {
|
|
t.image = append([]*imageIgnoreIntermediateType{&imageIgnoreIntermediateType{Image: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageImage deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetImageLink(index int) (v LinkType) {
|
|
return t.image[index].Link
|
|
|
|
}
|
|
|
|
// AppendImageLink adds to the back of image a LinkType type
|
|
func (t *Ignore) AppendImageLink(v LinkType) {
|
|
t.image = append(t.image, &imageIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependImageLink adds to the front of image a LinkType type
|
|
func (t *Ignore) PrependImageLink(v LinkType) {
|
|
t.image = append([]*imageIgnoreIntermediateType{&imageIgnoreIntermediateType{Link: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetImageIRI(index int) (v *url.URL) {
|
|
return t.image[index].IRI
|
|
|
|
}
|
|
|
|
// AppendImageIRI adds to the back of image a *url.URL type
|
|
func (t *Ignore) AppendImageIRI(v *url.URL) {
|
|
t.image = append(t.image, &imageIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependImageIRI adds to the front of image a *url.URL type
|
|
func (t *Ignore) PrependImageIRI(v *url.URL) {
|
|
t.image = append([]*imageIgnoreIntermediateType{&imageIgnoreIntermediateType{IRI: v}}, t.image...)
|
|
|
|
}
|
|
|
|
// RemoveImageIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownImage() (ok bool) {
|
|
return t.image != nil && t.image[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownImage returns the unknown value for image
|
|
func (t *Ignore) GetUnknownImage() (v interface{}) {
|
|
return t.image[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownImage sets the unknown value of image
|
|
func (t *Ignore) SetUnknownImage(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &imageIgnoreIntermediateType{}
|
|
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 *Ignore) InReplyToLen() (l int) {
|
|
return len(t.inReplyTo)
|
|
|
|
}
|
|
|
|
// IsInReplyToObject determines whether the call to GetInReplyToObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetInReplyToObject(index int) (v ObjectType) {
|
|
return t.inReplyTo[index].Object
|
|
|
|
}
|
|
|
|
// AppendInReplyToObject adds to the back of inReplyTo a ObjectType type
|
|
func (t *Ignore) AppendInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToObject adds to the front of inReplyTo a ObjectType type
|
|
func (t *Ignore) PrependInReplyToObject(v ObjectType) {
|
|
t.inReplyTo = append([]*inReplyToIgnoreIntermediateType{&inReplyToIgnoreIntermediateType{Object: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetInReplyToLink(index int) (v LinkType) {
|
|
return t.inReplyTo[index].Link
|
|
|
|
}
|
|
|
|
// AppendInReplyToLink adds to the back of inReplyTo a LinkType type
|
|
func (t *Ignore) AppendInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToLink adds to the front of inReplyTo a LinkType type
|
|
func (t *Ignore) PrependInReplyToLink(v LinkType) {
|
|
t.inReplyTo = append([]*inReplyToIgnoreIntermediateType{&inReplyToIgnoreIntermediateType{Link: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetInReplyToIRI(index int) (v *url.URL) {
|
|
return t.inReplyTo[index].IRI
|
|
|
|
}
|
|
|
|
// AppendInReplyToIRI adds to the back of inReplyTo a *url.URL type
|
|
func (t *Ignore) AppendInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append(t.inReplyTo, &inReplyToIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependInReplyToIRI adds to the front of inReplyTo a *url.URL type
|
|
func (t *Ignore) PrependInReplyToIRI(v *url.URL) {
|
|
t.inReplyTo = append([]*inReplyToIgnoreIntermediateType{&inReplyToIgnoreIntermediateType{IRI: v}}, t.inReplyTo...)
|
|
|
|
}
|
|
|
|
// RemoveInReplyToIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownInReplyTo() (ok bool) {
|
|
return t.inReplyTo != nil && t.inReplyTo[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInReplyTo returns the unknown value for inReplyTo
|
|
func (t *Ignore) GetUnknownInReplyTo() (v interface{}) {
|
|
return t.inReplyTo[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInReplyTo sets the unknown value of inReplyTo
|
|
func (t *Ignore) SetUnknownInReplyTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inReplyToIgnoreIntermediateType{}
|
|
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 *Ignore) LocationLen() (l int) {
|
|
return len(t.location)
|
|
|
|
}
|
|
|
|
// IsLocationObject determines whether the call to GetLocationObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetLocationObject(index int) (v ObjectType) {
|
|
return t.location[index].Object
|
|
|
|
}
|
|
|
|
// AppendLocationObject adds to the back of location a ObjectType type
|
|
func (t *Ignore) AppendLocationObject(v ObjectType) {
|
|
t.location = append(t.location, &locationIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependLocationObject adds to the front of location a ObjectType type
|
|
func (t *Ignore) PrependLocationObject(v ObjectType) {
|
|
t.location = append([]*locationIgnoreIntermediateType{&locationIgnoreIntermediateType{Object: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetLocationLink(index int) (v LinkType) {
|
|
return t.location[index].Link
|
|
|
|
}
|
|
|
|
// AppendLocationLink adds to the back of location a LinkType type
|
|
func (t *Ignore) AppendLocationLink(v LinkType) {
|
|
t.location = append(t.location, &locationIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependLocationLink adds to the front of location a LinkType type
|
|
func (t *Ignore) PrependLocationLink(v LinkType) {
|
|
t.location = append([]*locationIgnoreIntermediateType{&locationIgnoreIntermediateType{Link: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetLocationIRI(index int) (v *url.URL) {
|
|
return t.location[index].IRI
|
|
|
|
}
|
|
|
|
// AppendLocationIRI adds to the back of location a *url.URL type
|
|
func (t *Ignore) AppendLocationIRI(v *url.URL) {
|
|
t.location = append(t.location, &locationIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependLocationIRI adds to the front of location a *url.URL type
|
|
func (t *Ignore) PrependLocationIRI(v *url.URL) {
|
|
t.location = append([]*locationIgnoreIntermediateType{&locationIgnoreIntermediateType{IRI: v}}, t.location...)
|
|
|
|
}
|
|
|
|
// RemoveLocationIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownLocation() (ok bool) {
|
|
return t.location != nil && t.location[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLocation returns the unknown value for location
|
|
func (t *Ignore) GetUnknownLocation() (v interface{}) {
|
|
return t.location[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLocation sets the unknown value of location
|
|
func (t *Ignore) SetUnknownLocation(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &locationIgnoreIntermediateType{}
|
|
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 *Ignore) PreviewLen() (l int) {
|
|
return len(t.preview)
|
|
|
|
}
|
|
|
|
// IsPreviewObject determines whether the call to GetPreviewObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetPreviewObject(index int) (v ObjectType) {
|
|
return t.preview[index].Object
|
|
|
|
}
|
|
|
|
// AppendPreviewObject adds to the back of preview a ObjectType type
|
|
func (t *Ignore) AppendPreviewObject(v ObjectType) {
|
|
t.preview = append(t.preview, &previewIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewObject adds to the front of preview a ObjectType type
|
|
func (t *Ignore) PrependPreviewObject(v ObjectType) {
|
|
t.preview = append([]*previewIgnoreIntermediateType{&previewIgnoreIntermediateType{Object: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetPreviewLink(index int) (v LinkType) {
|
|
return t.preview[index].Link
|
|
|
|
}
|
|
|
|
// AppendPreviewLink adds to the back of preview a LinkType type
|
|
func (t *Ignore) AppendPreviewLink(v LinkType) {
|
|
t.preview = append(t.preview, &previewIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewLink adds to the front of preview a LinkType type
|
|
func (t *Ignore) PrependPreviewLink(v LinkType) {
|
|
t.preview = append([]*previewIgnoreIntermediateType{&previewIgnoreIntermediateType{Link: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetPreviewIRI(index int) (v *url.URL) {
|
|
return t.preview[index].IRI
|
|
|
|
}
|
|
|
|
// AppendPreviewIRI adds to the back of preview a *url.URL type
|
|
func (t *Ignore) AppendPreviewIRI(v *url.URL) {
|
|
t.preview = append(t.preview, &previewIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependPreviewIRI adds to the front of preview a *url.URL type
|
|
func (t *Ignore) PrependPreviewIRI(v *url.URL) {
|
|
t.preview = append([]*previewIgnoreIntermediateType{&previewIgnoreIntermediateType{IRI: v}}, t.preview...)
|
|
|
|
}
|
|
|
|
// RemovePreviewIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownPreview() (ok bool) {
|
|
return t.preview != nil && t.preview[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreview returns the unknown value for preview
|
|
func (t *Ignore) GetUnknownPreview() (v interface{}) {
|
|
return t.preview[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreview sets the unknown value of preview
|
|
func (t *Ignore) SetUnknownPreview(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &previewIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preview = append(t.preview, tmp)
|
|
|
|
}
|
|
|
|
// IsPublished determines whether the call to GetPublished is safe
|
|
func (t *Ignore) IsPublished() (ok bool) {
|
|
return t.published != nil && t.published.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetPublished returns the value safely if IsPublished returned true
|
|
func (t *Ignore) GetPublished() (v time.Time) {
|
|
return *t.published.dateTime
|
|
|
|
}
|
|
|
|
// SetPublished sets the value of published to be of time.Time type
|
|
func (t *Ignore) SetPublished(v time.Time) {
|
|
t.published = &publishedIgnoreIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsPublishedIRI determines whether the call to GetPublishedIRI is safe
|
|
func (t *Ignore) IsPublishedIRI() (ok bool) {
|
|
return t.published != nil && t.published.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPublishedIRI returns the value safely if IsPublishedIRI returned true
|
|
func (t *Ignore) GetPublishedIRI() (v *url.URL) {
|
|
return t.published.IRI
|
|
|
|
}
|
|
|
|
// SetPublishedIRI sets the value of published to be of *url.URL type
|
|
func (t *Ignore) SetPublishedIRI(v *url.URL) {
|
|
t.published = &publishedIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPublished determines whether the call to GetUnknownPublished is safe
|
|
func (t *Ignore) HasUnknownPublished() (ok bool) {
|
|
return t.published != nil && t.published.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPublished returns the unknown value for published
|
|
func (t *Ignore) GetUnknownPublished() (v interface{}) {
|
|
return t.published.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPublished sets the unknown value of published
|
|
func (t *Ignore) SetUnknownPublished(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &publishedIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.published = tmp
|
|
|
|
}
|
|
|
|
// IsReplies determines whether the call to GetReplies is safe
|
|
func (t *Ignore) IsReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.Collection != nil
|
|
|
|
}
|
|
|
|
// GetReplies returns the value safely if IsReplies returned true
|
|
func (t *Ignore) GetReplies() (v CollectionType) {
|
|
return t.replies.Collection
|
|
|
|
}
|
|
|
|
// SetReplies sets the value of replies to be of CollectionType type
|
|
func (t *Ignore) SetReplies(v CollectionType) {
|
|
t.replies = &repliesIgnoreIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsRepliesIRI determines whether the call to GetRepliesIRI is safe
|
|
func (t *Ignore) IsRepliesIRI() (ok bool) {
|
|
return t.replies != nil && t.replies.IRI != nil
|
|
|
|
}
|
|
|
|
// GetRepliesIRI returns the value safely if IsRepliesIRI returned true
|
|
func (t *Ignore) GetRepliesIRI() (v *url.URL) {
|
|
return t.replies.IRI
|
|
|
|
}
|
|
|
|
// SetRepliesIRI sets the value of replies to be of *url.URL type
|
|
func (t *Ignore) SetRepliesIRI(v *url.URL) {
|
|
t.replies = &repliesIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownReplies determines whether the call to GetUnknownReplies is safe
|
|
func (t *Ignore) HasUnknownReplies() (ok bool) {
|
|
return t.replies != nil && t.replies.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownReplies returns the unknown value for replies
|
|
func (t *Ignore) GetUnknownReplies() (v interface{}) {
|
|
return t.replies.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownReplies sets the unknown value of replies
|
|
func (t *Ignore) SetUnknownReplies(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &repliesIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.replies = tmp
|
|
|
|
}
|
|
|
|
// IsStartTime determines whether the call to GetStartTime is safe
|
|
func (t *Ignore) IsStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetStartTime returns the value safely if IsStartTime returned true
|
|
func (t *Ignore) GetStartTime() (v time.Time) {
|
|
return *t.startTime.dateTime
|
|
|
|
}
|
|
|
|
// SetStartTime sets the value of startTime to be of time.Time type
|
|
func (t *Ignore) SetStartTime(v time.Time) {
|
|
t.startTime = &startTimeIgnoreIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsStartTimeIRI determines whether the call to GetStartTimeIRI is safe
|
|
func (t *Ignore) IsStartTimeIRI() (ok bool) {
|
|
return t.startTime != nil && t.startTime.IRI != nil
|
|
|
|
}
|
|
|
|
// GetStartTimeIRI returns the value safely if IsStartTimeIRI returned true
|
|
func (t *Ignore) GetStartTimeIRI() (v *url.URL) {
|
|
return t.startTime.IRI
|
|
|
|
}
|
|
|
|
// SetStartTimeIRI sets the value of startTime to be of *url.URL type
|
|
func (t *Ignore) SetStartTimeIRI(v *url.URL) {
|
|
t.startTime = &startTimeIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownStartTime determines whether the call to GetUnknownStartTime is safe
|
|
func (t *Ignore) HasUnknownStartTime() (ok bool) {
|
|
return t.startTime != nil && t.startTime.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStartTime returns the unknown value for startTime
|
|
func (t *Ignore) GetUnknownStartTime() (v interface{}) {
|
|
return t.startTime.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownStartTime sets the unknown value of startTime
|
|
func (t *Ignore) SetUnknownStartTime(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &startTimeIgnoreIntermediateType{}
|
|
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 *Ignore) SummaryLen() (l int) {
|
|
return len(t.summary)
|
|
|
|
}
|
|
|
|
// IsSummaryString determines whether the call to GetSummaryString is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetSummaryString(index int) (v string) {
|
|
return *t.summary[index].stringName
|
|
|
|
}
|
|
|
|
// AppendSummaryString adds to the back of summary a string type
|
|
func (t *Ignore) AppendSummaryString(v string) {
|
|
t.summary = append(t.summary, &summaryIgnoreIntermediateType{stringName: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryString adds to the front of summary a string type
|
|
func (t *Ignore) PrependSummaryString(v string) {
|
|
t.summary = append([]*summaryIgnoreIntermediateType{&summaryIgnoreIntermediateType{stringName: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryString deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetSummaryLangString(index int) (v string) {
|
|
return *t.summary[index].langString
|
|
|
|
}
|
|
|
|
// AppendSummaryLangString adds to the back of summary a string type
|
|
func (t *Ignore) AppendSummaryLangString(v string) {
|
|
t.summary = append(t.summary, &summaryIgnoreIntermediateType{langString: &v})
|
|
|
|
}
|
|
|
|
// PrependSummaryLangString adds to the front of summary a string type
|
|
func (t *Ignore) PrependSummaryLangString(v string) {
|
|
t.summary = append([]*summaryIgnoreIntermediateType{&summaryIgnoreIntermediateType{langString: &v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryLangString deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetSummaryIRI(index int) (v *url.URL) {
|
|
return t.summary[index].IRI
|
|
|
|
}
|
|
|
|
// AppendSummaryIRI adds to the back of summary a *url.URL type
|
|
func (t *Ignore) AppendSummaryIRI(v *url.URL) {
|
|
t.summary = append(t.summary, &summaryIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependSummaryIRI adds to the front of summary a *url.URL type
|
|
func (t *Ignore) PrependSummaryIRI(v *url.URL) {
|
|
t.summary = append([]*summaryIgnoreIntermediateType{&summaryIgnoreIntermediateType{IRI: v}}, t.summary...)
|
|
|
|
}
|
|
|
|
// RemoveSummaryIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownSummary() (ok bool) {
|
|
return t.summary != nil && t.summary[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSummary returns the unknown value for summary
|
|
func (t *Ignore) GetUnknownSummary() (v interface{}) {
|
|
return t.summary[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSummary sets the unknown value of summary
|
|
func (t *Ignore) SetUnknownSummary(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &summaryIgnoreIntermediateType{}
|
|
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 *Ignore) 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 *Ignore) 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 *Ignore) 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 *Ignore) TagLen() (l int) {
|
|
return len(t.tag)
|
|
|
|
}
|
|
|
|
// IsTagObject determines whether the call to GetTagObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetTagObject(index int) (v ObjectType) {
|
|
return t.tag[index].Object
|
|
|
|
}
|
|
|
|
// AppendTagObject adds to the back of tag a ObjectType type
|
|
func (t *Ignore) AppendTagObject(v ObjectType) {
|
|
t.tag = append(t.tag, &tagIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependTagObject adds to the front of tag a ObjectType type
|
|
func (t *Ignore) PrependTagObject(v ObjectType) {
|
|
t.tag = append([]*tagIgnoreIntermediateType{&tagIgnoreIntermediateType{Object: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetTagLink(index int) (v LinkType) {
|
|
return t.tag[index].Link
|
|
|
|
}
|
|
|
|
// AppendTagLink adds to the back of tag a LinkType type
|
|
func (t *Ignore) AppendTagLink(v LinkType) {
|
|
t.tag = append(t.tag, &tagIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependTagLink adds to the front of tag a LinkType type
|
|
func (t *Ignore) PrependTagLink(v LinkType) {
|
|
t.tag = append([]*tagIgnoreIntermediateType{&tagIgnoreIntermediateType{Link: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetTagIRI(index int) (v *url.URL) {
|
|
return t.tag[index].IRI
|
|
|
|
}
|
|
|
|
// AppendTagIRI adds to the back of tag a *url.URL type
|
|
func (t *Ignore) AppendTagIRI(v *url.URL) {
|
|
t.tag = append(t.tag, &tagIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependTagIRI adds to the front of tag a *url.URL type
|
|
func (t *Ignore) PrependTagIRI(v *url.URL) {
|
|
t.tag = append([]*tagIgnoreIntermediateType{&tagIgnoreIntermediateType{IRI: v}}, t.tag...)
|
|
|
|
}
|
|
|
|
// RemoveTagIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownTag() (ok bool) {
|
|
return t.tag != nil && t.tag[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTag returns the unknown value for tag
|
|
func (t *Ignore) GetUnknownTag() (v interface{}) {
|
|
return t.tag[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTag sets the unknown value of tag
|
|
func (t *Ignore) SetUnknownTag(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &tagIgnoreIntermediateType{}
|
|
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 *Ignore) TypeLen() (l int) {
|
|
return len(t.typeName)
|
|
|
|
}
|
|
|
|
// GetType returns the value for the specified index
|
|
func (t *Ignore) GetType(index int) (v interface{}) {
|
|
return t.typeName[index]
|
|
|
|
}
|
|
|
|
// AppendType adds a value to the back of type
|
|
func (t *Ignore) AppendType(v interface{}) {
|
|
t.typeName = append(t.typeName, v)
|
|
|
|
}
|
|
|
|
// PrependType adds a value to the front of type
|
|
func (t *Ignore) PrependType(v interface{}) {
|
|
t.typeName = append([]interface{}{v}, t.typeName...)
|
|
|
|
}
|
|
|
|
// RemoveType deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) IsUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.dateTime != nil
|
|
|
|
}
|
|
|
|
// GetUpdated returns the value safely if IsUpdated returned true
|
|
func (t *Ignore) GetUpdated() (v time.Time) {
|
|
return *t.updated.dateTime
|
|
|
|
}
|
|
|
|
// SetUpdated sets the value of updated to be of time.Time type
|
|
func (t *Ignore) SetUpdated(v time.Time) {
|
|
t.updated = &updatedIgnoreIntermediateType{dateTime: &v}
|
|
|
|
}
|
|
|
|
// IsUpdatedIRI determines whether the call to GetUpdatedIRI is safe
|
|
func (t *Ignore) IsUpdatedIRI() (ok bool) {
|
|
return t.updated != nil && t.updated.IRI != nil
|
|
|
|
}
|
|
|
|
// GetUpdatedIRI returns the value safely if IsUpdatedIRI returned true
|
|
func (t *Ignore) GetUpdatedIRI() (v *url.URL) {
|
|
return t.updated.IRI
|
|
|
|
}
|
|
|
|
// SetUpdatedIRI sets the value of updated to be of *url.URL type
|
|
func (t *Ignore) SetUpdatedIRI(v *url.URL) {
|
|
t.updated = &updatedIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownUpdated determines whether the call to GetUnknownUpdated is safe
|
|
func (t *Ignore) HasUnknownUpdated() (ok bool) {
|
|
return t.updated != nil && t.updated.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUpdated returns the unknown value for updated
|
|
func (t *Ignore) GetUnknownUpdated() (v interface{}) {
|
|
return t.updated.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUpdated sets the unknown value of updated
|
|
func (t *Ignore) SetUnknownUpdated(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &updatedIgnoreIntermediateType{}
|
|
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 *Ignore) UrlLen() (l int) {
|
|
return len(t.url)
|
|
|
|
}
|
|
|
|
// IsUrlAnyURI determines whether the call to GetUrlAnyURI is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetUrlAnyURI(index int) (v *url.URL) {
|
|
return t.url[index].anyURI
|
|
|
|
}
|
|
|
|
// AppendUrlAnyURI adds to the back of url a *url.URL type
|
|
func (t *Ignore) AppendUrlAnyURI(v *url.URL) {
|
|
t.url = append(t.url, &urlIgnoreIntermediateType{anyURI: v})
|
|
|
|
}
|
|
|
|
// PrependUrlAnyURI adds to the front of url a *url.URL type
|
|
func (t *Ignore) PrependUrlAnyURI(v *url.URL) {
|
|
t.url = append([]*urlIgnoreIntermediateType{&urlIgnoreIntermediateType{anyURI: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlAnyURI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetUrlLink(index int) (v LinkType) {
|
|
return t.url[index].Link
|
|
|
|
}
|
|
|
|
// AppendUrlLink adds to the back of url a LinkType type
|
|
func (t *Ignore) AppendUrlLink(v LinkType) {
|
|
t.url = append(t.url, &urlIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependUrlLink adds to the front of url a LinkType type
|
|
func (t *Ignore) PrependUrlLink(v LinkType) {
|
|
t.url = append([]*urlIgnoreIntermediateType{&urlIgnoreIntermediateType{Link: v}}, t.url...)
|
|
|
|
}
|
|
|
|
// RemoveUrlLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownUrl() (ok bool) {
|
|
return t.url != nil && t.url[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownUrl returns the unknown value for url
|
|
func (t *Ignore) GetUnknownUrl() (v interface{}) {
|
|
return t.url[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownUrl sets the unknown value of url
|
|
func (t *Ignore) SetUnknownUrl(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &urlIgnoreIntermediateType{}
|
|
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 *Ignore) ToLen() (l int) {
|
|
return len(t.to)
|
|
|
|
}
|
|
|
|
// IsToObject determines whether the call to GetToObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetToObject(index int) (v ObjectType) {
|
|
return t.to[index].Object
|
|
|
|
}
|
|
|
|
// AppendToObject adds to the back of to a ObjectType type
|
|
func (t *Ignore) AppendToObject(v ObjectType) {
|
|
t.to = append(t.to, &toIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependToObject adds to the front of to a ObjectType type
|
|
func (t *Ignore) PrependToObject(v ObjectType) {
|
|
t.to = append([]*toIgnoreIntermediateType{&toIgnoreIntermediateType{Object: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetToLink(index int) (v LinkType) {
|
|
return t.to[index].Link
|
|
|
|
}
|
|
|
|
// AppendToLink adds to the back of to a LinkType type
|
|
func (t *Ignore) AppendToLink(v LinkType) {
|
|
t.to = append(t.to, &toIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependToLink adds to the front of to a LinkType type
|
|
func (t *Ignore) PrependToLink(v LinkType) {
|
|
t.to = append([]*toIgnoreIntermediateType{&toIgnoreIntermediateType{Link: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetToIRI(index int) (v *url.URL) {
|
|
return t.to[index].IRI
|
|
|
|
}
|
|
|
|
// AppendToIRI adds to the back of to a *url.URL type
|
|
func (t *Ignore) AppendToIRI(v *url.URL) {
|
|
t.to = append(t.to, &toIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependToIRI adds to the front of to a *url.URL type
|
|
func (t *Ignore) PrependToIRI(v *url.URL) {
|
|
t.to = append([]*toIgnoreIntermediateType{&toIgnoreIntermediateType{IRI: v}}, t.to...)
|
|
|
|
}
|
|
|
|
// RemoveToIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownTo() (ok bool) {
|
|
return t.to != nil && t.to[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownTo returns the unknown value for to
|
|
func (t *Ignore) GetUnknownTo() (v interface{}) {
|
|
return t.to[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownTo sets the unknown value of to
|
|
func (t *Ignore) SetUnknownTo(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &toIgnoreIntermediateType{}
|
|
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 *Ignore) BtoLen() (l int) {
|
|
return len(t.bto)
|
|
|
|
}
|
|
|
|
// IsBtoObject determines whether the call to GetBtoObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetBtoObject(index int) (v ObjectType) {
|
|
return t.bto[index].Object
|
|
|
|
}
|
|
|
|
// AppendBtoObject adds to the back of bto a ObjectType type
|
|
func (t *Ignore) AppendBtoObject(v ObjectType) {
|
|
t.bto = append(t.bto, &btoIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBtoObject adds to the front of bto a ObjectType type
|
|
func (t *Ignore) PrependBtoObject(v ObjectType) {
|
|
t.bto = append([]*btoIgnoreIntermediateType{&btoIgnoreIntermediateType{Object: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetBtoLink(index int) (v LinkType) {
|
|
return t.bto[index].Link
|
|
|
|
}
|
|
|
|
// AppendBtoLink adds to the back of bto a LinkType type
|
|
func (t *Ignore) AppendBtoLink(v LinkType) {
|
|
t.bto = append(t.bto, &btoIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBtoLink adds to the front of bto a LinkType type
|
|
func (t *Ignore) PrependBtoLink(v LinkType) {
|
|
t.bto = append([]*btoIgnoreIntermediateType{&btoIgnoreIntermediateType{Link: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetBtoIRI(index int) (v *url.URL) {
|
|
return t.bto[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBtoIRI adds to the back of bto a *url.URL type
|
|
func (t *Ignore) AppendBtoIRI(v *url.URL) {
|
|
t.bto = append(t.bto, &btoIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBtoIRI adds to the front of bto a *url.URL type
|
|
func (t *Ignore) PrependBtoIRI(v *url.URL) {
|
|
t.bto = append([]*btoIgnoreIntermediateType{&btoIgnoreIntermediateType{IRI: v}}, t.bto...)
|
|
|
|
}
|
|
|
|
// RemoveBtoIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownBto() (ok bool) {
|
|
return t.bto != nil && t.bto[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBto returns the unknown value for bto
|
|
func (t *Ignore) GetUnknownBto() (v interface{}) {
|
|
return t.bto[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBto sets the unknown value of bto
|
|
func (t *Ignore) SetUnknownBto(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &btoIgnoreIntermediateType{}
|
|
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 *Ignore) CcLen() (l int) {
|
|
return len(t.cc)
|
|
|
|
}
|
|
|
|
// IsCcObject determines whether the call to GetCcObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetCcObject(index int) (v ObjectType) {
|
|
return t.cc[index].Object
|
|
|
|
}
|
|
|
|
// AppendCcObject adds to the back of cc a ObjectType type
|
|
func (t *Ignore) AppendCcObject(v ObjectType) {
|
|
t.cc = append(t.cc, &ccIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependCcObject adds to the front of cc a ObjectType type
|
|
func (t *Ignore) PrependCcObject(v ObjectType) {
|
|
t.cc = append([]*ccIgnoreIntermediateType{&ccIgnoreIntermediateType{Object: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetCcLink(index int) (v LinkType) {
|
|
return t.cc[index].Link
|
|
|
|
}
|
|
|
|
// AppendCcLink adds to the back of cc a LinkType type
|
|
func (t *Ignore) AppendCcLink(v LinkType) {
|
|
t.cc = append(t.cc, &ccIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependCcLink adds to the front of cc a LinkType type
|
|
func (t *Ignore) PrependCcLink(v LinkType) {
|
|
t.cc = append([]*ccIgnoreIntermediateType{&ccIgnoreIntermediateType{Link: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetCcIRI(index int) (v *url.URL) {
|
|
return t.cc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendCcIRI adds to the back of cc a *url.URL type
|
|
func (t *Ignore) AppendCcIRI(v *url.URL) {
|
|
t.cc = append(t.cc, &ccIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependCcIRI adds to the front of cc a *url.URL type
|
|
func (t *Ignore) PrependCcIRI(v *url.URL) {
|
|
t.cc = append([]*ccIgnoreIntermediateType{&ccIgnoreIntermediateType{IRI: v}}, t.cc...)
|
|
|
|
}
|
|
|
|
// RemoveCcIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownCc() (ok bool) {
|
|
return t.cc != nil && t.cc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownCc returns the unknown value for cc
|
|
func (t *Ignore) GetUnknownCc() (v interface{}) {
|
|
return t.cc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownCc sets the unknown value of cc
|
|
func (t *Ignore) SetUnknownCc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &ccIgnoreIntermediateType{}
|
|
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 *Ignore) BccLen() (l int) {
|
|
return len(t.bcc)
|
|
|
|
}
|
|
|
|
// IsBccObject determines whether the call to GetBccObject is safe for the specified index
|
|
func (t *Ignore) 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 *Ignore) GetBccObject(index int) (v ObjectType) {
|
|
return t.bcc[index].Object
|
|
|
|
}
|
|
|
|
// AppendBccObject adds to the back of bcc a ObjectType type
|
|
func (t *Ignore) AppendBccObject(v ObjectType) {
|
|
t.bcc = append(t.bcc, &bccIgnoreIntermediateType{Object: v})
|
|
|
|
}
|
|
|
|
// PrependBccObject adds to the front of bcc a ObjectType type
|
|
func (t *Ignore) PrependBccObject(v ObjectType) {
|
|
t.bcc = append([]*bccIgnoreIntermediateType{&bccIgnoreIntermediateType{Object: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccObject deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetBccLink(index int) (v LinkType) {
|
|
return t.bcc[index].Link
|
|
|
|
}
|
|
|
|
// AppendBccLink adds to the back of bcc a LinkType type
|
|
func (t *Ignore) AppendBccLink(v LinkType) {
|
|
t.bcc = append(t.bcc, &bccIgnoreIntermediateType{Link: v})
|
|
|
|
}
|
|
|
|
// PrependBccLink adds to the front of bcc a LinkType type
|
|
func (t *Ignore) PrependBccLink(v LinkType) {
|
|
t.bcc = append([]*bccIgnoreIntermediateType{&bccIgnoreIntermediateType{Link: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccLink deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) GetBccIRI(index int) (v *url.URL) {
|
|
return t.bcc[index].IRI
|
|
|
|
}
|
|
|
|
// AppendBccIRI adds to the back of bcc a *url.URL type
|
|
func (t *Ignore) AppendBccIRI(v *url.URL) {
|
|
t.bcc = append(t.bcc, &bccIgnoreIntermediateType{IRI: v})
|
|
|
|
}
|
|
|
|
// PrependBccIRI adds to the front of bcc a *url.URL type
|
|
func (t *Ignore) PrependBccIRI(v *url.URL) {
|
|
t.bcc = append([]*bccIgnoreIntermediateType{&bccIgnoreIntermediateType{IRI: v}}, t.bcc...)
|
|
|
|
}
|
|
|
|
// RemoveBccIRI deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownBcc() (ok bool) {
|
|
return t.bcc != nil && t.bcc[0].unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownBcc returns the unknown value for bcc
|
|
func (t *Ignore) GetUnknownBcc() (v interface{}) {
|
|
return t.bcc[0].unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownBcc sets the unknown value of bcc
|
|
func (t *Ignore) SetUnknownBcc(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &bccIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.bcc = append(t.bcc, tmp)
|
|
|
|
}
|
|
|
|
// IsMediaType determines whether the call to GetMediaType is safe
|
|
func (t *Ignore) IsMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.mimeMediaTypeValue != nil
|
|
|
|
}
|
|
|
|
// GetMediaType returns the value safely if IsMediaType returned true
|
|
func (t *Ignore) GetMediaType() (v string) {
|
|
return *t.mediaType.mimeMediaTypeValue
|
|
|
|
}
|
|
|
|
// SetMediaType sets the value of mediaType to be of string type
|
|
func (t *Ignore) SetMediaType(v string) {
|
|
t.mediaType = &mediaTypeIgnoreIntermediateType{mimeMediaTypeValue: &v}
|
|
|
|
}
|
|
|
|
// IsMediaTypeIRI determines whether the call to GetMediaTypeIRI is safe
|
|
func (t *Ignore) IsMediaTypeIRI() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.IRI != nil
|
|
|
|
}
|
|
|
|
// GetMediaTypeIRI returns the value safely if IsMediaTypeIRI returned true
|
|
func (t *Ignore) GetMediaTypeIRI() (v *url.URL) {
|
|
return t.mediaType.IRI
|
|
|
|
}
|
|
|
|
// SetMediaTypeIRI sets the value of mediaType to be of *url.URL type
|
|
func (t *Ignore) SetMediaTypeIRI(v *url.URL) {
|
|
t.mediaType = &mediaTypeIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownMediaType determines whether the call to GetUnknownMediaType is safe
|
|
func (t *Ignore) HasUnknownMediaType() (ok bool) {
|
|
return t.mediaType != nil && t.mediaType.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownMediaType returns the unknown value for mediaType
|
|
func (t *Ignore) GetUnknownMediaType() (v interface{}) {
|
|
return t.mediaType.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownMediaType sets the unknown value of mediaType
|
|
func (t *Ignore) SetUnknownMediaType(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &mediaTypeIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.mediaType = tmp
|
|
|
|
}
|
|
|
|
// IsDuration determines whether the call to GetDuration is safe
|
|
func (t *Ignore) IsDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.duration != nil
|
|
|
|
}
|
|
|
|
// GetDuration returns the value safely if IsDuration returned true
|
|
func (t *Ignore) GetDuration() (v time.Duration) {
|
|
return *t.duration.duration
|
|
|
|
}
|
|
|
|
// SetDuration sets the value of duration to be of time.Duration type
|
|
func (t *Ignore) SetDuration(v time.Duration) {
|
|
t.duration = &durationIgnoreIntermediateType{duration: &v}
|
|
|
|
}
|
|
|
|
// IsDurationIRI determines whether the call to GetDurationIRI is safe
|
|
func (t *Ignore) IsDurationIRI() (ok bool) {
|
|
return t.duration != nil && t.duration.IRI != nil
|
|
|
|
}
|
|
|
|
// GetDurationIRI returns the value safely if IsDurationIRI returned true
|
|
func (t *Ignore) GetDurationIRI() (v *url.URL) {
|
|
return t.duration.IRI
|
|
|
|
}
|
|
|
|
// SetDurationIRI sets the value of duration to be of *url.URL type
|
|
func (t *Ignore) SetDurationIRI(v *url.URL) {
|
|
t.duration = &durationIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownDuration determines whether the call to GetUnknownDuration is safe
|
|
func (t *Ignore) HasUnknownDuration() (ok bool) {
|
|
return t.duration != nil && t.duration.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownDuration returns the unknown value for duration
|
|
func (t *Ignore) GetUnknownDuration() (v interface{}) {
|
|
return t.duration.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownDuration sets the unknown value of duration
|
|
func (t *Ignore) SetUnknownDuration(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &durationIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.duration = tmp
|
|
|
|
}
|
|
|
|
// IsSource determines whether the call to GetSource is safe
|
|
func (t *Ignore) IsSource() (ok bool) {
|
|
return t.source != nil && t.source.Object != nil
|
|
|
|
}
|
|
|
|
// GetSource returns the value safely if IsSource returned true
|
|
func (t *Ignore) GetSource() (v ObjectType) {
|
|
return t.source.Object
|
|
|
|
}
|
|
|
|
// SetSource sets the value of source to be of ObjectType type
|
|
func (t *Ignore) SetSource(v ObjectType) {
|
|
t.source = &sourceIgnoreIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsSourceIRI determines whether the call to GetSourceIRI is safe
|
|
func (t *Ignore) IsSourceIRI() (ok bool) {
|
|
return t.source != nil && t.source.IRI != nil
|
|
|
|
}
|
|
|
|
// GetSourceIRI returns the value safely if IsSourceIRI returned true
|
|
func (t *Ignore) GetSourceIRI() (v *url.URL) {
|
|
return t.source.IRI
|
|
|
|
}
|
|
|
|
// SetSourceIRI sets the value of source to be of *url.URL type
|
|
func (t *Ignore) SetSourceIRI(v *url.URL) {
|
|
t.source = &sourceIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownSource determines whether the call to GetUnknownSource is safe
|
|
func (t *Ignore) HasUnknownSource() (ok bool) {
|
|
return t.source != nil && t.source.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSource returns the unknown value for source
|
|
func (t *Ignore) GetUnknownSource() (v interface{}) {
|
|
return t.source.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownSource sets the unknown value of source
|
|
func (t *Ignore) SetUnknownSource(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &sourceIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.source = tmp
|
|
|
|
}
|
|
|
|
// IsInboxOrderedCollection determines whether the call to GetInboxOrderedCollection is safe
|
|
func (t *Ignore) IsInboxOrderedCollection() (ok bool) {
|
|
return t.inbox != nil && t.inbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetInboxOrderedCollection returns the value safely if IsInboxOrderedCollection returned true
|
|
func (t *Ignore) GetInboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.inbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetInboxOrderedCollection sets the value of inbox to be of OrderedCollectionType type
|
|
func (t *Ignore) SetInboxOrderedCollection(v OrderedCollectionType) {
|
|
t.inbox = &inboxIgnoreIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsInboxAnyURI determines whether the call to GetInboxAnyURI is safe
|
|
func (t *Ignore) IsInboxAnyURI() (ok bool) {
|
|
return t.inbox != nil && t.inbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetInboxAnyURI returns the value safely if IsInboxAnyURI returned true
|
|
func (t *Ignore) GetInboxAnyURI() (v *url.URL) {
|
|
return t.inbox.anyURI
|
|
|
|
}
|
|
|
|
// SetInboxAnyURI sets the value of inbox to be of *url.URL type
|
|
func (t *Ignore) SetInboxAnyURI(v *url.URL) {
|
|
t.inbox = &inboxIgnoreIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownInbox determines whether the call to GetUnknownInbox is safe
|
|
func (t *Ignore) HasUnknownInbox() (ok bool) {
|
|
return t.inbox != nil && t.inbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownInbox returns the unknown value for inbox
|
|
func (t *Ignore) GetUnknownInbox() (v interface{}) {
|
|
return t.inbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownInbox sets the unknown value of inbox
|
|
func (t *Ignore) SetUnknownInbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &inboxIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.inbox = tmp
|
|
|
|
}
|
|
|
|
// IsOutboxOrderedCollection determines whether the call to GetOutboxOrderedCollection is safe
|
|
func (t *Ignore) IsOutboxOrderedCollection() (ok bool) {
|
|
return t.outbox != nil && t.outbox.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetOutboxOrderedCollection returns the value safely if IsOutboxOrderedCollection returned true
|
|
func (t *Ignore) GetOutboxOrderedCollection() (v OrderedCollectionType) {
|
|
return t.outbox.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetOutboxOrderedCollection sets the value of outbox to be of OrderedCollectionType type
|
|
func (t *Ignore) SetOutboxOrderedCollection(v OrderedCollectionType) {
|
|
t.outbox = &outboxIgnoreIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsOutboxAnyURI determines whether the call to GetOutboxAnyURI is safe
|
|
func (t *Ignore) IsOutboxAnyURI() (ok bool) {
|
|
return t.outbox != nil && t.outbox.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetOutboxAnyURI returns the value safely if IsOutboxAnyURI returned true
|
|
func (t *Ignore) GetOutboxAnyURI() (v *url.URL) {
|
|
return t.outbox.anyURI
|
|
|
|
}
|
|
|
|
// SetOutboxAnyURI sets the value of outbox to be of *url.URL type
|
|
func (t *Ignore) SetOutboxAnyURI(v *url.URL) {
|
|
t.outbox = &outboxIgnoreIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownOutbox determines whether the call to GetUnknownOutbox is safe
|
|
func (t *Ignore) HasUnknownOutbox() (ok bool) {
|
|
return t.outbox != nil && t.outbox.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOutbox returns the unknown value for outbox
|
|
func (t *Ignore) GetUnknownOutbox() (v interface{}) {
|
|
return t.outbox.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownOutbox sets the unknown value of outbox
|
|
func (t *Ignore) SetUnknownOutbox(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &outboxIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.outbox = tmp
|
|
|
|
}
|
|
|
|
// IsFollowingCollection determines whether the call to GetFollowingCollection is safe
|
|
func (t *Ignore) IsFollowingCollection() (ok bool) {
|
|
return t.following != nil && t.following.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingCollection returns the value safely if IsFollowingCollection returned true
|
|
func (t *Ignore) GetFollowingCollection() (v CollectionType) {
|
|
return t.following.Collection
|
|
|
|
}
|
|
|
|
// SetFollowingCollection sets the value of following to be of CollectionType type
|
|
func (t *Ignore) SetFollowingCollection(v CollectionType) {
|
|
t.following = &followingIgnoreIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingOrderedCollection determines whether the call to GetFollowingOrderedCollection is safe
|
|
func (t *Ignore) IsFollowingOrderedCollection() (ok bool) {
|
|
return t.following != nil && t.following.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowingOrderedCollection returns the value safely if IsFollowingOrderedCollection returned true
|
|
func (t *Ignore) GetFollowingOrderedCollection() (v OrderedCollectionType) {
|
|
return t.following.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowingOrderedCollection sets the value of following to be of OrderedCollectionType type
|
|
func (t *Ignore) SetFollowingOrderedCollection(v OrderedCollectionType) {
|
|
t.following = &followingIgnoreIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowingAnyURI determines whether the call to GetFollowingAnyURI is safe
|
|
func (t *Ignore) IsFollowingAnyURI() (ok bool) {
|
|
return t.following != nil && t.following.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowingAnyURI returns the value safely if IsFollowingAnyURI returned true
|
|
func (t *Ignore) GetFollowingAnyURI() (v *url.URL) {
|
|
return t.following.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowingAnyURI sets the value of following to be of *url.URL type
|
|
func (t *Ignore) SetFollowingAnyURI(v *url.URL) {
|
|
t.following = &followingIgnoreIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowing determines whether the call to GetUnknownFollowing is safe
|
|
func (t *Ignore) HasUnknownFollowing() (ok bool) {
|
|
return t.following != nil && t.following.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowing returns the unknown value for following
|
|
func (t *Ignore) GetUnknownFollowing() (v interface{}) {
|
|
return t.following.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowing sets the unknown value of following
|
|
func (t *Ignore) SetUnknownFollowing(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followingIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.following = tmp
|
|
|
|
}
|
|
|
|
// IsFollowersCollection determines whether the call to GetFollowersCollection is safe
|
|
func (t *Ignore) IsFollowersCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.Collection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersCollection returns the value safely if IsFollowersCollection returned true
|
|
func (t *Ignore) GetFollowersCollection() (v CollectionType) {
|
|
return t.followers.Collection
|
|
|
|
}
|
|
|
|
// SetFollowersCollection sets the value of followers to be of CollectionType type
|
|
func (t *Ignore) SetFollowersCollection(v CollectionType) {
|
|
t.followers = &followersIgnoreIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersOrderedCollection determines whether the call to GetFollowersOrderedCollection is safe
|
|
func (t *Ignore) IsFollowersOrderedCollection() (ok bool) {
|
|
return t.followers != nil && t.followers.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetFollowersOrderedCollection returns the value safely if IsFollowersOrderedCollection returned true
|
|
func (t *Ignore) GetFollowersOrderedCollection() (v OrderedCollectionType) {
|
|
return t.followers.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetFollowersOrderedCollection sets the value of followers to be of OrderedCollectionType type
|
|
func (t *Ignore) SetFollowersOrderedCollection(v OrderedCollectionType) {
|
|
t.followers = &followersIgnoreIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsFollowersAnyURI determines whether the call to GetFollowersAnyURI is safe
|
|
func (t *Ignore) IsFollowersAnyURI() (ok bool) {
|
|
return t.followers != nil && t.followers.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetFollowersAnyURI returns the value safely if IsFollowersAnyURI returned true
|
|
func (t *Ignore) GetFollowersAnyURI() (v *url.URL) {
|
|
return t.followers.anyURI
|
|
|
|
}
|
|
|
|
// SetFollowersAnyURI sets the value of followers to be of *url.URL type
|
|
func (t *Ignore) SetFollowersAnyURI(v *url.URL) {
|
|
t.followers = &followersIgnoreIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownFollowers determines whether the call to GetUnknownFollowers is safe
|
|
func (t *Ignore) HasUnknownFollowers() (ok bool) {
|
|
return t.followers != nil && t.followers.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownFollowers returns the unknown value for followers
|
|
func (t *Ignore) GetUnknownFollowers() (v interface{}) {
|
|
return t.followers.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownFollowers sets the unknown value of followers
|
|
func (t *Ignore) SetUnknownFollowers(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &followersIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.followers = tmp
|
|
|
|
}
|
|
|
|
// IsLikedCollection determines whether the call to GetLikedCollection is safe
|
|
func (t *Ignore) IsLikedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikedCollection returns the value safely if IsLikedCollection returned true
|
|
func (t *Ignore) GetLikedCollection() (v CollectionType) {
|
|
return t.liked.Collection
|
|
|
|
}
|
|
|
|
// SetLikedCollection sets the value of liked to be of CollectionType type
|
|
func (t *Ignore) SetLikedCollection(v CollectionType) {
|
|
t.liked = &likedIgnoreIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikedOrderedCollection determines whether the call to GetLikedOrderedCollection is safe
|
|
func (t *Ignore) IsLikedOrderedCollection() (ok bool) {
|
|
return t.liked != nil && t.liked.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikedOrderedCollection returns the value safely if IsLikedOrderedCollection returned true
|
|
func (t *Ignore) GetLikedOrderedCollection() (v OrderedCollectionType) {
|
|
return t.liked.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikedOrderedCollection sets the value of liked to be of OrderedCollectionType type
|
|
func (t *Ignore) SetLikedOrderedCollection(v OrderedCollectionType) {
|
|
t.liked = &likedIgnoreIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikedAnyURI determines whether the call to GetLikedAnyURI is safe
|
|
func (t *Ignore) IsLikedAnyURI() (ok bool) {
|
|
return t.liked != nil && t.liked.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikedAnyURI returns the value safely if IsLikedAnyURI returned true
|
|
func (t *Ignore) GetLikedAnyURI() (v *url.URL) {
|
|
return t.liked.anyURI
|
|
|
|
}
|
|
|
|
// SetLikedAnyURI sets the value of liked to be of *url.URL type
|
|
func (t *Ignore) SetLikedAnyURI(v *url.URL) {
|
|
t.liked = &likedIgnoreIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLiked determines whether the call to GetUnknownLiked is safe
|
|
func (t *Ignore) HasUnknownLiked() (ok bool) {
|
|
return t.liked != nil && t.liked.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLiked returns the unknown value for liked
|
|
func (t *Ignore) GetUnknownLiked() (v interface{}) {
|
|
return t.liked.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLiked sets the unknown value of liked
|
|
func (t *Ignore) SetUnknownLiked(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likedIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.liked = tmp
|
|
|
|
}
|
|
|
|
// IsLikesCollection determines whether the call to GetLikesCollection is safe
|
|
func (t *Ignore) IsLikesCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.Collection != nil
|
|
|
|
}
|
|
|
|
// GetLikesCollection returns the value safely if IsLikesCollection returned true
|
|
func (t *Ignore) GetLikesCollection() (v CollectionType) {
|
|
return t.likes.Collection
|
|
|
|
}
|
|
|
|
// SetLikesCollection sets the value of likes to be of CollectionType type
|
|
func (t *Ignore) SetLikesCollection(v CollectionType) {
|
|
t.likes = &likesIgnoreIntermediateType{Collection: v}
|
|
|
|
}
|
|
|
|
// IsLikesOrderedCollection determines whether the call to GetLikesOrderedCollection is safe
|
|
func (t *Ignore) IsLikesOrderedCollection() (ok bool) {
|
|
return t.likes != nil && t.likes.OrderedCollection != nil
|
|
|
|
}
|
|
|
|
// GetLikesOrderedCollection returns the value safely if IsLikesOrderedCollection returned true
|
|
func (t *Ignore) GetLikesOrderedCollection() (v OrderedCollectionType) {
|
|
return t.likes.OrderedCollection
|
|
|
|
}
|
|
|
|
// SetLikesOrderedCollection sets the value of likes to be of OrderedCollectionType type
|
|
func (t *Ignore) SetLikesOrderedCollection(v OrderedCollectionType) {
|
|
t.likes = &likesIgnoreIntermediateType{OrderedCollection: v}
|
|
|
|
}
|
|
|
|
// IsLikesAnyURI determines whether the call to GetLikesAnyURI is safe
|
|
func (t *Ignore) IsLikesAnyURI() (ok bool) {
|
|
return t.likes != nil && t.likes.anyURI != nil
|
|
|
|
}
|
|
|
|
// GetLikesAnyURI returns the value safely if IsLikesAnyURI returned true
|
|
func (t *Ignore) GetLikesAnyURI() (v *url.URL) {
|
|
return t.likes.anyURI
|
|
|
|
}
|
|
|
|
// SetLikesAnyURI sets the value of likes to be of *url.URL type
|
|
func (t *Ignore) SetLikesAnyURI(v *url.URL) {
|
|
t.likes = &likesIgnoreIntermediateType{anyURI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownLikes determines whether the call to GetUnknownLikes is safe
|
|
func (t *Ignore) HasUnknownLikes() (ok bool) {
|
|
return t.likes != nil && t.likes.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownLikes returns the unknown value for likes
|
|
func (t *Ignore) GetUnknownLikes() (v interface{}) {
|
|
return t.likes.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownLikes sets the unknown value of likes
|
|
func (t *Ignore) SetUnknownLikes(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &likesIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.likes = tmp
|
|
|
|
}
|
|
|
|
// StreamsLen determines the number of elements able to be used for the GetStreams and RemoveStreams functions
|
|
func (t *Ignore) StreamsLen() (l int) {
|
|
return len(t.streams)
|
|
|
|
}
|
|
|
|
// GetStreams returns the value for the specified index
|
|
func (t *Ignore) GetStreams(index int) (v *url.URL) {
|
|
return t.streams[index]
|
|
|
|
}
|
|
|
|
// AppendStreams adds a value to the back of streams
|
|
func (t *Ignore) AppendStreams(v *url.URL) {
|
|
t.streams = append(t.streams, v)
|
|
|
|
}
|
|
|
|
// PrependStreams adds a value to the front of streams
|
|
func (t *Ignore) PrependStreams(v *url.URL) {
|
|
t.streams = append([]*url.URL{v}, t.streams...)
|
|
|
|
}
|
|
|
|
// RemoveStreams deletes the value from the specified index
|
|
func (t *Ignore) 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 *Ignore) HasUnknownStreams() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["streams"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownStreams returns the unknown value for streams
|
|
func (t *Ignore) GetUnknownStreams() (v interface{}) {
|
|
return t.unknown_["streams"]
|
|
|
|
}
|
|
|
|
// SetUnknownStreams sets the unknown value of streams
|
|
func (t *Ignore) 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 *Ignore) IsPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.stringName != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsername returns the value safely if IsPreferredUsername returned true
|
|
func (t *Ignore) GetPreferredUsername() (v string) {
|
|
return *t.preferredUsername.stringName
|
|
|
|
}
|
|
|
|
// SetPreferredUsername sets the value of preferredUsername to be of string type
|
|
func (t *Ignore) SetPreferredUsername(v string) {
|
|
t.preferredUsername = &preferredUsernameIgnoreIntermediateType{stringName: &v}
|
|
|
|
}
|
|
|
|
// IsPreferredUsernameIRI determines whether the call to GetPreferredUsernameIRI is safe
|
|
func (t *Ignore) IsPreferredUsernameIRI() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.IRI != nil
|
|
|
|
}
|
|
|
|
// GetPreferredUsernameIRI returns the value safely if IsPreferredUsernameIRI returned true
|
|
func (t *Ignore) GetPreferredUsernameIRI() (v *url.URL) {
|
|
return t.preferredUsername.IRI
|
|
|
|
}
|
|
|
|
// SetPreferredUsernameIRI sets the value of preferredUsername to be of *url.URL type
|
|
func (t *Ignore) SetPreferredUsernameIRI(v *url.URL) {
|
|
t.preferredUsername = &preferredUsernameIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownPreferredUsername determines whether the call to GetUnknownPreferredUsername is safe
|
|
func (t *Ignore) HasUnknownPreferredUsername() (ok bool) {
|
|
return t.preferredUsername != nil && t.preferredUsername.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownPreferredUsername returns the unknown value for preferredUsername
|
|
func (t *Ignore) GetUnknownPreferredUsername() (v interface{}) {
|
|
return t.preferredUsername.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownPreferredUsername sets the unknown value of preferredUsername
|
|
func (t *Ignore) SetUnknownPreferredUsername(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &preferredUsernameIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.preferredUsername = tmp
|
|
|
|
}
|
|
|
|
// PreferredUsernameMapLanguages returns all languages for this property's language mapping, or nil if there are none.
|
|
func (t *Ignore) 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 *Ignore) 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 *Ignore) 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 *Ignore) IsEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.Object != nil
|
|
|
|
}
|
|
|
|
// GetEndpoints returns the value safely if IsEndpoints returned true
|
|
func (t *Ignore) GetEndpoints() (v ObjectType) {
|
|
return t.endpoints.Object
|
|
|
|
}
|
|
|
|
// SetEndpoints sets the value of endpoints to be of ObjectType type
|
|
func (t *Ignore) SetEndpoints(v ObjectType) {
|
|
t.endpoints = &endpointsIgnoreIntermediateType{Object: v}
|
|
|
|
}
|
|
|
|
// IsEndpointsIRI determines whether the call to GetEndpointsIRI is safe
|
|
func (t *Ignore) IsEndpointsIRI() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.IRI != nil
|
|
|
|
}
|
|
|
|
// GetEndpointsIRI returns the value safely if IsEndpointsIRI returned true
|
|
func (t *Ignore) GetEndpointsIRI() (v *url.URL) {
|
|
return t.endpoints.IRI
|
|
|
|
}
|
|
|
|
// SetEndpointsIRI sets the value of endpoints to be of *url.URL type
|
|
func (t *Ignore) SetEndpointsIRI(v *url.URL) {
|
|
t.endpoints = &endpointsIgnoreIntermediateType{IRI: v}
|
|
|
|
}
|
|
|
|
// HasUnknownEndpoints determines whether the call to GetUnknownEndpoints is safe
|
|
func (t *Ignore) HasUnknownEndpoints() (ok bool) {
|
|
return t.endpoints != nil && t.endpoints.unknown_ != nil
|
|
|
|
}
|
|
|
|
// GetUnknownEndpoints returns the unknown value for endpoints
|
|
func (t *Ignore) GetUnknownEndpoints() (v interface{}) {
|
|
return t.endpoints.unknown_
|
|
|
|
}
|
|
|
|
// SetUnknownEndpoints sets the unknown value of endpoints
|
|
func (t *Ignore) SetUnknownEndpoints(i interface{}) {
|
|
if t.unknown_ == nil {
|
|
t.unknown_ = make(map[string]interface{})
|
|
}
|
|
tmp := &endpointsIgnoreIntermediateType{}
|
|
tmp.unknown_ = i
|
|
t.endpoints = tmp
|
|
|
|
}
|
|
|
|
// HasProxyUrl determines whether the call to GetProxyUrl is safe
|
|
func (t *Ignore) HasProxyUrl() (ok bool) {
|
|
return t.proxyUrl != nil
|
|
|
|
}
|
|
|
|
// GetProxyUrl returns the value for proxyUrl
|
|
func (t *Ignore) GetProxyUrl() (v *url.URL) {
|
|
return t.proxyUrl
|
|
|
|
}
|
|
|
|
// SetProxyUrl sets the value of proxyUrl
|
|
func (t *Ignore) SetProxyUrl(v *url.URL) {
|
|
t.proxyUrl = v
|
|
|
|
}
|
|
|
|
// HasUnknownProxyUrl determines whether the call to GetUnknownProxyUrl is safe
|
|
func (t *Ignore) HasUnknownProxyUrl() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["proxyUrl"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProxyUrl returns the unknown value for proxyUrl
|
|
func (t *Ignore) GetUnknownProxyUrl() (v interface{}) {
|
|
return t.unknown_["proxyUrl"]
|
|
|
|
}
|
|
|
|
// SetUnknownProxyUrl sets the unknown value of proxyUrl
|
|
func (t *Ignore) 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 *Ignore) HasOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.oauthAuthorizationEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthAuthorizationEndpoint returns the value for oauthAuthorizationEndpoint
|
|
func (t *Ignore) GetOauthAuthorizationEndpoint() (v *url.URL) {
|
|
return t.oauthAuthorizationEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthAuthorizationEndpoint sets the value of oauthAuthorizationEndpoint
|
|
func (t *Ignore) SetOauthAuthorizationEndpoint(v *url.URL) {
|
|
t.oauthAuthorizationEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthAuthorizationEndpoint determines whether the call to GetUnknownOauthAuthorizationEndpoint is safe
|
|
func (t *Ignore) HasUnknownOauthAuthorizationEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthAuthorizationEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthAuthorizationEndpoint returns the unknown value for oauthAuthorizationEndpoint
|
|
func (t *Ignore) GetUnknownOauthAuthorizationEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthAuthorizationEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthAuthorizationEndpoint sets the unknown value of oauthAuthorizationEndpoint
|
|
func (t *Ignore) 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 *Ignore) HasOauthTokenEndpoint() (ok bool) {
|
|
return t.oauthTokenEndpoint != nil
|
|
|
|
}
|
|
|
|
// GetOauthTokenEndpoint returns the value for oauthTokenEndpoint
|
|
func (t *Ignore) GetOauthTokenEndpoint() (v *url.URL) {
|
|
return t.oauthTokenEndpoint
|
|
|
|
}
|
|
|
|
// SetOauthTokenEndpoint sets the value of oauthTokenEndpoint
|
|
func (t *Ignore) SetOauthTokenEndpoint(v *url.URL) {
|
|
t.oauthTokenEndpoint = v
|
|
|
|
}
|
|
|
|
// HasUnknownOauthTokenEndpoint determines whether the call to GetUnknownOauthTokenEndpoint is safe
|
|
func (t *Ignore) HasUnknownOauthTokenEndpoint() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["oauthTokenEndpoint"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownOauthTokenEndpoint returns the unknown value for oauthTokenEndpoint
|
|
func (t *Ignore) GetUnknownOauthTokenEndpoint() (v interface{}) {
|
|
return t.unknown_["oauthTokenEndpoint"]
|
|
|
|
}
|
|
|
|
// SetUnknownOauthTokenEndpoint sets the unknown value of oauthTokenEndpoint
|
|
func (t *Ignore) 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 *Ignore) HasProvideClientKey() (ok bool) {
|
|
return t.provideClientKey != nil
|
|
|
|
}
|
|
|
|
// GetProvideClientKey returns the value for provideClientKey
|
|
func (t *Ignore) GetProvideClientKey() (v *url.URL) {
|
|
return t.provideClientKey
|
|
|
|
}
|
|
|
|
// SetProvideClientKey sets the value of provideClientKey
|
|
func (t *Ignore) SetProvideClientKey(v *url.URL) {
|
|
t.provideClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownProvideClientKey determines whether the call to GetUnknownProvideClientKey is safe
|
|
func (t *Ignore) HasUnknownProvideClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["provideClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownProvideClientKey returns the unknown value for provideClientKey
|
|
func (t *Ignore) GetUnknownProvideClientKey() (v interface{}) {
|
|
return t.unknown_["provideClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownProvideClientKey sets the unknown value of provideClientKey
|
|
func (t *Ignore) 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 *Ignore) HasSignClientKey() (ok bool) {
|
|
return t.signClientKey != nil
|
|
|
|
}
|
|
|
|
// GetSignClientKey returns the value for signClientKey
|
|
func (t *Ignore) GetSignClientKey() (v *url.URL) {
|
|
return t.signClientKey
|
|
|
|
}
|
|
|
|
// SetSignClientKey sets the value of signClientKey
|
|
func (t *Ignore) SetSignClientKey(v *url.URL) {
|
|
t.signClientKey = v
|
|
|
|
}
|
|
|
|
// HasUnknownSignClientKey determines whether the call to GetUnknownSignClientKey is safe
|
|
func (t *Ignore) HasUnknownSignClientKey() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["signClientKey"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSignClientKey returns the unknown value for signClientKey
|
|
func (t *Ignore) GetUnknownSignClientKey() (v interface{}) {
|
|
return t.unknown_["signClientKey"]
|
|
|
|
}
|
|
|
|
// SetUnknownSignClientKey sets the unknown value of signClientKey
|
|
func (t *Ignore) 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 *Ignore) HasSharedInbox() (ok bool) {
|
|
return t.sharedInbox != nil
|
|
|
|
}
|
|
|
|
// GetSharedInbox returns the value for sharedInbox
|
|
func (t *Ignore) GetSharedInbox() (v *url.URL) {
|
|
return t.sharedInbox
|
|
|
|
}
|
|
|
|
// SetSharedInbox sets the value of sharedInbox
|
|
func (t *Ignore) SetSharedInbox(v *url.URL) {
|
|
t.sharedInbox = v
|
|
|
|
}
|
|
|
|
// HasUnknownSharedInbox determines whether the call to GetUnknownSharedInbox is safe
|
|
func (t *Ignore) HasUnknownSharedInbox() (ok bool) {
|
|
return t.unknown_ != nil && t.unknown_["sharedInbox"] != nil
|
|
|
|
}
|
|
|
|
// GetUnknownSharedInbox returns the unknown value for sharedInbox
|
|
func (t *Ignore) GetUnknownSharedInbox() (v interface{}) {
|
|
return t.unknown_["sharedInbox"]
|
|
|
|
}
|
|
|
|
// SetUnknownSharedInbox sets the unknown value of sharedInbox
|
|
func (t *Ignore) 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 *Ignore) AddUnknown(k string, i interface{}) (this *Ignore) {
|
|
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 *Ignore) 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 *Ignore) RemoveUnknown(k string) (this *Ignore) {
|
|
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 "Ignore" if not manually set by the caller
|
|
func (t *Ignore) 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 == "Ignore" {
|
|
typeAlreadySet = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !typeAlreadySet {
|
|
t.typeName = append(t.typeName, "Ignore")
|
|
}
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceActorIgnoreIntermediateType(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 := serializeSliceObjectIgnoreIntermediateType(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 := serializeSliceTargetIgnoreIntermediateType(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 := serializeSliceResultIgnoreIntermediateType(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 := serializeSliceOriginIgnoreIntermediateType(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 := serializeSliceInstrumentIgnoreIntermediateType(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 := serializeAltitudeIgnoreIntermediateType(t.altitude); err == nil {
|
|
m["altitude"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceAttachmentIgnoreIntermediateType(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 := serializeSliceAttributedToIgnoreIntermediateType(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 := serializeSliceAudienceIgnoreIntermediateType(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 := serializeSliceContentIgnoreIntermediateType(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 := serializeSliceContextIgnoreIntermediateType(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 := serializeSliceNameIgnoreIntermediateType(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 := serializeEndTimeIgnoreIntermediateType(t.endTime); err == nil {
|
|
m["endTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceGeneratorIgnoreIntermediateType(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 := serializeSliceIconIgnoreIntermediateType(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 := serializeSliceImageIgnoreIntermediateType(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 := serializeSliceInReplyToIgnoreIntermediateType(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 := serializeSliceLocationIgnoreIntermediateType(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 := serializeSlicePreviewIgnoreIntermediateType(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 := serializePublishedIgnoreIntermediateType(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 := serializeRepliesIgnoreIntermediateType(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 := serializeStartTimeIgnoreIntermediateType(t.startTime); err == nil {
|
|
m["startTime"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceSummaryIgnoreIntermediateType(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 := serializeSliceTagIgnoreIntermediateType(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 := serializeUpdatedIgnoreIntermediateType(t.updated); err == nil {
|
|
m["updated"] = v
|
|
} else {
|
|
return m, err
|
|
}
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
// Begin generation by generateNonFunctionalMultiTypeDefinition
|
|
if v, err := serializeSliceUrlIgnoreIntermediateType(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 := serializeSliceToIgnoreIntermediateType(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 := serializeSliceBtoIgnoreIntermediateType(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 := serializeSliceCcIgnoreIntermediateType(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 := serializeSliceBccIgnoreIntermediateType(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 := serializeMediaTypeIgnoreIntermediateType(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 := serializeDurationIgnoreIntermediateType(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 := serializeSourceIgnoreIntermediateType(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 := serializeInboxIgnoreIntermediateType(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 := serializeOutboxIgnoreIntermediateType(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 := serializeFollowingIgnoreIntermediateType(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 := serializeFollowersIgnoreIntermediateType(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 := serializeLikedIgnoreIntermediateType(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 := serializeLikesIgnoreIntermediateType(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 := serializePreferredUsernameIgnoreIntermediateType(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 := serializeEndpointsIgnoreIntermediateType(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 *Ignore) 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 := deserializeActorIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.actor, err = deserializeSliceActorIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &actorIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.actor = []*actorIgnoreIntermediateType{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 := deserializeObjectIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.object, err = deserializeSliceObjectIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &objectIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.object = []*objectIgnoreIntermediateType{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 := deserializeTargetIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.target, err = deserializeSliceTargetIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &targetIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.target = []*targetIgnoreIntermediateType{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 := deserializeResultIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.result, err = deserializeSliceResultIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &resultIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.result = []*resultIgnoreIntermediateType{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 := deserializeOriginIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.origin, err = deserializeSliceOriginIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &originIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origin = []*originIgnoreIntermediateType{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 := deserializeInstrumentIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.instrument, err = deserializeSliceInstrumentIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &instrumentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.instrument = []*instrumentIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "altitude" {
|
|
t.altitude, err = deserializeAltitudeIgnoreIntermediateType(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 := deserializeAttachmentIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attachment, err = deserializeSliceAttachmentIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attachmentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attachment = []*attachmentIgnoreIntermediateType{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 := deserializeAttributedToIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.attributedTo, err = deserializeSliceAttributedToIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &attributedToIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.attributedTo = []*attributedToIgnoreIntermediateType{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 := deserializeAudienceIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.audience, err = deserializeSliceAudienceIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &audienceIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.audience = []*audienceIgnoreIntermediateType{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 := deserializeContentIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.content, err = deserializeSliceContentIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.content = []*contentIgnoreIntermediateType{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 := deserializeContextIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.context, err = deserializeSliceContextIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &contextIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.context = []*contextIgnoreIntermediateType{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 := deserializeNameIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.name, err = deserializeSliceNameIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &nameIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.name = []*nameIgnoreIntermediateType{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 = deserializeEndTimeIgnoreIntermediateType(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 := deserializeGeneratorIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.generator, err = deserializeSliceGeneratorIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &generatorIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.generator = []*generatorIgnoreIntermediateType{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 := deserializeIconIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.icon, err = deserializeSliceIconIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &iconIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.icon = []*iconIgnoreIntermediateType{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 := deserializeImageIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.image, err = deserializeSliceImageIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &imageIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.image = []*imageIgnoreIntermediateType{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 := deserializeInReplyToIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.inReplyTo, err = deserializeSliceInReplyToIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &inReplyToIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.inReplyTo = []*inReplyToIgnoreIntermediateType{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 := deserializeLocationIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.location, err = deserializeSliceLocationIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &locationIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.location = []*locationIgnoreIntermediateType{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 := deserializePreviewIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.preview, err = deserializeSlicePreviewIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &previewIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.preview = []*previewIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "published" {
|
|
t.published, err = deserializePublishedIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "replies" {
|
|
t.replies, err = deserializeRepliesIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "startTime" {
|
|
t.startTime, err = deserializeStartTimeIgnoreIntermediateType(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 := deserializeSummaryIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.summary, err = deserializeSliceSummaryIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &summaryIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.summary = []*summaryIgnoreIntermediateType{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 := deserializeTagIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.tag, err = deserializeSliceTagIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &tagIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.tag = []*tagIgnoreIntermediateType{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 = deserializeUpdatedIgnoreIntermediateType(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 := deserializeUrlIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.url, err = deserializeSliceUrlIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &urlIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.url = []*urlIgnoreIntermediateType{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 := deserializeToIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.to, err = deserializeSliceToIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &toIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.to = []*toIgnoreIntermediateType{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 := deserializeBtoIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bto, err = deserializeSliceBtoIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &btoIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bto = []*btoIgnoreIntermediateType{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 := deserializeCcIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.cc, err = deserializeSliceCcIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &ccIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.cc = []*ccIgnoreIntermediateType{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 := deserializeBccIgnoreIntermediateType(tmpMap)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
} else if tmpSlice, ok := v.([]interface{}); ok {
|
|
t.bcc, err = deserializeSliceBccIgnoreIntermediateType(tmpSlice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
} else {
|
|
tmp := &bccIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.bcc = []*bccIgnoreIntermediateType{tmp}
|
|
handled = true
|
|
}
|
|
}
|
|
// End generation by generateNonFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "mediaType" {
|
|
t.mediaType, err = deserializeMediaTypeIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "duration" {
|
|
t.duration, err = deserializeDurationIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "source" {
|
|
t.source, err = deserializeSourceIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "inbox" {
|
|
t.inbox, err = deserializeInboxIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "outbox" {
|
|
t.outbox, err = deserializeOutboxIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "following" {
|
|
t.following, err = deserializeFollowingIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "followers" {
|
|
t.followers, err = deserializeFollowersIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "liked" {
|
|
t.liked, err = deserializeLikedIgnoreIntermediateType(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
handled = true
|
|
}
|
|
// End generation by generateFunctionalMultiTypeDefinition
|
|
}
|
|
if !handled {
|
|
// Begin generation by generateFunctionalMultiTypeDefinition
|
|
if k == "likes" {
|
|
t.likes, err = deserializeLikesIgnoreIntermediateType(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 = deserializePreferredUsernameIgnoreIntermediateType(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 = deserializeEndpointsIgnoreIntermediateType(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
|
|
|
|
}
|
|
|
|
// actorIgnoreIntermediateType will only have one of its values set at most
|
|
type actorIgnoreIntermediateType 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 *actorIgnoreIntermediateType) 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 *actorIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// objectIgnoreIntermediateType will only have one of its values set at most
|
|
type objectIgnoreIntermediateType 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 *objectIgnoreIntermediateType) 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 *objectIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// targetIgnoreIntermediateType will only have one of its values set at most
|
|
type targetIgnoreIntermediateType 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 *targetIgnoreIntermediateType) 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 *targetIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// resultIgnoreIntermediateType will only have one of its values set at most
|
|
type resultIgnoreIntermediateType 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 *resultIgnoreIntermediateType) 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 *resultIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// originIgnoreIntermediateType will only have one of its values set at most
|
|
type originIgnoreIntermediateType 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 *originIgnoreIntermediateType) 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 *originIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// instrumentIgnoreIntermediateType will only have one of its values set at most
|
|
type instrumentIgnoreIntermediateType 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 *instrumentIgnoreIntermediateType) 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 *instrumentIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// altitudeIgnoreIntermediateType will only have one of its values set at most
|
|
type altitudeIgnoreIntermediateType 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 *altitudeIgnoreIntermediateType) 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 *altitudeIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// attachmentIgnoreIntermediateType will only have one of its values set at most
|
|
type attachmentIgnoreIntermediateType 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 *attachmentIgnoreIntermediateType) 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 *attachmentIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// attributedToIgnoreIntermediateType will only have one of its values set at most
|
|
type attributedToIgnoreIntermediateType 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 *attributedToIgnoreIntermediateType) 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 *attributedToIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// audienceIgnoreIntermediateType will only have one of its values set at most
|
|
type audienceIgnoreIntermediateType 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 *audienceIgnoreIntermediateType) 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 *audienceIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// contentIgnoreIntermediateType will only have one of its values set at most
|
|
type contentIgnoreIntermediateType 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 *contentIgnoreIntermediateType) 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 *contentIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// contextIgnoreIntermediateType will only have one of its values set at most
|
|
type contextIgnoreIntermediateType 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 *contextIgnoreIntermediateType) 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 *contextIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// nameIgnoreIntermediateType will only have one of its values set at most
|
|
type nameIgnoreIntermediateType 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 *nameIgnoreIntermediateType) 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 *nameIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// endTimeIgnoreIntermediateType will only have one of its values set at most
|
|
type endTimeIgnoreIntermediateType 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 *endTimeIgnoreIntermediateType) 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 *endTimeIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// generatorIgnoreIntermediateType will only have one of its values set at most
|
|
type generatorIgnoreIntermediateType 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 *generatorIgnoreIntermediateType) 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 *generatorIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// iconIgnoreIntermediateType will only have one of its values set at most
|
|
type iconIgnoreIntermediateType 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 *iconIgnoreIntermediateType) 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 *iconIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// imageIgnoreIntermediateType will only have one of its values set at most
|
|
type imageIgnoreIntermediateType 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 *imageIgnoreIntermediateType) 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 *imageIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// inReplyToIgnoreIntermediateType will only have one of its values set at most
|
|
type inReplyToIgnoreIntermediateType 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 *inReplyToIgnoreIntermediateType) 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 *inReplyToIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// locationIgnoreIntermediateType will only have one of its values set at most
|
|
type locationIgnoreIntermediateType 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 *locationIgnoreIntermediateType) 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 *locationIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// previewIgnoreIntermediateType will only have one of its values set at most
|
|
type previewIgnoreIntermediateType 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 *previewIgnoreIntermediateType) 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 *previewIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// publishedIgnoreIntermediateType will only have one of its values set at most
|
|
type publishedIgnoreIntermediateType 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 *publishedIgnoreIntermediateType) 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 *publishedIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// repliesIgnoreIntermediateType will only have one of its values set at most
|
|
type repliesIgnoreIntermediateType 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 *repliesIgnoreIntermediateType) 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 *repliesIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// startTimeIgnoreIntermediateType will only have one of its values set at most
|
|
type startTimeIgnoreIntermediateType 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 *startTimeIgnoreIntermediateType) 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 *startTimeIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// summaryIgnoreIntermediateType will only have one of its values set at most
|
|
type summaryIgnoreIntermediateType 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 *summaryIgnoreIntermediateType) 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 *summaryIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// tagIgnoreIntermediateType will only have one of its values set at most
|
|
type tagIgnoreIntermediateType 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 *tagIgnoreIntermediateType) 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 *tagIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// updatedIgnoreIntermediateType will only have one of its values set at most
|
|
type updatedIgnoreIntermediateType 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 *updatedIgnoreIntermediateType) 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 *updatedIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// urlIgnoreIntermediateType will only have one of its values set at most
|
|
type urlIgnoreIntermediateType 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 *urlIgnoreIntermediateType) 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 *urlIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// toIgnoreIntermediateType will only have one of its values set at most
|
|
type toIgnoreIntermediateType 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 *toIgnoreIntermediateType) 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 *toIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// btoIgnoreIntermediateType will only have one of its values set at most
|
|
type btoIgnoreIntermediateType 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 *btoIgnoreIntermediateType) 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 *btoIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// ccIgnoreIntermediateType will only have one of its values set at most
|
|
type ccIgnoreIntermediateType 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 *ccIgnoreIntermediateType) 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 *ccIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// bccIgnoreIntermediateType will only have one of its values set at most
|
|
type bccIgnoreIntermediateType 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 *bccIgnoreIntermediateType) 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 *bccIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// mediaTypeIgnoreIntermediateType will only have one of its values set at most
|
|
type mediaTypeIgnoreIntermediateType 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 *mediaTypeIgnoreIntermediateType) 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 *mediaTypeIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// durationIgnoreIntermediateType will only have one of its values set at most
|
|
type durationIgnoreIntermediateType 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 *durationIgnoreIntermediateType) 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 *durationIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// sourceIgnoreIntermediateType will only have one of its values set at most
|
|
type sourceIgnoreIntermediateType 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 *sourceIgnoreIntermediateType) 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 *sourceIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// inboxIgnoreIntermediateType will only have one of its values set at most
|
|
type inboxIgnoreIntermediateType 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 *inboxIgnoreIntermediateType) 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 *inboxIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// outboxIgnoreIntermediateType will only have one of its values set at most
|
|
type outboxIgnoreIntermediateType 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 *outboxIgnoreIntermediateType) 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 *outboxIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// followingIgnoreIntermediateType will only have one of its values set at most
|
|
type followingIgnoreIntermediateType 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 *followingIgnoreIntermediateType) 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 *followingIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// followersIgnoreIntermediateType will only have one of its values set at most
|
|
type followersIgnoreIntermediateType 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 *followersIgnoreIntermediateType) 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 *followersIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// likedIgnoreIntermediateType will only have one of its values set at most
|
|
type likedIgnoreIntermediateType 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 *likedIgnoreIntermediateType) 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 *likedIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// likesIgnoreIntermediateType will only have one of its values set at most
|
|
type likesIgnoreIntermediateType 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 *likesIgnoreIntermediateType) 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 *likesIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// preferredUsernameIgnoreIntermediateType will only have one of its values set at most
|
|
type preferredUsernameIgnoreIntermediateType 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 *preferredUsernameIgnoreIntermediateType) 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 *preferredUsernameIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// endpointsIgnoreIntermediateType will only have one of its values set at most
|
|
type endpointsIgnoreIntermediateType 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 *endpointsIgnoreIntermediateType) 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 *endpointsIgnoreIntermediateType) 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
|
|
}
|
|
|
|
// deserializeactorIgnoreIntermediateType will accept a map to create a actorIgnoreIntermediateType
|
|
func deserializeActorIgnoreIntermediateType(in interface{}) (t *actorIgnoreIntermediateType, err error) {
|
|
tmp := &actorIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice actorIgnoreIntermediateType will accept a slice to create a slice of actorIgnoreIntermediateType
|
|
func deserializeSliceActorIgnoreIntermediateType(in []interface{}) (t []*actorIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &actorIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeactorIgnoreIntermediateType will accept a actorIgnoreIntermediateType to create a map
|
|
func serializeActorIgnoreIntermediateType(t *actorIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceactorIgnoreIntermediateType will accept a slice of actorIgnoreIntermediateType to create a slice result
|
|
func serializeSliceActorIgnoreIntermediateType(s []*actorIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeobjectIgnoreIntermediateType will accept a map to create a objectIgnoreIntermediateType
|
|
func deserializeObjectIgnoreIntermediateType(in interface{}) (t *objectIgnoreIntermediateType, err error) {
|
|
tmp := &objectIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice objectIgnoreIntermediateType will accept a slice to create a slice of objectIgnoreIntermediateType
|
|
func deserializeSliceObjectIgnoreIntermediateType(in []interface{}) (t []*objectIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &objectIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeobjectIgnoreIntermediateType will accept a objectIgnoreIntermediateType to create a map
|
|
func serializeObjectIgnoreIntermediateType(t *objectIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceobjectIgnoreIntermediateType will accept a slice of objectIgnoreIntermediateType to create a slice result
|
|
func serializeSliceObjectIgnoreIntermediateType(s []*objectIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetargetIgnoreIntermediateType will accept a map to create a targetIgnoreIntermediateType
|
|
func deserializeTargetIgnoreIntermediateType(in interface{}) (t *targetIgnoreIntermediateType, err error) {
|
|
tmp := &targetIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice targetIgnoreIntermediateType will accept a slice to create a slice of targetIgnoreIntermediateType
|
|
func deserializeSliceTargetIgnoreIntermediateType(in []interface{}) (t []*targetIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &targetIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetargetIgnoreIntermediateType will accept a targetIgnoreIntermediateType to create a map
|
|
func serializeTargetIgnoreIntermediateType(t *targetIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetargetIgnoreIntermediateType will accept a slice of targetIgnoreIntermediateType to create a slice result
|
|
func serializeSliceTargetIgnoreIntermediateType(s []*targetIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeresultIgnoreIntermediateType will accept a map to create a resultIgnoreIntermediateType
|
|
func deserializeResultIgnoreIntermediateType(in interface{}) (t *resultIgnoreIntermediateType, err error) {
|
|
tmp := &resultIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice resultIgnoreIntermediateType will accept a slice to create a slice of resultIgnoreIntermediateType
|
|
func deserializeSliceResultIgnoreIntermediateType(in []interface{}) (t []*resultIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &resultIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeresultIgnoreIntermediateType will accept a resultIgnoreIntermediateType to create a map
|
|
func serializeResultIgnoreIntermediateType(t *resultIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceresultIgnoreIntermediateType will accept a slice of resultIgnoreIntermediateType to create a slice result
|
|
func serializeSliceResultIgnoreIntermediateType(s []*resultIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoriginIgnoreIntermediateType will accept a map to create a originIgnoreIntermediateType
|
|
func deserializeOriginIgnoreIntermediateType(in interface{}) (t *originIgnoreIntermediateType, err error) {
|
|
tmp := &originIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice originIgnoreIntermediateType will accept a slice to create a slice of originIgnoreIntermediateType
|
|
func deserializeSliceOriginIgnoreIntermediateType(in []interface{}) (t []*originIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &originIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoriginIgnoreIntermediateType will accept a originIgnoreIntermediateType to create a map
|
|
func serializeOriginIgnoreIntermediateType(t *originIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoriginIgnoreIntermediateType will accept a slice of originIgnoreIntermediateType to create a slice result
|
|
func serializeSliceOriginIgnoreIntermediateType(s []*originIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinstrumentIgnoreIntermediateType will accept a map to create a instrumentIgnoreIntermediateType
|
|
func deserializeInstrumentIgnoreIntermediateType(in interface{}) (t *instrumentIgnoreIntermediateType, err error) {
|
|
tmp := &instrumentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice instrumentIgnoreIntermediateType will accept a slice to create a slice of instrumentIgnoreIntermediateType
|
|
func deserializeSliceInstrumentIgnoreIntermediateType(in []interface{}) (t []*instrumentIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &instrumentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinstrumentIgnoreIntermediateType will accept a instrumentIgnoreIntermediateType to create a map
|
|
func serializeInstrumentIgnoreIntermediateType(t *instrumentIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinstrumentIgnoreIntermediateType will accept a slice of instrumentIgnoreIntermediateType to create a slice result
|
|
func serializeSliceInstrumentIgnoreIntermediateType(s []*instrumentIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializealtitudeIgnoreIntermediateType will accept a map to create a altitudeIgnoreIntermediateType
|
|
func deserializeAltitudeIgnoreIntermediateType(in interface{}) (t *altitudeIgnoreIntermediateType, err error) {
|
|
tmp := &altitudeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice altitudeIgnoreIntermediateType will accept a slice to create a slice of altitudeIgnoreIntermediateType
|
|
func deserializeSliceAltitudeIgnoreIntermediateType(in []interface{}) (t []*altitudeIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &altitudeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializealtitudeIgnoreIntermediateType will accept a altitudeIgnoreIntermediateType to create a map
|
|
func serializeAltitudeIgnoreIntermediateType(t *altitudeIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicealtitudeIgnoreIntermediateType will accept a slice of altitudeIgnoreIntermediateType to create a slice result
|
|
func serializeSliceAltitudeIgnoreIntermediateType(s []*altitudeIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattachmentIgnoreIntermediateType will accept a map to create a attachmentIgnoreIntermediateType
|
|
func deserializeAttachmentIgnoreIntermediateType(in interface{}) (t *attachmentIgnoreIntermediateType, err error) {
|
|
tmp := &attachmentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attachmentIgnoreIntermediateType will accept a slice to create a slice of attachmentIgnoreIntermediateType
|
|
func deserializeSliceAttachmentIgnoreIntermediateType(in []interface{}) (t []*attachmentIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attachmentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattachmentIgnoreIntermediateType will accept a attachmentIgnoreIntermediateType to create a map
|
|
func serializeAttachmentIgnoreIntermediateType(t *attachmentIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattachmentIgnoreIntermediateType will accept a slice of attachmentIgnoreIntermediateType to create a slice result
|
|
func serializeSliceAttachmentIgnoreIntermediateType(s []*attachmentIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeattributedToIgnoreIntermediateType will accept a map to create a attributedToIgnoreIntermediateType
|
|
func deserializeAttributedToIgnoreIntermediateType(in interface{}) (t *attributedToIgnoreIntermediateType, err error) {
|
|
tmp := &attributedToIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice attributedToIgnoreIntermediateType will accept a slice to create a slice of attributedToIgnoreIntermediateType
|
|
func deserializeSliceAttributedToIgnoreIntermediateType(in []interface{}) (t []*attributedToIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &attributedToIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeattributedToIgnoreIntermediateType will accept a attributedToIgnoreIntermediateType to create a map
|
|
func serializeAttributedToIgnoreIntermediateType(t *attributedToIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceattributedToIgnoreIntermediateType will accept a slice of attributedToIgnoreIntermediateType to create a slice result
|
|
func serializeSliceAttributedToIgnoreIntermediateType(s []*attributedToIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeaudienceIgnoreIntermediateType will accept a map to create a audienceIgnoreIntermediateType
|
|
func deserializeAudienceIgnoreIntermediateType(in interface{}) (t *audienceIgnoreIntermediateType, err error) {
|
|
tmp := &audienceIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice audienceIgnoreIntermediateType will accept a slice to create a slice of audienceIgnoreIntermediateType
|
|
func deserializeSliceAudienceIgnoreIntermediateType(in []interface{}) (t []*audienceIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &audienceIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeaudienceIgnoreIntermediateType will accept a audienceIgnoreIntermediateType to create a map
|
|
func serializeAudienceIgnoreIntermediateType(t *audienceIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceaudienceIgnoreIntermediateType will accept a slice of audienceIgnoreIntermediateType to create a slice result
|
|
func serializeSliceAudienceIgnoreIntermediateType(s []*audienceIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontentIgnoreIntermediateType will accept a map to create a contentIgnoreIntermediateType
|
|
func deserializeContentIgnoreIntermediateType(in interface{}) (t *contentIgnoreIntermediateType, err error) {
|
|
tmp := &contentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contentIgnoreIntermediateType will accept a slice to create a slice of contentIgnoreIntermediateType
|
|
func deserializeSliceContentIgnoreIntermediateType(in []interface{}) (t []*contentIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contentIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontentIgnoreIntermediateType will accept a contentIgnoreIntermediateType to create a map
|
|
func serializeContentIgnoreIntermediateType(t *contentIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontentIgnoreIntermediateType will accept a slice of contentIgnoreIntermediateType to create a slice result
|
|
func serializeSliceContentIgnoreIntermediateType(s []*contentIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializecontextIgnoreIntermediateType will accept a map to create a contextIgnoreIntermediateType
|
|
func deserializeContextIgnoreIntermediateType(in interface{}) (t *contextIgnoreIntermediateType, err error) {
|
|
tmp := &contextIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice contextIgnoreIntermediateType will accept a slice to create a slice of contextIgnoreIntermediateType
|
|
func deserializeSliceContextIgnoreIntermediateType(in []interface{}) (t []*contextIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &contextIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializecontextIgnoreIntermediateType will accept a contextIgnoreIntermediateType to create a map
|
|
func serializeContextIgnoreIntermediateType(t *contextIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicecontextIgnoreIntermediateType will accept a slice of contextIgnoreIntermediateType to create a slice result
|
|
func serializeSliceContextIgnoreIntermediateType(s []*contextIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializenameIgnoreIntermediateType will accept a map to create a nameIgnoreIntermediateType
|
|
func deserializeNameIgnoreIntermediateType(in interface{}) (t *nameIgnoreIntermediateType, err error) {
|
|
tmp := &nameIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice nameIgnoreIntermediateType will accept a slice to create a slice of nameIgnoreIntermediateType
|
|
func deserializeSliceNameIgnoreIntermediateType(in []interface{}) (t []*nameIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &nameIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializenameIgnoreIntermediateType will accept a nameIgnoreIntermediateType to create a map
|
|
func serializeNameIgnoreIntermediateType(t *nameIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicenameIgnoreIntermediateType will accept a slice of nameIgnoreIntermediateType to create a slice result
|
|
func serializeSliceNameIgnoreIntermediateType(s []*nameIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendTimeIgnoreIntermediateType will accept a map to create a endTimeIgnoreIntermediateType
|
|
func deserializeEndTimeIgnoreIntermediateType(in interface{}) (t *endTimeIgnoreIntermediateType, err error) {
|
|
tmp := &endTimeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endTimeIgnoreIntermediateType will accept a slice to create a slice of endTimeIgnoreIntermediateType
|
|
func deserializeSliceEndTimeIgnoreIntermediateType(in []interface{}) (t []*endTimeIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endTimeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendTimeIgnoreIntermediateType will accept a endTimeIgnoreIntermediateType to create a map
|
|
func serializeEndTimeIgnoreIntermediateType(t *endTimeIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendTimeIgnoreIntermediateType will accept a slice of endTimeIgnoreIntermediateType to create a slice result
|
|
func serializeSliceEndTimeIgnoreIntermediateType(s []*endTimeIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializegeneratorIgnoreIntermediateType will accept a map to create a generatorIgnoreIntermediateType
|
|
func deserializeGeneratorIgnoreIntermediateType(in interface{}) (t *generatorIgnoreIntermediateType, err error) {
|
|
tmp := &generatorIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice generatorIgnoreIntermediateType will accept a slice to create a slice of generatorIgnoreIntermediateType
|
|
func deserializeSliceGeneratorIgnoreIntermediateType(in []interface{}) (t []*generatorIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &generatorIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializegeneratorIgnoreIntermediateType will accept a generatorIgnoreIntermediateType to create a map
|
|
func serializeGeneratorIgnoreIntermediateType(t *generatorIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicegeneratorIgnoreIntermediateType will accept a slice of generatorIgnoreIntermediateType to create a slice result
|
|
func serializeSliceGeneratorIgnoreIntermediateType(s []*generatorIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeiconIgnoreIntermediateType will accept a map to create a iconIgnoreIntermediateType
|
|
func deserializeIconIgnoreIntermediateType(in interface{}) (t *iconIgnoreIntermediateType, err error) {
|
|
tmp := &iconIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice iconIgnoreIntermediateType will accept a slice to create a slice of iconIgnoreIntermediateType
|
|
func deserializeSliceIconIgnoreIntermediateType(in []interface{}) (t []*iconIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &iconIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeiconIgnoreIntermediateType will accept a iconIgnoreIntermediateType to create a map
|
|
func serializeIconIgnoreIntermediateType(t *iconIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceiconIgnoreIntermediateType will accept a slice of iconIgnoreIntermediateType to create a slice result
|
|
func serializeSliceIconIgnoreIntermediateType(s []*iconIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeimageIgnoreIntermediateType will accept a map to create a imageIgnoreIntermediateType
|
|
func deserializeImageIgnoreIntermediateType(in interface{}) (t *imageIgnoreIntermediateType, err error) {
|
|
tmp := &imageIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice imageIgnoreIntermediateType will accept a slice to create a slice of imageIgnoreIntermediateType
|
|
func deserializeSliceImageIgnoreIntermediateType(in []interface{}) (t []*imageIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &imageIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeimageIgnoreIntermediateType will accept a imageIgnoreIntermediateType to create a map
|
|
func serializeImageIgnoreIntermediateType(t *imageIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceimageIgnoreIntermediateType will accept a slice of imageIgnoreIntermediateType to create a slice result
|
|
func serializeSliceImageIgnoreIntermediateType(s []*imageIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinReplyToIgnoreIntermediateType will accept a map to create a inReplyToIgnoreIntermediateType
|
|
func deserializeInReplyToIgnoreIntermediateType(in interface{}) (t *inReplyToIgnoreIntermediateType, err error) {
|
|
tmp := &inReplyToIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inReplyToIgnoreIntermediateType will accept a slice to create a slice of inReplyToIgnoreIntermediateType
|
|
func deserializeSliceInReplyToIgnoreIntermediateType(in []interface{}) (t []*inReplyToIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inReplyToIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinReplyToIgnoreIntermediateType will accept a inReplyToIgnoreIntermediateType to create a map
|
|
func serializeInReplyToIgnoreIntermediateType(t *inReplyToIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinReplyToIgnoreIntermediateType will accept a slice of inReplyToIgnoreIntermediateType to create a slice result
|
|
func serializeSliceInReplyToIgnoreIntermediateType(s []*inReplyToIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelocationIgnoreIntermediateType will accept a map to create a locationIgnoreIntermediateType
|
|
func deserializeLocationIgnoreIntermediateType(in interface{}) (t *locationIgnoreIntermediateType, err error) {
|
|
tmp := &locationIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice locationIgnoreIntermediateType will accept a slice to create a slice of locationIgnoreIntermediateType
|
|
func deserializeSliceLocationIgnoreIntermediateType(in []interface{}) (t []*locationIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &locationIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelocationIgnoreIntermediateType will accept a locationIgnoreIntermediateType to create a map
|
|
func serializeLocationIgnoreIntermediateType(t *locationIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelocationIgnoreIntermediateType will accept a slice of locationIgnoreIntermediateType to create a slice result
|
|
func serializeSliceLocationIgnoreIntermediateType(s []*locationIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreviewIgnoreIntermediateType will accept a map to create a previewIgnoreIntermediateType
|
|
func deserializePreviewIgnoreIntermediateType(in interface{}) (t *previewIgnoreIntermediateType, err error) {
|
|
tmp := &previewIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice previewIgnoreIntermediateType will accept a slice to create a slice of previewIgnoreIntermediateType
|
|
func deserializeSlicePreviewIgnoreIntermediateType(in []interface{}) (t []*previewIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &previewIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreviewIgnoreIntermediateType will accept a previewIgnoreIntermediateType to create a map
|
|
func serializePreviewIgnoreIntermediateType(t *previewIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreviewIgnoreIntermediateType will accept a slice of previewIgnoreIntermediateType to create a slice result
|
|
func serializeSlicePreviewIgnoreIntermediateType(s []*previewIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepublishedIgnoreIntermediateType will accept a map to create a publishedIgnoreIntermediateType
|
|
func deserializePublishedIgnoreIntermediateType(in interface{}) (t *publishedIgnoreIntermediateType, err error) {
|
|
tmp := &publishedIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice publishedIgnoreIntermediateType will accept a slice to create a slice of publishedIgnoreIntermediateType
|
|
func deserializeSlicePublishedIgnoreIntermediateType(in []interface{}) (t []*publishedIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &publishedIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepublishedIgnoreIntermediateType will accept a publishedIgnoreIntermediateType to create a map
|
|
func serializePublishedIgnoreIntermediateType(t *publishedIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepublishedIgnoreIntermediateType will accept a slice of publishedIgnoreIntermediateType to create a slice result
|
|
func serializeSlicePublishedIgnoreIntermediateType(s []*publishedIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializerepliesIgnoreIntermediateType will accept a map to create a repliesIgnoreIntermediateType
|
|
func deserializeRepliesIgnoreIntermediateType(in interface{}) (t *repliesIgnoreIntermediateType, err error) {
|
|
tmp := &repliesIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice repliesIgnoreIntermediateType will accept a slice to create a slice of repliesIgnoreIntermediateType
|
|
func deserializeSliceRepliesIgnoreIntermediateType(in []interface{}) (t []*repliesIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &repliesIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializerepliesIgnoreIntermediateType will accept a repliesIgnoreIntermediateType to create a map
|
|
func serializeRepliesIgnoreIntermediateType(t *repliesIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicerepliesIgnoreIntermediateType will accept a slice of repliesIgnoreIntermediateType to create a slice result
|
|
func serializeSliceRepliesIgnoreIntermediateType(s []*repliesIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializestartTimeIgnoreIntermediateType will accept a map to create a startTimeIgnoreIntermediateType
|
|
func deserializeStartTimeIgnoreIntermediateType(in interface{}) (t *startTimeIgnoreIntermediateType, err error) {
|
|
tmp := &startTimeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice startTimeIgnoreIntermediateType will accept a slice to create a slice of startTimeIgnoreIntermediateType
|
|
func deserializeSliceStartTimeIgnoreIntermediateType(in []interface{}) (t []*startTimeIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &startTimeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializestartTimeIgnoreIntermediateType will accept a startTimeIgnoreIntermediateType to create a map
|
|
func serializeStartTimeIgnoreIntermediateType(t *startTimeIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicestartTimeIgnoreIntermediateType will accept a slice of startTimeIgnoreIntermediateType to create a slice result
|
|
func serializeSliceStartTimeIgnoreIntermediateType(s []*startTimeIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesummaryIgnoreIntermediateType will accept a map to create a summaryIgnoreIntermediateType
|
|
func deserializeSummaryIgnoreIntermediateType(in interface{}) (t *summaryIgnoreIntermediateType, err error) {
|
|
tmp := &summaryIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice summaryIgnoreIntermediateType will accept a slice to create a slice of summaryIgnoreIntermediateType
|
|
func deserializeSliceSummaryIgnoreIntermediateType(in []interface{}) (t []*summaryIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &summaryIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesummaryIgnoreIntermediateType will accept a summaryIgnoreIntermediateType to create a map
|
|
func serializeSummaryIgnoreIntermediateType(t *summaryIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesummaryIgnoreIntermediateType will accept a slice of summaryIgnoreIntermediateType to create a slice result
|
|
func serializeSliceSummaryIgnoreIntermediateType(s []*summaryIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetagIgnoreIntermediateType will accept a map to create a tagIgnoreIntermediateType
|
|
func deserializeTagIgnoreIntermediateType(in interface{}) (t *tagIgnoreIntermediateType, err error) {
|
|
tmp := &tagIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice tagIgnoreIntermediateType will accept a slice to create a slice of tagIgnoreIntermediateType
|
|
func deserializeSliceTagIgnoreIntermediateType(in []interface{}) (t []*tagIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &tagIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetagIgnoreIntermediateType will accept a tagIgnoreIntermediateType to create a map
|
|
func serializeTagIgnoreIntermediateType(t *tagIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetagIgnoreIntermediateType will accept a slice of tagIgnoreIntermediateType to create a slice result
|
|
func serializeSliceTagIgnoreIntermediateType(s []*tagIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeupdatedIgnoreIntermediateType will accept a map to create a updatedIgnoreIntermediateType
|
|
func deserializeUpdatedIgnoreIntermediateType(in interface{}) (t *updatedIgnoreIntermediateType, err error) {
|
|
tmp := &updatedIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice updatedIgnoreIntermediateType will accept a slice to create a slice of updatedIgnoreIntermediateType
|
|
func deserializeSliceUpdatedIgnoreIntermediateType(in []interface{}) (t []*updatedIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &updatedIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeupdatedIgnoreIntermediateType will accept a updatedIgnoreIntermediateType to create a map
|
|
func serializeUpdatedIgnoreIntermediateType(t *updatedIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceupdatedIgnoreIntermediateType will accept a slice of updatedIgnoreIntermediateType to create a slice result
|
|
func serializeSliceUpdatedIgnoreIntermediateType(s []*updatedIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeurlIgnoreIntermediateType will accept a map to create a urlIgnoreIntermediateType
|
|
func deserializeUrlIgnoreIntermediateType(in interface{}) (t *urlIgnoreIntermediateType, err error) {
|
|
tmp := &urlIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice urlIgnoreIntermediateType will accept a slice to create a slice of urlIgnoreIntermediateType
|
|
func deserializeSliceUrlIgnoreIntermediateType(in []interface{}) (t []*urlIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &urlIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeurlIgnoreIntermediateType will accept a urlIgnoreIntermediateType to create a map
|
|
func serializeUrlIgnoreIntermediateType(t *urlIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceurlIgnoreIntermediateType will accept a slice of urlIgnoreIntermediateType to create a slice result
|
|
func serializeSliceUrlIgnoreIntermediateType(s []*urlIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializetoIgnoreIntermediateType will accept a map to create a toIgnoreIntermediateType
|
|
func deserializeToIgnoreIntermediateType(in interface{}) (t *toIgnoreIntermediateType, err error) {
|
|
tmp := &toIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice toIgnoreIntermediateType will accept a slice to create a slice of toIgnoreIntermediateType
|
|
func deserializeSliceToIgnoreIntermediateType(in []interface{}) (t []*toIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &toIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializetoIgnoreIntermediateType will accept a toIgnoreIntermediateType to create a map
|
|
func serializeToIgnoreIntermediateType(t *toIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicetoIgnoreIntermediateType will accept a slice of toIgnoreIntermediateType to create a slice result
|
|
func serializeSliceToIgnoreIntermediateType(s []*toIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebtoIgnoreIntermediateType will accept a map to create a btoIgnoreIntermediateType
|
|
func deserializeBtoIgnoreIntermediateType(in interface{}) (t *btoIgnoreIntermediateType, err error) {
|
|
tmp := &btoIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice btoIgnoreIntermediateType will accept a slice to create a slice of btoIgnoreIntermediateType
|
|
func deserializeSliceBtoIgnoreIntermediateType(in []interface{}) (t []*btoIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &btoIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebtoIgnoreIntermediateType will accept a btoIgnoreIntermediateType to create a map
|
|
func serializeBtoIgnoreIntermediateType(t *btoIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebtoIgnoreIntermediateType will accept a slice of btoIgnoreIntermediateType to create a slice result
|
|
func serializeSliceBtoIgnoreIntermediateType(s []*btoIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeccIgnoreIntermediateType will accept a map to create a ccIgnoreIntermediateType
|
|
func deserializeCcIgnoreIntermediateType(in interface{}) (t *ccIgnoreIntermediateType, err error) {
|
|
tmp := &ccIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice ccIgnoreIntermediateType will accept a slice to create a slice of ccIgnoreIntermediateType
|
|
func deserializeSliceCcIgnoreIntermediateType(in []interface{}) (t []*ccIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &ccIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeccIgnoreIntermediateType will accept a ccIgnoreIntermediateType to create a map
|
|
func serializeCcIgnoreIntermediateType(t *ccIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceccIgnoreIntermediateType will accept a slice of ccIgnoreIntermediateType to create a slice result
|
|
func serializeSliceCcIgnoreIntermediateType(s []*ccIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializebccIgnoreIntermediateType will accept a map to create a bccIgnoreIntermediateType
|
|
func deserializeBccIgnoreIntermediateType(in interface{}) (t *bccIgnoreIntermediateType, err error) {
|
|
tmp := &bccIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice bccIgnoreIntermediateType will accept a slice to create a slice of bccIgnoreIntermediateType
|
|
func deserializeSliceBccIgnoreIntermediateType(in []interface{}) (t []*bccIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &bccIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializebccIgnoreIntermediateType will accept a bccIgnoreIntermediateType to create a map
|
|
func serializeBccIgnoreIntermediateType(t *bccIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicebccIgnoreIntermediateType will accept a slice of bccIgnoreIntermediateType to create a slice result
|
|
func serializeSliceBccIgnoreIntermediateType(s []*bccIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializemediaTypeIgnoreIntermediateType will accept a map to create a mediaTypeIgnoreIntermediateType
|
|
func deserializeMediaTypeIgnoreIntermediateType(in interface{}) (t *mediaTypeIgnoreIntermediateType, err error) {
|
|
tmp := &mediaTypeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice mediaTypeIgnoreIntermediateType will accept a slice to create a slice of mediaTypeIgnoreIntermediateType
|
|
func deserializeSliceMediaTypeIgnoreIntermediateType(in []interface{}) (t []*mediaTypeIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &mediaTypeIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializemediaTypeIgnoreIntermediateType will accept a mediaTypeIgnoreIntermediateType to create a map
|
|
func serializeMediaTypeIgnoreIntermediateType(t *mediaTypeIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicemediaTypeIgnoreIntermediateType will accept a slice of mediaTypeIgnoreIntermediateType to create a slice result
|
|
func serializeSliceMediaTypeIgnoreIntermediateType(s []*mediaTypeIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializedurationIgnoreIntermediateType will accept a map to create a durationIgnoreIntermediateType
|
|
func deserializeDurationIgnoreIntermediateType(in interface{}) (t *durationIgnoreIntermediateType, err error) {
|
|
tmp := &durationIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice durationIgnoreIntermediateType will accept a slice to create a slice of durationIgnoreIntermediateType
|
|
func deserializeSliceDurationIgnoreIntermediateType(in []interface{}) (t []*durationIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &durationIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializedurationIgnoreIntermediateType will accept a durationIgnoreIntermediateType to create a map
|
|
func serializeDurationIgnoreIntermediateType(t *durationIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicedurationIgnoreIntermediateType will accept a slice of durationIgnoreIntermediateType to create a slice result
|
|
func serializeSliceDurationIgnoreIntermediateType(s []*durationIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializesourceIgnoreIntermediateType will accept a map to create a sourceIgnoreIntermediateType
|
|
func deserializeSourceIgnoreIntermediateType(in interface{}) (t *sourceIgnoreIntermediateType, err error) {
|
|
tmp := &sourceIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice sourceIgnoreIntermediateType will accept a slice to create a slice of sourceIgnoreIntermediateType
|
|
func deserializeSliceSourceIgnoreIntermediateType(in []interface{}) (t []*sourceIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &sourceIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializesourceIgnoreIntermediateType will accept a sourceIgnoreIntermediateType to create a map
|
|
func serializeSourceIgnoreIntermediateType(t *sourceIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicesourceIgnoreIntermediateType will accept a slice of sourceIgnoreIntermediateType to create a slice result
|
|
func serializeSliceSourceIgnoreIntermediateType(s []*sourceIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeinboxIgnoreIntermediateType will accept a map to create a inboxIgnoreIntermediateType
|
|
func deserializeInboxIgnoreIntermediateType(in interface{}) (t *inboxIgnoreIntermediateType, err error) {
|
|
tmp := &inboxIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice inboxIgnoreIntermediateType will accept a slice to create a slice of inboxIgnoreIntermediateType
|
|
func deserializeSliceInboxIgnoreIntermediateType(in []interface{}) (t []*inboxIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &inboxIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeinboxIgnoreIntermediateType will accept a inboxIgnoreIntermediateType to create a map
|
|
func serializeInboxIgnoreIntermediateType(t *inboxIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceinboxIgnoreIntermediateType will accept a slice of inboxIgnoreIntermediateType to create a slice result
|
|
func serializeSliceInboxIgnoreIntermediateType(s []*inboxIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeoutboxIgnoreIntermediateType will accept a map to create a outboxIgnoreIntermediateType
|
|
func deserializeOutboxIgnoreIntermediateType(in interface{}) (t *outboxIgnoreIntermediateType, err error) {
|
|
tmp := &outboxIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice outboxIgnoreIntermediateType will accept a slice to create a slice of outboxIgnoreIntermediateType
|
|
func deserializeSliceOutboxIgnoreIntermediateType(in []interface{}) (t []*outboxIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &outboxIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeoutboxIgnoreIntermediateType will accept a outboxIgnoreIntermediateType to create a map
|
|
func serializeOutboxIgnoreIntermediateType(t *outboxIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceoutboxIgnoreIntermediateType will accept a slice of outboxIgnoreIntermediateType to create a slice result
|
|
func serializeSliceOutboxIgnoreIntermediateType(s []*outboxIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowingIgnoreIntermediateType will accept a map to create a followingIgnoreIntermediateType
|
|
func deserializeFollowingIgnoreIntermediateType(in interface{}) (t *followingIgnoreIntermediateType, err error) {
|
|
tmp := &followingIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followingIgnoreIntermediateType will accept a slice to create a slice of followingIgnoreIntermediateType
|
|
func deserializeSliceFollowingIgnoreIntermediateType(in []interface{}) (t []*followingIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followingIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowingIgnoreIntermediateType will accept a followingIgnoreIntermediateType to create a map
|
|
func serializeFollowingIgnoreIntermediateType(t *followingIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowingIgnoreIntermediateType will accept a slice of followingIgnoreIntermediateType to create a slice result
|
|
func serializeSliceFollowingIgnoreIntermediateType(s []*followingIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializefollowersIgnoreIntermediateType will accept a map to create a followersIgnoreIntermediateType
|
|
func deserializeFollowersIgnoreIntermediateType(in interface{}) (t *followersIgnoreIntermediateType, err error) {
|
|
tmp := &followersIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice followersIgnoreIntermediateType will accept a slice to create a slice of followersIgnoreIntermediateType
|
|
func deserializeSliceFollowersIgnoreIntermediateType(in []interface{}) (t []*followersIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &followersIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializefollowersIgnoreIntermediateType will accept a followersIgnoreIntermediateType to create a map
|
|
func serializeFollowersIgnoreIntermediateType(t *followersIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicefollowersIgnoreIntermediateType will accept a slice of followersIgnoreIntermediateType to create a slice result
|
|
func serializeSliceFollowersIgnoreIntermediateType(s []*followersIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikedIgnoreIntermediateType will accept a map to create a likedIgnoreIntermediateType
|
|
func deserializeLikedIgnoreIntermediateType(in interface{}) (t *likedIgnoreIntermediateType, err error) {
|
|
tmp := &likedIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likedIgnoreIntermediateType will accept a slice to create a slice of likedIgnoreIntermediateType
|
|
func deserializeSliceLikedIgnoreIntermediateType(in []interface{}) (t []*likedIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likedIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikedIgnoreIntermediateType will accept a likedIgnoreIntermediateType to create a map
|
|
func serializeLikedIgnoreIntermediateType(t *likedIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikedIgnoreIntermediateType will accept a slice of likedIgnoreIntermediateType to create a slice result
|
|
func serializeSliceLikedIgnoreIntermediateType(s []*likedIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializelikesIgnoreIntermediateType will accept a map to create a likesIgnoreIntermediateType
|
|
func deserializeLikesIgnoreIntermediateType(in interface{}) (t *likesIgnoreIntermediateType, err error) {
|
|
tmp := &likesIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice likesIgnoreIntermediateType will accept a slice to create a slice of likesIgnoreIntermediateType
|
|
func deserializeSliceLikesIgnoreIntermediateType(in []interface{}) (t []*likesIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &likesIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializelikesIgnoreIntermediateType will accept a likesIgnoreIntermediateType to create a map
|
|
func serializeLikesIgnoreIntermediateType(t *likesIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicelikesIgnoreIntermediateType will accept a slice of likesIgnoreIntermediateType to create a slice result
|
|
func serializeSliceLikesIgnoreIntermediateType(s []*likesIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializepreferredUsernameIgnoreIntermediateType will accept a map to create a preferredUsernameIgnoreIntermediateType
|
|
func deserializePreferredUsernameIgnoreIntermediateType(in interface{}) (t *preferredUsernameIgnoreIntermediateType, err error) {
|
|
tmp := &preferredUsernameIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice preferredUsernameIgnoreIntermediateType will accept a slice to create a slice of preferredUsernameIgnoreIntermediateType
|
|
func deserializeSlicePreferredUsernameIgnoreIntermediateType(in []interface{}) (t []*preferredUsernameIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &preferredUsernameIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializepreferredUsernameIgnoreIntermediateType will accept a preferredUsernameIgnoreIntermediateType to create a map
|
|
func serializePreferredUsernameIgnoreIntermediateType(t *preferredUsernameIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSlicepreferredUsernameIgnoreIntermediateType will accept a slice of preferredUsernameIgnoreIntermediateType to create a slice result
|
|
func serializeSlicePreferredUsernameIgnoreIntermediateType(s []*preferredUsernameIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// deserializeendpointsIgnoreIntermediateType will accept a map to create a endpointsIgnoreIntermediateType
|
|
func deserializeEndpointsIgnoreIntermediateType(in interface{}) (t *endpointsIgnoreIntermediateType, err error) {
|
|
tmp := &endpointsIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(in)
|
|
return tmp, err
|
|
|
|
}
|
|
|
|
// deserializeSlice endpointsIgnoreIntermediateType will accept a slice to create a slice of endpointsIgnoreIntermediateType
|
|
func deserializeSliceEndpointsIgnoreIntermediateType(in []interface{}) (t []*endpointsIgnoreIntermediateType, err error) {
|
|
for _, i := range in {
|
|
tmp := &endpointsIgnoreIntermediateType{}
|
|
err = tmp.Deserialize(i)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t = append(t, tmp)
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// serializeendpointsIgnoreIntermediateType will accept a endpointsIgnoreIntermediateType to create a map
|
|
func serializeEndpointsIgnoreIntermediateType(t *endpointsIgnoreIntermediateType) (i interface{}, err error) {
|
|
i, err = t.Serialize()
|
|
return
|
|
|
|
}
|
|
|
|
// serializeSliceendpointsIgnoreIntermediateType will accept a slice of endpointsIgnoreIntermediateType to create a slice result
|
|
func serializeSliceEndpointsIgnoreIntermediateType(s []*endpointsIgnoreIntermediateType) (out []interface{}, err error) {
|
|
for _, t := range s {
|
|
v, err := t.Serialize()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, v)
|
|
}
|
|
return
|
|
|
|
}
|