id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c500 | {
s.HasFlaggedResources = &v
return s
} | |
c501 | float64) *TrustedAdvisorCostOptimizingSummary {
s.EstimatedMonthlySavings = &v
return s
} | |
c502 | float64) *TrustedAdvisorCostOptimizingSummary {
s.EstimatedPercentMonthlySavings = &v
return s
} | |
c503 | bool) *TrustedAdvisorResourceDetail {
s.IsSuppressed = &v
return s
} | |
c504 | int64) *TrustedAdvisorResourcesSummary {
s.ResourcesFlagged = &v
return s
} | |
c505 | int64) *TrustedAdvisorResourcesSummary {
s.ResourcesIgnored = &v
return s
} | |
c506 | int64) *TrustedAdvisorResourcesSummary {
s.ResourcesProcessed = &v
return s
} | |
c507 | int64) *TrustedAdvisorResourcesSummary {
s.ResourcesSuppressed = &v
return s
} | |
c508 | code:\n%s", err.Error(), buf))
}
return string(formatted)
} | |
c509 | {
return strings.ToUpper(s)
}
return strings.ToUpper(s[0:1]) + s[1:]
} | |
c510 | _ := xmlutil.XMLToStruct(d, nil)
e := xml.NewEncoder(&buf)
xmlutil.StructToXML(e, root, true)
return buf.String()
} | |
c511 | "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)
}
} | |
c512 | s.ForceDeleteWithoutRecovery = &v
return s
} | |
c513 | s.RecoveryWindowInDays = &v
return s
} | |
c514 | *DescribeSecretOutput {
s.VersionIdsToStages = v
return s
} | |
c515 | {
s.ExcludeCharacters = &v
return s
} | |
c516 | bool) *GetRandomPasswordInput {
s.ExcludeLowercase = &v
return s
} | |
c517 | {
s.ExcludeNumbers = &v
return s
} | |
c518 | bool) *GetRandomPasswordInput {
s.ExcludePunctuation = &v
return s
} | |
c519 | bool) *GetRandomPasswordInput {
s.ExcludeUppercase = &v
return s
} | |
c520 | {
s.IncludeSpace = &v
return s
} | |
c521 | {
s.PasswordLength = &v
return s
} | |
c522 | s.RequireEachIncludedType = &v
return s
} | |
c523 | {
s.RandomPassword = &v
return s
} | |
c524 | {
s.IncludeDeprecated = &v
return s
} | |
c525 | *ListSecretsOutput {
s.SecretList = v
return s
} | |
c526 | s.AutomaticallyAfterDays = &v
return s
} | |
c527 | *SecretListEntry {
s.SecretVersionsToStages = v
return s
} | |
c528 | string) *UpdateSecretVersionStageInput {
s.MoveToVersionId = &v
return s
} | |
c529 | string) *UpdateSecretVersionStageInput {
s.RemoveFromVersionId = &v
return s
} | |
c530 | s.AuthorizationToken = &v
return s
} | |
c531 | s.ProxyEndpoint = &v
return s
} | |
c532 | s.AcceptedMediaTypes = v
return s
} | |
c533 | []*ImageDetail) *DescribeImagesOutput {
s.ImageDetails = v
return s
} | |
c534 | []*string) *GetAuthorizationTokenInput {
s.RegistryIds = v
return s
} | |
c535 | []*AuthorizationData) *GetAuthorizationTokenOutput {
s.AuthorizationData = v
return s
} | |
c536 | *GetLifecyclePolicyPreviewOutput {
s.PreviewResults = v
return s
} | |
c537 | s.ImageSizeInBytes = &v
return s
} | |
c538 | s.LayerAvailability = &v
return s
} | |
c539 | s.LayerSize = &v
return s
} | |
c540 | int64) *LifecyclePolicyPreviewResult {
s.AppliedRulePriority = &v
return s
} | |
c541 | {
s.ExpiringImageTotalCount = &v
return s
} | |
c542 | s.RepositoryArn = &v
return s
} | |
c543 | s.RepositoryUri = &v
return s
} | |
c544 | {
s.LayerPartBlob = v
return s
} | |
c545 | {
s.PartFirstByte = &v
return s
} | |
c546 | {
s.PartLastByte = &v
return s
} | |
c547 | int64) *UploadLayerPartOutput {
s.LastByteReceived = &v
return s
} | |
c548 |
err = parse(reflect.ValueOf(v), c, "")
if err != nil {
if err == io.EOF {
return nil
}
return err
}
}
}
return nil
}
return nil
} | |
c549 | 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)
}
} | |
c550 |
// 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
} | |
c551 | 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
} | |
c552 |
parseMapEntry(r, entry, tag)
}
} else { // this element is itself an entry
parseMapEntry(r, node, tag)
}
return nil
} | |
c553 | keyR := reflect.ValueOf(key.Text)
value := values[i]
valueR := reflect.New(r.Type().Elem()).Elem()
parse(valueR, value, "")
r.SetMapIndex(keyR, valueR)
}
}
return nil
} | |
c554 | 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
} | |
c555 | UnmarshalError: h.UnmarshalError.copy(),
UnmarshalMeta: h.UnmarshalMeta.copy(),
Retry: h.Retry.copy(),
AfterRetry: h.AfterRetry.copy(),
CompleteAttempt: h.CompleteAttempt.copy(),
Complete: h.Complete.copy(),
}
} | |
c556 |
h.ValidateResponse.Clear()
h.Retry.Clear()
h.AfterRetry.Clear()
h.CompleteAttempt.Clear()
h.Complete.Clear()
} | |
c557 | append(make([]NamedHandler, 0, len(l.list)), l.list...)
return n
} | |
c558 | == 0 {
l.list = make([]NamedHandler, 0, 5)
}
l.list = append(l.list, n)
} | |
c559 | = 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
}
} | |
c560 | 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--
}
}
} | |
c561 | n.Name {
l.list[i].Fn = n.Fn
swapped = true
}
}
return swapped
} | |
c562 | i := 0; i < len(l.list); i++ {
if l.list[i].Name == name {
l.list[i] = replace
swapped = true
}
}
return swapped
} | |
c563 | {
if !l.SwapNamed(n) {
l.PushBackNamed(n)
}
} | |
c564 | {
if !l.SwapNamed(n) {
l.PushFrontNamed(n)
}
} | |
c565 |
Index: i, Handler: h, Request: r,
}
if l.AfterEachFn != nil && !l.AfterEachFn(item) {
return
}
}
} | |
c566 |
return true
}
item.Request.Config.Logger.Log("DEBUG: RequestHandler",
item.Index, item.Handler.Name, item.Request.Error)
return true
} | |
c567 | *Request) {
AddToUserAgent(r, s)
})
}
} | |
c568 | buildXML(params, e, false)
} | |
c569 |
value = value.Elem()
}
return value
} | |
c570 |
}
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)
}
} | |
c571 | 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
} | |
c572 | := 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
} | |
c573 | }
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
} | |
c574 | c.WaitUntilIdentityExistsWithContext(aws.BackgroundContext(), input)
} | |
c575 | c.WaitUntilDistributionDeployedWithContext(aws.BackgroundContext(), input)
} | |
c576 | c.WaitUntilInvalidationCompletedWithContext(aws.BackgroundContext(), input)
} | |
c577 | c.WaitUntilStreamingDistributionDeployedWithContext(aws.BackgroundContext(), input)
} | |
c578 | c.WaitUntilAppExistsWithContext(aws.BackgroundContext(), input)
} | |
c579 | c.WaitUntilDeploymentSuccessfulWithContext(aws.BackgroundContext(), input)
} | |
c580 | c.WaitUntilInstanceOnlineWithContext(aws.BackgroundContext(), input)
} | |
c581 | c.WaitUntilInstanceRegisteredWithContext(aws.BackgroundContext(), input)
} | |
c582 | c.WaitUntilInstanceTerminatedWithContext(aws.BackgroundContext(), input)
} | |
c583 | *SharedDirectory) *AcceptSharedDirectoryOutput {
s.SharedDirectory = v
return s
} | |
c584 | {
s.IpRoutes = v
return s
} | |
c585 | s.UpdateSecurityGroupForDirectoryControllers = &v
return s
} | |
c586 | s.ComputerId = &v
return s
} | |
c587 | string) *ConditionalForwarder {
s.ReplicationScope = &v
return s
} | |
c588 | *Computer) *CreateComputerOutput {
s.Computer = v
return s
} | |
c589 | s.ConditionalForwarderIpAddrs = v
return s
} | |
c590 | s.TrustPassword = &v
return s
} | |
c591 | s.DeleteAssociatedConditionalForwarder = &v
return s
} | |
c592 | []*string) *DescribeConditionalForwardersInput {
s.RemoteDomainNames = v
return s
} | |
c593 | []*ConditionalForwarder) *DescribeConditionalForwardersOutput {
s.ConditionalForwarders = v
return s
} | |
c594 | []*DirectoryDescription) *DescribeDirectoriesOutput {
s.DirectoryDescriptions = v
return s
} | |
c595 | []*string) *DescribeDomainControllersInput {
s.DomainControllerIds = v
return s
} | |
c596 | []*string) *DescribeEventTopicsInput {
s.TopicNames = v
return s
} | |
c597 | []*EventTopic) *DescribeEventTopicsOutput {
s.EventTopics = v
return s
} | |
c598 | []*string) *DescribeSharedDirectoriesInput {
s.SharedDirectoryIds = v
return s
} | |
c599 | []*SharedDirectory) *DescribeSharedDirectoriesOutput {
s.SharedDirectories = v
return s
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.