Datasets:

CoIR-Retrieval

/

CodeSearchNet-go-queries-corpus

like 1

Follow

CoIR 6

q500

SetHasFlaggedResources

train

func (s *TrustedAdvisorCheckSummary) SetHasFlaggedResources(v bool) *TrustedAdvisorCheckSummary { s.HasFlaggedResources = &v return s }

go

q501

SetEstimatedMonthlySavings

train

func (s *TrustedAdvisorCostOptimizingSummary) SetEstimatedMonthlySavings(v float64) *TrustedAdvisorCostOptimizingSummary { s.EstimatedMonthlySavings = &v return s }

go

q502

SetEstimatedPercentMonthlySavings

train

func (s *TrustedAdvisorCostOptimizingSummary) SetEstimatedPercentMonthlySavings(v float64) *TrustedAdvisorCostOptimizingSummary { s.EstimatedPercentMonthlySavings = &v return s }

go

q503

SetIsSuppressed

train

func (s *TrustedAdvisorResourceDetail) SetIsSuppressed(v bool) *TrustedAdvisorResourceDetail { s.IsSuppressed = &v return s }

go

q504

SetResourcesFlagged

train

func (s *TrustedAdvisorResourcesSummary) SetResourcesFlagged(v int64) *TrustedAdvisorResourcesSummary { s.ResourcesFlagged = &v return s }

go

q505

SetResourcesIgnored

train

func (s *TrustedAdvisorResourcesSummary) SetResourcesIgnored(v int64) *TrustedAdvisorResourcesSummary { s.ResourcesIgnored = &v return s }

go

q506

SetResourcesProcessed

train

func (s *TrustedAdvisorResourcesSummary) SetResourcesProcessed(v int64) *TrustedAdvisorResourcesSummary { s.ResourcesProcessed = &v return s }

go

q507

SetResourcesSuppressed

train

func (s *TrustedAdvisorResourcesSummary) SetResourcesSuppressed(v int64) *TrustedAdvisorResourcesSummary { s.ResourcesSuppressed = &v return s }

go

q508

GoFmt

train

func GoFmt(buf string) string { formatted, err := format.Source([]byte(buf)) if err != nil { panic(fmt.Errorf("%s\nOriginal code:\n%s", err.Error(), buf)) } return string(formatted) }

go

q509

Capitalize

train

func Capitalize(s string) string { if len(s) == 1 { return strings.ToUpper(s) } return strings.ToUpper(s[0:1]) + s[1:] }

go

q510

SortXML

train

func SortXML(r io.Reader) string { var buf bytes.Buffer d := xml.NewDecoder(r) root, _ := xmlutil.XMLToStruct(d, nil) e := xml.NewEncoder(&buf) xmlutil.StructToXML(e, root, true) return buf.String() }

go

q511

PrettyPrint

train

func PrettyPrint(v interface{}) string { value := reflect.ValueOf(v) switch value.Kind() { case reflect.Struct: str := fullName(value.Type()) + "{\n" for i := 0; i < value.NumField(); i++ { l := string(value.Type().Field(i).Name[0]) if strings.ToUpper(l) == l { str += value.Type().Field(i).Name + ": " str += PrettyPrint(value.Field(i).Interface()) str += ",\n" } } str += "}" return str case reflect.Map: str := "map[" + fullName(value.Type().Key()) + "]" + fullName(value.Type().Elem()) + "{\n" for _, k := range value.MapKeys() { str += "\"" + k.String() + "\": " str += PrettyPrint(value.MapIndex(k).Interface()) str += ",\n" } str += "}" return str case reflect.Ptr: if e := value.Elem(); e.IsValid() { return "&" + PrettyPrint(e.Interface()) } return "nil" case reflect.Slice: str := "[]" + fullName(value.Type().Elem()) + "{\n" for i := 0; i < value.Len(); i++ { str += PrettyPrint(value.Index(i).Interface()) str += ",\n" } str += "}" return str default: return fmt.Sprintf("%#v", v) } }

go

q512

SetForceDeleteWithoutRecovery

train

func (s *DeleteSecretInput) SetForceDeleteWithoutRecovery(v bool) *DeleteSecretInput { s.ForceDeleteWithoutRecovery = &v return s }

go

q513

SetRecoveryWindowInDays

train

func (s *DeleteSecretInput) SetRecoveryWindowInDays(v int64) *DeleteSecretInput { s.RecoveryWindowInDays = &v return s }

go

q514

SetVersionIdsToStages

train

func (s *DescribeSecretOutput) SetVersionIdsToStages(v map[string][]*string) *DescribeSecretOutput { s.VersionIdsToStages = v return s }

go

q515

SetExcludeCharacters

train

func (s *GetRandomPasswordInput) SetExcludeCharacters(v string) *GetRandomPasswordInput { s.ExcludeCharacters = &v return s }

go

q516

SetExcludeLowercase

train

func (s *GetRandomPasswordInput) SetExcludeLowercase(v bool) *GetRandomPasswordInput { s.ExcludeLowercase = &v return s }

go

q517

SetExcludeNumbers

train

func (s *GetRandomPasswordInput) SetExcludeNumbers(v bool) *GetRandomPasswordInput { s.ExcludeNumbers = &v return s }

go

q518

SetExcludePunctuation

train

func (s *GetRandomPasswordInput) SetExcludePunctuation(v bool) *GetRandomPasswordInput { s.ExcludePunctuation = &v return s }

go

q519

SetExcludeUppercase

train

func (s *GetRandomPasswordInput) SetExcludeUppercase(v bool) *GetRandomPasswordInput { s.ExcludeUppercase = &v return s }

go

q520

SetIncludeSpace

train

func (s *GetRandomPasswordInput) SetIncludeSpace(v bool) *GetRandomPasswordInput { s.IncludeSpace = &v return s }

go

q521

SetPasswordLength

train

func (s *GetRandomPasswordInput) SetPasswordLength(v int64) *GetRandomPasswordInput { s.PasswordLength = &v return s }

go

q522

SetRequireEachIncludedType

train

func (s *GetRandomPasswordInput) SetRequireEachIncludedType(v bool) *GetRandomPasswordInput { s.RequireEachIncludedType = &v return s }

go

q523

SetRandomPassword

train

func (s *GetRandomPasswordOutput) SetRandomPassword(v string) *GetRandomPasswordOutput { s.RandomPassword = &v return s }

go

q524

SetIncludeDeprecated

train

func (s *ListSecretVersionIdsInput) SetIncludeDeprecated(v bool) *ListSecretVersionIdsInput { s.IncludeDeprecated = &v return s }

go

q525

SetSecretList

train

func (s *ListSecretsOutput) SetSecretList(v []*SecretListEntry) *ListSecretsOutput { s.SecretList = v return s }

go

q526

SetAutomaticallyAfterDays

train

func (s *RotationRulesType) SetAutomaticallyAfterDays(v int64) *RotationRulesType { s.AutomaticallyAfterDays = &v return s }

go

q527

SetSecretVersionsToStages

train

func (s *SecretListEntry) SetSecretVersionsToStages(v map[string][]*string) *SecretListEntry { s.SecretVersionsToStages = v return s }

go

q528

SetMoveToVersionId

train

func (s *UpdateSecretVersionStageInput) SetMoveToVersionId(v string) *UpdateSecretVersionStageInput { s.MoveToVersionId = &v return s }

go

q529

SetRemoveFromVersionId

train

func (s *UpdateSecretVersionStageInput) SetRemoveFromVersionId(v string) *UpdateSecretVersionStageInput { s.RemoveFromVersionId = &v return s }

go

q530

SetAuthorizationToken

train

func (s *AuthorizationData) SetAuthorizationToken(v string) *AuthorizationData { s.AuthorizationToken = &v return s }

go

q531

SetProxyEndpoint

train

func (s *AuthorizationData) SetProxyEndpoint(v string) *AuthorizationData { s.ProxyEndpoint = &v return s }

go

q532

SetAcceptedMediaTypes

train

func (s *BatchGetImageInput) SetAcceptedMediaTypes(v []*string) *BatchGetImageInput { s.AcceptedMediaTypes = v return s }

go

q533

SetImageDetails

train

func (s *DescribeImagesOutput) SetImageDetails(v []*ImageDetail) *DescribeImagesOutput { s.ImageDetails = v return s }

go

q534

SetRegistryIds

train

func (s *GetAuthorizationTokenInput) SetRegistryIds(v []*string) *GetAuthorizationTokenInput { s.RegistryIds = v return s }

go

q535

SetAuthorizationData

train

func (s *GetAuthorizationTokenOutput) SetAuthorizationData(v []*AuthorizationData) *GetAuthorizationTokenOutput { s.AuthorizationData = v return s }

go

q536

SetPreviewResults

train

func (s *GetLifecyclePolicyPreviewOutput) SetPreviewResults(v []*LifecyclePolicyPreviewResult) *GetLifecyclePolicyPreviewOutput { s.PreviewResults = v return s }

go

q537

SetImageSizeInBytes

train

func (s *ImageDetail) SetImageSizeInBytes(v int64) *ImageDetail { s.ImageSizeInBytes = &v return s }

go

q538

SetLayerAvailability

train

func (s *Layer) SetLayerAvailability(v string) *Layer { s.LayerAvailability = &v return s }

go

q539

SetLayerSize

train

func (s *Layer) SetLayerSize(v int64) *Layer { s.LayerSize = &v return s }

go

q540

SetAppliedRulePriority

train

func (s *LifecyclePolicyPreviewResult) SetAppliedRulePriority(v int64) *LifecyclePolicyPreviewResult { s.AppliedRulePriority = &v return s }

go

q541

SetExpiringImageTotalCount

train

func (s *LifecyclePolicyPreviewSummary) SetExpiringImageTotalCount(v int64) *LifecyclePolicyPreviewSummary { s.ExpiringImageTotalCount = &v return s }

go

q542

SetRepositoryArn

train

func (s *Repository) SetRepositoryArn(v string) *Repository { s.RepositoryArn = &v return s }

go

q543

SetRepositoryUri

train

func (s *Repository) SetRepositoryUri(v string) *Repository { s.RepositoryUri = &v return s }

go

q544

SetLayerPartBlob

train

func (s *UploadLayerPartInput) SetLayerPartBlob(v []byte) *UploadLayerPartInput { s.LayerPartBlob = v return s }

go

q545

SetPartFirstByte

train

func (s *UploadLayerPartInput) SetPartFirstByte(v int64) *UploadLayerPartInput { s.PartFirstByte = &v return s }

go

q546

SetPartLastByte

train

func (s *UploadLayerPartInput) SetPartLastByte(v int64) *UploadLayerPartInput { s.PartLastByte = &v return s }

go

q547

SetLastByteReceived

train

func (s *UploadLayerPartOutput) SetLastByteReceived(v int64) *UploadLayerPartOutput { s.LastByteReceived = &v return s }

go

q548

UnmarshalXML

train

func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error { n, err := XMLToStruct(d, nil) if err != nil { return err } if n.Children != nil { for _, root := range n.Children { for _, c := range root { if wrappedChild, ok := c.Children[wrapper]; ok { c = wrappedChild[0] // pull out wrapped element } err = parse(reflect.ValueOf(v), c, "") if err != nil { if err == io.EOF { return nil } return err } } } return nil } return nil }

go

q549

parse

train

func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error { rtype := r.Type() if rtype.Kind() == reflect.Ptr { rtype = rtype.Elem() // check kind of actual element type } t := tag.Get("type") if t == "" { switch rtype.Kind() { case reflect.Struct: // also it can't be a time object if _, ok := r.Interface().(*time.Time); !ok { t = "structure" } case reflect.Slice: // also it can't be a byte slice if _, ok := r.Interface().([]byte); !ok { t = "list" } case reflect.Map: t = "map" } } switch t { case "structure": if field, ok := rtype.FieldByName("_"); ok { tag = field.Tag } return parseStruct(r, node, tag) case "list": return parseList(r, node, tag) case "map": return parseMap(r, node, tag) default: return parseScalar(r, node, tag) } }

go

q550

parseStruct

train

func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error { t := r.Type() if r.Kind() == reflect.Ptr { if r.IsNil() { // create the structure if it's nil s := reflect.New(r.Type().Elem()) r.Set(s) r = s } r = r.Elem() t = t.Elem() } // unwrap any payloads if payload := tag.Get("payload"); payload != "" { field, _ := t.FieldByName(payload) return parseStruct(r.FieldByName(payload), node, field.Tag) } for i := 0; i < t.NumField(); i++ { field := t.Field(i) if c := field.Name[0:1]; strings.ToLower(c) == c { continue // ignore unexported fields } // figure out what this field is called name := field.Name if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" { name = field.Tag.Get("locationNameList") } else if locName := field.Tag.Get("locationName"); locName != "" { name = locName } // try to find the field by name in elements elems := node.Children[name] if elems == nil { // try to find the field in attributes if val, ok := node.findElem(name); ok { elems = []*XMLNode{{Text: val}} } } member := r.FieldByName(field.Name) for _, elem := range elems { err := parse(member, elem, field.Tag) if err != nil { return err } } } return nil }

go

q551

parseList

train

func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error { t := r.Type() if tag.Get("flattened") == "" { // look at all item entries mname := "member" if name := tag.Get("locationNameList"); name != "" { mname = name } if Children, ok := node.Children[mname]; ok { if r.IsNil() { r.Set(reflect.MakeSlice(t, len(Children), len(Children))) } for i, c := range Children { err := parse(r.Index(i), c, "") if err != nil { return err } } } } else { // flattened list means this is a single element if r.IsNil() { r.Set(reflect.MakeSlice(t, 0, 0)) } childR := reflect.Zero(t.Elem()) r.Set(reflect.Append(r, childR)) err := parse(r.Index(r.Len()-1), node, "") if err != nil { return err } } return nil }

go

q552

parseMap

train

func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error { if r.IsNil() { r.Set(reflect.MakeMap(r.Type())) } if tag.Get("flattened") == "" { // look at all child entries for _, entry := range node.Children["entry"] { parseMapEntry(r, entry, tag) } } else { // this element is itself an entry parseMapEntry(r, node, tag) } return nil }

go

q553

parseMapEntry

train

func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error { kname, vname := "key", "value" if n := tag.Get("locationNameKey"); n != "" { kname = n } if n := tag.Get("locationNameValue"); n != "" { vname = n } keys, ok := node.Children[kname] values := node.Children[vname] if ok { for i, key := range keys { keyR := reflect.ValueOf(key.Text) value := values[i] valueR := reflect.New(r.Type().Elem()).Elem() parse(valueR, value, "") r.SetMapIndex(keyR, valueR) } } return nil }

go

q554

parseScalar

train

func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error { switch r.Interface().(type) { case *string: r.Set(reflect.ValueOf(&node.Text)) return nil case []byte: b, err := base64.StdEncoding.DecodeString(node.Text) if err != nil { return err } r.Set(reflect.ValueOf(b)) case *bool: v, err := strconv.ParseBool(node.Text) if err != nil { return err } r.Set(reflect.ValueOf(&v)) case *int64: v, err := strconv.ParseInt(node.Text, 10, 64) if err != nil { return err } r.Set(reflect.ValueOf(&v)) case *float64: v, err := strconv.ParseFloat(node.Text, 64) if err != nil { return err } r.Set(reflect.ValueOf(&v)) case *time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.ISO8601TimeFormatName } t, err := protocol.ParseTime(format, node.Text) if err != nil { return err } r.Set(reflect.ValueOf(&t)) default: return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type()) } return nil }

go

q555

Copy

train

func (h *Handlers) Copy() Handlers { return Handlers{ Validate: h.Validate.copy(), Build: h.Build.copy(), Sign: h.Sign.copy(), Send: h.Send.copy(), ValidateResponse: h.ValidateResponse.copy(), Unmarshal: h.Unmarshal.copy(), UnmarshalStream: h.UnmarshalStream.copy(), UnmarshalError: h.UnmarshalError.copy(), UnmarshalMeta: h.UnmarshalMeta.copy(), Retry: h.Retry.copy(), AfterRetry: h.AfterRetry.copy(), CompleteAttempt: h.CompleteAttempt.copy(), Complete: h.Complete.copy(), } }

go

q556

Clear

train

func (h *Handlers) Clear() { h.Validate.Clear() h.Build.Clear() h.Send.Clear() h.Sign.Clear() h.Unmarshal.Clear() h.UnmarshalStream.Clear() h.UnmarshalMeta.Clear() h.UnmarshalError.Clear() h.ValidateResponse.Clear() h.Retry.Clear() h.AfterRetry.Clear() h.CompleteAttempt.Clear() h.Complete.Clear() }

go

q557

copy

train

func (l *HandlerList) copy() HandlerList { n := HandlerList{ AfterEachFn: l.AfterEachFn, } if len(l.list) == 0 { return n } n.list = append(make([]NamedHandler, 0, len(l.list)), l.list...) return n }

go

q558

PushBackNamed

train

func (l *HandlerList) PushBackNamed(n NamedHandler) { if cap(l.list) == 0 { l.list = make([]NamedHandler, 0, 5) } l.list = append(l.list, n) }

go

q559

PushFrontNamed

train

func (l *HandlerList) PushFrontNamed(n NamedHandler) { if cap(l.list) == len(l.list) { // Allocating new list required l.list = append([]NamedHandler{n}, l.list...) } else { // Enough room to prepend into list. l.list = append(l.list, NamedHandler{}) copy(l.list[1:], l.list) l.list[0] = n } }

go

q560

RemoveByName

train

func (l *HandlerList) RemoveByName(name string) { for i := 0; i < len(l.list); i++ { m := l.list[i] if m.Name == name { // Shift array preventing creating new arrays copy(l.list[i:], l.list[i+1:]) l.list[len(l.list)-1] = NamedHandler{} l.list = l.list[:len(l.list)-1] // decrement list so next check to length is correct i-- } } }

go

q561

SwapNamed

train

func (l *HandlerList) SwapNamed(n NamedHandler) (swapped bool) { for i := 0; i < len(l.list); i++ { if l.list[i].Name == n.Name { l.list[i].Fn = n.Fn swapped = true } } return swapped }

go

q562

Swap

train

func (l *HandlerList) Swap(name string, replace NamedHandler) bool { var swapped bool for i := 0; i < len(l.list); i++ { if l.list[i].Name == name { l.list[i] = replace swapped = true } } return swapped }

go

q563

SetBackNamed

train

func (l *HandlerList) SetBackNamed(n NamedHandler) { if !l.SwapNamed(n) { l.PushBackNamed(n) } }

go

q564

SetFrontNamed

train

func (l *HandlerList) SetFrontNamed(n NamedHandler) { if !l.SwapNamed(n) { l.PushFrontNamed(n) } }

go

q565

Run

train

func (l *HandlerList) Run(r *Request) { for i, h := range l.list { h.Fn(r) item := HandlerListRunItem{ Index: i, Handler: h, Request: r, } if l.AfterEachFn != nil && !l.AfterEachFn(item) { return } } }

go

q566

HandlerListLogItem

train

func HandlerListLogItem(item HandlerListRunItem) bool { if item.Request.Config.Logger == nil { return true } item.Request.Config.Logger.Log("DEBUG: RequestHandler", item.Index, item.Handler.Name, item.Request.Error) return true }

go

q567

WithAppendUserAgent

train

func WithAppendUserAgent(s string) Option { return func(r *Request) { r.Handlers.Build.PushBack(func(r2 *Request) { AddToUserAgent(r, s) }) } }

go

q568

BuildXML

train

func BuildXML(params interface{}, e *xml.Encoder) error { return buildXML(params, e, false) }

go

q569

elemOf

train

func elemOf(value reflect.Value) reflect.Value { for value.Kind() == reflect.Ptr { value = value.Elem() } return value }

go

q570

buildValue

train

func (b *xmlBuilder) buildValue(value reflect.Value, current *XMLNode, tag reflect.StructTag) error { value = elemOf(value) if !value.IsValid() { // no need to handle zero values return nil } else if tag.Get("location") != "" { // don't handle non-body location values return nil } t := tag.Get("type") if t == "" { switch value.Kind() { case reflect.Struct: t = "structure" case reflect.Slice: t = "list" case reflect.Map: t = "map" } } switch t { case "structure": if field, ok := value.Type().FieldByName("_"); ok { tag = tag + reflect.StructTag(" ") + field.Tag } return b.buildStruct(value, current, tag) case "list": return b.buildList(value, current, tag) case "map": return b.buildMap(value, current, tag) default: return b.buildScalar(value, current, tag) } }

go

q571

buildStruct

train

func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag reflect.StructTag) error { if !value.IsValid() { return nil } // unwrap payloads if payload := tag.Get("payload"); payload != "" { field, _ := value.Type().FieldByName(payload) tag = field.Tag value = elemOf(value.FieldByName(payload)) if !value.IsValid() { return nil } } child := NewXMLElement(xml.Name{Local: tag.Get("locationName")}) // there is an xmlNamespace associated with this struct if prefix, uri := tag.Get("xmlPrefix"), tag.Get("xmlURI"); uri != "" { ns := xml.Attr{ Name: xml.Name{Local: "xmlns"}, Value: uri, } if prefix != "" { b.namespaces[prefix] = uri // register the namespace ns.Name.Local = "xmlns:" + prefix } child.Attr = append(child.Attr, ns) } var payloadFields, nonPayloadFields int t := value.Type() for i := 0; i < value.NumField(); i++ { member := elemOf(value.Field(i)) field := t.Field(i) if field.PkgPath != "" { continue // ignore unexported fields } if field.Tag.Get("ignore") != "" { continue } mTag := field.Tag if mTag.Get("location") != "" { // skip non-body members nonPayloadFields++ continue } payloadFields++ if protocol.CanSetIdempotencyToken(value.Field(i), field) { token := protocol.GetIdempotencyToken() member = reflect.ValueOf(token) } memberName := mTag.Get("locationName") if memberName == "" { memberName = field.Name mTag = reflect.StructTag(string(mTag) + ` locationName:"` + memberName + `"`) } if err := b.buildValue(member, child, mTag); err != nil { return err } } // Only case where the child shape is not added is if the shape only contains // non-payload fields, e.g headers/query. if !(payloadFields == 0 && nonPayloadFields > 0) { current.AddChild(child) } return nil }

go

q572

buildList

train

func (b *xmlBuilder) buildList(value reflect.Value, current *XMLNode, tag reflect.StructTag) error { if value.IsNil() { // don't build omitted lists return nil } // check for unflattened list member flattened := tag.Get("flattened") != "" xname := xml.Name{Local: tag.Get("locationName")} if flattened { for i := 0; i < value.Len(); i++ { child := NewXMLElement(xname) current.AddChild(child) if err := b.buildValue(value.Index(i), child, ""); err != nil { return err } } } else { list := NewXMLElement(xname) current.AddChild(list) for i := 0; i < value.Len(); i++ { iname := tag.Get("locationNameList") if iname == "" { iname = "member" } child := NewXMLElement(xml.Name{Local: iname}) list.AddChild(child) if err := b.buildValue(value.Index(i), child, ""); err != nil { return err } } } return nil }

go

q573

buildScalar

train

func (b *xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error { var str string switch converted := value.Interface().(type) { case string: str = converted case []byte: if !value.IsNil() { str = base64.StdEncoding.EncodeToString(converted) } case bool: str = strconv.FormatBool(converted) case int64: str = strconv.FormatInt(converted, 10) case int: str = strconv.Itoa(converted) case float64: str = strconv.FormatFloat(converted, 'f', -1, 64) case float32: str = strconv.FormatFloat(float64(converted), 'f', -1, 32) case time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.ISO8601TimeFormatName } str = protocol.FormatTime(format, converted) default: return fmt.Errorf("unsupported value for param %s: %v (%s)", tag.Get("locationName"), value.Interface(), value.Type().Name()) } xname := xml.Name{Local: tag.Get("locationName")} if tag.Get("xmlAttribute") != "" { // put into current node's attribute list attr := xml.Attr{Name: xname, Value: str} current.Attr = append(current.Attr, attr) } else { // regular text node current.AddChild(&XMLNode{Name: xname, Text: str}) } return nil }

go

q574

WaitUntilIdentityExists

train

func (c *SES) WaitUntilIdentityExists(input *GetIdentityVerificationAttributesInput) error { return c.WaitUntilIdentityExistsWithContext(aws.BackgroundContext(), input) }

go

q575

WaitUntilDistributionDeployed

train

func (c *CloudFront) WaitUntilDistributionDeployed(input *GetDistributionInput) error { return c.WaitUntilDistributionDeployedWithContext(aws.BackgroundContext(), input) }

go

q576

WaitUntilInvalidationCompleted

train

func (c *CloudFront) WaitUntilInvalidationCompleted(input *GetInvalidationInput) error { return c.WaitUntilInvalidationCompletedWithContext(aws.BackgroundContext(), input) }

go

q577

WaitUntilStreamingDistributionDeployed

train

func (c *CloudFront) WaitUntilStreamingDistributionDeployed(input *GetStreamingDistributionInput) error { return c.WaitUntilStreamingDistributionDeployedWithContext(aws.BackgroundContext(), input) }

go

q578

WaitUntilAppExists

train

func (c *OpsWorks) WaitUntilAppExists(input *DescribeAppsInput) error { return c.WaitUntilAppExistsWithContext(aws.BackgroundContext(), input) }

go

q579

WaitUntilDeploymentSuccessful

train

func (c *OpsWorks) WaitUntilDeploymentSuccessful(input *DescribeDeploymentsInput) error { return c.WaitUntilDeploymentSuccessfulWithContext(aws.BackgroundContext(), input) }

go

q580

WaitUntilInstanceOnline

train

func (c *OpsWorks) WaitUntilInstanceOnline(input *DescribeInstancesInput) error { return c.WaitUntilInstanceOnlineWithContext(aws.BackgroundContext(), input) }

go

q581

WaitUntilInstanceRegistered

train

func (c *OpsWorks) WaitUntilInstanceRegistered(input *DescribeInstancesInput) error { return c.WaitUntilInstanceRegisteredWithContext(aws.BackgroundContext(), input) }

go

q582

WaitUntilInstanceTerminated

train

func (c *OpsWorks) WaitUntilInstanceTerminated(input *DescribeInstancesInput) error { return c.WaitUntilInstanceTerminatedWithContext(aws.BackgroundContext(), input) }

go

q583

SetSharedDirectory

train

func (s *AcceptSharedDirectoryOutput) SetSharedDirectory(v *SharedDirectory) *AcceptSharedDirectoryOutput { s.SharedDirectory = v return s }

go

q584

SetIpRoutes

train

func (s *AddIpRoutesInput) SetIpRoutes(v []*IpRoute) *AddIpRoutesInput { s.IpRoutes = v return s }

go

q585

SetUpdateSecurityGroupForDirectoryControllers

train

func (s *AddIpRoutesInput) SetUpdateSecurityGroupForDirectoryControllers(v bool) *AddIpRoutesInput { s.UpdateSecurityGroupForDirectoryControllers = &v return s }

go

q586

SetComputerId

train

func (s *Computer) SetComputerId(v string) *Computer { s.ComputerId = &v return s }

go

q587

SetReplicationScope

train

func (s *ConditionalForwarder) SetReplicationScope(v string) *ConditionalForwarder { s.ReplicationScope = &v return s }

go

q588

SetComputer

train

func (s *CreateComputerOutput) SetComputer(v *Computer) *CreateComputerOutput { s.Computer = v return s }

go

q589

SetConditionalForwarderIpAddrs

train

func (s *CreateTrustInput) SetConditionalForwarderIpAddrs(v []*string) *CreateTrustInput { s.ConditionalForwarderIpAddrs = v return s }

go

q590

SetTrustPassword

train

func (s *CreateTrustInput) SetTrustPassword(v string) *CreateTrustInput { s.TrustPassword = &v return s }

go

q591

SetDeleteAssociatedConditionalForwarder

train

func (s *DeleteTrustInput) SetDeleteAssociatedConditionalForwarder(v bool) *DeleteTrustInput { s.DeleteAssociatedConditionalForwarder = &v return s }

go

q592

SetRemoteDomainNames

train

func (s *DescribeConditionalForwardersInput) SetRemoteDomainNames(v []*string) *DescribeConditionalForwardersInput { s.RemoteDomainNames = v return s }

go

q593

SetConditionalForwarders

train

func (s *DescribeConditionalForwardersOutput) SetConditionalForwarders(v []*ConditionalForwarder) *DescribeConditionalForwardersOutput { s.ConditionalForwarders = v return s }

go

q594

SetDirectoryDescriptions

train

func (s *DescribeDirectoriesOutput) SetDirectoryDescriptions(v []*DirectoryDescription) *DescribeDirectoriesOutput { s.DirectoryDescriptions = v return s }

go

q595

SetDomainControllerIds

train

func (s *DescribeDomainControllersInput) SetDomainControllerIds(v []*string) *DescribeDomainControllersInput { s.DomainControllerIds = v return s }

go

q596

SetTopicNames

train

func (s *DescribeEventTopicsInput) SetTopicNames(v []*string) *DescribeEventTopicsInput { s.TopicNames = v return s }

go

q597

SetEventTopics

train

func (s *DescribeEventTopicsOutput) SetEventTopics(v []*EventTopic) *DescribeEventTopicsOutput { s.EventTopics = v return s }

go

q598

SetSharedDirectoryIds

train

func (s *DescribeSharedDirectoriesInput) SetSharedDirectoryIds(v []*string) *DescribeSharedDirectoriesInput { s.SharedDirectoryIds = v return s }

go

q599

SetSharedDirectories

train

func (s *DescribeSharedDirectoriesOutput) SetSharedDirectories(v []*SharedDirectory) *DescribeSharedDirectoriesOutput { s.SharedDirectories = v return s }

go