Package: aws

import "../ibm-cos-sdk-go/aws"

Overview

Package aws provides core functionality for making requests to IBM COS services.

Constants

const UseServiceDefaultRetries = readonly

UseServiceDefaultRetries instructs the config to use the service's own default number of retries. This will be the default action if Config.MaxRetries is nil also.

Value:

-1
const LogOff LogLevelType = readonly

LogOff states that no logging should be performed by the SDK. This is the default state of the SDK, and should be use to disable all logging.

Value:

iota * 0x1000
const LogDebugWithSigning LogLevelType = readonly

LogDebugWithSigning states that the SDK should log request signing and presigning events. This should be used to log the signing details of requests for debugging. Will also enable LogDebug.

Value:

LogDebug | (1 << iota)
const SDKName = readonly

SDKName is the name of this AWS SDK

Value:

"ibm-cos-sdk-go"
const SDKVersion = readonly

SDKVersion is the version of this SDK

Value:

"1.11.1"

Variables

var ErrMissingRegion = writable

ErrMissingRegion is an error that is returned if region configuration is not found.

Value:

awserr.New("MissingRegion", "could not find region configuration", nil)
var ErrMissingEndpoint = writable

ErrMissingEndpoint is an error that is returned if an endpoint cannot be resolved for a service.

Value:

awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", nil)

Type Summary collapse

Interface Summary collapse

Function Summary collapse

Function Details

func BackgroundContext() Context

BackgroundContext returns a context that will never be canceled, has no values, and no deadline. This context is used by the SDK to provide backwards compatibility with non-context API operations and functionality.

Go 1.6 and before: This context function is equivalent to context.Background in the Go stdlib.

Go 1.7 and later: The context returned will be the value returned by context.Background()

See golang.org/pkg/context for more information on Contexts.



18
19
20
 
// File 'aws/context_background_1_7.go', line 18


func BackgroundContext() Context {
	return context.Background()
}

func Bool(v bool) *bool

Bool returns a pointer to the bool value passed in.



64
65
66
 
// File 'aws/convert_types.go', line 64


func Bool(v bool) *bool {
	return &v
}

func BoolMap(src map[string]bool) map[string]*bool

BoolMap converts a string map of bool values into a string map of bool pointers



101
102
103
104
105
106
107
108
 
// File 'aws/convert_types.go', line 101


func BoolMap(src map[string]bool) map[string]*bool {
	dst := make(map[string]*bool)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func BoolSlice(src []bool) []*bool

BoolSlice converts a slice of bool values into a slice of bool pointers



79
80
81
82
83
84
85
 
// File 'aws/convert_types.go', line 79


func BoolSlice(src []bool) []*bool {
	dst := make([]*bool, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func BoolValue(v *bool) bool

BoolValue returns the value of the bool pointer passed in or false if the pointer is nil.



70
71
72
73
74
75
 
// File 'aws/convert_types.go', line 70


func BoolValue(v *bool) bool {
	if v != nil {
		return *v
	}
	return false
}

func BoolValueMap(src map[string]*bool) map[string]bool

BoolValueMap converts a string map of bool pointers into a string map of bool values



112
113
114
115
116
117
118
119
120
 
// File 'aws/convert_types.go', line 112


func BoolValueMap(src map[string]*bool) map[string]bool {
	dst := make(map[string]bool)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func BoolValueSlice(src []*bool) []bool

BoolValueSlice converts a slice of bool pointers into a slice of bool values



89
90
91
92
93
94
95
96
97
 
// File 'aws/convert_types.go', line 89


func BoolValueSlice(src []*bool) []bool {
	dst := make([]bool, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func CopySeekableBody(dst io.Writer, src io.ReadSeeker) (int64, error)

CopySeekableBody copies the seekable body to an io.Writer



243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
 
// File 'aws/types.go', line 243


func CopySeekableBody(dst io.Writer, src io.ReadSeeker) (int64, error) {
	curPos, err := src.Seek(0, sdkio.SeekCurrent)
	if err != nil {
		return 0, err
	}

	// copy errors may be assumed to be from the body.
	n, err := io.Copy(dst, src)
	if err != nil {
		return n, err
	}

	// seek back to the first position after reading to reset
	// the body for transmission.
	_, err = src.Seek(curPos, sdkio.SeekStart)
	if err != nil {
		return n, err
	}

	return n, nil
}

func Float32(v float32) *float32

Float32 returns a pointer to the float32 value passed in.



713
714
715
 
// File 'aws/convert_types.go', line 713


func Float32(v float32) *float32 {
	return &v
}

func Float32Map(src map[string]float32) map[string]*float32

Float32Map converts a string map of float32 values into a string map of float32 pointers



750
751
752
753
754
755
756
757
 
// File 'aws/convert_types.go', line 750


func Float32Map(src map[string]float32) map[string]*float32 {
	dst := make(map[string]*float32)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Float32Slice(src []float32) []*float32

Float32Slice converts a slice of float32 values into a slice of float32 pointers



728
729
730
731
732
733
734
 
// File 'aws/convert_types.go', line 728


func Float32Slice(src []float32) []*float32 {
	dst := make([]*float32, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Float32Value(v *float32) float32

Float32Value returns the value of the float32 pointer passed in or 0 if the pointer is nil.



719
720
721
722
723
724
 
// File 'aws/convert_types.go', line 719


func Float32Value(v *float32) float32 {
	if v != nil {
		return *v
	}
	return 0
}

func Float32ValueMap(src map[string]*float32) map[string]float32

Float32ValueMap converts a string map of float32 pointers into a string map of float32 values



761
762
763
764
765
766
767
768
769
 
// File 'aws/convert_types.go', line 761


func Float32ValueMap(src map[string]*float32) map[string]float32 {
	dst := make(map[string]float32)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Float32ValueSlice(src []*float32) []float32

Float32ValueSlice converts a slice of float32 pointers into a slice of float32 values



738
739
740
741
742
743
744
745
746
 
// File 'aws/convert_types.go', line 738


func Float32ValueSlice(src []*float32) []float32 {
	dst := make([]float32, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Float64(v float64) *float64

Float64 returns a pointer to the float64 value passed in.



772
773
774
 
// File 'aws/convert_types.go', line 772


func Float64(v float64) *float64 {
	return &v
}

func Float64Map(src map[string]float64) map[string]*float64

Float64Map converts a string map of float64 values into a string map of float64 pointers



809
810
811
812
813
814
815
816
 
// File 'aws/convert_types.go', line 809


func Float64Map(src map[string]float64) map[string]*float64 {
	dst := make(map[string]*float64)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Float64Slice(src []float64) []*float64

Float64Slice converts a slice of float64 values into a slice of float64 pointers



787
788
789
790
791
792
793
 
// File 'aws/convert_types.go', line 787


func Float64Slice(src []float64) []*float64 {
	dst := make([]*float64, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Float64Value(v *float64) float64

Float64Value returns the value of the float64 pointer passed in or 0 if the pointer is nil.



778
779
780
781
782
783
 
// File 'aws/convert_types.go', line 778


func Float64Value(v *float64) float64 {
	if v != nil {
		return *v
	}
	return 0
}

func Float64ValueMap(src map[string]*float64) map[string]float64

Float64ValueMap converts a string map of float64 pointers into a string map of float64 values



820
821
822
823
824
825
826
827
828
 
// File 'aws/convert_types.go', line 820


func Float64ValueMap(src map[string]*float64) map[string]float64 {
	dst := make(map[string]float64)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Float64ValueSlice(src []*float64) []float64

Float64ValueSlice converts a slice of float64 pointers into a slice of float64 values



797
798
799
800
801
802
803
804
805
 
// File 'aws/convert_types.go', line 797


func Float64ValueSlice(src []*float64) []float64 {
	dst := make([]float64, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Int(v int) *int

Int returns a pointer to the int value passed in.



123
124
125
 
// File 'aws/convert_types.go', line 123


func Int(v int) *int {
	return &v
}

func Int16(v int16) *int16

Int16 returns a pointer to the int16 value passed in.



300
301
302
 
// File 'aws/convert_types.go', line 300


func Int16(v int16) *int16 {
	return &v
}

func Int16Map(src map[string]int16) map[string]*int16

Int16Map converts a string map of int16 values into a string map of int16 pointers



337
338
339
340
341
342
343
344
 
// File 'aws/convert_types.go', line 337


func Int16Map(src map[string]int16) map[string]*int16 {
	dst := make(map[string]*int16)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Int16Slice(src []int16) []*int16

Int16Slice converts a slice of int16 values into a slice of int16 pointers



315
316
317
318
319
320
321
 
// File 'aws/convert_types.go', line 315


func Int16Slice(src []int16) []*int16 {
	dst := make([]*int16, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Int16Value(v *int16) int16

Int16Value returns the value of the int16 pointer passed in or 0 if the pointer is nil.



306
307
308
309
310
311
 
// File 'aws/convert_types.go', line 306


func Int16Value(v *int16) int16 {
	if v != nil {
		return *v
	}
	return 0
}

func Int16ValueMap(src map[string]*int16) map[string]int16

Int16ValueMap converts a string map of int16 pointers into a string map of int16 values



348
349
350
351
352
353
354
355
356
 
// File 'aws/convert_types.go', line 348


func Int16ValueMap(src map[string]*int16) map[string]int16 {
	dst := make(map[string]int16)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Int16ValueSlice(src []*int16) []int16

Int16ValueSlice converts a slice of int16 pointers into a slice of int16 values



325
326
327
328
329
330
331
332
333
 
// File 'aws/convert_types.go', line 325


func Int16ValueSlice(src []*int16) []int16 {
	dst := make([]int16, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Int32(v int32) *int32

Int32 returns a pointer to the int32 value passed in.



359
360
361
 
// File 'aws/convert_types.go', line 359


func Int32(v int32) *int32 {
	return &v
}

func Int32Map(src map[string]int32) map[string]*int32

Int32Map converts a string map of int32 values into a string map of int32 pointers



396
397
398
399
400
401
402
403
 
// File 'aws/convert_types.go', line 396


func Int32Map(src map[string]int32) map[string]*int32 {
	dst := make(map[string]*int32)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Int32Slice(src []int32) []*int32

Int32Slice converts a slice of int32 values into a slice of int32 pointers



374
375
376
377
378
379
380
 
// File 'aws/convert_types.go', line 374


func Int32Slice(src []int32) []*int32 {
	dst := make([]*int32, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Int32Value(v *int32) int32

Int32Value returns the value of the int32 pointer passed in or 0 if the pointer is nil.



365
366
367
368
369
370
 
// File 'aws/convert_types.go', line 365


func Int32Value(v *int32) int32 {
	if v != nil {
		return *v
	}
	return 0
}

func Int32ValueMap(src map[string]*int32) map[string]int32

Int32ValueMap converts a string map of int32 pointers into a string map of int32 values



407
408
409
410
411
412
413
414
415
 
// File 'aws/convert_types.go', line 407


func Int32ValueMap(src map[string]*int32) map[string]int32 {
	dst := make(map[string]int32)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Int32ValueSlice(src []*int32) []int32

Int32ValueSlice converts a slice of int32 pointers into a slice of int32 values



384
385
386
387
388
389
390
391
392
 
// File 'aws/convert_types.go', line 384


func Int32ValueSlice(src []*int32) []int32 {
	dst := make([]int32, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Int64(v int64) *int64

Int64 returns a pointer to the int64 value passed in.



418
419
420
 
// File 'aws/convert_types.go', line 418


func Int64(v int64) *int64 {
	return &v
}

func Int64Map(src map[string]int64) map[string]*int64

Int64Map converts a string map of int64 values into a string map of int64 pointers



455
456
457
458
459
460
461
462
 
// File 'aws/convert_types.go', line 455


func Int64Map(src map[string]int64) map[string]*int64 {
	dst := make(map[string]*int64)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Int64Slice(src []int64) []*int64

Int64Slice converts a slice of int64 values into a slice of int64 pointers



433
434
435
436
437
438
439
 
// File 'aws/convert_types.go', line 433


func Int64Slice(src []int64) []*int64 {
	dst := make([]*int64, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Int64Value(v *int64) int64

Int64Value returns the value of the int64 pointer passed in or 0 if the pointer is nil.



424
425
426
427
428
429
 
// File 'aws/convert_types.go', line 424


func Int64Value(v *int64) int64 {
	if v != nil {
		return *v
	}
	return 0
}

func Int64ValueMap(src map[string]*int64) map[string]int64

Int64ValueMap converts a string map of int64 pointers into a string map of int64 values



466
467
468
469
470
471
472
473
474
 
// File 'aws/convert_types.go', line 466


func Int64ValueMap(src map[string]*int64) map[string]int64 {
	dst := make(map[string]int64)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Int64ValueSlice(src []*int64) []int64

Int64ValueSlice converts a slice of int64 pointers into a slice of int64 values



443
444
445
446
447
448
449
450
451
 
// File 'aws/convert_types.go', line 443


func Int64ValueSlice(src []*int64) []int64 {
	dst := make([]int64, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Int8(v int8) *int8

Int8 returns a pointer to the int8 value passed in.



241
242
243
 
// File 'aws/convert_types.go', line 241


func Int8(v int8) *int8 {
	return &v
}

func Int8Map(src map[string]int8) map[string]*int8

Int8Map converts a string map of int8 values into a string map of int8 pointers



278
279
280
281
282
283
284
285
 
// File 'aws/convert_types.go', line 278


func Int8Map(src map[string]int8) map[string]*int8 {
	dst := make(map[string]*int8)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Int8Slice(src []int8) []*int8

Int8Slice converts a slice of int8 values into a slice of int8 pointers



256
257
258
259
260
261
262
 
// File 'aws/convert_types.go', line 256


func Int8Slice(src []int8) []*int8 {
	dst := make([]*int8, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Int8Value(v *int8) int8

Int8Value returns the value of the int8 pointer passed in or 0 if the pointer is nil.



247
248
249
250
251
252
 
// File 'aws/convert_types.go', line 247


func Int8Value(v *int8) int8 {
	if v != nil {
		return *v
	}
	return 0
}

func Int8ValueMap(src map[string]*int8) map[string]int8

Int8ValueMap converts a string map of int8 pointers into a string map of int8 values



289
290
291
292
293
294
295
296
297
 
// File 'aws/convert_types.go', line 289


func Int8ValueMap(src map[string]*int8) map[string]int8 {
	dst := make(map[string]int8)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Int8ValueSlice(src []*int8) []int8

Int8ValueSlice converts a slice of int8 pointers into a slice of int8 values



266
267
268
269
270
271
272
273
274
 
// File 'aws/convert_types.go', line 266


func Int8ValueSlice(src []*int8) []int8 {
	dst := make([]int8, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func IntMap(src map[string]int) map[string]*int

IntMap converts a string map of int values into a string map of int pointers



160
161
162
163
164
165
166
167
 
// File 'aws/convert_types.go', line 160


func IntMap(src map[string]int) map[string]*int {
	dst := make(map[string]*int)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func IntSlice(src []int) []*int

IntSlice converts a slice of int values into a slice of int pointers



138
139
140
141
142
143
144
 
// File 'aws/convert_types.go', line 138


func IntSlice(src []int) []*int {
	dst := make([]*int, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func IntValue(v *int) int

IntValue returns the value of the int pointer passed in or 0 if the pointer is nil.



129
130
131
132
133
134
 
// File 'aws/convert_types.go', line 129


func IntValue(v *int) int {
	if v != nil {
		return *v
	}
	return 0
}

func IntValueMap(src map[string]*int) map[string]int

IntValueMap converts a string map of int pointers into a string map of int values



171
172
173
174
175
176
177
178
179
 
// File 'aws/convert_types.go', line 171


func IntValueMap(src map[string]*int) map[string]int {
	dst := make(map[string]int)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func IntValueSlice(src []*int) []int

IntValueSlice converts a slice of int pointers into a slice of int values



148
149
150
151
152
153
154
155
156
 
// File 'aws/convert_types.go', line 148


func IntValueSlice(src []*int) []int {
	dst := make([]int, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func IsReaderSeekable(r io.Reader) bool

IsReaderSeekable returns if the underlying reader type can be seeked. A io.Reader might not actually be seekable if it is the ReaderSeekerCloser type.



35
36
37
38
39
40
41
42
43
44
45
46
 
// File 'aws/types.go', line 35


func IsReaderSeekable(r io.Reader) bool {
	switch v := r.(type) {
	case ReaderSeekerCloser:
		return v.IsSeeker()
	case *ReaderSeekerCloser:
		return v.IsSeeker()
	case io.ReadSeeker:
		return true
	default:
		return false
	}
}

func MillisecondsTimeValue(v *int64) time.Time

MillisecondsTimeValue converts an int64 pointer to a time.Time value representing milliseconds sinch Epoch or time.Time{} if the pointer is nil.



855
856
857
858
859
860
 
// File 'aws/convert_types.go', line 855


func MillisecondsTimeValue(v *int64) time.Time {
	if v != nil {
		return time.Unix(0, (*v * 1000000))
	}
	return time.Time{}
}

func NewDefaultLogger() Logger

NewDefaultLogger returns a Logger which will write log messages to stdout, and use same formatting runes as the stdlib log.Logger



107
108
109
110
111
 
// File 'aws/logger.go', line 107


func NewDefaultLogger() Logger {
	return &defaultLogger{
		logger: log.New(os.Stdout, "", log.LstdFlags),
	}
}

func ReadSeekCloser(r io.Reader) ReaderSeekerCloser

ReadSeekCloser wraps a io.Reader returning a ReaderSeekerCloser. Allows the SDK to accept an io.Reader that is not also an io.Seeker for unsigned streaming payload API operations.

A ReadSeekCloser wrapping an nonseekable io.Reader used in an API operation's input will prevent that operation being retried in the case of network errors, and cause operation requests to fail if the operation requires payload signing.

Note: If using With S3 PutObject to stream an object upload The SDK's S3 Upload manager (s3manager.Uploader) provides support for streaming with the ability to retry network errors.



22
23
24
 
// File 'aws/types.go', line 22


func ReadSeekCloser(r io.Reader) ReaderSeekerCloser {
	return ReaderSeekerCloser{r}
}

func SecondsTimeValue(v *int64) time.Time

SecondsTimeValue converts an int64 pointer to a time.Time value representing seconds since Epoch or time.Time{} if the pointer is nil.



846
847
848
849
850
851
 
// File 'aws/convert_types.go', line 846


func SecondsTimeValue(v *int64) time.Time {
	if v != nil {
		return time.Unix((*v / 1000), 0)
	}
	return time.Time{}
}

func SeekerLen(s io.Seeker) (int64, error)

SeekerLen attempts to get the number of bytes remaining at the seeker's current position. Returns the number of bytes remaining or error.



116
117
118
119
120
121
122
123
124
125
126
127
 
// File 'aws/types.go', line 116


func SeekerLen(s io.Seeker) (int64, error) {
	// Determine if the seeker is actually seekable. ReaderSeekerCloser
	// hides the fact that a io.Readers might not actually be seekable.
	switch v := s.(type) {
	case ReaderSeekerCloser:
		return v.GetLen()
	case *ReaderSeekerCloser:
		return v.GetLen()
	}

	return seekerLen(s)
}

func SleepWithContext(ctx Context, dur time.Duration) error

SleepWithContext will wait for the timer duration to expire, or the context is canceled. Which ever happens first. If the context is canceled the Context's error will be returned.

Expects Context to always return a non-nil error if the Done channel is closed.



11
12
13
14
15
16
17
18
19
20
21
22
23
 
// File 'aws/context_sleep.go', line 11


func SleepWithContext(ctx Context, dur time.Duration) error {
	t := time.NewTimer(dur)
	defer t.Stop()

	select {
	case <-t.C:
		break
	case <-ctx.Done():
		return ctx.Err()
	}

	return nil
}

func String(v string) *string

String returns a pointer to the string value passed in.



5
6
7
 
// File 'aws/convert_types.go', line 5


func String(v string) *string {
	return &v
}

func StringMap(src map[string]string) map[string]*string

StringMap converts a string map of string values into a string map of string pointers



42
43
44
45
46
47
48
49
 
// File 'aws/convert_types.go', line 42


func StringMap(src map[string]string) map[string]*string {
	dst := make(map[string]*string)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func StringSlice(src []string) []*string

StringSlice converts a slice of string values into a slice of string pointers



20
21
22
23
24
25
26
 
// File 'aws/convert_types.go', line 20


func StringSlice(src []string) []*string {
	dst := make([]*string, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func StringValue(v *string) string

StringValue returns the value of the string pointer passed in or “” if the pointer is nil.



11
12
13
14
15
16
 
// File 'aws/convert_types.go', line 11


func StringValue(v *string) string {
	if v != nil {
		return *v
	}
	return ""
}

func StringValueMap(src map[string]*string) map[string]string

StringValueMap converts a string map of string pointers into a string map of string values



53
54
55
56
57
58
59
60
61
 
// File 'aws/convert_types.go', line 53


func StringValueMap(src map[string]*string) map[string]string {
	dst := make(map[string]string)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func StringValueSlice(src []*string) []string

StringValueSlice converts a slice of string pointers into a slice of string values



30
31
32
33
34
35
36
37
38
 
// File 'aws/convert_types.go', line 30


func StringValueSlice(src []*string) []string {
	dst := make([]string, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Time(v time.Time) *time.Time

Time returns a pointer to the time.Time value passed in.



831
832
833
 
// File 'aws/convert_types.go', line 831


func Time(v time.Time) *time.Time {
	return &v
}

func TimeMap(src map[string]time.Time) map[string]*time.Time

TimeMap converts a string map of time.Time values into a string map of time.Time pointers



898
899
900
901
902
903
904
905
 
// File 'aws/convert_types.go', line 898


func TimeMap(src map[string]time.Time) map[string]*time.Time {
	dst := make(map[string]*time.Time)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func TimeSlice(src []time.Time) []*time.Time

TimeSlice converts a slice of time.Time values into a slice of time.Time pointers



876
877
878
879
880
881
882
 
// File 'aws/convert_types.go', line 876


func TimeSlice(src []time.Time) []*time.Time {
	dst := make([]*time.Time, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func TimeUnixMilli(t time.Time) int64

TimeUnixMilli returns a Unix timestamp in milliseconds from “January 1, 1970 UTC”. The result is undefined if the Unix time cannot be represented by an int64. Which includes calling TimeUnixMilli on a zero Time is undefined.

This utility is useful for service API's such as CloudWatch Logs which require their unix time values to be in milliseconds.

See Go stdlib golang.org/pkg/time/#Time.UnixNano for more information.



870
871
872
 
// File 'aws/convert_types.go', line 870


func TimeUnixMilli(t time.Time) int64 {
	return t.UnixNano() / int64(time.Millisecond/time.Nanosecond)
}

func TimeValue(v *time.Time) time.Time

TimeValue returns the value of the time.Time pointer passed in or time.Time{} if the pointer is nil.



837
838
839
840
841
842
 
// File 'aws/convert_types.go', line 837


func TimeValue(v *time.Time) time.Time {
	if v != nil {
		return *v
	}
	return time.Time{}
}

func TimeValueMap(src map[string]*time.Time) map[string]time.Time

TimeValueMap converts a string map of time.Time pointers into a string map of time.Time values



909
910
911
912
913
914
915
916
917
 
// File 'aws/convert_types.go', line 909


func TimeValueMap(src map[string]*time.Time) map[string]time.Time {
	dst := make(map[string]time.Time)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func TimeValueSlice(src []*time.Time) []time.Time

TimeValueSlice converts a slice of time.Time pointers into a slice of time.Time values



886
887
888
889
890
891
892
893
894
 
// File 'aws/convert_types.go', line 886


func TimeValueSlice(src []*time.Time) []time.Time {
	dst := make([]time.Time, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Uint(v uint) *uint

Uint returns a pointer to the uint value passed in.



182
183
184
 
// File 'aws/convert_types.go', line 182


func Uint(v uint) *uint {
	return &v
}

func Uint16(v uint16) *uint16

Uint16 returns a pointer to the uint16 value passed in.



536
537
538
 
// File 'aws/convert_types.go', line 536


func Uint16(v uint16) *uint16 {
	return &v
}

func Uint16Map(src map[string]uint16) map[string]*uint16

Uint16Map converts a string map of uint16 values into a string map of uint16 pointers



573
574
575
576
577
578
579
580
 
// File 'aws/convert_types.go', line 573


func Uint16Map(src map[string]uint16) map[string]*uint16 {
	dst := make(map[string]*uint16)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Uint16Slice(src []uint16) []*uint16

Uint16Slice converts a slice of uint16 values into a slice of uint16 pointers



551
552
553
554
555
556
557
 
// File 'aws/convert_types.go', line 551


func Uint16Slice(src []uint16) []*uint16 {
	dst := make([]*uint16, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Uint16Value(v *uint16) uint16

Uint16Value returns the value of the uint16 pointer passed in or 0 if the pointer is nil.



542
543
544
545
546
547
 
// File 'aws/convert_types.go', line 542


func Uint16Value(v *uint16) uint16 {
	if v != nil {
		return *v
	}
	return 0
}

func Uint16ValueMap(src map[string]*uint16) map[string]uint16

Uint16ValueMap converts a string map of uint16 pointers into a string map of uint16 values



584
585
586
587
588
589
590
591
592
 
// File 'aws/convert_types.go', line 584


func Uint16ValueMap(src map[string]*uint16) map[string]uint16 {
	dst := make(map[string]uint16)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Uint16ValueSlice(src []*uint16) []uint16

Uint16ValueSlice converts a slice of uint16 pointers into a slice of uint16 values



561
562
563
564
565
566
567
568
569
 
// File 'aws/convert_types.go', line 561


func Uint16ValueSlice(src []*uint16) []uint16 {
	dst := make([]uint16, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Uint32(v uint32) *uint32

Uint32 returns a pointer to the uint32 value passed in.



595
596
597
 
// File 'aws/convert_types.go', line 595


func Uint32(v uint32) *uint32 {
	return &v
}

func Uint32Map(src map[string]uint32) map[string]*uint32

Uint32Map converts a string map of uint32 values into a string map of uint32 pointers



632
633
634
635
636
637
638
639
 
// File 'aws/convert_types.go', line 632


func Uint32Map(src map[string]uint32) map[string]*uint32 {
	dst := make(map[string]*uint32)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Uint32Slice(src []uint32) []*uint32

Uint32Slice converts a slice of uint32 values into a slice of uint32 pointers



610
611
612
613
614
615
616
 
// File 'aws/convert_types.go', line 610


func Uint32Slice(src []uint32) []*uint32 {
	dst := make([]*uint32, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Uint32Value(v *uint32) uint32

Uint32Value returns the value of the uint32 pointer passed in or 0 if the pointer is nil.



601
602
603
604
605
606
 
// File 'aws/convert_types.go', line 601


func Uint32Value(v *uint32) uint32 {
	if v != nil {
		return *v
	}
	return 0
}

func Uint32ValueMap(src map[string]*uint32) map[string]uint32

Uint32ValueMap converts a string map of uint32 pointers into a string map of uint32 values



643
644
645
646
647
648
649
650
651
 
// File 'aws/convert_types.go', line 643


func Uint32ValueMap(src map[string]*uint32) map[string]uint32 {
	dst := make(map[string]uint32)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Uint32ValueSlice(src []*uint32) []uint32

Uint32ValueSlice converts a slice of uint32 pointers into a slice of uint32 values



620
621
622
623
624
625
626
627
628
 
// File 'aws/convert_types.go', line 620


func Uint32ValueSlice(src []*uint32) []uint32 {
	dst := make([]uint32, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Uint64(v uint64) *uint64

Uint64 returns a pointer to the uint64 value passed in.



654
655
656
 
// File 'aws/convert_types.go', line 654


func Uint64(v uint64) *uint64 {
	return &v
}

func Uint64Map(src map[string]uint64) map[string]*uint64

Uint64Map converts a string map of uint64 values into a string map of uint64 pointers



691
692
693
694
695
696
697
698
 
// File 'aws/convert_types.go', line 691


func Uint64Map(src map[string]uint64) map[string]*uint64 {
	dst := make(map[string]*uint64)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Uint64Slice(src []uint64) []*uint64

Uint64Slice converts a slice of uint64 values into a slice of uint64 pointers



669
670
671
672
673
674
675
 
// File 'aws/convert_types.go', line 669


func Uint64Slice(src []uint64) []*uint64 {
	dst := make([]*uint64, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Uint64Value(v *uint64) uint64

Uint64Value returns the value of the uint64 pointer passed in or 0 if the pointer is nil.



660
661
662
663
664
665
 
// File 'aws/convert_types.go', line 660


func Uint64Value(v *uint64) uint64 {
	if v != nil {
		return *v
	}
	return 0
}

func Uint64ValueMap(src map[string]*uint64) map[string]uint64

Uint64ValueMap converts a string map of uint64 pointers into a string map of uint64 values



702
703
704
705
706
707
708
709
710
 
// File 'aws/convert_types.go', line 702


func Uint64ValueMap(src map[string]*uint64) map[string]uint64 {
	dst := make(map[string]uint64)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Uint64ValueSlice(src []*uint64) []uint64

Uint64ValueSlice converts a slice of uint64 pointers into a slice of uint64 values



679
680
681
682
683
684
685
686
687
 
// File 'aws/convert_types.go', line 679


func Uint64ValueSlice(src []*uint64) []uint64 {
	dst := make([]uint64, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func Uint8(v uint8) *uint8

Uint8 returns a pointer to the uint8 value passed in.



477
478
479
 
// File 'aws/convert_types.go', line 477


func Uint8(v uint8) *uint8 {
	return &v
}

func Uint8Map(src map[string]uint8) map[string]*uint8

Uint8Map converts a string map of uint8 values into a string map of uint8 pointers



514
515
516
517
518
519
520
521
 
// File 'aws/convert_types.go', line 514


func Uint8Map(src map[string]uint8) map[string]*uint8 {
	dst := make(map[string]*uint8)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func Uint8Slice(src []uint8) []*uint8

Uint8Slice converts a slice of uint8 values into a slice of uint8 pointers



492
493
494
495
496
497
498
 
// File 'aws/convert_types.go', line 492


func Uint8Slice(src []uint8) []*uint8 {
	dst := make([]*uint8, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func Uint8Value(v *uint8) uint8

Uint8Value returns the value of the uint8 pointer passed in or 0 if the pointer is nil.



483
484
485
486
487
488
 
// File 'aws/convert_types.go', line 483


func Uint8Value(v *uint8) uint8 {
	if v != nil {
		return *v
	}
	return 0
}

func Uint8ValueMap(src map[string]*uint8) map[string]uint8

Uint8ValueMap converts a string map of uint8 pointers into a string map of uint8 values



525
526
527
528
529
530
531
532
533
 
// File 'aws/convert_types.go', line 525


func Uint8ValueMap(src map[string]*uint8) map[string]uint8 {
	dst := make(map[string]uint8)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func Uint8ValueSlice(src []*uint8) []uint8

Uint8ValueSlice converts a slice of uint8 pointers into a slice of uint8 values



502
503
504
505
506
507
508
509
510
 
// File 'aws/convert_types.go', line 502


func Uint8ValueSlice(src []*uint8) []uint8 {
	dst := make([]uint8, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func UintMap(src map[string]uint) map[string]*uint

UintMap converts a string map of uint values uinto a string map of uint pointers



219
220
221
222
223
224
225
226
 
// File 'aws/convert_types.go', line 219


func UintMap(src map[string]uint) map[string]*uint {
	dst := make(map[string]*uint)
	for k, val := range src {
		v := val
		dst[k] = &v
	}
	return dst
}

func UintSlice(src []uint) []*uint

UintSlice converts a slice of uint values uinto a slice of uint pointers



197
198
199
200
201
202
203
 
// File 'aws/convert_types.go', line 197


func UintSlice(src []uint) []*uint {
	dst := make([]*uint, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}

func UintValue(v *uint) uint

UintValue returns the value of the uint pointer passed in or 0 if the pointer is nil.



188
189
190
191
192
193
 
// File 'aws/convert_types.go', line 188


func UintValue(v *uint) uint {
	if v != nil {
		return *v
	}
	return 0
}

func UintValueMap(src map[string]*uint) map[string]uint

UintValueMap converts a string map of uint pointers uinto a string map of uint values



230
231
232
233
234
235
236
237
238
 
// File 'aws/convert_types.go', line 230


func UintValueMap(src map[string]*uint) map[string]uint {
	dst := make(map[string]uint)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

func UintValueSlice(src []*uint) []uint

UintValueSlice converts a slice of uint pointers uinto a slice of uint values



207
208
209
210
211
212
213
214
215
 
// File 'aws/convert_types.go', line 207


func UintValueSlice(src []*uint) []uint {
	dst := make([]uint, len(src))
	for i := 0; i < len(src); i++ {
		if src[i] != nil {
			dst[i] = *(src[i])
		}
	}
	return dst
}

func URLHostname(url *url.URL) string

URLHostname will extract the Hostname without port from the URL value.

Wrapper of net/url#URL.Hostname for backwards Go version compatibility.



10
11
12
 
// File 'aws/url.go', line 10


func URLHostname(url *url.URL) string {
	return url.Hostname()
}