_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q2100
|
SetDropFrameTimecode
|
train
|
func (s *VideoDescription) SetDropFrameTimecode(v string) *VideoDescription {
s.DropFrameTimecode = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2101
|
SetRespondToAfd
|
train
|
func (s *VideoDescription) SetRespondToAfd(v string) *VideoDescription {
s.RespondToAfd = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2102
|
SetScalingBehavior
|
train
|
func (s *VideoDescription) SetScalingBehavior(v string) *VideoDescription {
s.ScalingBehavior = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2103
|
SetVideoPreprocessors
|
train
|
func (s *VideoDescription) SetVideoPreprocessors(v *VideoPreprocessor) *VideoDescription {
s.VideoPreprocessors = v
return s
}
|
go
|
{
"resource": ""
}
|
q2104
|
SetHeightInPx
|
train
|
func (s *VideoDetail) SetHeightInPx(v int64) *VideoDetail {
s.HeightInPx = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2105
|
SetWidthInPx
|
train
|
func (s *VideoDetail) SetWidthInPx(v int64) *VideoDetail {
s.WidthInPx = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2106
|
SetColorCorrector
|
train
|
func (s *VideoPreprocessor) SetColorCorrector(v *ColorCorrector) *VideoPreprocessor {
s.ColorCorrector = v
return s
}
|
go
|
{
"resource": ""
}
|
q2107
|
SetDeinterlacer
|
train
|
func (s *VideoPreprocessor) SetDeinterlacer(v *Deinterlacer) *VideoPreprocessor {
s.Deinterlacer = v
return s
}
|
go
|
{
"resource": ""
}
|
q2108
|
SetNoiseReducer
|
train
|
func (s *VideoPreprocessor) SetNoiseReducer(v *NoiseReducer) *VideoPreprocessor {
s.NoiseReducer = v
return s
}
|
go
|
{
"resource": ""
}
|
q2109
|
SetTimecodeBurnin
|
train
|
func (s *VideoPreprocessor) SetTimecodeBurnin(v *TimecodeBurnin) *VideoPreprocessor {
s.TimecodeBurnin = v
return s
}
|
go
|
{
"resource": ""
}
|
q2110
|
SetColorSpace
|
train
|
func (s *VideoSelector) SetColorSpace(v string) *VideoSelector {
s.ColorSpace = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2111
|
SetColorSpaceUsage
|
train
|
func (s *VideoSelector) SetColorSpaceUsage(v string) *VideoSelector {
s.ColorSpaceUsage = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2112
|
WaitUntilStreamExists
|
train
|
func (c *Kinesis) WaitUntilStreamExists(input *DescribeStreamInput) error {
return c.WaitUntilStreamExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2113
|
WaitUntilStreamNotExists
|
train
|
func (c *Kinesis) WaitUntilStreamNotExists(input *DescribeStreamInput) error {
return c.WaitUntilStreamNotExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2114
|
Read
|
train
|
func (r *timeoutReadCloser) Read(b []byte) (int, error) {
timer := time.NewTimer(r.duration)
c := make(chan readResult, 1)
go func() {
n, err := r.reader.Read(b)
timer.Stop()
c <- readResult{n: n, err: err}
}()
select {
case data := <-c:
return data.n, data.err
case <-timer.C:
return 0, timeoutErr
}
}
|
go
|
{
"resource": ""
}
|
q2115
|
adaptToResponseTimeoutError
|
train
|
func adaptToResponseTimeoutError(req *Request) {
if err, ok := req.Error.(awserr.Error); ok {
aerr, ok := err.OrigErr().(awserr.Error)
if ok && aerr.Code() == ErrCodeResponseTimeout {
req.Error = aerr
}
}
}
|
go
|
{
"resource": ""
}
|
q2116
|
WaitUntilVaultExists
|
train
|
func (c *Glacier) WaitUntilVaultExists(input *DescribeVaultInput) error {
return c.WaitUntilVaultExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2117
|
WaitUntilVaultNotExists
|
train
|
func (c *Glacier) WaitUntilVaultNotExists(input *DescribeVaultInput) error {
return c.WaitUntilVaultNotExistsWithContext(aws.BackgroundContext(), input)
}
|
go
|
{
"resource": ""
}
|
q2118
|
EqualExprKey
|
train
|
func EqualExprKey(ast AST) string {
children := ast.GetChildren()
if len(children) == 0 || ast.Kind != ASTKindEqualExpr {
return ""
}
return string(children[0].Root.Raw())
}
|
go
|
{
"resource": ""
}
|
q2119
|
presignURL
|
train
|
func presignURL(r *request.Request, sourceRegion *string, newParams interface{}) *string {
cfg := r.Config.Copy(aws.NewConfig().
WithEndpoint("").
WithRegion(aws.StringValue(sourceRegion)))
clientInfo := r.ClientInfo
resolved, err := r.Config.EndpointResolver.EndpointFor(
clientInfo.ServiceName, aws.StringValue(cfg.Region),
func(opt *endpoints.Options) {
opt.DisableSSL = aws.BoolValue(cfg.DisableSSL)
opt.UseDualStack = aws.BoolValue(cfg.UseDualStack)
},
)
if err != nil {
r.Error = err
return nil
}
clientInfo.Endpoint = resolved.URL
clientInfo.SigningRegion = resolved.SigningRegion
// Presign a request with modified params
req := request.New(*cfg, clientInfo, r.Handlers, r.Retryer, r.Operation, newParams, r.Data)
req.Operation.HTTPMethod = "GET"
uri, err := req.Presign(5 * time.Minute) // 5 minutes should be enough.
if err != nil { // bubble error back up to original request
r.Error = err
return nil
}
// We have our URL, set it on params
return &uri
}
|
go
|
{
"resource": ""
}
|
q2120
|
LogDebug
|
train
|
func LogDebug(w io.Writer) {
var initialized bool
initDebugLoggerOnce.Do(func() {
debugLogger = &logger{
w: w,
}
initialized = true
})
if !initialized && debugLogger != nil {
panic("LogDebug called multiple times. Can only be called once")
}
}
|
go
|
{
"resource": ""
}
|
q2121
|
Logf
|
train
|
func (l *logger) Logf(format string, args ...interface{}) {
if l == nil {
return
}
fmt.Fprintf(l.w, format+"\n", args...)
}
|
go
|
{
"resource": ""
}
|
q2122
|
Logln
|
train
|
func (l *logger) Logln(args ...interface{}) {
if l == nil {
return
}
fmt.Fprintln(l.w, args...)
}
|
go
|
{
"resource": ""
}
|
q2123
|
BuildShape
|
train
|
func (b ShapeValueBuilder) BuildShape(ref *ShapeRef, shapes map[string]interface{}, isMap bool) string {
order := make([]string, len(shapes))
for k := range shapes {
order = append(order, k)
}
sort.Strings(order)
ret := ""
for _, name := range order {
if name == "" {
continue
}
shape := shapes[name]
// If the shape isn't a map, we want to export the value, since every field
// defined in our shapes are exported.
if len(name) > 0 && !isMap && strings.ToLower(name[0:1]) == name[0:1] {
name = strings.Title(name)
}
memName := name
passRef := ref.Shape.MemberRefs[name]
if isMap {
memName = fmt.Sprintf("%q", memName)
passRef = &ref.Shape.ValueRef
}
switch v := shape.(type) {
case map[string]interface{}:
ret += b.BuildComplex(name, memName, passRef, v)
case []interface{}:
ret += b.BuildList(name, memName, passRef, v)
default:
ret += b.BuildScalar(name, memName, passRef, v, ref.Shape.Payload == name)
}
}
return ret
}
|
go
|
{
"resource": ""
}
|
q2124
|
BuildList
|
train
|
func (b ShapeValueBuilder) BuildList(name, memName string, ref *ShapeRef, v []interface{}) string {
ret := ""
if len(v) == 0 || ref == nil {
return ""
}
passRef := &ref.Shape.MemberRef
ret += fmt.Sprintf("%s: %s {\n", memName, b.GoType(ref, false))
ret += b.buildListElements(passRef, v)
ret += "},\n"
return ret
}
|
go
|
{
"resource": ""
}
|
q2125
|
BuildScalar
|
train
|
func (b ShapeValueBuilder) BuildScalar(name, memName string, ref *ShapeRef, shape interface{}, isPayload bool) string {
if ref == nil || ref.Shape == nil {
return ""
}
switch v := shape.(type) {
case bool:
return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%t", v))
case int:
if ref.Shape.Type == "timestamp" {
return parseTimeString(ref, memName, fmt.Sprintf("%d", v))
}
return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%d", v))
case float64:
dataType := ref.Shape.Type
if dataType == "integer" || dataType == "int64" || dataType == "long" {
return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%d", int(shape.(float64))))
}
return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%f", v))
case string:
t := ref.Shape.Type
switch t {
case "timestamp":
return parseTimeString(ref, memName, fmt.Sprintf("%s", v))
case "blob":
if (ref.Streaming || ref.Shape.Streaming) && isPayload {
return fmt.Sprintf("%s: aws.ReadSeekCloser(strings.NewReader(%q)),\n", memName, v)
}
return fmt.Sprintf("%s: []byte(%q),\n", memName, v)
default:
return convertToCorrectType(memName, t, v)
}
default:
panic(fmt.Errorf("Unsupported scalar type: %v", reflect.TypeOf(v)))
}
}
|
go
|
{
"resource": ""
}
|
q2126
|
BuildComplex
|
train
|
func (b ShapeValueBuilder) BuildComplex(name, memName string, ref *ShapeRef, v map[string]interface{}) string {
switch ref.Shape.Type {
case "structure":
return fmt.Sprintf(`%s: &%s{
%s
},
`, memName, b.GoType(ref, true), b.BuildShape(ref, v, false))
case "map":
return fmt.Sprintf(`%s: %s{
%s
},
`, name, b.GoType(ref, false), b.BuildShape(ref, v, true))
default:
panic(fmt.Sprintf("Expected complex type but received %q", ref.Shape.Type))
}
}
|
go
|
{
"resource": ""
}
|
q2127
|
GoType
|
train
|
func (b ShapeValueBuilder) GoType(ref *ShapeRef, elem bool) string {
if ref.Shape.Type != "structure" && ref.Shape.Type != "list" && ref.Shape.Type != "map" {
// Scalars are always pointers.
return ref.GoTypeWithPkgName()
}
prefix := ""
if ref.Shape.Type == "list" {
ref = &ref.Shape.MemberRef
prefix = "[]"
}
if elem {
return prefix + ref.Shape.GoTypeWithPkgNameElem()
}
return prefix + ref.GoTypeWithPkgName()
}
|
go
|
{
"resource": ""
}
|
q2128
|
SetFragmentLengthInMilliseconds
|
train
|
func (s *Fragment) SetFragmentLengthInMilliseconds(v int64) *Fragment {
s.FragmentLengthInMilliseconds = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2129
|
SetFragmentNumber
|
train
|
func (s *Fragment) SetFragmentNumber(v string) *Fragment {
s.FragmentNumber = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2130
|
SetFragmentSizeInBytes
|
train
|
func (s *Fragment) SetFragmentSizeInBytes(v int64) *Fragment {
s.FragmentSizeInBytes = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2131
|
SetProducerTimestamp
|
train
|
func (s *Fragment) SetProducerTimestamp(v time.Time) *Fragment {
s.ProducerTimestamp = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2132
|
SetServerTimestamp
|
train
|
func (s *Fragment) SetServerTimestamp(v time.Time) *Fragment {
s.ServerTimestamp = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2133
|
SetContainerFormat
|
train
|
func (s *GetHLSStreamingSessionURLInput) SetContainerFormat(v string) *GetHLSStreamingSessionURLInput {
s.ContainerFormat = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2134
|
SetDiscontinuityMode
|
train
|
func (s *GetHLSStreamingSessionURLInput) SetDiscontinuityMode(v string) *GetHLSStreamingSessionURLInput {
s.DiscontinuityMode = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2135
|
SetDisplayFragmentTimestamp
|
train
|
func (s *GetHLSStreamingSessionURLInput) SetDisplayFragmentTimestamp(v string) *GetHLSStreamingSessionURLInput {
s.DisplayFragmentTimestamp = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2136
|
SetHLSFragmentSelector
|
train
|
func (s *GetHLSStreamingSessionURLInput) SetHLSFragmentSelector(v *HLSFragmentSelector) *GetHLSStreamingSessionURLInput {
s.HLSFragmentSelector = v
return s
}
|
go
|
{
"resource": ""
}
|
q2137
|
SetMaxMediaPlaylistFragmentResults
|
train
|
func (s *GetHLSStreamingSessionURLInput) SetMaxMediaPlaylistFragmentResults(v int64) *GetHLSStreamingSessionURLInput {
s.MaxMediaPlaylistFragmentResults = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2138
|
SetPlaybackMode
|
train
|
func (s *GetHLSStreamingSessionURLInput) SetPlaybackMode(v string) *GetHLSStreamingSessionURLInput {
s.PlaybackMode = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2139
|
SetHLSStreamingSessionURL
|
train
|
func (s *GetHLSStreamingSessionURLOutput) SetHLSStreamingSessionURL(v string) *GetHLSStreamingSessionURLOutput {
s.HLSStreamingSessionURL = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2140
|
SetFragmentSelector
|
train
|
func (s *ListFragmentsInput) SetFragmentSelector(v *FragmentSelector) *ListFragmentsInput {
s.FragmentSelector = v
return s
}
|
go
|
{
"resource": ""
}
|
q2141
|
SetBudgetLimit
|
train
|
func (s *Budget) SetBudgetLimit(v *Spend) *Budget {
s.BudgetLimit = v
return s
}
|
go
|
{
"resource": ""
}
|
q2142
|
SetCalculatedSpend
|
train
|
func (s *Budget) SetCalculatedSpend(v *CalculatedSpend) *Budget {
s.CalculatedSpend = v
return s
}
|
go
|
{
"resource": ""
}
|
q2143
|
SetBudgetedAndActualAmountsList
|
train
|
func (s *BudgetPerformanceHistory) SetBudgetedAndActualAmountsList(v []*BudgetedAndActualAmounts) *BudgetPerformanceHistory {
s.BudgetedAndActualAmountsList = v
return s
}
|
go
|
{
"resource": ""
}
|
q2144
|
SetActualAmount
|
train
|
func (s *BudgetedAndActualAmounts) SetActualAmount(v *Spend) *BudgetedAndActualAmounts {
s.ActualAmount = v
return s
}
|
go
|
{
"resource": ""
}
|
q2145
|
SetBudgetedAmount
|
train
|
func (s *BudgetedAndActualAmounts) SetBudgetedAmount(v *Spend) *BudgetedAndActualAmounts {
s.BudgetedAmount = v
return s
}
|
go
|
{
"resource": ""
}
|
q2146
|
SetActualSpend
|
train
|
func (s *CalculatedSpend) SetActualSpend(v *Spend) *CalculatedSpend {
s.ActualSpend = v
return s
}
|
go
|
{
"resource": ""
}
|
q2147
|
SetForecastedSpend
|
train
|
func (s *CalculatedSpend) SetForecastedSpend(v *Spend) *CalculatedSpend {
s.ForecastedSpend = v
return s
}
|
go
|
{
"resource": ""
}
|
q2148
|
SetIncludeCredit
|
train
|
func (s *CostTypes) SetIncludeCredit(v bool) *CostTypes {
s.IncludeCredit = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2149
|
SetIncludeDiscount
|
train
|
func (s *CostTypes) SetIncludeDiscount(v bool) *CostTypes {
s.IncludeDiscount = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2150
|
SetIncludeOtherSubscription
|
train
|
func (s *CostTypes) SetIncludeOtherSubscription(v bool) *CostTypes {
s.IncludeOtherSubscription = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2151
|
SetIncludeRecurring
|
train
|
func (s *CostTypes) SetIncludeRecurring(v bool) *CostTypes {
s.IncludeRecurring = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2152
|
SetIncludeRefund
|
train
|
func (s *CostTypes) SetIncludeRefund(v bool) *CostTypes {
s.IncludeRefund = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2153
|
SetIncludeSubscription
|
train
|
func (s *CostTypes) SetIncludeSubscription(v bool) *CostTypes {
s.IncludeSubscription = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2154
|
SetIncludeSupport
|
train
|
func (s *CostTypes) SetIncludeSupport(v bool) *CostTypes {
s.IncludeSupport = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2155
|
SetIncludeTax
|
train
|
func (s *CostTypes) SetIncludeTax(v bool) *CostTypes {
s.IncludeTax = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2156
|
SetIncludeUpfront
|
train
|
func (s *CostTypes) SetIncludeUpfront(v bool) *CostTypes {
s.IncludeUpfront = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2157
|
SetUseAmortized
|
train
|
func (s *CostTypes) SetUseAmortized(v bool) *CostTypes {
s.UseAmortized = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2158
|
SetUseBlended
|
train
|
func (s *CostTypes) SetUseBlended(v bool) *CostTypes {
s.UseBlended = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2159
|
SetNotificationsWithSubscribers
|
train
|
func (s *CreateBudgetInput) SetNotificationsWithSubscribers(v []*NotificationWithSubscribers) *CreateBudgetInput {
s.NotificationsWithSubscribers = v
return s
}
|
go
|
{
"resource": ""
}
|
q2160
|
SetBudgetPerformanceHistory
|
train
|
func (s *DescribeBudgetPerformanceHistoryOutput) SetBudgetPerformanceHistory(v *BudgetPerformanceHistory) *DescribeBudgetPerformanceHistoryOutput {
s.BudgetPerformanceHistory = v
return s
}
|
go
|
{
"resource": ""
}
|
q2161
|
SetNotificationState
|
train
|
func (s *Notification) SetNotificationState(v string) *Notification {
s.NotificationState = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2162
|
SetThresholdType
|
train
|
func (s *Notification) SetThresholdType(v string) *Notification {
s.ThresholdType = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2163
|
SetNewBudget
|
train
|
func (s *UpdateBudgetInput) SetNewBudget(v *Budget) *UpdateBudgetInput {
s.NewBudget = v
return s
}
|
go
|
{
"resource": ""
}
|
q2164
|
SetNewNotification
|
train
|
func (s *UpdateNotificationInput) SetNewNotification(v *Notification) *UpdateNotificationInput {
s.NewNotification = v
return s
}
|
go
|
{
"resource": ""
}
|
q2165
|
SetOldNotification
|
train
|
func (s *UpdateNotificationInput) SetOldNotification(v *Notification) *UpdateNotificationInput {
s.OldNotification = v
return s
}
|
go
|
{
"resource": ""
}
|
q2166
|
SetNewSubscriber
|
train
|
func (s *UpdateSubscriberInput) SetNewSubscriber(v *Subscriber) *UpdateSubscriberInput {
s.NewSubscriber = v
return s
}
|
go
|
{
"resource": ""
}
|
q2167
|
SetOldSubscriber
|
train
|
func (s *UpdateSubscriberInput) SetOldSubscriber(v *Subscriber) *UpdateSubscriberInput {
s.OldSubscriber = v
return s
}
|
go
|
{
"resource": ""
}
|
q2168
|
Build
|
train
|
func Build(r *request.Request) {
if r.ParamsFilled() {
v := reflect.ValueOf(r.Params).Elem()
buildLocationElements(r, v, false)
buildBody(r, v)
}
}
|
go
|
{
"resource": ""
}
|
q2169
|
BuildAsGET
|
train
|
func BuildAsGET(r *request.Request) {
if r.ParamsFilled() {
v := reflect.ValueOf(r.Params).Elem()
buildLocationElements(r, v, true)
buildBody(r, v)
}
}
|
go
|
{
"resource": ""
}
|
q2170
|
EscapePath
|
train
|
func EscapePath(path string, encodeSep bool) string {
var buf bytes.Buffer
for i := 0; i < len(path); i++ {
c := path[i]
if noEscape[c] || (c == '/' && !encodeSep) {
buf.WriteByte(c)
} else {
fmt.Fprintf(&buf, "%%%02X", c)
}
}
return buf.String()
}
|
go
|
{
"resource": ""
}
|
q2171
|
NewSyncFolderIterator
|
train
|
func NewSyncFolderIterator(path, bucket string) *SyncFolderIterator {
metadata := []fileInfo{}
filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
if !info.IsDir() {
key := strings.TrimPrefix(p, path)
metadata = append(metadata, fileInfo{key, p})
}
return nil
})
return &SyncFolderIterator{
bucket,
metadata,
nil,
}
}
|
go
|
{
"resource": ""
}
|
q2172
|
UploadObject
|
train
|
func (iter *SyncFolderIterator) UploadObject() s3manager.BatchUploadObject {
fi := iter.fileInfos[0]
iter.fileInfos = iter.fileInfos[1:]
body, err := os.Open(fi.fullpath)
if err != nil {
iter.err = err
}
extension := filepath.Ext(fi.key)
mimeType := mime.TypeByExtension(extension)
if mimeType == "" {
mimeType = "binary/octet-stream"
}
input := s3manager.UploadInput{
Bucket: &iter.bucket,
Key: &fi.key,
Body: body,
ContentType: &mimeType,
}
return s3manager.BatchUploadObject{
Object: &input,
}
}
|
go
|
{
"resource": ""
}
|
q2173
|
SetIgnorePollAlarmFailure
|
train
|
func (s *AlarmConfiguration) SetIgnorePollAlarmFailure(v bool) *AlarmConfiguration {
s.IgnorePollAlarmFailure = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2174
|
SetGitHubAccountName
|
train
|
func (s *ApplicationInfo) SetGitHubAccountName(v string) *ApplicationInfo {
s.GitHubAccountName = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2175
|
SetLinkedToGitHub
|
train
|
func (s *ApplicationInfo) SetLinkedToGitHub(v bool) *ApplicationInfo {
s.LinkedToGitHub = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2176
|
SetApplicationsInfo
|
train
|
func (s *BatchGetApplicationsOutput) SetApplicationsInfo(v []*ApplicationInfo) *BatchGetApplicationsOutput {
s.ApplicationsInfo = v
return s
}
|
go
|
{
"resource": ""
}
|
q2177
|
SetDeploymentGroupNames
|
train
|
func (s *BatchGetDeploymentGroupsInput) SetDeploymentGroupNames(v []*string) *BatchGetDeploymentGroupsInput {
s.DeploymentGroupNames = v
return s
}
|
go
|
{
"resource": ""
}
|
q2178
|
SetDeploymentGroupsInfo
|
train
|
func (s *BatchGetDeploymentGroupsOutput) SetDeploymentGroupsInfo(v []*DeploymentGroupInfo) *BatchGetDeploymentGroupsOutput {
s.DeploymentGroupsInfo = v
return s
}
|
go
|
{
"resource": ""
}
|
q2179
|
SetInstancesSummary
|
train
|
func (s *BatchGetDeploymentInstancesOutput) SetInstancesSummary(v []*InstanceSummary) *BatchGetDeploymentInstancesOutput {
s.InstancesSummary = v
return s
}
|
go
|
{
"resource": ""
}
|
q2180
|
SetDeploymentTargets
|
train
|
func (s *BatchGetDeploymentTargetsOutput) SetDeploymentTargets(v []*DeploymentTarget) *BatchGetDeploymentTargetsOutput {
s.DeploymentTargets = v
return s
}
|
go
|
{
"resource": ""
}
|
q2181
|
SetDeploymentsInfo
|
train
|
func (s *BatchGetDeploymentsOutput) SetDeploymentsInfo(v []*DeploymentInfo) *BatchGetDeploymentsOutput {
s.DeploymentsInfo = v
return s
}
|
go
|
{
"resource": ""
}
|
q2182
|
SetInstanceInfos
|
train
|
func (s *BatchGetOnPremisesInstancesOutput) SetInstanceInfos(v []*InstanceInfo) *BatchGetOnPremisesInstancesOutput {
s.InstanceInfos = v
return s
}
|
go
|
{
"resource": ""
}
|
q2183
|
SetDeploymentReadyOption
|
train
|
func (s *BlueGreenDeploymentConfiguration) SetDeploymentReadyOption(v *DeploymentReadyOption) *BlueGreenDeploymentConfiguration {
s.DeploymentReadyOption = v
return s
}
|
go
|
{
"resource": ""
}
|
q2184
|
SetGreenFleetProvisioningOption
|
train
|
func (s *BlueGreenDeploymentConfiguration) SetGreenFleetProvisioningOption(v *GreenFleetProvisioningOption) *BlueGreenDeploymentConfiguration {
s.GreenFleetProvisioningOption = v
return s
}
|
go
|
{
"resource": ""
}
|
q2185
|
SetTerminateBlueInstancesOnDeploymentSuccess
|
train
|
func (s *BlueGreenDeploymentConfiguration) SetTerminateBlueInstancesOnDeploymentSuccess(v *BlueInstanceTerminationOption) *BlueGreenDeploymentConfiguration {
s.TerminateBlueInstancesOnDeploymentSuccess = v
return s
}
|
go
|
{
"resource": ""
}
|
q2186
|
SetTerminationWaitTimeInMinutes
|
train
|
func (s *BlueInstanceTerminationOption) SetTerminationWaitTimeInMinutes(v int64) *BlueInstanceTerminationOption {
s.TerminationWaitTimeInMinutes = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2187
|
SetDeploymentWaitType
|
train
|
func (s *ContinueDeploymentInput) SetDeploymentWaitType(v string) *ContinueDeploymentInput {
s.DeploymentWaitType = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2188
|
SetLastAttemptedDeployment
|
train
|
func (s *DeploymentGroupInfo) SetLastAttemptedDeployment(v *LastDeploymentInfo) *DeploymentGroupInfo {
s.LastAttemptedDeployment = v
return s
}
|
go
|
{
"resource": ""
}
|
q2189
|
SetLastSuccessfulDeployment
|
train
|
func (s *DeploymentGroupInfo) SetLastSuccessfulDeployment(v *LastDeploymentInfo) *DeploymentGroupInfo {
s.LastSuccessfulDeployment = v
return s
}
|
go
|
{
"resource": ""
}
|
q2190
|
SetTargetRevision
|
train
|
func (s *DeploymentGroupInfo) SetTargetRevision(v *RevisionLocation) *DeploymentGroupInfo {
s.TargetRevision = v
return s
}
|
go
|
{
"resource": ""
}
|
q2191
|
SetAdditionalDeploymentStatusInfo
|
train
|
func (s *DeploymentInfo) SetAdditionalDeploymentStatusInfo(v string) *DeploymentInfo {
s.AdditionalDeploymentStatusInfo = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2192
|
SetCreator
|
train
|
func (s *DeploymentInfo) SetCreator(v string) *DeploymentInfo {
s.Creator = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2193
|
SetDeploymentOverview
|
train
|
func (s *DeploymentInfo) SetDeploymentOverview(v *DeploymentOverview) *DeploymentInfo {
s.DeploymentOverview = v
return s
}
|
go
|
{
"resource": ""
}
|
q2194
|
SetDeploymentStatusMessages
|
train
|
func (s *DeploymentInfo) SetDeploymentStatusMessages(v []*string) *DeploymentInfo {
s.DeploymentStatusMessages = v
return s
}
|
go
|
{
"resource": ""
}
|
q2195
|
SetErrorInformation
|
train
|
func (s *DeploymentInfo) SetErrorInformation(v *ErrorInformation) *DeploymentInfo {
s.ErrorInformation = v
return s
}
|
go
|
{
"resource": ""
}
|
q2196
|
SetInstanceTerminationWaitTimeStarted
|
train
|
func (s *DeploymentInfo) SetInstanceTerminationWaitTimeStarted(v bool) *DeploymentInfo {
s.InstanceTerminationWaitTimeStarted = &v
return s
}
|
go
|
{
"resource": ""
}
|
q2197
|
SetPreviousRevision
|
train
|
func (s *DeploymentInfo) SetPreviousRevision(v *RevisionLocation) *DeploymentInfo {
s.PreviousRevision = v
return s
}
|
go
|
{
"resource": ""
}
|
q2198
|
SetRollbackInfo
|
train
|
func (s *DeploymentInfo) SetRollbackInfo(v *RollbackInfo) *DeploymentInfo {
s.RollbackInfo = v
return s
}
|
go
|
{
"resource": ""
}
|
q2199
|
SetReady
|
train
|
func (s *DeploymentOverview) SetReady(v int64) *DeploymentOverview {
s.Ready = &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.