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.