_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q2300
|
SetViolatorCount
|
train
|
func (s *EvaluationResult) SetViolatorCount(v int64) *EvaluationResult {
s.ViolatorCount = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2301
|
SetRoleStatus
|
train
|
func (s *GetAdminAccountOutput) SetRoleStatus(v string) *GetAdminAccountOutput {
s.RoleStatus = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2302
|
SetPolicyComplianceDetail
|
train
|
func (s *GetComplianceDetailOutput) SetPolicyComplianceDetail(v *PolicyComplianceDetail) *GetComplianceDetailOutput {
s.PolicyComplianceDetail = v
return s
}
|
go
|
{
"resource": ""
}
|
q2303
|
SetAdminAccountId
|
train
|
func (s *GetProtectionStatusOutput) SetAdminAccountId(v string) *GetProtectionStatusOutput {
s.AdminAccountId = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2304
|
SetPolicyComplianceStatusList
|
train
|
func (s *ListComplianceStatusOutput) SetPolicyComplianceStatusList(v []*PolicyComplianceStatus) *ListComplianceStatusOutput {
s.PolicyComplianceStatusList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2305
|
SetPolicyList
|
train
|
func (s *ListPoliciesOutput) SetPolicyList(v []*PolicySummary) *ListPoliciesOutput {
s.PolicyList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2306
|
SetExcludeMap
|
train
|
func (s *Policy) SetExcludeMap(v map[string][]*string) *Policy {
s.ExcludeMap = v
return s
}
|
go
|
{
"resource": ""
}
|
q2307
|
SetExcludeResourceTags
|
train
|
func (s *Policy) SetExcludeResourceTags(v bool) *Policy {
s.ExcludeResourceTags = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2308
|
SetIncludeMap
|
train
|
func (s *Policy) SetIncludeMap(v map[string][]*string) *Policy {
s.IncludeMap = v
return s
}
|
go
|
{
"resource": ""
}
|
q2309
|
SetPolicyUpdateToken
|
train
|
func (s *Policy) SetPolicyUpdateToken(v string) *Policy {
s.PolicyUpdateToken = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2310
|
SetResourceTypeList
|
train
|
func (s *Policy) SetResourceTypeList(v []*string) *Policy {
s.ResourceTypeList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2311
|
SetSecurityServicePolicyData
|
train
|
func (s *Policy) SetSecurityServicePolicyData(v *SecurityServicePolicyData) *Policy {
s.SecurityServicePolicyData = v
return s
}
|
go
|
{
"resource": ""
}
|
q2312
|
SetExpiredAt
|
train
|
func (s *PolicyComplianceDetail) SetExpiredAt(v time.Time) *PolicyComplianceDetail {
s.ExpiredAt = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2313
|
SetViolators
|
train
|
func (s *PolicyComplianceDetail) SetViolators(v []*ComplianceViolator) *PolicyComplianceDetail {
s.Violators = v
return s
}
|
go
|
{
"resource": ""
}
|
q2314
|
SetSecurityServiceType
|
train
|
func (s *PolicySummary) SetSecurityServiceType(v string) *PolicySummary {
s.SecurityServiceType = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2315
|
SetManagedServiceData
|
train
|
func (s *SecurityServicePolicyData) SetManagedServiceData(v string) *SecurityServicePolicyData {
s.ManagedServiceData = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2316
|
SetClientContextEncoding
|
train
|
func (s *PutEventsInput) SetClientContextEncoding(v string) *PutEventsInput {
s.ClientContextEncoding = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2317
|
WaitUntilCertificateValidated
|
train
|
func (c *ACM) WaitUntilCertificateValidated(input *DescribeCertificateInput) error {
return c.WaitUntilCertificateValidatedWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2318
|
SetAcmCertificateArn
|
train
|
func (s *AssociateDomainInput) SetAcmCertificateArn(v string) *AssociateDomainInput {
s.AcmCertificateArn = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2319
|
SetFirstAccessedTime
|
train
|
func (s *DescribeDeviceOutput) SetFirstAccessedTime(v time.Time) *DescribeDeviceOutput {
s.FirstAccessedTime = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2320
|
SetLastAccessedTime
|
train
|
func (s *DescribeDeviceOutput) SetLastAccessedTime(v time.Time) *DescribeDeviceOutput {
s.LastAccessedTime = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2321
|
SetPatchLevel
|
train
|
func (s *DescribeDeviceOutput) SetPatchLevel(v string) *DescribeDeviceOutput {
s.PatchLevel = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2322
|
SetServiceProviderSamlMetadata
|
train
|
func (s *DescribeIdentityProviderConfigurationOutput) SetServiceProviderSamlMetadata(v string) *DescribeIdentityProviderConfigurationOutput {
s.ServiceProviderSamlMetadata = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2323
|
SetFleetSummaryList
|
train
|
func (s *ListFleetsOutput) SetFleetSummaryList(v []*FleetSummary) *ListFleetsOutput {
s.FleetSummaryList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2324
|
SetWebsiteCertificateAuthorities
|
train
|
func (s *ListWebsiteCertificateAuthoritiesOutput) SetWebsiteCertificateAuthorities(v []*WebsiteCaSummary) *ListWebsiteCertificateAuthoritiesOutput {
s.WebsiteCertificateAuthorities = v
return s
}
|
go
|
{
"resource": ""
}
|
q2325
|
Continue
|
train
|
func (b operationBlacklist) Continue(r *request.Request) bool {
for i := 0; i < len(b); i++ {
if b[i] == r.Operation.Name {
return false
}
}
return true
}
|
go
|
{
"resource": ""
}
|
q2326
|
updateEndpointForS3Config
|
train
|
func updateEndpointForS3Config(r *request.Request) {
forceHostStyle := aws.BoolValue(r.Config.S3ForcePathStyle)
accelerate := aws.BoolValue(r.Config.S3UseAccelerate)
if accelerate && accelerateOpBlacklist.Continue(r) {
if forceHostStyle {
if r.Config.Logger != nil {
r.Config.Logger.Log("ERROR: aws.Config.S3UseAccelerate is not compatible with aws.Config.S3ForcePathStyle, ignoring S3ForcePathStyle.")
}
}
updateEndpointForAccelerate(r)
} else if !forceHostStyle && r.Operation.Name != opGetBucketLocation {
updateEndpointForHostStyle(r)
}
}
|
go
|
{
"resource": ""
}
|
q2327
|
bucketNameFromReqParams
|
train
|
func bucketNameFromReqParams(params interface{}) (string, bool) {
if iface, ok := params.(bucketGetter); ok {
b := iface.getBucket()
return b, len(b) > 0
}
return "", false
}
|
go
|
{
"resource": ""
}
|
q2328
|
hostCompatibleBucketName
|
train
|
func hostCompatibleBucketName(u *url.URL, bucket string) bool {
// Bucket might be DNS compatible but dots in the hostname will fail
// certificate validation, so do not use host-style.
if u.Scheme == "https" && strings.Contains(bucket, ".") {
return false
}
// if the bucket is DNS compatible
return dnsCompatibleBucketName(bucket)
}
|
go
|
{
"resource": ""
}
|
q2329
|
dnsCompatibleBucketName
|
train
|
func dnsCompatibleBucketName(bucket string) bool {
return reDomain.MatchString(bucket) &&
!reIPAddress.MatchString(bucket) &&
!strings.Contains(bucket, "..")
}
|
go
|
{
"resource": ""
}
|
q2330
|
moveBucketToHost
|
train
|
func moveBucketToHost(u *url.URL, bucket string) {
u.Host = bucket + "." + u.Host
u.Path = strings.Replace(u.Path, "/{Bucket}", "", -1)
if u.Path == "" {
u.Path = "/"
}
}
|
go
|
{
"resource": ""
}
|
q2331
|
loadEnvConfig
|
train
|
func loadEnvConfig() envConfig {
enableSharedConfig, _ := strconv.ParseBool(os.Getenv("AWS_SDK_LOAD_CONFIG"))
return envConfigLoad(enableSharedConfig)
}
|
go
|
{
"resource": ""
}
|
q2332
|
SetIncludeCanceled
|
train
|
func (s *ListSigningProfilesInput) SetIncludeCanceled(v bool) *ListSigningProfilesInput {
s.IncludeCanceled = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2333
|
SetEncryptionAlgorithmOptions
|
train
|
func (s *SigningConfiguration) SetEncryptionAlgorithmOptions(v *EncryptionAlgorithmOptions) *SigningConfiguration {
s.EncryptionAlgorithmOptions = v
return s
}
|
go
|
{
"resource": ""
}
|
q2334
|
SetHashAlgorithmOptions
|
train
|
func (s *SigningConfiguration) SetHashAlgorithmOptions(v *HashAlgorithmOptions) *SigningConfiguration {
s.HashAlgorithmOptions = v
return s
}
|
go
|
{
"resource": ""
}
|
q2335
|
SetEncryptionAlgorithm
|
train
|
func (s *SigningConfigurationOverrides) SetEncryptionAlgorithm(v string) *SigningConfigurationOverrides {
s.EncryptionAlgorithm = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2336
|
SetDefaultFormat
|
train
|
func (s *SigningImageFormat) SetDefaultFormat(v string) *SigningImageFormat {
s.DefaultFormat = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2337
|
SetSupportedFormats
|
train
|
func (s *SigningImageFormat) SetSupportedFormats(v []*string) *SigningImageFormat {
s.SupportedFormats = v
return s
}
|
go
|
{
"resource": ""
}
|
q2338
|
WaitUntilBucketExists
|
train
|
func (c *S3) WaitUntilBucketExists(input *HeadBucketInput) error {
return c.WaitUntilBucketExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2339
|
WaitUntilBucketNotExists
|
train
|
func (c *S3) WaitUntilBucketNotExists(input *HeadBucketInput) error {
return c.WaitUntilBucketNotExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2340
|
WaitUntilObjectExists
|
train
|
func (c *S3) WaitUntilObjectExists(input *HeadObjectInput) error {
return c.WaitUntilObjectExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2341
|
WaitUntilObjectNotExists
|
train
|
func (c *S3) WaitUntilObjectNotExists(input *HeadObjectInput) error {
return c.WaitUntilObjectNotExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2342
|
Add
|
train
|
func (e *ErrInvalidParams) Add(err ErrInvalidParam) {
err.SetContext(e.Context)
e.errs = append(e.errs, err)
}
|
go
|
{
"resource": ""
}
|
q2343
|
AddNested
|
train
|
func (e *ErrInvalidParams) AddNested(nestedCtx string, nested ErrInvalidParams) {
for _, err := range nested.errs {
err.SetContext(e.Context)
err.AddNestedContext(nestedCtx)
e.errs = append(e.errs, err)
}
}
|
go
|
{
"resource": ""
}
|
q2344
|
Error
|
train
|
func (e ErrInvalidParams) Error() string {
w := &bytes.Buffer{}
fmt.Fprintf(w, "%s: %s\n", e.Code(), e.Message())
for _, err := range e.errs {
fmt.Fprintf(w, "- %s\n", err.Message())
}
return w.String()
}
|
go
|
{
"resource": ""
}
|
q2345
|
OrigErr
|
train
|
func (e ErrInvalidParams) OrigErr() error {
return awserr.NewBatchError(
InvalidParameterErrCode, e.Message(), e.OrigErrs())
}
|
go
|
{
"resource": ""
}
|
q2346
|
OrigErrs
|
train
|
func (e ErrInvalidParams) OrigErrs() []error {
errs := make([]error, len(e.errs))
for i := 0; i < len(errs); i++ {
errs[i] = e.errs[i]
}
return errs
}
|
go
|
{
"resource": ""
}
|
q2347
|
Message
|
train
|
func (e *errInvalidParam) Message() string {
return fmt.Sprintf("%s, %s.", e.msg, e.Field())
}
|
go
|
{
"resource": ""
}
|
q2348
|
Error
|
train
|
func (e *errInvalidParam) Error() string {
return fmt.Sprintf("%s: %s", e.code, e.Message())
}
|
go
|
{
"resource": ""
}
|
q2349
|
Field
|
train
|
func (e *errInvalidParam) Field() string {
field := e.context
if len(field) > 0 {
field += "."
}
if len(e.nestedContext) > 0 {
field += fmt.Sprintf("%s.", e.nestedContext)
}
field += e.field
return field
}
|
go
|
{
"resource": ""
}
|
q2350
|
AddNestedContext
|
train
|
func (e *errInvalidParam) AddNestedContext(ctx string) {
if len(e.nestedContext) == 0 {
e.nestedContext = ctx
} else {
e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext)
}
}
|
go
|
{
"resource": ""
}
|
q2351
|
NewErrParamRequired
|
train
|
func NewErrParamRequired(field string) *ErrParamRequired {
return &ErrParamRequired{
errInvalidParam{
code: ParamRequiredErrCode,
field: field,
msg: fmt.Sprintf("missing required field"),
},
}
}
|
go
|
{
"resource": ""
}
|
q2352
|
NewErrParamMinValue
|
train
|
func NewErrParamMinValue(field string, min float64) *ErrParamMinValue {
return &ErrParamMinValue{
errInvalidParam: errInvalidParam{
code: ParamMinValueErrCode,
field: field,
msg: fmt.Sprintf("minimum field value of %v", min),
},
min: min,
}
}
|
go
|
{
"resource": ""
}
|
q2353
|
NewErrParamMinLen
|
train
|
func NewErrParamMinLen(field string, min int) *ErrParamMinLen {
return &ErrParamMinLen{
errInvalidParam: errInvalidParam{
code: ParamMinLenErrCode,
field: field,
msg: fmt.Sprintf("minimum field size of %v", min),
},
min: min,
}
}
|
go
|
{
"resource": ""
}
|
q2354
|
NewErrParamMaxLen
|
train
|
func NewErrParamMaxLen(field string, max int, value string) *ErrParamMaxLen {
return &ErrParamMaxLen{
errInvalidParam: errInvalidParam{
code: ParamMaxLenErrCode,
field: field,
msg: fmt.Sprintf("maximum size of %v, %v", max, value),
},
max: max,
}
}
|
go
|
{
"resource": ""
}
|
q2355
|
NewErrParamFormat
|
train
|
func NewErrParamFormat(field string, format, value string) *ErrParamFormat {
return &ErrParamFormat{
errInvalidParam: errInvalidParam{
code: ParamFormatErrCode,
field: field,
msg: fmt.Sprintf("format %v, %v", format, value),
},
format: format,
}
}
|
go
|
{
"resource": ""
}
|
q2356
|
Append
|
train
|
func (v *Value) Append(tok Token) {
r := tok.Raw()
if v.Type != QuotedStringType {
v.Type = StringType
r = tok.raw[1 : len(tok.raw)-1]
}
if tok.Type() != TokenLit {
v.raw = append(v.raw, tok.Raw()...)
} else {
v.raw = append(v.raw, r...)
}
}
|
go
|
{
"resource": ""
}
|
q2357
|
StringValue
|
train
|
func (v Value) StringValue() string {
switch v.Type {
case StringType:
return strings.TrimFunc(string(v.raw), isTrimmable)
case QuotedStringType:
// preserve all characters in the quotes
return string(removeEscapedCharacters(v.raw[1 : len(v.raw)-1]))
default:
return strings.TrimFunc(string(v.raw), isTrimmable)
}
}
|
go
|
{
"resource": ""
}
|
q2358
|
NewClient
|
train
|
func NewClient(cfg ClientConfig) *http.Client {
tr := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: cfg.Timeouts.Connect,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: cfg.Timeouts.IdleConnection,
DisableKeepAlives: !cfg.KeepAlive,
TLSHandshakeTimeout: cfg.Timeouts.TLSHandshake,
ExpectContinueTimeout: cfg.Timeouts.ExpectContinue,
ResponseHeaderTimeout: cfg.Timeouts.ResponseHeader,
}
return &http.Client{
Transport: tr,
}
}
|
go
|
{
"resource": ""
}
|
q2359
|
SetInProgressJobs
|
train
|
func (s *GetPendingJobExecutionsOutput) SetInProgressJobs(v []*JobExecutionSummary) *GetPendingJobExecutionsOutput {
s.InProgressJobs = v
return s
}
|
go
|
{
"resource": ""
}
|
q2360
|
SetQueuedJobs
|
train
|
func (s *GetPendingJobExecutionsOutput) SetQueuedJobs(v []*JobExecutionSummary) *GetPendingJobExecutionsOutput {
s.QueuedJobs = v
return s
}
|
go
|
{
"resource": ""
}
|
q2361
|
SetIncludeJobExecutionState
|
train
|
func (s *UpdateJobExecutionInput) SetIncludeJobExecutionState(v bool) *UpdateJobExecutionInput {
s.IncludeJobExecutionState = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2362
|
SetExecutionState
|
train
|
func (s *UpdateJobExecutionOutput) SetExecutionState(v *JobExecutionState) *UpdateJobExecutionOutput {
s.ExecutionState = v
return s
}
|
go
|
{
"resource": ""
}
|
q2363
|
SetCachedMethods
|
train
|
func (s *AllowedMethods) SetCachedMethods(v *CachedMethods) *AllowedMethods {
s.CachedMethods = v
return s
}
|
go
|
{
"resource": ""
}
|
q2364
|
SetPathPattern
|
train
|
func (s *CacheBehavior) SetPathPattern(v string) *CacheBehavior {
s.PathPattern = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2365
|
SetContentTypeProfiles
|
train
|
func (s *ContentTypeProfileConfig) SetContentTypeProfiles(v *ContentTypeProfiles) *ContentTypeProfileConfig {
s.ContentTypeProfiles = v
return s
}
|
go
|
{
"resource": ""
}
|
q2366
|
SetForwardWhenContentTypeIsUnknown
|
train
|
func (s *ContentTypeProfileConfig) SetForwardWhenContentTypeIsUnknown(v bool) *ContentTypeProfileConfig {
s.ForwardWhenContentTypeIsUnknown = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2367
|
SetForward
|
train
|
func (s *CookiePreference) SetForward(v string) *CookiePreference {
s.Forward = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2368
|
SetWhitelistedNames
|
train
|
func (s *CookiePreference) SetWhitelistedNames(v *CookieNames) *CookiePreference {
s.WhitelistedNames = v
return s
}
|
go
|
{
"resource": ""
}
|
q2369
|
SetDistributionConfigWithTags
|
train
|
func (s *CreateDistributionWithTagsInput) SetDistributionConfigWithTags(v *DistributionConfigWithTags) *CreateDistributionWithTagsInput {
s.DistributionConfigWithTags = v
return s
}
|
go
|
{
"resource": ""
}
|
q2370
|
SetStreamingDistributionConfigWithTags
|
train
|
func (s *CreateStreamingDistributionWithTagsInput) SetStreamingDistributionConfigWithTags(v *StreamingDistributionConfigWithTags) *CreateStreamingDistributionWithTagsInput {
s.StreamingDistributionConfigWithTags = v
return s
}
|
go
|
{
"resource": ""
}
|
q2371
|
SetErrorCachingMinTTL
|
train
|
func (s *CustomErrorResponse) SetErrorCachingMinTTL(v int64) *CustomErrorResponse {
s.ErrorCachingMinTTL = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2372
|
SetResponsePagePath
|
train
|
func (s *CustomErrorResponse) SetResponsePagePath(v string) *CustomErrorResponse {
s.ResponsePagePath = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2373
|
SetHTTPPort
|
train
|
func (s *CustomOriginConfig) SetHTTPPort(v int64) *CustomOriginConfig {
s.HTTPPort = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2374
|
SetHTTPSPort
|
train
|
func (s *CustomOriginConfig) SetHTTPSPort(v int64) *CustomOriginConfig {
s.HTTPSPort = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2375
|
SetOriginKeepaliveTimeout
|
train
|
func (s *CustomOriginConfig) SetOriginKeepaliveTimeout(v int64) *CustomOriginConfig {
s.OriginKeepaliveTimeout = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2376
|
SetOriginProtocolPolicy
|
train
|
func (s *CustomOriginConfig) SetOriginProtocolPolicy(v string) *CustomOriginConfig {
s.OriginProtocolPolicy = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2377
|
SetOriginReadTimeout
|
train
|
func (s *CustomOriginConfig) SetOriginReadTimeout(v int64) *CustomOriginConfig {
s.OriginReadTimeout = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2378
|
SetOriginSslProtocols
|
train
|
func (s *CustomOriginConfig) SetOriginSslProtocols(v *OriginSslProtocols) *CustomOriginConfig {
s.OriginSslProtocols = v
return s
}
|
go
|
{
"resource": ""
}
|
q2379
|
SetInProgressInvalidationBatches
|
train
|
func (s *Distribution) SetInProgressInvalidationBatches(v int64) *Distribution {
s.InProgressInvalidationBatches = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2380
|
SetDefaultRootObject
|
train
|
func (s *DistributionConfig) SetDefaultRootObject(v string) *DistributionConfig {
s.DefaultRootObject = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2381
|
SetFieldPatterns
|
train
|
func (s *EncryptionEntity) SetFieldPatterns(v *FieldPatterns) *EncryptionEntity {
s.FieldPatterns = v
return s
}
|
go
|
{
"resource": ""
}
|
q2382
|
SetPublicKeyId
|
train
|
func (s *EncryptionEntity) SetPublicKeyId(v string) *EncryptionEntity {
s.PublicKeyId = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2383
|
SetCookies
|
train
|
func (s *ForwardedValues) SetCookies(v *CookiePreference) *ForwardedValues {
s.Cookies = v
return s
}
|
go
|
{
"resource": ""
}
|
q2384
|
SetQueryStringCacheKeys
|
train
|
func (s *ForwardedValues) SetQueryStringCacheKeys(v *QueryStringCacheKeys) *ForwardedValues {
s.QueryStringCacheKeys = v
return s
}
|
go
|
{
"resource": ""
}
|
q2385
|
SetRestrictionType
|
train
|
func (s *GeoRestriction) SetRestrictionType(v string) *GeoRestriction {
s.RestrictionType = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2386
|
SetPaths
|
train
|
func (s *InvalidationBatch) SetPaths(v *Paths) *InvalidationBatch {
s.Paths = v
return s
}
|
go
|
{
"resource": ""
}
|
q2387
|
SetIncludeBody
|
train
|
func (s *LambdaFunctionAssociation) SetIncludeBody(v bool) *LambdaFunctionAssociation {
s.IncludeBody = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2388
|
SetLambdaFunctionARN
|
train
|
func (s *LambdaFunctionAssociation) SetLambdaFunctionARN(v string) *LambdaFunctionAssociation {
s.LambdaFunctionARN = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2389
|
SetCloudFrontOriginAccessIdentityList
|
train
|
func (s *ListCloudFrontOriginAccessIdentitiesOutput) SetCloudFrontOriginAccessIdentityList(v *OriginAccessIdentityList) *ListCloudFrontOriginAccessIdentitiesOutput {
s.CloudFrontOriginAccessIdentityList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2390
|
SetFieldLevelEncryptionList
|
train
|
func (s *ListFieldLevelEncryptionConfigsOutput) SetFieldLevelEncryptionList(v *FieldLevelEncryptionList) *ListFieldLevelEncryptionConfigsOutput {
s.FieldLevelEncryptionList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2391
|
SetFieldLevelEncryptionProfileList
|
train
|
func (s *ListFieldLevelEncryptionProfilesOutput) SetFieldLevelEncryptionProfileList(v *FieldLevelEncryptionProfileList) *ListFieldLevelEncryptionProfilesOutput {
s.FieldLevelEncryptionProfileList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2392
|
SetInvalidationList
|
train
|
func (s *ListInvalidationsOutput) SetInvalidationList(v *InvalidationList) *ListInvalidationsOutput {
s.InvalidationList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2393
|
SetStreamingDistributionList
|
train
|
func (s *ListStreamingDistributionsOutput) SetStreamingDistributionList(v *StreamingDistributionList) *ListStreamingDistributionsOutput {
s.StreamingDistributionList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2394
|
SetIncludeCookies
|
train
|
func (s *LoggingConfig) SetIncludeCookies(v bool) *LoggingConfig {
s.IncludeCookies = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2395
|
SetCustomHeaders
|
train
|
func (s *Origin) SetCustomHeaders(v *CustomHeaders) *Origin {
s.CustomHeaders = v
return s
}
|
go
|
{
"resource": ""
}
|
q2396
|
SetCustomOriginConfig
|
train
|
func (s *Origin) SetCustomOriginConfig(v *CustomOriginConfig) *Origin {
s.CustomOriginConfig = v
return s
}
|
go
|
{
"resource": ""
}
|
q2397
|
SetOriginPath
|
train
|
func (s *Origin) SetOriginPath(v string) *Origin {
s.OriginPath = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2398
|
SetS3OriginConfig
|
train
|
func (s *Origin) SetS3OriginConfig(v *S3OriginConfig) *Origin {
s.S3OriginConfig = v
return s
}
|
go
|
{
"resource": ""
}
|
q2399
|
SetFailoverCriteria
|
train
|
func (s *OriginGroup) SetFailoverCriteria(v *OriginGroupFailoverCriteria) *OriginGroup {
s.FailoverCriteria = v
return s
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.