id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c166900 | s.TerminologyNames = v
return s
} | |
c166901 | *TextOutput {
s.AppliedTerminologies = v
return s
} | |
c166902 | s.TranslatedText = &v
return s
} | |
c166903 | }
return strings.ToUpper(name[0:1]) + name[1:]
} | |
c166904 | c.WaitUntilJobCompleteWithContext(aws.BackgroundContext(), input)
} | |
c166905 | cfg,
ClientInfo: clientInfo,
Handlers: handlers.Copy(),
Retryer: retryer,
Time: time.Now(),
ExpireTime: 0,
Operation: operation,
HTTPRequest: httpReq,
Body: nil,
Params: params,
Error: err,
Data: data,
}
r.SetBufferBody([]byte{})
return r
} | |
c166906 | opt := range opts {
opt(r)
}
} | |
c166907 | != nil {
return r.context
}
return aws.BackgroundContext()
} | |
c166908 |
return r.Error != nil && aws.BoolValue(r.Retryable) && r.RetryCount < r.MaxRetries()
} | |
c166909 | reflect.ValueOf(r.Params).Elem().IsValid()
} | |
c166910 | reflect.ValueOf(r.Data).Elem().IsValid()
} | |
c166911 | []byte) {
r.SetReaderBody(bytes.NewReader(buf))
} | |
c166912 | string) {
r.SetReaderBody(strings.NewReader(s))
} | |
c166913 | reader.Seek(0, sdkio.SeekCurrent) // Get the Bodies current offset.
r.ResetBody()
} | |
c166914 | no way to retrieve
// the signed headers not hoisted without this. Making the presigned URL
// useless.
r.NotHoist = false
u, _, err := getPresignedURL(r, expire)
return u, err
} | |
c166915 | (string, http.Header, error) {
r = r.copy()
return getPresignedURL(r, expire)
} | |
c166916 | nil {
debugLogReqError(r, "Build Request", false, r.Error)
return r.Error
}
r.built = true
}
return r.Error
} | |
c166917 |
return r.Error
}
r.Handlers.Sign.Run(r)
return r.Error
} | |
c166918 | *r
req.Handlers = r.Handlers.Copy()
op := *r.Operation
req.Operation = &op
return req
} | |
c166919 | = curUA + " " + s
}
r.HTTPRequest.Header.Set("User-Agent", s)
} | |
c166920 | := portOnly(host)
if port != "" && isDefaultPort(r.URL.Scheme, port) {
r.Host = stripPort(host)
}
} | |
c166921 | if r.Host != "" {
return r.Host
}
return r.URL.Host
} | |
c166922 | *Flow {
s.EgressIp = &v
return s
} | |
c166923 | *ListFlowsOutput {
s.Flows = v
return s
} | |
c166924 | s.EntitlementName = &v
return s
} | |
c166925 | s.MediaLiveInputArn = &v
return s
} | |
c166926 | s.IngestIp = &v
return s
} | |
c166927 | *Entitlement) *UpdateFlowEntitlementOutput {
s.Entitlement = v
return s
} | |
c166928 | HostPrefixBuilder{
Prefix: prefix,
LabelsFn: labelsFn,
}
return request.NamedHandler{
Name: HostPrefixHandlerName,
Fn: builder.Build,
}
} | |
c166929 | prefix = strings.Replace(prefix, "{"+name+"}", value, -1)
}
r.HTTPRequest.URL.Host = prefix + r.HTTPRequest.URL.Host
if len(r.HTTPRequest.Host) > 0 {
r.HTTPRequest.Host = prefix + r.HTTPRequest.Host
}
} | |
c166930 | int64) *ActivityScheduledEventDetails {
s.HeartbeatInSeconds = &v
return s
} | |
c166931 | *HistoryEvent {
s.ActivityFailedEventDetails = v
return s
} | |
c166932 | *HistoryEvent {
s.ActivityScheduleFailedEventDetails = v
return s
} | |
c166933 | *HistoryEvent {
s.ActivityScheduledEventDetails = v
return s
} | |
c166934 | *HistoryEvent {
s.ActivityStartedEventDetails = v
return s
} | |
c166935 | *HistoryEvent {
s.ActivitySucceededEventDetails = v
return s
} | |
c166936 | *HistoryEvent {
s.ActivityTimedOutEventDetails = v
return s
} | |
c166937 | *HistoryEvent {
s.ExecutionAbortedEventDetails = v
return s
} | |
c166938 | *HistoryEvent {
s.ExecutionFailedEventDetails = v
return s
} | |
c166939 | *HistoryEvent {
s.ExecutionStartedEventDetails = v
return s
} | |
c166940 | *HistoryEvent {
s.ExecutionSucceededEventDetails = v
return s
} | |
c166941 | *HistoryEvent {
s.ExecutionTimedOutEventDetails = v
return s
} | |
c166942 | *HistoryEvent {
s.LambdaFunctionFailedEventDetails = v
return s
} | |
c166943 | *HistoryEvent {
s.LambdaFunctionScheduleFailedEventDetails = v
return s
} | |
c166944 | *HistoryEvent {
s.LambdaFunctionScheduledEventDetails = v
return s
} | |
c166945 | *HistoryEvent {
s.LambdaFunctionStartFailedEventDetails = v
return s
} | |
c166946 | *HistoryEvent {
s.LambdaFunctionSucceededEventDetails = v
return s
} | |
c166947 | *HistoryEvent {
s.LambdaFunctionTimedOutEventDetails = v
return s
} | |
c166948 | s.PreviousEventId = &v
return s
} | |
c166949 | *HistoryEvent {
s.StateEnteredEventDetails = v
return s
} | |
c166950 | *HistoryEvent {
s.StateExitedEventDetails = v
return s
} | |
c166951 | *HistoryEvent {
s.TaskFailedEventDetails = v
return s
} | |
c166952 | *HistoryEvent {
s.TaskScheduledEventDetails = v
return s
} | |
c166953 | *HistoryEvent {
s.TaskStartFailedEventDetails = v
return s
} | |
c166954 | *HistoryEvent {
s.TaskStartedEventDetails = v
return s
} | |
c166955 | *HistoryEvent {
s.TaskSubmitFailedEventDetails = v
return s
} | |
c166956 | *HistoryEvent {
s.TaskSubmittedEventDetails = v
return s
} | |
c166957 | *HistoryEvent {
s.TaskSucceededEventDetails = v
return s
} | |
c166958 | *HistoryEvent {
s.TaskTimedOutEventDetails = v
return s
} | |
c166959 | *ListExecutionsOutput {
s.Executions = v
return s
} | |
c166960 | *ListStateMachinesOutput {
s.StateMachines = v
return s
} | |
c166961 | o.InputRef.Shape.Location = o.InputRef.Location
}
if o.InputRef.Payload != "" {
o.InputRef.Shape.Payload = o.InputRef.Payload
}
if o.InputRef.XMLNamespace.Prefix != "" {
o.InputRef.Shape.XMLNamespace.Prefix = o.InputRef.XMLNamespace.Prefix
}
if o.InputRef.XMLNamespace.URI != "" {
o.InputRef.Shape.... | |
c166962 | s := range a.Shapes {
s.API = a
s.ShapeName = n
}
} | |
c166963 | reference back to API
ref.Shape = shape // resolve shape reference
if r.visited[ref] {
return
}
r.visited[ref] = true
shape.refs = append(shape.refs, ref) // register the ref
// resolve shape's references, if it has any
r.resolveShape(shape)
} | |
c166964 |
r.resolveReference(&shape.KeyRef)
r.resolveReference(&shape.ValueRef)
for _, m := range shape.MemberRefs {
r.resolveReference(m)
}
} | |
c166965 | newName := a.ExportableName(mName)
if newName != mName {
delete(s.MemberRefs, mName)
s.MemberRefs[newName] = member
// also apply locationName trait so we keep the old one
// but only if there's no locationName trait on ref or shape
if member.LocationName == "" && member.Shape.LocationName == "... | |
c166966 | if any field names collide with setters.
for name := range namesWithSet {
field := v.MemberRefs[name]
renameCollidingField(name, v, field)
}
}
} | |
c166967 | MemberRefs: map[string]*ShapeRef{},
}
a.Shapes[name] = shape
return shape
} | |
c166968 | range a.Shapes {
if len(s.refs) == 0 {
a.removeShape(s)
}
}
} | |
c166969 | v, ok := custEndpointsKey[a.PackageName()]; ok {
a.Metadata.EndpointsID = v
} else {
a.Metadata.EndpointsID = a.Metadata.EndpointPrefix
}
} | |
c166970 | {
s.HapgSerial = &v
return s
} | |
c166971 | s.HsmsLastActionFailed = v
return s
} | |
c166972 | s.HsmsPendingDeletion = v
return s
} | |
c166973 | s.HsmsPendingRegistration = v
return s
} | |
c166974 | s.HsmSerialNumber = &v
return s
} | |
c166975 | s.ServerCertLastUpdated = &v
return s
} | |
c166976 | s.ServerCertUri = &v
return s
} | |
c166977 | s.SshKeyLastUpdated = &v
return s
} | |
c166978 | s.SubscriptionEndDate = &v
return s
} | |
c166979 | s.SubscriptionStartDate = &v
return s
} | |
c166980 | string) *DescribeHsmOutput {
s.VendorName = &v
return s
} | |
c166981 | s.ClientVersion = &v
return s
} | |
c166982 | s.ConfigCred = &v
return s
} | |
c166983 | s.ConfigFile = &v
return s
} | |
c166984 | s.ConfigType = &v
return s
} | |
c166985 | []*string) *ListAvailableZonesOutput {
s.AZList = v
return s
} | |
c166986 | {
s.HsmList = v
return s
} | |
c166987 | error) {
return fn(service, region, opts...)
} | |
c166988 | }
endpoint = fmt.Sprintf("%s://%s", scheme, endpoint)
}
return endpoint
} | |
c166989 | ok || p.p.RegionRegex.MatchString(regionID) {
return p, true
}
}
return Partition{}, false
} | |
c166990 | r := range p.p.Regions {
rs[id] = Region{
id: id,
desc: r.Description,
p: p.p,
}
}
return rs
} | |
c166991 | ss[id] = Service{
id: id,
p: p.p,
}
}
return ss
} | |
c166992 | return r.p.EndpointFor(service, r.id, opts...)
} | |
c166993 | r.p.Services {
if _, ok := s.Endpoints[r.id]; ok {
ss[id] = Service{
id: id,
p: r.p,
}
}
}
return ss
} | |
c166994 | return s.p.EndpointFor(s.id, region, opts...)
} | |
c166995 | id: id,
desc: r.Description,
p: s.p,
}
}
}
return rs
} | |
c166996 | s.p.Services[s.id].Endpoints {
es[id] = Endpoint{
id: id,
serviceID: s.id,
p: s.p,
}
}
return es
} | |
c166997 | return e.p.EndpointFor(e.serviceID, e.id, opts...)
} | |
c166998 | resolve endpoint for unknown service", nil),
Partition: p,
Service: s,
Known: known,
}
} | |
c166999 | extra += fmt.Sprintf(", known: %v", e.Known)
}
return awserr.SprintError(e.Code(), e.Message(), extra, e.OrigErr())
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.