mirror of https://gitlab.com/ngerakines/tavern.git
10228 lines
220 KiB
Go
10228 lines
220 KiB
Go
// Code generated by go generate; DO NOT EDIT.
|
|
// This file was generated by herr at 2020-03-26 10:29:28.140563266 -0400 EDT m=+0.008827289
|
|
package errors
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"path"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
go_errors "errors"
|
|
)
|
|
|
|
type CodedError interface {
|
|
Code() int
|
|
Description() string
|
|
Prefix() string
|
|
error
|
|
}
|
|
|
|
|
|
type NotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type EncryptFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type DecryptFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type QueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type DatabaseTransactionFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InsertQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type SelectQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UpdateQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type DeleteQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidUserError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSessionQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSessionSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSessionInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSessionUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSessionUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSessionDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidUserSessionError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserSessionNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserFeedQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserFeedSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserFeedInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserFeedUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserFeedUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserFeedDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidUserFeedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserFeedNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserObjectEventQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserObjectEventSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserObjectEventInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserObjectEventUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserObjectEventUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserObjectEventDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidUserObjectEventError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type UserObjectEventNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidActorError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorAliasQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorAliasSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorAliasInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorAliasUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorAliasUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorAliasDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidActorAliasError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorAliasNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorKeyQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorKeySelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorKeyInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorKeyUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorKeyUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorKeyDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidActorKeyError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ActorKeyNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type NetworkRelationshipQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type NetworkRelationshipSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type NetworkRelationshipInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type NetworkRelationshipUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type NetworkRelationshipUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type NetworkRelationshipDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidNetworkRelationshipError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type NetworkRelationshipNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidObjectError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectEventQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectEventSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectEventInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectEventUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectEventUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectEventDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidObjectEventError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectEventNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectReplyQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectReplySelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectReplyInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectReplyUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectReplyUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectReplyDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidObjectReplyError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectReplyNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectTagQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectTagSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectTagInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectTagUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectTagUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectTagDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidObjectTagError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectTagNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectThreadQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectThreadSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectThreadInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectThreadUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectThreadUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectThreadDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidObjectThreadError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectThreadNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectBoostQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectBoostSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectBoostInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectBoostUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectBoostUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectBoostDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidObjectBoostError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ObjectBoostNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidImageError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageAliasQueryFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageAliasSelectFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageAliasInsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageAliasUpsertFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageAliasUpdateFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageAliasDeleteFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidImageAliasError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type ImageAliasNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidEmailVerificationError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type CannotSaveSessionError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidCaptchaError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type EmailSendFailedError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type AuthenticationRequiredError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type TranslatorNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type TranslationNotFoundError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
type InvalidUserIDError struct {
|
|
Err error
|
|
Stack *stack
|
|
}
|
|
|
|
var _ CodedError = NotFoundError{}
|
|
var _ CodedError = EncryptFailedError{}
|
|
var _ CodedError = DecryptFailedError{}
|
|
var _ CodedError = QueryFailedError{}
|
|
var _ CodedError = DatabaseTransactionFailedError{}
|
|
var _ CodedError = InsertQueryFailedError{}
|
|
var _ CodedError = SelectQueryFailedError{}
|
|
var _ CodedError = UpdateQueryFailedError{}
|
|
var _ CodedError = DeleteQueryFailedError{}
|
|
var _ CodedError = UserQueryFailedError{}
|
|
var _ CodedError = UserSelectFailedError{}
|
|
var _ CodedError = UserInsertFailedError{}
|
|
var _ CodedError = UserUpsertFailedError{}
|
|
var _ CodedError = UserUpdateFailedError{}
|
|
var _ CodedError = UserDeleteFailedError{}
|
|
var _ CodedError = InvalidUserError{}
|
|
var _ CodedError = UserNotFoundError{}
|
|
var _ CodedError = UserSessionQueryFailedError{}
|
|
var _ CodedError = UserSessionSelectFailedError{}
|
|
var _ CodedError = UserSessionInsertFailedError{}
|
|
var _ CodedError = UserSessionUpsertFailedError{}
|
|
var _ CodedError = UserSessionUpdateFailedError{}
|
|
var _ CodedError = UserSessionDeleteFailedError{}
|
|
var _ CodedError = InvalidUserSessionError{}
|
|
var _ CodedError = UserSessionNotFoundError{}
|
|
var _ CodedError = UserFeedQueryFailedError{}
|
|
var _ CodedError = UserFeedSelectFailedError{}
|
|
var _ CodedError = UserFeedInsertFailedError{}
|
|
var _ CodedError = UserFeedUpsertFailedError{}
|
|
var _ CodedError = UserFeedUpdateFailedError{}
|
|
var _ CodedError = UserFeedDeleteFailedError{}
|
|
var _ CodedError = InvalidUserFeedError{}
|
|
var _ CodedError = UserFeedNotFoundError{}
|
|
var _ CodedError = UserObjectEventQueryFailedError{}
|
|
var _ CodedError = UserObjectEventSelectFailedError{}
|
|
var _ CodedError = UserObjectEventInsertFailedError{}
|
|
var _ CodedError = UserObjectEventUpsertFailedError{}
|
|
var _ CodedError = UserObjectEventUpdateFailedError{}
|
|
var _ CodedError = UserObjectEventDeleteFailedError{}
|
|
var _ CodedError = InvalidUserObjectEventError{}
|
|
var _ CodedError = UserObjectEventNotFoundError{}
|
|
var _ CodedError = ActorQueryFailedError{}
|
|
var _ CodedError = ActorSelectFailedError{}
|
|
var _ CodedError = ActorInsertFailedError{}
|
|
var _ CodedError = ActorUpsertFailedError{}
|
|
var _ CodedError = ActorUpdateFailedError{}
|
|
var _ CodedError = ActorDeleteFailedError{}
|
|
var _ CodedError = InvalidActorError{}
|
|
var _ CodedError = ActorNotFoundError{}
|
|
var _ CodedError = ActorAliasQueryFailedError{}
|
|
var _ CodedError = ActorAliasSelectFailedError{}
|
|
var _ CodedError = ActorAliasInsertFailedError{}
|
|
var _ CodedError = ActorAliasUpsertFailedError{}
|
|
var _ CodedError = ActorAliasUpdateFailedError{}
|
|
var _ CodedError = ActorAliasDeleteFailedError{}
|
|
var _ CodedError = InvalidActorAliasError{}
|
|
var _ CodedError = ActorAliasNotFoundError{}
|
|
var _ CodedError = ActorKeyQueryFailedError{}
|
|
var _ CodedError = ActorKeySelectFailedError{}
|
|
var _ CodedError = ActorKeyInsertFailedError{}
|
|
var _ CodedError = ActorKeyUpsertFailedError{}
|
|
var _ CodedError = ActorKeyUpdateFailedError{}
|
|
var _ CodedError = ActorKeyDeleteFailedError{}
|
|
var _ CodedError = InvalidActorKeyError{}
|
|
var _ CodedError = ActorKeyNotFoundError{}
|
|
var _ CodedError = NetworkRelationshipQueryFailedError{}
|
|
var _ CodedError = NetworkRelationshipSelectFailedError{}
|
|
var _ CodedError = NetworkRelationshipInsertFailedError{}
|
|
var _ CodedError = NetworkRelationshipUpsertFailedError{}
|
|
var _ CodedError = NetworkRelationshipUpdateFailedError{}
|
|
var _ CodedError = NetworkRelationshipDeleteFailedError{}
|
|
var _ CodedError = InvalidNetworkRelationshipError{}
|
|
var _ CodedError = NetworkRelationshipNotFoundError{}
|
|
var _ CodedError = ObjectQueryFailedError{}
|
|
var _ CodedError = ObjectSelectFailedError{}
|
|
var _ CodedError = ObjectInsertFailedError{}
|
|
var _ CodedError = ObjectUpsertFailedError{}
|
|
var _ CodedError = ObjectUpdateFailedError{}
|
|
var _ CodedError = ObjectDeleteFailedError{}
|
|
var _ CodedError = InvalidObjectError{}
|
|
var _ CodedError = ObjectNotFoundError{}
|
|
var _ CodedError = ObjectEventQueryFailedError{}
|
|
var _ CodedError = ObjectEventSelectFailedError{}
|
|
var _ CodedError = ObjectEventInsertFailedError{}
|
|
var _ CodedError = ObjectEventUpsertFailedError{}
|
|
var _ CodedError = ObjectEventUpdateFailedError{}
|
|
var _ CodedError = ObjectEventDeleteFailedError{}
|
|
var _ CodedError = InvalidObjectEventError{}
|
|
var _ CodedError = ObjectEventNotFoundError{}
|
|
var _ CodedError = ObjectReplyQueryFailedError{}
|
|
var _ CodedError = ObjectReplySelectFailedError{}
|
|
var _ CodedError = ObjectReplyInsertFailedError{}
|
|
var _ CodedError = ObjectReplyUpsertFailedError{}
|
|
var _ CodedError = ObjectReplyUpdateFailedError{}
|
|
var _ CodedError = ObjectReplyDeleteFailedError{}
|
|
var _ CodedError = InvalidObjectReplyError{}
|
|
var _ CodedError = ObjectReplyNotFoundError{}
|
|
var _ CodedError = ObjectTagQueryFailedError{}
|
|
var _ CodedError = ObjectTagSelectFailedError{}
|
|
var _ CodedError = ObjectTagInsertFailedError{}
|
|
var _ CodedError = ObjectTagUpsertFailedError{}
|
|
var _ CodedError = ObjectTagUpdateFailedError{}
|
|
var _ CodedError = ObjectTagDeleteFailedError{}
|
|
var _ CodedError = InvalidObjectTagError{}
|
|
var _ CodedError = ObjectTagNotFoundError{}
|
|
var _ CodedError = ObjectThreadQueryFailedError{}
|
|
var _ CodedError = ObjectThreadSelectFailedError{}
|
|
var _ CodedError = ObjectThreadInsertFailedError{}
|
|
var _ CodedError = ObjectThreadUpsertFailedError{}
|
|
var _ CodedError = ObjectThreadUpdateFailedError{}
|
|
var _ CodedError = ObjectThreadDeleteFailedError{}
|
|
var _ CodedError = InvalidObjectThreadError{}
|
|
var _ CodedError = ObjectThreadNotFoundError{}
|
|
var _ CodedError = ObjectBoostQueryFailedError{}
|
|
var _ CodedError = ObjectBoostSelectFailedError{}
|
|
var _ CodedError = ObjectBoostInsertFailedError{}
|
|
var _ CodedError = ObjectBoostUpsertFailedError{}
|
|
var _ CodedError = ObjectBoostUpdateFailedError{}
|
|
var _ CodedError = ObjectBoostDeleteFailedError{}
|
|
var _ CodedError = InvalidObjectBoostError{}
|
|
var _ CodedError = ObjectBoostNotFoundError{}
|
|
var _ CodedError = ImageQueryFailedError{}
|
|
var _ CodedError = ImageSelectFailedError{}
|
|
var _ CodedError = ImageInsertFailedError{}
|
|
var _ CodedError = ImageUpsertFailedError{}
|
|
var _ CodedError = ImageUpdateFailedError{}
|
|
var _ CodedError = ImageDeleteFailedError{}
|
|
var _ CodedError = InvalidImageError{}
|
|
var _ CodedError = ImageNotFoundError{}
|
|
var _ CodedError = ImageAliasQueryFailedError{}
|
|
var _ CodedError = ImageAliasSelectFailedError{}
|
|
var _ CodedError = ImageAliasInsertFailedError{}
|
|
var _ CodedError = ImageAliasUpsertFailedError{}
|
|
var _ CodedError = ImageAliasUpdateFailedError{}
|
|
var _ CodedError = ImageAliasDeleteFailedError{}
|
|
var _ CodedError = InvalidImageAliasError{}
|
|
var _ CodedError = ImageAliasNotFoundError{}
|
|
var _ CodedError = InvalidEmailVerificationError{}
|
|
var _ CodedError = CannotSaveSessionError{}
|
|
var _ CodedError = InvalidCaptchaError{}
|
|
var _ CodedError = EmailSendFailedError{}
|
|
var _ CodedError = AuthenticationRequiredError{}
|
|
var _ CodedError = TranslatorNotFoundError{}
|
|
var _ CodedError = TranslationNotFoundError{}
|
|
var _ CodedError = InvalidUserIDError{}
|
|
|
|
// ErrorFromCode returns the CodedError for a serialized coded error string.
|
|
func ErrorFromCode(code string) (bool, error) {
|
|
switch code {
|
|
case "TAVAAAAAAAB":
|
|
return true, NotFoundError{}
|
|
case "TAVAAAAAAAC":
|
|
return true, EncryptFailedError{}
|
|
case "TAVAAAAAAAD":
|
|
return true, DecryptFailedError{}
|
|
case "TAVDATAAAAAAAB":
|
|
return true, QueryFailedError{}
|
|
case "TAVDATAAAAAAAC":
|
|
return true, DatabaseTransactionFailedError{}
|
|
case "TAVDATAAAAAAAD":
|
|
return true, InsertQueryFailedError{}
|
|
case "TAVDATAAAAAAAE":
|
|
return true, SelectQueryFailedError{}
|
|
case "TAVDATAAAAAAAF":
|
|
return true, UpdateQueryFailedError{}
|
|
case "TAVDATAAAAAAAG":
|
|
return true, DeleteQueryFailedError{}
|
|
case "TAVDATAAAAAAAH":
|
|
return true, UserQueryFailedError{}
|
|
case "TAVDATAAAAAAAI":
|
|
return true, UserSelectFailedError{}
|
|
case "TAVDATAAAAAAAJ":
|
|
return true, UserInsertFailedError{}
|
|
case "TAVDATAAAAAAAK":
|
|
return true, UserUpsertFailedError{}
|
|
case "TAVDATAAAAAAAL":
|
|
return true, UserUpdateFailedError{}
|
|
case "TAVDATAAAAAAAM":
|
|
return true, UserDeleteFailedError{}
|
|
case "TAVDATAAAAAAAN":
|
|
return true, InvalidUserError{}
|
|
case "TAVDATAAAAAAAO":
|
|
return true, UserNotFoundError{}
|
|
case "TAVDATAAAAAAAP":
|
|
return true, UserSessionQueryFailedError{}
|
|
case "TAVDATAAAAAAAQ":
|
|
return true, UserSessionSelectFailedError{}
|
|
case "TAVDATAAAAAAAR":
|
|
return true, UserSessionInsertFailedError{}
|
|
case "TAVDATAAAAAAAS":
|
|
return true, UserSessionUpsertFailedError{}
|
|
case "TAVDATAAAAAAAT":
|
|
return true, UserSessionUpdateFailedError{}
|
|
case "TAVDATAAAAAAAU":
|
|
return true, UserSessionDeleteFailedError{}
|
|
case "TAVDATAAAAAAAV":
|
|
return true, InvalidUserSessionError{}
|
|
case "TAVDATAAAAAAAW":
|
|
return true, UserSessionNotFoundError{}
|
|
case "TAVDATAAAAAAAX":
|
|
return true, UserFeedQueryFailedError{}
|
|
case "TAVDATAAAAAAAY":
|
|
return true, UserFeedSelectFailedError{}
|
|
case "TAVDATAAAAAAAZ":
|
|
return true, UserFeedInsertFailedError{}
|
|
case "TAVDATAAAAAAA0":
|
|
return true, UserFeedUpsertFailedError{}
|
|
case "TAVDATAAAAAAA1":
|
|
return true, UserFeedUpdateFailedError{}
|
|
case "TAVDATAAAAAAA2":
|
|
return true, UserFeedDeleteFailedError{}
|
|
case "TAVDATAAAAAAA3":
|
|
return true, InvalidUserFeedError{}
|
|
case "TAVDATAAAAAAA4":
|
|
return true, UserFeedNotFoundError{}
|
|
case "TAVDATAAAAAAA5":
|
|
return true, UserObjectEventQueryFailedError{}
|
|
case "TAVDATAAAAAAA6":
|
|
return true, UserObjectEventSelectFailedError{}
|
|
case "TAVDATAAAAAAA7":
|
|
return true, UserObjectEventInsertFailedError{}
|
|
case "TAVDATAAAAAAA8":
|
|
return true, UserObjectEventUpsertFailedError{}
|
|
case "TAVDATAAAAAAA9":
|
|
return true, UserObjectEventUpdateFailedError{}
|
|
case "TAVDATAAAAAABA":
|
|
return true, UserObjectEventDeleteFailedError{}
|
|
case "TAVDATAAAAAABB":
|
|
return true, InvalidUserObjectEventError{}
|
|
case "TAVDATAAAAAABC":
|
|
return true, UserObjectEventNotFoundError{}
|
|
case "TAVDATAAAAAABD":
|
|
return true, ActorQueryFailedError{}
|
|
case "TAVDATAAAAAABE":
|
|
return true, ActorSelectFailedError{}
|
|
case "TAVDATAAAAAABF":
|
|
return true, ActorInsertFailedError{}
|
|
case "TAVDATAAAAAABG":
|
|
return true, ActorUpsertFailedError{}
|
|
case "TAVDATAAAAAABH":
|
|
return true, ActorUpdateFailedError{}
|
|
case "TAVDATAAAAAABI":
|
|
return true, ActorDeleteFailedError{}
|
|
case "TAVDATAAAAAABJ":
|
|
return true, InvalidActorError{}
|
|
case "TAVDATAAAAAABK":
|
|
return true, ActorNotFoundError{}
|
|
case "TAVDATAAAAAABL":
|
|
return true, ActorAliasQueryFailedError{}
|
|
case "TAVDATAAAAAABM":
|
|
return true, ActorAliasSelectFailedError{}
|
|
case "TAVDATAAAAAABN":
|
|
return true, ActorAliasInsertFailedError{}
|
|
case "TAVDATAAAAAABO":
|
|
return true, ActorAliasUpsertFailedError{}
|
|
case "TAVDATAAAAAABP":
|
|
return true, ActorAliasUpdateFailedError{}
|
|
case "TAVDATAAAAAABQ":
|
|
return true, ActorAliasDeleteFailedError{}
|
|
case "TAVDATAAAAAABR":
|
|
return true, InvalidActorAliasError{}
|
|
case "TAVDATAAAAAABS":
|
|
return true, ActorAliasNotFoundError{}
|
|
case "TAVDATAAAAAABT":
|
|
return true, ActorKeyQueryFailedError{}
|
|
case "TAVDATAAAAAABU":
|
|
return true, ActorKeySelectFailedError{}
|
|
case "TAVDATAAAAAABV":
|
|
return true, ActorKeyInsertFailedError{}
|
|
case "TAVDATAAAAAABW":
|
|
return true, ActorKeyUpsertFailedError{}
|
|
case "TAVDATAAAAAABX":
|
|
return true, ActorKeyUpdateFailedError{}
|
|
case "TAVDATAAAAAABY":
|
|
return true, ActorKeyDeleteFailedError{}
|
|
case "TAVDATAAAAAABZ":
|
|
return true, InvalidActorKeyError{}
|
|
case "TAVDATAAAAAAB0":
|
|
return true, ActorKeyNotFoundError{}
|
|
case "TAVDATAAAAAAB1":
|
|
return true, NetworkRelationshipQueryFailedError{}
|
|
case "TAVDATAAAAAAB2":
|
|
return true, NetworkRelationshipSelectFailedError{}
|
|
case "TAVDATAAAAAAB3":
|
|
return true, NetworkRelationshipInsertFailedError{}
|
|
case "TAVDATAAAAAAB4":
|
|
return true, NetworkRelationshipUpsertFailedError{}
|
|
case "TAVDATAAAAAAB5":
|
|
return true, NetworkRelationshipUpdateFailedError{}
|
|
case "TAVDATAAAAAAB6":
|
|
return true, NetworkRelationshipDeleteFailedError{}
|
|
case "TAVDATAAAAAAB7":
|
|
return true, InvalidNetworkRelationshipError{}
|
|
case "TAVDATAAAAAAB8":
|
|
return true, NetworkRelationshipNotFoundError{}
|
|
case "TAVDATAAAAAAB9":
|
|
return true, ObjectQueryFailedError{}
|
|
case "TAVDATAAAAAACA":
|
|
return true, ObjectSelectFailedError{}
|
|
case "TAVDATAAAAAACB":
|
|
return true, ObjectInsertFailedError{}
|
|
case "TAVDATAAAAAACC":
|
|
return true, ObjectUpsertFailedError{}
|
|
case "TAVDATAAAAAACD":
|
|
return true, ObjectUpdateFailedError{}
|
|
case "TAVDATAAAAAACE":
|
|
return true, ObjectDeleteFailedError{}
|
|
case "TAVDATAAAAAACF":
|
|
return true, InvalidObjectError{}
|
|
case "TAVDATAAAAAACG":
|
|
return true, ObjectNotFoundError{}
|
|
case "TAVDATAAAAAACH":
|
|
return true, ObjectEventQueryFailedError{}
|
|
case "TAVDATAAAAAACI":
|
|
return true, ObjectEventSelectFailedError{}
|
|
case "TAVDATAAAAAACJ":
|
|
return true, ObjectEventInsertFailedError{}
|
|
case "TAVDATAAAAAACK":
|
|
return true, ObjectEventUpsertFailedError{}
|
|
case "TAVDATAAAAAACL":
|
|
return true, ObjectEventUpdateFailedError{}
|
|
case "TAVDATAAAAAACM":
|
|
return true, ObjectEventDeleteFailedError{}
|
|
case "TAVDATAAAAAACN":
|
|
return true, InvalidObjectEventError{}
|
|
case "TAVDATAAAAAACO":
|
|
return true, ObjectEventNotFoundError{}
|
|
case "TAVDATAAAAAACP":
|
|
return true, ObjectReplyQueryFailedError{}
|
|
case "TAVDATAAAAAACQ":
|
|
return true, ObjectReplySelectFailedError{}
|
|
case "TAVDATAAAAAACR":
|
|
return true, ObjectReplyInsertFailedError{}
|
|
case "TAVDATAAAAAACS":
|
|
return true, ObjectReplyUpsertFailedError{}
|
|
case "TAVDATAAAAAACT":
|
|
return true, ObjectReplyUpdateFailedError{}
|
|
case "TAVDATAAAAAACU":
|
|
return true, ObjectReplyDeleteFailedError{}
|
|
case "TAVDATAAAAAACV":
|
|
return true, InvalidObjectReplyError{}
|
|
case "TAVDATAAAAAACW":
|
|
return true, ObjectReplyNotFoundError{}
|
|
case "TAVDATAAAAAACX":
|
|
return true, ObjectTagQueryFailedError{}
|
|
case "TAVDATAAAAAACY":
|
|
return true, ObjectTagSelectFailedError{}
|
|
case "TAVDATAAAAAACZ":
|
|
return true, ObjectTagInsertFailedError{}
|
|
case "TAVDATAAAAAAC0":
|
|
return true, ObjectTagUpsertFailedError{}
|
|
case "TAVDATAAAAAAC1":
|
|
return true, ObjectTagUpdateFailedError{}
|
|
case "TAVDATAAAAAAC2":
|
|
return true, ObjectTagDeleteFailedError{}
|
|
case "TAVDATAAAAAAC3":
|
|
return true, InvalidObjectTagError{}
|
|
case "TAVDATAAAAAAC4":
|
|
return true, ObjectTagNotFoundError{}
|
|
case "TAVDATAAAAAAC5":
|
|
return true, ObjectThreadQueryFailedError{}
|
|
case "TAVDATAAAAAAC6":
|
|
return true, ObjectThreadSelectFailedError{}
|
|
case "TAVDATAAAAAAC7":
|
|
return true, ObjectThreadInsertFailedError{}
|
|
case "TAVDATAAAAAAC8":
|
|
return true, ObjectThreadUpsertFailedError{}
|
|
case "TAVDATAAAAAAC9":
|
|
return true, ObjectThreadUpdateFailedError{}
|
|
case "TAVDATAAAAAADA":
|
|
return true, ObjectThreadDeleteFailedError{}
|
|
case "TAVDATAAAAAADB":
|
|
return true, InvalidObjectThreadError{}
|
|
case "TAVDATAAAAAADC":
|
|
return true, ObjectThreadNotFoundError{}
|
|
case "TAVDATAAAAAADD":
|
|
return true, ObjectBoostQueryFailedError{}
|
|
case "TAVDATAAAAAADE":
|
|
return true, ObjectBoostSelectFailedError{}
|
|
case "TAVDATAAAAAADF":
|
|
return true, ObjectBoostInsertFailedError{}
|
|
case "TAVDATAAAAAADG":
|
|
return true, ObjectBoostUpsertFailedError{}
|
|
case "TAVDATAAAAAADH":
|
|
return true, ObjectBoostUpdateFailedError{}
|
|
case "TAVDATAAAAAADI":
|
|
return true, ObjectBoostDeleteFailedError{}
|
|
case "TAVDATAAAAAADJ":
|
|
return true, InvalidObjectBoostError{}
|
|
case "TAVDATAAAAAADK":
|
|
return true, ObjectBoostNotFoundError{}
|
|
case "TAVDATAAAAAADL":
|
|
return true, ImageQueryFailedError{}
|
|
case "TAVDATAAAAAADM":
|
|
return true, ImageSelectFailedError{}
|
|
case "TAVDATAAAAAADN":
|
|
return true, ImageInsertFailedError{}
|
|
case "TAVDATAAAAAADO":
|
|
return true, ImageUpsertFailedError{}
|
|
case "TAVDATAAAAAADP":
|
|
return true, ImageUpdateFailedError{}
|
|
case "TAVDATAAAAAADQ":
|
|
return true, ImageDeleteFailedError{}
|
|
case "TAVDATAAAAAADR":
|
|
return true, InvalidImageError{}
|
|
case "TAVDATAAAAAADS":
|
|
return true, ImageNotFoundError{}
|
|
case "TAVDATAAAAAADT":
|
|
return true, ImageAliasQueryFailedError{}
|
|
case "TAVDATAAAAAADU":
|
|
return true, ImageAliasSelectFailedError{}
|
|
case "TAVDATAAAAAADV":
|
|
return true, ImageAliasInsertFailedError{}
|
|
case "TAVDATAAAAAADW":
|
|
return true, ImageAliasUpsertFailedError{}
|
|
case "TAVDATAAAAAADX":
|
|
return true, ImageAliasUpdateFailedError{}
|
|
case "TAVDATAAAAAADY":
|
|
return true, ImageAliasDeleteFailedError{}
|
|
case "TAVDATAAAAAADZ":
|
|
return true, InvalidImageAliasError{}
|
|
case "TAVDATAAAAAAD0":
|
|
return true, ImageAliasNotFoundError{}
|
|
case "TAVWEBAAAAAAAB":
|
|
return true, InvalidEmailVerificationError{}
|
|
case "TAVWEBAAAAAAAC":
|
|
return true, CannotSaveSessionError{}
|
|
case "TAVWEBAAAAAAAD":
|
|
return true, InvalidCaptchaError{}
|
|
case "TAVWEBAAAAAAAE":
|
|
return true, EmailSendFailedError{}
|
|
case "TAVWEBAAAAAAAF":
|
|
return true, AuthenticationRequiredError{}
|
|
case "TAVWEBAAAAAAAG":
|
|
return true, TranslatorNotFoundError{}
|
|
case "TAVWEBAAAAAAAH":
|
|
return true, TranslationNotFoundError{}
|
|
case "TAVWEBAAAAAAAI":
|
|
return true, InvalidUserIDError{}
|
|
default:
|
|
return false, fmt.Errorf("unknown error code: %s", code)
|
|
}
|
|
}
|
|
|
|
func NewNotFoundError(err error) error {
|
|
|
|
return NotFoundError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNotFoundError(err)
|
|
}
|
|
|
|
func NewEncryptFailedError(err error) error {
|
|
|
|
return EncryptFailedError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapEncryptFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewEncryptFailedError(err)
|
|
}
|
|
|
|
func NewDecryptFailedError(err error) error {
|
|
|
|
return DecryptFailedError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapDecryptFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewDecryptFailedError(err)
|
|
}
|
|
|
|
func NewQueryFailedError(err error) error {
|
|
|
|
return QueryFailedError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewQueryFailedError(err)
|
|
}
|
|
|
|
func NewDatabaseTransactionFailedError(err error) error {
|
|
|
|
return DatabaseTransactionFailedError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapDatabaseTransactionFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewDatabaseTransactionFailedError(err)
|
|
}
|
|
|
|
func NewInsertQueryFailedError(err error) error {
|
|
|
|
return InsertQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInsertQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInsertQueryFailedError(err)
|
|
}
|
|
|
|
func NewSelectQueryFailedError(err error) error {
|
|
|
|
return SelectQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapSelectQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewSelectQueryFailedError(err)
|
|
}
|
|
|
|
func NewUpdateQueryFailedError(err error) error {
|
|
|
|
return UpdateQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUpdateQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUpdateQueryFailedError(err)
|
|
}
|
|
|
|
func NewDeleteQueryFailedError(err error) error {
|
|
|
|
return DeleteQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapDeleteQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewDeleteQueryFailedError(err)
|
|
}
|
|
|
|
func NewUserQueryFailedError(err error) error {
|
|
|
|
return UserQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserQueryFailedError(err)
|
|
}
|
|
|
|
func NewUserSelectFailedError(err error) error {
|
|
|
|
return UserSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSelectFailedError(err)
|
|
}
|
|
|
|
func NewUserInsertFailedError(err error) error {
|
|
|
|
return UserInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserInsertFailedError(err)
|
|
}
|
|
|
|
func NewUserUpsertFailedError(err error) error {
|
|
|
|
return UserUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserUpsertFailedError(err)
|
|
}
|
|
|
|
func NewUserUpdateFailedError(err error) error {
|
|
|
|
return UserUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserUpdateFailedError(err)
|
|
}
|
|
|
|
func NewUserDeleteFailedError(err error) error {
|
|
|
|
return UserDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidUserError(err error) error {
|
|
|
|
return InvalidUserError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidUserError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidUserError(err)
|
|
}
|
|
|
|
func NewUserNotFoundError(err error) error {
|
|
|
|
return UserNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserNotFoundError(err)
|
|
}
|
|
|
|
func NewUserSessionQueryFailedError(err error) error {
|
|
|
|
return UserSessionQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSessionQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSessionQueryFailedError(err)
|
|
}
|
|
|
|
func NewUserSessionSelectFailedError(err error) error {
|
|
|
|
return UserSessionSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSessionSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSessionSelectFailedError(err)
|
|
}
|
|
|
|
func NewUserSessionInsertFailedError(err error) error {
|
|
|
|
return UserSessionInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSessionInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSessionInsertFailedError(err)
|
|
}
|
|
|
|
func NewUserSessionUpsertFailedError(err error) error {
|
|
|
|
return UserSessionUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSessionUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSessionUpsertFailedError(err)
|
|
}
|
|
|
|
func NewUserSessionUpdateFailedError(err error) error {
|
|
|
|
return UserSessionUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSessionUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSessionUpdateFailedError(err)
|
|
}
|
|
|
|
func NewUserSessionDeleteFailedError(err error) error {
|
|
|
|
return UserSessionDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSessionDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSessionDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidUserSessionError(err error) error {
|
|
|
|
return InvalidUserSessionError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidUserSessionError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidUserSessionError(err)
|
|
}
|
|
|
|
func NewUserSessionNotFoundError(err error) error {
|
|
|
|
return UserSessionNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserSessionNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserSessionNotFoundError(err)
|
|
}
|
|
|
|
func NewUserFeedQueryFailedError(err error) error {
|
|
|
|
return UserFeedQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserFeedQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserFeedQueryFailedError(err)
|
|
}
|
|
|
|
func NewUserFeedSelectFailedError(err error) error {
|
|
|
|
return UserFeedSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserFeedSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserFeedSelectFailedError(err)
|
|
}
|
|
|
|
func NewUserFeedInsertFailedError(err error) error {
|
|
|
|
return UserFeedInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserFeedInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserFeedInsertFailedError(err)
|
|
}
|
|
|
|
func NewUserFeedUpsertFailedError(err error) error {
|
|
|
|
return UserFeedUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserFeedUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserFeedUpsertFailedError(err)
|
|
}
|
|
|
|
func NewUserFeedUpdateFailedError(err error) error {
|
|
|
|
return UserFeedUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserFeedUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserFeedUpdateFailedError(err)
|
|
}
|
|
|
|
func NewUserFeedDeleteFailedError(err error) error {
|
|
|
|
return UserFeedDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserFeedDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserFeedDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidUserFeedError(err error) error {
|
|
|
|
return InvalidUserFeedError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidUserFeedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidUserFeedError(err)
|
|
}
|
|
|
|
func NewUserFeedNotFoundError(err error) error {
|
|
|
|
return UserFeedNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserFeedNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserFeedNotFoundError(err)
|
|
}
|
|
|
|
func NewUserObjectEventQueryFailedError(err error) error {
|
|
|
|
return UserObjectEventQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserObjectEventQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserObjectEventQueryFailedError(err)
|
|
}
|
|
|
|
func NewUserObjectEventSelectFailedError(err error) error {
|
|
|
|
return UserObjectEventSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserObjectEventSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserObjectEventSelectFailedError(err)
|
|
}
|
|
|
|
func NewUserObjectEventInsertFailedError(err error) error {
|
|
|
|
return UserObjectEventInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserObjectEventInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserObjectEventInsertFailedError(err)
|
|
}
|
|
|
|
func NewUserObjectEventUpsertFailedError(err error) error {
|
|
|
|
return UserObjectEventUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserObjectEventUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserObjectEventUpsertFailedError(err)
|
|
}
|
|
|
|
func NewUserObjectEventUpdateFailedError(err error) error {
|
|
|
|
return UserObjectEventUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserObjectEventUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserObjectEventUpdateFailedError(err)
|
|
}
|
|
|
|
func NewUserObjectEventDeleteFailedError(err error) error {
|
|
|
|
return UserObjectEventDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserObjectEventDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserObjectEventDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidUserObjectEventError(err error) error {
|
|
|
|
return InvalidUserObjectEventError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidUserObjectEventError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidUserObjectEventError(err)
|
|
}
|
|
|
|
func NewUserObjectEventNotFoundError(err error) error {
|
|
|
|
return UserObjectEventNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapUserObjectEventNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewUserObjectEventNotFoundError(err)
|
|
}
|
|
|
|
func NewActorQueryFailedError(err error) error {
|
|
|
|
return ActorQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorQueryFailedError(err)
|
|
}
|
|
|
|
func NewActorSelectFailedError(err error) error {
|
|
|
|
return ActorSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorSelectFailedError(err)
|
|
}
|
|
|
|
func NewActorInsertFailedError(err error) error {
|
|
|
|
return ActorInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorInsertFailedError(err)
|
|
}
|
|
|
|
func NewActorUpsertFailedError(err error) error {
|
|
|
|
return ActorUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorUpsertFailedError(err)
|
|
}
|
|
|
|
func NewActorUpdateFailedError(err error) error {
|
|
|
|
return ActorUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorUpdateFailedError(err)
|
|
}
|
|
|
|
func NewActorDeleteFailedError(err error) error {
|
|
|
|
return ActorDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidActorError(err error) error {
|
|
|
|
return InvalidActorError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidActorError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidActorError(err)
|
|
}
|
|
|
|
func NewActorNotFoundError(err error) error {
|
|
|
|
return ActorNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorNotFoundError(err)
|
|
}
|
|
|
|
func NewActorAliasQueryFailedError(err error) error {
|
|
|
|
return ActorAliasQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorAliasQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorAliasQueryFailedError(err)
|
|
}
|
|
|
|
func NewActorAliasSelectFailedError(err error) error {
|
|
|
|
return ActorAliasSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorAliasSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorAliasSelectFailedError(err)
|
|
}
|
|
|
|
func NewActorAliasInsertFailedError(err error) error {
|
|
|
|
return ActorAliasInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorAliasInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorAliasInsertFailedError(err)
|
|
}
|
|
|
|
func NewActorAliasUpsertFailedError(err error) error {
|
|
|
|
return ActorAliasUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorAliasUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorAliasUpsertFailedError(err)
|
|
}
|
|
|
|
func NewActorAliasUpdateFailedError(err error) error {
|
|
|
|
return ActorAliasUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorAliasUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorAliasUpdateFailedError(err)
|
|
}
|
|
|
|
func NewActorAliasDeleteFailedError(err error) error {
|
|
|
|
return ActorAliasDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorAliasDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorAliasDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidActorAliasError(err error) error {
|
|
|
|
return InvalidActorAliasError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidActorAliasError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidActorAliasError(err)
|
|
}
|
|
|
|
func NewActorAliasNotFoundError(err error) error {
|
|
|
|
return ActorAliasNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorAliasNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorAliasNotFoundError(err)
|
|
}
|
|
|
|
func NewActorKeyQueryFailedError(err error) error {
|
|
|
|
return ActorKeyQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorKeyQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorKeyQueryFailedError(err)
|
|
}
|
|
|
|
func NewActorKeySelectFailedError(err error) error {
|
|
|
|
return ActorKeySelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorKeySelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorKeySelectFailedError(err)
|
|
}
|
|
|
|
func NewActorKeyInsertFailedError(err error) error {
|
|
|
|
return ActorKeyInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorKeyInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorKeyInsertFailedError(err)
|
|
}
|
|
|
|
func NewActorKeyUpsertFailedError(err error) error {
|
|
|
|
return ActorKeyUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorKeyUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorKeyUpsertFailedError(err)
|
|
}
|
|
|
|
func NewActorKeyUpdateFailedError(err error) error {
|
|
|
|
return ActorKeyUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorKeyUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorKeyUpdateFailedError(err)
|
|
}
|
|
|
|
func NewActorKeyDeleteFailedError(err error) error {
|
|
|
|
return ActorKeyDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorKeyDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorKeyDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidActorKeyError(err error) error {
|
|
|
|
return InvalidActorKeyError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidActorKeyError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidActorKeyError(err)
|
|
}
|
|
|
|
func NewActorKeyNotFoundError(err error) error {
|
|
|
|
return ActorKeyNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapActorKeyNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewActorKeyNotFoundError(err)
|
|
}
|
|
|
|
func NewNetworkRelationshipQueryFailedError(err error) error {
|
|
|
|
return NetworkRelationshipQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNetworkRelationshipQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNetworkRelationshipQueryFailedError(err)
|
|
}
|
|
|
|
func NewNetworkRelationshipSelectFailedError(err error) error {
|
|
|
|
return NetworkRelationshipSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNetworkRelationshipSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNetworkRelationshipSelectFailedError(err)
|
|
}
|
|
|
|
func NewNetworkRelationshipInsertFailedError(err error) error {
|
|
|
|
return NetworkRelationshipInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNetworkRelationshipInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNetworkRelationshipInsertFailedError(err)
|
|
}
|
|
|
|
func NewNetworkRelationshipUpsertFailedError(err error) error {
|
|
|
|
return NetworkRelationshipUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNetworkRelationshipUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNetworkRelationshipUpsertFailedError(err)
|
|
}
|
|
|
|
func NewNetworkRelationshipUpdateFailedError(err error) error {
|
|
|
|
return NetworkRelationshipUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNetworkRelationshipUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNetworkRelationshipUpdateFailedError(err)
|
|
}
|
|
|
|
func NewNetworkRelationshipDeleteFailedError(err error) error {
|
|
|
|
return NetworkRelationshipDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNetworkRelationshipDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNetworkRelationshipDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidNetworkRelationshipError(err error) error {
|
|
|
|
return InvalidNetworkRelationshipError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidNetworkRelationshipError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidNetworkRelationshipError(err)
|
|
}
|
|
|
|
func NewNetworkRelationshipNotFoundError(err error) error {
|
|
|
|
return NetworkRelationshipNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapNetworkRelationshipNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewNetworkRelationshipNotFoundError(err)
|
|
}
|
|
|
|
func NewObjectQueryFailedError(err error) error {
|
|
|
|
return ObjectQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectQueryFailedError(err)
|
|
}
|
|
|
|
func NewObjectSelectFailedError(err error) error {
|
|
|
|
return ObjectSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectSelectFailedError(err)
|
|
}
|
|
|
|
func NewObjectInsertFailedError(err error) error {
|
|
|
|
return ObjectInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectInsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectUpsertFailedError(err error) error {
|
|
|
|
return ObjectUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectUpsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectUpdateFailedError(err error) error {
|
|
|
|
return ObjectUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectUpdateFailedError(err)
|
|
}
|
|
|
|
func NewObjectDeleteFailedError(err error) error {
|
|
|
|
return ObjectDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidObjectError(err error) error {
|
|
|
|
return InvalidObjectError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidObjectError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidObjectError(err)
|
|
}
|
|
|
|
func NewObjectNotFoundError(err error) error {
|
|
|
|
return ObjectNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectNotFoundError(err)
|
|
}
|
|
|
|
func NewObjectEventQueryFailedError(err error) error {
|
|
|
|
return ObjectEventQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectEventQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectEventQueryFailedError(err)
|
|
}
|
|
|
|
func NewObjectEventSelectFailedError(err error) error {
|
|
|
|
return ObjectEventSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectEventSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectEventSelectFailedError(err)
|
|
}
|
|
|
|
func NewObjectEventInsertFailedError(err error) error {
|
|
|
|
return ObjectEventInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectEventInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectEventInsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectEventUpsertFailedError(err error) error {
|
|
|
|
return ObjectEventUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectEventUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectEventUpsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectEventUpdateFailedError(err error) error {
|
|
|
|
return ObjectEventUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectEventUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectEventUpdateFailedError(err)
|
|
}
|
|
|
|
func NewObjectEventDeleteFailedError(err error) error {
|
|
|
|
return ObjectEventDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectEventDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectEventDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidObjectEventError(err error) error {
|
|
|
|
return InvalidObjectEventError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidObjectEventError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidObjectEventError(err)
|
|
}
|
|
|
|
func NewObjectEventNotFoundError(err error) error {
|
|
|
|
return ObjectEventNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectEventNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectEventNotFoundError(err)
|
|
}
|
|
|
|
func NewObjectReplyQueryFailedError(err error) error {
|
|
|
|
return ObjectReplyQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectReplyQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectReplyQueryFailedError(err)
|
|
}
|
|
|
|
func NewObjectReplySelectFailedError(err error) error {
|
|
|
|
return ObjectReplySelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectReplySelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectReplySelectFailedError(err)
|
|
}
|
|
|
|
func NewObjectReplyInsertFailedError(err error) error {
|
|
|
|
return ObjectReplyInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectReplyInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectReplyInsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectReplyUpsertFailedError(err error) error {
|
|
|
|
return ObjectReplyUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectReplyUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectReplyUpsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectReplyUpdateFailedError(err error) error {
|
|
|
|
return ObjectReplyUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectReplyUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectReplyUpdateFailedError(err)
|
|
}
|
|
|
|
func NewObjectReplyDeleteFailedError(err error) error {
|
|
|
|
return ObjectReplyDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectReplyDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectReplyDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidObjectReplyError(err error) error {
|
|
|
|
return InvalidObjectReplyError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidObjectReplyError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidObjectReplyError(err)
|
|
}
|
|
|
|
func NewObjectReplyNotFoundError(err error) error {
|
|
|
|
return ObjectReplyNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectReplyNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectReplyNotFoundError(err)
|
|
}
|
|
|
|
func NewObjectTagQueryFailedError(err error) error {
|
|
|
|
return ObjectTagQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectTagQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectTagQueryFailedError(err)
|
|
}
|
|
|
|
func NewObjectTagSelectFailedError(err error) error {
|
|
|
|
return ObjectTagSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectTagSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectTagSelectFailedError(err)
|
|
}
|
|
|
|
func NewObjectTagInsertFailedError(err error) error {
|
|
|
|
return ObjectTagInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectTagInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectTagInsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectTagUpsertFailedError(err error) error {
|
|
|
|
return ObjectTagUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectTagUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectTagUpsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectTagUpdateFailedError(err error) error {
|
|
|
|
return ObjectTagUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectTagUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectTagUpdateFailedError(err)
|
|
}
|
|
|
|
func NewObjectTagDeleteFailedError(err error) error {
|
|
|
|
return ObjectTagDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectTagDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectTagDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidObjectTagError(err error) error {
|
|
|
|
return InvalidObjectTagError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidObjectTagError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidObjectTagError(err)
|
|
}
|
|
|
|
func NewObjectTagNotFoundError(err error) error {
|
|
|
|
return ObjectTagNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectTagNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectTagNotFoundError(err)
|
|
}
|
|
|
|
func NewObjectThreadQueryFailedError(err error) error {
|
|
|
|
return ObjectThreadQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectThreadQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectThreadQueryFailedError(err)
|
|
}
|
|
|
|
func NewObjectThreadSelectFailedError(err error) error {
|
|
|
|
return ObjectThreadSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectThreadSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectThreadSelectFailedError(err)
|
|
}
|
|
|
|
func NewObjectThreadInsertFailedError(err error) error {
|
|
|
|
return ObjectThreadInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectThreadInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectThreadInsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectThreadUpsertFailedError(err error) error {
|
|
|
|
return ObjectThreadUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectThreadUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectThreadUpsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectThreadUpdateFailedError(err error) error {
|
|
|
|
return ObjectThreadUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectThreadUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectThreadUpdateFailedError(err)
|
|
}
|
|
|
|
func NewObjectThreadDeleteFailedError(err error) error {
|
|
|
|
return ObjectThreadDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectThreadDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectThreadDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidObjectThreadError(err error) error {
|
|
|
|
return InvalidObjectThreadError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidObjectThreadError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidObjectThreadError(err)
|
|
}
|
|
|
|
func NewObjectThreadNotFoundError(err error) error {
|
|
|
|
return ObjectThreadNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectThreadNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectThreadNotFoundError(err)
|
|
}
|
|
|
|
func NewObjectBoostQueryFailedError(err error) error {
|
|
|
|
return ObjectBoostQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectBoostQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectBoostQueryFailedError(err)
|
|
}
|
|
|
|
func NewObjectBoostSelectFailedError(err error) error {
|
|
|
|
return ObjectBoostSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectBoostSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectBoostSelectFailedError(err)
|
|
}
|
|
|
|
func NewObjectBoostInsertFailedError(err error) error {
|
|
|
|
return ObjectBoostInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectBoostInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectBoostInsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectBoostUpsertFailedError(err error) error {
|
|
|
|
return ObjectBoostUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectBoostUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectBoostUpsertFailedError(err)
|
|
}
|
|
|
|
func NewObjectBoostUpdateFailedError(err error) error {
|
|
|
|
return ObjectBoostUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectBoostUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectBoostUpdateFailedError(err)
|
|
}
|
|
|
|
func NewObjectBoostDeleteFailedError(err error) error {
|
|
|
|
return ObjectBoostDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectBoostDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectBoostDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidObjectBoostError(err error) error {
|
|
|
|
return InvalidObjectBoostError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidObjectBoostError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidObjectBoostError(err)
|
|
}
|
|
|
|
func NewObjectBoostNotFoundError(err error) error {
|
|
|
|
return ObjectBoostNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapObjectBoostNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewObjectBoostNotFoundError(err)
|
|
}
|
|
|
|
func NewImageQueryFailedError(err error) error {
|
|
|
|
return ImageQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageQueryFailedError(err)
|
|
}
|
|
|
|
func NewImageSelectFailedError(err error) error {
|
|
|
|
return ImageSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageSelectFailedError(err)
|
|
}
|
|
|
|
func NewImageInsertFailedError(err error) error {
|
|
|
|
return ImageInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageInsertFailedError(err)
|
|
}
|
|
|
|
func NewImageUpsertFailedError(err error) error {
|
|
|
|
return ImageUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageUpsertFailedError(err)
|
|
}
|
|
|
|
func NewImageUpdateFailedError(err error) error {
|
|
|
|
return ImageUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageUpdateFailedError(err)
|
|
}
|
|
|
|
func NewImageDeleteFailedError(err error) error {
|
|
|
|
return ImageDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidImageError(err error) error {
|
|
|
|
return InvalidImageError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidImageError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidImageError(err)
|
|
}
|
|
|
|
func NewImageNotFoundError(err error) error {
|
|
|
|
return ImageNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageNotFoundError(err)
|
|
}
|
|
|
|
func NewImageAliasQueryFailedError(err error) error {
|
|
|
|
return ImageAliasQueryFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageAliasQueryFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageAliasQueryFailedError(err)
|
|
}
|
|
|
|
func NewImageAliasSelectFailedError(err error) error {
|
|
|
|
return ImageAliasSelectFailedError{ Err: NewSelectQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageAliasSelectFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageAliasSelectFailedError(err)
|
|
}
|
|
|
|
func NewImageAliasInsertFailedError(err error) error {
|
|
|
|
return ImageAliasInsertFailedError{ Err: NewInsertQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageAliasInsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageAliasInsertFailedError(err)
|
|
}
|
|
|
|
func NewImageAliasUpsertFailedError(err error) error {
|
|
|
|
return ImageAliasUpsertFailedError{ Err: NewQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageAliasUpsertFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageAliasUpsertFailedError(err)
|
|
}
|
|
|
|
func NewImageAliasUpdateFailedError(err error) error {
|
|
|
|
return ImageAliasUpdateFailedError{ Err: NewUpdateQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageAliasUpdateFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageAliasUpdateFailedError(err)
|
|
}
|
|
|
|
func NewImageAliasDeleteFailedError(err error) error {
|
|
|
|
return ImageAliasDeleteFailedError{ Err: NewDeleteQueryFailedError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageAliasDeleteFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageAliasDeleteFailedError(err)
|
|
}
|
|
|
|
func NewInvalidImageAliasError(err error) error {
|
|
|
|
return InvalidImageAliasError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidImageAliasError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidImageAliasError(err)
|
|
}
|
|
|
|
func NewImageAliasNotFoundError(err error) error {
|
|
|
|
return ImageAliasNotFoundError{ Err: NewNotFoundError(err), Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapImageAliasNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewImageAliasNotFoundError(err)
|
|
}
|
|
|
|
func NewInvalidEmailVerificationError(err error) error {
|
|
|
|
return InvalidEmailVerificationError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidEmailVerificationError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidEmailVerificationError(err)
|
|
}
|
|
|
|
func NewCannotSaveSessionError(err error) error {
|
|
|
|
return CannotSaveSessionError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapCannotSaveSessionError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewCannotSaveSessionError(err)
|
|
}
|
|
|
|
func NewInvalidCaptchaError(err error) error {
|
|
|
|
return InvalidCaptchaError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidCaptchaError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidCaptchaError(err)
|
|
}
|
|
|
|
func NewEmailSendFailedError(err error) error {
|
|
|
|
return EmailSendFailedError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapEmailSendFailedError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewEmailSendFailedError(err)
|
|
}
|
|
|
|
func NewAuthenticationRequiredError(err error) error {
|
|
|
|
return AuthenticationRequiredError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapAuthenticationRequiredError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewAuthenticationRequiredError(err)
|
|
}
|
|
|
|
func NewTranslatorNotFoundError(err error) error {
|
|
|
|
return TranslatorNotFoundError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapTranslatorNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewTranslatorNotFoundError(err)
|
|
}
|
|
|
|
func NewTranslationNotFoundError(err error) error {
|
|
|
|
return TranslationNotFoundError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapTranslationNotFoundError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewTranslationNotFoundError(err)
|
|
}
|
|
|
|
func NewInvalidUserIDError(err error) error {
|
|
|
|
return InvalidUserIDError{ Err: err, Stack: callers() }
|
|
|
|
}
|
|
|
|
func WrapInvalidUserIDError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewInvalidUserIDError(err)
|
|
}
|
|
|
|
func (e NotFoundError) Error() string {
|
|
return "TAVAAAAAAAB"
|
|
}
|
|
|
|
func (e NotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NotFoundError) Is(target error) bool {
|
|
t, ok := target.(NotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAV" && t.Code() == 1
|
|
}
|
|
|
|
func (e NotFoundError) Code() int {
|
|
return 1
|
|
}
|
|
|
|
func (e NotFoundError) Description() string {
|
|
return "Not found."
|
|
}
|
|
|
|
func (e NotFoundError) Prefix() string {
|
|
return "TAV"
|
|
}
|
|
|
|
func (e NotFoundError) String() string {
|
|
return "TAVAAAAAAAB Not found."
|
|
}
|
|
|
|
func (e NotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVAAAAAAAB")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVAAAAAAAB")
|
|
}
|
|
}
|
|
|
|
func (e EncryptFailedError) Error() string {
|
|
return "TAVAAAAAAAC"
|
|
}
|
|
|
|
func (e EncryptFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e EncryptFailedError) Is(target error) bool {
|
|
t, ok := target.(EncryptFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAV" && t.Code() == 2
|
|
}
|
|
|
|
func (e EncryptFailedError) Code() int {
|
|
return 2
|
|
}
|
|
|
|
func (e EncryptFailedError) Description() string {
|
|
return "Encrypting data failed."
|
|
}
|
|
|
|
func (e EncryptFailedError) Prefix() string {
|
|
return "TAV"
|
|
}
|
|
|
|
func (e EncryptFailedError) String() string {
|
|
return "TAVAAAAAAAC Encrypting data failed."
|
|
}
|
|
|
|
func (e EncryptFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVAAAAAAAC")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVAAAAAAAC")
|
|
}
|
|
}
|
|
|
|
func (e DecryptFailedError) Error() string {
|
|
return "TAVAAAAAAAD"
|
|
}
|
|
|
|
func (e DecryptFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e DecryptFailedError) Is(target error) bool {
|
|
t, ok := target.(DecryptFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAV" && t.Code() == 3
|
|
}
|
|
|
|
func (e DecryptFailedError) Code() int {
|
|
return 3
|
|
}
|
|
|
|
func (e DecryptFailedError) Description() string {
|
|
return "Decrypting data failed."
|
|
}
|
|
|
|
func (e DecryptFailedError) Prefix() string {
|
|
return "TAV"
|
|
}
|
|
|
|
func (e DecryptFailedError) String() string {
|
|
return "TAVAAAAAAAD Decrypting data failed."
|
|
}
|
|
|
|
func (e DecryptFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVAAAAAAAD")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVAAAAAAAD")
|
|
}
|
|
}
|
|
|
|
func (e QueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAB"
|
|
}
|
|
|
|
func (e QueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e QueryFailedError) Is(target error) bool {
|
|
t, ok := target.(QueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 1
|
|
}
|
|
|
|
func (e QueryFailedError) Code() int {
|
|
return 1
|
|
}
|
|
|
|
func (e QueryFailedError) Description() string {
|
|
return "The query operation failed."
|
|
}
|
|
|
|
func (e QueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e QueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAB The query operation failed."
|
|
}
|
|
|
|
func (e QueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAB")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAB")
|
|
}
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) Error() string {
|
|
return "TAVDATAAAAAAAC"
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) Is(target error) bool {
|
|
t, ok := target.(DatabaseTransactionFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 2
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) Code() int {
|
|
return 2
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) Description() string {
|
|
return "The database transaction failed."
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) String() string {
|
|
return "TAVDATAAAAAAAC The database transaction failed."
|
|
}
|
|
|
|
func (e DatabaseTransactionFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAC")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAC")
|
|
}
|
|
}
|
|
|
|
func (e InsertQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAD"
|
|
}
|
|
|
|
func (e InsertQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InsertQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(InsertQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 3
|
|
}
|
|
|
|
func (e InsertQueryFailedError) Code() int {
|
|
return 3
|
|
}
|
|
|
|
func (e InsertQueryFailedError) Description() string {
|
|
return "The insert query failed"
|
|
}
|
|
|
|
func (e InsertQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InsertQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAD The insert query failed"
|
|
}
|
|
|
|
func (e InsertQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAD")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAD")
|
|
}
|
|
}
|
|
|
|
func (e SelectQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAE"
|
|
}
|
|
|
|
func (e SelectQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e SelectQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(SelectQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 4
|
|
}
|
|
|
|
func (e SelectQueryFailedError) Code() int {
|
|
return 4
|
|
}
|
|
|
|
func (e SelectQueryFailedError) Description() string {
|
|
return "The select query failed"
|
|
}
|
|
|
|
func (e SelectQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e SelectQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAE The select query failed"
|
|
}
|
|
|
|
func (e SelectQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAE")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAE")
|
|
}
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAF"
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(UpdateQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 5
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) Code() int {
|
|
return 5
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) Description() string {
|
|
return "The update query failed"
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAF The update query failed"
|
|
}
|
|
|
|
func (e UpdateQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAF")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAF")
|
|
}
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAG"
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(DeleteQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 6
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) Code() int {
|
|
return 6
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) Description() string {
|
|
return "The delete query failed"
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAG The delete query failed"
|
|
}
|
|
|
|
func (e DeleteQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAG")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAG")
|
|
}
|
|
}
|
|
|
|
func (e UserQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAH"
|
|
}
|
|
|
|
func (e UserQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(UserQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 7
|
|
}
|
|
|
|
func (e UserQueryFailedError) Code() int {
|
|
return 7
|
|
}
|
|
|
|
func (e UserQueryFailedError) Description() string {
|
|
return "The user query failed."
|
|
}
|
|
|
|
func (e UserQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAH The user query failed."
|
|
}
|
|
|
|
func (e UserQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAH")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAH")
|
|
}
|
|
}
|
|
|
|
func (e UserSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAAAI"
|
|
}
|
|
|
|
func (e UserSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(UserSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 8
|
|
}
|
|
|
|
func (e UserSelectFailedError) Code() int {
|
|
return 8
|
|
}
|
|
|
|
func (e UserSelectFailedError) Description() string {
|
|
return "The select record operation for user failed."
|
|
}
|
|
|
|
func (e UserSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSelectFailedError) String() string {
|
|
return "TAVDATAAAAAAAI The select record operation for user failed."
|
|
}
|
|
|
|
func (e UserSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAI")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAI")
|
|
}
|
|
}
|
|
|
|
func (e UserInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAAJ"
|
|
}
|
|
|
|
func (e UserInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 9
|
|
}
|
|
|
|
func (e UserInsertFailedError) Code() int {
|
|
return 9
|
|
}
|
|
|
|
func (e UserInsertFailedError) Description() string {
|
|
return "The insert record operation for user failed."
|
|
}
|
|
|
|
func (e UserInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserInsertFailedError) String() string {
|
|
return "TAVDATAAAAAAAJ The insert record operation for user failed."
|
|
}
|
|
|
|
func (e UserInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAJ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAJ")
|
|
}
|
|
}
|
|
|
|
func (e UserUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAAK"
|
|
}
|
|
|
|
func (e UserUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 10
|
|
}
|
|
|
|
func (e UserUpsertFailedError) Code() int {
|
|
return 10
|
|
}
|
|
|
|
func (e UserUpsertFailedError) Description() string {
|
|
return "The upsert record operation for user failed."
|
|
}
|
|
|
|
func (e UserUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAAAK The upsert record operation for user failed."
|
|
}
|
|
|
|
func (e UserUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAK")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAK")
|
|
}
|
|
}
|
|
|
|
func (e UserUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAAAL"
|
|
}
|
|
|
|
func (e UserUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(UserUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 11
|
|
}
|
|
|
|
func (e UserUpdateFailedError) Code() int {
|
|
return 11
|
|
}
|
|
|
|
func (e UserUpdateFailedError) Description() string {
|
|
return "The update record operation for user failed."
|
|
}
|
|
|
|
func (e UserUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAAAL The update record operation for user failed."
|
|
}
|
|
|
|
func (e UserUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAL")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAL")
|
|
}
|
|
}
|
|
|
|
func (e UserDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAAAM"
|
|
}
|
|
|
|
func (e UserDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(UserDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 12
|
|
}
|
|
|
|
func (e UserDeleteFailedError) Code() int {
|
|
return 12
|
|
}
|
|
|
|
func (e UserDeleteFailedError) Description() string {
|
|
return "The delete record operation for user failed."
|
|
}
|
|
|
|
func (e UserDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAAAM The delete record operation for user failed."
|
|
}
|
|
|
|
func (e UserDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAM")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAM")
|
|
}
|
|
}
|
|
|
|
func (e InvalidUserError) Error() string {
|
|
return "TAVDATAAAAAAAN"
|
|
}
|
|
|
|
func (e InvalidUserError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidUserError) Is(target error) bool {
|
|
t, ok := target.(InvalidUserError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 13
|
|
}
|
|
|
|
func (e InvalidUserError) Code() int {
|
|
return 13
|
|
}
|
|
|
|
func (e InvalidUserError) Description() string {
|
|
return "The user is invalid."
|
|
}
|
|
|
|
func (e InvalidUserError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidUserError) String() string {
|
|
return "TAVDATAAAAAAAN The user is invalid."
|
|
}
|
|
|
|
func (e InvalidUserError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAN")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAN")
|
|
}
|
|
}
|
|
|
|
func (e UserNotFoundError) Error() string {
|
|
return "TAVDATAAAAAAAO"
|
|
}
|
|
|
|
func (e UserNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserNotFoundError) Is(target error) bool {
|
|
t, ok := target.(UserNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 14
|
|
}
|
|
|
|
func (e UserNotFoundError) Code() int {
|
|
return 14
|
|
}
|
|
|
|
func (e UserNotFoundError) Description() string {
|
|
return "The user was not found."
|
|
}
|
|
|
|
func (e UserNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserNotFoundError) String() string {
|
|
return "TAVDATAAAAAAAO The user was not found."
|
|
}
|
|
|
|
func (e UserNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAO")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAO")
|
|
}
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAP"
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(UserSessionQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 15
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) Code() int {
|
|
return 15
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) Description() string {
|
|
return "The user session query failed."
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAP The user session query failed."
|
|
}
|
|
|
|
func (e UserSessionQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAP")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAP")
|
|
}
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAAAQ"
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(UserSessionSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 16
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) Code() int {
|
|
return 16
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) Description() string {
|
|
return "The select record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) String() string {
|
|
return "TAVDATAAAAAAAQ The select record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAQ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAQ")
|
|
}
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAAR"
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserSessionInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 17
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) Code() int {
|
|
return 17
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) Description() string {
|
|
return "The insert record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) String() string {
|
|
return "TAVDATAAAAAAAR The insert record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAR")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAR")
|
|
}
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAAS"
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserSessionUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 18
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) Code() int {
|
|
return 18
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) Description() string {
|
|
return "The upsert record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAAAS The upsert record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAS")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAS")
|
|
}
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAAAT"
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(UserSessionUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 19
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) Code() int {
|
|
return 19
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) Description() string {
|
|
return "The update record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAAAT The update record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAT")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAT")
|
|
}
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAAAU"
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(UserSessionDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 20
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) Code() int {
|
|
return 20
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) Description() string {
|
|
return "The delete record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAAAU The delete record operation for user session failed."
|
|
}
|
|
|
|
func (e UserSessionDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAU")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAU")
|
|
}
|
|
}
|
|
|
|
func (e InvalidUserSessionError) Error() string {
|
|
return "TAVDATAAAAAAAV"
|
|
}
|
|
|
|
func (e InvalidUserSessionError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidUserSessionError) Is(target error) bool {
|
|
t, ok := target.(InvalidUserSessionError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 21
|
|
}
|
|
|
|
func (e InvalidUserSessionError) Code() int {
|
|
return 21
|
|
}
|
|
|
|
func (e InvalidUserSessionError) Description() string {
|
|
return "The user session is invalid."
|
|
}
|
|
|
|
func (e InvalidUserSessionError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidUserSessionError) String() string {
|
|
return "TAVDATAAAAAAAV The user session is invalid."
|
|
}
|
|
|
|
func (e InvalidUserSessionError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAV")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAV")
|
|
}
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) Error() string {
|
|
return "TAVDATAAAAAAAW"
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) Is(target error) bool {
|
|
t, ok := target.(UserSessionNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 22
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) Code() int {
|
|
return 22
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) Description() string {
|
|
return "The user session was not found."
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) String() string {
|
|
return "TAVDATAAAAAAAW The user session was not found."
|
|
}
|
|
|
|
func (e UserSessionNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAW")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAW")
|
|
}
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAAX"
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(UserFeedQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 23
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) Code() int {
|
|
return 23
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) Description() string {
|
|
return "The user feed query failed."
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAAX The user feed query failed."
|
|
}
|
|
|
|
func (e UserFeedQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAX")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAX")
|
|
}
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAAAY"
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(UserFeedSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 24
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) Code() int {
|
|
return 24
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) Description() string {
|
|
return "The select record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) String() string {
|
|
return "TAVDATAAAAAAAY The select record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAY")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAY")
|
|
}
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAAZ"
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserFeedInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 25
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) Code() int {
|
|
return 25
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) Description() string {
|
|
return "The insert record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) String() string {
|
|
return "TAVDATAAAAAAAZ The insert record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAAZ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAAZ")
|
|
}
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAA0"
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserFeedUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 26
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) Code() int {
|
|
return 26
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) Description() string {
|
|
return "The upsert record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAAA0 The upsert record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA0")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA0")
|
|
}
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAAA1"
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(UserFeedUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 27
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) Code() int {
|
|
return 27
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) Description() string {
|
|
return "The update record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAAA1 The update record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA1")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA1")
|
|
}
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAAA2"
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(UserFeedDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 28
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) Code() int {
|
|
return 28
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) Description() string {
|
|
return "The delete record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAAA2 The delete record operation for user feed failed."
|
|
}
|
|
|
|
func (e UserFeedDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA2")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA2")
|
|
}
|
|
}
|
|
|
|
func (e InvalidUserFeedError) Error() string {
|
|
return "TAVDATAAAAAAA3"
|
|
}
|
|
|
|
func (e InvalidUserFeedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidUserFeedError) Is(target error) bool {
|
|
t, ok := target.(InvalidUserFeedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 29
|
|
}
|
|
|
|
func (e InvalidUserFeedError) Code() int {
|
|
return 29
|
|
}
|
|
|
|
func (e InvalidUserFeedError) Description() string {
|
|
return "The user feed is invalid."
|
|
}
|
|
|
|
func (e InvalidUserFeedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidUserFeedError) String() string {
|
|
return "TAVDATAAAAAAA3 The user feed is invalid."
|
|
}
|
|
|
|
func (e InvalidUserFeedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA3")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA3")
|
|
}
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) Error() string {
|
|
return "TAVDATAAAAAAA4"
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) Is(target error) bool {
|
|
t, ok := target.(UserFeedNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 30
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) Code() int {
|
|
return 30
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) Description() string {
|
|
return "The user feed was not found."
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) String() string {
|
|
return "TAVDATAAAAAAA4 The user feed was not found."
|
|
}
|
|
|
|
func (e UserFeedNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA4")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA4")
|
|
}
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAA5"
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(UserObjectEventQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 31
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) Code() int {
|
|
return 31
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) Description() string {
|
|
return "The user object event query failed."
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAA5 The user object event query failed."
|
|
}
|
|
|
|
func (e UserObjectEventQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA5")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA5")
|
|
}
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAAA6"
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(UserObjectEventSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 32
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) Code() int {
|
|
return 32
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) Description() string {
|
|
return "The select record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) String() string {
|
|
return "TAVDATAAAAAAA6 The select record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA6")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA6")
|
|
}
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAA7"
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserObjectEventInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 33
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) Code() int {
|
|
return 33
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) Description() string {
|
|
return "The insert record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) String() string {
|
|
return "TAVDATAAAAAAA7 The insert record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA7")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA7")
|
|
}
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAA8"
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(UserObjectEventUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 34
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) Code() int {
|
|
return 34
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) Description() string {
|
|
return "The upsert record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAAA8 The upsert record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA8")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA8")
|
|
}
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAAA9"
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(UserObjectEventUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 35
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) Code() int {
|
|
return 35
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) Description() string {
|
|
return "The update record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAAA9 The update record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAA9")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAA9")
|
|
}
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAABA"
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(UserObjectEventDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 36
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) Code() int {
|
|
return 36
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) Description() string {
|
|
return "The delete record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAABA The delete record operation for user object event failed."
|
|
}
|
|
|
|
func (e UserObjectEventDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABA")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABA")
|
|
}
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) Error() string {
|
|
return "TAVDATAAAAAABB"
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) Is(target error) bool {
|
|
t, ok := target.(InvalidUserObjectEventError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 37
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) Code() int {
|
|
return 37
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) Description() string {
|
|
return "The user object event is invalid."
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) String() string {
|
|
return "TAVDATAAAAAABB The user object event is invalid."
|
|
}
|
|
|
|
func (e InvalidUserObjectEventError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABB")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABB")
|
|
}
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) Error() string {
|
|
return "TAVDATAAAAAABC"
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) Is(target error) bool {
|
|
t, ok := target.(UserObjectEventNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 38
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) Code() int {
|
|
return 38
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) Description() string {
|
|
return "The user object event was not found."
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) String() string {
|
|
return "TAVDATAAAAAABC The user object event was not found."
|
|
}
|
|
|
|
func (e UserObjectEventNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABC")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABC")
|
|
}
|
|
}
|
|
|
|
func (e ActorQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAABD"
|
|
}
|
|
|
|
func (e ActorQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 39
|
|
}
|
|
|
|
func (e ActorQueryFailedError) Code() int {
|
|
return 39
|
|
}
|
|
|
|
func (e ActorQueryFailedError) Description() string {
|
|
return "The actor query failed."
|
|
}
|
|
|
|
func (e ActorQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorQueryFailedError) String() string {
|
|
return "TAVDATAAAAAABD The actor query failed."
|
|
}
|
|
|
|
func (e ActorQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABD")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABD")
|
|
}
|
|
}
|
|
|
|
func (e ActorSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAABE"
|
|
}
|
|
|
|
func (e ActorSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 40
|
|
}
|
|
|
|
func (e ActorSelectFailedError) Code() int {
|
|
return 40
|
|
}
|
|
|
|
func (e ActorSelectFailedError) Description() string {
|
|
return "The select record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorSelectFailedError) String() string {
|
|
return "TAVDATAAAAAABE The select record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABE")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABE")
|
|
}
|
|
}
|
|
|
|
func (e ActorInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAABF"
|
|
}
|
|
|
|
func (e ActorInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 41
|
|
}
|
|
|
|
func (e ActorInsertFailedError) Code() int {
|
|
return 41
|
|
}
|
|
|
|
func (e ActorInsertFailedError) Description() string {
|
|
return "The insert record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorInsertFailedError) String() string {
|
|
return "TAVDATAAAAAABF The insert record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABF")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABF")
|
|
}
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAABG"
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 42
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) Code() int {
|
|
return 42
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) Description() string {
|
|
return "The upsert record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAABG The upsert record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABG")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABG")
|
|
}
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAABH"
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 43
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) Code() int {
|
|
return 43
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) Description() string {
|
|
return "The update record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAABH The update record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABH")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABH")
|
|
}
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAABI"
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 44
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) Code() int {
|
|
return 44
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) Description() string {
|
|
return "The delete record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAABI The delete record operation for actor failed."
|
|
}
|
|
|
|
func (e ActorDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABI")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABI")
|
|
}
|
|
}
|
|
|
|
func (e InvalidActorError) Error() string {
|
|
return "TAVDATAAAAAABJ"
|
|
}
|
|
|
|
func (e InvalidActorError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidActorError) Is(target error) bool {
|
|
t, ok := target.(InvalidActorError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 45
|
|
}
|
|
|
|
func (e InvalidActorError) Code() int {
|
|
return 45
|
|
}
|
|
|
|
func (e InvalidActorError) Description() string {
|
|
return "The actor is invalid."
|
|
}
|
|
|
|
func (e InvalidActorError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidActorError) String() string {
|
|
return "TAVDATAAAAAABJ The actor is invalid."
|
|
}
|
|
|
|
func (e InvalidActorError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABJ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABJ")
|
|
}
|
|
}
|
|
|
|
func (e ActorNotFoundError) Error() string {
|
|
return "TAVDATAAAAAABK"
|
|
}
|
|
|
|
func (e ActorNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ActorNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 46
|
|
}
|
|
|
|
func (e ActorNotFoundError) Code() int {
|
|
return 46
|
|
}
|
|
|
|
func (e ActorNotFoundError) Description() string {
|
|
return "The actor was not found."
|
|
}
|
|
|
|
func (e ActorNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorNotFoundError) String() string {
|
|
return "TAVDATAAAAAABK The actor was not found."
|
|
}
|
|
|
|
func (e ActorNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABK")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABK")
|
|
}
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAABL"
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorAliasQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 47
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) Code() int {
|
|
return 47
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) Description() string {
|
|
return "The actor alias query failed."
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) String() string {
|
|
return "TAVDATAAAAAABL The actor alias query failed."
|
|
}
|
|
|
|
func (e ActorAliasQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABL")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABL")
|
|
}
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAABM"
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorAliasSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 48
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) Code() int {
|
|
return 48
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) Description() string {
|
|
return "The select record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) String() string {
|
|
return "TAVDATAAAAAABM The select record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABM")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABM")
|
|
}
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAABN"
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorAliasInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 49
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) Code() int {
|
|
return 49
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) Description() string {
|
|
return "The insert record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) String() string {
|
|
return "TAVDATAAAAAABN The insert record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABN")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABN")
|
|
}
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAABO"
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorAliasUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 50
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) Code() int {
|
|
return 50
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) Description() string {
|
|
return "The upsert record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAABO The upsert record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABO")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABO")
|
|
}
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAABP"
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorAliasUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 51
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) Code() int {
|
|
return 51
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) Description() string {
|
|
return "The update record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAABP The update record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABP")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABP")
|
|
}
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAABQ"
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorAliasDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 52
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) Code() int {
|
|
return 52
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) Description() string {
|
|
return "The delete record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAABQ The delete record operation for actor alias failed."
|
|
}
|
|
|
|
func (e ActorAliasDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABQ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABQ")
|
|
}
|
|
}
|
|
|
|
func (e InvalidActorAliasError) Error() string {
|
|
return "TAVDATAAAAAABR"
|
|
}
|
|
|
|
func (e InvalidActorAliasError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidActorAliasError) Is(target error) bool {
|
|
t, ok := target.(InvalidActorAliasError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 53
|
|
}
|
|
|
|
func (e InvalidActorAliasError) Code() int {
|
|
return 53
|
|
}
|
|
|
|
func (e InvalidActorAliasError) Description() string {
|
|
return "The actor alias is invalid."
|
|
}
|
|
|
|
func (e InvalidActorAliasError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidActorAliasError) String() string {
|
|
return "TAVDATAAAAAABR The actor alias is invalid."
|
|
}
|
|
|
|
func (e InvalidActorAliasError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABR")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABR")
|
|
}
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) Error() string {
|
|
return "TAVDATAAAAAABS"
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ActorAliasNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 54
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) Code() int {
|
|
return 54
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) Description() string {
|
|
return "The actor alias was not found."
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) String() string {
|
|
return "TAVDATAAAAAABS The actor alias was not found."
|
|
}
|
|
|
|
func (e ActorAliasNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABS")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABS")
|
|
}
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAABT"
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorKeyQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 55
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) Code() int {
|
|
return 55
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) Description() string {
|
|
return "The actor key query failed."
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) String() string {
|
|
return "TAVDATAAAAAABT The actor key query failed."
|
|
}
|
|
|
|
func (e ActorKeyQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABT")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABT")
|
|
}
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) Error() string {
|
|
return "TAVDATAAAAAABU"
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorKeySelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 56
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) Code() int {
|
|
return 56
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) Description() string {
|
|
return "The select record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) String() string {
|
|
return "TAVDATAAAAAABU The select record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeySelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABU")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABU")
|
|
}
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAABV"
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorKeyInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 57
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) Code() int {
|
|
return 57
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) Description() string {
|
|
return "The insert record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) String() string {
|
|
return "TAVDATAAAAAABV The insert record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABV")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABV")
|
|
}
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAABW"
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorKeyUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 58
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) Code() int {
|
|
return 58
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) Description() string {
|
|
return "The upsert record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAABW The upsert record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABW")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABW")
|
|
}
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAABX"
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorKeyUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 59
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) Code() int {
|
|
return 59
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) Description() string {
|
|
return "The update record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAABX The update record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABX")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABX")
|
|
}
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAABY"
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ActorKeyDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 60
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) Code() int {
|
|
return 60
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) Description() string {
|
|
return "The delete record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAABY The delete record operation for actor key failed."
|
|
}
|
|
|
|
func (e ActorKeyDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABY")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABY")
|
|
}
|
|
}
|
|
|
|
func (e InvalidActorKeyError) Error() string {
|
|
return "TAVDATAAAAAABZ"
|
|
}
|
|
|
|
func (e InvalidActorKeyError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidActorKeyError) Is(target error) bool {
|
|
t, ok := target.(InvalidActorKeyError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 61
|
|
}
|
|
|
|
func (e InvalidActorKeyError) Code() int {
|
|
return 61
|
|
}
|
|
|
|
func (e InvalidActorKeyError) Description() string {
|
|
return "The actor key is invalid."
|
|
}
|
|
|
|
func (e InvalidActorKeyError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidActorKeyError) String() string {
|
|
return "TAVDATAAAAAABZ The actor key is invalid."
|
|
}
|
|
|
|
func (e InvalidActorKeyError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAABZ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAABZ")
|
|
}
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) Error() string {
|
|
return "TAVDATAAAAAAB0"
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ActorKeyNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 62
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) Code() int {
|
|
return 62
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) Description() string {
|
|
return "The actor key was not found."
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) String() string {
|
|
return "TAVDATAAAAAAB0 The actor key was not found."
|
|
}
|
|
|
|
func (e ActorKeyNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB0")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB0")
|
|
}
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAB1"
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(NetworkRelationshipQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 63
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) Code() int {
|
|
return 63
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) Description() string {
|
|
return "The network relationship query failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAB1 The network relationship query failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB1")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB1")
|
|
}
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAAB2"
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(NetworkRelationshipSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 64
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) Code() int {
|
|
return 64
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) Description() string {
|
|
return "The select record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) String() string {
|
|
return "TAVDATAAAAAAB2 The select record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB2")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB2")
|
|
}
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAB3"
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(NetworkRelationshipInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 65
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) Code() int {
|
|
return 65
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) Description() string {
|
|
return "The insert record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) String() string {
|
|
return "TAVDATAAAAAAB3 The insert record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB3")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB3")
|
|
}
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAB4"
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(NetworkRelationshipUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 66
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) Code() int {
|
|
return 66
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) Description() string {
|
|
return "The upsert record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAAB4 The upsert record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB4")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB4")
|
|
}
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAAB5"
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(NetworkRelationshipUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 67
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) Code() int {
|
|
return 67
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) Description() string {
|
|
return "The update record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAAB5 The update record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB5")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB5")
|
|
}
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAAB6"
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(NetworkRelationshipDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 68
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) Code() int {
|
|
return 68
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) Description() string {
|
|
return "The delete record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAAB6 The delete record operation for network relationship failed."
|
|
}
|
|
|
|
func (e NetworkRelationshipDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB6")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB6")
|
|
}
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) Error() string {
|
|
return "TAVDATAAAAAAB7"
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) Is(target error) bool {
|
|
t, ok := target.(InvalidNetworkRelationshipError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 69
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) Code() int {
|
|
return 69
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) Description() string {
|
|
return "The network relationship is invalid."
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) String() string {
|
|
return "TAVDATAAAAAAB7 The network relationship is invalid."
|
|
}
|
|
|
|
func (e InvalidNetworkRelationshipError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB7")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB7")
|
|
}
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) Error() string {
|
|
return "TAVDATAAAAAAB8"
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) Is(target error) bool {
|
|
t, ok := target.(NetworkRelationshipNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 70
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) Code() int {
|
|
return 70
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) Description() string {
|
|
return "The network relationship was not found."
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) String() string {
|
|
return "TAVDATAAAAAAB8 The network relationship was not found."
|
|
}
|
|
|
|
func (e NetworkRelationshipNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB8")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB8")
|
|
}
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAB9"
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 71
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) Code() int {
|
|
return 71
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) Description() string {
|
|
return "The object query failed."
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAB9 The object query failed."
|
|
}
|
|
|
|
func (e ObjectQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAB9")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAB9")
|
|
}
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAACA"
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 72
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) Code() int {
|
|
return 72
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) Description() string {
|
|
return "The select record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) String() string {
|
|
return "TAVDATAAAAAACA The select record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACA")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACA")
|
|
}
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAACB"
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 73
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) Code() int {
|
|
return 73
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) Description() string {
|
|
return "The insert record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) String() string {
|
|
return "TAVDATAAAAAACB The insert record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACB")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACB")
|
|
}
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAACC"
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 74
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) Code() int {
|
|
return 74
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) Description() string {
|
|
return "The upsert record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAACC The upsert record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACC")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACC")
|
|
}
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAACD"
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 75
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) Code() int {
|
|
return 75
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) Description() string {
|
|
return "The update record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAACD The update record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACD")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACD")
|
|
}
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAACE"
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 76
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) Code() int {
|
|
return 76
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) Description() string {
|
|
return "The delete record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAACE The delete record operation for object failed."
|
|
}
|
|
|
|
func (e ObjectDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACE")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACE")
|
|
}
|
|
}
|
|
|
|
func (e InvalidObjectError) Error() string {
|
|
return "TAVDATAAAAAACF"
|
|
}
|
|
|
|
func (e InvalidObjectError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidObjectError) Is(target error) bool {
|
|
t, ok := target.(InvalidObjectError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 77
|
|
}
|
|
|
|
func (e InvalidObjectError) Code() int {
|
|
return 77
|
|
}
|
|
|
|
func (e InvalidObjectError) Description() string {
|
|
return "The object is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidObjectError) String() string {
|
|
return "TAVDATAAAAAACF The object is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACF")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACF")
|
|
}
|
|
}
|
|
|
|
func (e ObjectNotFoundError) Error() string {
|
|
return "TAVDATAAAAAACG"
|
|
}
|
|
|
|
func (e ObjectNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ObjectNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 78
|
|
}
|
|
|
|
func (e ObjectNotFoundError) Code() int {
|
|
return 78
|
|
}
|
|
|
|
func (e ObjectNotFoundError) Description() string {
|
|
return "The object was not found."
|
|
}
|
|
|
|
func (e ObjectNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectNotFoundError) String() string {
|
|
return "TAVDATAAAAAACG The object was not found."
|
|
}
|
|
|
|
func (e ObjectNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACG")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACG")
|
|
}
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAACH"
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectEventQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 79
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) Code() int {
|
|
return 79
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) Description() string {
|
|
return "The object event query failed."
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) String() string {
|
|
return "TAVDATAAAAAACH The object event query failed."
|
|
}
|
|
|
|
func (e ObjectEventQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACH")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACH")
|
|
}
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAACI"
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectEventSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 80
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) Code() int {
|
|
return 80
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) Description() string {
|
|
return "The select record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) String() string {
|
|
return "TAVDATAAAAAACI The select record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACI")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACI")
|
|
}
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAACJ"
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectEventInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 81
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) Code() int {
|
|
return 81
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) Description() string {
|
|
return "The insert record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) String() string {
|
|
return "TAVDATAAAAAACJ The insert record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACJ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACJ")
|
|
}
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAACK"
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectEventUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 82
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) Code() int {
|
|
return 82
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) Description() string {
|
|
return "The upsert record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAACK The upsert record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACK")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACK")
|
|
}
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAACL"
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectEventUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 83
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) Code() int {
|
|
return 83
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) Description() string {
|
|
return "The update record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAACL The update record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACL")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACL")
|
|
}
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAACM"
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectEventDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 84
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) Code() int {
|
|
return 84
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) Description() string {
|
|
return "The delete record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAACM The delete record operation for object event failed."
|
|
}
|
|
|
|
func (e ObjectEventDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACM")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACM")
|
|
}
|
|
}
|
|
|
|
func (e InvalidObjectEventError) Error() string {
|
|
return "TAVDATAAAAAACN"
|
|
}
|
|
|
|
func (e InvalidObjectEventError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidObjectEventError) Is(target error) bool {
|
|
t, ok := target.(InvalidObjectEventError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 85
|
|
}
|
|
|
|
func (e InvalidObjectEventError) Code() int {
|
|
return 85
|
|
}
|
|
|
|
func (e InvalidObjectEventError) Description() string {
|
|
return "The object event is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectEventError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidObjectEventError) String() string {
|
|
return "TAVDATAAAAAACN The object event is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectEventError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACN")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACN")
|
|
}
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) Error() string {
|
|
return "TAVDATAAAAAACO"
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ObjectEventNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 86
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) Code() int {
|
|
return 86
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) Description() string {
|
|
return "The object event was not found."
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) String() string {
|
|
return "TAVDATAAAAAACO The object event was not found."
|
|
}
|
|
|
|
func (e ObjectEventNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACO")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACO")
|
|
}
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAACP"
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectReplyQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 87
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) Code() int {
|
|
return 87
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) Description() string {
|
|
return "The object reply query failed."
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) String() string {
|
|
return "TAVDATAAAAAACP The object reply query failed."
|
|
}
|
|
|
|
func (e ObjectReplyQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACP")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACP")
|
|
}
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) Error() string {
|
|
return "TAVDATAAAAAACQ"
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectReplySelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 88
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) Code() int {
|
|
return 88
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) Description() string {
|
|
return "The select record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) String() string {
|
|
return "TAVDATAAAAAACQ The select record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplySelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACQ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACQ")
|
|
}
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAACR"
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectReplyInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 89
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) Code() int {
|
|
return 89
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) Description() string {
|
|
return "The insert record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) String() string {
|
|
return "TAVDATAAAAAACR The insert record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACR")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACR")
|
|
}
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAACS"
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectReplyUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 90
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) Code() int {
|
|
return 90
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) Description() string {
|
|
return "The upsert record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAACS The upsert record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACS")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACS")
|
|
}
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAACT"
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectReplyUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 91
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) Code() int {
|
|
return 91
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) Description() string {
|
|
return "The update record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAACT The update record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACT")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACT")
|
|
}
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAACU"
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectReplyDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 92
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) Code() int {
|
|
return 92
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) Description() string {
|
|
return "The delete record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAACU The delete record operation for object reply failed."
|
|
}
|
|
|
|
func (e ObjectReplyDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACU")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACU")
|
|
}
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) Error() string {
|
|
return "TAVDATAAAAAACV"
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) Is(target error) bool {
|
|
t, ok := target.(InvalidObjectReplyError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 93
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) Code() int {
|
|
return 93
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) Description() string {
|
|
return "The object reply is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) String() string {
|
|
return "TAVDATAAAAAACV The object reply is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectReplyError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACV")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACV")
|
|
}
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) Error() string {
|
|
return "TAVDATAAAAAACW"
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ObjectReplyNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 94
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) Code() int {
|
|
return 94
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) Description() string {
|
|
return "The object reply was not found."
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) String() string {
|
|
return "TAVDATAAAAAACW The object reply was not found."
|
|
}
|
|
|
|
func (e ObjectReplyNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACW")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACW")
|
|
}
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAACX"
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectTagQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 95
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) Code() int {
|
|
return 95
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) Description() string {
|
|
return "The object tag query failed."
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) String() string {
|
|
return "TAVDATAAAAAACX The object tag query failed."
|
|
}
|
|
|
|
func (e ObjectTagQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACX")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACX")
|
|
}
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAACY"
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectTagSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 96
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) Code() int {
|
|
return 96
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) Description() string {
|
|
return "The select record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) String() string {
|
|
return "TAVDATAAAAAACY The select record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACY")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACY")
|
|
}
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAACZ"
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectTagInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 97
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) Code() int {
|
|
return 97
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) Description() string {
|
|
return "The insert record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) String() string {
|
|
return "TAVDATAAAAAACZ The insert record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAACZ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAACZ")
|
|
}
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAC0"
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectTagUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 98
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) Code() int {
|
|
return 98
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) Description() string {
|
|
return "The upsert record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAAC0 The upsert record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC0")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC0")
|
|
}
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAAC1"
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectTagUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 99
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) Code() int {
|
|
return 99
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) Description() string {
|
|
return "The update record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAAC1 The update record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC1")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC1")
|
|
}
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAAC2"
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectTagDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 100
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) Code() int {
|
|
return 100
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) Description() string {
|
|
return "The delete record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAAC2 The delete record operation for object tag failed."
|
|
}
|
|
|
|
func (e ObjectTagDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC2")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC2")
|
|
}
|
|
}
|
|
|
|
func (e InvalidObjectTagError) Error() string {
|
|
return "TAVDATAAAAAAC3"
|
|
}
|
|
|
|
func (e InvalidObjectTagError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidObjectTagError) Is(target error) bool {
|
|
t, ok := target.(InvalidObjectTagError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 101
|
|
}
|
|
|
|
func (e InvalidObjectTagError) Code() int {
|
|
return 101
|
|
}
|
|
|
|
func (e InvalidObjectTagError) Description() string {
|
|
return "The object tag is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectTagError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidObjectTagError) String() string {
|
|
return "TAVDATAAAAAAC3 The object tag is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectTagError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC3")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC3")
|
|
}
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) Error() string {
|
|
return "TAVDATAAAAAAC4"
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ObjectTagNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 102
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) Code() int {
|
|
return 102
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) Description() string {
|
|
return "The object tag was not found."
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) String() string {
|
|
return "TAVDATAAAAAAC4 The object tag was not found."
|
|
}
|
|
|
|
func (e ObjectTagNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC4")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC4")
|
|
}
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAAC5"
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectThreadQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 103
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) Code() int {
|
|
return 103
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) Description() string {
|
|
return "The object thread query failed."
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) String() string {
|
|
return "TAVDATAAAAAAC5 The object thread query failed."
|
|
}
|
|
|
|
func (e ObjectThreadQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC5")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC5")
|
|
}
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAAC6"
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectThreadSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 104
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) Code() int {
|
|
return 104
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) Description() string {
|
|
return "The select record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) String() string {
|
|
return "TAVDATAAAAAAC6 The select record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC6")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC6")
|
|
}
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAC7"
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectThreadInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 105
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) Code() int {
|
|
return 105
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) Description() string {
|
|
return "The insert record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) String() string {
|
|
return "TAVDATAAAAAAC7 The insert record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC7")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC7")
|
|
}
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAAC8"
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectThreadUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 106
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) Code() int {
|
|
return 106
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) Description() string {
|
|
return "The upsert record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAAC8 The upsert record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC8")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC8")
|
|
}
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAAC9"
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectThreadUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 107
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) Code() int {
|
|
return 107
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) Description() string {
|
|
return "The update record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAAC9 The update record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAC9")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAC9")
|
|
}
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAADA"
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectThreadDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 108
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) Code() int {
|
|
return 108
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) Description() string {
|
|
return "The delete record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAADA The delete record operation for object thread failed."
|
|
}
|
|
|
|
func (e ObjectThreadDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADA")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADA")
|
|
}
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) Error() string {
|
|
return "TAVDATAAAAAADB"
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) Is(target error) bool {
|
|
t, ok := target.(InvalidObjectThreadError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 109
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) Code() int {
|
|
return 109
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) Description() string {
|
|
return "The object thread is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) String() string {
|
|
return "TAVDATAAAAAADB The object thread is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectThreadError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADB")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADB")
|
|
}
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) Error() string {
|
|
return "TAVDATAAAAAADC"
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ObjectThreadNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 110
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) Code() int {
|
|
return 110
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) Description() string {
|
|
return "The object thread was not found."
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) String() string {
|
|
return "TAVDATAAAAAADC The object thread was not found."
|
|
}
|
|
|
|
func (e ObjectThreadNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADC")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADC")
|
|
}
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAADD"
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectBoostQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 111
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) Code() int {
|
|
return 111
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) Description() string {
|
|
return "The object boost query failed."
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) String() string {
|
|
return "TAVDATAAAAAADD The object boost query failed."
|
|
}
|
|
|
|
func (e ObjectBoostQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADD")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADD")
|
|
}
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAADE"
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectBoostSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 112
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) Code() int {
|
|
return 112
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) Description() string {
|
|
return "The select record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) String() string {
|
|
return "TAVDATAAAAAADE The select record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADE")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADE")
|
|
}
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAADF"
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectBoostInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 113
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) Code() int {
|
|
return 113
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) Description() string {
|
|
return "The insert record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) String() string {
|
|
return "TAVDATAAAAAADF The insert record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADF")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADF")
|
|
}
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAADG"
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectBoostUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 114
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) Code() int {
|
|
return 114
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) Description() string {
|
|
return "The upsert record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAADG The upsert record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADG")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADG")
|
|
}
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAADH"
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectBoostUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 115
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) Code() int {
|
|
return 115
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) Description() string {
|
|
return "The update record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAADH The update record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADH")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADH")
|
|
}
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAADI"
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ObjectBoostDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 116
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) Code() int {
|
|
return 116
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) Description() string {
|
|
return "The delete record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAADI The delete record operation for object boost failed."
|
|
}
|
|
|
|
func (e ObjectBoostDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADI")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADI")
|
|
}
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) Error() string {
|
|
return "TAVDATAAAAAADJ"
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) Is(target error) bool {
|
|
t, ok := target.(InvalidObjectBoostError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 117
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) Code() int {
|
|
return 117
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) Description() string {
|
|
return "The object boost is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) String() string {
|
|
return "TAVDATAAAAAADJ The object boost is invalid."
|
|
}
|
|
|
|
func (e InvalidObjectBoostError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADJ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADJ")
|
|
}
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) Error() string {
|
|
return "TAVDATAAAAAADK"
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ObjectBoostNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 118
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) Code() int {
|
|
return 118
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) Description() string {
|
|
return "The object boost was not found."
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) String() string {
|
|
return "TAVDATAAAAAADK The object boost was not found."
|
|
}
|
|
|
|
func (e ObjectBoostNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADK")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADK")
|
|
}
|
|
}
|
|
|
|
func (e ImageQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAADL"
|
|
}
|
|
|
|
func (e ImageQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 119
|
|
}
|
|
|
|
func (e ImageQueryFailedError) Code() int {
|
|
return 119
|
|
}
|
|
|
|
func (e ImageQueryFailedError) Description() string {
|
|
return "The image query failed."
|
|
}
|
|
|
|
func (e ImageQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageQueryFailedError) String() string {
|
|
return "TAVDATAAAAAADL The image query failed."
|
|
}
|
|
|
|
func (e ImageQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADL")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADL")
|
|
}
|
|
}
|
|
|
|
func (e ImageSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAADM"
|
|
}
|
|
|
|
func (e ImageSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 120
|
|
}
|
|
|
|
func (e ImageSelectFailedError) Code() int {
|
|
return 120
|
|
}
|
|
|
|
func (e ImageSelectFailedError) Description() string {
|
|
return "The select record operation for image failed."
|
|
}
|
|
|
|
func (e ImageSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageSelectFailedError) String() string {
|
|
return "TAVDATAAAAAADM The select record operation for image failed."
|
|
}
|
|
|
|
func (e ImageSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADM")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADM")
|
|
}
|
|
}
|
|
|
|
func (e ImageInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAADN"
|
|
}
|
|
|
|
func (e ImageInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 121
|
|
}
|
|
|
|
func (e ImageInsertFailedError) Code() int {
|
|
return 121
|
|
}
|
|
|
|
func (e ImageInsertFailedError) Description() string {
|
|
return "The insert record operation for image failed."
|
|
}
|
|
|
|
func (e ImageInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageInsertFailedError) String() string {
|
|
return "TAVDATAAAAAADN The insert record operation for image failed."
|
|
}
|
|
|
|
func (e ImageInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADN")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADN")
|
|
}
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAADO"
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 122
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) Code() int {
|
|
return 122
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) Description() string {
|
|
return "The upsert record operation for image failed."
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAADO The upsert record operation for image failed."
|
|
}
|
|
|
|
func (e ImageUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADO")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADO")
|
|
}
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAADP"
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 123
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) Code() int {
|
|
return 123
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) Description() string {
|
|
return "The update record operation for image failed."
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAADP The update record operation for image failed."
|
|
}
|
|
|
|
func (e ImageUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADP")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADP")
|
|
}
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAADQ"
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 124
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) Code() int {
|
|
return 124
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) Description() string {
|
|
return "The delete record operation for image failed."
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAADQ The delete record operation for image failed."
|
|
}
|
|
|
|
func (e ImageDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADQ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADQ")
|
|
}
|
|
}
|
|
|
|
func (e InvalidImageError) Error() string {
|
|
return "TAVDATAAAAAADR"
|
|
}
|
|
|
|
func (e InvalidImageError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidImageError) Is(target error) bool {
|
|
t, ok := target.(InvalidImageError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 125
|
|
}
|
|
|
|
func (e InvalidImageError) Code() int {
|
|
return 125
|
|
}
|
|
|
|
func (e InvalidImageError) Description() string {
|
|
return "The image is invalid."
|
|
}
|
|
|
|
func (e InvalidImageError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidImageError) String() string {
|
|
return "TAVDATAAAAAADR The image is invalid."
|
|
}
|
|
|
|
func (e InvalidImageError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADR")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADR")
|
|
}
|
|
}
|
|
|
|
func (e ImageNotFoundError) Error() string {
|
|
return "TAVDATAAAAAADS"
|
|
}
|
|
|
|
func (e ImageNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ImageNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 126
|
|
}
|
|
|
|
func (e ImageNotFoundError) Code() int {
|
|
return 126
|
|
}
|
|
|
|
func (e ImageNotFoundError) Description() string {
|
|
return "The image was not found."
|
|
}
|
|
|
|
func (e ImageNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageNotFoundError) String() string {
|
|
return "TAVDATAAAAAADS The image was not found."
|
|
}
|
|
|
|
func (e ImageNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADS")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADS")
|
|
}
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) Error() string {
|
|
return "TAVDATAAAAAADT"
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageAliasQueryFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 127
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) Code() int {
|
|
return 127
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) Description() string {
|
|
return "The image alias query failed."
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) String() string {
|
|
return "TAVDATAAAAAADT The image alias query failed."
|
|
}
|
|
|
|
func (e ImageAliasQueryFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADT")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADT")
|
|
}
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) Error() string {
|
|
return "TAVDATAAAAAADU"
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageAliasSelectFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 128
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) Code() int {
|
|
return 128
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) Description() string {
|
|
return "The select record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) String() string {
|
|
return "TAVDATAAAAAADU The select record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasSelectFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADU")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADU")
|
|
}
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) Error() string {
|
|
return "TAVDATAAAAAADV"
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageAliasInsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 129
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) Code() int {
|
|
return 129
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) Description() string {
|
|
return "The insert record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) String() string {
|
|
return "TAVDATAAAAAADV The insert record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasInsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADV")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADV")
|
|
}
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) Error() string {
|
|
return "TAVDATAAAAAADW"
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageAliasUpsertFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 130
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) Code() int {
|
|
return 130
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) Description() string {
|
|
return "The upsert record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) String() string {
|
|
return "TAVDATAAAAAADW The upsert record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasUpsertFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADW")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADW")
|
|
}
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) Error() string {
|
|
return "TAVDATAAAAAADX"
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageAliasUpdateFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 131
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) Code() int {
|
|
return 131
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) Description() string {
|
|
return "The update record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) String() string {
|
|
return "TAVDATAAAAAADX The update record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasUpdateFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADX")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADX")
|
|
}
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) Error() string {
|
|
return "TAVDATAAAAAADY"
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) Is(target error) bool {
|
|
t, ok := target.(ImageAliasDeleteFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 132
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) Code() int {
|
|
return 132
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) Description() string {
|
|
return "The delete record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) String() string {
|
|
return "TAVDATAAAAAADY The delete record operation for image alias failed."
|
|
}
|
|
|
|
func (e ImageAliasDeleteFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADY")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADY")
|
|
}
|
|
}
|
|
|
|
func (e InvalidImageAliasError) Error() string {
|
|
return "TAVDATAAAAAADZ"
|
|
}
|
|
|
|
func (e InvalidImageAliasError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidImageAliasError) Is(target error) bool {
|
|
t, ok := target.(InvalidImageAliasError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 133
|
|
}
|
|
|
|
func (e InvalidImageAliasError) Code() int {
|
|
return 133
|
|
}
|
|
|
|
func (e InvalidImageAliasError) Description() string {
|
|
return "The image alias is invalid."
|
|
}
|
|
|
|
func (e InvalidImageAliasError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e InvalidImageAliasError) String() string {
|
|
return "TAVDATAAAAAADZ The image alias is invalid."
|
|
}
|
|
|
|
func (e InvalidImageAliasError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAADZ")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAADZ")
|
|
}
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) Error() string {
|
|
return "TAVDATAAAAAAD0"
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) Is(target error) bool {
|
|
t, ok := target.(ImageAliasNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVDAT" && t.Code() == 134
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) Code() int {
|
|
return 134
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) Description() string {
|
|
return "The image alias was not found."
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) Prefix() string {
|
|
return "TAVDAT"
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) String() string {
|
|
return "TAVDATAAAAAAD0 The image alias was not found."
|
|
}
|
|
|
|
func (e ImageAliasNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVDATAAAAAAD0")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVDATAAAAAAD0")
|
|
}
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) Error() string {
|
|
return "TAVWEBAAAAAAAB"
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) Is(target error) bool {
|
|
t, ok := target.(InvalidEmailVerificationError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 1
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) Code() int {
|
|
return 1
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) Description() string {
|
|
return "Invalid verification."
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) String() string {
|
|
return "TAVWEBAAAAAAAB Invalid verification."
|
|
}
|
|
|
|
func (e InvalidEmailVerificationError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAB")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAB")
|
|
}
|
|
}
|
|
|
|
func (e CannotSaveSessionError) Error() string {
|
|
return "TAVWEBAAAAAAAC"
|
|
}
|
|
|
|
func (e CannotSaveSessionError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e CannotSaveSessionError) Is(target error) bool {
|
|
t, ok := target.(CannotSaveSessionError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 2
|
|
}
|
|
|
|
func (e CannotSaveSessionError) Code() int {
|
|
return 2
|
|
}
|
|
|
|
func (e CannotSaveSessionError) Description() string {
|
|
return "Cannot save session."
|
|
}
|
|
|
|
func (e CannotSaveSessionError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e CannotSaveSessionError) String() string {
|
|
return "TAVWEBAAAAAAAC Cannot save session."
|
|
}
|
|
|
|
func (e CannotSaveSessionError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAC")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAC")
|
|
}
|
|
}
|
|
|
|
func (e InvalidCaptchaError) Error() string {
|
|
return "TAVWEBAAAAAAAD"
|
|
}
|
|
|
|
func (e InvalidCaptchaError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidCaptchaError) Is(target error) bool {
|
|
t, ok := target.(InvalidCaptchaError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 3
|
|
}
|
|
|
|
func (e InvalidCaptchaError) Code() int {
|
|
return 3
|
|
}
|
|
|
|
func (e InvalidCaptchaError) Description() string {
|
|
return "Invalid captcha."
|
|
}
|
|
|
|
func (e InvalidCaptchaError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e InvalidCaptchaError) String() string {
|
|
return "TAVWEBAAAAAAAD Invalid captcha."
|
|
}
|
|
|
|
func (e InvalidCaptchaError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAD")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAD")
|
|
}
|
|
}
|
|
|
|
func (e EmailSendFailedError) Error() string {
|
|
return "TAVWEBAAAAAAAE"
|
|
}
|
|
|
|
func (e EmailSendFailedError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e EmailSendFailedError) Is(target error) bool {
|
|
t, ok := target.(EmailSendFailedError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 4
|
|
}
|
|
|
|
func (e EmailSendFailedError) Code() int {
|
|
return 4
|
|
}
|
|
|
|
func (e EmailSendFailedError) Description() string {
|
|
return "Unable to send email."
|
|
}
|
|
|
|
func (e EmailSendFailedError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e EmailSendFailedError) String() string {
|
|
return "TAVWEBAAAAAAAE Unable to send email."
|
|
}
|
|
|
|
func (e EmailSendFailedError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAE")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAE")
|
|
}
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) Error() string {
|
|
return "TAVWEBAAAAAAAF"
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) Is(target error) bool {
|
|
t, ok := target.(AuthenticationRequiredError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 5
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) Code() int {
|
|
return 5
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) Description() string {
|
|
return "Authentication required"
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) String() string {
|
|
return "TAVWEBAAAAAAAF Authentication required"
|
|
}
|
|
|
|
func (e AuthenticationRequiredError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAF")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAF")
|
|
}
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) Error() string {
|
|
return "TAVWEBAAAAAAAG"
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) Is(target error) bool {
|
|
t, ok := target.(TranslatorNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 6
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) Code() int {
|
|
return 6
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) Description() string {
|
|
return "Translator not found # Used when the underlying translation system isn't found."
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) String() string {
|
|
return "TAVWEBAAAAAAAG Translator not found # Used when the underlying translation system isn't found."
|
|
}
|
|
|
|
func (e TranslatorNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAG")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAG")
|
|
}
|
|
}
|
|
|
|
func (e TranslationNotFoundError) Error() string {
|
|
return "TAVWEBAAAAAAAH"
|
|
}
|
|
|
|
func (e TranslationNotFoundError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e TranslationNotFoundError) Is(target error) bool {
|
|
t, ok := target.(TranslationNotFoundError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 7
|
|
}
|
|
|
|
func (e TranslationNotFoundError) Code() int {
|
|
return 7
|
|
}
|
|
|
|
func (e TranslationNotFoundError) Description() string {
|
|
return "Translation not found"
|
|
}
|
|
|
|
func (e TranslationNotFoundError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e TranslationNotFoundError) String() string {
|
|
return "TAVWEBAAAAAAAH Translation not found"
|
|
}
|
|
|
|
func (e TranslationNotFoundError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAH")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAH")
|
|
}
|
|
}
|
|
|
|
func (e InvalidUserIDError) Error() string {
|
|
return "TAVWEBAAAAAAAI"
|
|
}
|
|
|
|
func (e InvalidUserIDError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
func (e InvalidUserIDError) Is(target error) bool {
|
|
t, ok := target.(InvalidUserIDError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return t.Prefix() == "TAVWEB" && t.Code() == 8
|
|
}
|
|
|
|
func (e InvalidUserIDError) Code() int {
|
|
return 8
|
|
}
|
|
|
|
func (e InvalidUserIDError) Description() string {
|
|
return "The user id is invalid."
|
|
}
|
|
|
|
func (e InvalidUserIDError) Prefix() string {
|
|
return "TAVWEB"
|
|
}
|
|
|
|
func (e InvalidUserIDError) String() string {
|
|
return "TAVWEBAAAAAAAI The user id is invalid."
|
|
}
|
|
|
|
func (e InvalidUserIDError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
fmt.Fprintf(s, "%+v", e.Unwrap())
|
|
e.Stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, "TAVWEBAAAAAAAI")
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", "TAVWEBAAAAAAAI")
|
|
}
|
|
}
|
|
|
|
|
|
// Frame represents a program counter inside a stack frame.
|
|
// For historical reasons if Frame is interpreted as a uintptr
|
|
// its value represents the program counter + 1.
|
|
type Frame uintptr
|
|
|
|
// pc returns the program counter for this frame;
|
|
// multiple frames may have the same PC value.
|
|
func (f Frame) pc() uintptr { return uintptr(f) - 1 }
|
|
|
|
// file returns the full path to the file that contains the
|
|
// function for this Frame's pc.
|
|
func (f Frame) file() string {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return "unknown"
|
|
}
|
|
file, _ := fn.FileLine(f.pc())
|
|
return file
|
|
}
|
|
|
|
// line returns the line number of source code of the
|
|
// function for this Frame's pc.
|
|
func (f Frame) line() int {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return 0
|
|
}
|
|
_, line := fn.FileLine(f.pc())
|
|
return line
|
|
}
|
|
|
|
// name returns the name of this function, if known.
|
|
func (f Frame) name() string {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return "unknown"
|
|
}
|
|
return fn.Name()
|
|
}
|
|
|
|
// Format formats the frame according to the fmt.Formatter interface.
|
|
//
|
|
// %s source file
|
|
// %d source line
|
|
// %n function name
|
|
// %v equivalent to %s:%d
|
|
//
|
|
// Format accepts flags that alter the printing of some verbs, as follows:
|
|
//
|
|
// %+s function name and path of source file relative to the compile time
|
|
// GOPATH separated by \n\t (<funcname>\n\t<path>)
|
|
// %+v equivalent to %+s:%d
|
|
func (f Frame) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 's':
|
|
switch {
|
|
case s.Flag('+'):
|
|
io.WriteString(s, f.name())
|
|
io.WriteString(s, "\n\t")
|
|
io.WriteString(s, f.file())
|
|
default:
|
|
io.WriteString(s, path.Base(f.file()))
|
|
}
|
|
case 'd':
|
|
io.WriteString(s, strconv.Itoa(f.line()))
|
|
case 'n':
|
|
io.WriteString(s, funcname(f.name()))
|
|
case 'v':
|
|
f.Format(s, 's')
|
|
io.WriteString(s, ":")
|
|
f.Format(s, 'd')
|
|
}
|
|
}
|
|
|
|
// MarshalText formats a stacktrace Frame as a text string. The output is the
|
|
// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
|
|
func (f Frame) MarshalText() ([]byte, error) {
|
|
name := f.name()
|
|
if name == "unknown" {
|
|
return []byte(name), nil
|
|
}
|
|
return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
|
|
}
|
|
|
|
// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
|
|
type StackTrace []Frame
|
|
|
|
|
|
// Format formats the stack of Frames according to the fmt.Formatter interface.
|
|
//
|
|
// %s lists source files for each Frame in the stack
|
|
// %v lists the source file and line number for each Frame in the stack
|
|
//
|
|
// Format accepts flags that alter the printing of some verbs, as follows:
|
|
//
|
|
// %+v Prints filename, function, and line number for each Frame in the stack.
|
|
func (st StackTrace) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
switch {
|
|
case s.Flag('+'):
|
|
for _, f := range st {
|
|
io.WriteString(s, "\n")
|
|
f.Format(s, verb)
|
|
}
|
|
case s.Flag('#'):
|
|
fmt.Fprintf(s, "%#v", []Frame(st))
|
|
default:
|
|
st.formatSlice(s, verb)
|
|
}
|
|
case 's':
|
|
st.formatSlice(s, verb)
|
|
}
|
|
}
|
|
|
|
// formatSlice will format this StackTrace into the given buffer as a slice of
|
|
// Frame, only valid when called with '%s' or '%v'.
|
|
func (st StackTrace) formatSlice(s fmt.State, verb rune) {
|
|
io.WriteString(s, "[")
|
|
for i, f := range st {
|
|
if i > 0 {
|
|
io.WriteString(s, " ")
|
|
}
|
|
f.Format(s, verb)
|
|
}
|
|
io.WriteString(s, "]")
|
|
}
|
|
|
|
// stack represents a stack of program counters.
|
|
type stack []uintptr
|
|
|
|
func (s *stack) Format(st fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
switch {
|
|
case st.Flag('+'):
|
|
for _, pc := range *s {
|
|
f := Frame(pc)
|
|
fmt.Fprintf(st, "\n%+v", f)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *stack) StackTrace() StackTrace {
|
|
f := make([]Frame, len(*s))
|
|
for i := 0; i < len(f); i++ {
|
|
f[i] = Frame((*s)[i])
|
|
}
|
|
return f
|
|
}
|
|
|
|
func callers() *stack {
|
|
const depth = 32
|
|
var pcs [depth]uintptr
|
|
n := runtime.Callers(3, pcs[:])
|
|
var st stack = pcs[0:n]
|
|
return &st
|
|
}
|
|
|
|
// funcname removes the path prefix component of a function's name reported by func.Name().
|
|
func funcname(name string) string {
|
|
i := strings.LastIndex(name, "/")
|
|
name = name[i+1:]
|
|
i = strings.Index(name, ".")
|
|
return name[i+1:]
|
|
}
|
|
|
|
func ErrorChain(err error) []string {
|
|
var results []string
|
|
if err == nil {
|
|
return results
|
|
}
|
|
depth := 0
|
|
next := err
|
|
for {
|
|
if depth > 10 {
|
|
break
|
|
}
|
|
results = append(results, next.Error())
|
|
|
|
next = go_errors.Unwrap(next)
|
|
if next == nil {
|
|
break
|
|
}
|
|
|
|
depth = depth + 1
|
|
}
|
|
return results
|
|
}
|