id
stringlengths 2
7
| text
stringlengths 17
51.2k
| title
stringclasses 1
value |
|---|---|---|
c200
|
{
s.CloneUrlSsh = &v
return s
}
| |
c201
|
string) *RepositoryMetadata {
s.DefaultBranch = &v
return s
}
| |
c202
|
string) *RepositoryTrigger {
s.CustomData = &v
return s
}
| |
c203
|
bool) *SourceFileSpecifier {
s.IsMove = &v
return s
}
| |
c204
|
*TestRepositoryTriggersOutput {
s.FailedExecutions = v
return s
}
| |
c205
|
[]*string) *TestRepositoryTriggersOutput {
s.SuccessfulExecutions = v
return s
}
| |
c206
|
{
s.DefaultBranchName = &v
return s
}
| |
c207
|
string) *UpdateRepositoryNameInput {
s.NewName = &v
return s
}
| |
c208
|
string) *UpdateRepositoryNameInput {
s.OldName = &v
return s
}
| |
c209
|
s.Company = &v
return s
}
| |
c210
|
s.IsRestricted = &v
return s
}
| |
c211
|
s.Landmark = &v
return s
}
| |
c212
|
s.PrefectureOrDistrict = &v
return s
}
| |
c213
|
s.StateOrProvince = &v
return s
}
| |
c214
|
s.Street1 = &v
return s
}
| |
c215
|
s.Street2 = &v
return s
}
| |
c216
|
s.Street3 = &v
return s
}
| |
c217
|
s.ObjectsTransferred = &v
return s
}
| |
c218
|
s.TotalBytes = &v
return s
}
| |
c219
|
s.TotalObjects = &v
return s
}
| |
c220
|
*ClusterMetadata) *DescribeClusterOutput {
s.ClusterMetadata = v
return s
}
| |
c221
|
{
s.JobMetadata = v
return s
}
| |
c222
|
{
s.SubJobMetadata = v
return s
}
| |
c223
|
s.SnowballAmiId = &v
return s
}
| |
c224
|
{
s.EventResourceARN = &v
return s
}
| |
c225
|
{
s.ManifestURI = &v
return s
}
| |
c226
|
string) *GetJobUnlockCodeOutput {
s.UnlockCode = &v
return s
}
| |
c227
|
{
s.SnowballLimit = &v
return s
}
| |
c228
|
{
s.SnowballsInUse = &v
return s
}
| |
c229
|
s.IsMaster = &v
return s
}
| |
c230
|
s.JobCompletionReportURI = &v
return s
}
| |
c231
|
s.JobFailureLogURI = &v
return s
}
| |
c232
|
s.JobSuccessLogURI = &v
return s
}
| |
c233
|
s.JobLogInfo = v
return s
}
| |
c234
|
*JobMetadata {
s.ShippingDetails = v
return s
}
| |
c235
|
*JobResource {
s.Ec2AmiResources = v
return s
}
| |
c236
|
*JobResource {
s.LambdaResources = v
return s
}
| |
c237
|
s.BeginMarker = &v
return s
}
| |
c238
|
s.EndMarker = &v
return s
}
| |
c239
|
*LambdaResource {
s.EventTriggers = v
return s
}
| |
c240
|
s.LambdaArn = &v
return s
}
| |
c241
|
*ListClustersOutput {
s.ClusterListEntries = v
return s
}
| |
c242
|
[]*CompatibleImage) *ListCompatibleImagesOutput {
s.CompatibleImages = v
return s
}
| |
c243
|
s.JobStatesToNotify = v
return s
}
| |
c244
|
s.NotifyAll = &v
return s
}
| |
c245
|
s.BucketArn = &v
return s
}
| |
c246
|
s.KeyRange = v
return s
}
| |
c247
|
s.TrackingNumber = &v
return s
}
| |
c248
|
s.InboundShipment = v
return s
}
| |
c249
|
s.OutboundShipment = v
return s
}
| |
c250
|
c.WaitUntilSuccessfulSigningJobWithContext(aws.BackgroundContext(), input)
}
| |
c251
|
s.ProposalDurationInHours = &v
return s
}
| |
c252
|
string) *ApprovalThresholdPolicy {
s.ThresholdComparator = &v
return s
}
| |
c253
|
*CreateNodeInput {
s.NodeConfiguration = v
return s
}
| |
c254
|
{
s.Member = v
return s
}
| |
c255
|
{
s.Node = v
return s
}
| |
c256
|
*Proposal) *GetProposalOutput {
s.Proposal = v
return s
}
| |
c257
|
*Invitation {
s.NetworkSummary = v
return s
}
| |
c258
|
*ListNetworksOutput {
s.Networks = v
return s
}
| |
c259
|
[]*VoteSummary) *ListProposalVotesOutput {
s.ProposalVotes = v
return s
}
| |
c260
|
*ListProposalsOutput {
s.Proposals = v
return s
}
| |
c261
|
string) *MemberFabricAttributes {
s.CaEndpoint = &v
return s
}
| |
c262
|
string) *MemberFabricConfiguration {
s.AdminPassword = &v
return s
}
| |
c263
|
s.VpcEndpointServiceName = &v
return s
}
| |
c264
|
s.OrderingServiceEndpoint = &v
return s
}
| |
c265
|
{
s.PeerEndpoint = &v
return s
}
| |
c266
|
s.PeerEventEndpoint = &v
return s
}
| |
c267
|
s.NoVoteCount = &v
return s
}
| |
c268
|
s.OutstandingVoteCount = &v
return s
}
| |
c269
|
s.YesVoteCount = &v
return s
}
| |
c270
|
*ProposalActions {
s.Removals = v
return s
}
| |
c271
|
string) *VoteOnProposalInput {
s.VoterMemberId = &v
return s
}
| |
c272
|
*VotingPolicy {
s.ApprovalThresholdPolicy = v
return s
}
| |
c273
|
return awserr.SprintError(m.Code(), m.Message(), extra, m.OrigErr())
}
| |
c274
|
{
return func(u *Uploader) {
u.RequestOptions = append(u.RequestOptions, opts...)
}
}
| |
c275
|
}
i.cfg.RequestOptions = append(i.cfg.RequestOptions, request.WithAppendUserAgent("S3Manager"))
return i.upload()
}
| |
c276
|
u.singlePart(reader)
} else if err != nil {
return nil, awserr.New("ReadRequestBody", "read upload data failed", err)
}
mu := multiuploader{uploader: u}
return mu.upload(reader, part)
}
| |
c277
|
= sync.Pool{
New: func() interface{} { return make([]byte, u.cfg.PartSize) },
}
// Try to get the total size for some optimizations
u.initSize()
}
| |
c278
|
// Add one to the part size to account for remainders
// during the size calculation. e.g odd number of bytes.
u.cfg.PartSize = (u.totalSize / int64(u.cfg.MaxUploadParts)) + 1
}
}
}
| |
c279
|
reader := io.NewSectionReader(r, u.readerPos, n)
u.readerPos += n
return reader, int(n), nil, err
default:
part := u.bufferPool.Get().([]byte)
n, err := readFillBuf(r, part)
u.readerPos += int64(n)
return bytes.NewReader(part[0:n]), n, part, err
}
}
| |
c280
|
:= req.Send(); err != nil {
return nil, err
}
url := req.HTTPRequest.URL.String()
return &UploadOutput{
Location: url,
VersionID: out.VersionId,
}, nil
}
| |
c281
|
// with empty single part would of been created and never
// started multipart upload.
break
}
ch <- chunk{buf: reader, part: part, num: num}
}
// Close the channel, wait for workers, and complete upload
close(ch)
u.wg.Wait()
complete := u.complete()
if err := u.geterr(); err != nil {
return nil, &multiUploadError{
awsError: awserr.New(
"MultipartUpload",
"upload multipart failed",
err),
uploadID: u.uploadID,
}
}
// Create a presigned URL of the S3 Get Object in order to have parity with
// single part upload.
getReq, _ := u.cfg.S3.GetObjectRequest(&s3.GetObjectInput{
Bucket: u.in.Bucket,
Key: u.in.Key,
})
getReq.Config.Credentials = credentials.AnonymousCredentials
uploadLocation, _, _ := getReq.PresignRequest(1)
return &UploadOutput{
Location: uploadLocation,
VersionID: complete.VersionId,
UploadID: u.uploadID,
}, nil
}
| |
c282
|
back into the pool to conserve memory
u.bufferPool.Put(c.part)
if err != nil {
return err
}
n := c.num
completed := &s3.CompletedPart{ETag: resp.ETag, PartNumber: &n}
u.m.Lock()
u.parts = append(u.parts, completed)
u.m.Unlock()
return nil
}
| |
c283
|
defer u.m.Unlock()
return u.err
}
| |
c284
|
defer u.m.Unlock()
u.err = e
}
| |
c285
|
:= u.cfg.S3.AbortMultipartUploadWithContext(u.ctx, params, u.cfg.RequestOptions...)
if err != nil {
logMessage(u.cfg.S3, aws.LogDebug, fmt.Sprintf("failed to abort multipart upload, %v", err))
}
}
| |
c286
|
&u.uploadID,
MultipartUpload: &s3.CompletedMultipartUpload{Parts: u.parts},
}
resp, err := u.cfg.S3.CompleteMultipartUploadWithContext(u.ctx, params, u.cfg.RequestOptions...)
if err != nil {
u.seterr(err)
u.fail()
}
return resp
}
| |
c287
|
p.InputTokens.([]string)
return fmt.Sprintf("%#v", str)
}
| |
c288
|
p.OutputTokens.([]string)
return fmt.Sprintf("%#v", str)
}
| |
c289
|
{
case string:
paginator.OutputTokens = []string{t}
case []interface{}:
toks := []string{}
for _, e := range t {
s := e.(string)
toks = append(toks, s)
}
paginator.OutputTokens = toks
}
if o, ok := p.Operations[n]; ok {
o.Paginator = &paginator
} else {
panic("unknown operation for paginator " + n)
}
}
}
| |
c290
|
c.WaitUntilAuditReportCreatedWithContext(aws.BackgroundContext(), input)
}
| |
c291
|
c.WaitUntilCertificateAuthorityCSRCreatedWithContext(aws.BackgroundContext(), input)
}
| |
c292
|
c.WaitUntilCertificateIssuedWithContext(aws.BackgroundContext(), input)
}
| |
c293
|
stringValue(reflect.ValueOf(i), 0, &buf)
return buf.String()
}
| |
c294
|
s.IntervalMillis = &v
return s
}
| |
c295
|
s.TimeoutMillis = &v
return s
}
| |
c296
|
*HttpRoute {
s.Match = v
return s
}
| |
c297
|
[]*MeshRef) *ListMeshesOutput {
s.Meshes = v
return s
}
| |
c298
|
[]*VirtualNodeRef) *ListVirtualNodesOutput {
s.VirtualNodes = v
return s
}
| |
c299
|
[]*VirtualRouterRef) *ListVirtualRoutersOutput {
s.VirtualRouters = v
return s
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.