Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📁 arn	-	2025-05-25 12:27
📁 auth	-	2025-05-25 12:27
📁 awserr	-	2025-05-25 12:27
📁 awsutil	-	2025-05-25 12:27
📁 client	-	2025-05-25 12:27
📄 config.go package aws import ( "net/http" "time" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/endpoints" ) // 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. const UseServiceDefaultRetries = -1 // RequestRetryer is an alias for a type that implements the request.Retryer // interface. type RequestRetryer interface{} // A Config provides service configuration for service clients. By default, // all clients will use the defaults.DefaultConfig structure. // // // Create Session with MaxRetries configuration to be shared by multiple // // service clients. // sess := session.Must(session.NewSession(&aws.Config{ // MaxRetries: aws.Int(3), // })) // // // Create S3 service client with a specific Region. // svc := s3.New(sess, &aws.Config{ // Region: aws.String("us-west-2"), // }) type Config struct { // Enables verbose error printing of all credential chain errors. // Should be used when wanting to see all errors while attempting to // retrieve credentials. CredentialsChainVerboseErrors bool // The credentials object to use when signing requests. Defaults to a // chain of credential providers to search for credentials in environment // variables, shared credential file, and EC2 Instance Roles. Credentials credentials.Credentials // An optional endpoint URL (hostname only or fully qualified URI) // that overrides the default generated endpoint for a client. Set this // to `nil` or the value to `""` to use the default generated endpoint. // // Note: You must still provide a `Region` value when specifying an // endpoint for a client. Endpoint string // The resolver to use for looking up endpoints for AWS service clients // to use based on region. EndpointResolver endpoints.Resolver // EnforceShouldRetryCheck is used in the AfterRetryHandler to always call // ShouldRetry regardless of whether or not if request.Retryable is set. // This will utilize ShouldRetry method of custom retryers. If EnforceShouldRetryCheck // is not set, then ShouldRetry will only be called if request.Retryable is nil. // Proper handling of the request.Retryable field is important when setting this field. EnforceShouldRetryCheck bool // The region to send requests to. This parameter is required and must // be configured globally or on a per-client basis unless otherwise // noted. A full list of regions is found in the "Regions and Endpoints" // document. // // See http://docs.aws.amazon.com/general/latest/gr/rande.html for AWS // Regions and Endpoints. Region string // Set this to `true` to disable SSL when sending requests. Defaults // to `false`. DisableSSL bool // The HTTP client to use when sending requests. Defaults to // `http.DefaultClient`. HTTPClient http.Client // An integer value representing the logging level. The default log level // is zero (LogOff), which represents no logging. To enable logging set // to a LogLevel Value. LogLevel LogLevelType // The logger writer interface to write logging messages to. Defaults to // standard out. Logger Logger // The maximum number of times that a request will be retried for failures. // Defaults to -1, which defers the max retry setting to the service // specific configuration. MaxRetries int // Retryer guides how HTTP requests should be retried in case of // recoverable failures. // // When nil or the value does not implement the request.Retryer interface, // the client.DefaultRetryer will be used. // // When both Retryer and MaxRetries are non-nil, the former is used and // the latter ignored. // // To set the Retryer field in a type-safe manner and with chaining, use // the request.WithRetryer helper function: // // cfg := request.WithRetryer(aws.NewConfig(), myRetryer) // Retryer RequestRetryer // Disables semantic parameter validation, which validates input for // missing required fields and/or other semantic request input errors. DisableParamValidation bool // Disables the computation of request and response checksums, e.g., // CRC32 checksums in Amazon DynamoDB. DisableComputeChecksums bool // Set this to `true` to force the request to use path-style addressing, // i.e., `http://s3.amazonaws.com/BUCKET/KEY`. By default, the S3 client // will use virtual hosted bucket addressing when possible // (`http://BUCKET.s3.amazonaws.com/KEY`). // // Note: This configuration option is specific to the Amazon S3 service. // // See http://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html // for Amazon S3: Virtual Hosting of Buckets S3ForcePathStyle bool // Set this to `true` to disable the SDK adding the `Expect: 100-Continue` // header to PUT requests over 2MB of content. 100-Continue instructs the // HTTP client not to send the body until the service responds with a // `continue` status. This is useful to prevent sending the request body // until after the request is authenticated, and validated. // // http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html // // 100-Continue is only enabled for Go 1.6 and above. See `http.Transport`'s // `ExpectContinueTimeout` for information on adjusting the continue wait // timeout. https://golang.org/pkg/net/http/#Transport // // You should use this flag to disable 100-Continue if you experience issues // with proxies or third party S3 compatible services. S3Disable100Continue bool // Set this to `true` to enable S3 Accelerate feature. For all operations // compatible with S3 Accelerate will use the accelerate endpoint for // requests. Requests not compatible will fall back to normal S3 requests. // // The bucket must be enable for accelerate to be used with S3 client with // accelerate enabled. If the bucket is not enabled for accelerate an error // will be returned. The bucket name must be DNS compatible to also work // with accelerate. S3UseAccelerate bool // S3DisableContentMD5Validation config option is temporarily disabled, // For S3 GetObject API calls, #1837. // // Set this to `true` to disable the S3 service client from automatically // adding the ContentMD5 to S3 Object Put and Upload API calls. This option // will also disable the SDK from performing object ContentMD5 validation // on GetObject API calls. S3DisableContentMD5Validation bool // Set this to `true` to have the S3 service client to use the region specified // in the ARN, when an ARN is provided as an argument to a bucket parameter. S3UseARNRegion bool // Set this to `true` to enable the SDK to unmarshal API response header maps to // normalized lower case map keys. // // For example S3's X-Amz-Meta prefixed header will be unmarshaled to lower case // Metadata member's map keys. The value of the header in the map is unaffected. // // The AWS SDK for Go v2, uses lower case header maps by default. The v1 // SDK provides this opt-in for this option, for backwards compatibility. LowerCaseHeaderMaps bool // Set this to `true` to disable the EC2Metadata client from overriding the // default http.Client's Timeout. This is helpful if you do not want the // EC2Metadata client to create a new http.Client. This options is only // meaningful if you're not already using a custom HTTP client with the // SDK. Enabled by default. // // Must be set and provided to the session.NewSession() in order to disable // the EC2Metadata overriding the timeout for default credentials chain. // // Example: // sess := session.Must(session.NewSession(aws.NewConfig() // .WithEC2MetadataDisableTimeoutOverride(true))) // // svc := s3.New(sess) // EC2MetadataDisableTimeoutOverride bool // Set this to `false` to disable EC2Metadata client from falling back to IMDSv1. // By default, EC2 role credentials will fall back to IMDSv1 as needed for backwards compatibility. // You can disable this behavior by explicitly setting this flag to `false`. When false, the EC2Metadata // client will return any errors encountered from attempting to fetch a token instead of silently // using the insecure data flow of IMDSv1. // // Example: // sess := session.Must(session.NewSession(aws.NewConfig() // .WithEC2MetadataEnableFallback(false))) // // svc := s3.New(sess) // // See [configuring IMDS] for more information. // // [configuring IMDS]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html EC2MetadataEnableFallback bool // Instructs the endpoint to be generated for a service client to // be the dual stack endpoint. The dual stack endpoint will support // both IPv4 and IPv6 addressing. // // Setting this for a service which does not support dual stack will fail // to make requests. It is not recommended to set this value on the session // as it will apply to all service clients created with the session. Even // services which don't support dual stack endpoints. // // If the Endpoint config value is also provided the UseDualStack flag // will be ignored. // // Only supported with. // // sess := session.Must(session.NewSession()) // // svc := s3.New(sess, &aws.Config{ // UseDualStack: aws.Bool(true), // }) // // Deprecated: This option will continue to function for S3 and S3 Control for backwards compatibility. // UseDualStackEndpoint should be used to enable usage of a service's dual-stack endpoint for all service clients // moving forward. For S3 and S3 Control, when UseDualStackEndpoint is set to a non-zero value it takes higher // precedence then this option. UseDualStack bool // Sets the resolver to resolve a dual-stack endpoint for the service. UseDualStackEndpoint endpoints.DualStackEndpointState // UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint. UseFIPSEndpoint endpoints.FIPSEndpointState // SleepDelay is an override for the func the SDK will call when sleeping // during the lifecycle of a request. Specifically this will be used for // request delays. This value should only be used for testing. To adjust // the delay of a request see the aws/client.DefaultRetryer and // aws/request.Retryer. // // SleepDelay will prevent any Context from being used for canceling retry // delay of an API operation. It is recommended to not use SleepDelay at all // and specify a Retryer instead. SleepDelay func(time.Duration) // DisableRestProtocolURICleaning will not clean the URL path when making rest protocol requests. // Will default to false. This would only be used for empty directory names in s3 requests. // // Example: // sess := session.Must(session.NewSession(&aws.Config{ // DisableRestProtocolURICleaning: aws.Bool(true), // })) // // svc := s3.New(sess) // out, err := svc.GetObject(&s3.GetObjectInput { // Bucket: aws.String("bucketname"), // Key: aws.String("//foo//bar//moo"), // }) DisableRestProtocolURICleaning bool // EnableEndpointDiscovery will allow for endpoint discovery on operations that // have the definition in its model. By default, endpoint discovery is off. // To use EndpointDiscovery, Endpoint should be unset or set to an empty string. // // Example: // sess := session.Must(session.NewSession(&aws.Config{ // EnableEndpointDiscovery: aws.Bool(true), // })) // // svc := s3.New(sess) // out, err := svc.GetObject(&s3.GetObjectInput { // Bucket: aws.String("bucketname"), // Key: aws.String("/foo/bar/moo"), // }) EnableEndpointDiscovery bool // DisableEndpointHostPrefix will disable the SDK's behavior of prefixing // request endpoint hosts with modeled information. // // Disabling this feature is useful when you want to use local endpoints // for testing that do not support the modeled host prefix pattern. DisableEndpointHostPrefix bool // STSRegionalEndpoint will enable regional or legacy endpoint resolving STSRegionalEndpoint endpoints.STSRegionalEndpoint // S3UsEast1RegionalEndpoint will enable regional or legacy endpoint resolving S3UsEast1RegionalEndpoint endpoints.S3UsEast1RegionalEndpoint } // NewConfig returns a new Config pointer that can be chained with builder // methods to set multiple configuration values inline without using pointers. // // // Create Session with MaxRetries configuration to be shared by multiple // // service clients. // sess := session.Must(session.NewSession(aws.NewConfig(). // WithMaxRetries(3), // )) // // // Create S3 service client with a specific Region. // svc := s3.New(sess, aws.NewConfig(). // WithRegion("us-west-2"), // ) func NewConfig() Config { return &Config{} } // WithCredentialsChainVerboseErrors sets a config verbose errors boolean and returning // a Config pointer. func (c Config) WithCredentialsChainVerboseErrors(verboseErrs bool) Config { c.CredentialsChainVerboseErrors = &verboseErrs return c } // WithCredentials sets a config Credentials value returning a Config pointer // for chaining. func (c Config) WithCredentials(creds credentials.Credentials) Config { c.Credentials = creds return c } // WithEndpoint sets a config Endpoint value returning a Config pointer for // chaining. func (c Config) WithEndpoint(endpoint string) Config { c.Endpoint = &endpoint return c } // WithEndpointResolver sets a config EndpointResolver value returning a // Config pointer for chaining. func (c Config) WithEndpointResolver(resolver endpoints.Resolver) Config { c.EndpointResolver = resolver return c } // WithRegion sets a config Region value returning a Config pointer for // chaining. func (c Config) WithRegion(region string) Config { c.Region = &region return c } // WithDisableSSL sets a config DisableSSL value returning a Config pointer // for chaining. func (c Config) WithDisableSSL(disable bool) Config { c.DisableSSL = &disable return c } // WithHTTPClient sets a config HTTPClient value returning a Config pointer // for chaining. func (c Config) WithHTTPClient(client http.Client) Config { c.HTTPClient = client return c } // WithMaxRetries sets a config MaxRetries value returning a Config pointer // for chaining. func (c Config) WithMaxRetries(max int) Config { c.MaxRetries = &max return c } // WithDisableParamValidation sets a config DisableParamValidation value // returning a Config pointer for chaining. func (c Config) WithDisableParamValidation(disable bool) Config { c.DisableParamValidation = &disable return c } // WithDisableComputeChecksums sets a config DisableComputeChecksums value // returning a Config pointer for chaining. func (c Config) WithDisableComputeChecksums(disable bool) Config { c.DisableComputeChecksums = &disable return c } // WithLogLevel sets a config LogLevel value returning a Config pointer for // chaining. func (c Config) WithLogLevel(level LogLevelType) Config { c.LogLevel = &level return c } // WithLogger sets a config Logger value returning a Config pointer for // chaining. func (c Config) WithLogger(logger Logger) Config { c.Logger = logger return c } // WithS3ForcePathStyle sets a config S3ForcePathStyle value returning a Config // pointer for chaining. func (c Config) WithS3ForcePathStyle(force bool) Config { c.S3ForcePathStyle = &force return c } // WithS3Disable100Continue sets a config S3Disable100Continue value returning // a Config pointer for chaining. func (c Config) WithS3Disable100Continue(disable bool) Config { c.S3Disable100Continue = &disable return c } // WithS3UseAccelerate sets a config S3UseAccelerate value returning a Config // pointer for chaining. func (c Config) WithS3UseAccelerate(enable bool) Config { c.S3UseAccelerate = &enable return c } // WithS3DisableContentMD5Validation sets a config // S3DisableContentMD5Validation value returning a Config pointer for chaining. func (c Config) WithS3DisableContentMD5Validation(enable bool) Config { c.S3DisableContentMD5Validation = &enable return c } // WithS3UseARNRegion sets a config S3UseARNRegion value and // returning a Config pointer for chaining func (c Config) WithS3UseARNRegion(enable bool) Config { c.S3UseARNRegion = &enable return c } // WithUseDualStack sets a config UseDualStack value returning a Config // pointer for chaining. func (c Config) WithUseDualStack(enable bool) Config { c.UseDualStack = &enable return c } // WithUseFIPSEndpoint sets a config UseFIPSEndpoint value returning a Config // pointer for chaining. func (c Config) WithUseFIPSEndpoint(enable bool) Config { if enable { c.UseFIPSEndpoint = endpoints.FIPSEndpointStateEnabled } else { c.UseFIPSEndpoint = endpoints.FIPSEndpointStateDisabled } return c } // WithEC2MetadataDisableTimeoutOverride sets a config EC2MetadataDisableTimeoutOverride value // returning a Config pointer for chaining. func (c Config) WithEC2MetadataDisableTimeoutOverride(enable bool) Config { c.EC2MetadataDisableTimeoutOverride = &enable return c } // WithEC2MetadataEnableFallback sets a config EC2MetadataEnableFallback value // returning a Config pointer for chaining. func (c Config) WithEC2MetadataEnableFallback(v bool) Config { c.EC2MetadataEnableFallback = &v return c } // WithSleepDelay overrides the function used to sleep while waiting for the // next retry. Defaults to time.Sleep. func (c Config) WithSleepDelay(fn func(time.Duration)) Config { c.SleepDelay = fn return c } // WithEndpointDiscovery will set whether or not to use endpoint discovery. func (c Config) WithEndpointDiscovery(t bool) Config { c.EnableEndpointDiscovery = &t return c } // WithDisableEndpointHostPrefix will set whether or not to use modeled host prefix // when making requests. func (c Config) WithDisableEndpointHostPrefix(t bool) Config { c.DisableEndpointHostPrefix = &t return c } // WithSTSRegionalEndpoint will set whether or not to use regional endpoint flag // when resolving the endpoint for a service func (c Config) WithSTSRegionalEndpoint(sre endpoints.STSRegionalEndpoint) Config { c.STSRegionalEndpoint = sre return c } // WithS3UsEast1RegionalEndpoint will set whether or not to use regional endpoint flag // when resolving the endpoint for a service func (c Config) WithS3UsEast1RegionalEndpoint(sre endpoints.S3UsEast1RegionalEndpoint) Config { c.S3UsEast1RegionalEndpoint = sre return c } // WithLowerCaseHeaderMaps sets a config LowerCaseHeaderMaps value // returning a Config pointer for chaining. func (c Config) WithLowerCaseHeaderMaps(t bool) Config { c.LowerCaseHeaderMaps = &t return c } // WithDisableRestProtocolURICleaning sets a config DisableRestProtocolURICleaning value // returning a Config pointer for chaining. func (c Config) WithDisableRestProtocolURICleaning(t bool) Config { c.DisableRestProtocolURICleaning = &t return c } // MergeIn merges the passed in configs into the existing config object. func (c Config) MergeIn(cfgs ...Config) { for _, other := range cfgs { mergeInConfig(c, other) } } func mergeInConfig(dst Config, other Config) { if other == nil { return } if other.CredentialsChainVerboseErrors != nil { dst.CredentialsChainVerboseErrors = other.CredentialsChainVerboseErrors } if other.Credentials != nil { dst.Credentials = other.Credentials } if other.Endpoint != nil { dst.Endpoint = other.Endpoint } if other.EndpointResolver != nil { dst.EndpointResolver = other.EndpointResolver } if other.Region != nil { dst.Region = other.Region } if other.DisableSSL != nil { dst.DisableSSL = other.DisableSSL } if other.HTTPClient != nil { dst.HTTPClient = other.HTTPClient } if other.LogLevel != nil { dst.LogLevel = other.LogLevel } if other.Logger != nil { dst.Logger = other.Logger } if other.MaxRetries != nil { dst.MaxRetries = other.MaxRetries } if other.Retryer != nil { dst.Retryer = other.Retryer } if other.DisableParamValidation != nil { dst.DisableParamValidation = other.DisableParamValidation } if other.DisableComputeChecksums != nil { dst.DisableComputeChecksums = other.DisableComputeChecksums } if other.S3ForcePathStyle != nil { dst.S3ForcePathStyle = other.S3ForcePathStyle } if other.S3Disable100Continue != nil { dst.S3Disable100Continue = other.S3Disable100Continue } if other.S3UseAccelerate != nil { dst.S3UseAccelerate = other.S3UseAccelerate } if other.S3DisableContentMD5Validation != nil { dst.S3DisableContentMD5Validation = other.S3DisableContentMD5Validation } if other.S3UseARNRegion != nil { dst.S3UseARNRegion = other.S3UseARNRegion } if other.UseDualStack != nil { dst.UseDualStack = other.UseDualStack } if other.UseDualStackEndpoint != endpoints.DualStackEndpointStateUnset { dst.UseDualStackEndpoint = other.UseDualStackEndpoint } if other.EC2MetadataDisableTimeoutOverride != nil { dst.EC2MetadataDisableTimeoutOverride = other.EC2MetadataDisableTimeoutOverride } if other.EC2MetadataEnableFallback != nil { dst.EC2MetadataEnableFallback = other.EC2MetadataEnableFallback } if other.SleepDelay != nil { dst.SleepDelay = other.SleepDelay } if other.DisableRestProtocolURICleaning != nil { dst.DisableRestProtocolURICleaning = other.DisableRestProtocolURICleaning } if other.EnforceShouldRetryCheck != nil { dst.EnforceShouldRetryCheck = other.EnforceShouldRetryCheck } if other.EnableEndpointDiscovery != nil { dst.EnableEndpointDiscovery = other.EnableEndpointDiscovery } if other.DisableEndpointHostPrefix != nil { dst.DisableEndpointHostPrefix = other.DisableEndpointHostPrefix } if other.STSRegionalEndpoint != endpoints.UnsetSTSEndpoint { dst.STSRegionalEndpoint = other.STSRegionalEndpoint } if other.S3UsEast1RegionalEndpoint != endpoints.UnsetS3UsEast1Endpoint { dst.S3UsEast1RegionalEndpoint = other.S3UsEast1RegionalEndpoint } if other.LowerCaseHeaderMaps != nil { dst.LowerCaseHeaderMaps = other.LowerCaseHeaderMaps } if other.UseDualStackEndpoint != endpoints.DualStackEndpointStateUnset { dst.UseDualStackEndpoint = other.UseDualStackEndpoint } if other.UseFIPSEndpoint != endpoints.FIPSEndpointStateUnset { dst.UseFIPSEndpoint = other.UseFIPSEndpoint } } // Copy will return a shallow copy of the Config object. If any additional // configurations are provided they will be merged into the new config returned. func (c Config) Copy(cfgs ...Config) *Config { dst := &Config{} dst.MergeIn(c) for _, cfg := range cfgs { dst.MergeIn(cfg) } return dst }	22.06 KB	2025-05-25 12:27
📄 config_test.go package aws import ( "net/http" "reflect" "testing" "github.com/aws/aws-sdk-go/aws/credentials" ) var testCredentials = credentials.NewStaticCredentials("AKID", "SECRET", "SESSION") var copyTestConfig = Config{ Credentials: testCredentials, Endpoint: String("CopyTestEndpoint"), Region: String("COPY_TEST_AWS_REGION"), DisableSSL: Bool(true), HTTPClient: http.DefaultClient, LogLevel: LogLevel(LogDebug), Logger: NewDefaultLogger(), MaxRetries: Int(3), DisableParamValidation: Bool(true), DisableComputeChecksums: Bool(true), S3ForcePathStyle: Bool(true), } func TestCopy(t testing.T) { want := copyTestConfig got := copyTestConfig.Copy() if !reflect.DeepEqual(got, want) { t.Errorf("Copy() = %+v", got) t.Errorf(" want %+v", want) } got.Region = String("other") if got.Region == want.Region { t.Errorf("Expect setting copy values not not reflect in source") } } func TestCopyReturnsNewInstance(t testing.T) { want := copyTestConfig got := copyTestConfig.Copy() if got == &want { t.Errorf("Copy() = %p; want different instance as source %p", got, &want) } } var mergeTestZeroValueConfig = Config{} var mergeTestConfig = Config{ Credentials: testCredentials, Endpoint: String("MergeTestEndpoint"), Region: String("MERGE_TEST_AWS_REGION"), DisableSSL: Bool(true), HTTPClient: http.DefaultClient, LogLevel: LogLevel(LogDebug), Logger: NewDefaultLogger(), MaxRetries: Int(10), DisableParamValidation: Bool(true), DisableComputeChecksums: Bool(true), DisableEndpointHostPrefix: Bool(true), EnableEndpointDiscovery: Bool(true), EnforceShouldRetryCheck: Bool(true), DisableRestProtocolURICleaning: Bool(true), S3ForcePathStyle: Bool(true), LowerCaseHeaderMaps: Bool(true), } var mergeTests = []struct { cfg Config in Config want Config }{ {&Config{}, nil, &Config{}}, {&Config{}, &mergeTestZeroValueConfig, &Config{}}, {&Config{}, &mergeTestConfig, &mergeTestConfig}, } func TestMerge(t *testing.T) { for i, tt := range mergeTests { got := tt.cfg.Copy() got.MergeIn(tt.in) if !reflect.DeepEqual(got, tt.want) { t.Errorf("Config %d %+v", i, tt.cfg) t.Errorf(" Merge(%+v)", tt.in) t.Errorf(" got %+v", got) t.Errorf(" want %+v", tt.want) } } }	2.54 KB	2025-05-25 12:27
📄 context_1_5.go //go:build !go1.9 // +build !go1.9 package aws import "time" // Context is an copy of the Go v1.7 stdlib's context.Context interface. // It is represented as a SDK interface to enable you to use the "WithContext" // API methods with Go v1.6 and a Context type such as golang.org/x/net/context. // // See https://golang.org/pkg/context on how to use contexts. type Context interface { // Deadline returns the time when work done on behalf of this context // should be canceled. Deadline returns ok==false when no deadline is // set. Successive calls to Deadline return the same results. Deadline() (deadline time.Time, ok bool) // Done returns a channel that's closed when work done on behalf of this // context should be canceled. Done may return nil if this context can // never be canceled. Successive calls to Done return the same value. Done() <-chan struct{} // Err returns a non-nil error value after Done is closed. Err returns // Canceled if the context was canceled or DeadlineExceeded if the // context's deadline passed. No other values for Err are defined. // After Done is closed, successive calls to Err return the same value. Err() error // Value returns the value associated with this context for key, or nil // if no value is associated with key. Successive calls to Value with // the same key returns the same result. // // Use context values only for request-scoped data that transits // processes and API boundaries, not for passing optional parameters to // functions. Value(key interface{}) interface{} }	1.52 KB	2025-05-25 12:27
📄 context_1_9.go //go:build go1.9 // +build go1.9 package aws import "context" // Context is an alias of the Go stdlib's context.Context interface. // It can be used within the SDK's API operation "WithContext" methods. // // See https://golang.org/pkg/context on how to use contexts. type Context = context.Context	302 B	2025-05-25 12:27
📄 context_background_1_5.go //go:build !go1.7 // +build !go1.7 package aws import ( "github.com/aws/aws-sdk-go/internal/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 https://golang.org/pkg/context for more information on Contexts. func BackgroundContext() Context { return context.BackgroundCtx }	676 B	2025-05-25 12:27
📄 context_background_1_7.go //go:build go1.7 // +build go1.7 package aws import "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 https://golang.org/pkg/context for more information on Contexts. func BackgroundContext() Context { return context.Background() }	633 B	2025-05-25 12:27
📄 context_sleep.go package aws import ( "time" ) // 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. 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 }	500 B	2025-05-25 12:27
📄 context_test.go package aws_test import ( "fmt" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/awstesting" ) func TestSleepWithContext(t testing.T) { ctx := &awstesting.FakeContext{DoneCh: make(chan struct{})} err := aws.SleepWithContext(ctx, 1time.Millisecond) if err != nil { t.Errorf("expect context to not be canceled, got %v", err) } } func TestSleepWithContext_Canceled(t testing.T) { ctx := &awstesting.FakeContext{DoneCh: make(chan struct{})} expectErr := fmt.Errorf("context canceled") ctx.Error = expectErr close(ctx.DoneCh) err := aws.SleepWithContext(ctx, 10time.Second) if err == nil { t.Fatalf("expect error, did not get one") } if e, a := expectErr, err; e != a { t.Errorf("expect %v error, got %v", e, a) } }	775 B	2025-05-25 12:27
📄 convert_types.go package aws import "time" // String returns a pointer to the string value passed in. func String(v string) string { return &v } // StringValue returns the value of the string pointer passed in or // "" if the pointer is nil. func StringValue(v string) string { if v != nil { return v } return "" } // StringSlice converts a slice of string values into a slice of // string pointers func StringSlice(src []string) []string { dst := make([]string, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // StringValueSlice converts a slice of string pointers into a slice of // string values 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 } // StringMap converts a string map of string values into a string // map of string pointers 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 } // StringValueMap converts a string map of string pointers into a string // map of string values 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 } // Bool returns a pointer to the bool value passed in. func Bool(v bool) bool { return &v } // BoolValue returns the value of the bool pointer passed in or // false if the pointer is nil. func BoolValue(v bool) bool { if v != nil { return v } return false } // BoolSlice converts a slice of bool values into a slice of // bool pointers func BoolSlice(src []bool) []bool { dst := make([]bool, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // BoolValueSlice converts a slice of bool pointers into a slice of // bool values 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 } // BoolMap converts a string map of bool values into a string // map of bool pointers 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 } // BoolValueMap converts a string map of bool pointers into a string // map of bool values 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 } // Int returns a pointer to the int value passed in. func Int(v int) int { return &v } // IntValue returns the value of the int pointer passed in or // 0 if the pointer is nil. func IntValue(v int) int { if v != nil { return v } return 0 } // IntSlice converts a slice of int values into a slice of // int pointers func IntSlice(src []int) []int { dst := make([]int, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // IntValueSlice converts a slice of int pointers into a slice of // int values 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 } // IntMap converts a string map of int values into a string // map of int pointers 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 } // IntValueMap converts a string map of int pointers into a string // map of int values 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 } // Uint returns a pointer to the uint value passed in. func Uint(v uint) uint { return &v } // UintValue returns the value of the uint pointer passed in or // 0 if the pointer is nil. func UintValue(v uint) uint { if v != nil { return v } return 0 } // UintSlice converts a slice of uint values uinto a slice of // uint pointers func UintSlice(src []uint) []uint { dst := make([]uint, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // UintValueSlice converts a slice of uint pointers uinto a slice of // uint values 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 } // UintMap converts a string map of uint values uinto a string // map of uint pointers 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 } // UintValueMap converts a string map of uint pointers uinto a string // map of uint values 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 } // Int8 returns a pointer to the int8 value passed in. func Int8(v int8) int8 { return &v } // Int8Value returns the value of the int8 pointer passed in or // 0 if the pointer is nil. func Int8Value(v int8) int8 { if v != nil { return v } return 0 } // Int8Slice converts a slice of int8 values into a slice of // int8 pointers func Int8Slice(src []int8) []int8 { dst := make([]int8, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Int8ValueSlice converts a slice of int8 pointers into a slice of // int8 values 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 } // Int8Map converts a string map of int8 values into a string // map of int8 pointers 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 } // Int8ValueMap converts a string map of int8 pointers into a string // map of int8 values 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 } // Int16 returns a pointer to the int16 value passed in. func Int16(v int16) int16 { return &v } // Int16Value returns the value of the int16 pointer passed in or // 0 if the pointer is nil. func Int16Value(v int16) int16 { if v != nil { return v } return 0 } // Int16Slice converts a slice of int16 values into a slice of // int16 pointers func Int16Slice(src []int16) []int16 { dst := make([]int16, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Int16ValueSlice converts a slice of int16 pointers into a slice of // int16 values 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 } // Int16Map converts a string map of int16 values into a string // map of int16 pointers 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 } // Int16ValueMap converts a string map of int16 pointers into a string // map of int16 values 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 } // Int32 returns a pointer to the int32 value passed in. func Int32(v int32) int32 { return &v } // Int32Value returns the value of the int32 pointer passed in or // 0 if the pointer is nil. func Int32Value(v int32) int32 { if v != nil { return v } return 0 } // Int32Slice converts a slice of int32 values into a slice of // int32 pointers func Int32Slice(src []int32) []int32 { dst := make([]int32, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Int32ValueSlice converts a slice of int32 pointers into a slice of // int32 values 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 } // Int32Map converts a string map of int32 values into a string // map of int32 pointers 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 } // Int32ValueMap converts a string map of int32 pointers into a string // map of int32 values 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 } // Int64 returns a pointer to the int64 value passed in. func Int64(v int64) int64 { return &v } // Int64Value returns the value of the int64 pointer passed in or // 0 if the pointer is nil. func Int64Value(v int64) int64 { if v != nil { return v } return 0 } // Int64Slice converts a slice of int64 values into a slice of // int64 pointers func Int64Slice(src []int64) []int64 { dst := make([]int64, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Int64ValueSlice converts a slice of int64 pointers into a slice of // int64 values 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 } // Int64Map converts a string map of int64 values into a string // map of int64 pointers 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 } // Int64ValueMap converts a string map of int64 pointers into a string // map of int64 values 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 } // Uint8 returns a pointer to the uint8 value passed in. func Uint8(v uint8) uint8 { return &v } // Uint8Value returns the value of the uint8 pointer passed in or // 0 if the pointer is nil. func Uint8Value(v uint8) uint8 { if v != nil { return v } return 0 } // Uint8Slice converts a slice of uint8 values into a slice of // uint8 pointers func Uint8Slice(src []uint8) []uint8 { dst := make([]uint8, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Uint8ValueSlice converts a slice of uint8 pointers into a slice of // uint8 values 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 } // Uint8Map converts a string map of uint8 values into a string // map of uint8 pointers 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 } // Uint8ValueMap converts a string map of uint8 pointers into a string // map of uint8 values 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 } // Uint16 returns a pointer to the uint16 value passed in. func Uint16(v uint16) uint16 { return &v } // Uint16Value returns the value of the uint16 pointer passed in or // 0 if the pointer is nil. func Uint16Value(v uint16) uint16 { if v != nil { return v } return 0 } // Uint16Slice converts a slice of uint16 values into a slice of // uint16 pointers func Uint16Slice(src []uint16) []uint16 { dst := make([]uint16, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Uint16ValueSlice converts a slice of uint16 pointers into a slice of // uint16 values 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 } // Uint16Map converts a string map of uint16 values into a string // map of uint16 pointers 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 } // Uint16ValueMap converts a string map of uint16 pointers into a string // map of uint16 values 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 } // Uint32 returns a pointer to the uint32 value passed in. func Uint32(v uint32) uint32 { return &v } // Uint32Value returns the value of the uint32 pointer passed in or // 0 if the pointer is nil. func Uint32Value(v uint32) uint32 { if v != nil { return v } return 0 } // Uint32Slice converts a slice of uint32 values into a slice of // uint32 pointers func Uint32Slice(src []uint32) []uint32 { dst := make([]uint32, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Uint32ValueSlice converts a slice of uint32 pointers into a slice of // uint32 values 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 } // Uint32Map converts a string map of uint32 values into a string // map of uint32 pointers 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 } // Uint32ValueMap converts a string map of uint32 pointers into a string // map of uint32 values 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 } // Uint64 returns a pointer to the uint64 value passed in. func Uint64(v uint64) uint64 { return &v } // Uint64Value returns the value of the uint64 pointer passed in or // 0 if the pointer is nil. func Uint64Value(v uint64) uint64 { if v != nil { return v } return 0 } // Uint64Slice converts a slice of uint64 values into a slice of // uint64 pointers func Uint64Slice(src []uint64) []uint64 { dst := make([]uint64, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Uint64ValueSlice converts a slice of uint64 pointers into a slice of // uint64 values 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 } // Uint64Map converts a string map of uint64 values into a string // map of uint64 pointers 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 } // Uint64ValueMap converts a string map of uint64 pointers into a string // map of uint64 values 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 } // Float32 returns a pointer to the float32 value passed in. func Float32(v float32) float32 { return &v } // Float32Value returns the value of the float32 pointer passed in or // 0 if the pointer is nil. func Float32Value(v float32) float32 { if v != nil { return v } return 0 } // Float32Slice converts a slice of float32 values into a slice of // float32 pointers func Float32Slice(src []float32) []float32 { dst := make([]float32, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Float32ValueSlice converts a slice of float32 pointers into a slice of // float32 values 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 } // Float32Map converts a string map of float32 values into a string // map of float32 pointers 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 } // Float32ValueMap converts a string map of float32 pointers into a string // map of float32 values 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 } // Float64 returns a pointer to the float64 value passed in. func Float64(v float64) float64 { return &v } // Float64Value returns the value of the float64 pointer passed in or // 0 if the pointer is nil. func Float64Value(v float64) float64 { if v != nil { return v } return 0 } // Float64Slice converts a slice of float64 values into a slice of // float64 pointers func Float64Slice(src []float64) []float64 { dst := make([]float64, len(src)) for i := 0; i < len(src); i++ { dst[i] = &(src[i]) } return dst } // Float64ValueSlice converts a slice of float64 pointers into a slice of // float64 values 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 } // Float64Map converts a string map of float64 values into a string // map of float64 pointers 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 } // Float64ValueMap converts a string map of float64 pointers into a string // map of float64 values 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 } // Time returns a pointer to the time.Time value passed in. func Time(v time.Time) time.Time { return &v } // TimeValue returns the value of the time.Time pointer passed in or // time.Time{} if the pointer is nil. func TimeValue(v time.Time) time.Time { if v != nil { return v } return time.Time{} } // SecondsTimeValue converts an int64 pointer to a time.Time value // representing seconds since Epoch or time.Time{} if the pointer is nil. func SecondsTimeValue(v int64) time.Time { if v != nil { return time.Unix((v / 1000), 0) } return time.Time{} } // MillisecondsTimeValue converts an int64 pointer to a time.Time value // representing milliseconds sinch Epoch or time.Time{} if the pointer is nil. func MillisecondsTimeValue(v int64) time.Time { if v != nil { return time.Unix(0, (v 1000000)) } return time.Time{} } // 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 https://golang.org/pkg/time/#Time.UnixNano for more information. func TimeUnixMilli(t time.Time) int64 { return t.UnixNano() / int64(time.Millisecond/time.Nanosecond) } // TimeSlice converts a slice of time.Time values into a slice of // time.Time pointers 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 } // TimeValueSlice converts a slice of time.Time pointers into a slice of // time.Time values 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 } // TimeMap converts a string map of time.Time values into a string // map of time.Time pointers 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 } // TimeValueMap converts a string map of time.Time pointers into a string // map of time.Time values 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 }	20.01 KB	2025-05-25 12:27
📄 convert_types_test.go package aws import ( "reflect" "testing" "time" ) var testCasesStringSlice = [][]string{ {"a", "b", "c", "d", "e"}, {"a", "b", "", "", "e"}, } func TestStringSlice(t testing.T) { for idx, in := range testCasesStringSlice { if in == nil { continue } out := StringSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := StringValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesStringValueSlice = [][]string{ {String("a"), String("b"), nil, String("c")}, } func TestStringValueSlice(t testing.T) { for idx, in := range testCasesStringValueSlice { if in == nil { continue } out := StringValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != "" { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := StringSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != "" { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesStringMap = []map[string]string{ {"a": "1", "b": "2", "c": "3"}, } func TestStringMap(t testing.T) { for idx, in := range testCasesStringMap { if in == nil { continue } out := StringMap(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := StringValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesBoolSlice = [][]bool{ {true, true, false, false}, } func TestBoolSlice(t testing.T) { for idx, in := range testCasesBoolSlice { if in == nil { continue } out := BoolSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := BoolValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesBoolValueSlice = [][]bool{} func TestBoolValueSlice(t testing.T) { for idx, in := range testCasesBoolValueSlice { if in == nil { continue } out := BoolValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := BoolSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesBoolMap = []map[string]bool{ {"a": true, "b": false, "c": true}, } func TestBoolMap(t testing.T) { for idx, in := range testCasesBoolMap { if in == nil { continue } out := BoolMap(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := BoolValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUintSlice = [][]uint{ {1, 2, 3, 4}, } func TestUintSlice(t testing.T) { for idx, in := range testCasesUintSlice { if in == nil { continue } out := UintSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := UintValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUintValueSlice = [][]uint{} func TestUintValueSlice(t testing.T) { for idx, in := range testCasesUintValueSlice { if in == nil { continue } out := UintValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := UintSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesUintMap = []map[string]uint{ {"a": 3, "b": 2, "c": 1}, } func TestUintMap(t testing.T) { for idx, in := range testCasesUintMap { if in == nil { continue } out := UintMap(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := UintValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesIntSlice = [][]int{ {1, 2, 3, 4}, } func TestIntSlice(t testing.T) { for idx, in := range testCasesIntSlice { if in == nil { continue } out := IntSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := IntValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesIntValueSlice = [][]int{} func TestIntValueSlice(t testing.T) { for idx, in := range testCasesIntValueSlice { if in == nil { continue } out := IntValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := IntSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesIntMap = []map[string]int{ {"a": 3, "b": 2, "c": 1}, } func TestIntMap(t testing.T) { for idx, in := range testCasesIntMap { if in == nil { continue } out := IntMap(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := IntValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt8Slice = [][]int8{ {1, 2, 3, 4}, } func TestInt8Slice(t testing.T) { for idx, in := range testCasesInt8Slice { if in == nil { continue } out := Int8Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int8ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt8ValueSlice = [][]int8{} func TestInt8ValueSlice(t testing.T) { for idx, in := range testCasesInt8ValueSlice { if in == nil { continue } out := Int8ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Int8Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesInt8Map = []map[string]int8{ {"a": 3, "b": 2, "c": 1}, } func TestInt8Map(t testing.T) { for idx, in := range testCasesInt8Map { if in == nil { continue } out := Int8Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int8ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt16Slice = [][]int16{ {1, 2, 3, 4}, } func TestInt16Slice(t testing.T) { for idx, in := range testCasesInt16Slice { if in == nil { continue } out := Int16Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int16ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt16ValueSlice = [][]int16{} func TestInt16ValueSlice(t testing.T) { for idx, in := range testCasesInt16ValueSlice { if in == nil { continue } out := Int16ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Int16Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesInt16Map = []map[string]int16{ {"a": 3, "b": 2, "c": 1}, } func TestInt16Map(t testing.T) { for idx, in := range testCasesInt16Map { if in == nil { continue } out := Int16Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int16ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt32Slice = [][]int32{ {1, 2, 3, 4}, } func TestInt32Slice(t testing.T) { for idx, in := range testCasesInt32Slice { if in == nil { continue } out := Int32Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int32ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt32ValueSlice = [][]int32{} func TestInt32ValueSlice(t testing.T) { for idx, in := range testCasesInt32ValueSlice { if in == nil { continue } out := Int32ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Int32Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesInt32Map = []map[string]int32{ {"a": 3, "b": 2, "c": 1}, } func TestInt32Map(t testing.T) { for idx, in := range testCasesInt32Map { if in == nil { continue } out := Int32Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int32ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt64Slice = [][]int64{ {1, 2, 3, 4}, } func TestInt64Slice(t testing.T) { for idx, in := range testCasesInt64Slice { if in == nil { continue } out := Int64Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int64ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesInt64ValueSlice = [][]int64{} func TestInt64ValueSlice(t testing.T) { for idx, in := range testCasesInt64ValueSlice { if in == nil { continue } out := Int64ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Int64Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesInt64Map = []map[string]int64{ {"a": 3, "b": 2, "c": 1}, } func TestInt64Map(t testing.T) { for idx, in := range testCasesInt64Map { if in == nil { continue } out := Int64Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Int64ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint8Slice = [][]uint8{ {1, 2, 3, 4}, } func TestUint8Slice(t testing.T) { for idx, in := range testCasesUint8Slice { if in == nil { continue } out := Uint8Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint8ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint8ValueSlice = [][]uint8{} func TestUint8ValueSlice(t testing.T) { for idx, in := range testCasesUint8ValueSlice { if in == nil { continue } out := Uint8ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Uint8Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesUint8Map = []map[string]uint8{ {"a": 3, "b": 2, "c": 1}, } func TestUint8Map(t testing.T) { for idx, in := range testCasesUint8Map { if in == nil { continue } out := Uint8Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint8ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint16Slice = [][]uint16{ {1, 2, 3, 4}, } func TestUint16Slice(t testing.T) { for idx, in := range testCasesUint16Slice { if in == nil { continue } out := Uint16Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint16ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint16ValueSlice = [][]uint16{} func TestUint16ValueSlice(t testing.T) { for idx, in := range testCasesUint16ValueSlice { if in == nil { continue } out := Uint16ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Uint16Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesUint16Map = []map[string]uint16{ {"a": 3, "b": 2, "c": 1}, } func TestUint16Map(t testing.T) { for idx, in := range testCasesUint16Map { if in == nil { continue } out := Uint16Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint16ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint32Slice = [][]uint32{ {1, 2, 3, 4}, } func TestUint32Slice(t testing.T) { for idx, in := range testCasesUint32Slice { if in == nil { continue } out := Uint32Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint32ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint32ValueSlice = [][]uint32{} func TestUint32ValueSlice(t testing.T) { for idx, in := range testCasesUint32ValueSlice { if in == nil { continue } out := Uint32ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Uint32Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesUint32Map = []map[string]uint32{ {"a": 3, "b": 2, "c": 1}, } func TestUint32Map(t testing.T) { for idx, in := range testCasesUint32Map { if in == nil { continue } out := Uint32Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint32ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint64Slice = [][]uint64{ {1, 2, 3, 4}, } func TestUint64Slice(t testing.T) { for idx, in := range testCasesUint64Slice { if in == nil { continue } out := Uint64Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint64ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesUint64ValueSlice = [][]uint64{} func TestUint64ValueSlice(t testing.T) { for idx, in := range testCasesUint64ValueSlice { if in == nil { continue } out := Uint64ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Uint64Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesUint64Map = []map[string]uint64{ {"a": 3, "b": 2, "c": 1}, } func TestUint64Map(t testing.T) { for idx, in := range testCasesUint64Map { if in == nil { continue } out := Uint64Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Uint64ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesFloat32Slice = [][]float32{ {1, 2, 3, 4}, } func TestFloat32Slice(t testing.T) { for idx, in := range testCasesFloat32Slice { if in == nil { continue } out := Float32Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Float32ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesFloat32ValueSlice = [][]float32{} func TestFloat32ValueSlice(t testing.T) { for idx, in := range testCasesFloat32ValueSlice { if in == nil { continue } out := Float32ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Float32Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesFloat32Map = []map[string]float32{ {"a": 3, "b": 2, "c": 1}, } func TestFloat32Map(t testing.T) { for idx, in := range testCasesFloat32Map { if in == nil { continue } out := Float32Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Float32ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesFloat64Slice = [][]float64{ {1, 2, 3, 4}, } func TestFloat64Slice(t testing.T) { for idx, in := range testCasesFloat64Slice { if in == nil { continue } out := Float64Slice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Float64ValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesFloat64ValueSlice = [][]float64{} func TestFloat64ValueSlice(t testing.T) { for idx, in := range testCasesFloat64ValueSlice { if in == nil { continue } out := Float64ValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if out[i] != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := Float64Slice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if (out2[i]) != 0 { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesFloat64Map = []map[string]float64{ {"a": 3, "b": 2, "c": 1}, } func TestFloat64Map(t testing.T) { for idx, in := range testCasesFloat64Map { if in == nil { continue } out := Float64Map(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := Float64ValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesTimeSlice = [][]time.Time{ {time.Now(), time.Now().AddDate(100, 0, 0)}, } func TestTimeSlice(t testing.T) { for idx, in := range testCasesTimeSlice { if in == nil { continue } out := TimeSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := TimeValueSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } var testCasesTimeValueSlice = [][]time.Time{} func TestTimeValueSlice(t testing.T) { for idx, in := range testCasesTimeValueSlice { if in == nil { continue } out := TimeValueSlice(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if in[i] == nil { if !out[i].IsZero() { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := (in[i]), out[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } out2 := TimeSlice(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out2 { if in[i] == nil { if !(out2[i]).IsZero() { t.Errorf("Unexpected value at idx %d", idx) } } else { if e, a := in[i], out2[i]; e != a { t.Errorf("Unexpected value at idx %d", idx) } } } } } var testCasesTimeMap = []map[string]time.Time{ {"a": time.Now().AddDate(-100, 0, 0), "b": time.Now()}, } func TestTimeMap(t testing.T) { for idx, in := range testCasesTimeMap { if in == nil { continue } out := TimeMap(in) if e, a := len(out), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } for i := range out { if e, a := in[i], (out[i]); e != a { t.Errorf("Unexpected value at idx %d", idx) } } out2 := TimeValueMap(out) if e, a := len(out2), len(in); e != a { t.Errorf("Unexpected len at idx %d", idx) } if e, a := in, out2; !reflect.DeepEqual(e, a) { t.Errorf("Unexpected value at idx %d", idx) } } } type TimeValueTestCase struct { in int64 outSecs time.Time outMillis time.Time } var testCasesTimeValue = []TimeValueTestCase{ { in: int64(1501558289000), outSecs: time.Unix(1501558289, 0), outMillis: time.Unix(1501558289, 0), }, { in: int64(1501558289001), outSecs: time.Unix(1501558289, 0), outMillis: time.Unix(1501558289, 11000000), }, } func TestSecondsTimeValue(t testing.T) { for idx, testCase := range testCasesTimeValue { out := SecondsTimeValue(&testCase.in) if e, a := testCase.outSecs, out; e != a { t.Errorf("Unexpected value for time value at %d", idx) } } } func TestMillisecondsTimeValue(t testing.T) { for idx, testCase := range testCasesTimeValue { out := MillisecondsTimeValue(&testCase.in) if e, a := testCase.outMillis, out; e != a { t.Errorf("Unexpected value for time value at %d", idx) } } }	32.89 KB	2025-05-25 12:27
📁 corehandlers	-	2025-05-25 12:27
📁 credentials	-	2025-05-25 12:27
📁 crr	-	2025-05-25 12:27
📁 csm	-	2025-05-25 12:27
📁 defaults	-	2025-05-25 12:27
📄 doc.go // Package aws provides the core SDK's utilities and shared types. Use this package's // utilities to simplify setting and reading API operations parameters. // // Value and Pointer Conversion Utilities // // This package includes a helper conversion utility for each scalar type the SDK's // API use. These utilities make getting a pointer of the scalar, and dereferencing // a pointer easier. // // Each conversion utility comes in two forms. Value to Pointer and Pointer to Value. // The Pointer to value will safely dereference the pointer and return its value. // If the pointer was nil, the scalar's zero value will be returned. // // The value to pointer functions will be named after the scalar type. So get a // string from a string value use the "String" function. This makes it easy to // to get pointer of a literal string value, because getting the address of a // literal requires assigning the value to a variable first. // // var strPtr string // // // Without the SDK's conversion functions // str := "my string" // strPtr = &str // // // With the SDK's conversion functions // strPtr = aws.String("my string") // // // Convert string to string value // str = aws.StringValue(strPtr) // // In addition to scalars the aws package also includes conversion utilities for // map and slice for commonly types used in API parameters. The map and slice // conversion functions use similar naming pattern as the scalar conversion // functions. // // var strPtrs []string // var strs []string = []string{"Go", "Gophers", "Go"} // // // Convert []string to []string // strPtrs = aws.StringSlice(strs) // // // Convert []string to []string // strs = aws.StringValueSlice(strPtrs) // // SDK Default HTTP Client // // The SDK will use the http.DefaultClient if a HTTP client is not provided to // the SDK's Session, or service client constructor. This means that if the // http.DefaultClient is modified by other components of your application the // modifications will be picked up by the SDK as well. // // In some cases this might be intended, but it is a better practice to create // a custom HTTP Client to share explicitly through your application. You can // configure the SDK to use the custom HTTP Client by setting the HTTPClient // value of the SDK's Config type when creating a Session or service client. package aws	2.33 KB	2025-05-25 12:27
📁 ec2metadata	-	2025-05-25 12:27
📁 endpoints	-	2025-05-25 12:27
📄 errors.go package aws import "github.com/aws/aws-sdk-go/aws/awserr" var ( // ErrMissingRegion is an error that is returned if region configuration is // not found. ErrMissingRegion = awserr.New("MissingRegion", "could not find region configuration", nil) // ErrMissingEndpoint is an error that is returned if an endpoint cannot be // resolved for a service. ErrMissingEndpoint = awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", nil) )	472 B	2025-05-25 12:27
📄 jsonvalue.go package aws // JSONValue is a representation of a grab bag type that will be marshaled // into a json string. This type can be used just like any other map. // // Example: // // values := aws.JSONValue{ // "Foo": "Bar", // } // values["Baz"] = "Qux" type JSONValue map[string]interface{}	290 B	2025-05-25 12:27
📄 logger.go package aws import ( "log" "os" ) // A LogLevelType defines the level logging should be performed at. Used to instruct // the SDK which statements should be logged. type LogLevelType uint // LogLevel returns the pointer to a LogLevel. Should be used to workaround // not being able to take the address of a non-composite literal. func LogLevel(l LogLevelType) LogLevelType { return &l } // Value returns the LogLevel value or the default value LogOff if the LogLevel // is nil. Safe to use on nil value LogLevelTypes. func (l LogLevelType) Value() LogLevelType { if l != nil { return l } return LogOff } // Matches returns true if the v LogLevel is enabled by this LogLevel. Should be // used with logging sub levels. Is safe to use on nil value LogLevelTypes. If // LogLevel is nil, will default to LogOff comparison. func (l LogLevelType) Matches(v LogLevelType) bool { c := l.Value() return c&v == v } // AtLeast returns true if this LogLevel is at least high enough to satisfies v. // Is safe to use on nil value LogLevelTypes. If LogLevel is nil, will default // to LogOff comparison. func (l LogLevelType) AtLeast(v LogLevelType) bool { c := l.Value() return c >= v } const ( // 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. LogOff LogLevelType = iota 0x1000 // LogDebug state that debug output should be logged by the SDK. This should // be used to inspect request made and responses received. LogDebug ) // Debug Logging Sub Levels const ( // 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. LogDebugWithSigning LogLevelType = LogDebug \| (1 << iota) // LogDebugWithHTTPBody states the SDK should log HTTP request and response // HTTP bodys in addition to the headers and path. This should be used to // see the body content of requests and responses made while using the SDK // Will also enable LogDebug. LogDebugWithHTTPBody // LogDebugWithRequestRetries states the SDK should log when service requests will // be retried. This should be used to log when you want to log when service // requests are being retried. Will also enable LogDebug. LogDebugWithRequestRetries // LogDebugWithRequestErrors states the SDK should log when service requests fail // to build, send, validate, or unmarshal. LogDebugWithRequestErrors // LogDebugWithEventStreamBody states the SDK should log EventStream // request and response bodys. This should be used to log the EventStream // wire unmarshaled message content of requests and responses made while // using the SDK Will also enable LogDebug. LogDebugWithEventStreamBody // LogDebugWithDeprecated states the SDK should log details about deprecated functionality. LogDebugWithDeprecated ) // A Logger is a minimalistic interface for the SDK to log messages to. Should // be used to provide custom logging writers for the SDK to use. type Logger interface { Log(...interface{}) } // A LoggerFunc is a convenience type to convert a function taking a variadic // list of arguments and wrap it so the Logger interface can be used. // // Example: // s3.New(sess, &aws.Config{Logger: aws.LoggerFunc(func(args ...interface{}) { // fmt.Fprintln(os.Stdout, args...) // })}) type LoggerFunc func(...interface{}) // Log calls the wrapped function with the arguments provided func (f LoggerFunc) Log(args ...interface{}) { f(args...) } // NewDefaultLogger returns a Logger which will write log messages to stdout, and // use same formatting runes as the stdlib log.Logger func NewDefaultLogger() Logger { return &defaultLogger{ logger: log.New(os.Stdout, "", log.LstdFlags), } } // A defaultLogger provides a minimalistic logger satisfying the Logger interface. type defaultLogger struct { logger *log.Logger } // Log logs the parameters to the stdlib logger. See log.Println. func (l defaultLogger) Log(args ...interface{}) { l.logger.Println(args...) }	4.03 KB	2025-05-25 12:27
📁 request	-	2025-05-25 12:27
📁 session	-	2025-05-25 12:27
📁 signer	-	2025-05-25 12:27
📄 types.go package aws import ( "io" "strings" "sync" "github.com/aws/aws-sdk-go/internal/sdkio" ) // 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. func ReadSeekCloser(r io.Reader) ReaderSeekerCloser { return ReaderSeekerCloser{r} } // ReaderSeekerCloser represents a reader that can also delegate io.Seeker and // io.Closer interfaces to the underlying object if they are available. type ReaderSeekerCloser struct { r io.Reader } // IsReaderSeekable returns if the underlying reader type can be seeked. A // io.Reader might not actually be seekable if it is the ReaderSeekerCloser // type. 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 } } // Read reads from the reader up to size of p. The number of bytes read, and // error if it occurred will be returned. // // If the reader is not an io.Reader zero bytes read, and nil error will be // returned. // // Performs the same functionality as io.Reader Read func (r ReaderSeekerCloser) Read(p []byte) (int, error) { switch t := r.r.(type) { case io.Reader: return t.Read(p) } return 0, nil } // Seek sets the offset for the next Read to offset, interpreted according to // whence: 0 means relative to the origin of the file, 1 means relative to the // current offset, and 2 means relative to the end. Seek returns the new offset // and an error, if any. // // If the ReaderSeekerCloser is not an io.Seeker nothing will be done. func (r ReaderSeekerCloser) Seek(offset int64, whence int) (int64, error) { switch t := r.r.(type) { case io.Seeker: return t.Seek(offset, whence) } return int64(0), nil } // IsSeeker returns if the underlying reader is also a seeker. func (r ReaderSeekerCloser) IsSeeker() bool { _, ok := r.r.(io.Seeker) return ok } // HasLen returns the length of the underlying reader if the value implements // the Len() int method. func (r ReaderSeekerCloser) HasLen() (int, bool) { type lenner interface { Len() int } if lr, ok := r.r.(lenner); ok { return lr.Len(), true } return 0, false } // GetLen returns the length of the bytes remaining in the underlying reader. // Checks first for Len(), then io.Seeker to determine the size of the // underlying reader. // // Will return -1 if the length cannot be determined. func (r ReaderSeekerCloser) GetLen() (int64, error) { if l, ok := r.HasLen(); ok { return int64(l), nil } if s, ok := r.r.(io.Seeker); ok { return seekerLen(s) } return -1, nil } // SeekerLen attempts to get the number of bytes remaining at the seeker's // current position. Returns the number of bytes remaining or error. 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 seekerLen(s io.Seeker) (int64, error) { curOffset, err := s.Seek(0, sdkio.SeekCurrent) if err != nil { return 0, err } endOffset, err := s.Seek(0, sdkio.SeekEnd) if err != nil { return 0, err } _, err = s.Seek(curOffset, sdkio.SeekStart) if err != nil { return 0, err } return endOffset - curOffset, nil } // Close closes the ReaderSeekerCloser. // // If the ReaderSeekerCloser is not an io.Closer nothing will be done. func (r ReaderSeekerCloser) Close() error { switch t := r.r.(type) { case io.Closer: return t.Close() } return nil } // A WriteAtBuffer provides a in memory buffer supporting the io.WriterAt interface // Can be used with the s3manager.Downloader to download content to a buffer // in memory. Safe to use concurrently. type WriteAtBuffer struct { buf []byte m sync.Mutex // GrowthCoeff defines the growth rate of the internal buffer. By // default, the growth rate is 1, where expanding the internal // buffer will allocate only enough capacity to fit the new expected // length. GrowthCoeff float64 } // NewWriteAtBuffer creates a WriteAtBuffer with an internal buffer // provided by buf. func NewWriteAtBuffer(buf []byte) WriteAtBuffer { return &WriteAtBuffer{buf: buf} } // WriteAt writes a slice of bytes to a buffer starting at the position provided // The number of bytes written will be returned, or error. Can overwrite previous // written slices if the write ats overlap. func (b WriteAtBuffer) WriteAt(p []byte, pos int64) (n int, err error) { pLen := len(p) expLen := pos + int64(pLen) b.m.Lock() defer b.m.Unlock() if int64(len(b.buf)) < expLen { if int64(cap(b.buf)) < expLen { if b.GrowthCoeff < 1 { b.GrowthCoeff = 1 } newBuf := make([]byte, expLen, int64(b.GrowthCoefffloat64(expLen))) copy(newBuf, b.buf) b.buf = newBuf } b.buf = b.buf[:expLen] } copy(b.buf[pos:], p) return pLen, nil } // Bytes returns a slice of bytes written to the buffer. func (b WriteAtBuffer) Bytes() []byte { b.m.Lock() defer b.m.Unlock() return b.buf } // MultiCloser is a utility to close multiple io.Closers within a single // statement. type MultiCloser []io.Closer // Close closes all of the io.Closers making up the MultiClosers. Any // errors that occur while closing will be returned in the order they // occur. func (m MultiCloser) Close() error { var errs errors for _, c := range m { err := c.Close() if err != nil { errs = append(errs, err) } } if len(errs) != 0 { return errs } return nil } type errors []error func (es errors) Error() string { var parts []string for _, e := range es { parts = append(parts, e.Error()) } return strings.Join(parts, "\n") } // CopySeekableBody copies the seekable body to an io.Writer 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 }	6.71 KB	2025-05-25 12:27
📄 types_test.go package aws import ( "bytes" "math/rand" "testing" ) func TestWriteAtBuffer(t testing.T) { b := &WriteAtBuffer{} n, err := b.WriteAt([]byte{1}, 0) if err != nil { t.Errorf("expected no error, but received %v", err) } if e, a := 1, n; e != a { t.Errorf("expected %d, but received %d", e, a) } n, err = b.WriteAt([]byte{1, 1, 1}, 5) if err != nil { t.Errorf("expected no error, but received %v", err) } if e, a := 3, n; e != a { t.Errorf("expected %d, but received %d", e, a) } n, err = b.WriteAt([]byte{2}, 1) if err != nil { t.Errorf("expected no error, but received %v", err) } if e, a := 1, n; e != a { t.Errorf("expected %d, but received %d", e, a) } n, err = b.WriteAt([]byte{3}, 2) if err != nil { t.Errorf("expected no error, but received %v", err) } if e, a := 1, n; e != a { t.Errorf("expected %d, but received %d", e, a) } if !bytes.Equal([]byte{1, 2, 3, 0, 0, 1, 1, 1}, b.Bytes()) { t.Errorf("expected %v, but received %v", []byte{1, 2, 3, 0, 0, 1, 1, 1}, b.Bytes()) } } func BenchmarkWriteAtBuffer(b testing.B) { buf := &WriteAtBuffer{} r := rand.New(rand.NewSource(1)) b.ResetTimer() for i := 0; i < b.N; i++ { to := r.Intn(10) * 4096 bs := make([]byte, to) buf.WriteAt(bs, r.Int63n(10)4096) } } func BenchmarkWriteAtBufferOrderedWrites(b testing.B) { // test the performance of a WriteAtBuffer when written in an // ordered fashion. This is similar to the behavior of the // s3.Downloader, since downloads the first chunk of the file, then // the second, and so on. // // This test simulates a 150MB file being written in 30 ordered 5MB chunks. chunk := int64(5e6) max := chunk * 30 // we'll write the same 5MB chunk every time tmp := make([]byte, chunk) for i := 0; i < b.N; i++ { buf := &WriteAtBuffer{} for i := int64(0); i < max; i += chunk { buf.WriteAt(tmp, i) } } } func BenchmarkWriteAtBufferParallel(b testing.B) { buf := &WriteAtBuffer{} r := rand.New(rand.NewSource(1)) b.ResetTimer() b.RunParallel(func(pb testing.PB) { for pb.Next() { to := r.Intn(10) * 4096 bs := make([]byte, to) buf.WriteAt(bs, r.Int63n(10)*4096) } }) }	2.11 KB	2025-05-25 12:27
📄 url.go //go:build go1.8 // +build go1.8 package aws import "net/url" // URLHostname will extract the Hostname without port from the URL value. // // Wrapper of net/url#URL.Hostname for backwards Go version compatibility. func URLHostname(url *url.URL) string { return url.Hostname() }	282 B	2025-05-25 12:27
📄 url_1_7.go //go:build !go1.8 // +build !go1.8 package aws import ( "net/url" "strings" ) // URLHostname will extract the Hostname without port from the URL value. // // Copy of Go 1.8's net/url#URL.Hostname functionality. func URLHostname(url *url.URL) string { return stripPort(url.Host) } // stripPort is copy of Go 1.8 url#URL.Hostname functionality. // https://golang.org/src/net/url/url.go func stripPort(hostport string) string { colon := strings.IndexByte(hostport, ':') if colon == -1 { return hostport } if i := strings.IndexByte(hostport, ']'); i != -1 { return strings.TrimPrefix(hostport[:i], "[") } return hostport[:colon] }	645 B	2025-05-25 12:27
📄 version.go // Package aws provides core functionality for making requests to AWS services. package aws // SDKName is the name of this AWS SDK const SDKName = "aws-sdk-go" // SDKVersion is the version of this SDK const SDKVersion = "1.55.5"	231 B	2025-05-25 12:27

Edit File:

Terminal